@ray-js/lock-sdk 1.2.0-beta.2 → 1.2.0-beta.21

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, } from "../misc/capability";
 import { getCurrentUserForRuntime } from "../user/current-user";
 import { checkOfflineDpUpdateForRuntime } from "../offline-dps";
 import { autoSyncTemp } from "../password/sync-temp";
@@ -16,7 +17,7 @@ import { fetchDeviceProperties } from "./remote-permissions";
 import { ipc, yuChannelSyncSingleSync } from "../../platform";
 import { sdkLog } from "../../utils/sdk-log";
 import { RotateType } from "../../constant";
-import { isHarmony } from "src/utils";
+import { isHarmony } from "../../utils";
 export const initState = async (runtime) => {
     const { devInfo: { dps, devId, yuNetState }, dpSchema, } = runtime.config;
     const startedAt = Date.now();
@@ -39,23 +40,28 @@ export const initState = async (runtime) => {
                 isSupportVideo,
             },
         });
-        const [, , rotateInfo, deviceSkill, ipcConfig] = await Promise.allSettled([
+        const [, , , advanceAbilities, rotateInfo, deviceSkill, ipcConfig] = await Promise.allSettled([
             updateOnlineType(runtime),
             getCurrentUserForRuntime(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: [],
@@ -84,8 +90,8 @@ export const initState = async (runtime) => {
                 }
                 else {
                     try {
-                        const modeRes = await ipc.getCurrentSupportedTalkMode(devId);
                         runtime.config.supportTalk = true;
+                        const modeRes = await ipc.getCurrentSupportedTalkMode(devId);
                         runtime.config.isTwoWayTalk = modeRes.talkbackMode === 2;
                         sdkLog("info", "initState", "supportTalk", {
                             devId,
@@ -99,7 +105,7 @@ export const initState = async (runtime) => {
                         sdkLog("error", "initState", "supportTalk", {
                             devId,
                             duration: Date.now() - startedAt,
-                            data: {},
+                            error: e,
                         });
                     }
                 }
@@ -111,7 +117,6 @@ export const initState = async (runtime) => {
                 runtime.config.mediaHeight = temp;
             }
         }
-        await fetchDeviceProperties(runtime);
         sdkLog("info", "initState", "ready", {
             devId,
             duration: Date.now() - startedAt,
@@ -121,7 +126,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 +151,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

@@ -90,8 +90,14 @@ const globalHandleBleChange = ({ deviceId, status }) => {
         devId: deviceId,
         data: { status, registered: !!rt },
     });
-    if (!rt || status !== "CONNECTED") {
-        return;
+    if (rt) {
+        updateOnlineType(rt);
+        if (status === "CONNECTED") {
+            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,
@@ -10,10 +11,12 @@ var DeviceProperties;
 (function (DeviceProperties) {
     DeviceProperties["REMOTE_UNLOCK_AUTH"] = "REMOTE_UNLOCK_AUTH";
     DeviceProperties["UNLOCK_PHONE_REMOTE"] = "UNLOCK_PHONE_REMOTE";
+    DeviceProperties["LOCK_POS_ROT_ANGLE"] = "LOCK_POS_ROT_ANGLE";
 })(DeviceProperties || (DeviceProperties = {}));
 const propsList = [
     DeviceProperties.REMOTE_UNLOCK_AUTH,
     DeviceProperties.UNLOCK_PHONE_REMOTE,
+    DeviceProperties.LOCK_POS_ROT_ANGLE,
 ];
 export async function fetchDeviceProperties(runtime, isForce) {
     let result = null;
@@ -27,4 +30,18 @@ export async function fetchDeviceProperties(runtime, isForce) {
         result[DeviceProperties.UNLOCK_PHONE_REMOTE] === "true";
     runtime.config.remoteOpenPermission =
         permissions[+result[DeviceProperties.REMOTE_UNLOCK_AUTH] || 0];
+    if (result[DeviceProperties.LOCK_POS_ROT_ANGLE]) {
+        try {
+            const data = JSON.parse(result[DeviceProperties.LOCK_POS_ROT_ANGLE]);
+            runtime.config.cameraConfig = data.map((item) => ({
+                isVR: !!item.vr,
+                width: item.w,
+                height: item.h,
+                rotate: item.al,
+                location: cameraPositionMap[item.p],
+            }));
+        }
+        catch (e) {
+        }
+    }
 }

package/lib/feature/storage/index.d.ts

@@ -0,0 +1,5 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const setStorageForRuntime: (rt: LockDeviceRuntime, key: string, data: unknown) => void;
+export declare const getStorageForRuntime: <T = unknown>(rt: LockDeviceRuntime, key: string) => T | null;
+export declare const removeStorageForRuntime: (rt: LockDeviceRuntime, key: string) => void;
+export declare const clearStorageForRuntime: (rt: LockDeviceRuntime, keys: string[]) => void;

package/lib/feature/storage/index.js

@@ -0,0 +1,32 @@
+import { getStorageSync, removeStorageSync, setStorageSync, } from "../../platform";
+const buildStorageKey = (rt, key) => {
+    const { devId, activeTime } = rt.config.devInfo;
+    return `${devId}_${activeTime}_${key}`;
+};
+export const setStorageForRuntime = (rt, key, data) => {
+    const value = typeof data === "string" ? data : JSON.stringify(data);
+    setStorageSync(buildStorageKey(rt, key), value);
+};
+export const getStorageForRuntime = (rt, key) => {
+    const raw = getStorageSync(buildStorageKey(rt, key));
+    if (raw == null || raw === "") {
+        return null;
+    }
+    if (typeof raw === "string") {
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return raw;
+        }
+    }
+    return raw;
+};
+export const removeStorageForRuntime = (rt, key) => {
+    removeStorageSync(buildStorageKey(rt, key));
+};
+export const clearStorageForRuntime = (rt, keys) => {
+    keys.forEach((key) => {
+        removeStorageSync(buildStorageKey(rt, key));
+    });
+};

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/sync/unlock-method.js

@@ -19,6 +19,9 @@ export const syncUnlockMethodWithRuntime = async (runtime) => {
     });
     rt.sync.unlockMethodAutoSyncEnabled = false;
     const { allOpenDps = "" } = await getCurrentUserForRuntime(rt);
+    if (!allOpenDps) {
+        return;
+    }
     const { ins = "", distributed = false } = await fetchSyncUnlockMethodInfo({
         devId: rt.config.devInfo.devId,
         dpIds: allOpenDps.split(","),

package/lib/feature/voip/voip.d.ts

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const getVoipAuthForRuntime: (rt: LockDeviceRuntime) => Promise<import("../../api/voip").VoipAuth>;
+export declare const saveVoipAuthForRuntime: (rt: LockDeviceRuntime, userId: string) => Promise<boolean>;

package/lib/feature/voip/voip.js

@@ -0,0 +1,3 @@
+import { getVoipAuthApi, saveVoipAuthApi } from "../../api/voip";
+export const getVoipAuthForRuntime = (rt) => getVoipAuthApi(rt.config.devInfo.devId);
+export const saveVoipAuthForRuntime = (rt, userId) => saveVoipAuthApi(rt.config.devInfo.devId, userId);

package/lib/interface.d.ts

@@ -12,6 +12,8 @@ export interface LockSDKOption {
     supportMultipleFace?: boolean;
     supportOfflineDps?: boolean;
     preFetch?: boolean;
+    localCache?: boolean;
+    notSupportWake?: boolean;
     logLevel?: SDKLogLevel;
     logger?: SDKLogSink;
     logToConsole?: boolean;
@@ -254,6 +256,11 @@ export interface MediaInfo {
     fileUrl: string;
     mediaBucket: string;
     mediaKey: string;
+    width: number;
+    height: number;
+    angle: number;
+    position: number;
+    isVR: boolean;
 }
 export type LogType = "alarm_record" | "close_record" | "unlock_record" | "operation" | "local_operation";
 export type CloseValue = "UNDEFINED" | "VOICE_REMOTE" | "APP_REMOTE" | "AUTO" | "LOCAL_MANUAL" | "FITTINGS" | "APP" | "GEO_FENCE";
@@ -334,10 +341,20 @@ export interface AlbumMessage extends MediaInfo {
     type: number;
     createTime: number;
 }
+export type VRModeType = "original" | "VR" | "horizontal" | "vertical";
 export interface DeviceAdvancedAbility {
     cloudStorage: {
         support: boolean;
     };
+    vr: {
+        support: boolean;
+        coverMode: VRModeType;
+        modes: Array<{
+            mode: VRModeType;
+            value: number;
+        }>;
+        defaultMode: VRModeType;
+    };
     ai: {
         support: boolean;
         config: Record<string, any>;
@@ -348,7 +365,9 @@ export interface DeviceAdvancedAbility {
     };
     wechatVoip: {
         support: boolean;
-        config: Record<string, any>;
+        isPublice: boolean;
+        appId?: string;
+        modeId?: string;
     };
     voip: {
         support: boolean;
@@ -390,4 +409,11 @@ export interface AIReportPopup {
     reportId: string;
     yearMonth: number;
 }
+export interface CameraConfig {
+    isVR: boolean;
+    width: number;
+    height: number;
+    rotate: number;
+    location: number;
+}
 export {};

package/lib/platform/device.d.ts

@@ -52,7 +52,7 @@ export declare const getSystemInfoSync: () => {
     locationEnabled: boolean;
     wifiEnabled: boolean;
     theme?: ty.Themes;
-    deviceOrientation?: ty.Orientation;
+    deviceOrientation?: ty.PhoneOrientation;
     deviceLevel: string;
     isSupportPinShortcut?: boolean;
     deviceType?: string;
@@ -74,9 +74,10 @@ export declare const requestCloud: <T>(options: {
 export declare const getLaunchOptionsSync: () => {
     path: string;
     scene?: ty.MiniAppScene;
-    query: any;
+    query: Record<string, any>;
     referrerInfo: ty.ReferrerInfo;
     apiCategory?: string;
+    extraQuery?: Record<string, any>;
 };
 export declare function encrypt(deviceId: string, plaintext: string): Promise<string>;
 export declare function decrypt(deviceId: string, plaintext: string): Promise<string>;
@@ -219,7 +220,7 @@ export declare const onResetMemberName: (cb: HomeMemberListener) => void;
 export declare const offResetMemberName: (cb: HomeMemberListener) => void;
 export declare const onResetMemberRole: (cb: HomeMemberListener) => void;
 export declare const offResetMemberRole: (cb: HomeMemberListener) => void;
-export declare const getLogManager: () => ty.GetLogManagerTask;
+export declare const getLogManager: () => ty.LogManager;
 export declare const getAppUserInfo: () => Promise<{
     nickName: string;
     avatarUrl: string;

package/lib/platform/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./device";
+export * from "./storage";
 export { default as ipc } from "./ipc";

package/lib/platform/index.js

@@ -1,2 +1,3 @@
 export * from "./device";
+export * from "./storage";
 export { default as ipc } from "./ipc";

package/lib/platform/ipc.d.ts

@@ -10,5 +10,8 @@ declare const _default: {
     getCurrentSupportedTalkMode: (deviceId: string) => Promise<{
         talkbackMode: number;
     }>;
+    getTTTAbilityKeyList: (key: string) => Promise<{
+        abilityList: string[];
+    }>;
 };
 export default _default;

package/lib/platform/ipc.js

@@ -31,10 +31,23 @@ const getCurrentSupportedTalkMode = (deviceId) => {
     }
     return Promise.reject(new Error("not support"));
 };
+const getTTTAbilityKeyList = (key) => {
+    if (ty.ipc.getTTTAbilityKeyList) {
+        return new Promise((resolve, reject) => {
+            ty.ipc.getTTTAbilityKeyList({
+                key,
+                success: resolve,
+                fail: reject,
+            });
+        });
+    }
+    return Promise.resolve({ abilityList: [] });
+};
 export default {
     wakeUpDoorBell,
     isConnected,
     isConnecting,
     connect,
     getCurrentSupportedTalkMode,
+    getTTTAbilityKeyList,
 };

package/lib/platform/storage.d.ts

@@ -0,0 +1,3 @@
+export declare const setStorageSync: (key: string, data: string) => void;
+export declare const getStorageSync: (key: string) => any;
+export declare const removeStorageSync: (key: string) => void;

package/lib/platform/storage.js

@@ -0,0 +1,9 @@
+export const setStorageSync = (key, data) => {
+    ty.setStorageSync({ key, data });
+};
+export const getStorageSync = (key) => {
+    return ty.getStorageSync({ key });
+};
+export const removeStorageSync = (key) => {
+    ty.removeStorageSync({ key });
+};

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

@@ -1,5 +1,5 @@
 import { ProductCommunicationType, RemotePermissionType } from "../constant";
-import { CapabilityInfo, DeviceInfo, DeviceStatus, DpSchema } from "../interface";
+import { CameraConfig, CapabilityInfo, DeviceInfo, DeviceStatus, DpSchema } from "../interface";
 export type LockConfigState = {
     devInfo: DeviceInfo;
     dpSchema: Record<string, DpSchema>;
@@ -21,8 +21,11 @@ export type LockConfigState = {
     supportMultipleFace: boolean;
     supportOfflineDps: boolean;
     preFetch: boolean;
+    localCache: boolean;
     supportTalk: boolean;
     isTwoWayTalk: boolean;
+    cameraConfig: CameraConfig[];
+    notSupportWake: boolean;
 };
 export declare function createDefaultDeviceStatus(): DeviceStatus;
 export declare function createLockConfigState(): LockConfigState;

package/lib/runtime/lock-config.js

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

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/lib/utils/errors.js

@@ -102,7 +102,9 @@ const errors = {
     1100: "Binding limit reached",
     1101: "The lock has already been bound, please do not bind it again",
     1102: "Lock is binding",
-    1103: "Binding failed"
+    1103: "Binding failed",
+    1104: "Failed to switch cameras",
+    1105: "Camera switching is not supported",
 };
 export const getError = (code, ...places) => {
     if (errors[code]) {

package/lib/utils/index.d.ts

@@ -32,7 +32,7 @@ export declare const getSystemInfo: () => {
     locationEnabled: boolean;
     wifiEnabled: boolean;
     theme?: ty.Themes;
-    deviceOrientation?: ty.Orientation;
+    deviceOrientation?: ty.PhoneOrientation;
     deviceLevel: string;
     isSupportPinShortcut?: boolean;
     deviceType?: string;

package/lib/utils/parse.js

@@ -6,7 +6,7 @@ export const parseCapabilities = (dpValue) => {
         return null;
     }
     const data = dpUtils.parse(dpValue, capabilitiesMap);
-    if (data.tyep === ModuleType.M7258) {
+    if (data.type === ModuleType.M7258) {
         return {
             ...data,
             rotateType: data.rotateType === 1 ? 0 : data.rotateType === 0 ? 1 : data.rotateType,

package/package.json

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