Merge "Add choreographer API to the NDK." (6cfa1cc4) · Commits · e / os / android_frameworks_base

core/jni/android_view_DisplayEventReceiver.cpp

+5 −103

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@
		#include <inttypes.h>

		#include <android_runtime/AndroidRuntime.h>
		#include <androidfw/DisplayEventDispatcher.h>
		#include <utils/Log.h>
		#include <utils/Looper.h>
		#include <utils/threads.h>
		@@ -48,14 +49,12 @@ static struct {
		} gDisplayEventReceiverClassInfo;


		class NativeDisplayEventReceiver : public LooperCallback {
		class NativeDisplayEventReceiver : public DisplayEventDispatcher {
		public:
		NativeDisplayEventReceiver(JNIEnv* env,
		jobject receiverWeak, const sp<MessageQueue>& messageQueue);

		status_t initialize();
		void dispose();
		status_t scheduleVsync();

		protected:
		virtual ~NativeDisplayEventReceiver();
		@@ -66,15 +65,14 @@ private:
		DisplayEventReceiver mReceiver;
		bool mWaitingForVsync;

		virtual int handleEvent(int receiveFd, int events, void* data);
		bool processPendingEvents(nsecs_t* outTimestamp, int32_t* id, uint32_t* outCount);
		void dispatchVsync(nsecs_t timestamp, int32_t id, uint32_t count);
		void dispatchHotplug(nsecs_t timestamp, int32_t id, bool connected);
		virtual void dispatchVsync(nsecs_t timestamp, int32_t id, uint32_t count);
		virtual void dispatchHotplug(nsecs_t timestamp, int32_t id, bool connected);
		};


		NativeDisplayEventReceiver::NativeDisplayEventReceiver(JNIEnv* env,
		jobject receiverWeak, const sp<MessageQueue>& messageQueue) :
		DisplayEventDispatcher(messageQueue->getLooper()),
		mReceiverWeakGlobal(env->NewGlobalRef(receiverWeak)),
		mMessageQueue(messageQueue), mWaitingForVsync(false) {
		ALOGV("receiver %p ~ Initializing display event receiver.", this);
		@@ -85,21 +83,6 @@ NativeDisplayEventReceiver::~NativeDisplayEventReceiver() {
		env->DeleteGlobalRef(mReceiverWeakGlobal);
		}

		status_t NativeDisplayEventReceiver::initialize() {
		status_t result = mReceiver.initCheck();
		if (result) {
		ALOGW("Failed to initialize display event receiver, status=%d", result);
		return result;
		}

		int rc = mMessageQueue->getLooper()->addFd(mReceiver.getFd(), 0, Looper::EVENT_INPUT,
		this, NULL);
		if (rc < 0) {
		return UNKNOWN_ERROR;
		}
		return OK;
		}

		void NativeDisplayEventReceiver::dispose() {
		ALOGV("receiver %p ~ Disposing display event receiver.", this);

		@@ -108,87 +91,6 @@ void NativeDisplayEventReceiver::dispose() {
		}
		}

		status_t NativeDisplayEventReceiver::scheduleVsync() {
		if (!mWaitingForVsync) {
		ALOGV("receiver %p ~ Scheduling vsync.", this);

		// Drain all pending events.
		nsecs_t vsyncTimestamp;
		int32_t vsyncDisplayId;
		uint32_t vsyncCount;
		processPendingEvents(&vsyncTimestamp, &vsyncDisplayId, &vsyncCount);

		status_t status = mReceiver.requestNextVsync();
		if (status) {
		ALOGW("Failed to request next vsync, status=%d", status);
		return status;
		}

		mWaitingForVsync = true;
		}
		return OK;
		}

		int NativeDisplayEventReceiver::handleEvent(int receiveFd, int events, void* data) {
		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;
		int32_t vsyncDisplayId;
		uint32_t vsyncCount;
		if (processPendingEvents(&vsyncTimestamp, &vsyncDisplayId, &vsyncCount)) {
		ALOGV("receiver %p ~ Vsync pulse: timestamp=%" PRId64 ", id=%d, count=%d",
		this, vsyncTimestamp, vsyncDisplayId, vsyncCount);
		mWaitingForVsync = false;
		dispatchVsync(vsyncTimestamp, vsyncDisplayId, vsyncCount);
		}

		return 1; // keep the callback
		}

		bool NativeDisplayEventReceiver::processPendingEvents(
		nsecs_t* outTimestamp, int32_t* outId, 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("receiver %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;
		*outId = ev.header.id;
		*outCount = ev.vsync.count;
		break;
		case DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG:
		dispatchHotplug(ev.header.timestamp, ev.header.id, ev.hotplug.connected);
		break;
		default:
		ALOGW("receiver %p ~ ignoring unknown event type %#x", this, ev.header.type);
		break;
		}
		}
		}
		if (n < 0) {
		ALOGW("Failed to get events from display event receiver, status=%d", status_t(n));
		}
		return gotVsync;
		}

		void NativeDisplayEventReceiver::dispatchVsync(nsecs_t timestamp, int32_t id, uint32_t count) {
		JNIEnv* env = AndroidRuntime::getJNIEnv();

include/androidfw/DisplayEventDispatcher.h

0 → 100644

+45 −0

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:
		DisplayEventDispatcher(const sp<Looper>& looper);

		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, int32_t id, uint32_t count) = 0;
		virtual void dispatchHotplug(nsecs_t timestamp, int32_t id, bool connected) = 0;

		virtual int handleEvent(int receiveFd, int events, void* data);
		bool processPendingEvents(nsecs_t* outTimestamp, int32_t* id, uint32_t* outCount);
		};
		}

libs/androidfw/Android.mk

+3 −1

Original line number	Diff line number	Diff line
		@@ -34,7 +34,8 @@ deviceSources := \
		$(commonSources) \
		BackupData.cpp \
		BackupHelpers.cpp \
		CursorWindow.cpp
		CursorWindow.cpp \
		DisplayEventDispatcher.cpp

		hostSources := $(commonSources)

		@@ -66,6 +67,7 @@ LOCAL_SHARED_LIBRARIES := \
		libbinder \
		liblog \
		libcutils \
		libgui \
		libutils \
		libz

libs/androidfw/DisplayEventDispatcher.cpp

0 → 100644

+147 −0

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) :
		mLooper(looper), 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;
		int32_t 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;
		int32_t vsyncDisplayId;
		uint32_t vsyncCount;
		if (processPendingEvents(&vsyncTimestamp, &vsyncDisplayId, &vsyncCount)) {
		ALOGE("dispatcher %p ~ Vsync pulse: timestamp=%" PRId64 ", id=%d, count=%d",
		this, ns2ms(vsyncTimestamp), vsyncDisplayId, vsyncCount);
		mWaitingForVsync = false;
		dispatchVsync(vsyncTimestamp, vsyncDisplayId, vsyncCount);
		}

		return 1; // keep the callback
		}

		bool DisplayEventDispatcher::processPendingEvents(
		nsecs_t* outTimestamp, int32_t* outId, 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;
		*outId = ev.header.id;
		*outCount = ev.vsync.count;
		break;
		case DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG:
		dispatchHotplug(ev.header.timestamp, ev.header.id, ev.hotplug.connected);
		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;
		}
		}

native/android/Android.mk

+4 −0

Original line number	Diff line number	Diff line
		@@ -7,6 +7,7 @@ include $(CLEAR_VARS)
		#
		LOCAL_SRC_FILES:= \
		asset_manager.cpp \
		choreographer.cpp \
		configuration.cpp \
		input.cpp \
		looper.cpp \
		@@ -43,4 +44,7 @@ LOCAL_MODULE := libandroid

		LOCAL_CFLAGS += -Wall -Werror -Wunused -Wunreachable-code

		# Required because of b/25642296
		LOCAL_CLANG_arm64 := false

		include $(BUILD_SHARED_LIBRARY)