@boozilla/homebridge-shome 1.0.12 → 1.1.0

package/src/shomeClient.ts

@@ -24,20 +24,30 @@ export interface SubDevice {
     [key: string]: unknown;
 }
 
+export interface Visitor {
+    sttId: string;
+    thumbNail: string;
+    recodDt: string;
+    deviceLabel: string;
+}
+
 type QueueTask<T = unknown> = {
     request: () => Promise<T>;
     resolve: (value: T | PromiseLike<T>) => void;
     reject: (reason?: unknown) => void;
+    deviceId?: string;
 };
 
 export class ShomeClient {
   private cachedAccessToken: string | null = null;
   private ihdId: string | null = null;
+  private homeId: string | null = null;
   private tokenExpiry: number = 0;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   private putQueue: QueueTask<any>[] = [];
   private isProcessingPut = false;
   private loginPromise: Promise<string | null> | null = null;
+  private pendingPutRequests = new Set<string>();
 
   constructor(
         private readonly log: Logger,
@@ -100,6 +110,7 @@ export class ShomeClient {
       if (response.data && response.data.accessToken) {
         this.cachedAccessToken = response.data.accessToken;
         this.ihdId = response.data.ihdId;
+        this.homeId = response.data.homeId;
 
         const payload = JSON.parse(Buffer.from(this.cachedAccessToken!.split('.')[1], 'base64').toString());
         this.tokenExpiry = payload.exp * 1000;
@@ -116,9 +127,9 @@ export class ShomeClient {
     }
   }
 
-  private enqueuePut<T>(request: () => Promise<T>): Promise<T> {
+  private enqueuePut<T>(request: () => Promise<T>, deviceId?: string): Promise<T> {
     return new Promise<T>((resolve, reject) => {
-      this.putQueue.push({ request, resolve, reject });
+      this.putQueue.push({ request, resolve, reject, deviceId });
       this.processPutQueue();
     });
   }
@@ -131,11 +142,18 @@ export class ShomeClient {
 
     while (this.putQueue.length > 0) {
       const task = this.putQueue.shift()!;
+      if (task.deviceId) {
+        this.pendingPutRequests.add(task.deviceId);
+      }
       try {
         const result = await this.executeWithRetries(task.request, true);
         task.resolve(result);
       } catch (error) {
         task.reject(error);
+      } finally {
+        if (task.deviceId) {
+          this.pendingPutRequests.delete(task.deviceId);
+        }
       }
       await new Promise(resolve => setTimeout(resolve, REQUEST_DELAY_MS));
     }
@@ -147,8 +165,6 @@ export class ShomeClient {
     let retries = 0;
     while (true) {
       try {
-        // For non-queued (concurrent) requests, we need to ensure login happens before the request.
-        // For queued requests, the login is handled as part of the queue, so we can just await it.
         if (!isQueued) {
           await this.login();
         }
@@ -174,12 +190,15 @@ export class ShomeClient {
         }
         await new Promise(resolve => setTimeout(resolve, backoffTime));
 
-        // After a failure, always ensure we are logged in before the next attempt.
         await this.login();
       }
     }
   }
 
+  public isDeviceBusy(deviceId: string): boolean {
+    return this.pendingPutRequests.has(deviceId);
+  }
+
   async getDeviceList(): Promise<MainDevice[]> {
     return this.executeWithRetries(async () => {
       const token = this.cachedAccessToken;
@@ -219,19 +238,20 @@ export class ShomeClient {
     });
   }
 
-  async setDevice(thingId: string, deviceId: string, type: string, controlType: string, state: string, nickname?: string): Promise<boolean> {
-    return this.enqueuePut(async () => {
+  async setDevice(thingId: string, subDeviceId: string, type: string, controlType: string, state: string, nickname?: string): Promise<boolean> {
+    const deviceId = `${thingId}-${subDeviceId}`;
+    const request = async () => {
       const token = this.cachedAccessToken;
       if (!token) {
         return false;
       }
 
       const createDate = this.getDateTime();
-      const hashData = this.sha512(`IHRESTAPI${thingId}${deviceId}${state}${createDate}`);
+      const hashData = this.sha512(`IHRESTAPI${thingId}${subDeviceId}${state}${createDate}`);
       const typePath = type.toLowerCase().replace(/_/g, '');
       const controlPath = controlType.toLowerCase().replace(/_/g, '-');
 
-      await axios.put(`${BASE_URL}/v18/settings/${typePath}/${thingId}/${deviceId}/${controlPath}`, null, {
+      await axios.put(`${BASE_URL}/v18/settings/${typePath}/${thingId}/${subDeviceId}/${controlPath}`, null, {
         params: {
           createDate,
           [controlType === 'WINDSPEED' ? 'mode' : 'state']: state,
@@ -240,14 +260,17 @@ export class ShomeClient {
         headers: { 'Authorization': `Bearer ${token}` },
       });
 
-      const displayName = nickname || `${thingId}/${deviceId}`;
+      const displayName = nickname || deviceId;
       this.log.info(`[${displayName}] state set to ${state}.`);
       return true;
-    });
+    };
+
+    return this.enqueuePut(request, deviceId);
   }
 
   async unlockDoorlock(thingId: string, nickname?: string): Promise<boolean> {
-    return this.enqueuePut(async () => {
+    const deviceId = thingId;
+    const request = async () => {
       const token = this.cachedAccessToken;
       if (!token) {
         return false;
@@ -268,9 +291,62 @@ export class ShomeClient {
       const displayName = nickname || thingId;
       this.log.info(`Unlocked [${displayName}].`);
       return true;
+    };
+    return this.enqueuePut(request, deviceId);
+  }
+
+  async getVisitorHistory(): Promise<Visitor[]> {
+    return this.executeWithRetries(async () => {
+      const token = this.cachedAccessToken;
+      if (!token || !this.homeId) {
+        this.log.error('Cannot fetch visitor history: Not logged in or homeId is missing.');
+        return [];
+      }
+
+      const createDate = this.getDateTime();
+      const offset = 0;
+      const hashData = this.sha512(`IHRESTAPI${this.homeId}${offset}${createDate}`);
+      const response = await axios.get(`${BASE_URL}/v16/histories/${this.homeId}/video-histories`, {
+        params: { createDate, hashData, offset },
+        headers: { 'Authorization': `Bearer ${token}` },
+      });
+
+      return response.data.videoList || [];
     });
   }
 
+  async getThumbnailImage(visitor: Visitor): Promise<Buffer | null> {
+    const request = async () => {
+      const token = this.cachedAccessToken;
+      if (!token) {
+        this.log.error('Cannot fetch thumbnail: Not logged in.');
+        return null;
+      }
+
+      if (!visitor.sttId) {
+        this.log.error('Cannot fetch thumbnail: sttId is missing from visitor object.');
+        return null;
+      }
+
+      const createDate = this.getDateTime();
+      const hashData = this.sha512(`IHRESTAPI${visitor.sttId}${createDate}`);
+      const thumbnailUrl = `${BASE_URL}/v16/histories/${visitor.sttId}/video-thumbnail`;
+      const response = await axios.get(thumbnailUrl, {
+        params: {
+          createDate,
+          hashData,
+        },
+        headers: { 'Authorization': `Bearer ${token}` },
+        responseType: 'arraybuffer',
+      });
+
+      return Buffer.from(response.data, 'binary');
+    };
+
+    return this.executeWithRetries(request);
+  }
+
+
   private sha512(input: string): string {
     return CryptoJS.SHA512(input).toString();
   }