homebridge-xbox-tv 3.7.9-beta.21 → 3.7.9-beta.23

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "Xbox TV",
   "name": "homebridge-xbox-tv",
-  "version": "3.7.9-beta.21",
+  "version": "3.7.9-beta.23",
   "description": "Homebridge plugin to control Xbox game consoles.",
   "license": "MIT",
   "author": "grzegorz914",

package/src/localApi/structure.js

@@ -1,140 +1,148 @@
 class Structure {
     constructor(packet) {
-        packet = packet === undefined ? Buffer.from('') : packet;
-        this.packet = packet;
-        this.totalLength = packet.length;
+        this.packet = packet ?? Buffer.alloc(0);
+        this.totalLength = this.packet.length;
         this.offset = 0;
-
-        return this;
-    };
+    }
 
     writeSGString(data) {
         if (typeof data !== 'string') {
             throw new Error('data must be a string');
         }
 
-        const dataLength = data.length;
+        const dataLength = Buffer.byteLength(data, 'utf8');
         if (dataLength > 65535) {
             throw new Error('data exceeds the maximum allowed length');
         }
 
         const stringLengthBuffer = Buffer.allocUnsafe(2);
         stringLengthBuffer.writeUInt16BE(dataLength, 0);
-        const dataBuffer = Buffer.from(data + '\x00');
-        this.add(Buffer.concat([stringLengthBuffer, dataBuffer]));
+
+        const dataBuffer = Buffer.from(data, 'utf8');
+        const nullTerminator = Buffer.from([0]);
+
+        this.add(Buffer.concat([stringLengthBuffer, dataBuffer, nullTerminator]));
         return this;
-    };
+    }
 
     readSGString() {
         const stringLength = this.readUInt16();
         const stringBuffer = this.packet.slice(this.offset, this.offset + stringLength);
-        this.offset += stringLength + 1;
-        return stringBuffer;
-    };
+        this.offset += stringLength + 1; // skip null terminator
+        return stringBuffer.toString('utf8');
+    }
 
     writeBytes(data, type) {
         const dataBuffer = Buffer.from(data, type);
         this.add(dataBuffer);
         return this;
-    };
+    }
 
     readBytes(length = false) {
-        let rawData = '';
-        switch (length) {
-            case false:
-                rawData = this.packet.slice(this.offset);
-                this.offset = this.totalLength;
-                break;
-            default:
-                rawData = this.packet.slice(this.offset, this.offset + length);
-                this.offset += length;
-                break
+        let rawData;
+        if (length === false) {
+            rawData = this.packet.slice(this.offset);
+            this.offset = this.totalLength;
+        } else {
+            rawData = this.packet.slice(this.offset, this.offset + length);
+            this.offset += length;
         }
         return rawData;
-    };
+    }
 
     writeUInt8(data) {
         if (data < 0 || data > 255) {
             throw new Error('data must be a valid unsigned 8-bit integer');
         }
-
-        const uint8Buffer = Buffer.allocUnsafe(1);
-        uint8Buffer.writeUInt8(data, 0);
-        this.add(uint8Buffer);
+        const buf = Buffer.allocUnsafe(1);
+        buf.writeUInt8(data, 0);
+        this.add(buf);
         return this;
-    };
+    }
 
     readUInt8() {
-        const uint8 = this.packet.readUInt8BE(this.offset);
+        const value = this.packet.readUInt8(this.offset);
         this.offset += 1;
-        return uint8;
-    };
+        return value;
+    }
 
     writeUInt16(data) {
         if (data < 0 || data > 65535) {
             throw new Error('data must be a valid unsigned 16-bit integer');
         }
-
-        const uint16Buffer = Buffer.allocUnsafe(2);
-        uint16Buffer.writeUInt16BE(data, 0);
-        this.add(uint16Buffer);
+        const buf = Buffer.allocUnsafe(2);
+        buf.writeUInt16BE(data, 0);
+        this.add(buf);
         return this;
-    };
+    }
 
     readUInt16() {
-        const uint16 = this.packet.readUInt16BE(this.offset);
+        const value = this.packet.readUInt16BE(this.offset);
         this.offset += 2;
-        return uint16;
-    };
+        return value;
+    }
 
     writeUInt32(data) {
-        if (data < 0 || data > 4294967295) {
+        if (data < 0 || data > 0xFFFFFFFF) {
             throw new Error('data must be a valid unsigned 32-bit integer');
         }
-
-        const uint32Buffer = Buffer.allocUnsafe(4);
-        uint32Buffer.writeUInt32BE(data, 0);
-        this.add(uint32Buffer);
+        const buf = Buffer.allocUnsafe(4);
+        buf.writeUInt32BE(data, 0);
+        this.add(buf);
         return this;
-    };
+    }
 
     readUInt32() {
-        const uint32 = this.packet.readUInt32BE(this.offset);
+        const value = this.packet.readUInt32BE(this.offset);
         this.offset += 4;
-        return uint32;
-    };
+        return value;
+    }
 
     writeInt32(data) {
         if (data < -2147483648 || data > 2147483647) {
             throw new Error('data must be a valid signed 32-bit integer');
         }
-        const int32Buffer = Buffer.allocUnsafe(4);
-        int32Buffer.writeInt32BE(data, 0);
-        this.add(int32Buffer);
+        const buf = Buffer.allocUnsafe(4);
+        buf.writeInt32BE(data, 0);
+        this.add(buf);
         return this;
-    };
+    }
 
     readInt32() {
-        const int32 = this.packet.readInt32BE(this.offset);
+        const value = this.packet.readInt32BE(this.offset);
         this.offset += 4;
-        return int32;
-    };
+        return value;
+    }
+
+    writeUInt64(value) {
+        if (typeof value !== 'bigint') {
+            throw new Error('value must be a BigInt');
+        }
+        const buf = Buffer.allocUnsafe(8);
+        buf.writeUInt32BE(Number(value >> 32n), 0);
+        buf.writeUInt32BE(Number(value & 0xFFFFFFFFn), 4);
+        this.add(buf);
+        return this;
+    }
 
     readUInt64() {
-        const data = this.readBytes(8);
-        return data;
-    };
+        const high = this.packet.readUInt32BE(this.offset);
+        const low = this.packet.readUInt32BE(this.offset + 4);
+        this.offset += 8;
+        return (BigInt(high) << 32n) | BigInt(low);
+    }
 
     toBuffer() {
         return this.packet;
-    };
+    }
 
     add(data) {
         if (!Buffer.isBuffer(data)) {
             throw new Error('Data must be a Buffer object');
         }
-
         this.packet = Buffer.concat([this.packet, data]);
-    };
-};
-export default Structure;
+        this.totalLength = this.packet.length;
+    }
+}
+
+export default Structure;

package/src/localApi/xboxlocalapi.js

@@ -30,6 +30,7 @@ class XboxLocalApi extends EventEmitter {
         this.channels = [];
         this.channelRequestId = 0;
         this.mediaRequestId = 0;
+        this.fragments = {};
 
         //create impulse generator
         this.impulseGenerator = new ImpulseGenerator();
@@ -205,8 +206,8 @@ class XboxLocalApi extends EventEmitter {
         };
 
         const channelRequestId = LocalApi.Channels.System[channelName].Id
-        const channelCommunicationId = this.channels[requestId].id;
-        const channelOpen = this.channels[requestId].open;
+        const channelCommunicationId = this.channels[channelRequestId]?.id ?? -1;
+        const channelOpen = this.channels[channelRequestId]?.open ?? false;
 
         if (channelCommunicationId === -1 || !channelOpen) {
             this.emit('warn', `Channel Id: ${channelCommunicationId}, state: ${channelOpen ? 'Open' : 'Closed'}, trying to open it`);
@@ -278,91 +279,6 @@ class XboxLocalApi extends EventEmitter {
         return true;
     };
 
-    // Dodaj do klasy XboxLocalApi:
-
-    async sendSystemButton(channelName, command) {
-        if (!this.isConnected) {
-            this.emit('warn', `Cannot send command, console not connected`);
-            return;
-        }
-
-        const channelInfo = LocalApi.Channels.System[channelName];
-        if (!channelInfo) {
-            this.emit('warn', `Unknown channel: ${channelName}`);
-            return;
-        }
-
-        let channel = this.channels.find(c => c.id !== -1);
-        if (!channel) {
-            // Otwórz kanał jeśli nie istnieje
-            await this.channelOpen(channelInfo.Id, channelInfo.Uuid);
-            channel = this.channels.find(c => c.id !== -1);
-            if (!channel) {
-                this.emit('warn', `Failed to open channel: ${channelName}`);
-                return;
-            }
-        }
-
-        const channelId = channel.id;
-
-        switch (channelInfo.Id) {
-            case 0: // Gamepad
-                await this._sendGamepadCommand(command, channelId);
-                break;
-            case 1: // TvRemote
-                await this._sendTvRemoteCommand(command, channelId);
-                break;
-            case 2: // Media
-                await this._sendMediaCommand(command, channelId);
-                break;
-            default:
-                this.emit('warn', `Unhandled channel type: ${channelName}`);
-        }
-    }
-
-    // Prywatne metody do wysyłania komend
-    async _sendGamepadCommand(buttons, channelId) {
-        const timestamp = Buffer.from(`000${Date.now()}`, 'hex');
-        const press = new MessagePacket('gamepad');
-        press.set('timestamp', timestamp);
-        press.set('buttons', buttons);
-        let seq = await this.getSequenceNumber();
-        await this.sendSocketMessage(press.pack(this.crypto, seq, this.sourceParticipantId, channelId), 'gamepad');
-
-        // Release buttons
-        setTimeout(async () => {
-            const release = new MessagePacket('gamepad');
-            release.set('timestamp', timestamp);
-            release.set('buttons', LocalApi.Channels.System.Input.Commands.unpress);
-            seq = await this.getSequenceNumber();
-            await this.sendSocketMessage(release.pack(this.crypto, seq, this.sourceParticipantId, channelId), 'gamepadUnpress');
-        }, 150);
-    }
-
-    async _sendTvRemoteCommand(command, channelId) {
-        const seq = await this.getSequenceNumber();
-        const jsonReq = JSON.stringify({
-            msgid: `2ed6c0fd.${seq}`,
-            request: LocalApi.Channels.System.TvRemote.MessageType.SendKey,
-            params: { button_id: command, device_id: null }
-        });
-        const json = new MessagePacket('json');
-        json.set('json', jsonReq);
-        await this.sendSocketMessage(json.pack(this.crypto, seq, this.sourceParticipantId, channelId), 'json');
-    }
-
-    async _sendMediaCommand(command, channelId) {
-        const requestIdHex = (`0000000000000000${this.mediaRequestId}`).slice(-16);
-        const media = new MessagePacket('mediaCommand');
-        media.set('requestId', Buffer.from(requestIdHex, 'hex'));
-        media.set('titleId', 0);
-        media.set('command', command);
-        const seq = await this.getSequenceNumber();
-        await this.sendSocketMessage(media.pack(this.crypto, seq, this.sourceParticipantId, channelId), 'mediaCommand');
-        this.mediaRequestId++;
-    }
-
-
     async disconnect() {
         if (this.enableDebugMode) this.emit('debug', 'Disconnecting...');
 
@@ -475,7 +391,7 @@ class XboxLocalApi extends EventEmitter {
                     switch (type) {
                         case 'json':
                             // Object to hold fragments
-                            const fragments = {};
+                            const fragments = this.fragments;
                             const jsonMessage = JSON.parse(packet.payloadProtected.json);
                             const datagramId = jsonMessage.datagramId;
 

package/src/xboxdevice.js

@@ -658,10 +658,7 @@ class XboxDevice extends EventEmitter {
                                 break;
                         }
 
-                        //await this.xboxWebApi.send(channelName, 'InjectKey', [{ 'keyType': command }]);
-                        await this.xboxLocalApi.sendSystemButton('Input', LocalApi.Channels.System.Input.Commands[command]);
-                        //await xboxLocalApi.sendSystemButton('TvRemote', LocalApi.Channels.System.TvRemote.Buttons.Power);
-                        //await xboxLocalApi.sendSystemButton('Media', LocalApi.Channels.System.Media.Commands[command]);
+                        await this.xboxWebApi.send(channelName, 'InjectKey', [{ 'keyType': command }]);
                         if (!this.disableLogInfo) this.emit('info', `Remote Key: ${command}`);
                     } catch (error) {
                         this.emit('warn', `set Remote Key error: ${JSON.stringify(error, null, 2)}`);