Merge "Remove unused HdmiCecController jni library"

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;

        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;

        "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",

        "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",

/*

 * 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 */

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

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