node-libcec 1.0.0

package/src/native/cec_adapter.h

@@ -0,0 +1,96 @@
+#ifndef CEC_ADAPTER_H
+#define CEC_ADAPTER_H
+
+#include <napi.h>
+#include <libcec/cec.h>
+#include <memory>
+#include <string>
+#include <mutex>
+
+using namespace CEC;
+
+class CECCallbackHandler;
+
+class CECAdapter : public Napi::ObjectWrap<CECAdapter> {
+public:
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    CECAdapter(const Napi::CallbackInfo& info);
+    ~CECAdapter();
+
+private:
+    // Adapter connection methods
+    Napi::Value Open(const Napi::CallbackInfo& info);
+    Napi::Value Close(const Napi::CallbackInfo& info);
+    Napi::Value PingAdapter(const Napi::CallbackInfo& info);
+    Napi::Value GetAdapterVendorId(const Napi::CallbackInfo& info);
+    Napi::Value GetAdapterProductId(const Napi::CallbackInfo& info);
+    Napi::Value GetLibInfo(const Napi::CallbackInfo& info);
+
+    // Device discovery
+    static Napi::Value DetectAdapters(const Napi::CallbackInfo& info);
+
+    // Device control methods
+    Napi::Value PowerOnDevices(const Napi::CallbackInfo& info);
+    Napi::Value StandbyDevices(const Napi::CallbackInfo& info);
+    Napi::Value SetActiveSource(const Napi::CallbackInfo& info);
+    Napi::Value SetInactiveView(const Napi::CallbackInfo& info);
+
+    // Command transmission
+    Napi::Value Transmit(const Napi::CallbackInfo& info);
+    Napi::Value SendKeypress(const Napi::CallbackInfo& info);
+    Napi::Value SendKeyRelease(const Napi::CallbackInfo& info);
+
+    // Device information queries
+    Napi::Value GetDeviceCecVersion(const Napi::CallbackInfo& info);
+    Napi::Value GetDeviceMenuLanguage(const Napi::CallbackInfo& info);
+    Napi::Value GetDeviceVendorId(const Napi::CallbackInfo& info);
+    Napi::Value GetDevicePowerStatus(const Napi::CallbackInfo& info);
+    Napi::Value GetDeviceOSDName(const Napi::CallbackInfo& info);
+    Napi::Value GetDevicePhysicalAddress(const Napi::CallbackInfo& info);
+
+    // Device status checks
+    Napi::Value PollDevice(const Napi::CallbackInfo& info);
+    Napi::Value GetActiveDevices(const Napi::CallbackInfo& info);
+    Napi::Value IsActiveDevice(const Napi::CallbackInfo& info);
+    Napi::Value IsActiveDeviceType(const Napi::CallbackInfo& info);
+    Napi::Value GetActiveSource(const Napi::CallbackInfo& info);
+    Napi::Value IsActiveSource(const Napi::CallbackInfo& info);
+    Napi::Value IsLibCECActiveSource(const Napi::CallbackInfo& info);
+
+    // Audio control
+    Napi::Value VolumeUp(const Napi::CallbackInfo& info);
+    Napi::Value VolumeDown(const Napi::CallbackInfo& info);
+    Napi::Value MuteAudio(const Napi::CallbackInfo& info);
+    Napi::Value AudioToggleMute(const Napi::CallbackInfo& info);
+    Napi::Value AudioStatus(const Napi::CallbackInfo& info);
+
+    // Display control
+    Napi::Value SetOSDString(const Napi::CallbackInfo& info);
+
+    // Address configuration
+    Napi::Value SetLogicalAddress(const Napi::CallbackInfo& info);
+    Napi::Value SetPhysicalAddress(const Napi::CallbackInfo& info);
+    Napi::Value SetHDMIPort(const Napi::CallbackInfo& info);
+    Napi::Value GetLogicalAddresses(const Napi::CallbackInfo& info);
+
+    // Configuration
+    Napi::Value GetCurrentConfiguration(const Napi::CallbackInfo& info);
+    Napi::Value SetConfiguration(const Napi::CallbackInfo& info);
+    Napi::Value RescanActiveDevices(const Napi::CallbackInfo& info);
+
+    // Event handling
+    Napi::Value SetCallbacks(const Napi::CallbackInfo& info);
+    Napi::Value DisableCallbacks(const Napi::CallbackInfo& info);
+
+    // Static initializer
+    static Napi::FunctionReference constructor;
+
+    // libcec adapter instance
+    ICECAdapter* adapter_;
+    libcec_configuration config_;
+    std::unique_ptr<CECCallbackHandler> callbackHandler_;
+    std::mutex mutex_;
+    bool isOpen_;
+};
+
+#endif // CEC_ADAPTER_H

package/src/native/cec_addon.cc

@@ -0,0 +1,9 @@
+#include <napi.h>
+#include "cec_adapter.h"
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    CECAdapter::Init(env, exports);
+    return exports;
+}
+
+NODE_API_MODULE(cec, Init)

package/src/native/cec_callbacks.cc

@@ -0,0 +1,313 @@
+#include "cec_callbacks.h"
+#include <cstring>
+
+CECCallbackHandler::CECCallbackHandler(Napi::Env env) : callbacks_{} {
+}
+
+CECCallbackHandler::~CECCallbackHandler() {
+    ClearCallbacks();
+}
+
+void CECCallbackHandler::ClearCallbacks() {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (logMessageTsfn_) {
+        logMessageTsfn_.Release();
+    }
+    if (keyPressTsfn_) {
+        keyPressTsfn_.Release();
+    }
+    if (commandTsfn_) {
+        commandTsfn_.Release();
+    }
+    if (configChangedTsfn_) {
+        configChangedTsfn_.Release();
+    }
+    if (alertTsfn_) {
+        alertTsfn_.Release();
+    }
+    if (sourceActivatedTsfn_) {
+        sourceActivatedTsfn_.Release();
+    }
+
+    callbacks_ = {};
+}
+
+void CECCallbackHandler::SetLogMessageCallback(Napi::Function callback) {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (logMessageTsfn_) {
+        logMessageTsfn_.Release();
+    }
+
+    logMessageTsfn_ = Napi::ThreadSafeFunction::New(
+        callback.Env(),
+        callback,
+        "LogMessageCallback",
+        0,
+        1
+    );
+
+    callbacks_.logMessage = &CECCallbackHandler::LogMessageCallback;
+}
+
+void CECCallbackHandler::SetKeyPressCallback(Napi::Function callback) {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (keyPressTsfn_) {
+        keyPressTsfn_.Release();
+    }
+
+    keyPressTsfn_ = Napi::ThreadSafeFunction::New(
+        callback.Env(),
+        callback,
+        "KeyPressCallback",
+        0,
+        1
+    );
+
+    callbacks_.keyPress = &CECCallbackHandler::KeyPressCallback;
+}
+
+void CECCallbackHandler::SetCommandCallback(Napi::Function callback) {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (commandTsfn_) {
+        commandTsfn_.Release();
+    }
+
+    commandTsfn_ = Napi::ThreadSafeFunction::New(
+        callback.Env(),
+        callback,
+        "CommandCallback",
+        0,
+        1
+    );
+
+    callbacks_.commandReceived = &CECCallbackHandler::CommandReceivedCallback;
+}
+
+void CECCallbackHandler::SetConfigurationChangedCallback(Napi::Function callback) {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (configChangedTsfn_) {
+        configChangedTsfn_.Release();
+    }
+
+    configChangedTsfn_ = Napi::ThreadSafeFunction::New(
+        callback.Env(),
+        callback,
+        "ConfigurationChangedCallback",
+        0,
+        1
+    );
+
+    callbacks_.configurationChanged = &CECCallbackHandler::ConfigurationChangedCallback;
+}
+
+void CECCallbackHandler::SetAlertCallback(Napi::Function callback) {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (alertTsfn_) {
+        alertTsfn_.Release();
+    }
+
+    alertTsfn_ = Napi::ThreadSafeFunction::New(
+        callback.Env(),
+        callback,
+        "AlertCallback",
+        0,
+        1
+    );
+
+    callbacks_.alert = &CECCallbackHandler::AlertCallback;
+}
+
+void CECCallbackHandler::SetSourceActivatedCallback(Napi::Function callback) {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (sourceActivatedTsfn_) {
+        sourceActivatedTsfn_.Release();
+    }
+
+    sourceActivatedTsfn_ = Napi::ThreadSafeFunction::New(
+        callback.Env(),
+        callback,
+        "SourceActivatedCallback",
+        0,
+        1
+    );
+
+    callbacks_.sourceActivated = &CECCallbackHandler::SourceActivatedCallback;
+}
+
+// Log message data structure
+struct LogMessageData {
+    std::string message;
+    int level;
+    int64_t time;
+};
+
+void CECCallbackHandler::LogMessageCallback(void* cbParam, const cec_log_message* message) {
+    CECCallbackHandler* handler = static_cast<CECCallbackHandler*>(cbParam);
+    if (!handler || !handler->logMessageTsfn_) return;
+
+    auto* data = new LogMessageData{
+        std::string(message->message),
+        static_cast<int>(message->level),
+        message->time
+    };
+
+    handler->logMessageTsfn_.BlockingCall(data, [](Napi::Env env, Napi::Function jsCallback, LogMessageData* data) {
+        Napi::Object obj = Napi::Object::New(env);
+        obj.Set("message", Napi::String::New(env, data->message));
+        obj.Set("level", Napi::Number::New(env, data->level));
+        obj.Set("time", Napi::Number::New(env, static_cast<double>(data->time)));
+        jsCallback.Call({obj});
+        delete data;
+    });
+}
+
+// Key press data structure
+struct KeyPressData {
+    int keycode;
+    int duration;
+};
+
+void CECCallbackHandler::KeyPressCallback(void* cbParam, const cec_keypress* key) {
+    CECCallbackHandler* handler = static_cast<CECCallbackHandler*>(cbParam);
+    if (!handler || !handler->keyPressTsfn_) return;
+
+    auto* data = new KeyPressData{
+        static_cast<int>(key->keycode),
+        static_cast<int>(key->duration)
+    };
+
+    handler->keyPressTsfn_.BlockingCall(data, [](Napi::Env env, Napi::Function jsCallback, KeyPressData* data) {
+        Napi::Object obj = Napi::Object::New(env);
+        obj.Set("keycode", Napi::Number::New(env, data->keycode));
+        obj.Set("duration", Napi::Number::New(env, data->duration));
+        jsCallback.Call({obj});
+        delete data;
+    });
+}
+
+// Command data structure
+struct CommandData {
+    int initiator;
+    int destination;
+    int opcode;
+    bool ack;
+    bool eom;
+    int opcodeSet;
+    std::vector<uint8_t> parameters;
+};
+
+void CECCallbackHandler::CommandReceivedCallback(void* cbParam, const cec_command* command) {
+    CECCallbackHandler* handler = static_cast<CECCallbackHandler*>(cbParam);
+    if (!handler || !handler->commandTsfn_) return;
+
+    auto* data = new CommandData{
+        static_cast<int>(command->initiator),
+        static_cast<int>(command->destination),
+        static_cast<int>(command->opcode),
+        command->ack != 0,
+        command->eom != 0,
+        command->opcode_set != 0,
+        std::vector<uint8_t>(command->parameters.data, command->parameters.data + command->parameters.size)
+    };
+
+    handler->commandTsfn_.BlockingCall(data, [](Napi::Env env, Napi::Function jsCallback, CommandData* data) {
+        Napi::Object obj = Napi::Object::New(env);
+        obj.Set("initiator", Napi::Number::New(env, data->initiator));
+        obj.Set("destination", Napi::Number::New(env, data->destination));
+        obj.Set("opcode", Napi::Number::New(env, data->opcode));
+        obj.Set("ack", Napi::Boolean::New(env, data->ack));
+        obj.Set("eom", Napi::Boolean::New(env, data->eom));
+        obj.Set("opcodeSet", Napi::Boolean::New(env, data->opcodeSet));
+
+        Napi::Array params = Napi::Array::New(env, data->parameters.size());
+        for (size_t i = 0; i < data->parameters.size(); i++) {
+            params.Set(static_cast<uint32_t>(i), Napi::Number::New(env, data->parameters[i]));
+        }
+        obj.Set("parameters", params);
+
+        jsCallback.Call({obj});
+        delete data;
+    });
+}
+
+// Configuration changed data structure
+struct ConfigChangedData {
+    std::string deviceName;
+    uint16_t physicalAddress;
+    int baseDevice;
+    uint8_t hdmiPort;
+};
+
+void CECCallbackHandler::ConfigurationChangedCallback(void* cbParam, const libcec_configuration* config) {
+    CECCallbackHandler* handler = static_cast<CECCallbackHandler*>(cbParam);
+    if (!handler || !handler->configChangedTsfn_) return;
+
+    auto* data = new ConfigChangedData{
+        std::string(config->strDeviceName),
+        config->iPhysicalAddress,
+        static_cast<int>(config->baseDevice),
+        config->iHDMIPort
+    };
+
+    handler->configChangedTsfn_.BlockingCall(data, [](Napi::Env env, Napi::Function jsCallback, ConfigChangedData* data) {
+        Napi::Object obj = Napi::Object::New(env);
+        obj.Set("deviceName", Napi::String::New(env, data->deviceName));
+        obj.Set("physicalAddress", Napi::Number::New(env, data->physicalAddress));
+        obj.Set("baseDevice", Napi::Number::New(env, data->baseDevice));
+        obj.Set("hdmiPort", Napi::Number::New(env, data->hdmiPort));
+        jsCallback.Call({obj});
+        delete data;
+    });
+}
+
+// Alert data structure
+struct AlertData {
+    int alertType;
+};
+
+void CECCallbackHandler::AlertCallback(void* cbParam, const libcec_alert type, const libcec_parameter param) {
+    CECCallbackHandler* handler = static_cast<CECCallbackHandler*>(cbParam);
+    if (!handler || !handler->alertTsfn_) return;
+
+    auto* data = new AlertData{
+        static_cast<int>(type)
+    };
+
+    handler->alertTsfn_.BlockingCall(data, [](Napi::Env env, Napi::Function jsCallback, AlertData* data) {
+        Napi::Object obj = Napi::Object::New(env);
+        obj.Set("type", Napi::Number::New(env, data->alertType));
+        jsCallback.Call({obj});
+        delete data;
+    });
+}
+
+// Source activated data structure
+struct SourceActivatedData {
+    int logicalAddress;
+    bool activated;
+};
+
+void CECCallbackHandler::SourceActivatedCallback(void* cbParam, const cec_logical_address logicalAddress, const uint8_t activated) {
+    CECCallbackHandler* handler = static_cast<CECCallbackHandler*>(cbParam);
+    if (!handler || !handler->sourceActivatedTsfn_) return;
+
+    auto* data = new SourceActivatedData{
+        static_cast<int>(logicalAddress),
+        activated != 0
+    };
+
+    handler->sourceActivatedTsfn_.BlockingCall(data, [](Napi::Env env, Napi::Function jsCallback, SourceActivatedData* data) {
+        Napi::Object obj = Napi::Object::New(env);
+        obj.Set("logicalAddress", Napi::Number::New(env, data->logicalAddress));
+        obj.Set("activated", Napi::Boolean::New(env, data->activated));
+        jsCallback.Call({obj});
+        delete data;
+    });
+}

package/src/native/cec_callbacks.h

@@ -0,0 +1,48 @@
+#ifndef CEC_CALLBACKS_H
+#define CEC_CALLBACKS_H
+
+#include <napi.h>
+#include <libcec/cec.h>
+#include <memory>
+#include <mutex>
+
+using namespace CEC;
+
+class CECCallbackHandler {
+public:
+    CECCallbackHandler(Napi::Env env);
+    ~CECCallbackHandler();
+
+    void SetLogMessageCallback(Napi::Function callback);
+    void SetKeyPressCallback(Napi::Function callback);
+    void SetCommandCallback(Napi::Function callback);
+    void SetConfigurationChangedCallback(Napi::Function callback);
+    void SetAlertCallback(Napi::Function callback);
+    void SetSourceActivatedCallback(Napi::Function callback);
+
+    void ClearCallbacks();
+
+    ICECCallbacks* GetCallbacks() { return &callbacks_; }
+
+    // Static callback functions for libcec
+    static void LogMessageCallback(void* cbParam, const cec_log_message* message);
+    static void KeyPressCallback(void* cbParam, const cec_keypress* key);
+    static void CommandReceivedCallback(void* cbParam, const cec_command* command);
+    static void ConfigurationChangedCallback(void* cbParam, const libcec_configuration* config);
+    static void AlertCallback(void* cbParam, const libcec_alert type, const libcec_parameter param);
+    static void SourceActivatedCallback(void* cbParam, const cec_logical_address logicalAddress, const uint8_t activated);
+
+private:
+    ICECCallbacks callbacks_;
+
+    Napi::ThreadSafeFunction logMessageTsfn_;
+    Napi::ThreadSafeFunction keyPressTsfn_;
+    Napi::ThreadSafeFunction commandTsfn_;
+    Napi::ThreadSafeFunction configChangedTsfn_;
+    Napi::ThreadSafeFunction alertTsfn_;
+    Napi::ThreadSafeFunction sourceActivatedTsfn_;
+
+    std::mutex mutex_;
+};
+
+#endif // CEC_CALLBACKS_H