diff options
Diffstat (limited to 'widget/gonk/nsScreenManagerGonk.cpp')
| -rw-r--r-- | widget/gonk/nsScreenManagerGonk.cpp | 1081 |
1 files changed, 1081 insertions, 0 deletions
diff --git a/widget/gonk/nsScreenManagerGonk.cpp b/widget/gonk/nsScreenManagerGonk.cpp new file mode 100644 index 000000000..e359fd195 --- /dev/null +++ b/widget/gonk/nsScreenManagerGonk.cpp @@ -0,0 +1,1081 @@ +/* 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. + */ + +#include "android/log.h" +#include "GLContext.h" +#include "gfxPrefs.h" +#include "gfxUtils.h" +#include "mozilla/MouseEvents.h" +#include "mozilla/TouchEvents.h" +#include "mozilla/Hal.h" +#include "libdisplay/BootAnimation.h" +#include "libdisplay/GonkDisplay.h" +#include "nsScreenManagerGonk.h" +#include "nsThreadUtils.h" +#include "HwcComposer2D.h" +#include "VsyncSource.h" +#include "nsWindow.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/layers/CompositorBridgeParent.h" +#include "mozilla/layers/CompositorThread.h" +#include "mozilla/Services.h" +#include "mozilla/ProcessPriorityManager.h" +#include "nsIdleService.h" +#include "nsIObserverService.h" +#include "nsAppShell.h" +#include "nsProxyRelease.h" +#include "nsTArray.h" +#include "pixelflinger/format.h" +#include "nsIDisplayInfo.h" +#include "base/task.h" + +#if ANDROID_VERSION >= 17 +#include "libdisplay/DisplaySurface.h" +#endif + +#define LOG(args...) __android_log_print(ANDROID_LOG_INFO, "nsScreenGonk" , ## args) +#define LOGW(args...) __android_log_print(ANDROID_LOG_WARN, "nsScreenGonk", ## args) +#define LOGE(args...) __android_log_print(ANDROID_LOG_ERROR, "nsScreenGonk", ## args) + +using namespace mozilla; +using namespace mozilla::hal; +using namespace mozilla::gfx; +using namespace mozilla::gl; +using namespace mozilla::layers; +using namespace mozilla::dom; + +namespace { + +class ScreenOnOffEvent : public mozilla::Runnable { +public: + ScreenOnOffEvent(bool on) + : mIsOn(on) + {} + + NS_IMETHOD Run() override { + // Notify observers that the screen state has just changed. + nsCOMPtr<nsIObserverService> observerService = mozilla::services::GetObserverService(); + if (observerService) { + observerService->NotifyObservers( + nullptr, "screen-state-changed", + mIsOn ? u"on" : u"off" + ); + } + + RefPtr<nsScreenGonk> screen = nsScreenManagerGonk::GetPrimaryScreen(); + const nsTArray<nsWindow*>& windows = screen->GetTopWindows(); + + for (uint32_t i = 0; i < windows.Length(); i++) { + nsWindow *win = windows[i]; + + if (nsIWidgetListener* listener = win->GetWidgetListener()) { + listener->SizeModeChanged(mIsOn ? nsSizeMode_Fullscreen : nsSizeMode_Minimized); + } + } + + return NS_OK; + } + +private: + bool mIsOn; +}; + +static void +displayEnabledCallback(bool enabled) +{ + RefPtr<nsScreenManagerGonk> screenManager = nsScreenManagerGonk::GetInstance(); + screenManager->DisplayEnabled(enabled); +} + +} // namespace + +static uint32_t +SurfaceFormatToColorDepth(int32_t aSurfaceFormat) +{ + switch (aSurfaceFormat) { + case GGL_PIXEL_FORMAT_RGB_565: + return 16; + case GGL_PIXEL_FORMAT_RGBA_8888: + return 32; + } + return 24; // GGL_PIXEL_FORMAT_RGBX_8888 +} + +// nsScreenGonk.cpp + +nsScreenGonk::nsScreenGonk(uint32_t aId, + GonkDisplay::DisplayType aDisplayType, + const GonkDisplay::NativeData& aNativeData, + NotifyDisplayChangedEvent aEventVisibility) + : mId(aId) + , mEventVisibility(aEventVisibility) + , mNativeWindow(aNativeData.mNativeWindow) + , mDpi(aNativeData.mXdpi) + , mScreenRotation(nsIScreen::ROTATION_0_DEG) + , mPhysicalScreenRotation(nsIScreen::ROTATION_0_DEG) +#if ANDROID_VERSION >= 17 + , mDisplaySurface(aNativeData.mDisplaySurface) +#endif + , mIsMirroring(false) + , mDisplayType(aDisplayType) + , mEGLDisplay(EGL_NO_DISPLAY) + , mEGLSurface(EGL_NO_SURFACE) + , mGLContext(nullptr) + , mFramebuffer(nullptr) + , mMappedBuffer(nullptr) +{ + if (mNativeWindow->query(mNativeWindow.get(), NATIVE_WINDOW_WIDTH, &mVirtualBounds.width) || + mNativeWindow->query(mNativeWindow.get(), NATIVE_WINDOW_HEIGHT, &mVirtualBounds.height) || + mNativeWindow->query(mNativeWindow.get(), NATIVE_WINDOW_FORMAT, &mSurfaceFormat)) { + NS_RUNTIMEABORT("Failed to get native window size, aborting..."); + } + + mNaturalBounds = mVirtualBounds; + + if (IsPrimaryScreen()) { + char propValue[PROPERTY_VALUE_MAX]; + property_get("ro.sf.hwrotation", propValue, "0"); + mPhysicalScreenRotation = atoi(propValue) / 90; + } + + mColorDepth = SurfaceFormatToColorDepth(mSurfaceFormat); +} + +static void +ReleaseGLContextSync(mozilla::gl::GLContext* aGLContext) +{ + MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread()); + aGLContext->Release(); +} + +nsScreenGonk::~nsScreenGonk() +{ + // Release GLContext on compositor thread + if (mGLContext) { + CompositorThreadHolder::Loop()->PostTask( + NewRunnableFunction(&ReleaseGLContextSync, + mGLContext.forget().take())); + mGLContext = nullptr; + } +} + +bool +nsScreenGonk::IsPrimaryScreen() +{ + return mDisplayType == GonkDisplay::DISPLAY_PRIMARY; +} + +NS_IMETHODIMP +nsScreenGonk::GetId(uint32_t *outId) +{ + *outId = mId; + return NS_OK; +} + +uint32_t +nsScreenGonk::GetId() +{ + return mId; +} + +NotifyDisplayChangedEvent +nsScreenGonk::GetEventVisibility() +{ + return mEventVisibility; +} + +NS_IMETHODIMP +nsScreenGonk::GetRect(int32_t *outLeft, int32_t *outTop, + int32_t *outWidth, int32_t *outHeight) +{ + *outLeft = mVirtualBounds.x; + *outTop = mVirtualBounds.y; + + *outWidth = mVirtualBounds.width; + *outHeight = mVirtualBounds.height; + + return NS_OK; +} + +LayoutDeviceIntRect +nsScreenGonk::GetRect() +{ + return mVirtualBounds; +} + +NS_IMETHODIMP +nsScreenGonk::GetAvailRect(int32_t *outLeft, int32_t *outTop, + int32_t *outWidth, int32_t *outHeight) +{ + return GetRect(outLeft, outTop, outWidth, outHeight); +} + +NS_IMETHODIMP +nsScreenGonk::GetPixelDepth(int32_t *aPixelDepth) +{ + // XXX: this should actually return 32 when we're using 24-bit + // color, because we use RGBX. + *aPixelDepth = mColorDepth; + return NS_OK; +} + +NS_IMETHODIMP +nsScreenGonk::GetColorDepth(int32_t *aColorDepth) +{ + *aColorDepth = mColorDepth; + return NS_OK; +} + +NS_IMETHODIMP +nsScreenGonk::GetRotation(uint32_t* aRotation) +{ + *aRotation = mScreenRotation; + return NS_OK; +} + +float +nsScreenGonk::GetDpi() +{ + return mDpi; +} + +int32_t +nsScreenGonk::GetSurfaceFormat() +{ + return mSurfaceFormat; +} + +ANativeWindow* +nsScreenGonk::GetNativeWindow() +{ + return mNativeWindow.get(); +} + +NS_IMETHODIMP +nsScreenGonk::SetRotation(uint32_t aRotation) +{ + if (!(aRotation <= ROTATION_270_DEG)) { + return NS_ERROR_ILLEGAL_VALUE; + } + + if (mScreenRotation == aRotation) { + return NS_OK; + } + + mScreenRotation = aRotation; + uint32_t rotation = EffectiveScreenRotation(); + if (rotation == nsIScreen::ROTATION_90_DEG || + rotation == nsIScreen::ROTATION_270_DEG) { + mVirtualBounds = LayoutDeviceIntRect(0, 0, + mNaturalBounds.height, + mNaturalBounds.width); + } else { + mVirtualBounds = mNaturalBounds; + } + + nsAppShell::NotifyScreenRotation(); + + for (unsigned int i = 0; i < mTopWindows.Length(); i++) { + mTopWindows[i]->Resize(mVirtualBounds.width, + mVirtualBounds.height, + true); + } + + return NS_OK; +} + +LayoutDeviceIntRect +nsScreenGonk::GetNaturalBounds() +{ + return mNaturalBounds; +} + +uint32_t +nsScreenGonk::EffectiveScreenRotation() +{ + return (mScreenRotation + mPhysicalScreenRotation) % (360 / 90); +} + +// NB: This isn't gonk-specific, but gonk is the only widget backend +// that does this calculation itself, currently. +static ScreenOrientationInternal +ComputeOrientation(uint32_t aRotation, const LayoutDeviceIntSize& aScreenSize) +{ + bool naturallyPortrait = (aScreenSize.height > aScreenSize.width); + switch (aRotation) { + case nsIScreen::ROTATION_0_DEG: + return (naturallyPortrait ? eScreenOrientation_PortraitPrimary : + eScreenOrientation_LandscapePrimary); + case nsIScreen::ROTATION_90_DEG: + // Arbitrarily choosing 90deg to be primary "unnatural" + // rotation. + return (naturallyPortrait ? eScreenOrientation_LandscapePrimary : + eScreenOrientation_PortraitPrimary); + case nsIScreen::ROTATION_180_DEG: + return (naturallyPortrait ? eScreenOrientation_PortraitSecondary : + eScreenOrientation_LandscapeSecondary); + case nsIScreen::ROTATION_270_DEG: + return (naturallyPortrait ? eScreenOrientation_LandscapeSecondary : + eScreenOrientation_PortraitSecondary); + default: + MOZ_CRASH("Gonk screen must always have a known rotation"); + } +} + +static uint16_t +RotationToAngle(uint32_t aRotation) +{ + uint16_t angle = 90 * aRotation; + MOZ_ASSERT(angle == 0 || angle == 90 || angle == 180 || angle == 270); + return angle; +} + +ScreenConfiguration +nsScreenGonk::GetConfiguration() +{ + ScreenOrientationInternal orientation = + ComputeOrientation(mScreenRotation, mNaturalBounds.Size()); + + // NB: perpetuating colorDepth == pixelDepth illusion here, for + // consistency. + return ScreenConfiguration(mVirtualBounds.ToUnknownRect(), orientation, + RotationToAngle(mScreenRotation), + mColorDepth, mColorDepth); +} + +void +nsScreenGonk::RegisterWindow(nsWindow* aWindow) +{ + mTopWindows.AppendElement(aWindow); +} + +void +nsScreenGonk::UnregisterWindow(nsWindow* aWindow) +{ + mTopWindows.RemoveElement(aWindow); +} + +void +nsScreenGonk::BringToTop(nsWindow* aWindow) +{ + mTopWindows.RemoveElement(aWindow); + mTopWindows.InsertElementAt(0, aWindow); +} + +static gralloc_module_t const* +gralloc_module() +{ + hw_module_t const *module; + if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module)) { + return nullptr; + } + return reinterpret_cast<gralloc_module_t const*>(module); +} + +static SurfaceFormat +HalFormatToSurfaceFormat(int aHalFormat) +{ + switch (aHalFormat) { + case HAL_PIXEL_FORMAT_RGBA_8888: + // Needs RB swap + return SurfaceFormat::B8G8R8A8; + case HAL_PIXEL_FORMAT_RGBX_8888: + // Needs RB swap + return SurfaceFormat::B8G8R8X8; + case HAL_PIXEL_FORMAT_BGRA_8888: + return SurfaceFormat::B8G8R8A8; + case HAL_PIXEL_FORMAT_RGB_565: + return SurfaceFormat::R5G6B5_UINT16; + default: + MOZ_CRASH("Unhandled HAL pixel format"); + return SurfaceFormat::UNKNOWN; // not reached + } +} + +static bool +NeedsRBSwap(int aHalFormat) +{ + switch (aHalFormat) { + case HAL_PIXEL_FORMAT_RGBA_8888: + return true; + case HAL_PIXEL_FORMAT_RGBX_8888: + return true; + case HAL_PIXEL_FORMAT_BGRA_8888: + return false; + case HAL_PIXEL_FORMAT_RGB_565: + return false; + default: + MOZ_CRASH("Unhandled HAL pixel format"); + return false; // not reached + } +} + +already_AddRefed<DrawTarget> +nsScreenGonk::StartRemoteDrawing() +{ + MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread()); + MOZ_ASSERT(!mFramebuffer); + MOZ_ASSERT(!mMappedBuffer); + + mFramebuffer = DequeueBuffer(); + int width = mFramebuffer->width, height = mFramebuffer->height; + if (gralloc_module()->lock(gralloc_module(), mFramebuffer->handle, + GRALLOC_USAGE_SW_READ_NEVER | + GRALLOC_USAGE_SW_WRITE_OFTEN | + GRALLOC_USAGE_HW_FB, + 0, 0, width, height, + reinterpret_cast<void**>(&mMappedBuffer))) { + EndRemoteDrawing(); + return nullptr; + } + SurfaceFormat format = HalFormatToSurfaceFormat(GetSurfaceFormat()); + mFramebufferTarget = Factory::CreateDrawTargetForData( + BackendType::CAIRO, + mMappedBuffer, + IntSize(width, height), + mFramebuffer->stride * gfx::BytesPerPixel(format), + format); + if (!mFramebufferTarget) { + MOZ_CRASH("nsWindow::StartRemoteDrawing failed in CreateDrawTargetForData"); + } + if (!mBackBuffer || + mBackBuffer->GetSize() != mFramebufferTarget->GetSize() || + mBackBuffer->GetFormat() != mFramebufferTarget->GetFormat()) { + mBackBuffer = mFramebufferTarget->CreateSimilarDrawTarget( + mFramebufferTarget->GetSize(), mFramebufferTarget->GetFormat()); + } + RefPtr<DrawTarget> buffer(mBackBuffer); + return buffer.forget(); +} + +void +nsScreenGonk::EndRemoteDrawing() +{ + MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread()); + + if (mFramebufferTarget && mFramebuffer) { + IntSize size = mFramebufferTarget->GetSize(); + Rect rect(0, 0, size.width, size.height); + RefPtr<SourceSurface> source = mBackBuffer->Snapshot(); + mFramebufferTarget->DrawSurface(source, rect, rect); + + // Convert from BGR to RGB + // XXX this is a temporary solution. It consumes extra cpu cycles, + // it should not be used on product device. + if (NeedsRBSwap(GetSurfaceFormat())) { + LOGE("Very slow composition path, it should not be used on product!!!"); + SurfaceFormat format = HalFormatToSurfaceFormat(GetSurfaceFormat()); + gfxUtils::ConvertBGRAtoRGBA( + mMappedBuffer, + mFramebuffer->stride * mFramebuffer->height * gfx::BytesPerPixel(format)); + } + } + if (mMappedBuffer) { + MOZ_ASSERT(mFramebuffer); + gralloc_module()->unlock(gralloc_module(), mFramebuffer->handle); + mMappedBuffer = nullptr; + } + if (mFramebuffer) { + QueueBuffer(mFramebuffer); + } + mFramebuffer = nullptr; + mFramebufferTarget = nullptr; +} + +ANativeWindowBuffer* +nsScreenGonk::DequeueBuffer() +{ + ANativeWindowBuffer* buf = nullptr; +#if ANDROID_VERSION >= 17 + int fenceFd = -1; + mNativeWindow->dequeueBuffer(mNativeWindow.get(), &buf, &fenceFd); + android::sp<android::Fence> fence(new android::Fence(fenceFd)); +#if ANDROID_VERSION == 17 + fence->waitForever(1000, "nsScreenGonk_DequeueBuffer"); + // 1000 is what Android uses. It is a warning timeout in ms. + // This timeout was removed in ANDROID_VERSION 18. +#else + fence->waitForever("nsScreenGonk_DequeueBuffer"); +#endif +#else + mNativeWindow->dequeueBuffer(mNativeWindow.get(), &buf); +#endif + return buf; +} + +bool +nsScreenGonk::QueueBuffer(ANativeWindowBuffer* buf) +{ +#if ANDROID_VERSION >= 17 + int ret = mNativeWindow->queueBuffer(mNativeWindow.get(), buf, -1); + return ret == 0; +#else + int ret = mNativeWindow->queueBuffer(mNativeWindow.get(), buf); + return ret == 0; +#endif +} + +nsresult +nsScreenGonk::MakeSnapshot(ANativeWindowBuffer* aBuffer) +{ + MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread()); + MOZ_ASSERT(aBuffer); + + layers::CompositorBridgeParent* compositorParent = mCompositorBridgeParent; + if (!compositorParent) { + return NS_ERROR_FAILURE; + } + + int width = aBuffer->width, height = aBuffer->height; + uint8_t* mappedBuffer = nullptr; + if (gralloc_module()->lock(gralloc_module(), aBuffer->handle, + GRALLOC_USAGE_SW_READ_OFTEN | + GRALLOC_USAGE_SW_WRITE_OFTEN, + 0, 0, width, height, + reinterpret_cast<void**>(&mappedBuffer))) { + return NS_ERROR_FAILURE; + } + + SurfaceFormat format = HalFormatToSurfaceFormat(GetSurfaceFormat()); + RefPtr<DrawTarget> mTarget = + Factory::CreateDrawTargetForData( + BackendType::CAIRO, + mappedBuffer, + IntSize(width, height), + aBuffer->stride * gfx::BytesPerPixel(format), + format); + if (!mTarget) { + return NS_ERROR_FAILURE; + } + + gfx::IntRect rect = GetRect().ToUnknownRect(); + compositorParent->ForceComposeToTarget(mTarget, &rect); + + // Convert from BGR to RGB + // XXX this is a temporary solution. It consumes extra cpu cycles, + if (NeedsRBSwap(GetSurfaceFormat())) { + LOGE("Slow path of making Snapshot!!!"); + SurfaceFormat format = HalFormatToSurfaceFormat(GetSurfaceFormat()); + gfxUtils::ConvertBGRAtoRGBA( + mappedBuffer, + aBuffer->stride * aBuffer->height * gfx::BytesPerPixel(format)); + mappedBuffer = nullptr; + } + gralloc_module()->unlock(gralloc_module(), aBuffer->handle); + return NS_OK; +} + +void +nsScreenGonk::SetCompositorBridgeParent(layers::CompositorBridgeParent* aCompositorBridgeParent) +{ + MOZ_ASSERT(NS_IsMainThread()); + mCompositorBridgeParent = aCompositorBridgeParent; +} + +#if ANDROID_VERSION >= 17 +android::DisplaySurface* +nsScreenGonk::GetDisplaySurface() +{ + return mDisplaySurface.get(); +} + +int +nsScreenGonk::GetPrevDispAcquireFd() +{ + if (!mDisplaySurface.get()) { + return -1; + } + return mDisplaySurface->GetPrevDispAcquireFd(); +} +#endif + +GonkDisplay::DisplayType +nsScreenGonk::GetDisplayType() +{ + return mDisplayType; +} + +void +nsScreenGonk::SetEGLInfo(hwc_display_t aDisplay, + hwc_surface_t aSurface, + gl::GLContext* aGLContext) +{ + MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread()); + mEGLDisplay = aDisplay; + mEGLSurface = aSurface; + mGLContext = aGLContext; +} + +hwc_display_t +nsScreenGonk::GetEGLDisplay() +{ + MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread()); + return mEGLDisplay; +} + +hwc_surface_t +nsScreenGonk::GetEGLSurface() +{ + MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread()); + return mEGLSurface; +} + +already_AddRefed<mozilla::gl::GLContext> +nsScreenGonk::GetGLContext() +{ + MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread()); + RefPtr<mozilla::gl::GLContext>glContext = mGLContext; + return glContext.forget(); +} + +static void +UpdateMirroringWidgetSync(nsMainThreadPtrHandle<nsScreenGonk>&& aScreen, nsWindow* aWindow) +{ + MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread()); + already_AddRefed<nsWindow> window(aWindow); + aScreen->UpdateMirroringWidget(window); +} + +bool +nsScreenGonk::EnableMirroring() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsPrimaryScreen()); + + RefPtr<nsScreenGonk> primaryScreen = nsScreenManagerGonk::GetPrimaryScreen(); + NS_ENSURE_TRUE(primaryScreen, false); + + bool ret = primaryScreen->SetMirroringScreen(this); + NS_ENSURE_TRUE(ret, false); + + // Create a widget for mirroring + nsWidgetInitData initData; + initData.mScreenId = mId; + RefPtr<nsWindow> window = new nsWindow(); + nsresult rv = window->Create(nullptr, nullptr, mNaturalBounds, &initData); + NS_ENSURE_SUCCESS(rv, false); + MOZ_ASSERT(static_cast<nsWindow*>(window)->GetScreen() == this); + + // Update mMirroringWidget on compositor thread + nsMainThreadPtrHandle<nsScreenGonk> primary = + nsMainThreadPtrHandle<nsScreenGonk>(new nsMainThreadPtrHolder<nsScreenGonk>(primaryScreen, false)); + CompositorThreadHolder::Loop()->PostTask( + NewRunnableFunction(&UpdateMirroringWidgetSync, + primary, + window.forget().take())); + + mIsMirroring = true; + return true; +} + +bool +nsScreenGonk::DisableMirroring() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsPrimaryScreen()); + + mIsMirroring = false; + RefPtr<nsScreenGonk> primaryScreen = nsScreenManagerGonk::GetPrimaryScreen(); + NS_ENSURE_TRUE(primaryScreen, false); + + bool ret = primaryScreen->ClearMirroringScreen(this); + NS_ENSURE_TRUE(ret, false); + + // Update mMirroringWidget on compositor thread + nsMainThreadPtrHandle<nsScreenGonk> primary = + nsMainThreadPtrHandle<nsScreenGonk>(new nsMainThreadPtrHolder<nsScreenGonk>(primaryScreen, false)); + CompositorThreadHolder::Loop()->PostTask( + NewRunnableFunction(&UpdateMirroringWidgetSync, + primary, + nullptr)); + return true; +} + +bool +nsScreenGonk::SetMirroringScreen(nsScreenGonk* aScreen) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(IsPrimaryScreen()); + + if (mMirroringScreen) { + return false; + } + mMirroringScreen = aScreen; + return true; +} + +bool +nsScreenGonk::ClearMirroringScreen(nsScreenGonk* aScreen) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(IsPrimaryScreen()); + + if (mMirroringScreen != aScreen) { + return false; + } + mMirroringScreen = nullptr; + return true; +} + +void +nsScreenGonk::UpdateMirroringWidget(already_AddRefed<nsWindow>& aWindow) +{ + MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread()); + MOZ_ASSERT(IsPrimaryScreen()); + + if (mMirroringWidget) { + nsCOMPtr<nsIWidget> widget = mMirroringWidget.forget(); + NS_ReleaseOnMainThread(widget.forget()); + } + mMirroringWidget = aWindow; +} + +nsWindow* +nsScreenGonk::GetMirroringWidget() +{ + MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread()); + MOZ_ASSERT(IsPrimaryScreen()); + + return mMirroringWidget; +} + +NS_IMPL_ISUPPORTS(nsScreenManagerGonk, nsIScreenManager) + +nsScreenManagerGonk::nsScreenManagerGonk() + : mInitialized(false) +#if ANDROID_VERSION >= 19 + , mDisplayEnabled(false) +#endif +{ +} + +nsScreenManagerGonk::~nsScreenManagerGonk() +{ +} + +static StaticRefPtr<nsScreenManagerGonk> sScreenManagerGonk; + +/* static */ already_AddRefed<nsScreenManagerGonk> +nsScreenManagerGonk::GetInstance() +{ + MOZ_ASSERT(NS_IsMainThread()); + + // Avoid creating nsScreenManagerGonk from content process. + if (!XRE_IsParentProcess()) { + MOZ_CRASH("Non-chrome processes should not get here."); + } + + // Avoid creating multiple nsScreenManagerGonk instance inside main process. + if (!sScreenManagerGonk) { + sScreenManagerGonk = new nsScreenManagerGonk(); + ClearOnShutdown(&sScreenManagerGonk); + } + + RefPtr<nsScreenManagerGonk> screenMgr = sScreenManagerGonk.get(); + return screenMgr.forget(); +} + +/* static */ already_AddRefed< nsScreenGonk> +nsScreenManagerGonk::GetPrimaryScreen() +{ + MOZ_ASSERT(NS_IsMainThread()); + + RefPtr<nsScreenManagerGonk> manager = nsScreenManagerGonk::GetInstance(); + nsCOMPtr<nsIScreen> screen; + manager->GetPrimaryScreen(getter_AddRefs(screen)); + MOZ_ASSERT(screen); + return already_AddRefed<nsScreenGonk>( + static_cast<nsScreenGonk*>(screen.forget().take())); +} + +void +nsScreenManagerGonk::Initialize() +{ + if (mInitialized) { + return; + } + + mScreenOnEvent = new ScreenOnOffEvent(true); + mScreenOffEvent = new ScreenOnOffEvent(false); + GetGonkDisplay()->OnEnabled(displayEnabledCallback); + + AddScreen(GonkDisplay::DISPLAY_PRIMARY); + + nsAppShell::NotifyScreenInitialized(); + mInitialized = true; +} + +void +nsScreenManagerGonk::DisplayEnabled(bool aEnabled) +{ + MOZ_ASSERT(NS_IsMainThread()); + +#if ANDROID_VERSION >= 19 + /* Bug 1244044 + * This function could be called before |mCompositorVsyncScheduler| is set. + * To avoid this issue, keep the value stored in |mDisplayEnabled|. + */ + mDisplayEnabled = aEnabled; + if (mCompositorVsyncScheduler) { + mCompositorVsyncScheduler->SetDisplay(mDisplayEnabled); + } +#endif + + VsyncControl(aEnabled); + NS_DispatchToMainThread(aEnabled ? mScreenOnEvent : mScreenOffEvent); +} + +NS_IMETHODIMP +nsScreenManagerGonk::GetPrimaryScreen(nsIScreen **outScreen) +{ + NS_IF_ADDREF(*outScreen = mScreens[0].get()); + return NS_OK; +} + +NS_IMETHODIMP +nsScreenManagerGonk::ScreenForId(uint32_t aId, + nsIScreen **outScreen) +{ + for (size_t i = 0; i < mScreens.Length(); i++) { + if (mScreens[i]->GetId() == aId) { + NS_IF_ADDREF(*outScreen = mScreens[i].get()); + return NS_OK; + } + } + + *outScreen = nullptr; + return NS_OK; +} + +NS_IMETHODIMP +nsScreenManagerGonk::ScreenForRect(int32_t inLeft, + int32_t inTop, + int32_t inWidth, + int32_t inHeight, + nsIScreen **outScreen) +{ + // Since all screens have independent coordinate system, we could + // only return the primary screen no matter what rect is given. + return GetPrimaryScreen(outScreen); +} + +NS_IMETHODIMP +nsScreenManagerGonk::ScreenForNativeWidget(void *aWidget, nsIScreen **outScreen) +{ + for (size_t i = 0; i < mScreens.Length(); i++) { + if (aWidget == mScreens[i]->GetNativeWindow()) { + NS_IF_ADDREF(*outScreen = mScreens[i].get()); + return NS_OK; + } + } + + *outScreen = nullptr; + return NS_OK; +} + +NS_IMETHODIMP +nsScreenManagerGonk::GetNumberOfScreens(uint32_t *aNumberOfScreens) +{ + *aNumberOfScreens = mScreens.Length(); + return NS_OK; +} + +NS_IMETHODIMP +nsScreenManagerGonk::GetSystemDefaultScale(float *aDefaultScale) +{ + *aDefaultScale = 1.0f; + return NS_OK; +} + +void +nsScreenManagerGonk::VsyncControl(bool aEnabled) +{ + if (!NS_IsMainThread()) { + NS_DispatchToMainThread( + NewRunnableMethod<bool>(this, + &nsScreenManagerGonk::VsyncControl, + aEnabled)); + return; + } + + MOZ_ASSERT(NS_IsMainThread()); + VsyncSource::Display &display = gfxPlatform::GetPlatform()->GetHardwareVsync()->GetGlobalDisplay(); + if (aEnabled) { + display.EnableVsync(); + } else { + display.DisableVsync(); + } +} + +uint32_t +nsScreenManagerGonk::GetIdFromType(GonkDisplay::DisplayType aDisplayType) +{ + // This is the only place where we make the assumption that + // display type is equivalent to screen id. + + // Bug 1138287 will address the conversion from type to id. + return aDisplayType; +} + +bool +nsScreenManagerGonk::IsScreenConnected(uint32_t aId) +{ + for (size_t i = 0; i < mScreens.Length(); ++i) { + if (mScreens[i]->GetId() == aId) { + return true; + } + } + + return false; +} + +namespace { + +// A concrete class as a subject for 'display-changed' observer event. +class DisplayInfo : public nsIDisplayInfo { +public: + NS_DECL_ISUPPORTS + + DisplayInfo(uint32_t aId, bool aConnected) + : mId(aId) + , mConnected(aConnected) + { + } + + NS_IMETHODIMP GetId(int32_t *aId) + { + *aId = mId; + return NS_OK; + } + + NS_IMETHODIMP GetConnected(bool *aConnected) + { + *aConnected = mConnected; + return NS_OK; + } + +private: + virtual ~DisplayInfo() {} + + uint32_t mId; + bool mConnected; +}; + +NS_IMPL_ISUPPORTS(DisplayInfo, nsIDisplayInfo, nsISupports) + +class NotifyTask : public mozilla::Runnable { +public: + NotifyTask(uint32_t aId, bool aConnected) + : mDisplayInfo(new DisplayInfo(aId, aConnected)) + { + } + + NS_IMETHOD Run() override + { + nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService(); + if (os) { + os->NotifyObservers(mDisplayInfo, "display-changed", nullptr); + } + + return NS_OK; + } +private: + RefPtr<DisplayInfo> mDisplayInfo; +}; + +void +NotifyDisplayChange(uint32_t aId, bool aConnected) +{ + NS_DispatchToMainThread(new NotifyTask(aId, aConnected)); +} + +} // end of unnamed namespace. + +nsresult +nsScreenManagerGonk::AddScreen(GonkDisplay::DisplayType aDisplayType, + android::IGraphicBufferProducer* aSink, + NotifyDisplayChangedEvent aEventVisibility) +{ + MOZ_ASSERT(NS_IsMainThread()); + + NS_ENSURE_TRUE(aDisplayType < GonkDisplay::DisplayType::NUM_DISPLAY_TYPES, + NS_ERROR_FAILURE); + + uint32_t id = GetIdFromType(aDisplayType); + NS_ENSURE_TRUE(!IsScreenConnected(id), NS_ERROR_FAILURE); + + GonkDisplay::NativeData nativeData = + GetGonkDisplay()->GetNativeData(aDisplayType, aSink); + nsScreenGonk* screen = new nsScreenGonk(id, + aDisplayType, + nativeData, + aEventVisibility); + mScreens.AppendElement(screen); + + if (aEventVisibility == NotifyDisplayChangedEvent::Observable) { + NotifyDisplayChange(id, true); + } + + // By default, non primary screen does mirroring. + if (aDisplayType != GonkDisplay::DISPLAY_PRIMARY && + gfxPrefs::ScreenMirroringEnabled()) { + screen->EnableMirroring(); + } + + return NS_OK; +} + +nsresult +nsScreenManagerGonk::RemoveScreen(GonkDisplay::DisplayType aDisplayType) +{ + MOZ_ASSERT(NS_IsMainThread()); + + NS_ENSURE_TRUE(aDisplayType < GonkDisplay::DisplayType::NUM_DISPLAY_TYPES, + NS_ERROR_FAILURE); + + NotifyDisplayChangedEvent eventVisibility = NotifyDisplayChangedEvent::Observable; + uint32_t screenId = GetIdFromType(aDisplayType); + NS_ENSURE_TRUE(IsScreenConnected(screenId), NS_ERROR_FAILURE); + + for (size_t i = 0; i < mScreens.Length(); i++) { + if (mScreens[i]->GetId() == screenId) { + if (mScreens[i]->IsMirroring()) { + mScreens[i]->DisableMirroring(); + } + eventVisibility = mScreens[i]->GetEventVisibility(); + mScreens.RemoveElementAt(i); + break; + } + } + + if (eventVisibility == NotifyDisplayChangedEvent::Observable) { + NotifyDisplayChange(screenId, false); + } + return NS_OK; +} + +#if ANDROID_VERSION >= 19 +void +nsScreenManagerGonk::SetCompositorVsyncScheduler(mozilla::layers::CompositorVsyncScheduler *aObserver) +{ + MOZ_ASSERT(NS_IsMainThread()); + + // We assume on b2g that there is only 1 CompositorBridgeParent + MOZ_ASSERT(mCompositorVsyncScheduler == nullptr); + MOZ_ASSERT(aObserver); + mCompositorVsyncScheduler = aObserver; + mCompositorVsyncScheduler->SetDisplay(mDisplayEnabled); +} +#endif |