TvInputHal: AOSP refactor on TvInput Hal (f290be73) · Commits · e / os / android_frameworks_base

services/Android.mk

+5 −0

Original line number	Diff line number	Diff line
		@@ -48,6 +48,11 @@ LOCAL_SHARED_LIBRARIES :=
		# include all the jni subdirs to collect their sources
		include $(wildcard $(LOCAL_PATH)/*/jni/Android.mk)

		LOCAL_C_INCLUDES += \
		$(TOP)/frameworks/base/services/libtvextensions \

		LOCAL_WHOLE_STATIC_LIBRARIES := libTvInputHalExtensions

		LOCAL_CFLAGS += -DEGL_EGLEXT_PROTOTYPES -DGL_GLEXT_PROTOTYPES

		LOCAL_MODULE:= libandroid_servers

services/core/jni/com_android_server_tv_TvInputHal.cpp

+23 −37

Original line number	Diff line number	Diff line
		@@ -32,6 +32,8 @@
		#include <utils/NativeHandle.h>
		#include <hardware/tv_input.h>

		#include <jni/TvInputHalExtensions.h>

		namespace android {

		static struct {
		@@ -71,37 +73,6 @@ static struct {

		////////////////////////////////////////////////////////////////////////////////

		class BufferProducerThread : public Thread {
		public:
		BufferProducerThread(tv_input_device_t* device, int deviceId, const tv_stream_t* stream);

		virtual status_t readyToRun();

		void setSurface(const sp<Surface>& surface);
		void onCaptured(uint32_t seq, bool succeeded);
		void shutdown();

		private:
		Mutex mLock;
		Condition mCondition;
		sp<Surface> mSurface;
		tv_input_device_t* mDevice;
		int mDeviceId;
		tv_stream_t mStream;
		sp<ANativeWindowBuffer_t> mBuffer;
		enum {
		CAPTURING,
		CAPTURED,
		RELEASED,
		} mBufferState;
		uint32_t mSeq;
		bool mShutdown;

		virtual bool threadLoop();

		void setSurfaceLocked(const sp<Surface>& surface);
		};

		BufferProducerThread::BufferProducerThread(
		tv_input_device_t* device, int deviceId, const tv_stream_t* stream)
		: Thread(false),
		@@ -132,14 +103,14 @@ status_t BufferProducerThread::readyToRun() {
		return NO_ERROR;
		}

		void BufferProducerThread::setSurface(const sp<Surface>& surface) {
		int BufferProducerThread::setSurface(const sp<Surface>& surface) {
		Mutex::Autolock autoLock(&mLock);
		setSurfaceLocked(surface);
		return setSurfaceLocked(surface);
		}

		void BufferProducerThread::setSurfaceLocked(const sp<Surface>& surface) {
		int BufferProducerThread::setSurfaceLocked(const sp<Surface>& surface) {
		if (surface == mSurface) {
		return;
		return NO_ERROR;
		}

		if (mBufferState == CAPTURING) {
		@@ -157,6 +128,8 @@ void BufferProducerThread::setSurfaceLocked(const sp<Surface>& surface) {

		mSurface = surface;
		mCondition.broadcast();

		return NO_ERROR;
		}

		void BufferProducerThread::onCaptured(uint32_t seq, bool succeeded) {
		@@ -390,7 +363,8 @@ int JTvInputHal::addOrUpdateStream(int deviceId, int streamId, const sp<Surface>
		if (connection.mThread != NULL) {
		connection.mThread->shutdown();
		}
		connection.mThread = new BufferProducerThread(mDevice, deviceId, &stream);

		connection.mThread = TvInputHalFactory::get()->createBufferProducerThread(mDevice, deviceId, &stream);
		if (connection.mThread == NULL) {
		ALOGE("No memory for BufferProducerThread");

		@@ -406,7 +380,19 @@ int JTvInputHal::addOrUpdateStream(int deviceId, int streamId, const sp<Surface>
		if (connection.mStreamType == TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE) {
		connection.mSurface->setSidebandStream(connection.mSourceHandle);
		} else if (connection.mStreamType == TV_STREAM_TYPE_BUFFER_PRODUCER) {
		connection.mThread->setSurface(surface);
		if (NO_ERROR != connection.mThread->setSurface(surface))
		{
		ALOGE("failed to setSurface");
		// clean up
		connection.mThread.clear();
		if (mDevice->close_stream(mDevice, deviceId, streamId) != 0) {
		ALOGE("Couldn't remove stream");
		}
		if (connection.mSurface != NULL) {
		connection.mSurface.clear();
		}
		return UNKNOWN_ERROR;
		}
		connection.mThread->run();
		}
		return NO_ERROR;

services/libtvextensions/Android.mk

0 → 100644

+21 −0

Original line number	Diff line number	Diff line
		LOCAL_PATH:= $(call my-dir)
		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= \
		jni/TvInputHalFactory.cpp \

		LOCAL_C_INCLUDES:= \
		$(TOP)/frameworks/base/services/libtvextensions \

		LOCAL_CFLAGS += -Wno-multichar

		ifeq ($(TARGET_ENABLE_QC_TVINPUT_HAL_EXTENSIONS),true)
		LOCAL_CFLAGS += -DENABLE_TVINPUT_HAL_EXTENSIONS
		endif

		LOCAL_MODULE:= libTvInputHalExtensions

		LOCAL_MODULE_TAGS := optional

		include $(BUILD_STATIC_LIBRARY)

services/libtvextensions/common/ExtensionsLoader.hpp

0 → 100644

+91 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (c) 2013 - 2015, The Linux Foundation. All rights reserved.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions are
		* met:
		* * Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		* * Redistributions in binary form must reproduce the above
		* copyright notice, this list of conditions and the following
		* disclaimer in the documentation and/or other materials provided
		* with the distribution.
		* * Neither the name of The Linux Foundation nor the names of its
		* contributors may be used to endorse or promote products derived
		* from this software without specific prior written permission.
		*
		* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
		* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
		* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
		* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
		* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
		* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
		* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
		* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
		* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		*/
		#include <dlfcn.h>
		#include <common/TvInputHalExtensionsCommon.h>

		namespace android {

		/*
		* Create strongly-typed objects of type T
		* If the customization library exists and does contain a "named" constructor,
		* invoke and create an instance
		* Else create the object of type T itself
		*
		* Contains a static instance to dlopen'd library, But may end up
		* opening the library mutiple times. Following snip from dlopen man page is
		* reassuring "...Only a single copy of an object file is brought into the
		* address space, even if dlopen() is invoked multiple times in reference to
		* the file, and even if different pathnames are used to reference the file.."
		*/

		template <typename T>
		T ExtensionsLoader<T>::createInstance(const char createFunctionName) {
		ALOGV("createInstance(%dbit) : %s", sizeof(intptr_t)*8, createFunctionName);
		// create extended object if extensions-lib is available and
		// TVINPUT_HAL_EXTENSIONS is enabled
		#if ENABLE_TVINPUT_HAL_EXTENSIONS
		createFunction_t createFunc = loadCreateFunction(createFunctionName);
		if (createFunc) {
		return reinterpret_cast<T >((createFunc)());
		}
		#endif
		// Else, create the default object
		return new T;
		}

		template <typename T>
		void ExtensionsLoader<T>::loadLib() {
		if (!mLibHandle) {
		mLibHandle = ::dlopen(CUSTOMIZATION_LIB_NAME, RTLD_LAZY);
		if (!mLibHandle) {
		ALOGV("%s", dlerror());
		return;
		}
		ALOGV("Opened %s", CUSTOMIZATION_LIB_NAME);
		}
		}

		template <typename T>
		createFunction_t ExtensionsLoader<T>::loadCreateFunction(const char *createFunctionName) {
		loadLib();
		if (!mLibHandle) {
		return NULL;
		}
		createFunction_t func = (createFunction_t)dlsym(mLibHandle, createFunctionName);
		if (!func) {
		ALOGW("symbol %s not found: %s",createFunctionName, dlerror());
		}
		return func;
		}

		//static
		template <typename T>
		void *ExtensionsLoader<T>::mLibHandle = NULL;

		} //namespace android

services/libtvextensions/common/TvInputHalExtensionsCommon.h

0 → 100644

+69 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (c) 2013 - 2015, The Linux Foundation. All rights reserved.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions are
		* met:
		* * Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		* * Redistributions in binary form must reproduce the above
		* copyright notice, this list of conditions and the following
		* disclaimer in the documentation and/or other materials provided
		* with the distribution.
		* * Neither the name of The Linux Foundation nor the names of its
		* contributors may be used to endorse or promote products derived
		* from this software without specific prior written permission.
		*
		* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
		* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
		* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
		* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
		* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
		* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
		* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
		* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
		* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		*/
		#ifndef _TVINPUTHAL_EXTENSIONS_COMMON_H_
		#define _TVINPUTHAL_EXTENSIONS_COMMON_H_

		namespace android {

		static const char * CUSTOMIZATION_LIB_NAME = "libTvInputHalEnhancements.so";

		typedef void (createFunction_t)(void);

		template <typename T>
		struct ExtensionsLoader {

		static T createInstance(const char createFunctionName);

		private:
		static void loadLib();
		static createFunction_t loadCreateFunction(const char *createFunctionName);
		static void *mLibHandle;
		};

		/*
		* Boiler-plate to declare the class as a singleton (with a static getter)
		* which can be loaded (dlopen'd) via ExtensionsLoader
		*/
		#define DECLARE_LOADABLE_SINGLETON(className) \
		protected: \
		className(); \
		virtual ~className(); \
		static className *sInst; \
		private: \
		className(const className&); \
		className &operator=(className &); \
		public: \
		static className *get() { \
		return sInst; \
		} \
		friend struct ExtensionsLoader<className>;

		} //namespace android

		#endif // _TVINPUTHAL_EXTENSIONS_COMMON_H_