@ray-js/lock-sdk 1.2.0-beta.18 → 1.2.0-beta.19

package/lib/constant.d.ts

@@ -76,4 +76,3 @@ export declare enum RemotePermissionType {
     ADMINS_ONLY = "adminsOnly",
     NO_ONE = "noOne"
 }
-export declare const cameraPositionMap: Record<number, number>;

package/lib/constant.js

@@ -87,9 +87,3 @@ export var RemotePermissionType;
     RemotePermissionType["ADMINS_ONLY"] = "adminsOnly";
     RemotePermissionType["NO_ONE"] = "noOne";
 })(RemotePermissionType || (RemotePermissionType = {}));
-export const cameraPositionMap = {
-    0: 4,
-    1: 3,
-    2: 5,
-    3: 6,
-};

package/lib/entries/main/bootstrap/bootstrap.js

@@ -47,6 +47,7 @@ export async function applyLockOptionsToRuntime(runtime, options) {
     config.idsByCode = idsByCode;
     config.supportBigData = !!dpSchema[dpCodes.synchMethodW];
     config.preFetch = options?.preFetch ?? false;
+    config.localCache = options?.localCache ?? true;
     config.notSupportWake = options?.notSupportWake ?? false;
     config.communication = getCapabilities(devInfo.capability).map((item) => item.id);
     sdkLog("info", "bootstrap", "applyOptions", {

package/lib/feature/log/log.js

@@ -6,7 +6,7 @@ import { LOGCHANGE } from "../../utils/constant";
 import emitter from "../../utils/event";
 import { handleLocalOperation } from "../../utils/log";
 import { parseWeek } from "../../utils";
-import { cameraPositionMap } from "../../constant";
+import { cameraPositionMap } from "../../utils/constant";
 export function getLogsRefreshEvent(runtime) {
     return `${LOGCHANGE}_${runtime.devId}`;
 }

package/lib/feature/misc/capability.js

@@ -2,6 +2,7 @@ import { getDeviceAdvancedAbility, getProductAbilities } from "../../api";
 import { 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;
@@ -60,15 +61,17 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
     if (rt.cache.deviceAdvanceAbilityCache) {
         return rt.cache.deviceAdvanceAbilityCache;
     }
-    const [productAbilitiesRes, tttList] = 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",
-        ]),
+        ])),
+        getWithLocalCache(rt, "deviceAdvancedAbility", () => getDeviceAdvancedAbility(devId)),
         ipc.getTTTAbilityKeyList("isSupportedVRMode"),
     ]);
     const productAbilities = productAbilitiesRes.status === "fulfilled" ? productAbilitiesRes.value : [];
@@ -180,12 +183,13 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
             console.warn(`setting [${item.abilityCode}] config error`, error);
         }
     });
-    getDeviceAdvancedAbility(rt.config.devInfo.devId).then((res) => {
+    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;
 };

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

@@ -1,6 +1,7 @@
 import dpCodes from "../../config/dp-code";
 import { getDeviceSkill, getIPCConfig, getRotateInfo } from "../../api/video";
 import { getDataWithPreFetchForRuntime } from "../utils";
+import { getWithLocalCache } from "../storage/swr-cache";
 import { getDeviceAdvancedAbilitiesForRuntime, } from "../misc/capability";
 import { getCurrentUserForRuntime } from "../user/current-user";
 import { checkOfflineDpUpdateForRuntime } from "../offline-dps";
@@ -45,19 +46,22 @@ export const initState = async (runtime) => {
             fetchDeviceProperties(runtime),
             getDeviceAdvancedAbilitiesForRuntime(runtime),
             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: [],

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

@@ -1,6 +1,7 @@
 import { getDeviceProperties } from "../../api/setting";
 import { getDataWithPreFetchForRuntime } from "../utils";
-import { cameraPositionMap, RemotePermissionType } from "../../constant";
+import { RemotePermissionType } from "../../constant";
+import { cameraPositionMap } from "../../utils/constant";
 export const permissions = [
     RemotePermissionType.ADMINS_ONLY,
     RemotePermissionType.EVERY_ONE,

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/interface.d.ts

@@ -12,6 +12,7 @@ export interface LockSDKOption {
     supportMultipleFace?: boolean;
     supportOfflineDps?: boolean;
     preFetch?: boolean;
+    localCache?: boolean;
     notSupportWake?: boolean;
     logLevel?: SDKLogLevel;
     logger?: SDKLogSink;

package/lib/runtime/lock-config.d.ts

@@ -21,6 +21,7 @@ export type LockConfigState = {
     supportMultipleFace: boolean;
     supportOfflineDps: boolean;
     preFetch: boolean;
+    localCache: boolean;
     supportTalk: boolean;
     isTwoWayTalk: boolean;
     cameraConfig: CameraConfig[];

package/lib/runtime/lock-config.js

@@ -31,6 +31,7 @@ export function createLockConfigState() {
         supportMultipleFace: false,
         supportOfflineDps: false,
         preFetch: false,
+        localCache: true,
         supportTalk: false,
         isTwoWayTalk: false,
         cameraConfig: [],

package/lib/utils/constant.d.ts

@@ -12,3 +12,4 @@ export declare enum LoopTypes {
     WEEK = 2,
     MONTH = 3
 }
+export declare const cameraPositionMap: Record<number, number>;

package/lib/utils/constant.js

@@ -14,3 +14,9 @@ export var LoopTypes;
     LoopTypes[LoopTypes["WEEK"] = 2] = "WEEK";
     LoopTypes[LoopTypes["MONTH"] = 3] = "MONTH";
 })(LoopTypes || (LoopTypes = {}));
+export const cameraPositionMap = {
+    0: 4,
+    1: 3,
+    2: 5,
+    3: 6,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/lock-sdk",
-  "version": "1.2.0-beta.18",
+  "version": "1.2.0-beta.19",
   "files": [
     "lib",
     "LICENSE.md"