Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7d77ff82 authored by Alec Mouri's avatar Alec Mouri
Browse files

[DisplayEventDispatcher] Kick DisplayEventDispatcher out of libandroidfw. 

DisplayEventDispatcher will live in libgui for now, as a shim over
DisplayEventReceiver. This is so that we can keep libgui out of the
UI-renderer module while we can work on stabilizing the interface with
libandroidfw for asset management required by graphics classes.

It also doesn't make much sense to have display-event functionality in a
separate grab-bag library, especially when there's two users, and
there is potentially an opportunity to somehow merge with
DisplayEventReceiver to simplify code a bit.

Change-Id: Ife0f9c8ad2053437087fdbf0618b892928ce6864
Bug: 142760698
Test: builds
parent 4ac18603

core/jni/android_view_DisplayEventReceiver.cpp

+1 −3
Original line number Diff line number Diff line
@@ -23,11 +23,10 @@ 
#include <inttypes.h>



#include <android_runtime/AndroidRuntime.h>

#include <androidfw/DisplayEventDispatcher.h>

#include <gui/DisplayEventDispatcher.h>

#include <utils/Log.h>

#include <utils/Looper.h>

#include <utils/threads.h>

#include <gui/DisplayEventReceiver.h>

#include "android_os_MessageQueue.h"



#include <nativehelper/ScopedLocalRef.h>
@@ -59,7 +58,6 @@ protected: 
private:

    jobject mReceiverWeakGlobal;

    sp<MessageQueue> mMessageQueue;

    DisplayEventReceiver mReceiver;



    void dispatchVsync(nsecs_t timestamp, PhysicalDisplayId displayId, uint32_t count) override;

    void dispatchHotplug(nsecs_t timestamp, PhysicalDisplayId displayId, bool connected) override;

libs/androidfw/Android.bp

+0 −2
Original line number Diff line number Diff line
@@ -67,7 +67,6 @@ cc_library { 
                "BackupData.cpp",

                "BackupHelpers.cpp",

                "CursorWindow.cpp",

                "DisplayEventDispatcher.cpp",

            ],

            shared_libs: [

                "libziparchive",
@@ -75,7 +74,6 @@ cc_library { 
                "libbinder",

                "liblog",

                "libcutils",

                "libgui",

                "libutils",

                "libz",

            ],

libs/androidfw/DisplayEventDispatcher.cpp

deleted100644 → 0
+0 −153
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2015 The Android Open Source Project

 *

 * 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.

 */



#define LOG_TAG "DisplayEventDispatcher"



#include <cinttypes>

#include <cstdint>



#include <androidfw/DisplayEventDispatcher.h>

#include <gui/DisplayEventReceiver.h>

#include <utils/Log.h>

#include <utils/Looper.h>



#include <utils/Timers.h>



namespace android {



// Number of events to read at a time from the DisplayEventDispatcher pipe.

// The value should be large enough that we can quickly drain the pipe

// using just a few large reads.

static const size_t EVENT_BUFFER_SIZE = 100;



DisplayEventDispatcher::DisplayEventDispatcher(const sp<Looper>& looper,

        ISurfaceComposer::VsyncSource vsyncSource,

        ISurfaceComposer::ConfigChanged configChanged) :

        mLooper(looper), mReceiver(vsyncSource, configChanged), mWaitingForVsync(false) {

    ALOGV("dispatcher %p ~ Initializing display event dispatcher.", this);

}



status_t DisplayEventDispatcher::initialize() {

    status_t result = mReceiver.initCheck();

    if (result) {

        ALOGW("Failed to initialize display event receiver, status=%d", result);

        return result;

    }



    int rc = mLooper->addFd(mReceiver.getFd(), 0, Looper::EVENT_INPUT,

            this, NULL);

    if (rc < 0) {

        return UNKNOWN_ERROR;

    }

    return OK;

}



void DisplayEventDispatcher::dispose() {

    ALOGV("dispatcher %p ~ Disposing display event dispatcher.", this);



    if (!mReceiver.initCheck()) {

        mLooper->removeFd(mReceiver.getFd());

    }

}



status_t DisplayEventDispatcher::scheduleVsync() {

    if (!mWaitingForVsync) {

        ALOGV("dispatcher %p ~ Scheduling vsync.", this);



        // Drain all pending events.

        nsecs_t vsyncTimestamp;

        PhysicalDisplayId vsyncDisplayId;

        uint32_t vsyncCount;

        if (processPendingEvents(&vsyncTimestamp, &vsyncDisplayId, &vsyncCount)) {

            ALOGE("dispatcher %p ~ last event processed while scheduling was for %" PRId64 "",

                    this, ns2ms(static_cast<nsecs_t>(vsyncTimestamp)));

        }



        status_t status = mReceiver.requestNextVsync();

        if (status) {

            ALOGW("Failed to request next vsync, status=%d", status);

            return status;

        }



        mWaitingForVsync = true;

    }

    return OK;

}



int DisplayEventDispatcher::handleEvent(int, int events, void*) {

    if (events & (Looper::EVENT_ERROR | Looper::EVENT_HANGUP)) {

        ALOGE("Display event receiver pipe was closed or an error occurred.  "

                "events=0x%x", events);

        return 0; // remove the callback

    }



    if (!(events & Looper::EVENT_INPUT)) {

        ALOGW("Received spurious callback for unhandled poll event.  "

                "events=0x%x", events);

        return 1; // keep the callback

    }



    // Drain all pending events, keep the last vsync.

    nsecs_t vsyncTimestamp;

    PhysicalDisplayId vsyncDisplayId;

    uint32_t vsyncCount;

    if (processPendingEvents(&vsyncTimestamp, &vsyncDisplayId, &vsyncCount)) {

        ALOGV("dispatcher %p ~ Vsync pulse: timestamp=%" PRId64 ", displayId=%"

                ANDROID_PHYSICAL_DISPLAY_ID_FORMAT ", count=%d",

                this, ns2ms(vsyncTimestamp), vsyncDisplayId, vsyncCount);

        mWaitingForVsync = false;

        dispatchVsync(vsyncTimestamp, vsyncDisplayId, vsyncCount);

    }



    return 1; // keep the callback

}



bool DisplayEventDispatcher::processPendingEvents(

        nsecs_t* outTimestamp, PhysicalDisplayId* outDisplayId, uint32_t* outCount) {

    bool gotVsync = false;

    DisplayEventReceiver::Event buf[EVENT_BUFFER_SIZE];

    ssize_t n;

    while ((n = mReceiver.getEvents(buf, EVENT_BUFFER_SIZE)) > 0) {

        ALOGV("dispatcher %p ~ Read %d events.", this, int(n));

        for (ssize_t i = 0; i < n; i++) {

            const DisplayEventReceiver::Event& ev = buf[i];

            switch (ev.header.type) {

            case DisplayEventReceiver::DISPLAY_EVENT_VSYNC:

                // Later vsync events will just overwrite the info from earlier

                // ones. That's fine, we only care about the most recent.

                gotVsync = true;

                *outTimestamp = ev.header.timestamp;

                *outDisplayId = ev.header.displayId;

                *outCount = ev.vsync.count;

                break;

            case DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG:

                dispatchHotplug(ev.header.timestamp, ev.header.displayId, ev.hotplug.connected);

                break;

            case DisplayEventReceiver::DISPLAY_EVENT_CONFIG_CHANGED:

                dispatchConfigChanged(ev.header.timestamp, ev.header.displayId, ev.config.configId);

                break;

            default:

                ALOGW("dispatcher %p ~ ignoring unknown event type %#x", this, ev.header.type);

                break;

            }

        }

    }

    if (n < 0) {

        ALOGW("Failed to get events from display event dispatcher, status=%d", status_t(n));

    }

    return gotVsync;

}

}

libs/androidfw/include/androidfw/DisplayEventDispatcher.h

deleted100644 → 0
+0 −51
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2015 The Android Open Source Project

 *

 * 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 <gui/DisplayEventReceiver.h>

#include <utils/Log.h>

#include <utils/Looper.h>



namespace android {



class DisplayEventDispatcher : public LooperCallback {

public:

    explicit DisplayEventDispatcher(const sp<Looper>& looper,

            ISurfaceComposer::VsyncSource vsyncSource = ISurfaceComposer::eVsyncSourceApp,

            ISurfaceComposer::ConfigChanged configChanged = ISurfaceComposer::eConfigChangedSuppress);



    status_t initialize();

    void dispose();

    status_t scheduleVsync();



protected:

    virtual ~DisplayEventDispatcher() = default;



private:

    sp<Looper> mLooper;

    DisplayEventReceiver mReceiver;

    bool mWaitingForVsync;



    virtual void dispatchVsync(nsecs_t timestamp, PhysicalDisplayId displayId, uint32_t count) = 0;

    virtual void dispatchHotplug(nsecs_t timestamp, PhysicalDisplayId displayId,

                                 bool connected) = 0;

    virtual void dispatchConfigChanged(nsecs_t timestamp, PhysicalDisplayId displayId,

                                       int32_t configId) = 0;



    virtual int handleEvent(int receiveFd, int events, void* data);

    bool processPendingEvents(nsecs_t* outTimestamp, PhysicalDisplayId* outDisplayId,

                              uint32_t* outCount);

};

}