@phystack/hub-client 4.4.52 → 4.4.53

package/src/peripheral-twin.ts

@@ -0,0 +1,356 @@
+import { EventPayload, PhygridDataChannel, PhygridMediaStream, PhyHubClient } from ".";
+import { Instance, TwinResponse, TwinTypeEnum } from "./types/twin.types";
+
+export class PeripheralTwinInstance {
+  public phyHubClient: PhyHubClient;
+  public twinId: string;
+  public edgeInstance: Instance | null = null;
+  public peripheralTwinResponse: TwinResponse | null = null;
+
+  private instanceTypePrefix = 'peripheralInstance';
+
+  constructor(phyHubClient: PhyHubClient, twinId: string) {
+    this.phyHubClient = phyHubClient;
+    this.twinId = twinId;
+  }
+
+  // initialize the instance by performing sanity checks
+  async initialize() {
+    const edgeInstance = await this.phyHubClient.getInstance();
+    if (!edgeInstance) {
+      console.error('Edge instance not found');
+      throw new Error('Edge instance not found');
+    }
+    this.edgeInstance = edgeInstance;
+
+    const peripheralTwinResponse = await this.phyHubClient.getTwinById(this.twinId);
+    if (!peripheralTwinResponse) {
+      console.error(`Peripheral twin with id ${this.twinId} not found`);
+      throw new Error(`Peripheral twin with id ${this.twinId} not found`);
+    }
+
+    if (peripheralTwinResponse.type !== TwinTypeEnum.Peripheral) {
+      console.error(`Twin ${this.twinId} is not a peripheral twin`);
+      throw new Error(`Twin ${this.twinId} is not a peripheral twin`);
+    }
+
+    this.peripheralTwinResponse = peripheralTwinResponse;
+
+    await this.phyHubClient.subscribeTwin(this.twinId);
+  }
+
+  // alias to sendEvent()
+  async emit(eventType: string, payload: any) {
+    return await this.sendEvent(eventType, payload);
+  }
+
+  async sendEvent(eventType: string, payload: any) {
+    return await this.peripheralTwinEmit(eventType, payload);
+  }
+
+  private async peripheralTwinEmit(eventType: string, payload: any) {
+    if (!this.edgeInstance || !this.peripheralTwinResponse) {
+     throw new Error('Object is not initialized correctly');
+    }
+
+    const messagePayload = {
+      type: `${this.instanceTypePrefix}:${this.peripheralTwinResponse.id}:${eventType}`,
+      sourceTwinId: this.peripheralTwinResponse.id,
+      sourceDeviceId: this.edgeInstance.deviceId,
+      data: payload,
+    };
+
+    const result = await this.phyHubClient.sendTwinMessage(this.peripheralTwinResponse.id, messagePayload);
+    return result;
+  };
+
+  // alias to onEvent()
+  on(eventType: string, callback: (message: any) => void) {
+    return this.onEvent(eventType, callback);
+  }
+
+  onEvent(eventType: string, callback: (message: any) => void) {
+    return this.peripheralTwinOn(eventType, callback);
+  }
+
+  private peripheralTwinOn(eventType: string, callback: (message: any) => void) {
+    console.log(`Setting up listener for peripheral ${this.twinId} event: ${eventType}`);
+
+    if (!this.peripheralTwinResponse) {
+      console.error('Object is not initialized correctly');
+      return;
+    }
+
+    const onMessage = (payload: any) => {
+      // console.log(`Received message for peripheral ${peripheralTwinId}:`, payload);
+      const messageType = payload.data?.type || payload.type;
+      if (messageType === `${this.instanceTypePrefix}:${this.peripheralTwinResponse!.id}:${eventType}`) {
+        // console.log('Processing matching message type');
+        callback(payload.data?.data || payload.data);
+      } else {
+        // console.log('Ignoring non-matching message type:', messageType);
+      }
+    };
+
+    this.phyHubClient.onTwinMessage(this.peripheralTwinResponse.id, onMessage);
+  };
+
+  to(targetTwinId: string) {
+    return {
+      emit: async (eventType: string, payload: any) => {
+        if (!this.edgeInstance || !this.peripheralTwinResponse) {
+          throw new Error('Object is not initialized correctly');
+        }
+
+        const messagePayload = {
+          type: `${this.instanceTypePrefix}:${this.peripheralTwinResponse.id}:${eventType}`,
+          sourceTwinId: this.edgeInstance.id,
+          sourceDeviceId: this.edgeInstance.deviceId,
+          data: payload,
+        };
+
+        return await this.phyHubClient.sendTwinMessage(targetTwinId, messagePayload);
+      }
+    }
+  }
+
+  async getDataChannel() {
+    if (!this.peripheralTwinResponse) {
+      console.error('Object is not initialized correctly');
+      return;
+    }
+
+    return await this.phyHubClient.getDataChannel(this.peripheralTwinResponse.id);
+  };
+
+  async onDataChannel(callback: (dc: PhygridDataChannel) => void) {
+    if (!this.peripheralTwinResponse) {
+      console.error('Object is not initialized correctly');
+      return;
+    }
+
+    await this.phyHubClient.onDataChannel(this.peripheralTwinResponse.id, callback);
+  };
+
+  async getMediaStream() {
+    if (!this.peripheralTwinResponse) {
+      console.error('Object is not initialized correctly');
+      return;
+    }
+
+    return await this.phyHubClient.getMediaStream(this.peripheralTwinResponse.id);
+  };
+
+  async onMediaStream(callback: (stream: PhygridMediaStream) => void): Promise<void> {
+    if (!this.peripheralTwinResponse) {
+      throw new Error('Peripheral instance not initialized');
+    }
+
+    await this.phyHubClient.onMediaStream(this.peripheralTwinResponse.id, callback);
+  };
+
+  async updateReported(properties: Record<string, any>) {
+    if (!this.peripheralTwinResponse) {
+      throw new Error('Peripheral instance not initialized');
+    }
+
+    const newReported = {
+      ...properties,
+    };
+
+    const result = await this.phyHubClient.updateReportedProperties(this.peripheralTwinResponse.id, newReported);
+
+    this.peripheralTwinResponse = Object.assign({}, this.peripheralTwinResponse, result);
+
+    return result;
+  };
+
+  onUpdateReported(callback: (reportedProperties: Record<string, any>) => void) {
+    if (!this.peripheralTwinResponse) {
+      throw new Error('Peripheral instance not initialized');
+    }
+
+    let previousProperties: Record<string, any> | undefined = undefined;
+
+    console.log(`[onUpdateReported] Registering handler for all reported properties`);
+
+    this.phyHubClient.onTwinUpdate(this.peripheralTwinResponse.id, (twin: TwinResponse) => {
+      console.log(`[onUpdateReported] Twin update received for ${this.peripheralTwinResponse!.id}`);
+
+      // Only process updates for this specific peripheral
+      if (twin.id !== this.peripheralTwinResponse!.id) {
+        console.log(`[onUpdateReported] Twin ID mismatch: ${twin.id} !== ${this.peripheralTwinResponse!.id}`);
+        return;
+      }
+
+      const reported = twin.properties.reported as Record<string, any>;
+
+      // Check if reported properties exist
+      if (reported) {
+        // If this is the first update, always trigger
+        if (previousProperties === undefined) {
+          console.log(`[onUpdateReported] First update - calling callback`);
+          previousProperties = JSON.parse(JSON.stringify(reported)); // Deep copy
+          callback(reported);
+          return;
+        }
+
+        const currentPropertiesStr = JSON.stringify(reported);
+        const previousPropertiesStr = JSON.stringify(previousProperties);
+
+        // Debug by printing parts of the strings - last 100 chars to avoid excessive logs
+        console.log(
+          `[onUpdateReported] Current (end): ...${currentPropertiesStr.substring(currentPropertiesStr.length - 100)}`
+        );
+        console.log(
+          `[onUpdateReported] Previous (end): ...${previousPropertiesStr.substring(previousPropertiesStr.length - 100)}`
+        );
+
+        // Additional check - compare string lengths first
+        if (currentPropertiesStr.length !== previousPropertiesStr.length) {
+          console.log(
+            `[onUpdateReported] String length changed: ${currentPropertiesStr.length} vs ${previousPropertiesStr.length}`
+          );
+        }
+
+        const hasChanged = currentPropertiesStr !== previousPropertiesStr;
+
+        console.log(
+          `[onUpdateReported] Properties comparison:`,
+          hasChanged ? 'CHANGED' : 'UNCHANGED'
+        );
+
+        if (hasChanged) {
+          previousProperties = JSON.parse(currentPropertiesStr); // Deep copy
+          console.log(`[onUpdateReported] Calling callback with updated reported properties`);
+          callback(reported);
+        } else {
+          // Force a callback call at least every 5 updates to ensure clients get updates
+          // This is a safety mechanism
+          console.log(`[onUpdateReported] No change detected in properties`);
+        }
+      } else {
+        console.log(`[onUpdateReported] No reported properties found`);
+      }
+    });
+  };
+
+  async updateDesired(properties: Record<string, any>): Promise<TwinResponse>{
+    if (!this.peripheralTwinResponse) {
+      throw new Error('Peripheral instance not initialized');
+    }
+
+    const payload: EventPayload = {
+      twinId: this.peripheralTwinResponse.id,
+      data: properties,
+    };
+
+    const phyClientSocket = this.phyHubClient.getSocket();
+
+    return new Promise((resolve, reject) => {
+      this.phyHubClient.emit('updatePeripheralTwinDesired', payload, (response: any) => {
+        const { twin } = response;
+        resolve(twin || {});
+      });
+
+      phyClientSocket?.on('error', (error: any) => {
+        reject(error);
+      });
+    });
+  };
+
+  onUpdateDesired(callback: (desiredProperties: Record<string, any>) => void) {
+    if (!this.peripheralTwinResponse) {
+      throw new Error('Peripheral instance not initialized');
+    }
+
+    let previousProperties: Record<string, any> | undefined = undefined;
+
+    console.log(`[onUpdateDesired] Registering handler for all desired properties`);
+
+    this.phyHubClient.onTwinUpdate(this.peripheralTwinResponse.id, (twin: TwinResponse) => {
+      console.log(`[onUpdateDesired] Twin update received for ${this.peripheralTwinResponse!.id}`);
+
+      // Only process updates for this specific peripheral
+      if (twin.id !== this.peripheralTwinResponse!.id) {
+        console.log(`[onUpdateDesired] Twin ID mismatch: ${twin.id} !== ${this.peripheralTwinResponse!.id}`);
+        return;
+      }
+
+      const desired = twin.properties.desired as Record<string, any>;
+
+      // Check if desired properties exist
+      if (desired) {
+        // If this is the first update, always trigger
+        if (previousProperties === undefined) {
+          console.log(`[onUpdateDesired] First update - calling callback`);
+          previousProperties = JSON.parse(JSON.stringify(desired)); // Deep copy
+          callback(desired);
+          return;
+        }
+
+        const currentPropertiesStr = JSON.stringify(desired);
+        const previousPropertiesStr = JSON.stringify(previousProperties);
+
+        // Debug by printing parts of the strings - last 100 chars to avoid excessive logs
+        console.log(
+          `[onUpdateDesired] Current (end): ...${currentPropertiesStr.substring(currentPropertiesStr.length - 100)}`
+        );
+        console.log(
+          `[onUpdateDesired] Previous (end): ...${previousPropertiesStr.substring(previousPropertiesStr.length - 100)}`
+        );
+
+        // Additional check - compare string lengths first
+        if (currentPropertiesStr.length !== previousPropertiesStr.length) {
+          console.log(
+            `[onUpdateDesired] String length changed: ${currentPropertiesStr.length} vs ${previousPropertiesStr.length}`
+          );
+        }
+
+        const hasChanged = currentPropertiesStr !== previousPropertiesStr;
+
+        console.log(
+          `[onUpdateDesired] Properties comparison:`,
+          hasChanged ? 'CHANGED' : 'UNCHANGED'
+        );
+
+        if (hasChanged) {
+          previousProperties = JSON.parse(currentPropertiesStr); // Deep copy
+          console.log(`[onUpdateDesired] Calling callback with updated desired properties`);
+          callback(desired);
+        } else {
+          // Force a callback call at least every 5 updates to ensure clients get updates
+          // This is a safety mechanism
+          console.log(`[onUpdateDesired] No change detected in properties`);
+        }
+      } else {
+        console.log(`[onUpdateDesired] No desired properties found`);
+      }
+    });
+  };
+
+  async remove() : Promise<TwinResponse | void> {
+    if (!this.peripheralTwinResponse) {
+      throw new Error('Peripheral instance not initialized');
+    }
+
+    const payload: EventPayload = {
+      data: { twinId: this.peripheralTwinResponse.id },
+    };
+
+    const phyClientSocket = this.phyHubClient.getSocket();
+
+    return new Promise((resolve, reject) => {
+      this.phyHubClient.emit('deletePeripheralTwin', payload, (response: any) => {
+        const { twin } = response;
+        resolve(twin);
+      });
+
+      phyClientSocket?.on('error', (error: any) => {
+        reject(error);
+      });
+    });
+  };
+
+}
+

package/src/twin-registry.ts

@@ -0,0 +1,39 @@
+import { PhyHubClient } from ".";
+import { PeripheralTwinInstance } from "./peripheral-twin";
+import { IPeripheralTwinInstance } from "./types/twin.types";
+
+/**
+ * registry to create, store and retrieve instances of different types of twins e.g. Device, Screen, Peripheral
+ */
+
+export class TwinRegistry {
+  private peripheralInstances: Map<string, IPeripheralTwinInstance> = new Map();
+
+  constructor(private phyHubClient: PhyHubClient) {
+  }
+
+  // create an instance of PeripheralTwinInstance class
+  async getPeripheralInstance(twinId: string) : Promise<IPeripheralTwinInstance | null> {
+    try {
+
+      // check whether we've already created instance for this twinId
+      if (this.peripheralInstances.has(twinId)) {
+        return this.peripheralInstances.get(twinId)!;
+      }
+
+      // create an object of PeripheralTwinInstance class
+      const peripheralTwinInstance = new PeripheralTwinInstance(this.phyHubClient, twinId);
+
+      // class object is created, but perform sanity checks such as whether PhyHubClient is valid, twinId is valid etc.
+      // to make sure we are able to correct and return a valid instance
+      await peripheralTwinInstance.initialize();
+
+      // set the newly created instance in the map for future use
+      this.peripheralInstances.set(twinId, peripheralTwinInstance);
+
+      return peripheralTwinInstance;
+    } catch(error) {
+      throw error;
+    }
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './signal.types';
+export * from './twin.types';
+export * from './webrtc.types';

package/src/types/twin.types.ts

@@ -1,3 +1,4 @@
+import { PhyHubClient } from '..';
 import { PhygridDataChannel, PhygridMediaStream } from './webrtc.types';
 
 export enum TwinTypeEnum {
@@ -801,3 +802,35 @@ export interface MediaOptions {
   isMediaConnection?: boolean;
   mediaDirection?: string;
 }
+
+export enum TwinMessageResultStatus {
+  Success = 'success',
+  Error = 'error',
+  Warning = 'warning',
+};
+
+export interface TwinMessageResult {
+  status: TwinMessageResultStatus;
+  message: string;
+}
+
+export interface IPeripheralTwinInstance {
+  phyHubClient: PhyHubClient;
+  twinId: string;
+  edgeInstance: Instance | null;
+  peripheralTwinResponse: TwinResponse | null;
+  emit: (eventType: string, payload: any) => Promise<TwinMessageResult | undefined>;
+  sendEvent: (eventType: string, payload: any) => Promise<TwinMessageResult | undefined>;
+  on: (eventType: string, callback: (message: any) => void) => void;
+  onEvent: (eventType: string, callback: (message: any) => void) => void;
+  to: (targetTwinId: string) => { emit:  (eventType: string, payload: any) => Promise<TwinMessageResult | undefined>};
+  getDataChannel: () => Promise<PhygridDataChannel | undefined>;
+  onDataChannel: (callback: (dc: PhygridDataChannel) => void) => Promise<void>;
+  getMediaStream: () => Promise<{stream: PhygridMediaStream; close: () => void} | undefined>;
+  onMediaStream: (callback: (stream: PhygridMediaStream) => void) => Promise<void>;
+  updateReported: (properties: Record<string, any>) => Promise<TwinResponse>;
+  onUpdateReported: (callback: (reportedProperties: Record<string, any>) => void) => void;
+  updateDesired: (properties: Record<string, any>) => Promise<TwinResponse>;
+  onUpdateDesired: (callback: (reportedProperties: Record<string, any>) => void) => void;
+  remove : () => Promise<TwinResponse | void>;
+}