summaryrefslogtreecommitdiffstats
path: root/widget/gonk/nsScreenManagerGonk.h
diff options
context:
space:
mode:
Diffstat (limited to 'widget/gonk/nsScreenManagerGonk.h')
-rw-r--r--widget/gonk/nsScreenManagerGonk.h228
1 files changed, 228 insertions, 0 deletions
diff --git a/widget/gonk/nsScreenManagerGonk.h b/widget/gonk/nsScreenManagerGonk.h
new file mode 100644
index 000000000..33ef5edb8
--- /dev/null
+++ b/widget/gonk/nsScreenManagerGonk.h
@@ -0,0 +1,228 @@
+/* -*- Mode: C++; tab-width: 40; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* Copyright 2012 Mozilla Foundation and Mozilla contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef nsScreenManagerGonk_h___
+#define nsScreenManagerGonk_h___
+
+#include "cutils/properties.h"
+#include "hardware/hwcomposer.h"
+
+#include "libdisplay/GonkDisplay.h"
+#include "mozilla/Atomics.h"
+#include "mozilla/Hal.h"
+#include "mozilla/Mutex.h"
+#include "nsBaseScreen.h"
+#include "nsCOMPtr.h"
+#include "nsIScreenManager.h"
+#include "nsProxyRelease.h"
+
+#include <android/native_window.h>
+
+class nsWindow;
+
+namespace android {
+ class DisplaySurface;
+ class IGraphicBufferProducer;
+};
+
+namespace mozilla {
+ class Runnable;
+namespace gl {
+ class GLContext;
+}
+namespace layers {
+class CompositorVsyncScheduler;
+class CompositorBridgeParent;
+}
+}
+
+enum class NotifyDisplayChangedEvent : int8_t {
+ Observable,
+ Suppressed
+};
+
+class nsScreenGonk : public nsBaseScreen
+{
+ typedef mozilla::hal::ScreenConfiguration ScreenConfiguration;
+ typedef mozilla::GonkDisplay GonkDisplay;
+ typedef mozilla::LayoutDeviceIntRect LayoutDeviceIntRect;
+ typedef mozilla::layers::CompositorBridgeParent CompositorBridgeParent;
+ typedef mozilla::gfx::DrawTarget DrawTarget;
+
+public:
+ nsScreenGonk(uint32_t aId,
+ GonkDisplay::DisplayType aDisplayType,
+ const GonkDisplay::NativeData& aNativeData,
+ NotifyDisplayChangedEvent aEventVisibility);
+
+ ~nsScreenGonk();
+
+ NS_IMETHOD GetId(uint32_t* aId);
+ NS_IMETHOD GetRect(int32_t* aLeft, int32_t* aTop, int32_t* aWidth, int32_t* aHeight);
+ NS_IMETHOD GetAvailRect(int32_t* aLeft, int32_t* aTop, int32_t* aWidth, int32_t* aHeight);
+ NS_IMETHOD GetPixelDepth(int32_t* aPixelDepth);
+ NS_IMETHOD GetColorDepth(int32_t* aColorDepth);
+ NS_IMETHOD GetRotation(uint32_t* aRotation);
+ NS_IMETHOD SetRotation(uint32_t aRotation);
+
+ uint32_t GetId();
+ NotifyDisplayChangedEvent GetEventVisibility();
+ LayoutDeviceIntRect GetRect();
+ float GetDpi();
+ int32_t GetSurfaceFormat();
+ ANativeWindow* GetNativeWindow();
+ LayoutDeviceIntRect GetNaturalBounds();
+ uint32_t EffectiveScreenRotation();
+ ScreenConfiguration GetConfiguration();
+ bool IsPrimaryScreen();
+
+ already_AddRefed<DrawTarget> StartRemoteDrawing();
+ void EndRemoteDrawing();
+
+ nsresult MakeSnapshot(ANativeWindowBuffer* aBuffer);
+ void SetCompositorBridgeParent(CompositorBridgeParent* aCompositorBridgeParent);
+
+#if ANDROID_VERSION >= 17
+ android::DisplaySurface* GetDisplaySurface();
+ int GetPrevDispAcquireFd();
+#endif
+ GonkDisplay::DisplayType GetDisplayType();
+
+ void RegisterWindow(nsWindow* aWindow);
+ void UnregisterWindow(nsWindow* aWindow);
+ void BringToTop(nsWindow* aWindow);
+
+ const nsTArray<nsWindow*>& GetTopWindows() const
+ {
+ return mTopWindows;
+ }
+
+ // Non-primary screen only
+ bool EnableMirroring();
+ bool DisableMirroring();
+ bool IsMirroring()
+ {
+ return mIsMirroring;
+ }
+
+ // Primary screen only
+ bool SetMirroringScreen(nsScreenGonk* aScreen);
+ bool ClearMirroringScreen(nsScreenGonk* aScreen);
+
+ // Called only on compositor thread
+ void SetEGLInfo(hwc_display_t aDisplay, hwc_surface_t aSurface,
+ mozilla::gl::GLContext* aGLContext);
+ hwc_display_t GetEGLDisplay();
+ hwc_surface_t GetEGLSurface();
+ already_AddRefed<mozilla::gl::GLContext> GetGLContext();
+ void UpdateMirroringWidget(already_AddRefed<nsWindow>& aWindow); // Primary screen only
+ nsWindow* GetMirroringWidget(); // Primary screen only
+
+protected:
+ ANativeWindowBuffer* DequeueBuffer();
+ bool QueueBuffer(ANativeWindowBuffer* buf);
+
+ uint32_t mId;
+ NotifyDisplayChangedEvent mEventVisibility;
+ int32_t mColorDepth;
+ android::sp<ANativeWindow> mNativeWindow;
+ float mDpi;
+ int32_t mSurfaceFormat;
+ LayoutDeviceIntRect mNaturalBounds; // Screen bounds w/o rotation taken into account.
+ LayoutDeviceIntRect mVirtualBounds; // Screen bounds w/ rotation taken into account.
+ uint32_t mScreenRotation;
+ uint32_t mPhysicalScreenRotation;
+ nsTArray<nsWindow*> mTopWindows;
+#if ANDROID_VERSION >= 17
+ android::sp<android::DisplaySurface> mDisplaySurface;
+#endif
+ bool mIsMirroring; // Non-primary screen only
+ RefPtr<nsScreenGonk> mMirroringScreen; // Primary screen only
+ mozilla::Atomic<CompositorBridgeParent*> mCompositorBridgeParent;
+
+ // Accessed and updated only on compositor thread
+ GonkDisplay::DisplayType mDisplayType;
+ hwc_display_t mEGLDisplay;
+ hwc_surface_t mEGLSurface;
+ RefPtr<mozilla::gl::GLContext> mGLContext;
+ RefPtr<nsWindow> mMirroringWidget; // Primary screen only
+
+ // If we're using a BasicCompositor, these fields are temporarily
+ // set during frame composition. They wrap the hardware
+ // framebuffer.
+ RefPtr<DrawTarget> mFramebufferTarget;
+ ANativeWindowBuffer* mFramebuffer;
+ /**
+ * Points to a mapped gralloc buffer between calls to lock and unlock.
+ * Should be null outside of the lock-unlock pair.
+ */
+ uint8_t* mMappedBuffer;
+ // If we're using a BasicCompositor, this is our window back
+ // buffer. The gralloc framebuffer driver expects us to draw the
+ // entire framebuffer on every frame, but gecko expects the
+ // windowing system to be tracking buffer updates for invalidated
+ // regions. We get stuck holding that bag.
+ //
+ // Only accessed on the compositor thread, except during
+ // destruction.
+ RefPtr<DrawTarget> mBackBuffer;
+};
+
+class nsScreenManagerGonk final : public nsIScreenManager
+{
+public:
+ typedef mozilla::GonkDisplay GonkDisplay;
+
+public:
+ nsScreenManagerGonk();
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISCREENMANAGER
+
+ static already_AddRefed<nsScreenManagerGonk> GetInstance();
+ static already_AddRefed<nsScreenGonk> GetPrimaryScreen();
+
+ void Initialize();
+ void DisplayEnabled(bool aEnabled);
+
+ nsresult AddScreen(GonkDisplay::DisplayType aDisplayType,
+ android::IGraphicBufferProducer* aSink = nullptr,
+ NotifyDisplayChangedEvent aEventVisibility = NotifyDisplayChangedEvent::Observable);
+
+ nsresult RemoveScreen(GonkDisplay::DisplayType aDisplayType);
+
+#if ANDROID_VERSION >= 19
+ void SetCompositorVsyncScheduler(mozilla::layers::CompositorVsyncScheduler* aObserver);
+#endif
+
+protected:
+ ~nsScreenManagerGonk();
+ void VsyncControl(bool aEnabled);
+ uint32_t GetIdFromType(GonkDisplay::DisplayType aDisplayType);
+ bool IsScreenConnected(uint32_t aId);
+
+ bool mInitialized;
+ nsTArray<RefPtr<nsScreenGonk>> mScreens;
+ RefPtr<mozilla::Runnable> mScreenOnEvent;
+ RefPtr<mozilla::Runnable> mScreenOffEvent;
+
+#if ANDROID_VERSION >= 19
+ bool mDisplayEnabled;
+ RefPtr<mozilla::layers::CompositorVsyncScheduler> mCompositorVsyncScheduler;
+#endif
+};
+
+#endif /* nsScreenManagerGonk_h___ */