@ray-js/lock-sdk 1.2.0-beta.3 → 1.2.0-beta.30

package/lib/feature/fit/temp-password.js

@@ -3,11 +3,13 @@ import dpCodes from "../../config/dp-code";
 import { fitAddTempPwd, fitReportAddTempPwd, fitRemoveTempPwd, fitReportRemoveTempPwd, fitUpdateTempPwd, fitReportUpdateTempPwd, fitBlePswCreate, fitBlePswDelete, fitBlePswCreateReport, fitBlePswDeleteReport, fitBlePswUpdate, fitBlePswUpdateReport, } from "../../config/dp-map/temp-pwd-fit";
 import { publishDpsForRuntime } from "../dp/publish-dps";
 import { resolveSlaveId } from "./resolve-slave-id";
-import { getError } from "../../utils/errors";
+import { getError, handleCloudError } from "../../utils/errors";
 import { sdkLog } from "../../utils/sdk-log";
-import { addFitOnlineTempPwd, addFitOnlineTempPwdCloud, getFitPasswordList, removeFitOnlineTempPwd, renameFitOnlineTempPwd, updateFitOnlineTempPwd, } from "../../api/fit";
+import { addFitOnlineTempPwd, addFitOnlineTempPwdCloud, getFitPasswordList, removeFitOnlineTempPwd, renameFitOnlineTempPwd, resendFitOnlineTempPwd, updateFitOnlineTempPwd, } from "../../api/fit";
+import { reNameOfflineByPwdId, revokeOfflinePasswordByPwdId } from "../../api/temp";
 import { decrypt, encrypt } from "../../platform";
 import { formatPasswordToList, formatWeek, getAppUser, parseWeek, sleep, transformEffectiveConfigToValidConfig, validateEffectiveConfig, } from "../../utils";
+import { parseOfflinePasswordForRuntime } from "../utils";
 import { hasDpForRuntime } from "../dp/has-dp";
 export async function fitAddTempPwdForRuntime(runtime, params) {
     const startedAt = Date.now();
@@ -180,7 +182,7 @@ export async function fitRemoveTempPwdForRuntime(runtime, params) {
                 data: { id: params.id, status: res.status, strategy: "device_first" },
             });
             if (res.status === 0x00 || res.status === 0x02) {
-                await removeFitOnlineTempPwd(runtime.devId, exist.pwdId);
+                await removeFitOnlineTempPwd(runtime.devId, exist.unlockBindingId);
             }
             else {
                 throw getError(1028);
@@ -426,3 +428,93 @@ export const fitRenameTempPwdForRuntime = async (runtime, params) => {
         throw error;
     }
 };
+export const fitRenameOfflineTempPwdForRuntime = async (runtime, params) => {
+    const startedAt = Date.now();
+    sdkLog("info", "fitTempPassword", "renameOfflineStart", {
+        devId: runtime.devId,
+        data: { pwdId: params.pwdId, hasName: typeof params.name === "string" },
+    });
+    try {
+        await reNameOfflineByPwdId({
+            devId: runtime.devId,
+            pwdName: params.name,
+            pwdId: params.pwdId,
+        });
+        sdkLog("info", "fitTempPassword", "renameOfflineSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { pwdId: params.pwdId },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fitTempPassword", "renameOfflineFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { pwdId: params.pwdId },
+            error,
+        });
+        throw error;
+    }
+};
+export const fitRevokeOfflineTempPwdForRuntime = async (runtime, params) => {
+    const startedAt = Date.now();
+    sdkLog("info", "fitTempPassword", "revokeOfflineStart", {
+        devId: runtime.devId,
+        data: { pwdId: params.pwdId, hasName: typeof params.name === "string" },
+    });
+    try {
+        const res = await revokeOfflinePasswordByPwdId({
+            devId: runtime.devId,
+            pwdId: params.pwdId,
+            name: params.name,
+        });
+        sdkLog("info", "fitTempPassword", "revokeOfflineSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { pwdId: params.pwdId },
+        });
+        return {
+            password: parseOfflinePasswordForRuntime(runtime, res.pwd),
+            pwdId: res.pwdId,
+            name: res.pwdName,
+            effectiveConfig: {
+                effectiveDate: res.gmtStart,
+                expiredDate: res.gmtExpired,
+            },
+        };
+    }
+    catch (error) {
+        sdkLog("error", "fitTempPassword", "revokeOfflineFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { pwdId: params.pwdId },
+            error,
+        });
+        throw handleCloudError(error);
+    }
+};
+export const fitResendTempPwdForRuntime = async (runtime, params) => {
+    const startedAt = Date.now();
+    sdkLog("info", "fitTempPassword", "resendStart", {
+        devId: runtime.devId,
+        data: { id: params.id },
+    });
+    try {
+        const result = await resendFitOnlineTempPwd(runtime.devId, params.id);
+        sdkLog("info", "fitTempPassword", "resendSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fitTempPassword", "resendFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+            error,
+        });
+        throw error;
+    }
+};

package/lib/feature/fit/users.d.ts

@@ -7,6 +7,7 @@ export interface FitUserItem {
     nickName: string;
     userType: UserType;
     userContact: string;
+    userTimeSet: string;
     phase: number;
 }
 export declare function getFitUsersForRuntime(runtime: LockDeviceRuntime): Promise<FitUserItem[]>;

package/lib/feature/fit/users.js

@@ -7,6 +7,7 @@ const pickFitUserItem = (raw) => ({
     nickName: raw.nickName,
     userType: raw.userType,
     userContact: raw.userContact,
+    userTimeSet: raw.userTimeSet,
     phase: raw.phase,
 });
 export async function getFitUsersForRuntime(runtime) {

package/lib/feature/gesture/gesture.d.ts

@@ -0,0 +1,6 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const getGestureStatusForRuntime: (rt: LockDeviceRuntime) => Promise<import("../../api/gesture").GestureStatus>;
+export declare const updateGestureStatusForRuntime: (rt: LockDeviceRuntime, params: {
+    password: string;
+    open: boolean;
+}) => Promise<boolean>;

package/lib/feature/gesture/gesture.js

@@ -0,0 +1,3 @@
+import { getGestureStatusApi, setGestureStatusApi } from "../../api/gesture";
+export const getGestureStatusForRuntime = (rt) => getGestureStatusApi(rt.config.devInfo.devId);
+export const updateGestureStatusForRuntime = (rt, params) => setGestureStatusApi({ devId: rt.config.devInfo.devId, ...params });

package/lib/feature/log/log.d.ts

@@ -1,5 +1,5 @@
 import { LockLogCategory } from "../../api/log";
-import { AlbumMessage, LogData, UnlockMethodType } from "../../interface";
+import { AlbumMessage, CloseValue, LogData, UnlockMethodType } from "../../interface";
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
 export type LogsRefreshListener = () => void;
 export declare function getLogsRefreshEvent(runtime: LockDeviceRuntime): string;
@@ -16,11 +16,13 @@ export interface GetLogsParams {
     pageSize?: number;
 }
 export declare const openDps: ("unlock_matter_kw" | "unlock_password" | "unlock_fingerprint" | "unlock_finger_vein" | "unlock_hand" | "unlock_dynamic" | "unlock_key" | "unlock_card" | "unlock_face" | "unlock_temporary" | "unlock_offline_pd" | "unlock_phone_remote" | "unlock_voice_remote" | "lock_record" | "unlock_ble" | "unlock_eye" | "unlock_double_kit" | "unlock_double_kit_w" | "open_inside" | "lock_local_record" | "unlock_inside" | "door_opened" | "unlock_app")[];
+export declare const closeTypes: CloseValue[];
 export interface GetLogsResult {
     list: LogData[];
     hasMore: boolean;
     total: number;
 }
+export declare const dpIdsForUsernameToUnlockName: number[];
 export declare function getLogsForRuntime(rt: LockDeviceRuntime, params?: GetLogsParams): Promise<GetLogsResult>;
 export interface GetAlarmsParams {
     page?: number;
@@ -61,3 +63,5 @@ export interface GetLockLogListResult {
     lastRowKey: string;
 }
 export declare const getLockLogListForRuntime: (rt: LockDeviceRuntime, params: GetLockLogListParams) => Promise<GetLockLogListResult>;
+export declare const getAlarmUnreadCountForRuntime: (rt: LockDeviceRuntime) => Promise<number>;
+export declare const getActivePeriodForRuntime: (rt: LockDeviceRuntime) => Promise<number>;

package/lib/feature/log/log.js

@@ -1,4 +1,4 @@
-import { getAlarmList, getAlbumMessages, getLatest2Log, getLockLogList, getRecordList, } from "../../api/log";
+import { getAlarmList, getAlbumMessages, getLatest2Log, getLockLogList, getRecordList, getAlarmUnreadCountApi, getActivePeriodApi, } from "../../api/log";
 import dpCodes from "../../config/dp-code";
 import { getCurrentUserForRuntime } from "../user/current-user";
 import base64ToHex from "../../utils/base64-to-hex";
@@ -6,6 +6,7 @@ import { LOGCHANGE } from "../../utils/constant";
 import emitter from "../../utils/event";
 import { handleLocalOperation } from "../../utils/log";
 import { parseWeek } from "../../utils";
+import { cameraPositionMap } from "../../utils/constant";
 export function getLogsRefreshEvent(runtime) {
     return `${LOGCHANGE}_${runtime.devId}`;
 }
@@ -152,7 +153,20 @@ function handleLockLogs(list, cfg) {
             userId: item.userId,
             userName: userName || "",
             unlockName: unlockName || "",
-            mediaInfo: item.mediaInfoList,
+            mediaInfo: item.mediaInfoList?.map?.((item) => {
+                return {
+                    mediaPath: item.mediaPath,
+                    fileKey: item.fileKey,
+                    fileUrl: item.fileUrl,
+                    mediaBucket: item.mediaBucket,
+                    mediaKey: item.mediaKey,
+                    width: item.positionWidth,
+                    height: item.positionHeight,
+                    angle: item.positionAngle,
+                    isVR: !!item.positionVr,
+                    position: item.position,
+                };
+            }),
             localRecord: handleLocalOperation(item.localOperateRecordInfo, itemData),
             unionUnlockInfo: item.unionUnlockInfo?.map((item1) => {
                 return {
@@ -227,7 +241,7 @@ export const openDps = [
     dpCodes.unlockApp,
     dpCodes.unlockMatterKw,
 ];
-const closeTypes = [
+export const closeTypes = [
     "UNDEFINED",
     "APP_REMOTE",
     "VOICE_REMOTE",
@@ -237,7 +251,7 @@ const closeTypes = [
     "AUTO",
     "LOCAL_MANUAL",
 ];
-const dpIdsForUsernameToUnlockName = [89, 69, 55, 67, 3, 32];
+export const dpIdsForUsernameToUnlockName = [89, 69, 55, 67, 3, 32];
 export async function getLogsForRuntime(rt, params) {
     const cfg = rt.config;
     const { page = 1, pageSize = 50 } = params || {};
@@ -285,7 +299,20 @@ export async function getLogsForRuntime(rt, params) {
                 dpCode,
                 userName,
                 unlockName,
-                mediaInfo: record.mediaInfoList,
+                mediaInfo: record.mediaInfoList?.map?.(item => {
+                    return {
+                        mediaPath: item.mediaPath,
+                        fileKey: item.fileKey,
+                        fileUrl: item.fileUrl,
+                        mediaBucket: item.mediaBucket,
+                        mediaKey: item.mediaKey,
+                        width: item.positionWidth,
+                        height: item.positionHeight,
+                        angle: item.positionAngle,
+                        isVR: !!item.positionVr,
+                        position: item.position,
+                    };
+                }),
                 unionUnlockInfo: record.unionUnlockInfo?.map((item) => ({
                     userId: item.userId,
                     userName: item.userName,
@@ -364,7 +391,20 @@ export async function getAlarmsForRuntime(rt, params) {
                 dpCode,
                 userName: record.userName,
                 unlockName: record.unlockName,
-                mediaInfo: record.mediaInfoList,
+                mediaInfo: record.mediaInfoList?.map?.(item => {
+                    return {
+                        mediaPath: item.mediaPath,
+                        fileKey: item.fileKey,
+                        fileUrl: item.fileUrl,
+                        mediaBucket: item.mediaBucket,
+                        mediaKey: item.mediaKey,
+                        width: item.positionWidth,
+                        height: item.positionHeight,
+                        angle: item.positionAngle,
+                        isVR: !!item.positionVr,
+                        position: item.position,
+                    };
+                }),
                 time: record.gmtCreate,
                 currentUser: +record.userId === +currentUser.userId,
                 bindable: false,
@@ -418,6 +458,11 @@ export async function getAlbumsForRuntime(rt, params) {
             })),
             type: item.eventType,
             createTime: item.uploadMilTime,
+            width: item.width,
+            height: item.height,
+            angle: item.angle,
+            position: cameraPositionMap[item.position],
+            isVR: !!item.vr,
         })),
         allAitypes: data.allAitypes,
         types: data.eventTypes,
@@ -436,3 +481,5 @@ export const getLockLogListForRuntime = async (rt, params) => {
         lastRowKey: data?.lastRowKey ?? "",
     };
 };
+export const getAlarmUnreadCountForRuntime = (rt) => getAlarmUnreadCountApi(rt.config.devInfo.devId);
+export const getActivePeriodForRuntime = (rt) => getActivePeriodApi(rt.config.devInfo.devId);

package/lib/feature/media/camera.d.ts

@@ -0,0 +1,18 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import type { CameraConfig, DpMapDataType } from "../../interface";
+import { locationSelectReportMap } from "../../config/dp-map/media";
+export type CameraInfo = DpMapDataType<typeof locationSelectReportMap>;
+export declare const isSupportMultiCameraForRuntime: (runtime: LockDeviceRuntime) => boolean;
+interface CameraItem {
+    index: number;
+    type: number;
+}
+export interface CameraDpInfo {
+    status: number;
+    list: CameraItem[];
+}
+export declare const getCameraInfoForRuntime: (runtime: LockDeviceRuntime) => CameraDpInfo | undefined;
+export declare const queryCameraInfoForRuntime: (runtime: LockDeviceRuntime) => Promise<CameraInfo | undefined>;
+export declare const switchCameraForRuntime: (runtime: LockDeviceRuntime, index: number) => Promise<true>;
+export declare const getCameraConfigForRuntime: (runtime: LockDeviceRuntime) => CameraConfig[];
+export {};

package/lib/feature/media/camera.js

@@ -0,0 +1,36 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import dpCodes from "../../config/dp-code";
+import { locationSelectReportMap } from "../../config/dp-map/media";
+import { getDpValueForRuntime } from "../dp/get-dp-value";
+import { hasDpForRuntime } from "../dp/has-dp";
+import { publishDpsForRuntime } from "../dp/publish-dps";
+import { getError } from "../../utils/errors";
+export const isSupportMultiCameraForRuntime = (runtime) => hasDpForRuntime(runtime, dpCodes.locationSelect);
+export const getCameraInfoForRuntime = (runtime) => {
+    const raw = getDpValueForRuntime(runtime, dpCodes.locationSelect);
+    if (!raw) {
+        return undefined;
+    }
+    return dpUtils.parse(raw, locationSelectReportMap);
+};
+export const queryCameraInfoForRuntime = async (runtime) => {
+    await publishDpsForRuntime(runtime, { [dpCodes.locationSelect]: "ff" });
+    return getCameraInfoForRuntime(runtime);
+};
+export const switchCameraForRuntime = async (runtime, index) => {
+    const value = index.toString(16).padStart(2, "0");
+    await publishDpsForRuntime(runtime, { [dpCodes.locationSelect]: value });
+    const info = getCameraInfoForRuntime(runtime);
+    switch (info?.status) {
+        case 0:
+            return true;
+        case 2:
+            throw getError(1105);
+        case 1:
+        default:
+            throw getError(1104);
+    }
+};
+export const getCameraConfigForRuntime = (runtime) => {
+    return runtime.config.cameraConfig;
+};

package/lib/feature/media/media.d.ts

@@ -1,4 +1,5 @@
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import { MediaViewTimesResult, getAlbumDateListResult } from "../../api/video";
 export interface GetMediaUrlParams {
     mediaPath: string;
     mediaBucket: string;
@@ -19,6 +20,12 @@ export interface OpenLocalAlbumParams {
     serviceCode?: string;
 }
 export declare const openLocalAlbumForRuntime: (runtime: LockDeviceRuntime, params?: OpenLocalAlbumParams) => Promise<void>;
+export interface GotoPlaybackParams {
+    tabs?: ("local" | "cloud")[];
+    isLowPower?: boolean;
+    rotate?: number;
+}
+export declare const gotoPlaybackForRuntime: (runtime: LockDeviceRuntime, params?: GotoPlaybackParams) => Promise<void>;
 export interface MediaInfo {
     imageAngle: number;
     videoAngle: number;
@@ -29,3 +36,6 @@ export interface MediaInfo {
     isTwoWayTalk: boolean;
 }
 export declare const getMediaInfoForRuntime: (runtime: LockDeviceRuntime) => MediaInfo;
+export declare const getMediaViewTimesForRuntime: (runtime: LockDeviceRuntime) => Promise<MediaViewTimesResult>;
+export declare const setMediaViewTimesForRuntime: (runtime: LockDeviceRuntime) => Promise<MediaViewTimesResult>;
+export declare const getAlbumDateListForRuntime: (runtime: LockDeviceRuntime) => Promise<getAlbumDateListResult>;

package/lib/feature/media/media.js

@@ -4,6 +4,7 @@ import dpCodes from "../../config/dp-code";
 import { RotateType, VedioType } from "../../constant";
 import { isSupportShortLink } from "../../platform";
 import { getError } from "../../utils/errors";
+import { getMediaViewTimes, setMediaViewTimes, getAlbumDateList, } from "../../api/video";
 export const getMediaUrlForRuntime = async (runtime, params) => {
     const devId = runtime.config.devInfo.devId;
     if ("mediaPath" in params && "mediaBucket" in params) {
@@ -52,6 +53,27 @@ export const openLocalAlbumForRuntime = async (runtime, params) => {
     }
     return Promise.reject(getError(1013));
 };
+export const gotoPlaybackForRuntime = async (runtime, params) => {
+    const link = await isSupportShortLink("camera_playbacks_panel");
+    if (!link) {
+        return Promise.reject(getError(1013));
+    }
+    const tabs = params?.tabs && params.tabs.length ? params.tabs : ["local"];
+    let url = `tuyaSmart://${link}?extra_camera_uuid=${runtime.devId}&devId=${runtime.devId}&bizType=doorLock&defaultShowTabs=true&theme=1&tabs=${JSON.stringify(tabs)}`;
+    if (params?.isLowPower) {
+        url += `&isLowPowerDevice=true`;
+    }
+    if (params?.rotate !== undefined) {
+        url += `&rotate=${params.rotate}`;
+    }
+    return new Promise((resolve, reject) => {
+        ty.router({
+            url,
+            success: () => resolve(),
+            fail: (e) => reject(e),
+        });
+    });
+};
 export const getMediaInfoForRuntime = (runtime) => {
     const isSEI = runtime.config.capabilities?.rotateType === RotateType.SEI;
     return {
@@ -64,3 +86,12 @@ export const getMediaInfoForRuntime = (runtime) => {
         isTwoWayTalk: runtime.config.isTwoWayTalk,
     };
 };
+export const getMediaViewTimesForRuntime = (runtime) => {
+    return getMediaViewTimes(runtime.config.devInfo.devId);
+};
+export const setMediaViewTimesForRuntime = (runtime) => {
+    return setMediaViewTimes(runtime.config.devInfo.devId);
+};
+export const getAlbumDateListForRuntime = (runtime) => {
+    return getAlbumDateList(runtime.config.devInfo.devId);
+};

package/lib/feature/misc/ble-control.js

@@ -26,10 +26,10 @@ export const isSupportBleControlForRuntime = (rt) => {
     const bleControlDp = rt.config.idsByCode[dpCodes.bleControl];
     if (bleControlDp) {
         const reportTIme = devInfo?.dpsTime?.[bleControlDp];
-        const hasReportTime = !reportTIme ||
+        const noReportTime = !reportTIme ||
             Math.floor(Number(reportTIme) / 1000) <= devInfo.activeTime;
         const bleVal = rt.cache.dpState[dpCodes.bleControl];
-        if (!bleVal || !hasReportTime) {
+        if (!bleVal && noReportTime) {
             return true;
         }
         return bleVal;

package/lib/feature/misc/capability.d.ts

@@ -5,4 +5,6 @@ export declare const hasCapabilityForRuntime: (runtime: LockDeviceRuntime, capab
 export declare const isBlePureDeviceForRuntime: (rt: LockDeviceRuntime) => boolean;
 export declare const isShareTheadForRuntime: (rt: LockDeviceRuntime) => boolean;
 export declare const isActiveThreadForRuntime: (rt: LockDeviceRuntime) => Promise<boolean>;
+export declare const getDeviceAdvancedAbilitiesSyncForRuntime: (rt: LockDeviceRuntime) => DeviceAdvancedAbility | undefined;
 export declare const getDeviceAdvancedAbilitiesForRuntime: (rt: LockDeviceRuntime) => Promise<DeviceAdvancedAbility>;
+export declare const getDeviceCapabilitiesForRuntime: (rt: LockDeviceRuntime) => import("../../interface").CapabilityInfo | null;

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 {
@@ -34,23 +42,55 @@ export const isActiveThreadForRuntime = async (rt) => {
     }
     return false;
 };
+const allModes = [
+    {
+        mode: "VR",
+        value: 1,
+    },
+    {
+        mode: "original",
+        value: 0,
+    },
+    {
+        mode: "vertical",
+        value: 3,
+    },
+    {
+        mode: "horizontal",
+        value: 2,
+    },
+];
+export const getDeviceAdvancedAbilitiesSyncForRuntime = (rt) => {
+    return rt.cache.deviceAdvanceAbilityCache;
+};
 export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
     if (rt.cache.deviceAdvanceAbilityCache) {
         return rt.cache.deviceAdvanceAbilityCache;
     }
-    const [productAbilities, deviceAdvancedAbility] = await Promise.all([
-        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",
-        ]),
-        getDeviceAdvancedAbility(rt.config.devInfo.devId),
+            "visual_door_lock_cloud_store",
+        ])),
+        getWithLocalCache(rt, "deviceAdvancedAbility", () => getDeviceAdvancedAbility(devId)),
+        ipc.getTTTAbilityKeyList("isSupportedVRMode"),
     ]);
+    const productAbilities = productAbilitiesRes.status === "fulfilled" ? productAbilitiesRes.value : [];
+    const tttAbList = tttList.status === "fulfilled" ? tttList.value.abilityList : [];
     const deviceAdvanceAbilityCache = {
         cloudStorage: {
-            support: deviceAdvancedAbility.types.includes(0),
+            support: false,
+        },
+        vr: {
+            support: false,
+            defaultMode: "VR",
+            modes: [],
+            coverMode: "VR",
         },
         ai: {
             support: false,
@@ -61,12 +101,12 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
             config: {},
         },
         voip: {
-            support: deviceAdvancedAbility.types.includes(1),
+            support: false,
             config: {},
         },
         wechatVoip: {
             support: false,
-            config: {},
+            isPublice: true,
         },
         unlockGuide: {
             support: false,
@@ -80,8 +120,11 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
     productAbilities.forEach((item) => {
         try {
             if (item.isOpen) {
-                const data = JSON.parse(item.extConfig);
+                const data = item.extConfig ? JSON.parse(item.extConfig) : {};
                 switch (item.abilityCode) {
+                    case "visual_door_lock_cloud_store":
+                        deviceAdvanceAbilityCache.cloudStorage.support = true;
+                        break;
                     case "tyabi4ucx5": {
                         deviceAdvanceAbilityCache.ai.config = data;
                         const dataReport = data?.ai_data_report ?? false;
@@ -95,6 +138,20 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
                                 petRecognition ||
                                 voice ||
                                 message;
+                        deviceAdvanceAbilityCache.vr.support =
+                            !!data?.lock_VR && tttAbList.length > 0;
+                        if (deviceAdvanceAbilityCache.vr.support) {
+                            deviceAdvanceAbilityCache.vr.modes = allModes.filter((item) => {
+                                return data?.modes?.includes(item.mode);
+                            });
+                            deviceAdvanceAbilityCache.vr.defaultMode = data.default_mode;
+                            const exist = deviceAdvanceAbilityCache.vr.modes.find((x) => x.mode === deviceAdvanceAbilityCache.vr.defaultMode);
+                            if (!exist) {
+                                deviceAdvanceAbilityCache.vr.defaultMode =
+                                    deviceAdvanceAbilityCache.vr.modes?.[0]?.mode;
+                            }
+                            deviceAdvanceAbilityCache.vr.coverMode = data.photo_cover_format;
+                        }
                         break;
                     }
                     case "tyabis9tpe": {
@@ -103,9 +160,15 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
                         break;
                     }
                     case "tyabiwxrn9": {
-                        deviceAdvanceAbilityCache.wechatVoip.support =
+                        deviceAdvanceAbilityCache.wechatVoip.isPublice =
+                            data?.WechatType === "0";
+                        if (!deviceAdvanceAbilityCache.wechatVoip.isPublice) {
+                            deviceAdvanceAbilityCache.wechatVoip.appId =
+                                data["WechatMPAppid"];
+                            deviceAdvanceAbilityCache.wechatVoip.modeId = data["WechatMPMid"];
+                        }
+                        deviceAdvanceAbilityCache.voip.support =
                             !!data?.voipType?.includes("0");
-                        deviceAdvanceAbilityCache.wechatVoip.config = data;
                         break;
                     }
                     case "tyabipd4hh": {
@@ -126,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>;