node-libcec 1.0.0

package/src/native/cec_adapter.cc

@@ -0,0 +1,909 @@
+#include "cec_adapter.h"
+#include "cec_callbacks.h"
+#include <cstring>
+
+Napi::FunctionReference CECAdapter::constructor;
+
+CECAdapter::CECAdapter(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<CECAdapter>(info), adapter_(nullptr), isOpen_(false) {
+    Napi::Env env = info.Env();
+
+    // Initialize configuration with defaults
+    config_.Clear();
+
+    // Set device name
+    std::string deviceName = "node-libcec";
+    if (info.Length() > 0 && info[0].IsObject()) {
+        Napi::Object options = info[0].As<Napi::Object>();
+        if (options.Has("deviceName") && options.Get("deviceName").IsString()) {
+            deviceName = options.Get("deviceName").As<Napi::String>().Utf8Value();
+        }
+        if (options.Has("deviceTypes") && options.Get("deviceTypes").IsArray()) {
+            Napi::Array types = options.Get("deviceTypes").As<Napi::Array>();
+            for (uint32_t i = 0; i < types.Length() && i < 5; i++) {
+                config_.deviceTypes.Add(static_cast<cec_device_type>(types.Get(i).As<Napi::Number>().Int32Value()));
+            }
+        } else {
+            config_.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
+        }
+        if (options.Has("physicalAddress") && options.Get("physicalAddress").IsNumber()) {
+            config_.iPhysicalAddress = static_cast<uint16_t>(options.Get("physicalAddress").As<Napi::Number>().Int32Value());
+        }
+        if (options.Has("baseDevice") && options.Get("baseDevice").IsNumber()) {
+            config_.baseDevice = static_cast<cec_logical_address>(options.Get("baseDevice").As<Napi::Number>().Int32Value());
+        }
+        if (options.Has("hdmiPort") && options.Get("hdmiPort").IsNumber()) {
+            config_.iHDMIPort = static_cast<uint8_t>(options.Get("hdmiPort").As<Napi::Number>().Int32Value());
+        }
+        if (options.Has("activateSource") && options.Get("activateSource").IsBoolean()) {
+            config_.bActivateSource = options.Get("activateSource").As<Napi::Boolean>().Value() ? 1 : 0;
+        }
+    } else {
+        config_.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
+    }
+
+    snprintf(config_.strDeviceName, LIBCEC_OSD_NAME_SIZE, "%s", deviceName.c_str());
+    config_.clientVersion = LIBCEC_VERSION_CURRENT;
+
+    // Initialize callback handler
+    callbackHandler_ = std::make_unique<CECCallbackHandler>(env);
+    config_.callbacks = callbackHandler_->GetCallbacks();
+    config_.callbackParam = callbackHandler_.get();
+
+    // Initialize the adapter
+    adapter_ = CECInitialise(&config_);
+    if (!adapter_) {
+        Napi::Error::New(env, "Failed to initialize libcec").ThrowAsJavaScriptException();
+        return;
+    }
+
+    adapter_->InitVideoStandalone();
+}
+
+CECAdapter::~CECAdapter() {
+    if (adapter_) {
+        if (isOpen_) {
+            adapter_->Close();
+        }
+        CECDestroy(adapter_);
+        adapter_ = nullptr;
+    }
+}
+
+Napi::Object CECAdapter::Init(Napi::Env env, Napi::Object exports) {
+    Napi::Function func = DefineClass(env, "CECAdapter", {
+        // Static methods
+        StaticMethod("detectAdapters", &CECAdapter::DetectAdapters),
+
+        // Instance methods
+        InstanceMethod("open", &CECAdapter::Open),
+        InstanceMethod("close", &CECAdapter::Close),
+        InstanceMethod("pingAdapter", &CECAdapter::PingAdapter),
+        InstanceMethod("getAdapterVendorId", &CECAdapter::GetAdapterVendorId),
+        InstanceMethod("getAdapterProductId", &CECAdapter::GetAdapterProductId),
+        InstanceMethod("getLibInfo", &CECAdapter::GetLibInfo),
+
+        InstanceMethod("powerOnDevices", &CECAdapter::PowerOnDevices),
+        InstanceMethod("standbyDevices", &CECAdapter::StandbyDevices),
+        InstanceMethod("setActiveSource", &CECAdapter::SetActiveSource),
+        InstanceMethod("setInactiveView", &CECAdapter::SetInactiveView),
+
+        InstanceMethod("transmit", &CECAdapter::Transmit),
+        InstanceMethod("sendKeypress", &CECAdapter::SendKeypress),
+        InstanceMethod("sendKeyRelease", &CECAdapter::SendKeyRelease),
+
+        InstanceMethod("getDeviceCecVersion", &CECAdapter::GetDeviceCecVersion),
+        InstanceMethod("getDeviceMenuLanguage", &CECAdapter::GetDeviceMenuLanguage),
+        InstanceMethod("getDeviceVendorId", &CECAdapter::GetDeviceVendorId),
+        InstanceMethod("getDevicePowerStatus", &CECAdapter::GetDevicePowerStatus),
+        InstanceMethod("getDeviceOSDName", &CECAdapter::GetDeviceOSDName),
+        InstanceMethod("getDevicePhysicalAddress", &CECAdapter::GetDevicePhysicalAddress),
+
+        InstanceMethod("pollDevice", &CECAdapter::PollDevice),
+        InstanceMethod("getActiveDevices", &CECAdapter::GetActiveDevices),
+        InstanceMethod("isActiveDevice", &CECAdapter::IsActiveDevice),
+        InstanceMethod("isActiveDeviceType", &CECAdapter::IsActiveDeviceType),
+        InstanceMethod("getActiveSource", &CECAdapter::GetActiveSource),
+        InstanceMethod("isActiveSource", &CECAdapter::IsActiveSource),
+        InstanceMethod("isLibCECActiveSource", &CECAdapter::IsLibCECActiveSource),
+
+        InstanceMethod("volumeUp", &CECAdapter::VolumeUp),
+        InstanceMethod("volumeDown", &CECAdapter::VolumeDown),
+        InstanceMethod("muteAudio", &CECAdapter::MuteAudio),
+        InstanceMethod("audioToggleMute", &CECAdapter::AudioToggleMute),
+        InstanceMethod("audioStatus", &CECAdapter::AudioStatus),
+
+        InstanceMethod("setOSDString", &CECAdapter::SetOSDString),
+
+        InstanceMethod("setLogicalAddress", &CECAdapter::SetLogicalAddress),
+        InstanceMethod("setPhysicalAddress", &CECAdapter::SetPhysicalAddress),
+        InstanceMethod("setHDMIPort", &CECAdapter::SetHDMIPort),
+        InstanceMethod("getLogicalAddresses", &CECAdapter::GetLogicalAddresses),
+
+        InstanceMethod("getCurrentConfiguration", &CECAdapter::GetCurrentConfiguration),
+        InstanceMethod("setConfiguration", &CECAdapter::SetConfiguration),
+        InstanceMethod("rescanActiveDevices", &CECAdapter::RescanActiveDevices),
+
+        InstanceMethod("setCallbacks", &CECAdapter::SetCallbacks),
+        InstanceMethod("disableCallbacks", &CECAdapter::DisableCallbacks),
+    });
+
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+
+    exports.Set("CECAdapter", func);
+    return exports;
+}
+
+Napi::Value CECAdapter::DetectAdapters(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    // Create temporary configuration for detection
+    libcec_configuration config;
+    config.Clear();
+    config.clientVersion = LIBCEC_VERSION_CURRENT;
+    config.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
+    snprintf(config.strDeviceName, LIBCEC_OSD_NAME_SIZE, "detector");
+
+    ICECAdapter* tempAdapter = CECInitialise(&config);
+    if (!tempAdapter) {
+        return Napi::Array::New(env, 0);
+    }
+
+    cec_adapter_descriptor adapters[10];
+    int8_t count = tempAdapter->DetectAdapters(adapters, 10);
+
+    CECDestroy(tempAdapter);
+
+    Napi::Array result = Napi::Array::New(env, count > 0 ? count : 0);
+    for (int8_t i = 0; i < count; i++) {
+        Napi::Object adapterObj = Napi::Object::New(env);
+        adapterObj.Set("comPath", Napi::String::New(env, adapters[i].strComPath));
+        adapterObj.Set("comName", Napi::String::New(env, adapters[i].strComName));
+        adapterObj.Set("vendorId", Napi::Number::New(env, adapters[i].iVendorId));
+        adapterObj.Set("productId", Napi::Number::New(env, adapters[i].iProductId));
+        adapterObj.Set("firmwareVersion", Napi::Number::New(env, adapters[i].iFirmwareVersion));
+        adapterObj.Set("physicalAddress", Napi::Number::New(env, adapters[i].iPhysicalAddress));
+        adapterObj.Set("firmwareBuildDate", Napi::Number::New(env, static_cast<double>(adapters[i].iFirmwareBuildDate)));
+        adapterObj.Set("adapterType", Napi::Number::New(env, static_cast<int>(adapters[i].adapterType)));
+        result.Set(static_cast<uint32_t>(i), adapterObj);
+    }
+
+    return result;
+}
+
+Napi::Value CECAdapter::Open(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_) {
+        Napi::Error::New(env, "Adapter not initialized").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    std::string port;
+    uint32_t timeout = 10000;
+
+    if (info.Length() > 0 && info[0].IsString()) {
+        port = info[0].As<Napi::String>().Utf8Value();
+    } else {
+        // Auto-detect adapter
+        cec_adapter_descriptor adapters[1];
+        int8_t count = adapter_->DetectAdapters(adapters, 1);
+        if (count < 1) {
+            return Napi::Boolean::New(env, false);
+        }
+        port = adapters[0].strComPath;
+    }
+
+    if (info.Length() > 1 && info[1].IsNumber()) {
+        timeout = info[1].As<Napi::Number>().Uint32Value();
+    }
+
+    bool result = adapter_->Open(port.c_str(), timeout);
+    isOpen_ = result;
+    return Napi::Boolean::New(env, result);
+}
+
+Napi::Value CECAdapter::Close(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (adapter_ && isOpen_) {
+        adapter_->Close();
+        isOpen_ = false;
+    }
+    return env.Undefined();
+}
+
+Napi::Value CECAdapter::PingAdapter(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+    return Napi::Boolean::New(env, adapter_->PingAdapter());
+}
+
+Napi::Value CECAdapter::GetAdapterVendorId(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_) {
+        return Napi::Number::New(env, 0);
+    }
+    return Napi::Number::New(env, adapter_->GetAdapterVendorId());
+}
+
+Napi::Value CECAdapter::GetAdapterProductId(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_) {
+        return Napi::Number::New(env, 0);
+    }
+    return Napi::Number::New(env, adapter_->GetAdapterProductId());
+}
+
+Napi::Value CECAdapter::GetLibInfo(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_) {
+        return Napi::String::New(env, "");
+    }
+    return Napi::String::New(env, adapter_->GetLibInfo());
+}
+
+Napi::Value CECAdapter::PowerOnDevices(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    cec_logical_address address = CECDEVICE_TV;
+    if (info.Length() > 0 && info[0].IsNumber()) {
+        address = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    }
+
+    return Napi::Boolean::New(env, adapter_->PowerOnDevices(address));
+}
+
+Napi::Value CECAdapter::StandbyDevices(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    cec_logical_address address = CECDEVICE_BROADCAST;
+    if (info.Length() > 0 && info[0].IsNumber()) {
+        address = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    }
+
+    return Napi::Boolean::New(env, adapter_->StandbyDevices(address));
+}
+
+Napi::Value CECAdapter::SetActiveSource(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    cec_device_type type = CEC_DEVICE_TYPE_RESERVED;
+    if (info.Length() > 0 && info[0].IsNumber()) {
+        type = static_cast<cec_device_type>(info[0].As<Napi::Number>().Int32Value());
+    }
+
+    return Napi::Boolean::New(env, adapter_->SetActiveSource(type));
+}
+
+Napi::Value CECAdapter::SetInactiveView(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    return Napi::Boolean::New(env, adapter_->SetInactiveView());
+}
+
+Napi::Value CECAdapter::Transmit(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    if (info.Length() < 1 || !info[0].IsObject()) {
+        Napi::TypeError::New(env, "Expected command object").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    Napi::Object cmdObj = info[0].As<Napi::Object>();
+    cec_command command;
+    command.Clear();
+
+    if (cmdObj.Has("initiator")) {
+        command.initiator = static_cast<cec_logical_address>(cmdObj.Get("initiator").As<Napi::Number>().Int32Value());
+    }
+    if (cmdObj.Has("destination")) {
+        command.destination = static_cast<cec_logical_address>(cmdObj.Get("destination").As<Napi::Number>().Int32Value());
+    }
+    if (cmdObj.Has("opcode")) {
+        command.opcode = static_cast<cec_opcode>(cmdObj.Get("opcode").As<Napi::Number>().Int32Value());
+        command.opcode_set = 1;
+    }
+    if (cmdObj.Has("parameters") && cmdObj.Get("parameters").IsArray()) {
+        Napi::Array params = cmdObj.Get("parameters").As<Napi::Array>();
+        for (uint32_t i = 0; i < params.Length() && i < 64; i++) {
+            command.parameters.PushBack(static_cast<uint8_t>(params.Get(i).As<Napi::Number>().Int32Value()));
+        }
+    }
+
+    return Napi::Boolean::New(env, adapter_->Transmit(command));
+}
+
+Napi::Value CECAdapter::SendKeypress(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected destination and keycode").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    cec_logical_address destination = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    cec_user_control_code key = static_cast<cec_user_control_code>(info[1].As<Napi::Number>().Int32Value());
+    bool wait = false;
+    if (info.Length() > 2 && info[2].IsBoolean()) {
+        wait = info[2].As<Napi::Boolean>().Value();
+    }
+
+    return Napi::Boolean::New(env, adapter_->SendKeypress(destination, key, wait));
+}
+
+Napi::Value CECAdapter::SendKeyRelease(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "Expected destination").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    cec_logical_address destination = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    bool wait = false;
+    if (info.Length() > 1 && info[1].IsBoolean()) {
+        wait = info[1].As<Napi::Boolean>().Value();
+    }
+
+    return Napi::Boolean::New(env, adapter_->SendKeyRelease(destination, wait));
+}
+
+Napi::Value CECAdapter::GetDeviceCecVersion(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Number::New(env, -1);
+    }
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Expected logical address").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    cec_logical_address address = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    return Napi::Number::New(env, static_cast<int>(adapter_->GetDeviceCecVersion(address)));
+}
+
+Napi::Value CECAdapter::GetDeviceMenuLanguage(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::String::New(env, "");
+    }
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Expected logical address").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    cec_logical_address address = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    std::string lang = adapter_->GetDeviceMenuLanguage(address);
+    return Napi::String::New(env, lang);
+}
+
+Napi::Value CECAdapter::GetDeviceVendorId(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Number::New(env, 0);
+    }
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Expected logical address").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    cec_logical_address address = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    return Napi::Number::New(env, adapter_->GetDeviceVendorId(address));
+}
+
+Napi::Value CECAdapter::GetDevicePowerStatus(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Number::New(env, -1);
+    }
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Expected logical address").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    cec_logical_address address = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    return Napi::Number::New(env, static_cast<int>(adapter_->GetDevicePowerStatus(address)));
+}
+
+Napi::Value CECAdapter::GetDeviceOSDName(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::String::New(env, "");
+    }
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Expected logical address").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    cec_logical_address address = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    std::string name = adapter_->GetDeviceOSDName(address);
+    return Napi::String::New(env, name);
+}
+
+Napi::Value CECAdapter::GetDevicePhysicalAddress(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Number::New(env, 0);
+    }
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Expected logical address").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    cec_logical_address address = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    return Napi::Number::New(env, adapter_->GetDevicePhysicalAddress(address));
+}
+
+Napi::Value CECAdapter::PollDevice(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Expected logical address").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    cec_logical_address address = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    return Napi::Boolean::New(env, adapter_->PollDevice(address));
+}
+
+Napi::Value CECAdapter::GetActiveDevices(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    Napi::Array result = Napi::Array::New(env);
+
+    if (!adapter_ || !isOpen_) {
+        return result;
+    }
+
+    cec_logical_addresses addresses = adapter_->GetActiveDevices();
+    uint32_t idx = 0;
+    for (int i = 0; i < 16; i++) {
+        if (addresses.IsSet(static_cast<cec_logical_address>(i))) {
+            result.Set(idx++, Napi::Number::New(env, i));
+        }
+    }
+
+    return result;
+}
+
+Napi::Value CECAdapter::IsActiveDevice(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Expected logical address").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    cec_logical_address address = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    return Napi::Boolean::New(env, adapter_->IsActiveDevice(address));
+}
+
+Napi::Value CECAdapter::IsActiveDeviceType(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Expected device type").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    cec_device_type type = static_cast<cec_device_type>(info[0].As<Napi::Number>().Int32Value());
+    return Napi::Boolean::New(env, adapter_->IsActiveDeviceType(type));
+}
+
+Napi::Value CECAdapter::GetActiveSource(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Number::New(env, -1);
+    }
+
+    return Napi::Number::New(env, static_cast<int>(adapter_->GetActiveSource()));
+}
+
+Napi::Value CECAdapter::IsActiveSource(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Expected logical address").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    cec_logical_address address = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    return Napi::Boolean::New(env, adapter_->IsActiveSource(address));
+}
+
+Napi::Value CECAdapter::IsLibCECActiveSource(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    return Napi::Boolean::New(env, adapter_->IsLibCECActiveSource());
+}
+
+Napi::Value CECAdapter::VolumeUp(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Number::New(env, 0);
+    }
+
+    bool sendRelease = true;
+    if (info.Length() > 0 && info[0].IsBoolean()) {
+        sendRelease = info[0].As<Napi::Boolean>().Value();
+    }
+
+    return Napi::Number::New(env, adapter_->VolumeUp(sendRelease));
+}
+
+Napi::Value CECAdapter::VolumeDown(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Number::New(env, 0);
+    }
+
+    bool sendRelease = true;
+    if (info.Length() > 0 && info[0].IsBoolean()) {
+        sendRelease = info[0].As<Napi::Boolean>().Value();
+    }
+
+    return Napi::Number::New(env, adapter_->VolumeDown(sendRelease));
+}
+
+Napi::Value CECAdapter::MuteAudio(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Number::New(env, 0);
+    }
+
+    return Napi::Number::New(env, adapter_->MuteAudio());
+}
+
+Napi::Value CECAdapter::AudioToggleMute(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Number::New(env, 0);
+    }
+
+    return Napi::Number::New(env, adapter_->AudioToggleMute());
+}
+
+Napi::Value CECAdapter::AudioStatus(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Number::New(env, 0);
+    }
+
+    return Napi::Number::New(env, adapter_->AudioStatus());
+}
+
+Napi::Value CECAdapter::SetOSDString(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    if (info.Length() < 3) {
+        Napi::TypeError::New(env, "Expected address, duration, and message").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    cec_logical_address address = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    cec_display_control duration = static_cast<cec_display_control>(info[1].As<Napi::Number>().Int32Value());
+    std::string message = info[2].As<Napi::String>().Utf8Value();
+
+    return Napi::Boolean::New(env, adapter_->SetOSDString(address, duration, message.c_str()));
+}
+
+Napi::Value CECAdapter::SetLogicalAddress(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    cec_logical_address address = CECDEVICE_PLAYBACKDEVICE1;
+    if (info.Length() > 0 && info[0].IsNumber()) {
+        address = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    }
+
+    return Napi::Boolean::New(env, adapter_->SetLogicalAddress(address));
+}
+
+Napi::Value CECAdapter::SetPhysicalAddress(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    uint16_t address = CEC_DEFAULT_PHYSICAL_ADDRESS;
+    if (info.Length() > 0 && info[0].IsNumber()) {
+        address = static_cast<uint16_t>(info[0].As<Napi::Number>().Int32Value());
+    }
+
+    return Napi::Boolean::New(env, adapter_->SetPhysicalAddress(address));
+}
+
+Napi::Value CECAdapter::SetHDMIPort(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected base device and port number").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    cec_logical_address baseDevice = static_cast<cec_logical_address>(info[0].As<Napi::Number>().Int32Value());
+    uint8_t port = static_cast<uint8_t>(info[1].As<Napi::Number>().Int32Value());
+
+    return Napi::Boolean::New(env, adapter_->SetHDMIPort(baseDevice, port));
+}
+
+Napi::Value CECAdapter::GetLogicalAddresses(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    Napi::Object result = Napi::Object::New(env);
+
+    if (!adapter_ || !isOpen_) {
+        result.Set("primary", Napi::Number::New(env, -1));
+        result.Set("addresses", Napi::Array::New(env));
+        return result;
+    }
+
+    cec_logical_addresses addresses = adapter_->GetLogicalAddresses();
+    result.Set("primary", Napi::Number::New(env, static_cast<int>(addresses.primary)));
+
+    Napi::Array arr = Napi::Array::New(env);
+    uint32_t idx = 0;
+    for (int i = 0; i < 16; i++) {
+        if (addresses.IsSet(static_cast<cec_logical_address>(i))) {
+            arr.Set(idx++, Napi::Number::New(env, i));
+        }
+    }
+    result.Set("addresses", arr);
+
+    return result;
+}
+
+Napi::Value CECAdapter::GetCurrentConfiguration(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    Napi::Object result = Napi::Object::New(env);
+
+    if (!adapter_) {
+        return result;
+    }
+
+    libcec_configuration config;
+    config.Clear();
+
+    if (adapter_->GetCurrentConfiguration(&config)) {
+        result.Set("deviceName", Napi::String::New(env, config.strDeviceName));
+        result.Set("physicalAddress", Napi::Number::New(env, config.iPhysicalAddress));
+        result.Set("baseDevice", Napi::Number::New(env, static_cast<int>(config.baseDevice)));
+        result.Set("hdmiPort", Napi::Number::New(env, config.iHDMIPort));
+        result.Set("clientVersion", Napi::Number::New(env, static_cast<double>(config.clientVersion)));
+        result.Set("serverVersion", Napi::Number::New(env, static_cast<double>(config.serverVersion)));
+        result.Set("activateSource", Napi::Boolean::New(env, config.bActivateSource != 0));
+
+        Napi::Array deviceTypes = Napi::Array::New(env);
+        uint32_t deviceTypeIndex = 0;
+        for (uint8_t i = 0; i < 5; i++) {
+            if (config.deviceTypes.types[i] != CEC_DEVICE_TYPE_RESERVED) {
+                deviceTypes.Set(deviceTypeIndex++, Napi::Number::New(env, static_cast<int>(config.deviceTypes.types[i])));
+            }
+        }
+        result.Set("deviceTypes", deviceTypes);
+    }
+
+    return result;
+}
+
+Napi::Value CECAdapter::SetConfiguration(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    if (info.Length() < 1 || !info[0].IsObject()) {
+        Napi::TypeError::New(env, "Expected configuration object").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    Napi::Object configObj = info[0].As<Napi::Object>();
+    libcec_configuration config;
+    config.Clear();
+    config.clientVersion = LIBCEC_VERSION_CURRENT;
+
+    if (configObj.Has("deviceName") && configObj.Get("deviceName").IsString()) {
+        std::string name = configObj.Get("deviceName").As<Napi::String>().Utf8Value();
+        snprintf(config.strDeviceName, LIBCEC_OSD_NAME_SIZE, "%s", name.c_str());
+    }
+    if (configObj.Has("physicalAddress") && configObj.Get("physicalAddress").IsNumber()) {
+        config.iPhysicalAddress = static_cast<uint16_t>(configObj.Get("physicalAddress").As<Napi::Number>().Int32Value());
+    }
+    if (configObj.Has("baseDevice") && configObj.Get("baseDevice").IsNumber()) {
+        config.baseDevice = static_cast<cec_logical_address>(configObj.Get("baseDevice").As<Napi::Number>().Int32Value());
+    }
+    if (configObj.Has("hdmiPort") && configObj.Get("hdmiPort").IsNumber()) {
+        config.iHDMIPort = static_cast<uint8_t>(configObj.Get("hdmiPort").As<Napi::Number>().Int32Value());
+    }
+    if (configObj.Has("activateSource") && configObj.Get("activateSource").IsBoolean()) {
+        config.bActivateSource = configObj.Get("activateSource").As<Napi::Boolean>().Value() ? 1 : 0;
+    }
+    if (configObj.Has("deviceTypes") && configObj.Get("deviceTypes").IsArray()) {
+        Napi::Array types = configObj.Get("deviceTypes").As<Napi::Array>();
+        for (uint32_t i = 0; i < types.Length() && i < 5; i++) {
+            config.deviceTypes.Add(static_cast<cec_device_type>(types.Get(i).As<Napi::Number>().Int32Value()));
+        }
+    }
+
+    return Napi::Boolean::New(env, adapter_->SetConfiguration(&config));
+}
+
+Napi::Value CECAdapter::RescanActiveDevices(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (!adapter_ || !isOpen_) {
+        return env.Undefined();
+    }
+
+    adapter_->RescanActiveDevices();
+    return env.Undefined();
+}
+
+Napi::Value CECAdapter::SetCallbacks(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsObject()) {
+        Napi::TypeError::New(env, "Expected callbacks object").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    Napi::Object callbacks = info[0].As<Napi::Object>();
+
+    if (callbacks.Has("onLogMessage") && callbacks.Get("onLogMessage").IsFunction()) {
+        callbackHandler_->SetLogMessageCallback(callbacks.Get("onLogMessage").As<Napi::Function>());
+    }
+    if (callbacks.Has("onKeyPress") && callbacks.Get("onKeyPress").IsFunction()) {
+        callbackHandler_->SetKeyPressCallback(callbacks.Get("onKeyPress").As<Napi::Function>());
+    }
+    if (callbacks.Has("onCommand") && callbacks.Get("onCommand").IsFunction()) {
+        callbackHandler_->SetCommandCallback(callbacks.Get("onCommand").As<Napi::Function>());
+    }
+    if (callbacks.Has("onConfigurationChanged") && callbacks.Get("onConfigurationChanged").IsFunction()) {
+        callbackHandler_->SetConfigurationChangedCallback(callbacks.Get("onConfigurationChanged").As<Napi::Function>());
+    }
+    if (callbacks.Has("onAlert") && callbacks.Get("onAlert").IsFunction()) {
+        callbackHandler_->SetAlertCallback(callbacks.Get("onAlert").As<Napi::Function>());
+    }
+    if (callbacks.Has("onSourceActivated") && callbacks.Get("onSourceActivated").IsFunction()) {
+        callbackHandler_->SetSourceActivatedCallback(callbacks.Get("onSourceActivated").As<Napi::Function>());
+    }
+
+    return Napi::Boolean::New(env, true);
+}
+
+Napi::Value CECAdapter::DisableCallbacks(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (callbackHandler_) {
+        callbackHandler_->ClearCallbacks();
+    }
+
+    return Napi::Boolean::New(env, true);
+}