Home | History | Annotate | Download | only in androidfw 
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #define LOG_TAG "DisplayEventDispatcher"
     18 
     19 #include <cinttypes>
     20 #include <cstdint>
     21 
     22 #include <androidfw/DisplayEventDispatcher.h>
     23 #include <gui/DisplayEventReceiver.h>
     24 #include <utils/Log.h>
     25 #include <utils/Looper.h>
     26 
     27 #include <utils/Timers.h>
     28 
     29 namespace android {
     30 
     31 // Number of events to read at a time from the DisplayEventDispatcher pipe.
     32 // The value should be large enough that we can quickly drain the pipe
     33 // using just a few large reads.
     34 static const size_t EVENT_BUFFER_SIZE = 100;
     35 
     36 DisplayEventDispatcher::DisplayEventDispatcher(const sp<Looper>& looper,
     37         ISurfaceComposer::VsyncSource vsyncSource) :
     38         mLooper(looper), mReceiver(vsyncSource), mWaitingForVsync(false) {
     39     ALOGV("dispatcher %p ~ Initializing display event dispatcher.", this);
     40 }
     41 
     42 status_t DisplayEventDispatcher::initialize() {
     43     status_t result = mReceiver.initCheck();
     44     if (result) {
     45         ALOGW("Failed to initialize display event receiver, status=%d", result);
     46         return result;
     47     }
     48 
     49     int rc = mLooper->addFd(mReceiver.getFd(), 0, Looper::EVENT_INPUT,
     50             this, NULL);
     51     if (rc < 0) {
     52         return UNKNOWN_ERROR;
     53     }
     54     return OK;
     55 }
     56 
     57 void DisplayEventDispatcher::dispose() {
     58     ALOGV("dispatcher %p ~ Disposing display event dispatcher.", this);
     59 
     60     if (!mReceiver.initCheck()) {
     61         mLooper->removeFd(mReceiver.getFd());
     62     }
     63 }
     64 
     65 status_t DisplayEventDispatcher::scheduleVsync() {
     66     if (!mWaitingForVsync) {
     67         ALOGV("dispatcher %p ~ Scheduling vsync.", this);
     68 
     69         // Drain all pending events.
     70         nsecs_t vsyncTimestamp;
     71         PhysicalDisplayId vsyncDisplayId;
     72         uint32_t vsyncCount;
     73         if (processPendingEvents(&vsyncTimestamp, &vsyncDisplayId, &vsyncCount)) {
     74             ALOGE("dispatcher %p ~ last event processed while scheduling was for %" PRId64 "",
     75                     this, ns2ms(static_cast<nsecs_t>(vsyncTimestamp)));
     76         }
     77 
     78         status_t status = mReceiver.requestNextVsync();
     79         if (status) {
     80             ALOGW("Failed to request next vsync, status=%d", status);
     81             return status;
     82         }
     83 
     84         mWaitingForVsync = true;
     85     }
     86     return OK;
     87 }
     88 
     89 int DisplayEventDispatcher::handleEvent(int, int events, void*) {
     90     if (events & (Looper::EVENT_ERROR | Looper::EVENT_HANGUP)) {
     91         ALOGE("Display event receiver pipe was closed or an error occurred.  "
     92                 "events=0x%x", events);
     93         return 0; // remove the callback
     94     }
     95 
     96     if (!(events & Looper::EVENT_INPUT)) {
     97         ALOGW("Received spurious callback for unhandled poll event.  "
     98                 "events=0x%x", events);
     99         return 1; // keep the callback
    100     }
    101 
    102     // Drain all pending events, keep the last vsync.
    103     nsecs_t vsyncTimestamp;
    104     PhysicalDisplayId vsyncDisplayId;
    105     uint32_t vsyncCount;
    106     if (processPendingEvents(&vsyncTimestamp, &vsyncDisplayId, &vsyncCount)) {
    107         ALOGV("dispatcher %p ~ Vsync pulse: timestamp=%" PRId64 ", displayId=%"
    108                 ANDROID_PHYSICAL_DISPLAY_ID_FORMAT ", count=%d",
    109                 this, ns2ms(vsyncTimestamp), vsyncDisplayId, vsyncCount);
    110         mWaitingForVsync = false;
    111         dispatchVsync(vsyncTimestamp, vsyncDisplayId, vsyncCount);
    112     }
    113 
    114     return 1; // keep the callback
    115 }
    116 
    117 bool DisplayEventDispatcher::processPendingEvents(
    118         nsecs_t* outTimestamp, PhysicalDisplayId* outDisplayId, uint32_t* outCount) {
    119     bool gotVsync = false;
    120     DisplayEventReceiver::Event buf[EVENT_BUFFER_SIZE];
    121     ssize_t n;
    122     while ((n = mReceiver.getEvents(buf, EVENT_BUFFER_SIZE)) > 0) {
    123         ALOGV("dispatcher %p ~ Read %d events.", this, int(n));
    124         for (ssize_t i = 0; i < n; i++) {
    125             const DisplayEventReceiver::Event& ev = buf[i];
    126             switch (ev.header.type) {
    127             case DisplayEventReceiver::DISPLAY_EVENT_VSYNC:
    128                 // Later vsync events will just overwrite the info from earlier
    129                 // ones. That's fine, we only care about the most recent.
    130                 gotVsync = true;
    131                 *outTimestamp = ev.header.timestamp;
    132                 *outDisplayId = ev.header.displayId;
    133                 *outCount = ev.vsync.count;
    134                 break;
    135             case DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG:
    136                 dispatchHotplug(ev.header.timestamp, ev.header.displayId, ev.hotplug.connected);
    137                 break;
    138             case DisplayEventReceiver::DISPLAY_EVENT_CONFIG_CHANGED:
    139                 dispatchConfigChanged(ev.header.timestamp, ev.header.displayId, ev.config.configId);
    140                 break;
    141             default:
    142                 ALOGW("dispatcher %p ~ ignoring unknown event type %#x", this, ev.header.type);
    143                 break;
    144             }
    145         }
    146     }
    147     if (n < 0) {
    148         ALOGW("Failed to get events from display event dispatcher, status=%d", status_t(n));
    149     }
    150     return gotVsync;
    151 }
    152 }
    153