Merge "[DisplayEventDispatcher] Kick DisplayEventDispatcher out of libandroidfw." (fe7538bf) · Commits · e / os / android_frameworks_base

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);
		};
		}