cec: convert to aidl

* Use hardware/interfaces/tv/hdmi/cec/aidl/ as reference.

cec/Android.bp

@@ -4,23 +4,22 @@
 // SPDX-License-Identifier: Apache-2.0
 
 cc_binary {
-    name: "android.hardware.tv.cec@1.0-service.rpi",
+    name: "android.hardware.tv.hdmi.cec-service.rpi",
     relative_install_path: "hw",
-    init_rc: ["android.hardware.tv.cec@1.0-service.rpi.rc"],
-    vintf_fragments: ["android.hardware.tv.cec@1.0-service.rpi.xml"],
+    init_rc: ["android.hardware.tv.hdmi.cec-service.rpi.rc"],
+    vintf_fragments: ["android.hardware.tv.hdmi.cec-service.rpi.xml"],
     vendor: true,
     srcs: [
         "HdmiCec.cpp",
         "HdmiCecPort.cpp",
-        "service.cpp",
+        "main.cpp",
     ],
     shared_libs: [
-        "android.hardware.tv.cec@1.0",
+        "android.hardware.tv.hdmi.cec-V1-ndk",
         "libbase",
+        "libbinder_ndk",
         "libcutils",
         "libhardware",
-        "libhidlbase",
         "liblog",
-        "libutils",
     ],
 }

cec/HdmiCec.cpp

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-#define LOG_TAG "android.hardware.tv.cec@1.0-service.rpi"
+#define LOG_TAG "android.hardware.tv.hdmi.cec-service.rpi"
 
 #include <android-base/logging.h>
 #include <android-base/properties.h>
@@ -33,16 +33,17 @@
 #define PROPERTY_CEC_VERSION "ro.hdmi.cec_version"
 #define PROPERTY_VENDOR_ID "ro.hdmi.vendor_id"
 
+using android::base::GetProperty;
+using ndk::ScopedAStatus;
+using std::string;
+
 namespace android {
 namespace hardware {
 namespace tv {
+namespace hdmi {
 namespace cec {
-namespace V1_0 {
 namespace implementation {
 
-using android::base::GetProperty;
-using std::string;
-
 HdmiCec::HdmiCec() {
     mCecEnabled = false;
     mWakeupEnabled = false;
@@ -59,18 +60,19 @@ HdmiCec::~HdmiCec() {
     release();
 }
 
-// Methods from ::android::hardware::tv::cec::V1_0::IHdmiCec follow.
-Return<Result> HdmiCec::addLogicalAddress(CecLogicalAddress addr) {
+ScopedAStatus HdmiCec::addLogicalAddress(CecLogicalAddress addr, Result* _aidl_return) {
     if (addr < CecLogicalAddress::TV || addr >= CecLogicalAddress::BROADCAST) {
         LOG(ERROR) << "Add logical address failed, Invalid address";
-        return Result::FAILURE_INVALID_ARGS;
+        *_aidl_return = Result::FAILURE_INVALID_ARGS;
+        return ScopedAStatus::ok();
     }
 
     cec_log_addrs cecLogAddrs;
     int ret = ioctl(mHdmiCecPorts[0]->mCecFd, CEC_ADAP_G_LOG_ADDRS, &cecLogAddrs);
     if (ret) {
         LOG(ERROR) << "Add logical address failed, Error = " << strerror(errno);
-        return Result::FAILURE_BUSY;
+        *_aidl_return = Result::FAILURE_BUSY;
+        return ScopedAStatus::ok();
     }
 
     cecLogAddrs.cec_version = getCecVersion();
@@ -121,6 +123,9 @@ Return<Result> HdmiCec::addLogicalAddress(CecLogicalAddress addr) {
         case CecLogicalAddress::UNREGISTERED:
             cecLogAddrs.flags |= CEC_LOG_ADDRS_FL_ALLOW_UNREG_FALLBACK;
             break;
+        case CecLogicalAddress::BACKUP_1:
+        case CecLogicalAddress::BACKUP_2:
+            break;
     }
 
     int logAddrIndex = cecLogAddrs.num_log_addrs;
@@ -136,13 +141,15 @@ Return<Result> HdmiCec::addLogicalAddress(CecLogicalAddress addr) {
     if (ret) {
         LOG(ERROR) << "Add logical address failed for port " << mHdmiCecPorts[0]->mPortId
                    << ", Error = " << strerror(errno);
-        return Result::FAILURE_BUSY;
+        *_aidl_return = Result::FAILURE_BUSY;
+        return ScopedAStatus::ok();
     }
 
-    return Result::SUCCESS;
+    *_aidl_return = Result::SUCCESS;
+    return ScopedAStatus::ok();
 }
 
-Return<void> HdmiCec::clearLogicalAddress() {
+ScopedAStatus HdmiCec::clearLogicalAddress() {
     cec_log_addrs cecLogAddrs;
     memset(&cecLogAddrs, 0, sizeof(cecLogAddrs));
 
@@ -152,27 +159,49 @@ Return<void> HdmiCec::clearLogicalAddress() {
                    << ", Error = " << strerror(errno);
     }
 
-    return Void();
+    return ScopedAStatus::ok();
 }
 
-Return<void> HdmiCec::getPhysicalAddress(getPhysicalAddress_cb callback) {
+ScopedAStatus HdmiCec::enableAudioReturnChannel(int32_t portId __unused, bool enable __unused) {
+    return ScopedAStatus::ok();
+}
+
+int32_t HdmiCec::getCecVersion() {
+    return property_get_int32(PROPERTY_CEC_VERSION, CEC_OP_CEC_VERSION_1_4);
+}
+
+ScopedAStatus HdmiCec::getCecVersion(int32_t* _aidl_return) {
+    *_aidl_return = getCecVersion();
+    return ScopedAStatus::ok();
+}
+
+ScopedAStatus HdmiCec::getPhysicalAddress(int32_t* _aidl_return) {
     uint16_t addr;
 
     int ret = ioctl(mHdmiCecPorts[0]->mCecFd, CEC_ADAP_G_PHYS_ADDR, &addr);
     if (ret) {
         LOG(ERROR) << "Get physical address failed, Error = " << strerror(errno);
-        callback(Result::FAILURE_INVALID_STATE, addr);
-        return Void();
+        return ScopedAStatus::fromServiceSpecificError(
+                static_cast<int32_t>(Result::FAILURE_INVALID_STATE));
     }
 
-    callback(Result::SUCCESS, addr);
-
-    return Void();
+    *_aidl_return = addr;
+    return ScopedAStatus::ok();
 }
 
-Return<SendMessageResult> HdmiCec::sendMessage(const CecMessage& message) {
+uint32_t HdmiCec::getVendorId() {
+    return property_get_int32(PROPERTY_VENDOR_ID, 0x000c03 /* HDMI LLC vendor ID */);
+}
+
+ScopedAStatus HdmiCec::getVendorId(int32_t* _aidl_return) {
+    *_aidl_return = getVendorId();
+    return ScopedAStatus::ok();
+}
+
+ScopedAStatus HdmiCec::sendMessage(const CecMessage& message, SendMessageResult* _aidl_return) {
     if (!mCecEnabled) {
-        return SendMessageResult::FAIL;
+        *_aidl_return = SendMessageResult::FAIL;
+        return ScopedAStatus::ok();
     }
 
     cec_msg cecMsg;
@@ -190,104 +219,51 @@ Return<SendMessageResult> HdmiCec::sendMessage(const CecMessage& message) {
     int ret = ioctl(mHdmiCecPorts[0]->mCecFd, CEC_TRANSMIT, &cecMsg);
     if (ret) {
         LOG(ERROR) << "Send message failed, Error = " << strerror(errno);
-        return SendMessageResult::FAIL;
+        *_aidl_return = SendMessageResult::FAIL;
+        return ScopedAStatus::ok();
     }
 
     if (cecMsg.tx_status != CEC_TX_STATUS_OK) {
         LOG(ERROR) << "Send message tx_status = " << cecMsg.tx_status;
     }
 
-    return getSendMessageResult(cecMsg.tx_status);
+    *_aidl_return = getSendMessageResult(cecMsg.tx_status);
+    return ScopedAStatus::ok();
 }
 
-Return<void> HdmiCec::setCallback(const sp<IHdmiCecCallback>& callback) {
+ScopedAStatus HdmiCec::setCallback(const std::shared_ptr<IHdmiCecCallback>& callback) {
     if (mCallback != nullptr) {
-        mCallback->unlinkToDeath(this);
         mCallback = nullptr;
     }
 
     if (callback != nullptr) {
         mCallback = callback;
-        mCallback->linkToDeath(this, 0 /*cookie*/);
     }
 
-    return Void();
+    return ScopedAStatus::ok();
 }
 
-Return<int32_t> HdmiCec::getCecVersion() {
-    return property_get_int32(PROPERTY_CEC_VERSION, CEC_OP_CEC_VERSION_1_4);
+ScopedAStatus HdmiCec::setLanguage(const std::string& language __unused) {
+    return ScopedAStatus::ok();
 }
 
-Return<uint32_t> HdmiCec::getVendorId() {
-    return property_get_int32(PROPERTY_VENDOR_ID, 0x000c03 /* HDMI LLC vendor ID */);
-}
-
-Return<void> HdmiCec::getPortInfo(getPortInfo_cb callback) {
-    uint16_t addr = CEC_PHYS_ADDR_INVALID;
-
-    int ret = ioctl(mHdmiCecPorts[0]->mCecFd, CEC_ADAP_G_PHYS_ADDR, &addr);
-    if (ret) {
-        LOG(ERROR) << "Get port info failed for port : " << mHdmiCecPorts[0]->mPortId
-                   << ", Error = " << strerror(errno);
-    }
-
-    hidl_vec<HdmiPortInfo> portInfos {
-        {.type = HdmiPortType::OUTPUT,
-         .portId = mHdmiCecPorts[0]->mPortId,
-         .cecSupported = true,
-         .arcSupported = false,
-         .physicalAddress = addr}
-    };
-    callback(portInfos);
-
-    return Void();
-}
-
-Return<void> HdmiCec::setOption(OptionKey key, bool value) {
-    switch (key) {
-        case OptionKey::ENABLE_CEC:
-            LOG(DEBUG) << "setOption: Enable CEC: " << value;
-            mCecEnabled = value;
-            break;
-        case OptionKey::WAKEUP:
-            LOG(DEBUG) << "setOption: WAKEUP: " << value;
+ScopedAStatus HdmiCec::enableWakeupByOtp(bool value) {
     mWakeupEnabled = value;
-            break;
-        case OptionKey::SYSTEM_CEC_CONTROL:
-            LOG(DEBUG) << "setOption: SYSTEM_CEC_CONTROL: " << value;
+    return ScopedAStatus::ok();
+}
+
+ScopedAStatus HdmiCec::enableCec(bool value) {
+    mCecEnabled = value;
+    return ScopedAStatus::ok();
+}
+
+ScopedAStatus HdmiCec::enableSystemCecControl(bool value) {
     mCecControlEnabled = value;
-            break;
-    }
-
-    return Void();
-}
-
-Return<void> HdmiCec::setLanguage(const hidl_string& language __unused) {
-    return Void();
-}
-
-Return<void> HdmiCec::enableAudioReturnChannel(int32_t portId __unused, bool enable __unused) {
-    return Void();
-}
-
-Return<bool> HdmiCec::isConnected(int32_t portId __unused) {
-    uint16_t addr = CEC_PHYS_ADDR_INVALID;
-
-    int ret = ioctl(mHdmiCecPorts[0]->mCecFd, CEC_ADAP_G_PHYS_ADDR, &addr);
-    if (ret) {
-        LOG(ERROR) << "Is connected failed, Error = " << strerror(errno);
-        return false;
-    }
-
-    if (addr == CEC_PHYS_ADDR_INVALID) {
-        return false;
-    }
-
-    return true;
+    return ScopedAStatus::ok();
 }
 
 // Initialise the cec file descriptor
-Return<Result> HdmiCec::init() {
+Result HdmiCec::init() {
     string cecDevice = GetProperty(PROPERTY_CEC_DEVICE, "cec0");
     if (cecDevice != "cec0" && cecDevice != "cec1") {
         LOG(ERROR) << "Invalid CEC device " << cecDevice;
@@ -315,7 +291,7 @@ Return<Result> HdmiCec::init() {
     return Result::SUCCESS;
 }
 
-Return<void> HdmiCec::release() {
+void HdmiCec::release() {
     mCecEnabled = false;
     mWakeupEnabled = false;
     mCecControlEnabled = false;
@@ -328,8 +304,6 @@ Return<void> HdmiCec::release() {
     setCallback(nullptr);
     mHdmiCecPorts.clear();
     mEventThreads.clear();
-
-    return Void();
 }
 
 void HdmiCec::event_thread(HdmiCecPort* hdmiCecPort) {
@@ -367,6 +341,7 @@ void HdmiCec::event_thread(HdmiCecPort* hdmiCecPort) {
                 continue;
             }
 
+/*
             if (ev.event == CEC_EVENT_STATE_CHANGE) {
                 if (mCallback != nullptr) {
                     HotplugEvent hotplugEvent{
@@ -377,6 +352,7 @@ void HdmiCec::event_thread(HdmiCecPort* hdmiCecPort) {
                     LOG(ERROR) << "No event callback for hotplug";
                 }
             }
+*/
         }
 
         if (ufds[0].revents == POLLIN) { /* CEC Driver */
@@ -408,7 +384,7 @@ void HdmiCec::event_thread(HdmiCecPort* hdmiCecPort) {
             }
 
             if (mCallback != nullptr) {
-                size_t length = std::min(msg.len - 1, (uint32_t)MaxLength::MESSAGE_BODY);
+                size_t length = std::min(msg.len - 1, (uint32_t)(CEC_MESSAGE_BODY_MAX_LENGTH - 1));
                 CecMessage cecMessage{
                         .initiator = static_cast<CecLogicalAddress>(msg.msg[0] >> 4),
                         .destination = static_cast<CecLogicalAddress>(msg.msg[0] & 0xf),
@@ -483,7 +459,7 @@ bool HdmiCec::isPowerUICommand(cec_msg message) {
     }
 }
 
-Return<SendMessageResult> HdmiCec::getSendMessageResult(int tx_status) {
+SendMessageResult HdmiCec::getSendMessageResult(int tx_status) {
     switch (tx_status) {
         case CEC_TX_STATUS_OK:
             return SendMessageResult::SUCCESS;
@@ -497,8 +473,8 @@ Return<SendMessageResult> HdmiCec::getSendMessageResult(int tx_status) {
 }
 
 }  // namespace implementation
-}  // namespace V1_0
 }  // namespace cec
+}  // namespace hdmi
 }  // namespace tv
 }  // namespace hardware
 }  // namespace android

cec/HdmiCec.h

@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 
+#include <aidl/android/hardware/tv/hdmi/cec/BnHdmiCec.h>
 #include <hardware/hdmi_cec.h>
 #include <linux/cec.h>
 #include <thread>
@@ -24,38 +25,42 @@
 namespace android {
 namespace hardware {
 namespace tv {
+namespace hdmi {
 namespace cec {
-namespace V1_0 {
 namespace implementation {
 
 using std::shared_ptr;
 using std::thread;
 using std::vector;
 
-class HdmiCec : public IHdmiCec, public hidl_death_recipient {
+using ::aidl::android::hardware::tv::hdmi::cec::BnHdmiCec;
+using ::aidl::android::hardware::tv::hdmi::cec::CecLogicalAddress;
+using ::aidl::android::hardware::tv::hdmi::cec::CecMessage;
+using ::aidl::android::hardware::tv::hdmi::cec::IHdmiCec;
+using ::aidl::android::hardware::tv::hdmi::cec::IHdmiCecCallback;
+using ::aidl::android::hardware::tv::hdmi::cec::Result;
+using ::aidl::android::hardware::tv::hdmi::cec::SendMessageResult;
+
+struct HdmiCec : public BnHdmiCec {
   public:
     HdmiCec();
     ~HdmiCec();
-    // Methods from ::android::hardware::tv::cec::V1_0::IHdmiCec follow.
-    Return<Result> addLogicalAddress(CecLogicalAddress addr) override;
-    Return<void> clearLogicalAddress() override;
-    Return<void> getPhysicalAddress(getPhysicalAddress_cb _hidl_cb) override;
-    Return<SendMessageResult> sendMessage(const CecMessage& message) override;
-    Return<void> setCallback(const sp<IHdmiCecCallback>& callback) override;
-    Return<int32_t> getCecVersion() override;
-    Return<uint32_t> getVendorId() override;
-    Return<void> getPortInfo(getPortInfo_cb _hidl_cb) override;
-    Return<void> setOption(OptionKey key, bool value) override;
-    Return<void> setLanguage(const hidl_string& language) override;
-    Return<void> enableAudioReturnChannel(int32_t portId, bool enable) override;
-    Return<bool> isConnected(int32_t portId) override;
+    ::ndk::ScopedAStatus addLogicalAddress(CecLogicalAddress addr, Result* _aidl_return) override;
+    ::ndk::ScopedAStatus clearLogicalAddress() override;
+    ::ndk::ScopedAStatus enableAudioReturnChannel(int32_t portId, bool enable) override;
+    ::ndk::ScopedAStatus getCecVersion(int32_t* _aidl_return) override;
+    ::ndk::ScopedAStatus getPhysicalAddress(int32_t* _aidl_return) override;
+    ::ndk::ScopedAStatus getVendorId(int32_t* _aidl_return) override;
+    ::ndk::ScopedAStatus sendMessage(const CecMessage& message,
+                                     SendMessageResult* _aidl_return) override;
+    ::ndk::ScopedAStatus setCallback(const std::shared_ptr<IHdmiCecCallback>& callback) override;
+    ::ndk::ScopedAStatus setLanguage(const std::string& language) override;
+    ::ndk::ScopedAStatus enableWakeupByOtp(bool value) override;
+    ::ndk::ScopedAStatus enableCec(bool value) override;
+    ::ndk::ScopedAStatus enableSystemCecControl(bool value) override;
 
-    virtual void serviceDied(uint64_t, const wp<::android::hidl::base::V1_0::IBase>&) {
-        setCallback(nullptr);
-    }
-
-    Return<Result> init();
-    Return<void> release();
+    Result init();
+    void release();
 
   private:
     void event_thread(HdmiCecPort* hdmiCecPort);
@@ -64,7 +69,7 @@ class HdmiCec : public IHdmiCec, public hidl_death_recipient {
     static bool isWakeupMessage(cec_msg message);
     static bool isTransferableInSleep(cec_msg message);
     static bool isPowerUICommand(cec_msg message);
-    static Return<SendMessageResult> getSendMessageResult(int tx_status);
+    static SendMessageResult getSendMessageResult(int tx_status);
 
     vector<thread> mEventThreads;
     vector<shared_ptr<HdmiCecPort>> mHdmiCecPorts;
@@ -84,12 +89,15 @@ class HdmiCec : public IHdmiCec, public hidl_death_recipient {
      */
     bool mCecControlEnabled;
 
-    sp<IHdmiCecCallback> mCallback;
+    int32_t getCecVersion();
+    uint32_t getVendorId();
+
+    std::shared_ptr<IHdmiCecCallback> mCallback;
 };
 
 }  // namespace implementation
-}  // namespace V1_0
 }  // namespace cec
+}  // namespace hdmi
 }  // namespace tv
 }  // namespace hardware
 }  // namespace android

cec/HdmiCecPort.cpp

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-#define LOG_TAG "android.hardware.tv.cec@1.0-service.rpi"
+#define LOG_TAG "android.hardware.tv.hdmi.cec-service.rpi"
 
 #include <android-base/logging.h>
 #include <errno.h>
@@ -29,8 +29,8 @@
 namespace android {
 namespace hardware {
 namespace tv {
+namespace hdmi {
 namespace cec {
-namespace V1_0 {
 namespace implementation {
 
 HdmiCecPort::HdmiCecPort(unsigned int portId) {
@@ -44,7 +44,7 @@ HdmiCecPort::~HdmiCecPort() {
 }
 
 // Initialise the cec file descriptor
-Return<Result> HdmiCecPort::init(const char* path) {
+Result HdmiCecPort::init(const char* path) {
     mCecFd = open(path, O_RDWR);
     if (mCecFd < 0) {
         LOG(ERROR) << "Failed to open " << path << ", Error = " << strerror(errno);
@@ -82,7 +82,7 @@ Return<Result> HdmiCecPort::init(const char* path) {
     return Result::SUCCESS;
 }
 
-Return<void> HdmiCecPort::release() {
+void HdmiCecPort::release() {
     if (mExitFd > 0) {
         uint64_t tmp = 1;
         write(mExitFd, &tmp, sizeof(tmp));
@@ -93,12 +93,11 @@ Return<void> HdmiCecPort::release() {
     if (mCecFd > 0) {
         close(mCecFd);
     }
-    return Void();
 }
 
 }  // namespace implementation
-}  // namespace V1_0
 }  // namespace cec
+}  // namespace hdmi
 }  // namespace tv
 }  // namespace hardware
 }  // namespace android

cec/HdmiCecPort.h

@@ -15,21 +15,23 @@
  * limitations under the License.
  */
 
-#include <android/hardware/tv/cec/1.0/IHdmiCec.h>
+#include <aidl/android/hardware/tv/hdmi/cec/BnHdmiCec.h>
 
 namespace android {
 namespace hardware {
 namespace tv {
+namespace hdmi {
 namespace cec {
-namespace V1_0 {
 namespace implementation {
 
+using ::aidl::android::hardware::tv::hdmi::cec::Result;
+
 class HdmiCecPort {
   public:
     HdmiCecPort(unsigned int portId);
     ~HdmiCecPort();
-    Return<Result> init(const char* path);
-    Return<void> release();
+    Result init(const char* path);
+    void release();
 
     unsigned int mPortId;
     int mCecFd;
@@ -37,8 +39,8 @@ class HdmiCecPort {
 };
 
 }  // namespace implementation
-}  // namespace V1_0
 }  // namespace cec
+}  // namespace hdmi
 }  // namespace tv
 }  // namespace hardware
 }  // namespace android

cec/android.hardware.tv.cec@1.0-service.rpi.rc

@@ -1,5 +0,0 @@
-service vendor.cec-hal-1-0-rpi /vendor/bin/hw/android.hardware.tv.cec@1.0-service.rpi
-    interface android.hardware.tv.cec@1.0::IHdmiCec default
-    class hal
-    user system
-    group system

cec/android.hardware.tv.hdmi.cec-service.rpi.rc

@@ -0,0 +1,5 @@
+service vendor.cec-default /vendor/bin/hw/android.hardware.tv.hdmi.cec-service.rpi
+    interface aidl android.hardware.tv.hdmi.cec.IHdmiCec/default
+    class hal
+    user system
+    group system

cec/android.hardware.tv.hdmi.cec-service.rpi.xml

@@ -1,8 +1,7 @@
 <manifest version="1.0" type="device">
-    <hal format="hidl">
-        <name>android.hardware.tv.cec</name>
-        <transport>hwbinder</transport>
-        <version>1.0</version>
+    <hal format="aidl">
+        <name>android.hardware.tv.hdmi.cec</name>
+        <version>1</version>
         <interface>
             <name>IHdmiCec</name>
             <instance>default</instance>

cec/main.cpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2025 KonstaKANG
+ *
+ * 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 "HdmiCec.h"
+
+#include <android-base/logging.h>
+#include <android/binder_manager.h>
+#include <android/binder_process.h>
+
+using android::hardware::tv::hdmi::cec::implementation::HdmiCec;
+
+int main() {
+    ABinderProcess_setThreadPoolMaxThreadCount(1);
+    ABinderProcess_startThreadPool();
+
+    std::shared_ptr<HdmiCec> hdmiCecAidl = ndk::SharedRefBase::make<HdmiCec>();
+    const std::string instance = std::string() + HdmiCec::descriptor + "/default";
+    binder_status_t status = AServiceManager_addService(hdmiCecAidl->asBinder().get(), instance.c_str());
+    CHECK_EQ(status, STATUS_OK);
+
+    ABinderProcess_joinThreadPool();
+    return EXIT_FAILURE;  // should not reach
+}

cec/service.cpp

@@ -1,49 +0,0 @@
-/*
- * Copyright (C) 2019 The Android Open Source Project
- * Copyright (C) 2025 KonstaKANG
- *
- * 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 "android.hardware.tv.cec@1.0-service-rpi"
-
-#include <android/hardware/tv/cec/1.0/IHdmiCec.h>
-#include <hidl/LegacySupport.h>
-#include "HdmiCec.h"
-
-using android::hardware::configureRpcThreadpool;
-using android::hardware::joinRpcThreadpool;
-using android::hardware::tv::cec::V1_0::IHdmiCec;
-using android::hardware::tv::cec::V1_0::implementation::HdmiCec;
-
-using android::OK;
-using android::status_t;
-
-int main() {
-    configureRpcThreadpool(1, true /* callerWillJoin */);
-
-    android::sp<IHdmiCec> service = new HdmiCec();
-
-    status_t status = service->registerAsService();
-    if (status != OK) {
-        ALOGE("Cannot register HDMI-CEC HAL service.");
-        return 1;
-    }
-
-    ALOGI("HDMI-CEC HAL ready.");
-    joinRpcThreadpool();
-
-    // Under normal cases, execution will not reach this line.
-    ALOGE("HDMI-CEC HAL failed to join thread pool.");
-    return 1;
-}

device.mk

@@ -138,7 +138,7 @@ PRODUCT_COPY_FILES += \
 
 # CEC
 PRODUCT_PACKAGES += \
-    android.hardware.tv.cec@1.0-service.rpi
+    android.hardware.tv.hdmi.cec-service.rpi
 
 PRODUCT_COPY_FILES += \
     frameworks/native/data/etc/android.hardware.hdmi.cec.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.hdmi.cec.xml

sepolicy/file_contexts

@@ -4,7 +4,7 @@
 # CEC
 /dev/cec0                                                                    u:object_r:cec_device:s0
 /dev/cec1                                                                    u:object_r:cec_device:s0
-/vendor/bin/hw/android\.hardware\.tv\.cec@1\.0-service\.rpi                  u:object_r:hal_tv_cec_default_exec:s0
+/vendor/bin/hw/android\.hardware\.tv\.hdmi\.cec-service\.rpi                 u:object_r:hal_tv_hdmi_cec_default_exec:s0
 
 # DRM
 /data/vendor/mediadrm(/.*)?                                                  u:object_r:mediadrm_vendor_data_file:s0

sepolicy/hal_tv_cec_default.te

@@ -1 +0,0 @@
-allow hal_tv_cec_default cec_device:chr_file rw_file_perms;

sepolicy/hal_tv_hdmi_cec_default.te

@@ -0,0 +1 @@
+allow hal_tv_hdmi_cec_default cec_device:chr_file rw_file_perms;