Merge "Remove unused HdmiCecController jni library"

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

@@ -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

@@ -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

@@ -1,463 +0,0 @@
-/*
- * 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

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