services/displayservice/DisplayEventReceiver.cpp

/*
 * Copyright (C) 2017 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 "libdisplayservicehidl"

#include <displayservice/DisplayEventReceiver.h>

#include <android-base/logging.h>
#include <android/frameworks/displayservice/1.0/BpHwEventCallback.h>

#include <thread>

namespace android {
namespace frameworks {
namespace displayservice {
namespace V1_0 {
namespace implementation {

sp<Looper> getLooper() {
    static sp<Looper> looper = []() {
        sp<Looper> looper = new Looper(false /* allowNonCallbacks */);

        std::thread{[&](){
            int pollResult = looper->pollAll(-1 /* timeout */);
            LOG(ERROR) << "Looper::pollAll returns unexpected " << pollResult;
        }}.detach();

        return looper;
    }();

    return looper;
}

DisplayEventReceiver::AttachedEvent::AttachedEvent(const sp<IEventCallback> &callback)
    : mCallback(callback)
{
    mLooperAttached = getLooper()->addFd(mFwkReceiver.getFd(),
            Looper::POLL_CALLBACK,
            Looper::EVENT_INPUT,
            this,
            nullptr);
}

DisplayEventReceiver::AttachedEvent::~AttachedEvent() {
    if (!detach()) {
        LOG(ERROR) << "Could not remove fd from looper.";
    }
}

bool DisplayEventReceiver::AttachedEvent::detach() {
    if (!valid()) {
        return true;
    }

    return getLooper()->removeFd(mFwkReceiver.getFd());
}

bool DisplayEventReceiver::AttachedEvent::valid() const {
    return mFwkReceiver.initCheck() == OK && mLooperAttached;
}

DisplayEventReceiver::FwkReceiver &DisplayEventReceiver::AttachedEvent::receiver() {
    return mFwkReceiver;
}

int DisplayEventReceiver::AttachedEvent::handleEvent(int fd, int events, void* /* data */) {
    CHECK(fd == mFwkReceiver.getFd());

    if (events & (Looper::EVENT_ERROR | Looper::EVENT_HANGUP)) {
        LOG(ERROR) << "AttachedEvent handleEvent received error or hangup:" << events;
        return 0; // remove the callback
    }

    if (!(events & Looper::EVENT_INPUT)) {
        LOG(ERROR) << "AttachedEvent handleEvent unhandled poll event:" << events;
        return 1; // keep the callback
    }

    constexpr size_t SIZE = 1;

    ssize_t n;
    FwkReceiver::Event buf[SIZE];
    while ((n = mFwkReceiver.getEvents(buf, SIZE)) > 0) {
        for (size_t i = 0; i < static_cast<size_t>(n); ++i) {
            const FwkReceiver::Event &event = buf[i];

            uint32_t type = event.header.type;
            uint64_t timestamp = event.header.timestamp;

            switch(buf[i].header.type) {
                case FwkReceiver::DISPLAY_EVENT_VSYNC: {
                    mCallback->onVsync(timestamp, event.vsync.count);
                } break;
                case FwkReceiver::DISPLAY_EVENT_HOTPLUG: {
                    mCallback->onHotplug(timestamp, event.hotplug.connected);
                } break;
                default: {
                    LOG(ERROR) << "AttachedEvent handleEvent unknown type: " << type;
                }
            }
        }
    }

    return 1; // keep on going
}

Return<Status> DisplayEventReceiver::init(const sp<IEventCallback>& callback) {
    std::unique_lock<std::mutex> lock(mMutex);

    if (mAttached != nullptr || callback == nullptr) {
        return Status::BAD_VALUE;
    }

    mAttached = new AttachedEvent(callback);

    return mAttached->valid() ? Status::SUCCESS : Status::UNKNOWN;
}

Return<Status> DisplayEventReceiver::setVsyncRate(int32_t count) {
    std::unique_lock<std::mutex> lock(mMutex);

    if (mAttached == nullptr || count < 0) {
        return Status::BAD_VALUE;
    }

    bool success = OK == mAttached->receiver().setVsyncRate(count);
    return success ? Status::SUCCESS : Status::UNKNOWN;
}

Return<Status> DisplayEventReceiver::requestNextVsync() {
    std::unique_lock<std::mutex> lock(mMutex);

    if (mAttached == nullptr) {
        return Status::BAD_VALUE;
    }

    bool success = OK == mAttached->receiver().requestNextVsync();
    return success ? Status::SUCCESS : Status::UNKNOWN;
}

Return<Status> DisplayEventReceiver::close() {
    std::unique_lock<std::mutex> lock(mMutex);
    if (mAttached == nullptr) {
        return Status::BAD_VALUE;
    }

    bool success = mAttached->detach();
    mAttached = nullptr;

    return success ? Status::SUCCESS : Status::UNKNOWN;
}

}  // namespace implementation
}  // namespace V1_0
}  // namespace displayservice
}  // namespace frameworks
}  // namespace android