gecko/widget/gonk/libdisplay/GonkDisplayICS.cpp

/* Copyright 2013 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 "GonkDisplayICS.h"
#include <ui/FramebufferNativeWindow.h>

#include <hardware/hardware.h>
#include <hardware/gralloc.h>
#include <hardware/hwcomposer.h>
#include <hardware_legacy/power.h>
#include <cutils/log.h>
#include <fcntl.h>

#include "mozilla/FileUtils.h"
#include "mozilla/NullPtr.h"
#include "mozilla/FileUtils.h"

#include "BootAnimation.h"

using namespace android;


namespace {
static const char* kSleepFile = "/sys/power/wait_for_fb_sleep";
static const char* kWakeFile = "/sys/power/wait_for_fb_wake";
static mozilla::GonkDisplay::OnEnabledCallbackType sEnabledCallback;
static pthread_t sFramebufferWatchThread;

static void *
frameBufferWatcher(void *)
{
    int len = 0;
    char buf;

    while (true) {
        // Cannot use epoll here because kSleepFile and kWakeFile are
        // always ready to read and blocking.
        {
            mozilla::ScopedClose fd(open(kSleepFile, O_RDONLY, 0));
            do {
                len = read(fd.get(), &buf, 1);
            } while (len < 0 && errno == EINTR);
            NS_WARN_IF_FALSE(len >= 0, "WAIT_FOR_FB_SLEEP failed");
        }
        sEnabledCallback(false);

        {
            mozilla::ScopedClose fd(open(kWakeFile, O_RDONLY, 0));
            do {
                len = read(fd.get(), &buf, 1);
            } while (len < 0 && errno == EINTR);
            NS_WARN_IF_FALSE(len >= 0, "WAIT_FOR_FB_WAKE failed");
        }
        sEnabledCallback(true);
    }

    return nullptr;
}

} // anonymous namespace


namespace mozilla {

static GonkDisplayICS* sGonkDisplay = nullptr;

static int
FramebufferNativeWindowCancelBufferNoop(ANativeWindow* aWindow,
    android_native_buffer_t* aBuffer)
{
    return 0;
}

GonkDisplayICS::GonkDisplayICS()
    : mModule(nullptr)
    , mHwc(nullptr)
{
    // Some gralloc HALs need this in order to open the
    // framebuffer device after we restart with the screen off.
    //
    // this *must* run BEFORE allocating the
    // FramebufferNativeWindow.
    set_screen_state(1);

    // For some devices, it takes a while for the framebuffer to become
    // usable. So we wait until the framebuffer has woken up before we
    // try to open it.
    {
        char buf;
        int len = 0;
        ScopedClose fd(open("/sys/power/wait_for_fb_wake", O_RDONLY, 0));
        do {
            len = read(fd.get(), &buf, 1);
        } while (len < 0 && errno == EINTR);
        if (len < 0) {
            LOGE("BootAnimation: wait_for_fb_sleep failed errno: %d", errno);
        }
    }

    mFBSurface = new FramebufferNativeWindow();

    // ICS FramebufferNativeWindow doesn't set the |cancelBuffer|
    // function pointer.
    // It will crash when deleting the EGL window surface.
    if (!mFBSurface->cancelBuffer) {
        mFBSurface->cancelBuffer = FramebufferNativeWindowCancelBufferNoop;
    }

    int err = hw_get_module(HWC_HARDWARE_MODULE_ID, &mModule);
    LOGW_IF(err, "%s module not found", HWC_HARDWARE_MODULE_ID);
    if (!err) {
        err = hwc_open(mModule, &mHwc);
        LOGE_IF(err, "%s device failed to initialize (%s)",
                 HWC_HARDWARE_COMPOSER, strerror(-err));
    }

    xdpi = mFBSurface->xdpi;

    const framebuffer_device_t *fbdev = mFBSurface->getDevice();
    surfaceformat = fbdev->format;

    StartBootAnimation();
}

GonkDisplayICS::~GonkDisplayICS()
{
    if (mHwc)
        hwc_close(mHwc);
}

ANativeWindow*
GonkDisplayICS::GetNativeWindow()
{
    StopBootAnimation();
    return static_cast<ANativeWindow *>(mFBSurface.get());
}

void
GonkDisplayICS::SetEnabled(bool enabled)
{
    set_screen_state(enabled);
}

void
GonkDisplayICS::OnEnabled(OnEnabledCallbackType callback)
{
    if (sEnabledCallback)
        return;
    sEnabledCallback = callback;

    // Watching screen on/off state by using a pthread
    // which implicitly calls exit() when the main thread ends
    if (pthread_create(&sFramebufferWatchThread, NULL, frameBufferWatcher, NULL)) {
        NS_RUNTIMEABORT("Failed to create framebufferWatcherThread, aborting...");
    }
}


void*
GonkDisplayICS::GetHWCDevice()
{
    return mHwc;
}

void*
GonkDisplayICS::GetFBSurface()
{
    return mFBSurface.get();
}

bool
GonkDisplayICS::SwapBuffers(EGLDisplay dpy, EGLSurface sur)
{
    // Should be called when composition rendering is complete for a frame.
    // Only HWC v1.0 needs this call. ICS gonk always needs the call.
    mFBSurface->compositionComplete();

    if (!mHwc)
        return eglSwapBuffers(dpy, sur);

    mHwc->prepare(mHwc, nullptr);
    return !mHwc->set(mHwc, dpy, sur, 0);
}

ANativeWindowBuffer*
GonkDisplayICS::DequeueBuffer()
{
    ANativeWindow *window = static_cast<ANativeWindow *>(mFBSurface.get());
    ANativeWindowBuffer *buf = nullptr;
    window->dequeueBuffer(window, &buf);
    return buf;
}

bool
GonkDisplayICS::QueueBuffer(ANativeWindowBuffer *buf)
{
    ANativeWindow *window = static_cast<ANativeWindow *>(mFBSurface.get());
    return !window->queueBuffer(window, buf);
}

void
GonkDisplayICS::UpdateFBSurface(EGLDisplay dpy, EGLSurface sur)
{
    eglSwapBuffers(dpy, sur);
}

void
GonkDisplayICS::SetFBReleaseFd(int fd)
{
}

__attribute__ ((visibility ("default")))
GonkDisplay*
GetGonkDisplay()
{
    if (!sGonkDisplay)
        sGonkDisplay = new GonkDisplayICS();
    return sGonkDisplay;
}

} // namespace mozilla