widget/gonk/nsScreenManagerGonk.cpp

   1 /* Copyright 2012 Mozilla Foundation and Mozilla contributors
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include "android/log.h"
  17 #include "GLContext.h"
  18 #include "gfxPrefs.h"
  19 #include "gfxUtils.h"
  20 #include "mozilla/MouseEvents.h"
  21 #include "mozilla/TouchEvents.h"
  22 #include "mozilla/Hal.h"
  23 #include "libdisplay/BootAnimation.h"
  24 #include "libdisplay/GonkDisplay.h"
  25 #include "nsScreenManagerGonk.h"
  26 #include "nsThreadUtils.h"
  27 #include "HwcComposer2D.h"
  28 #include "VsyncSource.h"
  29 #include "nsWindow.h"
  30 #include "mozilla/ClearOnShutdown.h"
  31 #include "mozilla/layers/CompositorBridgeParent.h"
  32 #include "mozilla/layers/CompositorThread.h"
  33 #include "mozilla/Services.h"
  34 #include "mozilla/ProcessPriorityManager.h"
  35 #include "nsIdleService.h"
  36 #include "nsIObserverService.h"
  37 #include "nsAppShell.h"
  38 #include "nsProxyRelease.h"
  39 #include "nsTArray.h"
  40 #include "pixelflinger/format.h"
  41 #include "nsIDisplayInfo.h"
  42
  43 #if ANDROID_VERSION >= 17
  44 #include "libdisplay/DisplaySurface.h"
  45 #endif
  46
  47 #define LOG(args...)  __android_log_print(ANDROID_LOG_INFO, "nsScreenGonk" , ## args)
  48 #define LOGW(args...) __android_log_print(ANDROID_LOG_WARN, "nsScreenGonk", ## args)
  49 #define LOGE(args...) __android_log_print(ANDROID_LOG_ERROR, "nsScreenGonk", ## args)
  50
  51 using namespace mozilla;
  52 using namespace mozilla::hal;
  53 using namespace mozilla::gfx;
  54 using namespace mozilla::gl;
  55 using namespace mozilla::layers;
  56 using namespace mozilla::dom;
  57
  58 namespace {
  59
  60 class ScreenOnOffEvent : public mozilla::Runnable {
  61 public:
  62     ScreenOnOffEvent(bool on)
  63         : mIsOn(on)
  64     {}
  65
  66     NS_IMETHOD Run() {
  67         // Notify observers that the screen state has just changed.
  68         nsCOMPtr<nsIObserverService> observerService = mozilla::services::GetObserverService();
  69         if (observerService) {
  70           observerService->NotifyObservers(
  71             nullptr, "screen-state-changed",
  72             mIsOn ? MOZ_UTF16("on") : MOZ_UTF16("off")
  73           );
  74         }
  75
  76         RefPtr<nsScreenGonk> screen = nsScreenManagerGonk::GetPrimaryScreen();
  77         const nsTArray<nsWindow*>& windows = screen->GetTopWindows();
  78
  79         for (uint32_t i = 0; i < windows.Length(); i++) {
  80             nsWindow *win = windows[i];
  81
  82             if (nsIWidgetListener* listener = win->GetWidgetListener()) {
  83                 listener->SizeModeChanged(mIsOn ? nsSizeMode_Fullscreen : nsSizeMode_Minimized);
  84             }
  85         }
  86
  87         return NS_OK;
  88     }
  89
  90 private:
  91     bool mIsOn;
  92 };
  93
  94 static void
  95 displayEnabledCallback(bool enabled)
  96 {
  97     RefPtr<nsScreenManagerGonk> screenManager = nsScreenManagerGonk::GetInstance();
  98     screenManager->DisplayEnabled(enabled);
  99 }
 100
 101 } // namespace
 102
 103 static uint32_t
 104 SurfaceFormatToColorDepth(int32_t aSurfaceFormat)
 105 {
 106     switch (aSurfaceFormat) {
 107     case GGL_PIXEL_FORMAT_RGB_565:
 108         return 16;
 109     case GGL_PIXEL_FORMAT_RGBA_8888:
 110         return 32;
 111     }
 112     return 24; // GGL_PIXEL_FORMAT_RGBX_8888
 113 }
 114
 115 // nsScreenGonk.cpp
 116
 117 nsScreenGonk::nsScreenGonk(uint32_t aId,
 118                            GonkDisplay::DisplayType aDisplayType,
 119                            const GonkDisplay::NativeData& aNativeData,
 120                            NotifyDisplayChangedEvent aEventVisibility)
 121     : mId(aId)
 122     , mEventVisibility(aEventVisibility)
 123     , mNativeWindow(aNativeData.mNativeWindow)
 124     , mDpi(aNativeData.mXdpi)
 125     , mScreenRotation(nsIScreen::ROTATION_0_DEG)
 126     , mPhysicalScreenRotation(nsIScreen::ROTATION_0_DEG)
 127 #if ANDROID_VERSION >= 17
 128     , mDisplaySurface(aNativeData.mDisplaySurface)
 129 #endif
 130     , mIsMirroring(false)
 131     , mDisplayType(aDisplayType)
 132     , mEGLDisplay(EGL_NO_DISPLAY)
 133     , mEGLSurface(EGL_NO_SURFACE)
 134     , mGLContext(nullptr)
 135     , mFramebuffer(nullptr)
 136     , mMappedBuffer(nullptr)
 137 {
 138     if (mNativeWindow->query(mNativeWindow.get(), NATIVE_WINDOW_WIDTH, &mVirtualBounds.width) ||
 139         mNativeWindow->query(mNativeWindow.get(), NATIVE_WINDOW_HEIGHT, &mVirtualBounds.height) ||
 140         mNativeWindow->query(mNativeWindow.get(), NATIVE_WINDOW_FORMAT, &mSurfaceFormat)) {
 141         NS_RUNTIMEABORT("Failed to get native window size, aborting...");
 142     }
 143
 144     mNaturalBounds = mVirtualBounds;
 145
 146     if (IsPrimaryScreen()) {
 147         char propValue[PROPERTY_VALUE_MAX];
 148         property_get("ro.sf.hwrotation", propValue, "0");
 149         mPhysicalScreenRotation = atoi(propValue) / 90;
 150     }
 151
 152     mColorDepth = SurfaceFormatToColorDepth(mSurfaceFormat);
 153 }
 154
 155 static void
 156 ReleaseGLContextSync(mozilla::gl::GLContext* aGLContext) {
 157     MOZ_ASSERT(CompositorBridgeParent::IsInCompositorThread());
 158     aGLContext->Release();
 159 }
 160
 161 nsScreenGonk::~nsScreenGonk()
 162 {
 163     // Release GLContext on compositor thread
 164     if (mGLContext) {
 165         CompositorThreadHolder::Loop()->PostTask(
 166             NewRunnableFunction(&ReleaseGLContextSync,
 167                                 mGLContext.forget().take()));
 168         mGLContext = nullptr;
 169     }
 170 }
 171
 172 bool
 173 nsScreenGonk::IsPrimaryScreen()
 174 {
 175     return mDisplayType == GonkDisplay::DISPLAY_PRIMARY;
 176 }
 177
 178 NS_IMETHODIMP
 179 nsScreenGonk::GetId(uint32_t *outId)
 180 {
 181     *outId = mId;
 182     return NS_OK;
 183 }
 184
 185 uint32_t
 186 nsScreenGonk::GetId()
 187 {
 188     return mId;
 189 }
 190
 191 NotifyDisplayChangedEvent
 192 nsScreenGonk::GetEventVisibility()
 193 {
 194     return mEventVisibility;
 195 }
 196
 197 NS_IMETHODIMP
 198 nsScreenGonk::GetRect(int32_t *outLeft,  int32_t *outTop,
 199                       int32_t *outWidth, int32_t *outHeight)
 200 {
 201     *outLeft = mVirtualBounds.x;
 202     *outTop = mVirtualBounds.y;
 203
 204     *outWidth = mVirtualBounds.width;
 205     *outHeight = mVirtualBounds.height;
 206
 207     return NS_OK;
 208 }
 209
 210 LayoutDeviceIntRect
 211 nsScreenGonk::GetRect()
 212 {
 213     return mVirtualBounds;
 214 }
 215
 216 NS_IMETHODIMP
 217 nsScreenGonk::GetAvailRect(int32_t *outLeft,  int32_t *outTop,
 218                            int32_t *outWidth, int32_t *outHeight)
 219 {
 220     return GetRect(outLeft, outTop, outWidth, outHeight);
 221 }
 222
 223 NS_IMETHODIMP
 224 nsScreenGonk::GetPixelDepth(int32_t *aPixelDepth)
 225 {
 226     // XXX: this should actually return 32 when we're using 24-bit
 227     // color, because we use RGBX.
 228     *aPixelDepth = mColorDepth;
 229     return NS_OK;
 230 }
 231
 232 NS_IMETHODIMP
 233 nsScreenGonk::GetColorDepth(int32_t *aColorDepth)
 234 {
 235     *aColorDepth = mColorDepth;
 236     return NS_OK;
 237 }
 238
 239 NS_IMETHODIMP
 240 nsScreenGonk::GetRotation(uint32_t* aRotation)
 241 {
 242     *aRotation = mScreenRotation;
 243     return NS_OK;
 244 }
 245
 246 float
 247 nsScreenGonk::GetDpi()
 248 {
 249     return mDpi;
 250 }
 251
 252 int32_t
 253 nsScreenGonk::GetSurfaceFormat()
 254 {
 255     return mSurfaceFormat;
 256 }
 257
 258 ANativeWindow*
 259 nsScreenGonk::GetNativeWindow()
 260 {
 261     return mNativeWindow.get();
 262 }
 263
 264 NS_IMETHODIMP
 265 nsScreenGonk::SetRotation(uint32_t aRotation)
 266 {
 267     if (!(aRotation <= ROTATION_270_DEG)) {
 268         return NS_ERROR_ILLEGAL_VALUE;
 269     }
 270
 271     if (mScreenRotation == aRotation) {
 272         return NS_OK;
 273     }
 274
 275     mScreenRotation = aRotation;
 276     uint32_t rotation = EffectiveScreenRotation();
 277     if (rotation == nsIScreen::ROTATION_90_DEG ||
 278         rotation == nsIScreen::ROTATION_270_DEG) {
 279         mVirtualBounds = LayoutDeviceIntRect(0, 0,
 280                                              mNaturalBounds.height,
 281                                              mNaturalBounds.width);
 282     } else {
 283         mVirtualBounds = mNaturalBounds;
 284     }
 285
 286     nsAppShell::NotifyScreenRotation();
 287
 288     for (unsigned int i = 0; i < mTopWindows.Length(); i++) {
 289         mTopWindows[i]->Resize(mVirtualBounds.width,
 290                                mVirtualBounds.height,
 291                                true);
 292     }
 293
 294     return NS_OK;
 295 }
 296
 297 LayoutDeviceIntRect
 298 nsScreenGonk::GetNaturalBounds()
 299 {
 300     return mNaturalBounds;
 301 }
 302
 303 uint32_t
 304 nsScreenGonk::EffectiveScreenRotation()
 305 {
 306     return (mScreenRotation + mPhysicalScreenRotation) % (360 / 90);
 307 }
 308
 309 // NB: This isn't gonk-specific, but gonk is the only widget backend
 310 // that does this calculation itself, currently.
 311 static ScreenOrientationInternal
 312 ComputeOrientation(uint32_t aRotation, const LayoutDeviceIntSize& aScreenSize)
 313 {
 314     bool naturallyPortrait = (aScreenSize.height > aScreenSize.width);
 315     switch (aRotation) {
 316     case nsIScreen::ROTATION_0_DEG:
 317         return (naturallyPortrait ? eScreenOrientation_PortraitPrimary :
 318                 eScreenOrientation_LandscapePrimary);
 319     case nsIScreen::ROTATION_90_DEG:
 320         // Arbitrarily choosing 90deg to be primary "unnatural"
 321         // rotation.
 322         return (naturallyPortrait ? eScreenOrientation_LandscapePrimary :
 323                 eScreenOrientation_PortraitPrimary);
 324     case nsIScreen::ROTATION_180_DEG:
 325         return (naturallyPortrait ? eScreenOrientation_PortraitSecondary :
 326                 eScreenOrientation_LandscapeSecondary);
 327     case nsIScreen::ROTATION_270_DEG:
 328         return (naturallyPortrait ? eScreenOrientation_LandscapeSecondary :
 329                 eScreenOrientation_PortraitSecondary);
 330     default:
 331         MOZ_CRASH("Gonk screen must always have a known rotation");
 332     }
 333 }
 334
 335 static uint16_t
 336 RotationToAngle(uint32_t aRotation)
 337 {
 338     uint16_t angle = 90 * aRotation;
 339     MOZ_ASSERT(angle == 0 || angle == 90 || angle == 180 || angle == 270);
 340     return angle;
 341 }
 342
 343 ScreenConfiguration
 344 nsScreenGonk::GetConfiguration()
 345 {
 346     ScreenOrientationInternal orientation =
 347         ComputeOrientation(mScreenRotation, mNaturalBounds.Size());
 348
 349     // NB: perpetuating colorDepth == pixelDepth illusion here, for
 350     // consistency.
 351     return ScreenConfiguration(mVirtualBounds.ToUnknownRect(), orientation,
 352                                RotationToAngle(mScreenRotation),
 353                                mColorDepth, mColorDepth);
 354 }
 355
 356 void
 357 nsScreenGonk::RegisterWindow(nsWindow* aWindow)
 358 {
 359     mTopWindows.AppendElement(aWindow);
 360 }
 361
 362 void
 363 nsScreenGonk::UnregisterWindow(nsWindow* aWindow)
 364 {
 365     mTopWindows.RemoveElement(aWindow);
 366 }
 367
 368 void
 369 nsScreenGonk::BringToTop(nsWindow* aWindow)
 370 {
 371     mTopWindows.RemoveElement(aWindow);
 372     mTopWindows.InsertElementAt(0, aWindow);
 373 }
 374
 375 static gralloc_module_t const*
 376 gralloc_module()
 377 {
 378     hw_module_t const *module;
 379     if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module)) {
 380         return nullptr;
 381     }
 382     return reinterpret_cast<gralloc_module_t const*>(module);
 383 }
 384
 385 static SurfaceFormat
 386 HalFormatToSurfaceFormat(int aHalFormat)
 387 {
 388     switch (aHalFormat) {
 389     case HAL_PIXEL_FORMAT_RGBA_8888:
 390         // Needs RB swap
 391         return SurfaceFormat::B8G8R8A8;
 392     case HAL_PIXEL_FORMAT_RGBX_8888:
 393         // Needs RB swap
 394         return SurfaceFormat::B8G8R8X8;
 395     case HAL_PIXEL_FORMAT_BGRA_8888:
 396         return SurfaceFormat::B8G8R8A8;
 397     case HAL_PIXEL_FORMAT_RGB_565:
 398         return SurfaceFormat::R5G6B5_UINT16;
 399     default:
 400         MOZ_CRASH("Unhandled HAL pixel format");
 401         return SurfaceFormat::UNKNOWN; // not reached
 402     }
 403 }
 404
 405 static bool
 406 NeedsRBSwap(int aHalFormat)
 407 {
 408     switch (aHalFormat) {
 409     case HAL_PIXEL_FORMAT_RGBA_8888:
 410         return true;
 411     case HAL_PIXEL_FORMAT_RGBX_8888:
 412         return true;
 413     case HAL_PIXEL_FORMAT_BGRA_8888:
 414         return false;
 415     case HAL_PIXEL_FORMAT_RGB_565:
 416         return false;
 417     default:
 418         MOZ_CRASH("Unhandled HAL pixel format");
 419         return false; // not reached
 420     }
 421 }
 422
 423 already_AddRefed<DrawTarget>
 424 nsScreenGonk::StartRemoteDrawing()
 425 {
 426     MOZ_ASSERT(CompositorBridgeParent::IsInCompositorThread());
 427     MOZ_ASSERT(!mFramebuffer);
 428     MOZ_ASSERT(!mMappedBuffer);
 429
 430     mFramebuffer = DequeueBuffer();
 431     int width = mFramebuffer->width, height = mFramebuffer->height;
 432     if (gralloc_module()->lock(gralloc_module(), mFramebuffer->handle,
 433                                GRALLOC_USAGE_SW_READ_NEVER |
 434                                GRALLOC_USAGE_SW_WRITE_OFTEN |
 435                                GRALLOC_USAGE_HW_FB,
 436                                0, 0, width, height,
 437                                reinterpret_cast<void**>(&mMappedBuffer))) {
 438         EndRemoteDrawing();
 439         return nullptr;
 440     }
 441     SurfaceFormat format = HalFormatToSurfaceFormat(GetSurfaceFormat());
 442     mFramebufferTarget = Factory::CreateDrawTargetForData(
 443         BackendType::CAIRO,
 444         mMappedBuffer,
 445         IntSize(width, height),
 446         mFramebuffer->stride * gfx::BytesPerPixel(format),
 447         format);
 448     if (!mFramebufferTarget) {
 449         MOZ_CRASH("nsWindow::StartRemoteDrawing failed in CreateDrawTargetForData");
 450     }
 451     if (!mBackBuffer ||
 452         mBackBuffer->GetSize() != mFramebufferTarget->GetSize() ||
 453         mBackBuffer->GetFormat() != mFramebufferTarget->GetFormat()) {
 454         mBackBuffer = mFramebufferTarget->CreateSimilarDrawTarget(
 455             mFramebufferTarget->GetSize(), mFramebufferTarget->GetFormat());
 456     }
 457     RefPtr<DrawTarget> buffer(mBackBuffer);
 458     return buffer.forget();
 459 }
 460
 461 void
 462 nsScreenGonk::EndRemoteDrawing()
 463 {
 464     MOZ_ASSERT(CompositorBridgeParent::IsInCompositorThread());
 465
 466     if (mFramebufferTarget && mFramebuffer) {
 467         IntSize size = mFramebufferTarget->GetSize();
 468         Rect rect(0, 0, size.width, size.height);
 469         RefPtr<SourceSurface> source = mBackBuffer->Snapshot();
 470         mFramebufferTarget->DrawSurface(source, rect, rect);
 471
 472         // Convert from BGR to RGB
 473         // XXX this is a temporary solution. It consumes extra cpu cycles,
 474         // it should not be used on product device.
 475         if (NeedsRBSwap(GetSurfaceFormat())) {
 476             LOGE("Very slow composition path, it should not be used on product!!!");
 477             SurfaceFormat format = HalFormatToSurfaceFormat(GetSurfaceFormat());
 478             gfxUtils::ConvertBGRAtoRGBA(
 479                 mMappedBuffer,
 480                 mFramebuffer->stride * mFramebuffer->height * gfx::BytesPerPixel(format));
 481         }
 482     }
 483     if (mMappedBuffer) {
 484         MOZ_ASSERT(mFramebuffer);
 485         gralloc_module()->unlock(gralloc_module(), mFramebuffer->handle);
 486         mMappedBuffer = nullptr;
 487     }
 488     if (mFramebuffer) {
 489         QueueBuffer(mFramebuffer);
 490     }
 491     mFramebuffer = nullptr;
 492     mFramebufferTarget = nullptr;
 493 }
 494
 495 ANativeWindowBuffer*
 496 nsScreenGonk::DequeueBuffer()
 497 {
 498     ANativeWindowBuffer* buf = nullptr;
 499 #if ANDROID_VERSION >= 17
 500     int fenceFd = -1;
 501     mNativeWindow->dequeueBuffer(mNativeWindow.get(), &buf, &fenceFd);
 502     android::sp<android::Fence> fence(new android::Fence(fenceFd));
 503 #if ANDROID_VERSION == 17
 504     fence->waitForever(1000, "nsScreenGonk_DequeueBuffer");
 505     // 1000 is what Android uses. It is a warning timeout in ms.
 506     // This timeout was removed in ANDROID_VERSION 18.
 507 #else
 508     fence->waitForever("nsScreenGonk_DequeueBuffer");
 509 #endif
 510 #else
 511     mNativeWindow->dequeueBuffer(mNativeWindow.get(), &buf);
 512 #endif
 513     return buf;
 514 }
 515
 516 bool
 517 nsScreenGonk::QueueBuffer(ANativeWindowBuffer* buf)
 518 {
 519 #if ANDROID_VERSION >= 17
 520   int ret = mNativeWindow->queueBuffer(mNativeWindow.get(), buf, -1);
 521   return ret == 0;
 522 #else
 523   int ret = mNativeWindow->queueBuffer(mNativeWindow.get(), buf);
 524   return ret == 0;
 525 #endif
 526 }
 527
 528 nsresult
 529 nsScreenGonk::MakeSnapshot(ANativeWindowBuffer* aBuffer)
 530 {
 531     MOZ_ASSERT(CompositorBridgeParent::IsInCompositorThread());
 532     MOZ_ASSERT(aBuffer);
 533
 534     layers::CompositorBridgeParent* compositorParent = mCompositorBridgeParent;
 535     if (!compositorParent) {
 536         return NS_ERROR_FAILURE;
 537     }
 538
 539     int width = aBuffer->width, height = aBuffer->height;
 540     uint8_t* mappedBuffer = nullptr;
 541     if (gralloc_module()->lock(gralloc_module(), aBuffer->handle,
 542                                GRALLOC_USAGE_SW_READ_OFTEN |
 543                                GRALLOC_USAGE_SW_WRITE_OFTEN,
 544                                0, 0, width, height,
 545                                reinterpret_cast<void**>(&mappedBuffer))) {
 546         return NS_ERROR_FAILURE;
 547     }
 548
 549     SurfaceFormat format = HalFormatToSurfaceFormat(GetSurfaceFormat());
 550     RefPtr<DrawTarget> mTarget =
 551         Factory::CreateDrawTargetForData(
 552             BackendType::CAIRO,
 553             mappedBuffer,
 554             IntSize(width, height),
 555             aBuffer->stride * gfx::BytesPerPixel(format),
 556             format);
 557     if (!mTarget) {
 558         return NS_ERROR_FAILURE;
 559     }
 560
 561     gfx::IntRect rect = GetRect().ToUnknownRect();
 562     compositorParent->ForceComposeToTarget(mTarget, &rect);
 563
 564     // Convert from BGR to RGB
 565     // XXX this is a temporary solution. It consumes extra cpu cycles,
 566     if (NeedsRBSwap(GetSurfaceFormat())) {
 567         LOGE("Slow path of making Snapshot!!!");
 568         SurfaceFormat format = HalFormatToSurfaceFormat(GetSurfaceFormat());
 569         gfxUtils::ConvertBGRAtoRGBA(
 570             mappedBuffer,
 571             aBuffer->stride * aBuffer->height * gfx::BytesPerPixel(format));
 572         mappedBuffer = nullptr;
 573     }
 574     gralloc_module()->unlock(gralloc_module(), aBuffer->handle);
 575     return NS_OK;
 576 }
 577
 578 void
 579 nsScreenGonk::SetCompositorBridgeParent(layers::CompositorBridgeParent* aCompositorBridgeParent)
 580 {
 581     MOZ_ASSERT(NS_IsMainThread());
 582     mCompositorBridgeParent = aCompositorBridgeParent;
 583 }
 584
 585 #if ANDROID_VERSION >= 17
 586 android::DisplaySurface*
 587 nsScreenGonk::GetDisplaySurface()
 588 {
 589     return mDisplaySurface.get();
 590 }
 591
 592 int
 593 nsScreenGonk::GetPrevDispAcquireFd()
 594 {
 595     if (!mDisplaySurface.get()) {
 596         return -1;
 597     }
 598     return mDisplaySurface->GetPrevDispAcquireFd();
 599 }
 600 #endif
 601
 602 GonkDisplay::DisplayType
 603 nsScreenGonk::GetDisplayType()
 604 {
 605     return mDisplayType;
 606 }
 607
 608 void
 609 nsScreenGonk::SetEGLInfo(hwc_display_t aDisplay,
 610                          hwc_surface_t aSurface,
 611                          gl::GLContext* aGLContext)
 612 {
 613     MOZ_ASSERT(CompositorBridgeParent::IsInCompositorThread());
 614     mEGLDisplay = aDisplay;
 615     mEGLSurface = aSurface;
 616     mGLContext = aGLContext;
 617 }
 618
 619 hwc_display_t
 620 nsScreenGonk::GetEGLDisplay()
 621 {
 622     MOZ_ASSERT(CompositorBridgeParent::IsInCompositorThread());
 623     return mEGLDisplay;
 624 }
 625
 626 hwc_surface_t
 627 nsScreenGonk::GetEGLSurface()
 628 {
 629     MOZ_ASSERT(CompositorBridgeParent::IsInCompositorThread());
 630     return mEGLSurface;
 631 }
 632
 633 already_AddRefed<mozilla::gl::GLContext>
 634 nsScreenGonk::GetGLContext()
 635 {
 636     MOZ_ASSERT(CompositorBridgeParent::IsInCompositorThread());
 637     RefPtr<mozilla::gl::GLContext>glContext = mGLContext;
 638     return glContext.forget();
 639 }
 640
 641 static void
 642 UpdateMirroringWidgetSync(nsMainThreadPtrHandle<nsScreenGonk>&& aScreen, nsWindow* aWindow)
 643 {
 644     MOZ_ASSERT(CompositorBridgeParent::IsInCompositorThread());
 645     already_AddRefed<nsWindow> window(aWindow);
 646     aScreen->UpdateMirroringWidget(window);
 647 }
 648
 649 bool
 650 nsScreenGonk::EnableMirroring()
 651 {
 652     MOZ_ASSERT(NS_IsMainThread());
 653     MOZ_ASSERT(!IsPrimaryScreen());
 654
 655     RefPtr<nsScreenGonk> primaryScreen = nsScreenManagerGonk::GetPrimaryScreen();
 656     NS_ENSURE_TRUE(primaryScreen, false);
 657
 658     bool ret = primaryScreen->SetMirroringScreen(this);
 659     NS_ENSURE_TRUE(ret, false);
 660
 661     // Create a widget for mirroring
 662     nsWidgetInitData initData;
 663     initData.mScreenId = mId;
 664     RefPtr<nsWindow> window = new nsWindow();
 665     window->Create(nullptr, nullptr, mNaturalBounds, &initData);
 666     MOZ_ASSERT(static_cast<nsWindow*>(window)->GetScreen() == this);
 667
 668     // Update mMirroringWidget on compositor thread
 669     nsMainThreadPtrHandle<nsScreenGonk> primary =
 670       nsMainThreadPtrHandle<nsScreenGonk>(new nsMainThreadPtrHolder<nsScreenGonk>(primaryScreen, false));
 671     CompositorThreadHolder::Loop()->PostTask(
 672         NewRunnableFunction(&UpdateMirroringWidgetSync,
 673                             primary,
 674                             window.forget().take()));
 675
 676     mIsMirroring = true;
 677     return true;
 678 }
 679
 680 bool
 681 nsScreenGonk::DisableMirroring()
 682 {
 683     MOZ_ASSERT(NS_IsMainThread());
 684     MOZ_ASSERT(!IsPrimaryScreen());
 685
 686     mIsMirroring = false;
 687     RefPtr<nsScreenGonk> primaryScreen = nsScreenManagerGonk::GetPrimaryScreen();
 688     NS_ENSURE_TRUE(primaryScreen, false);
 689
 690     bool ret = primaryScreen->ClearMirroringScreen(this);
 691     NS_ENSURE_TRUE(ret, false);
 692
 693     // Update mMirroringWidget on compositor thread
 694     nsMainThreadPtrHandle<nsScreenGonk> primary =
 695       nsMainThreadPtrHandle<nsScreenGonk>(new nsMainThreadPtrHolder<nsScreenGonk>(primaryScreen, false));
 696     CompositorThreadHolder::Loop()->PostTask(
 697         NewRunnableFunction(&UpdateMirroringWidgetSync,
 698                             primary,
 699                             nullptr));
 700     return true;
 701 }
 702
 703 bool
 704 nsScreenGonk::SetMirroringScreen(nsScreenGonk* aScreen)
 705 {
 706     MOZ_ASSERT(NS_IsMainThread());
 707     MOZ_ASSERT(IsPrimaryScreen());
 708
 709     if (mMirroringScreen) {
 710         return false;
 711     }
 712     mMirroringScreen = aScreen;
 713     return true;
 714 }
 715
 716 bool
 717 nsScreenGonk::ClearMirroringScreen(nsScreenGonk* aScreen)
 718 {
 719     MOZ_ASSERT(NS_IsMainThread());
 720     MOZ_ASSERT(IsPrimaryScreen());
 721
 722     if (mMirroringScreen != aScreen) {
 723         return false;
 724     }
 725     mMirroringScreen = nullptr;
 726     return true;
 727 }
 728
 729 void
 730 nsScreenGonk::UpdateMirroringWidget(already_AddRefed<nsWindow>& aWindow)
 731 {
 732     MOZ_ASSERT(CompositorBridgeParent::IsInCompositorThread());
 733     MOZ_ASSERT(IsPrimaryScreen());
 734
 735     if (mMirroringWidget) {
 736         nsCOMPtr<nsIWidget> widget = mMirroringWidget.forget();
 737         NS_ReleaseOnMainThread(widget.forget());
 738     }
 739     mMirroringWidget = aWindow;
 740 }
 741
 742 nsWindow*
 743 nsScreenGonk::GetMirroringWidget()
 744 {
 745     MOZ_ASSERT(CompositorBridgeParent::IsInCompositorThread());
 746     MOZ_ASSERT(IsPrimaryScreen());
 747
 748     return mMirroringWidget;
 749 }
 750
 751 NS_IMPL_ISUPPORTS(nsScreenManagerGonk, nsIScreenManager)
 752
 753 nsScreenManagerGonk::nsScreenManagerGonk()
 754     : mInitialized(false)
 755 #if ANDROID_VERSION >= 19
 756     , mDisplayEnabled(false)
 757 #endif
 758 {
 759 }
 760
 761 nsScreenManagerGonk::~nsScreenManagerGonk()
 762 {
 763 }
 764
 765 static StaticRefPtr<nsScreenManagerGonk> sScreenManagerGonk;
 766
 767 /* static */ already_AddRefed<nsScreenManagerGonk>
 768 nsScreenManagerGonk::GetInstance()
 769 {
 770     MOZ_ASSERT(NS_IsMainThread());
 771
 772     // Avoid creating nsScreenManagerGonk from content process.
 773     if (!XRE_IsParentProcess()) {
 774         MOZ_CRASH("Non-chrome processes should not get here.");
 775     }
 776
 777     // Avoid creating multiple nsScreenManagerGonk instance inside main process.
 778     if (!sScreenManagerGonk) {
 779       sScreenManagerGonk = new nsScreenManagerGonk();
 780       ClearOnShutdown(&sScreenManagerGonk);
 781     }
 782
 783     RefPtr<nsScreenManagerGonk> screenMgr = sScreenManagerGonk.get();
 784     return screenMgr.forget();
 785 }
 786
 787 /* static */ already_AddRefed< nsScreenGonk>
 788 nsScreenManagerGonk::GetPrimaryScreen()
 789 {
 790     MOZ_ASSERT(NS_IsMainThread());
 791
 792     RefPtr<nsScreenManagerGonk> manager = nsScreenManagerGonk::GetInstance();
 793     nsCOMPtr<nsIScreen> screen;
 794     manager->GetPrimaryScreen(getter_AddRefs(screen));
 795     MOZ_ASSERT(screen);
 796     return already_AddRefed<nsScreenGonk>(
 797         static_cast<nsScreenGonk*>(screen.forget().take()));
 798 }
 799
 800 void
 801 nsScreenManagerGonk::Initialize()
 802 {
 803     if (mInitialized) {
 804         return;
 805     }
 806
 807     mScreenOnEvent = new ScreenOnOffEvent(true);
 808     mScreenOffEvent = new ScreenOnOffEvent(false);
 809     GetGonkDisplay()->OnEnabled(displayEnabledCallback);
 810
 811     AddScreen(GonkDisplay::DISPLAY_PRIMARY);
 812
 813     nsAppShell::NotifyScreenInitialized();
 814     mInitialized = true;
 815 }
 816
 817 void
 818 nsScreenManagerGonk::DisplayEnabled(bool aEnabled)
 819 {
 820     MOZ_ASSERT(NS_IsMainThread());
 821
 822 #if ANDROID_VERSION >= 19
 823     /* Bug 1244044
 824      * This function could be called before |mCompositorVsyncScheduler| is set.
 825      * To avoid this issue, keep the value stored in |mDisplayEnabled|.
 826      */
 827     mDisplayEnabled = aEnabled;
 828     if (mCompositorVsyncScheduler) {
 829         mCompositorVsyncScheduler->SetDisplay(mDisplayEnabled);
 830     }
 831 #endif
 832
 833     VsyncControl(aEnabled);
 834     NS_DispatchToMainThread(aEnabled ? mScreenOnEvent : mScreenOffEvent);
 835 }
 836
 837 NS_IMETHODIMP
 838 nsScreenManagerGonk::GetPrimaryScreen(nsIScreen **outScreen)
 839 {
 840     NS_IF_ADDREF(*outScreen = mScreens[0].get());
 841     return NS_OK;
 842 }
 843
 844 NS_IMETHODIMP
 845 nsScreenManagerGonk::ScreenForId(uint32_t aId,
 846                                  nsIScreen **outScreen)
 847 {
 848     for (size_t i = 0; i < mScreens.Length(); i++) {
 849         if (mScreens[i]->GetId() == aId) {
 850             NS_IF_ADDREF(*outScreen = mScreens[i].get());
 851             return NS_OK;
 852         }
 853     }
 854
 855     *outScreen = nullptr;
 856     return NS_OK;
 857 }
 858
 859 NS_IMETHODIMP
 860 nsScreenManagerGonk::ScreenForRect(int32_t inLeft,
 861                                    int32_t inTop,
 862                                    int32_t inWidth,
 863                                    int32_t inHeight,
 864                                    nsIScreen **outScreen)
 865 {
 866     // Since all screens have independent coordinate system, we could
 867     // only return the primary screen no matter what rect is given.
 868     return GetPrimaryScreen(outScreen);
 869 }
 870
 871 NS_IMETHODIMP
 872 nsScreenManagerGonk::ScreenForNativeWidget(void *aWidget, nsIScreen **outScreen)
 873 {
 874     for (size_t i = 0; i < mScreens.Length(); i++) {
 875         if (aWidget == mScreens[i]->GetNativeWindow()) {
 876             NS_IF_ADDREF(*outScreen = mScreens[i].get());
 877             return NS_OK;
 878         }
 879     }
 880
 881     *outScreen = nullptr;
 882     return NS_OK;
 883 }
 884
 885 NS_IMETHODIMP
 886 nsScreenManagerGonk::GetNumberOfScreens(uint32_t *aNumberOfScreens)
 887 {
 888     *aNumberOfScreens = mScreens.Length();
 889     return NS_OK;
 890 }
 891
 892 NS_IMETHODIMP
 893 nsScreenManagerGonk::GetSystemDefaultScale(float *aDefaultScale)
 894 {
 895     *aDefaultScale = 1.0f;
 896     return NS_OK;
 897 }
 898
 899 void
 900 nsScreenManagerGonk::VsyncControl(bool aEnabled)
 901 {
 902     if (!NS_IsMainThread()) {
 903         NS_DispatchToMainThread(
 904             NS_NewRunnableMethodWithArgs<bool>(this,
 905                                                &nsScreenManagerGonk::VsyncControl,
 906                                                aEnabled));
 907         return;
 908     }
 909
 910     MOZ_ASSERT(NS_IsMainThread());
 911     VsyncSource::Display &display = gfxPlatform::GetPlatform()->GetHardwareVsync()->GetGlobalDisplay();
 912     if (aEnabled) {
 913         display.EnableVsync();
 914     } else {
 915         display.DisableVsync();
 916     }
 917 }
 918
 919 uint32_t
 920 nsScreenManagerGonk::GetIdFromType(GonkDisplay::DisplayType aDisplayType)
 921 {
 922     // This is the only place where we make the assumption that
 923     // display type is equivalent to screen id.
 924
 925     // Bug 1138287 will address the conversion from type to id.
 926     return aDisplayType;
 927 }
 928
 929 bool
 930 nsScreenManagerGonk::IsScreenConnected(uint32_t aId)
 931 {
 932     for (size_t i = 0; i < mScreens.Length(); ++i) {
 933         if (mScreens[i]->GetId() == aId) {
 934             return true;
 935         }
 936     }
 937
 938     return false;
 939 }
 940
 941 namespace {
 942
 943 // A concrete class as a subject for 'display-changed' observer event.
 944 class DisplayInfo : public nsIDisplayInfo {
 945 public:
 946     NS_DECL_ISUPPORTS
 947
 948     DisplayInfo(uint32_t aId, bool aConnected)
 949         : mId(aId)
 950         , mConnected(aConnected)
 951     {
 952     }
 953
 954     NS_IMETHODIMP GetId(int32_t *aId)
 955     {
 956         *aId = mId;
 957         return NS_OK;
 958     }
 959
 960     NS_IMETHODIMP GetConnected(bool *aConnected)
 961     {
 962         *aConnected = mConnected;
 963         return NS_OK;
 964     }
 965
 966 private:
 967     virtual ~DisplayInfo() {}
 968
 969     uint32_t mId;
 970     bool mConnected;
 971 };
 972
 973 NS_IMPL_ISUPPORTS(DisplayInfo, nsIDisplayInfo, nsISupports)
 974
 975 class NotifyTask : public mozilla::Runnable {
 976 public:
 977     NotifyTask(uint32_t aId, bool aConnected)
 978         : mDisplayInfo(new DisplayInfo(aId, aConnected))
 979     {
 980     }
 981
 982     NS_IMETHOD Run()
 983     {
 984         nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
 985         if (os) {
 986           os->NotifyObservers(mDisplayInfo, "display-changed", nullptr);
 987         }
 988
 989         return NS_OK;
 990     }
 991 private:
 992     RefPtr<DisplayInfo> mDisplayInfo;
 993 };
 994
 995 void
 996 NotifyDisplayChange(uint32_t aId, bool aConnected)
 997 {
 998     NS_DispatchToMainThread(new NotifyTask(aId, aConnected));
 999 }
1000
1001 } // end of unnamed namespace.
1002
1003 nsresult
1004 nsScreenManagerGonk::AddScreen(GonkDisplay::DisplayType aDisplayType,
1005                                android::IGraphicBufferProducer* aSink,
1006                                NotifyDisplayChangedEvent aEventVisibility)
1007 {
1008     MOZ_ASSERT(NS_IsMainThread());
1009
1010     NS_ENSURE_TRUE(aDisplayType < GonkDisplay::DisplayType::NUM_DISPLAY_TYPES,
1011                    NS_ERROR_FAILURE);
1012
1013     uint32_t id = GetIdFromType(aDisplayType);
1014     NS_ENSURE_TRUE(!IsScreenConnected(id), NS_ERROR_FAILURE);
1015
1016     GonkDisplay::NativeData nativeData =
1017         GetGonkDisplay()->GetNativeData(aDisplayType, aSink);
1018     nsScreenGonk* screen = new nsScreenGonk(id,
1019                                             aDisplayType,
1020                                             nativeData,
1021                                             aEventVisibility);
1022     mScreens.AppendElement(screen);
1023
1024     if (aEventVisibility == NotifyDisplayChangedEvent::Observable) {
1025         NotifyDisplayChange(id, true);
1026     }
1027
1028     // By default, non primary screen does mirroring.
1029     if (aDisplayType != GonkDisplay::DISPLAY_PRIMARY &&
1030         gfxPrefs::ScreenMirroringEnabled()) {
1031         screen->EnableMirroring();
1032     }
1033
1034     return NS_OK;
1035 }
1036
1037 nsresult
1038 nsScreenManagerGonk::RemoveScreen(GonkDisplay::DisplayType aDisplayType)
1039 {
1040     MOZ_ASSERT(NS_IsMainThread());
1041
1042     NS_ENSURE_TRUE(aDisplayType < GonkDisplay::DisplayType::NUM_DISPLAY_TYPES,
1043                    NS_ERROR_FAILURE);
1044
1045     NotifyDisplayChangedEvent eventVisibility = NotifyDisplayChangedEvent::Observable;
1046     uint32_t screenId = GetIdFromType(aDisplayType);
1047     NS_ENSURE_TRUE(IsScreenConnected(screenId), NS_ERROR_FAILURE);
1048
1049     for (size_t i = 0; i < mScreens.Length(); i++) {
1050         if (mScreens[i]->GetId() == screenId) {
1051             if (mScreens[i]->IsMirroring()) {
1052                 mScreens[i]->DisableMirroring();
1053             }
1054             eventVisibility = mScreens[i]->GetEventVisibility();
1055             mScreens.RemoveElementAt(i);
1056             break;
1057         }
1058     }
1059
1060     if (eventVisibility == NotifyDisplayChangedEvent::Observable) {
1061       NotifyDisplayChange(screenId, false);
1062     }
1063     return NS_OK;
1064 }
1065
1066 #if ANDROID_VERSION >= 19
1067 void
1068 nsScreenManagerGonk::SetCompositorVsyncScheduler(mozilla::layers::CompositorVsyncScheduler *aObserver)
1069 {
1070     MOZ_ASSERT(NS_IsMainThread());
1071
1072     // We assume on b2g that there is only 1 CompositorBridgeParent
1073     MOZ_ASSERT(mCompositorVsyncScheduler == nullptr);
1074     MOZ_ASSERT(aObserver);
1075     mCompositorVsyncScheduler = aObserver;
1076     mCompositorVsyncScheduler->SetDisplay(mDisplayEnabled);
1077 }
1078 #endif