Remove unused HdmiCecController jni library (5efdd34d) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/hdmi/HdmiCecController.java

+0 −16

Original line number	Diff line number	Diff line
		@@ -27,7 +27,6 @@ import android.hardware.tv.cec.V1_0.SendMessageResult;
		import android.os.Handler;
		import android.os.IHwBinder;
		import android.os.Looper;
		import android.os.MessageQueue;
		import android.os.RemoteException;
		import android.util.Slog;
		import android.util.SparseArray;
		@@ -708,21 +707,6 @@ final class HdmiCecController {
		boolean nativeIsConnected(int port);
		}

		private static native long nativeInit(HdmiCecController handler, MessageQueue messageQueue);
		private static native int nativeSendCecCommand(long controllerPtr, int srcAddress,
		int dstAddress, byte[] body);
		private static native int nativeAddLogicalAddress(long controllerPtr, int logicalAddress);
		private static native void nativeClearLogicalAddress(long controllerPtr);
		private static native int nativeGetPhysicalAddress(long controllerPtr);
		private static native int nativeGetVersion(long controllerPtr);
		private static native int nativeGetVendorId(long controllerPtr);
		private static native HdmiPortInfo[] nativeGetPortInfos(long controllerPtr);
		private static native void nativeSetOption(long controllerPtr, int flag, boolean enabled);
		private static native void nativeSetLanguage(long controllerPtr, String language);
		private static native void nativeEnableAudioReturnChannel(long controllerPtr,
		int port, boolean flag);
		private static native boolean nativeIsConnected(long controllerPtr, int port);

		private static final class NativeWrapperImpl implements NativeWrapper,
		IHwBinder.DeathRecipient, getPhysicalAddressCallback {
		private IHdmiCec mHdmiCec;

services/core/jni/Android.bp

+0 −2

Original line number	Diff line number	Diff line
		@@ -27,7 +27,6 @@ cc_library_static {
		"com_android_server_ConsumerIrService.cpp",
		"com_android_server_devicepolicy_CryptoTestHelper.cpp",
		"com_android_server_HardwarePropertiesManagerService.cpp",
		"com_android_server_hdmi_HdmiCecController.cpp",
		"com_android_server_input_InputManagerService.cpp",
		"com_android_server_lights_LightsService.cpp",
		"com_android_server_location_GnssLocationProvider.cpp",
		@@ -126,7 +125,6 @@ cc_defaults {
		"android.hardware.power@1.1",
		"android.hardware.power.stats@1.0",
		"android.hardware.thermal@1.0",
		"android.hardware.tv.cec@1.0",
		"android.hardware.tv.input@1.0",
		"android.hardware.vibrator-cpp",
		"android.hardware.vibrator@1.0",

services/core/jni/com_android_server_hdmi_HdmiCecController.cpp

deleted100644 → 0

+0 −463

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 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 "HdmiCecControllerJni"

		#define LOG_NDEBUG 1

		#include <nativehelper/JNIHelp.h>
		#include <nativehelper/ScopedPrimitiveArray.h>

		#include <android/hardware/tv/cec/1.0/IHdmiCec.h>
		#include <android/hardware/tv/cec/1.0/IHdmiCecCallback.h>
		#include <android/hardware/tv/cec/1.0/types.h>
		#include <android_os_MessageQueue.h>
		#include <android_runtime/AndroidRuntime.h>
		#include <android_runtime/Log.h>
		#include <sys/param.h>
		#include <utils/Errors.h>
		#include <utils/Looper.h>
		#include <utils/RefBase.h>

		using ::android::hardware::tv::cec::V1_0::CecLogicalAddress;
		using ::android::hardware::tv::cec::V1_0::CecMessage;
		using ::android::hardware::tv::cec::V1_0::HdmiPortInfo;
		using ::android::hardware::tv::cec::V1_0::HotplugEvent;
		using ::android::hardware::tv::cec::V1_0::IHdmiCec;
		using ::android::hardware::tv::cec::V1_0::IHdmiCecCallback;
		using ::android::hardware::tv::cec::V1_0::MaxLength;
		using ::android::hardware::tv::cec::V1_0::OptionKey;
		using ::android::hardware::tv::cec::V1_0::Result;
		using ::android::hardware::tv::cec::V1_0::SendMessageResult;
		using ::android::hardware::Return;
		using ::android::hardware::Void;
		using ::android::hardware::hidl_vec;
		using ::android::hardware::hidl_string;

		namespace android {

		static struct {
		jmethodID handleIncomingCecCommand;
		jmethodID handleHotplug;
		} gHdmiCecControllerClassInfo;

		class HdmiCecController {
		public:
		HdmiCecController(sp<IHdmiCec> hdmiCec, jobject callbacksObj, const sp<Looper>& looper);
		~HdmiCecController();

		// Send message to other device. Note that it runs in IO thread.
		int sendMessage(const CecMessage& message);
		// Add a logical address to device.
		int addLogicalAddress(CecLogicalAddress address);
		// Clear all logical address registered to the device.
		void clearLogicaladdress();
		// Get physical address of device.
		int getPhysicalAddress();
		// Get CEC version from driver.
		int getVersion();
		// Get vendor id used for vendor command.
		uint32_t getVendorId();
		// Get Port information on all the HDMI ports.
		jobjectArray getPortInfos();
		// Set an option to CEC HAL.
		void setOption(OptionKey key, bool enabled);
		// Informs CEC HAL about the current system language.
		void setLanguage(hidl_string language);
		// Enable audio return channel.
		void enableAudioReturnChannel(int port, bool flag);
		// Whether to hdmi device is connected to the given port.
		bool isConnected(int port);

		jobject getCallbacksObj() const {
		return mCallbacksObj;
		}

		private:
		class HdmiCecCallback : public IHdmiCecCallback {
		public:
		explicit HdmiCecCallback(HdmiCecController* controller) : mController(controller) {};
		Return<void> onCecMessage(const CecMessage& event) override;
		Return<void> onHotplugEvent(const HotplugEvent& event) override;
		private:
		HdmiCecController* mController;
		};

		static const int INVALID_PHYSICAL_ADDRESS = 0xFFFF;

		sp<IHdmiCec> mHdmiCec;
		jobject mCallbacksObj;
		sp<IHdmiCecCallback> mHdmiCecCallback;
		sp<Looper> mLooper;
		};

		// Handler class to delegate incoming message to service thread.
		class HdmiCecEventHandler : public MessageHandler {
		public:
		enum EventType {
		CEC_MESSAGE,
		HOT_PLUG
		};

		HdmiCecEventHandler(HdmiCecController* controller, const CecMessage& cecMessage)
		: mController(controller),
		mCecMessage(cecMessage) {}

		HdmiCecEventHandler(HdmiCecController* controller, const HotplugEvent& hotplugEvent)
		: mController(controller),
		mHotplugEvent(hotplugEvent) {}

		virtual ~HdmiCecEventHandler() {}

		void handleMessage(const Message& message) {
		switch (message.what) {
		case EventType::CEC_MESSAGE:
		propagateCecCommand(mCecMessage);
		break;
		case EventType::HOT_PLUG:
		propagateHotplugEvent(mHotplugEvent);
		break;
		default:
		// TODO: add more type whenever new type is introduced.
		break;
		}
		}

		private:
		// Propagate the message up to Java layer.
		void propagateCecCommand(const CecMessage& message) {
		JNIEnv* env = AndroidRuntime::getJNIEnv();
		jint srcAddr = static_cast<jint>(message.initiator);
		jint dstAddr = static_cast<jint>(message.destination);
		jbyteArray body = env->NewByteArray(message.body.size());
		const jbyte* bodyPtr = reinterpret_cast<const jbyte *>(message.body.data());
		env->SetByteArrayRegion(body, 0, message.body.size(), bodyPtr);
		env->CallVoidMethod(mController->getCallbacksObj(),
		gHdmiCecControllerClassInfo.handleIncomingCecCommand, srcAddr,
		dstAddr, body);
		env->DeleteLocalRef(body);

		checkAndClearExceptionFromCallback(env, __FUNCTION__);
		}

		void propagateHotplugEvent(const HotplugEvent& event) {
		// Note that this method should be called in service thread.
		JNIEnv* env = AndroidRuntime::getJNIEnv();
		jint port = static_cast<jint>(event.portId);
		jboolean connected = (jboolean) event.connected;
		env->CallVoidMethod(mController->getCallbacksObj(),
		gHdmiCecControllerClassInfo.handleHotplug, port, connected);

		checkAndClearExceptionFromCallback(env, __FUNCTION__);
		}

		// static
		static void checkAndClearExceptionFromCallback(JNIEnv* env, const char* methodName) {
		if (env->ExceptionCheck()) {
		ALOGE("An exception was thrown by callback '%s'.", methodName);
		LOGE_EX(env);
		env->ExceptionClear();
		}
		}

		HdmiCecController* mController;
		CecMessage mCecMessage;
		HotplugEvent mHotplugEvent;
		};

		HdmiCecController::HdmiCecController(sp<IHdmiCec> hdmiCec,
		jobject callbacksObj, const sp<Looper>& looper)
		: mHdmiCec(hdmiCec),
		mCallbacksObj(callbacksObj),
		mLooper(looper) {
		mHdmiCecCallback = new HdmiCecCallback(this);
		Return<void> ret = mHdmiCec->setCallback(mHdmiCecCallback);
		if (!ret.isOk()) {
		ALOGE("Failed to set a cec callback.");
		}
		}

		HdmiCecController::~HdmiCecController() {
		Return<void> ret = mHdmiCec->setCallback(nullptr);
		if (!ret.isOk()) {
		ALOGE("Failed to set a cec callback.");
		}
		}

		int HdmiCecController::sendMessage(const CecMessage& message) {
		// TODO: propagate send_message's return value.
		Return<SendMessageResult> ret = mHdmiCec->sendMessage(message);
		if (!ret.isOk()) {
		ALOGE("Failed to send CEC message.");
		return static_cast<int>(SendMessageResult::FAIL);
		}
		return static_cast<int>((SendMessageResult) ret);
		}

		int HdmiCecController::addLogicalAddress(CecLogicalAddress address) {
		Return<Result> ret = mHdmiCec->addLogicalAddress(address);
		if (!ret.isOk()) {
		ALOGE("Failed to add a logical address.");
		return static_cast<int>(Result::FAILURE_UNKNOWN);
		}
		return static_cast<int>((Result) ret);
		}

		void HdmiCecController::clearLogicaladdress() {
		Return<void> ret = mHdmiCec->clearLogicalAddress();
		if (!ret.isOk()) {
		ALOGE("Failed to clear logical address.");
		}
		}

		int HdmiCecController::getPhysicalAddress() {
		Result result;
		uint16_t addr;
		Return<void> ret = mHdmiCec->getPhysicalAddress([&result, &addr](Result res, uint16_t paddr) {
		result = res;
		addr = paddr;
		});
		if (!ret.isOk()) {
		ALOGE("Failed to get physical address.");
		return INVALID_PHYSICAL_ADDRESS;
		}
		return result == Result::SUCCESS ? addr : INVALID_PHYSICAL_ADDRESS;
		}

		int HdmiCecController::getVersion() {
		Return<int32_t> ret = mHdmiCec->getCecVersion();
		if (!ret.isOk()) {
		ALOGE("Failed to get cec version.");
		}
		return ret;
		}

		uint32_t HdmiCecController::getVendorId() {
		Return<uint32_t> ret = mHdmiCec->getVendorId();
		if (!ret.isOk()) {
		ALOGE("Failed to get vendor id.");
		}
		return ret;
		}

		jobjectArray HdmiCecController::getPortInfos() {
		JNIEnv* env = AndroidRuntime::getJNIEnv();
		jclass hdmiPortInfo = env->FindClass("android/hardware/hdmi/HdmiPortInfo");
		if (hdmiPortInfo == NULL) {
		return NULL;
		}
		jmethodID ctor = env->GetMethodID(hdmiPortInfo, "<init>", "(IIIZZZ)V");
		if (ctor == NULL) {
		return NULL;
		}
		hidl_vec<HdmiPortInfo> ports;
		Return<void> ret = mHdmiCec->getPortInfo([&ports](hidl_vec<HdmiPortInfo> list) {
		ports = list;
		});
		if (!ret.isOk()) {
		ALOGE("Failed to get port information.");
		return NULL;
		}
		jobjectArray res = env->NewObjectArray(ports.size(), hdmiPortInfo, NULL);

		// MHL support field will be obtained from MHL HAL. Leave it to false.
		jboolean mhlSupported = (jboolean) 0;
		for (size_t i = 0; i < ports.size(); ++i) {
		jboolean cecSupported = (jboolean) ports[i].cecSupported;
		jboolean arcSupported = (jboolean) ports[i].arcSupported;
		jobject infoObj = env->NewObject(hdmiPortInfo, ctor, ports[i].portId, ports[i].type,
		ports[i].physicalAddress, cecSupported, mhlSupported, arcSupported);
		env->SetObjectArrayElement(res, i, infoObj);
		}
		return res;
		}

		void HdmiCecController::setOption(OptionKey key, bool enabled) {
		Return<void> ret = mHdmiCec->setOption(key, enabled);
		if (!ret.isOk()) {
		ALOGE("Failed to set option.");
		}
		}

		void HdmiCecController::setLanguage(hidl_string language) {
		Return<void> ret = mHdmiCec->setLanguage(language);
		if (!ret.isOk()) {
		ALOGE("Failed to set language.");
		}
		}

		// Enable audio return channel.
		void HdmiCecController::enableAudioReturnChannel(int port, bool enabled) {
		Return<void> ret = mHdmiCec->enableAudioReturnChannel(port, enabled);
		if (!ret.isOk()) {
		ALOGE("Failed to enable/disable ARC.");
		}
		}

		// Whether to hdmi device is connected to the given port.
		bool HdmiCecController::isConnected(int port) {
		Return<bool> ret = mHdmiCec->isConnected(port);
		if (!ret.isOk()) {
		ALOGE("Failed to get connection info.");
		}
		return ret;
		}

		Return<void> HdmiCecController::HdmiCecCallback::onCecMessage(const CecMessage& message) {
		sp<HdmiCecEventHandler> handler(new HdmiCecEventHandler(mController, message));
		mController->mLooper->sendMessage(handler, HdmiCecEventHandler::EventType::CEC_MESSAGE);
		return Void();
		}

		Return<void> HdmiCecController::HdmiCecCallback::onHotplugEvent(const HotplugEvent& event) {
		sp<HdmiCecEventHandler> handler(new HdmiCecEventHandler(mController, event));
		mController->mLooper->sendMessage(handler, HdmiCecEventHandler::EventType::HOT_PLUG);
		return Void();
		}

		//------------------------------------------------------------------------------
		#define GET_METHOD_ID(var, clazz, methodName, methodDescriptor) \
		var = env->GetMethodID(clazz, methodName, methodDescriptor); \
		LOG_FATAL_IF(! (var), "Unable to find method " methodName);

		static jlong nativeInit(JNIEnv* env, jclass clazz, jobject callbacksObj,
		jobject messageQueueObj) {
		// TODO(b/31632518)
		sp<IHdmiCec> hdmiCec = IHdmiCec::getService();
		if (hdmiCec == nullptr) {
		ALOGE("Couldn't get tv.cec service.");
		return 0;
		}
		sp<MessageQueue> messageQueue =
		android_os_MessageQueue_getMessageQueue(env, messageQueueObj);

		HdmiCecController* controller = new HdmiCecController(
		hdmiCec,
		env->NewGlobalRef(callbacksObj),
		messageQueue->getLooper());

		GET_METHOD_ID(gHdmiCecControllerClassInfo.handleIncomingCecCommand, clazz,
		"handleIncomingCecCommand", "(II[B)V");
		GET_METHOD_ID(gHdmiCecControllerClassInfo.handleHotplug, clazz,
		"handleHotplug", "(IZ)V");

		return reinterpret_cast<jlong>(controller);
		}

		static jint nativeSendCecCommand(JNIEnv* env, jclass clazz, jlong controllerPtr,
		jint srcAddr, jint dstAddr, jbyteArray body) {
		CecMessage message;
		message.initiator = static_cast<CecLogicalAddress>(srcAddr);
		message.destination = static_cast<CecLogicalAddress>(dstAddr);

		jsize len = env->GetArrayLength(body);
		ScopedByteArrayRO bodyPtr(env, body);
		size_t bodyLength = MIN(static_cast<size_t>(len),
		static_cast<size_t>(MaxLength::MESSAGE_BODY));
		message.body.resize(bodyLength);
		for (size_t i = 0; i < bodyLength; ++i) {
		message.body[i] = static_cast<uint8_t>(bodyPtr[i]);
		}

		HdmiCecController* controller =
		reinterpret_cast<HdmiCecController*>(controllerPtr);
		return controller->sendMessage(message);
		}

		static jint nativeAddLogicalAddress(JNIEnv* env, jclass clazz, jlong controllerPtr,
		jint logicalAddress) {
		HdmiCecController* controller = reinterpret_cast<HdmiCecController*>(controllerPtr);
		return controller->addLogicalAddress(static_cast<CecLogicalAddress>(logicalAddress));
		}

		static void nativeClearLogicalAddress(JNIEnv* env, jclass clazz, jlong controllerPtr) {
		HdmiCecController* controller = reinterpret_cast<HdmiCecController*>(controllerPtr);
		controller->clearLogicaladdress();
		}

		static jint nativeGetPhysicalAddress(JNIEnv* env, jclass clazz, jlong controllerPtr) {
		HdmiCecController* controller = reinterpret_cast<HdmiCecController*>(controllerPtr);
		return controller->getPhysicalAddress();
		}

		static jint nativeGetVersion(JNIEnv* env, jclass clazz, jlong controllerPtr) {
		HdmiCecController* controller = reinterpret_cast<HdmiCecController*>(controllerPtr);
		return controller->getVersion();
		}

		static jint nativeGetVendorId(JNIEnv* env, jclass clazz, jlong controllerPtr) {
		HdmiCecController* controller = reinterpret_cast<HdmiCecController*>(controllerPtr);
		return controller->getVendorId();
		}

		static jobjectArray nativeGetPortInfos(JNIEnv* env, jclass clazz, jlong controllerPtr) {
		HdmiCecController* controller = reinterpret_cast<HdmiCecController*>(controllerPtr);
		return controller->getPortInfos();
		}

		static void nativeSetOption(JNIEnv* env, jclass clazz, jlong controllerPtr, jint flag, jint value) {
		HdmiCecController* controller = reinterpret_cast<HdmiCecController*>(controllerPtr);
		controller->setOption(static_cast<OptionKey>(flag), value > 0 ? true : false);
		}

		static void nativeSetLanguage(JNIEnv* env, jclass clazz, jlong controllerPtr, jstring language) {
		HdmiCecController* controller = reinterpret_cast<HdmiCecController*>(controllerPtr);
		const char *languageStr = env->GetStringUTFChars(language, NULL);
		controller->setLanguage(languageStr);
		env->ReleaseStringUTFChars(language, languageStr);
		}

		static void nativeEnableAudioReturnChannel(JNIEnv* env, jclass clazz, jlong controllerPtr,
		jint port, jboolean enabled) {
		HdmiCecController* controller = reinterpret_cast<HdmiCecController*>(controllerPtr);
		controller->enableAudioReturnChannel(port, enabled == JNI_TRUE);
		}

		static jboolean nativeIsConnected(JNIEnv* env, jclass clazz, jlong controllerPtr, jint port) {
		HdmiCecController* controller = reinterpret_cast<HdmiCecController*>(controllerPtr);
		return controller->isConnected(port) ? JNI_TRUE : JNI_FALSE ;
		}

		static const JNINativeMethod sMethods[] = {
		/* name, signature, funcPtr */
		{ "nativeInit",
		"(Lcom/android/server/hdmi/HdmiCecController;Landroid/os/MessageQueue;)J",
		(void *) nativeInit },
		{ "nativeSendCecCommand", "(JII[B)I", (void *) nativeSendCecCommand },
		{ "nativeAddLogicalAddress", "(JI)I", (void *) nativeAddLogicalAddress },
		{ "nativeClearLogicalAddress", "(J)V", (void *) nativeClearLogicalAddress },
		{ "nativeGetPhysicalAddress", "(J)I", (void *) nativeGetPhysicalAddress },
		{ "nativeGetVersion", "(J)I", (void *) nativeGetVersion },
		{ "nativeGetVendorId", "(J)I", (void *) nativeGetVendorId },
		{ "nativeGetPortInfos",
		"(J)[Landroid/hardware/hdmi/HdmiPortInfo;",
		(void *) nativeGetPortInfos },
		{ "nativeSetOption", "(JIZ)V", (void *) nativeSetOption },
		{ "nativeSetLanguage", "(JLjava/lang/String;)V", (void *) nativeSetLanguage },
		{ "nativeEnableAudioReturnChannel", "(JIZ)V", (void *) nativeEnableAudioReturnChannel },
		{ "nativeIsConnected", "(JI)Z", (void *) nativeIsConnected },
		};

		#define CLASS_PATH "com/android/server/hdmi/HdmiCecController"

		int register_android_server_hdmi_HdmiCecController(JNIEnv* env) {
		int res = jniRegisterNativeMethods(env, CLASS_PATH, sMethods, NELEM(sMethods));
		LOG_FATAL_IF(res < 0, "Unable to register native methods.");
		(void)res; // Don't scream about unused variable in the LOG_NDEBUG case
		return 0;
		}

		} /* namespace android */

services/core/jni/onload.cpp

+0 −2

Original line number	Diff line number	Diff line
		@@ -42,7 +42,6 @@ int register_android_server_location_GnssLocationProvider(JNIEnv* env);
		int register_android_server_connectivity_Vpn(JNIEnv* env);
		int register_android_server_TestNetworkService(JNIEnv* env);
		int register_android_server_devicepolicy_CryptoTestHelper(JNIEnv*);
		int register_android_server_hdmi_HdmiCecController(JNIEnv* env);
		int register_android_server_tv_TvUinputBridge(JNIEnv* env);
		int register_android_server_tv_TvInputHal(JNIEnv* env);
		int register_android_server_PersistentDataBlockService(JNIEnv* env);
		@@ -92,7 +91,6 @@ extern "C" jint JNI_OnLoad(JavaVM* vm, void* /* reserved */)
		register_android_server_devicepolicy_CryptoTestHelper(env);
		register_android_server_ConsumerIrService(env);
		register_android_server_BatteryStatsService(env);
		register_android_server_hdmi_HdmiCecController(env);
		register_android_server_tv_TvUinputBridge(env);
		register_android_server_tv_TvInputHal(env);
		register_android_server_PersistentDataBlockService(env);