node-libcec 1.0.3 → 1.0.4

package/examples/advanced.js

@@ -0,0 +1,422 @@
+import {
+  CECAdapter,
+  LogicalAddress,
+  DeviceType,
+  PowerStatus,
+  UserControlCode,
+  DisplayControl,
+  Opcode,
+  Version
+} from '../lib/index.js';
+import readline from 'readline';
+
+/**
+ * Advanced example demonstrating more libcec features
+ */
+
+class CECController {
+  constructor() {
+    this.cec = new CECAdapter({
+      deviceName: 'AdvancedCEC',
+      deviceTypes: [DeviceType.PLAYBACK_DEVICE],
+      hdmiPort: 1,
+      activateSource: false
+    });
+
+    this.devices = new Map();
+    this.setupEventHandlers();
+  }
+
+  setupEventHandlers() {
+    // Log messages with filtering
+    this.cec.on('log', (msg) => {
+      // Only show warnings and errors
+      if (msg.level <= 2) {
+        const level = msg.level === 1 ? 'ERROR' : 'WARN';
+        console.log(`[${level}] ${msg.message}`);
+      }
+    });
+
+    // Handle remote control keypresses
+    this.cec.on('keypress', (key) => {
+      if (key.duration === 0) {
+        // Key pressed
+        this.handleKeyPress(key.keycode);
+      } else {
+        // Key released (duration > 0 indicates release)
+        this.handleKeyRelease(key.keycode, key.duration);
+      }
+    });
+
+    // Handle incoming CEC commands
+    this.cec.on('command', (cmd) => {
+      this.handleCommand(cmd);
+    });
+
+    // Handle source activation changes
+    this.cec.on('sourceActivated', (source) => {
+      if (source.activated) {
+        console.log(`Source activated: device ${source.logicalAddress}`);
+      } else {
+        console.log(`Source deactivated: device ${source.logicalAddress}`);
+      }
+    });
+
+    // Handle alerts
+    this.cec.on('alert', (alert) => {
+      console.log(`Alert received: type ${alert.type}`);
+    });
+
+    // Handle configuration changes
+    this.cec.on('configurationChanged', (config) => {
+      console.log('Configuration changed:', config);
+    });
+  }
+
+  handleKeyPress(keycode) {
+    const keyName = Object.keys(UserControlCode).find(k => UserControlCode[k] === keycode) || keycode;
+    console.log(`Key pressed: ${keyName}`);
+
+    // Example: Handle specific keys
+    switch (keycode) {
+      case UserControlCode.PLAY:
+        console.log('  -> Play action');
+        break;
+      case UserControlCode.PAUSE:
+        console.log('  -> Pause action');
+        break;
+      case UserControlCode.STOP:
+        console.log('  -> Stop action');
+        break;
+      case UserControlCode.UP:
+      case UserControlCode.DOWN:
+      case UserControlCode.LEFT:
+      case UserControlCode.RIGHT:
+        console.log('  -> Navigation');
+        break;
+      case UserControlCode.SELECT:
+        console.log('  -> Select/Enter');
+        break;
+      case UserControlCode.EXIT:
+      case UserControlCode.ROOT_MENU:
+        console.log('  -> Menu action');
+        break;
+    }
+  }
+
+  handleKeyRelease(keycode, duration) {
+    console.log(`Key released after ${duration}ms`);
+  }
+
+  handleCommand(cmd) {
+    const opcodeName = Object.keys(Opcode).find(k => Opcode[k] === cmd.opcode) || `0x${cmd.opcode.toString(16)}`;
+    console.log(`Command: ${opcodeName} from ${cmd.initiator} to ${cmd.destination}`);
+
+    // Handle specific commands
+    switch (cmd.opcode) {
+      case Opcode.STANDBY:
+        console.log('  -> Standby requested');
+        break;
+      case Opcode.GIVE_DEVICE_POWER_STATUS:
+        console.log('  -> Power status requested');
+        break;
+      case Opcode.REQUEST_ACTIVE_SOURCE:
+        console.log('  -> Active source requested');
+        break;
+      case Opcode.SET_STREAM_PATH:
+        if (cmd.parameters.length >= 2) {
+          const physAddr = (cmd.parameters[0] << 8) | cmd.parameters[1];
+          console.log(`  -> Stream path set to ${formatPhysicalAddress(physAddr)}`);
+        }
+        break;
+    }
+  }
+
+  connect() {
+    const adapters = CECAdapter.detectAdapters();
+    if (adapters.length === 0) {
+      throw new Error('No CEC adapters found');
+    }
+
+    console.log('Detected adapters:');
+    adapters.forEach((a, i) => {
+      console.log(`  ${i}: ${a.comName} (${a.comPath})`);
+      console.log(`     Vendor: 0x${a.vendorId.toString(16)}, Product: 0x${a.productId.toString(16)}`);
+      console.log(`     Firmware: v${a.firmwareVersion}`);
+    });
+
+    if (!this.cec.open()) {
+      throw new Error('Failed to open CEC adapter');
+    }
+
+    console.log('\nConnected to CEC adapter');
+    console.log('Library info:', this.cec.getLibInfo());
+  }
+
+  async scanDevices() {
+    console.log('\nScanning CEC bus...');
+    this.cec.rescanActiveDevices();
+
+    // Small delay to let scan complete
+    await sleep(1000);
+
+    const activeDevices = this.cec.getActiveDevices();
+    console.log(`Found ${activeDevices.length} devices\n`);
+
+    for (const addr of activeDevices) {
+      const device = {
+        address: addr,
+        name: this.cec.getDeviceOSDName(addr),
+        vendorId: this.cec.getDeviceVendorId(addr),
+        physicalAddress: this.cec.getDevicePhysicalAddress(addr),
+        cecVersion: this.cec.getDeviceCecVersion(addr),
+        powerStatus: this.cec.getDevicePowerStatus(addr),
+        language: this.cec.getDeviceMenuLanguage(addr),
+        isActiveSource: this.cec.isActiveSource(addr)
+      };
+
+      this.devices.set(addr, device);
+      this.printDeviceInfo(device);
+    }
+  }
+
+  printDeviceInfo(device) {
+    const addrName = Object.keys(LogicalAddress).find(k => LogicalAddress[k] === device.address) || device.address;
+    const powerName = Object.keys(PowerStatus).find(k => PowerStatus[k] === device.powerStatus) || device.powerStatus;
+    const versionName = Object.keys(Version).find(k => Version[k] === device.cecVersion) || device.cecVersion;
+
+    console.log(`Device: ${addrName} (${device.address})`);
+    console.log(`  OSD Name: ${device.name || '(unknown)'}`);
+    console.log(`  Physical Address: ${formatPhysicalAddress(device.physicalAddress)}`);
+    console.log(`  Vendor: ${formatVendorId(device.vendorId)}`);
+    console.log(`  CEC Version: ${versionName}`);
+    console.log(`  Power Status: ${powerName}`);
+    console.log(`  Menu Language: ${device.language || '(unknown)'}`);
+    console.log(`  Active Source: ${device.isActiveSource ? 'Yes' : 'No'}`);
+    console.log();
+  }
+
+  // Power control
+  async powerOn(address = LogicalAddress.TV) {
+    console.log(`Powering on device ${address}...`);
+    return this.cec.powerOnDevices(address);
+  }
+
+  async powerOff(address = LogicalAddress.BROADCAST) {
+    console.log(`Putting device ${address} into standby...`);
+    return this.cec.standbyDevices(address);
+  }
+
+  // Source control
+  becomeActiveSource() {
+    console.log('Becoming active source...');
+    return this.cec.setActiveSource();
+  }
+
+  becomeInactive() {
+    console.log('Becoming inactive...');
+    return this.cec.setInactiveView();
+  }
+
+  // Volume control
+  async adjustVolume(direction, steps = 1) {
+    for (let i = 0; i < steps; i++) {
+      if (direction === 'up') {
+        this.cec.volumeUp();
+      } else {
+        this.cec.volumeDown();
+      }
+      await sleep(100);
+    }
+  }
+
+  toggleMute() {
+    return this.cec.audioToggleMute();
+  }
+
+  getAudioStatus() {
+    const status = this.cec.audioStatus();
+    const muted = (status & 0x80) !== 0;
+    const volume = status & 0x7F;
+    return { muted, volume };
+  }
+
+  // Display message on TV
+  showMessage(message, address = LogicalAddress.TV) {
+    console.log(`Showing message on device ${address}: "${message}"`);
+    return this.cec.setOSDString(address, DisplayControl.DISPLAY_FOR_DEFAULT_TIME, message);
+  }
+
+  // Send raw CEC command
+  sendCommand(initiator, destination, opcode, parameters = []) {
+    return this.cec.transmit({
+      initiator,
+      destination,
+      opcode,
+      parameters
+    });
+  }
+
+  // Simulate remote control
+  pressButton(address, button) {
+    this.cec.sendKeypress(address, button);
+    return sleep(100).then(() => this.cec.sendKeyRelease(address));
+  }
+
+  close() {
+    console.log('Closing CEC connection...');
+    this.cec.close();
+  }
+}
+
+// Helper functions
+function formatPhysicalAddress(addr) {
+  return `${(addr >> 12) & 0xF}.${(addr >> 8) & 0xF}.${(addr >> 4) & 0xF}.${addr & 0xF}`;
+}
+
+function formatVendorId(id) {
+  const vendors = {
+    0x000039: 'Toshiba',
+    0x0000F0: 'Samsung',
+    0x0005CD: 'Denon',
+    0x000678: 'Marantz',
+    0x000982: 'Loewe',
+    0x0009B0: 'Onkyo',
+    0x001582: 'Pulse-Eight',
+    0x001950: 'Harman Kardon',
+    0x001A11: 'Google',
+    0x00903E: 'Philips',
+    0x009053: 'Daewoo',
+    0x00A0DE: 'Yamaha',
+    0x00D0D5: 'Pioneer',
+    0x00E036: 'Sharp',
+    0x00E091: 'LG',
+    0x080046: 'Sony',
+    0x18C086: 'Broadcom',
+    0x6B746D: 'Vizio',
+    0x8065E9: 'Benq'
+  };
+  return vendors[id] || `0x${id.toString(16).padStart(6, '0')}`;
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// Interactive CLI
+async function interactiveMode(controller) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const prompt = () => {
+    rl.question('\ncec> ', async (input) => {
+      const [cmd, ...args] = input.trim().split(' ');
+
+      try {
+        switch (cmd) {
+          case 'scan':
+            await controller.scanDevices();
+            break;
+          case 'on':
+            await controller.powerOn(parseInt(args[0]) || LogicalAddress.TV);
+            break;
+          case 'off':
+          case 'standby':
+            await controller.powerOff(parseInt(args[0]) || LogicalAddress.BROADCAST);
+            break;
+          case 'active':
+            controller.becomeActiveSource();
+            break;
+          case 'inactive':
+            controller.becomeInactive();
+            break;
+          case 'vol+':
+            await controller.adjustVolume('up', parseInt(args[0]) || 1);
+            break;
+          case 'vol-':
+            await controller.adjustVolume('down', parseInt(args[0]) || 1);
+            break;
+          case 'mute':
+            controller.toggleMute();
+            break;
+          case 'audio':
+            const audio = controller.getAudioStatus();
+            console.log(`Volume: ${audio.volume}%, Muted: ${audio.muted}`);
+            break;
+          case 'msg':
+            controller.showMessage(args.join(' ') || 'Hello from Node.js!');
+            break;
+          case 'status':
+            const addr = parseInt(args[0]) || LogicalAddress.TV;
+            const power = controller.cec.getDevicePowerStatus(addr);
+            const powerName = Object.keys(PowerStatus).find(k => PowerStatus[k] === power);
+            console.log(`Device ${addr} power status: ${powerName}`);
+            break;
+          case 'config':
+            console.log(controller.cec.getCurrentConfiguration());
+            break;
+          case 'help':
+            console.log(`
+Commands:
+  scan              - Scan for CEC devices
+  on [addr]         - Power on device (default: TV)
+  off [addr]        - Standby device (default: all)
+  active            - Become active source
+  inactive          - Become inactive
+  vol+ [steps]      - Volume up
+  vol- [steps]      - Volume down
+  mute              - Toggle mute
+  audio             - Show audio status
+  msg <text>        - Display message on TV
+  status [addr]     - Get device power status
+  config            - Show current configuration
+  quit              - Exit
+            `);
+            break;
+          case 'quit':
+          case 'exit':
+            controller.close();
+            rl.close();
+            process.exit(0);
+            break;
+          case '':
+            break;
+          default:
+            console.log(`Unknown command: ${cmd}. Type 'help' for commands.`);
+        }
+      } catch (err) {
+        console.error('Error:', err.message);
+      }
+
+      prompt();
+    });
+  };
+
+  prompt();
+}
+
+// Main
+async function main() {
+  const controller = new CECController();
+
+  process.on('SIGINT', () => {
+    console.log('\nInterrupted');
+    controller.close();
+    process.exit(0);
+  });
+
+  try {
+    controller.connect();
+    await controller.scanDevices();
+
+    console.log("Type 'help' for available commands\n");
+    await interactiveMode(controller);
+  } catch (err) {
+    console.error('Error:', err.message);
+    process.exit(1);
+  }
+}
+
+main();

package/examples/basic.js

@@ -0,0 +1,98 @@
+import {
+  CECAdapter,
+  LogicalAddress,
+  DeviceType,
+  PowerStatus,
+  UserControlCode,
+  DisplayControl
+} from '../lib/index.js';
+
+async function main() {
+  // Detect available adapters
+  const adapters = CECAdapter.detectAdapters();
+  console.log('Found adapters:', adapters);
+
+  if (adapters.length === 0) {
+    console.log('No CEC adapters found');
+    return;
+  }
+
+  // Create adapter instance
+  const cec = new CECAdapter({
+    deviceName: 'NodeCEC',
+    deviceTypes: [DeviceType.RECORDING_DEVICE],
+    activateSource: false
+  });
+
+  // Set up event listeners
+  cec.on('log', (msg) => {
+    console.log(`[LOG ${msg.level}] ${msg.message}`);
+  });
+
+  cec.on('keypress', (key) => {
+    console.log(`Key pressed: ${key.keycode} (duration: ${key.duration}ms)`);
+  });
+
+  cec.on('command', (cmd) => {
+    console.log(`Command received:`, cmd);
+  });
+
+  cec.on('sourceActivated', (source) => {
+    console.log(`Source ${source.logicalAddress} activated: ${source.activated}`);
+  });
+
+  // Open connection (auto-detect port)
+  console.log('Opening connection...');
+  if (!cec.open()) {
+    console.error('Failed to open CEC adapter');
+    return;
+  }
+  console.log('Connected!');
+
+  // Get library info
+  console.log('Library:', cec.getLibInfo());
+
+  // Scan for active devices
+  console.log('\nScanning for devices...');
+  const devices = cec.getActiveDevices();
+  console.log('Active devices:', devices);
+
+  // Get info about each device
+  for (const addr of devices) {
+    const name = cec.getDeviceOSDName(addr);
+    const vendor = cec.getDeviceVendorId(addr);
+    const power = cec.getDevicePowerStatus(addr);
+    const physical = cec.getDevicePhysicalAddress(addr);
+
+    console.log(`\nDevice ${addr}:`);
+    console.log(`  Name: ${name}`);
+    console.log(`  Vendor ID: 0x${vendor.toString(16)}`);
+    console.log(`  Power: ${PowerStatus[Object.keys(PowerStatus).find(k => PowerStatus[k] === power)] || power}`);
+    console.log(`  Physical Address: ${(physical >> 12) & 0xF}.${(physical >> 8) & 0xF}.${(physical >> 4) & 0xF}.${physical & 0xF}`);
+  }
+
+  // Example: Power on the TV
+  // console.log('\nPowering on TV...');
+  // cec.powerOnDevices(LogicalAddress.TV);
+
+  // Example: Set as active source
+  // console.log('Setting as active source...');
+  // cec.setActiveSource();
+
+  // Example: Display message on TV
+  // cec.setOSDString(LogicalAddress.TV, DisplayControl.DISPLAY_FOR_DEFAULT_TIME, 'Hello from Node!');
+
+  // Example: Send remote button press
+  // cec.sendKeypress(LogicalAddress.TV, UserControlCode.VOLUME_UP);
+
+  // Keep running to receive events
+  console.log('\nListening for CEC events (Ctrl+C to exit)...');
+
+  process.on('SIGINT', () => {
+    console.log('\nClosing...');
+    cec.close();
+    process.exit(0);
+  });
+}
+
+main().catch(console.error);

package/examples/diagnose.js

@@ -0,0 +1,148 @@
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const require = createRequire(import.meta.url);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+console.log('=== node-libcec Diagnostic Script ===\n');
+console.log('Step 1: Loading native module...');
+
+let native;
+try {
+  native = require(join(__dirname, '../build/Release/cec.node'));
+  console.log('  OK: Loaded Release build');
+} catch (e) {
+  try {
+    native = require(join(__dirname, '../build/Debug/cec.node'));
+    console.log('  OK: Loaded Debug build');
+  } catch (e2) {
+    console.error('  FAILED: Could not load native module');
+    console.error('  Error:', e2.message);
+    process.exit(1);
+  }
+}
+
+console.log('  Native module exports:', Object.keys(native));
+
+console.log('\nStep 2: Detecting adapters (static method, no instance)...');
+const detectStart = Date.now();
+try {
+  const adapters = native.CECAdapter.detectAdapters();
+  console.log(`  OK: Found ${adapters.length} adapter(s) in ${Date.now() - detectStart}ms`);
+  adapters.forEach((a, i) => {
+    console.log(`  Adapter ${i}: ${a.comName} @ ${a.comPath}`);
+  });
+
+  if (adapters.length === 0) {
+    console.log('\n  No adapters found. Make sure your CEC adapter is connected.');
+    console.log('  Try: ls -la /dev/ttyACM* /dev/ttyUSB*');
+    process.exit(0);
+  }
+} catch (e) {
+  console.error('  FAILED:', e.message);
+  process.exit(1);
+}
+
+console.log('\nStep 3: Creating CECAdapter instance (no callbacks)...');
+const createStart = Date.now();
+let adapter;
+try {
+  adapter = new native.CECAdapter({
+    deviceName: 'Diagnose',
+    deviceTypes: [1], // RECORDING_DEVICE
+    activateSource: false
+  });
+  console.log(`  OK: Instance created in ${Date.now() - createStart}ms`);
+} catch (e) {
+  console.error('  FAILED:', e.message);
+  process.exit(1);
+}
+
+console.log('\nStep 4: Setting up callbacks...');
+const cbStart = Date.now();
+try {
+  adapter.setCallbacks({
+    onLogMessage: (msg) => {
+      console.log(`  [LOG] level=${msg.level}: ${msg.message}`);
+    },
+    onKeyPress: (key) => {
+      console.log(`  [KEY] keycode=${key.keycode} duration=${key.duration}`);
+    },
+    onCommand: (cmd) => {
+      console.log(`  [CMD] opcode=${cmd.opcode} from=${cmd.initiator} to=${cmd.destination}`);
+    },
+    onAlert: (alert) => {
+      console.log(`  [ALERT] type=${alert.type}`);
+    },
+    onSourceActivated: (src) => {
+      console.log(`  [SRC] address=${src.logicalAddress} activated=${src.activated}`);
+    },
+    onConfigurationChanged: (cfg) => {
+      console.log(`  [CFG] changed`);
+    }
+  });
+  console.log(`  OK: Callbacks set in ${Date.now() - cbStart}ms`);
+} catch (e) {
+  console.error('  FAILED:', e.message);
+  process.exit(1);
+}
+
+console.log('\nStep 5: Opening connection (this is where it might hang)...');
+console.log('  Starting open() - will timeout after 30 seconds...');
+const openStart = Date.now();
+
+// Set a timeout to detect hang
+const timeout = setTimeout(() => {
+  console.error(`\n  TIMEOUT: open() has been running for 30 seconds`);
+  console.error('  This indicates a deadlock in the native code.');
+  console.error('  The callbacks are likely using BlockingCall instead of NonBlockingCall.');
+  process.exit(1);
+}, 30000);
+
+let opened = false;
+try {
+  opened = adapter.open();
+  clearTimeout(timeout);
+  console.log(`  OK: open() returned ${opened} in ${Date.now() - openStart}ms`);
+} catch (e) {
+  clearTimeout(timeout);
+  console.error(`  FAILED: open() threw after ${Date.now() - openStart}ms`);
+  console.error('  Error:', e.message);
+  process.exit(1);
+}
+
+if (!opened) {
+  console.log('\n  open() returned false - adapter could not be opened');
+  console.log('  Check permissions: ls -la /dev/ttyACM*');
+  console.log('  You may need: sudo usermod -a -G dialout $USER');
+  process.exit(1);
+}
+
+console.log('\nStep 6: Getting library info...');
+try {
+  const info = adapter.getLibInfo();
+  console.log('  OK:', info);
+} catch (e) {
+  console.error('  FAILED:', e.message);
+}
+
+console.log('\nStep 7: Getting active devices...');
+try {
+  const devices = adapter.getActiveDevices();
+  console.log(`  OK: Found ${devices.length} active device(s):`, devices);
+} catch (e) {
+  console.error('  FAILED:', e.message);
+}
+
+console.log('\nStep 8: Closing connection...');
+try {
+  adapter.close();
+  console.log('  OK: Closed');
+} catch (e) {
+  console.error('  FAILED:', e.message);
+}
+
+console.log('\n=== Diagnostic Complete ===');
+console.log('If you see this message, the basic operations are working.');
+process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-libcec",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Node.js bindings for libcec - control CEC devices over HDMI",
   "type": "module",
   "main": "lib/index.js",
@@ -41,6 +41,7 @@
   "files": [
     "lib/",
     "src/",
+    "examples/",
     "binding.gyp"
   ],
   "dependencies": {