node-libcec 1.0.0

package/lib/index.js

@@ -0,0 +1,433 @@
+const EventEmitter = require('events');
+
+// Load native addon
+let native;
+try {
+  native = require('../build/Release/cec.node');
+} catch (e) {
+  try {
+    native = require('../build/Debug/cec.node');
+  } catch (e2) {
+    throw new Error('Failed to load native cec module. Did you run npm run build?');
+  }
+}
+
+const constants = require('./constants');
+
+/**
+ * CEC Adapter class - provides high-level interface to libcec
+ */
+class CECAdapter extends EventEmitter {
+  /**
+   * Create a new CEC adapter instance
+   * @param {Object} options - Configuration options
+   * @param {string} [options.deviceName='node-libcec'] - OSD name for this device
+   * @param {number[]} [options.deviceTypes] - Array of device types (default: [DeviceType.RECORDING_DEVICE])
+   * @param {number} [options.physicalAddress] - Physical address (auto-detected if not specified)
+   * @param {number} [options.baseDevice] - Base device logical address
+   * @param {number} [options.hdmiPort] - HDMI port number
+   * @param {boolean} [options.activateSource=false] - Whether to activate as source on connect
+   */
+  constructor(options = {}) {
+    super();
+    this._adapter = new native.CECAdapter(options);
+    this._setupCallbacks();
+  }
+
+  /**
+   * Set up internal callbacks that emit events
+   */
+  _setupCallbacks() {
+    this._adapter.setCallbacks({
+      onLogMessage: (msg) => this.emit('log', msg),
+      onKeyPress: (key) => this.emit('keypress', key),
+      onCommand: (cmd) => this.emit('command', cmd),
+      onConfigurationChanged: (config) => this.emit('configurationChanged', config),
+      onAlert: (alert) => this.emit('alert', alert),
+      onSourceActivated: (source) => this.emit('sourceActivated', source)
+    });
+  }
+
+  /**
+   * Detect available CEC adapters
+   * @returns {Array} Array of adapter descriptors
+   */
+  static detectAdapters() {
+    return native.CECAdapter.detectAdapters();
+  }
+
+  /**
+   * Open connection to a CEC adapter
+   * @param {string} [port] - COM port path (auto-detected if not specified)
+   * @param {number} [timeout=10000] - Connection timeout in milliseconds
+   * @returns {boolean} True if connection successful
+   */
+  open(port, timeout = 10000) {
+    return this._adapter.open(port, timeout);
+  }
+
+  /**
+   * Close the adapter connection
+   */
+  close() {
+    this._adapter.close();
+  }
+
+  /**
+   * Check if the adapter is responding
+   * @returns {boolean} True if adapter responds to ping
+   */
+  pingAdapter() {
+    return this._adapter.pingAdapter();
+  }
+
+  /**
+   * Get the adapter's USB vendor ID
+   * @returns {number} Vendor ID
+   */
+  getAdapterVendorId() {
+    return this._adapter.getAdapterVendorId();
+  }
+
+  /**
+   * Get the adapter's USB product ID
+   * @returns {number} Product ID
+   */
+  getAdapterProductId() {
+    return this._adapter.getAdapterProductId();
+  }
+
+  /**
+   * Get libcec library information
+   * @returns {string} Library info string
+   */
+  getLibInfo() {
+    return this._adapter.getLibInfo();
+  }
+
+  // === Device Control ===
+
+  /**
+   * Power on devices
+   * @param {number} [address=LogicalAddress.TV] - Target device address
+   * @returns {boolean} True if command sent successfully
+   */
+  powerOnDevices(address = constants.LogicalAddress.TV) {
+    return this._adapter.powerOnDevices(address);
+  }
+
+  /**
+   * Put devices into standby
+   * @param {number} [address=LogicalAddress.BROADCAST] - Target device address
+   * @returns {boolean} True if command sent successfully
+   */
+  standbyDevices(address = constants.LogicalAddress.BROADCAST) {
+    return this._adapter.standbyDevices(address);
+  }
+
+  /**
+   * Set this device as the active source
+   * @param {number} [deviceType] - Device type
+   * @returns {boolean} True if command sent successfully
+   */
+  setActiveSource(deviceType) {
+    return this._adapter.setActiveSource(deviceType);
+  }
+
+  /**
+   * Mark this device as inactive source
+   * @returns {boolean} True if command sent successfully
+   */
+  setInactiveView() {
+    return this._adapter.setInactiveView();
+  }
+
+  // === Command Transmission ===
+
+  /**
+   * Transmit a raw CEC command
+   * @param {Object} command - Command object
+   * @param {number} command.initiator - Source logical address
+   * @param {number} command.destination - Target logical address
+   * @param {number} command.opcode - CEC opcode
+   * @param {number[]} [command.parameters] - Command parameters
+   * @returns {boolean} True if command sent successfully
+   */
+  transmit(command) {
+    return this._adapter.transmit(command);
+  }
+
+  /**
+   * Send a keypress to a device
+   * @param {number} destination - Target device address
+   * @param {number} keycode - User control code
+   * @param {boolean} [wait=false] - Wait for ACK
+   * @returns {boolean} True if command sent successfully
+   */
+  sendKeypress(destination, keycode, wait = false) {
+    return this._adapter.sendKeypress(destination, keycode, wait);
+  }
+
+  /**
+   * Send a key release to a device
+   * @param {number} destination - Target device address
+   * @param {boolean} [wait=false] - Wait for ACK
+   * @returns {boolean} True if command sent successfully
+   */
+  sendKeyRelease(destination, wait = false) {
+    return this._adapter.sendKeyRelease(destination, wait);
+  }
+
+  // === Device Information ===
+
+  /**
+   * Get the CEC version of a device
+   * @param {number} address - Device logical address
+   * @returns {number} CEC version
+   */
+  getDeviceCecVersion(address) {
+    return this._adapter.getDeviceCecVersion(address);
+  }
+
+  /**
+   * Get the menu language of a device
+   * @param {number} address - Device logical address
+   * @returns {string} Menu language (3-letter code)
+   */
+  getDeviceMenuLanguage(address) {
+    return this._adapter.getDeviceMenuLanguage(address);
+  }
+
+  /**
+   * Get the vendor ID of a device
+   * @param {number} address - Device logical address
+   * @returns {number} Vendor ID
+   */
+  getDeviceVendorId(address) {
+    return this._adapter.getDeviceVendorId(address);
+  }
+
+  /**
+   * Get the power status of a device
+   * @param {number} address - Device logical address
+   * @returns {number} Power status (see PowerStatus)
+   */
+  getDevicePowerStatus(address) {
+    return this._adapter.getDevicePowerStatus(address);
+  }
+
+  /**
+   * Get the OSD name of a device
+   * @param {number} address - Device logical address
+   * @returns {string} OSD name
+   */
+  getDeviceOSDName(address) {
+    return this._adapter.getDeviceOSDName(address);
+  }
+
+  /**
+   * Get the physical address of a device
+   * @param {number} address - Device logical address
+   * @returns {number} Physical address
+   */
+  getDevicePhysicalAddress(address) {
+    return this._adapter.getDevicePhysicalAddress(address);
+  }
+
+  // === Device Status ===
+
+  /**
+   * Poll a device to check if it's present
+   * @param {number} address - Device logical address
+   * @returns {boolean} True if device responds
+   */
+  pollDevice(address) {
+    return this._adapter.pollDevice(address);
+  }
+
+  /**
+   * Get all active devices on the bus
+   * @returns {number[]} Array of active logical addresses
+   */
+  getActiveDevices() {
+    return this._adapter.getActiveDevices();
+  }
+
+  /**
+   * Check if a device is active
+   * @param {number} address - Device logical address
+   * @returns {boolean} True if device is active
+   */
+  isActiveDevice(address) {
+    return this._adapter.isActiveDevice(address);
+  }
+
+  /**
+   * Check if a device type is active
+   * @param {number} type - Device type
+   * @returns {boolean} True if device type is active
+   */
+  isActiveDeviceType(type) {
+    return this._adapter.isActiveDeviceType(type);
+  }
+
+  /**
+   * Get the current active source
+   * @returns {number} Logical address of active source
+   */
+  getActiveSource() {
+    return this._adapter.getActiveSource();
+  }
+
+  /**
+   * Check if a device is the active source
+   * @param {number} address - Device logical address
+   * @returns {boolean} True if device is active source
+   */
+  isActiveSource(address) {
+    return this._adapter.isActiveSource(address);
+  }
+
+  /**
+   * Check if libcec is the active source
+   * @returns {boolean} True if libcec controls active source
+   */
+  isLibCECActiveSource() {
+    return this._adapter.isLibCECActiveSource();
+  }
+
+  // === Audio Control ===
+
+  /**
+   * Increase volume
+   * @param {boolean} [sendRelease=true] - Send key release after
+   * @returns {number} New audio status
+   */
+  volumeUp(sendRelease = true) {
+    return this._adapter.volumeUp(sendRelease);
+  }
+
+  /**
+   * Decrease volume
+   * @param {boolean} [sendRelease=true] - Send key release after
+   * @returns {number} New audio status
+   */
+  volumeDown(sendRelease = true) {
+    return this._adapter.volumeDown(sendRelease);
+  }
+
+  /**
+   * Mute audio
+   * @returns {number} Audio status
+   */
+  muteAudio() {
+    return this._adapter.muteAudio();
+  }
+
+  /**
+   * Toggle mute
+   * @returns {number} Audio status
+   */
+  audioToggleMute() {
+    return this._adapter.audioToggleMute();
+  }
+
+  /**
+   * Get current audio status
+   * @returns {number} Audio status
+   */
+  audioStatus() {
+    return this._adapter.audioStatus();
+  }
+
+  // === Display Control ===
+
+  /**
+   * Display a message on a device's OSD
+   * @param {number} address - Target device address
+   * @param {number} duration - Display control (see DisplayControl)
+   * @param {string} message - Message to display
+   * @returns {boolean} True if command sent successfully
+   */
+  setOSDString(address, duration, message) {
+    return this._adapter.setOSDString(address, duration, message);
+  }
+
+  // === Address Configuration ===
+
+  /**
+   * Set the logical address
+   * @param {number} [address=LogicalAddress.PLAYBACK_DEVICE_1] - Logical address
+   * @returns {boolean} True if successful
+   */
+  setLogicalAddress(address = constants.LogicalAddress.PLAYBACK_DEVICE_1) {
+    return this._adapter.setLogicalAddress(address);
+  }
+
+  /**
+   * Set the physical address
+   * @param {number} address - Physical address (e.g., 0x1000 for HDMI 1)
+   * @returns {boolean} True if successful
+   */
+  setPhysicalAddress(address) {
+    return this._adapter.setPhysicalAddress(address);
+  }
+
+  /**
+   * Set the HDMI port
+   * @param {number} baseDevice - Base device logical address (usually TV)
+   * @param {number} port - HDMI port number (1-15)
+   * @returns {boolean} True if successful
+   */
+  setHDMIPort(baseDevice, port) {
+    return this._adapter.setHDMIPort(baseDevice, port);
+  }
+
+  /**
+   * Get the logical addresses controlled by this adapter
+   * @returns {Object} Object with primary address and array of all addresses
+   */
+  getLogicalAddresses() {
+    return this._adapter.getLogicalAddresses();
+  }
+
+  // === Configuration ===
+
+  /**
+   * Get the current configuration
+   * @returns {Object} Configuration object
+   */
+  getCurrentConfiguration() {
+    return this._adapter.getCurrentConfiguration();
+  }
+
+  /**
+   * Set the configuration
+   * @param {Object} config - Configuration object
+   * @returns {boolean} True if successful
+   */
+  setConfiguration(config) {
+    return this._adapter.setConfiguration(config);
+  }
+
+  /**
+   * Rescan for active devices
+   */
+  rescanActiveDevices() {
+    this._adapter.rescanActiveDevices();
+  }
+
+  /**
+   * Disable all callbacks
+   * @returns {boolean} True if successful
+   */
+  disableCallbacks() {
+    return this._adapter.disableCallbacks();
+  }
+}
+
+// Export everything
+module.exports = {
+  CECAdapter,
+  ...constants
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "node-libcec",
+  "version": "1.0.0",
+  "description": "Node.js bindings for libcec - control CEC devices over HDMI",
+  "main": "lib/index.js",
+  "scripts": {
+    "build": "node-gyp rebuild",
+    "clean": "node-gyp clean",
+    "prepare": "npm run build",
+    "test": "node --test test/"
+  },
+  "keywords": [
+    "cec",
+    "hdmi",
+    "libcec",
+    "pulse-eight",
+    "consumer-electronics-control",
+    "tv",
+    "remote",
+    "home-automation",
+    "smart-home",
+    "native-addon"
+  ],
+  "author": "fajitacat",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "os": [
+    "linux",
+    "darwin",
+    "win32"
+  ],
+  "files": [
+    "lib/",
+    "src/",
+    "binding.gyp"
+  ],
+  "dependencies": {
+    "node-addon-api": "^8.0.0"
+  },
+  "devDependencies": {
+    "node-gyp": "^10.0.0"
+  },
+  "gypfile": true
+}