@ray-js/lock-sdk 1.2.0-beta.9 → 1.2.0

package/lib/feature/misc/capability.js

@@ -1,6 +1,8 @@
 import { getDeviceAdvancedAbility, getProductAbilities } from "../../api";
-import { ProductCommunicationType } from "../../constant";
+import { CommunicationType, ProductCommunicationType } from "../../constant";
 import { checkShowMatterMutilpleShare } from "../../platform/device";
+import { ipc } from "../../platform";
+import { getWithLocalCache } from "../storage/swr-cache";
 export const hasCapabilityForRuntime = (runtime, capability) => runtime.config.communication.includes(capability);
 export const isBlePureDeviceForRuntime = (rt) => hasCapabilityForRuntime(rt, ProductCommunicationType.BLUETOOTH) &&
     rt.config.communication.length === 1;
@@ -15,11 +17,17 @@ export const isActiveThreadForRuntime = async (rt) => {
     if (hasThread) {
         if (rt.deviceStatus.onlineTypes.includes("cloud") ||
             rt.config.communication.length === 1) {
+            rt.cache.isActiveThreadCache = true;
             return true;
         }
         const hasBle = hasCapabilityForRuntime(rt, ProductCommunicationType.BLUETOOTH);
+        if (rt.config.capabilities?.communicationType === CommunicationType.THREAD) {
+            rt.cache.isActiveThreadCache = true;
+            return true;
+        }
         if (hasBle) {
             if (rt.cache.isActiveThreadCache) {
+                rt.cache.isActiveThreadCache = true;
                 return true;
             }
             try {
@@ -52,28 +60,31 @@ const allModes = [
         value: 2,
     },
 ];
+export const getDeviceAdvancedAbilitiesSyncForRuntime = (rt) => {
+    return rt.cache.deviceAdvanceAbilityCache;
+};
 export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
     if (rt.cache.deviceAdvanceAbilityCache) {
         return rt.cache.deviceAdvanceAbilityCache;
     }
-    const [productAbilitiesRes, deviceAdvancedAbilityRes] = await Promise.allSettled([
-        getProductAbilities(rt.config.devInfo.devId, [
+    const devId = rt.config.devInfo.devId;
+    const [productAbilitiesRes, deviceAdvancedAbilityRes, tttList] = await Promise.allSettled([
+        getWithLocalCache(rt, "productAbilities", () => getProductAbilities(devId, [
             "tyabi4ucx5",
             "tyabis9tpe",
             "tyabiwxrn9",
             "tyabipd4hh",
             "tyabin4u5v",
             "visual_door_lock_cloud_store",
-        ]),
-        getDeviceAdvancedAbility(rt.config.devInfo.devId),
+        ])),
+        getWithLocalCache(rt, "deviceAdvancedAbility", () => getDeviceAdvancedAbility(devId)),
+        ipc.getTTTAbilityKeyList("isSupportedVRMode"),
     ]);
     const productAbilities = productAbilitiesRes.status === "fulfilled" ? productAbilitiesRes.value : [];
-    const deviceAdvancedAbility = deviceAdvancedAbilityRes.status === "fulfilled"
-        ? deviceAdvancedAbilityRes.value
-        : undefined;
+    const tttAbList = tttList.status === "fulfilled" ? tttList.value.abilityList : [];
     const deviceAdvanceAbilityCache = {
         cloudStorage: {
-            support: deviceAdvancedAbility?.types?.includes(0) ?? false,
+            support: false,
         },
         vr: {
             support: false,
@@ -127,26 +138,9 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
                                 petRecognition ||
                                 voice ||
                                 message;
-                        deviceAdvanceAbilityCache.vr.support = !!data?.lock_VR;
+                        deviceAdvanceAbilityCache.vr.support =
+                            !!data?.lock_VR && tttAbList.length > 0;
                         if (deviceAdvanceAbilityCache.vr.support) {
-                            const modeMap = {
-                                original: {
-                                    mode: "original",
-                                    value: 0,
-                                },
-                                VR: {
-                                    mode: "VR",
-                                    value: 1,
-                                },
-                                horizontal: {
-                                    mode: "horizontal",
-                                    value: 2,
-                                },
-                                vertical: {
-                                    mode: "vertical",
-                                    value: 3,
-                                },
-                            };
                             deviceAdvanceAbilityCache.vr.modes = allModes.filter((item) => {
                                 return data?.modes?.includes(item.mode);
                             });
@@ -154,7 +148,7 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
                             const exist = deviceAdvanceAbilityCache.vr.modes.find((x) => x.mode === deviceAdvanceAbilityCache.vr.defaultMode);
                             if (!exist) {
                                 deviceAdvanceAbilityCache.vr.defaultMode =
-                                    deviceAdvanceAbilityCache.vr.modes?.[0].mode;
+                                    deviceAdvanceAbilityCache.vr.modes?.[0]?.mode;
                             }
                             deviceAdvanceAbilityCache.vr.coverMode = data.photo_cover_format;
                         }
@@ -166,8 +160,6 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
                         break;
                     }
                     case "tyabiwxrn9": {
-                        deviceAdvanceAbilityCache.wechatVoip.support =
-                            deviceAdvancedAbility?.types?.includes(1) ?? false;
                         deviceAdvanceAbilityCache.wechatVoip.isPublice =
                             data?.WechatType === "0";
                         if (!deviceAdvanceAbilityCache.wechatVoip.isPublice) {
@@ -197,6 +189,16 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
             console.warn(`setting [${item.abilityCode}] config error`, error);
         }
     });
+    if (deviceAdvancedAbilityRes.status === "fulfilled") {
+        const res = deviceAdvancedAbilityRes.value;
+        deviceAdvanceAbilityCache.cloudStorage.support =
+            res.types?.includes(0) ?? false;
+        deviceAdvanceAbilityCache.wechatVoip.support =
+            res.types?.includes(1) ?? false;
+    }
     rt.cache.deviceAdvanceAbilityCache = deviceAdvanceAbilityCache;
     return deviceAdvanceAbilityCache;
 };
+export const getDeviceCapabilitiesForRuntime = (rt) => {
+    return rt.config.capabilities;
+};

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

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

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

@@ -72,7 +72,7 @@ const awakeDevice = async (devId, timeout) => {
         run();
     });
 };
-const connectBle = async (devId) => {
+const connectBle = async (devId, timeout) => {
     const startedAt = Date.now();
     sdkLog("info", "connectDevice", "bleConnectStart", { devId });
     return new Promise((resolve, reject) => {
@@ -109,7 +109,7 @@ const connectBle = async (devId) => {
                     error,
                 });
                 reject(error);
-            }, 15000);
+            }, timeout ?? 15000);
             const clearTimer = () => {
                 clearTimeout(timer);
                 offBleChange(handleStatusChange);
@@ -143,7 +143,7 @@ const connectBle = async (devId) => {
         });
     });
 };
-export async function connectDeviceForRuntime(rt) {
+export async function connectDeviceForRuntime(rt, timeout) {
     const cfg = rt.config;
     const devId = cfg.devInfo.devId;
     const deviceStatus = getDeviceStatusForRuntime(rt);
@@ -154,12 +154,13 @@ export async function connectDeviceForRuntime(rt) {
         data: {
             statusType: deviceStatus.type,
             onlineTypes: deviceStatus.onlineTypes,
+            connectEnable: deviceStatus.connectEnable,
             hasWirelessAwakeDp,
         },
     });
-    if (hasWirelessAwakeDp) {
+    if (deviceStatus.connectEnable && hasWirelessAwakeDp) {
         if (cfg.devInfo.isCloudOnline && !getDpValueForRuntime(rt, wirelessAwake)) {
-            const result = await awakeDevice(devId);
+            const result = await awakeDevice(devId, timeout);
             sdkLog("info", "connectDevice", "success", {
                 devId,
                 duration: Date.now() - startedAt,
@@ -178,7 +179,7 @@ export async function connectDeviceForRuntime(rt) {
             });
             return true;
         }
-        await connectBle(devId);
+        await connectBle(devId, timeout);
         if (rt.cache.deviceAdvanceAbilityCache?.yuChannel.support) {
             if (rt.cache.deviceAdvanceAbilityCache?.yuChannel.value === 1) {
                 yuChannelSyncSingleSync(devId);

package/lib/feature/misc/is-use-near-channel-for-runtime.js

@@ -1,17 +1,24 @@
+import dpCodes from "../../config/dp-code";
 import { ProductCommunicationType } from "../../constant";
 import { isOnlineByType } from "../../utils";
+import { hasDpForRuntime } from "../dp/has-dp";
 import { hasCapabilityForRuntime } from "./capability";
 export const isUseNearChannelForRuntime = (rt) => {
     const { onlineType, devInfo } = rt.config;
     const isBleOnline = isOnlineByType(onlineType, 2);
     const isSupportWifi = hasCapabilityForRuntime(rt, ProductCommunicationType.WIFI);
     const isSupportBle = hasCapabilityForRuntime(rt, ProductCommunicationType.BLUETOOTH);
+    if (isSupportWifi &&
+        isSupportBle &&
+        !hasDpForRuntime(rt, dpCodes.unlockBle)) {
+        return false;
+    }
     const isSupportThread = hasCapabilityForRuntime(rt, ProductCommunicationType.THREAD);
     if (isSupportWifi && isSupportBle) {
         return isBleOnline;
     }
     if (isSupportThread && isSupportBle) {
-        return isBleOnline && !devInfo.isCloudOnline && !devInfo.isLocalOnline;
+        return isBleOnline && !devInfo.isCloudOnline;
     }
     return isBleOnline;
 };

package/lib/feature/password/temporary/offline-create.d.ts

@@ -1,7 +1,21 @@
+import { type LimitOfflinePwdItem, type OfflinePwdAvailableResult } from "../../../api/temp";
 import type { TempPasswordResult } from "../../../interface";
 import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
 import type { CreateClearParams, CreateLimitParams, CreateOnceParams } from "./types";
 export declare function createTempLimitForRuntime(rt: LockDeviceRuntime, params: CreateLimitParams): Promise<TempPasswordResult>;
 export declare function createTempOnceForRuntime(rt: LockDeviceRuntime, params: CreateOnceParams): Promise<TempPasswordResult>;
+export interface FitOfflineOnceResult {
+    password: string;
+    pwdId: string;
+    gmtExpired: number;
+}
+export declare function createFitOfflineOnceForRuntime(rt: LockDeviceRuntime): Promise<FitOfflineOnceResult>;
+export declare function createFitOfflineLimitForRuntime(rt: LockDeviceRuntime, params: {
+    effectiveTime: number;
+    invalidTime: number;
+}): Promise<FitOfflineOnceResult>;
+export declare function createFitOfflineClearAllForRuntime(rt: LockDeviceRuntime): Promise<FitOfflineOnceResult>;
+export declare function getFitOfflineRevocableListForRuntime(rt: LockDeviceRuntime): Promise<LimitOfflinePwdItem[]>;
+export declare function getFitOfflinePwdAvailableForRuntime(rt: LockDeviceRuntime, pwdType: string): Promise<OfflinePwdAvailableResult>;
 export declare function createTempDynamicForRuntime(rt: LockDeviceRuntime): Promise<TempPasswordResult>;
 export declare function createTempClearForRuntime(rt: LockDeviceRuntime, params: CreateClearParams): Promise<TempPasswordResult>;

package/lib/feature/password/temporary/offline-create.js

@@ -1,4 +1,4 @@
-import { getDynamicPassword, revokeOfflinePassword, } from "../../../api/temp";
+import { createOfflineOnceAPI, getDynamicPassword, getLimitOfflinePwdListForClear, getOfflinePwdAvailable, revokeOfflinePassword, } from "../../../api/temp";
 import { parseOfflinePasswordForRuntime } from "../../utils";
 import { getError, handleCloudError } from "../../../utils/errors";
 import { getOfflinePassword } from "./internal/password-helpers";
@@ -87,6 +87,82 @@ export async function createTempOnceForRuntime(rt, params) {
         },
     };
 }
+async function createFitOfflinePwdForRuntime(rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "createFitOfflinePwdStart", {
+        devId: rt.devId,
+        data: { pwdType: params.pwdType },
+    });
+    try {
+        const res = await createOfflineOnceAPI({
+            devId: rt.devId,
+            ...params,
+        });
+        sdkLog("info", "tempPassword", "createFitOfflinePwdSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { pwdType: params.pwdType },
+        });
+        return {
+            password: parseOfflinePasswordForRuntime(rt, res.pwd),
+            pwdId: res.pwdId,
+            gmtExpired: res.gmtExpired,
+        };
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "createFitOfflinePwdFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { pwdType: params.pwdType },
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}
+export function createFitOfflineOnceForRuntime(rt) {
+    return createFitOfflinePwdForRuntime(rt, {
+        pwdType: "1",
+        gmtStart: "0",
+        gmtExpired: "0",
+    });
+}
+export function createFitOfflineLimitForRuntime(rt, params) {
+    const { effectiveTime, invalidTime } = params;
+    if (effectiveTime >= invalidTime) {
+        throw getError(1010);
+    }
+    return createFitOfflinePwdForRuntime(rt, {
+        pwdType: "0",
+        gmtStart: String(effectiveTime),
+        gmtExpired: String(invalidTime),
+    });
+}
+export function createFitOfflineClearAllForRuntime(rt) {
+    return createFitOfflinePwdForRuntime(rt, {
+        pwdType: "9",
+        gmtStart: "0",
+        gmtExpired: "0",
+    });
+}
+export async function getFitOfflineRevocableListForRuntime(rt) {
+    try {
+        return (await getLimitOfflinePwdListForClear({ devId: rt.devId })) || [];
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}
+export async function getFitOfflinePwdAvailableForRuntime(rt, pwdType) {
+    try {
+        return await getOfflinePwdAvailable({
+            devId: rt.config.devInfo.devId,
+            pwdType,
+        });
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}
 export async function createTempDynamicForRuntime(rt) {
     const startedAt = Date.now();
     sdkLog("info", "tempPassword", "createDynamicStart", {

package/lib/feature/service/goto-service.d.ts

@@ -3,4 +3,4 @@ export interface GotoServiceParams {
     tab?: "cloudStorage" | "AI" | "voip";
     showGift?: boolean;
 }
-export declare function gotoServiceForRuntime(rt: LockDeviceRuntime, params?: GotoServiceParams): Promise<unknown>;
+export declare function gotoServiceForRuntime(rt: LockDeviceRuntime, params?: GotoServiceParams): Promise<void>;

package/lib/feature/state/clear.js

@@ -8,6 +8,7 @@ export function clearStateForRuntime(runtime) {
     runtime.cache.currentUser = null;
     runtime.cache.offlineDpCache = undefined;
     runtime.cache.deviceAdvanceAbilityCache = undefined;
+    runtime.cache.fitDeviceBvCache = undefined;
     runtime.cache.isActiveThreadCache = false;
     runtime.sync.hasSyncedT0 = false;
     runtime.sync.syncDeleteUsersBusy = false;

package/lib/feature/state/device-status.js

@@ -1,4 +1,4 @@
-import { hasCapabilityForRuntime } from "../misc/capability";
+import { hasCapabilityForRuntime, isActiveThreadForRuntime, } from "../misc/capability";
 import { hasDpForRuntime } from "../dp/has-dp";
 import dpCodes from "../../config/dp-code";
 import { ProductCommunicationType } from "../../constant";
@@ -13,9 +13,14 @@ import { getDpValueForRuntime } from "../dp/get-dp-value";
 import { readIsSleepForRuntime } from "./internal/read-is-sleep";
 import { isShareThreadRuntimeLocal } from "./internal/share-thread-local";
 export const updateOnlineType = async (runtime) => {
+    const hasThreadBle = hasCapabilityForRuntime(runtime, ProductCommunicationType.THREAD) &&
+        hasCapabilityForRuntime(runtime, ProductCommunicationType.BLUETOOTH);
     const [devInfo, onlineType] = await Promise.all([
         getDeviceInfo(runtime.config.devInfo.devId),
         getDeviceOnlineType(runtime.config.devInfo.devId),
+        hasThreadBle && runtime.cache.isActiveThreadCache !== true
+            ? isActiveThreadForRuntime(runtime)
+            : Promise.resolve(false),
     ]);
     runtime.config.onlineType = onlineType;
     runtime.config.devInfo = devInfo;
@@ -23,7 +28,7 @@ export const updateOnlineType = async (runtime) => {
     updateDeviceStatus(runtime);
 };
 export const getDeviceStatusForRuntime = (runtime) => {
-    const { onlineType, devInfo: { isCloudOnline, isOnline, wifiEnableState, isMatter }, } = runtime.config;
+    const { onlineType, notSupportWake, devInfo: { isCloudOnline, isOnline, wifiEnableState, isMatter }, } = runtime.config;
     const supportWifi = hasCapabilityForRuntime(runtime, ProductCommunicationType.WIFI);
     const supportBle = hasCapabilityForRuntime(runtime, ProductCommunicationType.BLUETOOTH);
     const supportThread = hasCapabilityForRuntime(runtime, ProductCommunicationType.THREAD);
@@ -34,11 +39,18 @@ export const getDeviceStatusForRuntime = (runtime) => {
         onlineTypes: [],
         isWifiActive: wifiEnableState !== 1,
         isWifiMatter: !!isMatter && supportWifi,
+        isActiveThread: runtime.cache.isActiveThreadCache ?? false,
+        isShareThread: isShareThreadRuntimeLocal(runtime),
     };
     const isMatterLocal = isOnlineByType(onlineType, 8);
     const isBleOnline = isOnlineByType(onlineType, 2);
-    const isLocalOnline = !isCloudOnline && isOnlineByType(onlineType, 1);
-    const hasWirelessAwakeDp = hasDpForRuntime(runtime, dpCodes.wirelessAwake);
+    let isLocalOnline = !isCloudOnline && isOnlineByType(onlineType, 1);
+    if (isLocalOnline &&
+        runtime.cache.isActiveThreadCache !== true &&
+        supportThread) {
+        isLocalOnline = false;
+    }
+    const hasWirelessAwakeDp = !notSupportWake && hasDpForRuntime(runtime, dpCodes.wirelessAwake);
     const wirelessAwake = getDpValueForRuntime(runtime, dpCodes.wirelessAwake);
     status.connectEnable = isSupportBleControlForRuntime(runtime) && !isOnline;
     if (supportWifi) {
@@ -76,8 +88,7 @@ export const getDeviceStatusForRuntime = (runtime) => {
         }
     }
     if (supportThread && supportBle) {
-        const isShareThread = isShareThreadRuntimeLocal(runtime);
-        if (isShareThread && isOnline) {
+        if (status.isShareThread && isOnline) {
             if (!status.onlineTypes.includes("local")) {
                 status.onlineTypes = ["local"];
             }

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

@@ -1,7 +1,8 @@
 import dpCodes from "../../config/dp-code";
 import { getDeviceSkill, getIPCConfig, getRotateInfo } from "../../api/video";
 import { getDataWithPreFetchForRuntime } from "../utils";
-import { getDeviceAdvancedAbilitiesForRuntime } from "../misc/capability";
+import { getWithLocalCache } from "../storage/swr-cache";
+import { getDeviceAdvancedAbilitiesForRuntime, hasCapabilityForRuntime, isActiveThreadForRuntime, } from "../misc/capability";
 import { getCurrentUserForRuntime } from "../user/current-user";
 import { checkOfflineDpUpdateForRuntime } from "../offline-dps";
 import { autoSyncTemp } from "../password/sync-temp";
@@ -13,9 +14,9 @@ import syncT0 from "./sync/t0";
 import { getDeviceStatusForRuntime, updateOnlineType } from "./device-status";
 import { handleDpChange } from "./dp-change";
 import { fetchDeviceProperties } from "./remote-permissions";
-import { ipc, yuChannelSyncSingleSync } from "../../platform";
+import { ipc, yuChannelSyncSingleSync, } from "../../platform";
 import { sdkLog } from "../../utils/sdk-log";
-import { RotateType } from "../../constant";
+import { ProductCommunicationType, RotateType } from "../../constant";
 import { isHarmony } from "../../utils";
 export const initState = async (runtime) => {
     const { devInfo: { dps, devId, yuNetState }, dpSchema, } = runtime.config;
@@ -30,6 +31,7 @@ export const initState = async (runtime) => {
     try {
         handleDpChange(runtime, dps, true);
         const isSupportVideo = !!dpSchema[dpCodes.initiativeMessage];
+        const hasThread = hasCapabilityForRuntime(runtime, ProductCommunicationType.THREAD);
         runtime.deviceStatus = getDeviceStatusForRuntime(runtime);
         sdkLog("debug", "initState", "baseStateReady", {
             devId,
@@ -39,24 +41,29 @@ export const initState = async (runtime) => {
                 isSupportVideo,
             },
         });
-        const [, , , rotateInfo, deviceSkill, ipcConfig] = await Promise.allSettled([
+        const [, , , advanceAbilities, isActiveThread, rotateInfo, deviceSkill, ipcConfig,] = await Promise.allSettled([
             updateOnlineType(runtime),
             getCurrentUserForRuntime(runtime),
             fetchDeviceProperties(runtime),
+            getDeviceAdvancedAbilitiesForRuntime(runtime),
+            hasThread ? isActiveThreadForRuntime(runtime) : Promise.resolve(false),
             isSupportVideo
-                ? getDataWithPreFetchForRuntime(runtime, "getRotate", () => getRotateInfo(devId))
+                ?
+                    getDataWithPreFetchForRuntime(runtime, "getRotate", () => getWithLocalCache(runtime, "rotateInfo", () => getRotateInfo(devId), {
+                        version: 1,
+                    }))
                 : Promise.resolve({
                     angle: 0,
                     actualAngle: 0,
                 }),
             isSupportVideo
-                ? getDeviceSkill(devId)
+                ? getWithLocalCache(runtime, "deviceSkill", () => getDeviceSkill(devId))
                 : Promise.resolve({
                     devId,
                     json: { videos: [{ width: 0, height: 0 }] },
                 }),
             isSupportVideo
-                ? getIPCConfig(devId)
+                ? getWithLocalCache(runtime, "ipcConfig", () => getIPCConfig(devId))
                 : Promise.resolve({
                     audioAttributes: {
                         hardwareCapability: [],
@@ -121,7 +128,8 @@ export const initState = async (runtime) => {
                 videoAngle: runtime.config.videoAngle,
             },
         });
-        getDeviceAdvancedAbilitiesForRuntime(runtime).then((abilities) => {
+        if (advanceAbilities.status === "fulfilled") {
+            const abilities = advanceAbilities.value;
             sdkLog("debug", "initState", "advancedAbilitiesFetched", {
                 devId,
                 data: {
@@ -145,7 +153,7 @@ export const initState = async (runtime) => {
                     yuChannelSyncSingleSync(devId);
                 }
             }
-        });
+        }
         syncRemoteSerectKey(runtime);
         checkOfflineDpUpdateForRuntime(runtime, {}, true).then(() => {
             sdkLog("debug", "initState", "offlineDpCheckDone", { devId });

package/lib/feature/state/platform-routing.js

@@ -3,6 +3,7 @@ import { getRuntimeByDevId, listRegisteredRuntimes, } from "../../runtime/regist
 import emitter from "../../utils/event";
 import { getWiFiSignalChangeEvent } from "../misc/signal";
 import { autoSyncTemp } from "../password/sync-temp";
+import { syncFitBindingsForRuntime } from "../fit/sync";
 import syncT0 from "./sync/t0";
 import syncRemoteSerectKey from "./sync/remote-serect-key";
 import { syncOfflineDps } from "./sync/offline-dps";
@@ -38,7 +39,6 @@ const globalHandleDeviceInfoChange = async ({ dps, deviceId, }) => {
         handleDpChange(rt, dps);
     }
     await updateOnlineType(rt);
-    updateDeviceStatus(rt);
 };
 const globalUpdateAllOnlineTypes = async (data) => {
     if (!data?.deviceId) {
@@ -90,8 +90,17 @@ const globalHandleBleChange = ({ deviceId, status }) => {
         devId: deviceId,
         data: { status, registered: !!rt },
     });
-    if (!rt || status !== "CONNECTED") {
-        return;
+    if (rt) {
+        updateOnlineType(rt);
+        if (status === "CONNECTED") {
+            if (rt.config.isFitting) {
+                syncFitBindingsForRuntime(rt).catch(() => { });
+            }
+            void syncRemoteSerectKey(rt);
+            autoSyncTemp(rt);
+            void syncT0(rt);
+            void syncOfflineDps(rt);
+        }
     }
 };
 const globalHandleAppShow = () => {

package/lib/feature/state/remote-permissions.js

@@ -1,6 +1,7 @@
 import { getDeviceProperties } from "../../api/setting";
 import { getDataWithPreFetchForRuntime } from "../utils";
 import { RemotePermissionType } from "../../constant";
+import { cameraPositionMap } from "../../utils/constant";
 export const permissions = [
     RemotePermissionType.ADMINS_ONLY,
     RemotePermissionType.EVERY_ONE,
@@ -37,7 +38,7 @@ export async function fetchDeviceProperties(runtime, isForce) {
                 width: item.w,
                 height: item.h,
                 rotate: item.al,
-                localtion: item.p,
+                location: cameraPositionMap[item.p],
             }));
         }
         catch (e) {

package/lib/feature/state/sync/remote-serect-key.js

@@ -11,6 +11,13 @@ import { reportSetKey as reportSetKeyMap, setKey as setKeyMap, } from "../../../
 import { sdkLog } from "../../../utils/sdk-log";
 const syncRemoteSerectKey = async (runtime, force) => {
     const rt = runtime;
+    if (rt.config.isFitting || !rt.config.idsByCode[dpCodes.remoteNoPdSetkey]) {
+        sdkLog("debug", "syncKey", "skipped", {
+            devId: rt.devId,
+            data: { reason: "unsupported", force: !!force },
+        });
+        return;
+    }
     const useNear = isUseNearChannelForRuntime(rt);
     if (!useNear) {
         sdkLog("debug", "syncKey", "skipped", {

package/lib/feature/storage/swr-cache.d.ts

@@ -0,0 +1,7 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface SwrOptions<T> {
+    version?: number;
+    maxAge?: number;
+    applyToSession?: (rt: LockDeviceRuntime, fresh: T) => void;
+}
+export declare function getWithLocalCache<T>(rt: LockDeviceRuntime, key: string, fetcher: () => Promise<T>, options?: SwrOptions<T>): Promise<T>;

package/lib/feature/storage/swr-cache.js

@@ -0,0 +1,54 @@
+import { getRuntimeByDevId } from "../../runtime/registry";
+import { sdkLog } from "../../utils/sdk-log";
+import { getStorageForRuntime, setStorageForRuntime } from "./index";
+const CACHE_KEY_PREFIX = "swr_";
+const buildKey = (key) => `${CACHE_KEY_PREFIX}${key}`;
+function readValidCache(rt, storageKey, version, maxAge) {
+    const envelope = getStorageForRuntime(rt, storageKey);
+    if (!envelope ||
+        typeof envelope !== "object" ||
+        envelope.v !== version ||
+        !("data" in envelope)) {
+        return { hit: false };
+    }
+    if (typeof maxAge === "number" && maxAge >= 0 && Date.now() - envelope.t > maxAge) {
+        return { hit: false };
+    }
+    return { hit: true, data: envelope.data };
+}
+export async function getWithLocalCache(rt, key, fetcher, options) {
+    if (!rt.config.localCache) {
+        return fetcher();
+    }
+    const version = options?.version ?? 1;
+    const storageKey = buildKey(key);
+    const devId = rt.devId;
+    const writeCache = (data) => {
+        if (getRuntimeByDevId(devId) !== rt) {
+            return;
+        }
+        const envelope = { v: version, t: Date.now(), data };
+        setStorageForRuntime(rt, storageKey, envelope);
+    };
+    const cached = readValidCache(rt, storageKey, version, options?.maxAge);
+    if (cached.hit) {
+        void (async () => {
+            try {
+                const fresh = await fetcher();
+                writeCache(fresh);
+                options?.applyToSession?.(rt, fresh);
+            }
+            catch (error) {
+                sdkLog("warn", "swrCache", "revalidateFailed", {
+                    devId,
+                    data: { key },
+                    error,
+                });
+            }
+        })();
+        return cached.data;
+    }
+    const fresh = await fetcher();
+    writeCache(fresh);
+    return fresh;
+}

package/lib/feature/unlock/method/add-flow.js

@@ -1,7 +1,7 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { createUnlockMethod } from "../../../api/lock";
 import { parallelOnlyForRuntime } from "../../utils";
-import { sleep } from "../../../utils";
+import { formatCloudUnlockId, sleep } from "../../../utils";
 import { getError } from "../../../utils/errors";
 import { publishDpsForRuntime } from "../../dp/publish-dps";
 import emitter from "../../../utils/event";
@@ -207,7 +207,7 @@ const handleAddReport = async (dps) => {
                         const res = await createUnlockMethod({
                             devId: cfg.devInfo.devId,
                             userId: addUnlockMethodData.userId,
-                            unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
+                            unlockId: formatCloudUnlockId(addUnlockMethodData.unlockDpId, result.unlockId),
                             unlockName: "",
                             unlockAttr: 0,
                         });

package/lib/feature/unlock/method/add-password.js

@@ -1,7 +1,7 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { createUnlockMethod } from "../../../api/lock";
 import { encrypt } from "../../../platform/device";
-import { sleep } from "../../../utils";
+import { formatCloudUnlockId, sleep } from "../../../utils";
 import { getError, handleCloudError } from "../../../utils/errors";
 import { publishDpsForRuntime } from "../../dp/publish-dps";
 import { getUnlockMethodBase } from "./internal/base";
@@ -76,7 +76,7 @@ export async function addPasswordForRuntime(rt, params) {
         const result = await createUnlockMethod({
             devId: devId,
             userId: params.userId,
-            unlockId: `${dpId}-${res.unlockId}`,
+            unlockId: formatCloudUnlockId(dpId, res.unlockId),
             unlockName: params.name,
             unlockDetail: aesPwd,
             ...specialInfo,