@ray-js/lock-sdk 1.2.1-beta.7 → 1.2.1-beta.9

package/lib/api/video.d.ts

@@ -48,4 +48,9 @@ interface GetDeviceCurrentMeidaConfigResult {
     vedioClaritys: number[];
 }
 export declare const getDeviceCurrentMeidaConfig: (devId: string) => Promise<GetDeviceCurrentMeidaConfigResult>;
+interface GetVideoResolutionMarkResult {
+    capability: number[];
+    cloudCapability: string[];
+}
+export declare const getVideoResolutionMark: (devId: string) => Promise<GetVideoResolutionMarkResult>;
 export {};

package/lib/api/video.js

@@ -70,3 +70,13 @@ export const getDeviceCurrentMeidaConfig = (devId) => {
         },
     });
 };
+export const getVideoResolutionMark = (devId) => {
+    return requestApi({
+        logName: "getVideoResolutionMark",
+        api: `${THING}.m.device.lock.capability.cloud.get`,
+        version: "1.0",
+        data: {
+            devId,
+        },
+    });
+};

package/lib/entries/main/exports/misc.d.ts

@@ -16,3 +16,7 @@ export declare function updateDpPeriodTime(dpCode: string, data: UpdateDpPeriodT
 export declare function connectDevice(options?: ConnectDeviceOptions): Promise<true>;
 export declare function gotoService(params?: GotoServiceParams): Promise<void>;
 export declare function validatePwdComplexity(password: string): Promise<boolean>;
+export interface AwakeDeviceOptions {
+    timeout?: number;
+}
+export declare function awakeDevice(options?: AwakeDeviceOptions): Promise<true>;

package/lib/entries/main/exports/misc.js

@@ -2,7 +2,7 @@ import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-
 import { openSceneForRuntime } from "../../../feature/misc/open-scene";
 import { isSupportBleControlForRuntime } from "../../../feature/misc/ble-control";
 import { getDpPeriodTimeForRuntime, updateDpPeriodTimeForRuntime, } from "../../../feature/misc/dp-period";
-import { connectDeviceForRuntime } from "../../../feature/misc/connect-device";
+import { awakeDeviceForRuntime, connectDeviceForRuntime, } from "../../../feature/misc/connect-device";
 import { validatePwdComplexityForRuntime } from "../../../feature/misc/validate-pwd";
 import { gotoServiceForRuntime, } from "../../../feature/service/goto-service";
 export { parseDpPeriodTime } from "../../../feature/misc/dp-period";
@@ -28,3 +28,6 @@ export async function gotoService(params) {
 export async function validatePwdComplexity(password) {
     return validatePwdComplexityForRuntime(resolveRuntimeFromExportThis(this), password);
 }
+export async function awakeDevice(options) {
+    return awakeDeviceForRuntime(resolveRuntimeFromExportThis(this), options);
+}

package/lib/feature/misc/capability.js

@@ -3,6 +3,9 @@ import { CommunicationType, ProductCommunicationType } from "../../constant";
 import { checkShowMatterMutilpleShare } from "../../platform/device";
 import { ipc } from "../../platform";
 import { getWithLocalCache } from "../storage/swr-cache";
+import { getVideoResolutionMark } from "../../api/video";
+import dpCodes from "../../config/dp-code";
+import { hasDpForRuntime } from "../dp/has-dp";
 export const hasCapabilityForRuntime = (runtime, capability) => runtime.config.communication.includes(capability);
 export const isBlePureDeviceForRuntime = (rt) => hasCapabilityForRuntime(rt, ProductCommunicationType.BLUETOOTH) &&
     rt.config.communication.length === 1;
@@ -68,7 +71,7 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
         return rt.cache.deviceAdvanceAbilityCache;
     }
     const devId = rt.config.devInfo.devId;
-    const [productAbilitiesRes, deviceAdvancedAbilityRes, tttList] = await Promise.allSettled([
+    const [productAbilitiesRes, deviceAdvancedAbilityRes, tttList, videoMarkRes] = await Promise.allSettled([
         getWithLocalCache(rt, "productAbilities", () => getProductAbilities(devId, [
             "tyabi4ucx5",
             "tyabis9tpe",
@@ -76,18 +79,25 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
             "tyabipd4hh",
             "tyabin4u5v",
             "visual_door_lock_cloud_store",
-            "tyabixkep7",
-            "tyabig3wt9",
         ])),
         getWithLocalCache(rt, "deviceAdvancedAbility", () => getDeviceAdvancedAbility(devId)),
         ipc.getTTTAbilityKeyList("isSupportedVRMode"),
+        hasDpForRuntime(rt, dpCodes.initiativeMessage)
+            ? getWithLocalCache(rt, "videoResolutionMark", () => getVideoResolutionMark(devId))
+            : Promise.resolve({
+                capability: [],
+                cloudCapability: [],
+            }),
     ]);
     const productAbilities = productAbilitiesRes.status === "fulfilled" ? productAbilitiesRes.value : [];
     const tttAbList = tttList.status === "fulfilled" ? tttList.value.abilityList : [];
+    const videoMark = videoMarkRes.status === "fulfilled"
+        ? videoMarkRes.value
+        : { capability: [], cloudCapability: [] };
     const deviceAdvanceAbilityCache = {
         videoConfig: {
-            isLowResolution: false,
-            isHighResolution: false,
+            isLowResolution: videoMark?.cloudCapability?.includes("tyabig3wt9"),
+            isHighResolution: videoMark?.cloudCapability?.includes("tyabixkep7"),
         },
         cloudStorage: {
             support: false,
@@ -129,14 +139,6 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
             if (item.isOpen) {
                 const data = item.extConfig ? JSON.parse(item.extConfig) : {};
                 switch (item.abilityCode) {
-                    case "tyabixkep7": {
-                        deviceAdvanceAbilityCache.videoConfig.isHighResolution = true;
-                        break;
-                    }
-                    case "tyabig3wt9": {
-                        deviceAdvanceAbilityCache.videoConfig.isLowResolution = true;
-                        break;
-                    }
                     case "visual_door_lock_cloud_store":
                         deviceAdvanceAbilityCache.cloudStorage.support = true;
                         break;

package/lib/feature/misc/connect-device.d.ts

@@ -1,2 +1,5 @@
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
 export declare function connectDeviceForRuntime(rt: LockDeviceRuntime, timeout?: number): Promise<true>;
+export declare const awakeDeviceForRuntime: (runtime: LockDeviceRuntime, options?: {
+    timeout?: number;
+}) => Promise<true>;

package/lib/feature/misc/connect-device.js

@@ -8,70 +8,8 @@ import { getDpValueForRuntime } from "../dp/get-dp-value";
 import { getDeviceStatusForRuntime } from "../state/device-status";
 import { isSupportBleControlForRuntime } from "./ble-control";
 import { sdkLog } from "../../utils/sdk-log";
+import { hasDpForRuntime } from "../dp/has-dp";
 const { wirelessAwake } = dpCodes;
-const awakeDevice = async (devId, timeout) => {
-    const startedAt = Date.now();
-    sdkLog("info", "connectDevice", "awakeStart", {
-        devId,
-        data: { timeout: timeout || 15000 },
-    });
-    return new Promise((resolve, reject) => {
-        const handleChangeDp = (dpCodesArg) => {
-            if (dpCodesArg[wirelessAwake] === true) {
-                sdkLog("info", "connectDevice", "awakeReportSuccess", {
-                    devId,
-                    duration: Date.now() - startedAt,
-                });
-                resolve(true);
-                emitter.off(DPCHANGE, handleChangeDp);
-                clearTimeout(timer);
-            }
-        };
-        emitter.on(DPCHANGE, handleChangeDp);
-        const timer = setTimeout(() => {
-            emitter.off(DPCHANGE, handleChangeDp);
-            const error = getError(1002);
-            sdkLog("warn", "connectDevice", "awakeTimeout", {
-                devId,
-                duration: Date.now() - startedAt,
-                error,
-            });
-            reject(error);
-        }, timeout || 15000);
-        const run = async () => {
-            try {
-                ipc.wakeUpDoorBell(devId);
-                ipc.wakeUpDoorBell(devId);
-                ipc.wakeUpDoorBell(devId);
-                const connected = await ipc.isConnected(devId);
-                if (connected.isConnected) {
-                    sdkLog("info", "connectDevice", "awakeAlreadyConnected", {
-                        devId,
-                        duration: Date.now() - startedAt,
-                    });
-                    return resolve(true);
-                }
-                const connecting = await ipc.isConnecting(devId);
-                if (!connecting.isConnecting) {
-                    sdkLog("info", "connectDevice", "awakeIpcConnectStart", { devId });
-                    await ipc.connect(devId);
-                }
-                else {
-                    sdkLog("debug", "connectDevice", "awakeIpcConnecting", { devId });
-                }
-            }
-            catch (error) {
-                sdkLog("error", "connectDevice", "awakeFail", {
-                    devId,
-                    duration: Date.now() - startedAt,
-                    error,
-                });
-                reject(error);
-            }
-        };
-        run();
-    });
-};
 const connectBle = async (devId, timeout) => {
     const startedAt = Date.now();
     sdkLog("info", "connectDevice", "bleConnectStart", { devId });
@@ -160,7 +98,7 @@ export async function connectDeviceForRuntime(rt, timeout) {
     });
     if (deviceStatus.connectEnable && hasWirelessAwakeDp) {
         if (cfg.devInfo.isCloudOnline && !getDpValueForRuntime(rt, wirelessAwake)) {
-            const result = await awakeDevice(devId, timeout);
+            const result = await awakeDeviceForRuntime(rt, { timeout });
             sdkLog("info", "connectDevice", "success", {
                 devId,
                 duration: Date.now() - startedAt,
@@ -205,3 +143,74 @@ export async function connectDeviceForRuntime(rt, timeout) {
     });
     throw error;
 }
+export const awakeDeviceForRuntime = (runtime, options) => {
+    const cfg = runtime.config;
+    const devId = cfg.devInfo.devId;
+    const timeout = options?.timeout || 15000;
+    const startedAt = Date.now();
+    const hasWirelessAwake = hasDpForRuntime(runtime, wirelessAwake);
+    sdkLog("info", "connectDevice", "awakeStart", {
+        devId,
+        data: { timeout, hasWirelessAwake },
+    });
+    return new Promise((resolve, reject) => {
+        const handleChangeDp = (dpCodesArg) => {
+            if (dpCodesArg[wirelessAwake] === true) {
+                sdkLog("info", "connectDevice", "awakeReportSuccess", {
+                    devId,
+                    duration: Date.now() - startedAt,
+                });
+                resolve(true);
+                emitter.off(DPCHANGE, handleChangeDp);
+                clearTimeout(timer);
+            }
+        };
+        hasWirelessAwake && emitter.on(DPCHANGE, handleChangeDp);
+        const timer = setTimeout(() => {
+            emitter.off(DPCHANGE, handleChangeDp);
+            const error = getError(1002);
+            sdkLog("warn", "connectDevice", "awakeTimeout", {
+                devId,
+                duration: Date.now() - startedAt,
+                error,
+            });
+            reject(error);
+        }, timeout);
+        const run = async () => {
+            try {
+                ipc.wakeUpDoorBell(devId);
+                ipc.wakeUpDoorBell(devId);
+                ipc.wakeUpDoorBell(devId);
+                const connected = await ipc.isConnected(devId);
+                if (connected.isConnected) {
+                    sdkLog("info", "connectDevice", "awakeAlreadyConnected", {
+                        devId,
+                        duration: Date.now() - startedAt,
+                    });
+                    return resolve(true);
+                }
+                const connecting = await ipc.isConnecting(devId);
+                if (!connecting.isConnecting) {
+                    sdkLog("info", "connectDevice", "awakeIpcConnectStart", { devId });
+                    await ipc.connect(devId);
+                    if (!hasWirelessAwake) {
+                        clearTimeout(timer);
+                        return resolve(true);
+                    }
+                }
+                else {
+                    sdkLog("debug", "connectDevice", "awakeIpcConnecting", { devId });
+                }
+            }
+            catch (error) {
+                sdkLog("error", "connectDevice", "awakeFail", {
+                    devId,
+                    duration: Date.now() - startedAt,
+                    error,
+                });
+                reject(error);
+            }
+        };
+        run();
+    });
+};

package/lib/feature/state/init-state.js

@@ -172,8 +172,10 @@ export const initState = async (runtime) => {
         });
         setTimeout(() => {
             sdkLog("debug", "initState", "scheduledSyncUnlock", { devId });
-            syncT0(runtime);
-            autoSyncUnlockMethod(runtime);
+            if (getDeviceStatusForRuntime(runtime).type === "online") {
+                syncT0(runtime);
+                autoSyncUnlockMethod(runtime);
+            }
         }, 2000);
         setTimeout(() => {
             sdkLog("debug", "initState", "scheduledSyncTempAndUsers", { devId });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/lock-sdk",
-  "version": "1.2.1-beta.7",
+  "version": "1.2.1-beta.9",
   "files": [
     "lib",
     "LICENSE.md"