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

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

@@ -1,4 +1,4 @@
-import { getFitPasswordList } from "../../api/fit";
+import { getFitPasswordList, getFitOfflinePasswordList, } from "../../api/fit";
 import { parseWeek } from "../../utils";
 export const getFitPasswordListForRuntime = async (runtime) => {
     const list = await getFitPasswordList(runtime.devId);
@@ -29,3 +29,46 @@ export const getFitPasswordListForRuntime = async (runtime) => {
         };
     });
 };
+export const getFitOnlinePasswordListForRuntime = async (runtime) => {
+    const list = await getFitPasswordList(runtime.devId);
+    return (list ?? []).map((item) => ({
+        id: item.unlockBindingId,
+        pwdId: item.pwdId,
+        sn: item.sn,
+        gmtCreate: item.gmtCreate,
+        opModeType: item.opModeType,
+        opModeSubType: item.opModeSubType,
+        name: item.name,
+        userName: item.userName,
+        mobile: item.mobile,
+        hijack: item.hijack,
+        operate: item.operate,
+        effectiveTime: item.effectiveTime,
+        invalidTime: item.invalidTime,
+        devNameList: item.devNameList ?? [],
+        scheduleDetails: item.scheduleDetails ?? [],
+    }));
+};
+export const getFitOfflinePasswordListForRuntime = async (runtime) => {
+    const res = await getFitOfflinePasswordList(runtime.devId);
+    const list = Array.isArray(res)
+        ? res
+        : (res?.datas ?? []);
+    return list.map((item) => ({
+        id: item.unlockBindingId ?? item.pwdId,
+        pwdId: item.pwdId,
+        sn: item.sn,
+        gmtCreate: item.gmtCreate,
+        opModeType: item.opModeType ?? 3,
+        opModeSubType: item.opModeSubType,
+        pwdName: item.pwdName,
+        mayExpired: item.mayExpired,
+        gmtStart: item.gmtStart,
+        gmtExpired: item.gmtExpired,
+        devNameList: item.devNameList ?? [],
+        scheduleDetails: item.scheduleDetails ?? [],
+        revokedPwdName: item.revokedPwdName,
+        revokedPwdEffectiveTime: item.revokedPwdEffectiveTime,
+        revokedPwdInvalidTime: item.revokedPwdInvalidTime,
+    }));
+};

package/lib/feature/fit/security-channel.d.ts

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const isFitSecurityChannelEnabledForRuntime: (rt: LockDeviceRuntime) => boolean;
+export declare const getSecurityUpdatedLockIds: (fittingId: string) => Promise<string[]>;

package/lib/feature/fit/security-channel.js

@@ -0,0 +1,43 @@
+import { getDeviceProperties } from "../../api/setting";
+import { sdkLog } from "../../utils/sdk-log";
+export const isFitSecurityChannelEnabledForRuntime = (rt) => {
+    const raw = rt.config.devInfo?.meta?.["btScyChannel"];
+    if (!raw) {
+        return false;
+    }
+    try {
+        const parsed = typeof raw === "string"
+            ? JSON.parse(raw)
+            : raw;
+        return parsed?.enable === 1;
+    }
+    catch {
+        return false;
+    }
+};
+export const getSecurityUpdatedLockIds = async (fittingId) => {
+    try {
+        const props = await getDeviceProperties(fittingId, ["SECURITY_UPDATED"]);
+        const raw = props?.["SECURITY_UPDATED"];
+        if (typeof raw === "string") {
+            try {
+                return JSON.parse(raw).value || [];
+            }
+            catch {
+                return [];
+            }
+        }
+        if (raw && typeof raw === "object") {
+            return (raw.value ||
+                (Array.isArray(raw) ? raw : []));
+        }
+        return [];
+    }
+    catch (e) {
+        sdkLog("warn", "fit", "getSecurityUpdatedError", {
+            devId: fittingId,
+            error: e,
+        });
+        return [];
+    }
+};

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

@@ -2,6 +2,14 @@ export type FitBindOperation = "bind" | "unbind";
 export declare const FIT_BIND_TIMEOUT_MS = 12000;
 export declare const FIT_OPERATION_CODE: Record<FitBindOperation, "00" | "01">;
 export declare const normalizeHex: (value: string) => string;
+export declare function markPrecautionaryUnbindPublished(fittingId: string, fit: {
+    fittingUnlockId: string;
+    randomStr: string;
+    devUnlockId: string;
+}): void;
+export declare function clearPrecautionaryUnbindSuppression(fittingId: string): void;
+export declare function shouldSuppressFitSyncReportFrame(fittingId: string, data: string): boolean;
+export declare function normalizeDevUuidHex(devUuid: string): string;
 export declare function buildTransparentData(operation: FitBindOperation, fit: {
     fittingUnlockId: string;
     randomStr: string;

package/lib/feature/fit/shared.js

@@ -7,8 +7,43 @@ export const FIT_OPERATION_CODE = {
     unbind: "01",
 };
 export const normalizeHex = (value) => value.replace(/\s/g, "");
+const PRECAUTIONARY_UNBIND_SUPPRESS_MS = 60_000;
+const pendingPrecautionaryUnbindAcks = new Map();
+const buildUnbindAckPrefix = (fit) => `01${fit.fittingUnlockId}${fit.randomStr}${fit.devUnlockId}`.toLowerCase();
+export function markPrecautionaryUnbindPublished(fittingId, fit) {
+    pendingPrecautionaryUnbindAcks.set(fittingId, {
+        prefix: buildUnbindAckPrefix(fit),
+        expiresAt: Date.now() + PRECAUTIONARY_UNBIND_SUPPRESS_MS,
+    });
+}
+export function clearPrecautionaryUnbindSuppression(fittingId) {
+    pendingPrecautionaryUnbindAcks.delete(fittingId);
+}
+export function shouldSuppressFitSyncReportFrame(fittingId, data) {
+    const entry = pendingPrecautionaryUnbindAcks.get(fittingId);
+    if (!entry) {
+        return false;
+    }
+    if (Date.now() > entry.expiresAt) {
+        pendingPrecautionaryUnbindAcks.delete(fittingId);
+        return false;
+    }
+    return normalizeHex(data).toLowerCase().startsWith(entry.prefix);
+}
+export function normalizeDevUuidHex(devUuid) {
+    if (devUuid.length >= 32 &&
+        devUuid.length % 2 === 0 &&
+        /^[0-9a-fA-F]+$/.test(devUuid)) {
+        return devUuid;
+    }
+    let hex = "";
+    for (let i = 0; i < devUuid.length; i += 1) {
+        hex += devUuid.charCodeAt(i).toString(16);
+    }
+    return hex;
+}
 export function buildTransparentData(operation, fit, loginKey) {
-    return `${FIT_OPERATION_CODE[operation]}${fit.fittingUnlockId}${fit.randomStr}${fit.devUnlockId}${fit.devUuid}${loginKey}`;
+    return `${FIT_OPERATION_CODE[operation]}${fit.fittingUnlockId}${fit.randomStr}${fit.devUnlockId}${normalizeDevUuidHex(fit.devUuid)}${loginKey}`;
 }
 export function buildLockCheckCodeTemplate(operation, fit) {
     return `ffff${fit.devUnlockId}${FIT_OPERATION_CODE[operation]}${fit.fittingUnlockId}${fit.randomStr}`;
@@ -106,8 +141,12 @@ export async function publishFitTransparentFlow(fittingId, keyDeviceId, operatio
         expectedOperation: FIT_OPERATION_CODE[operation],
     });
     if (operation === "bind") {
+        markPrecautionaryUnbindPublished(fittingId, fit);
         await publishBLETransparentData(fittingId, buildTransparentData("unbind", fit, loginKey));
     }
+    else {
+        clearPrecautionaryUnbindSuppression(fittingId);
+    }
     await publishBLETransparentData(fittingId, buildTransparentData(operation, fit, loginKey));
     await waitResult;
     sdkLog("info", "fit", "transparentFlowSuccess", {

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

@@ -1,4 +1,6 @@
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import { type SyncOpenModeRiseResult } from "../../api/fit";
 export declare function syncFitBindingsForRuntime(runtime: LockDeviceRuntime): Promise<void>;
-export declare function syncFitReportForRuntime(runtime: LockDeviceRuntime, ins: string): Promise<unknown>;
-export declare function syncOpenModeRiseForRuntime(runtime: LockDeviceRuntime, dpIds: string): Promise<unknown>;
+export declare function startFitSyncReportForRuntime(runtime: LockDeviceRuntime): void;
+export declare function stopFitSyncReportForRuntime(runtime: LockDeviceRuntime): void;
+export declare function syncOpenModeRiseForRuntime(runtime: LockDeviceRuntime, dpCodes?: string[]): Promise<SyncOpenModeRiseResult>;

package/lib/feature/fit/sync.js

@@ -1,12 +1,22 @@
 import { syncFitToLockRise, syncFitReport as syncFitReportApi, syncOpenModeRise as syncOpenModeRiseApi, } from "../../api/fit";
-import { publishBLETransparentData, subscribeBLETransparentDataReport, } from "../../platform/device";
+import { unlockMethodDpCodes } from "../utils";
+import { offBLETransparentDataReport, onBLETransparentDataReport, publishBLETransparentData, subscribeBLETransparentDataReport, } from "../../platform/device";
 import { sdkLog } from "../../utils/sdk-log";
+import { shouldSuppressFitSyncReportFrame } from "./shared";
 export async function syncFitBindingsForRuntime(runtime) {
     const startedAt = Date.now();
     const fittingId = runtime.devId;
     sdkLog("info", "fit", "syncBindingsStart", {
         devId: runtime.devId,
     });
+    if (runtime.sync.fitBindingsSyncStarted) {
+        sdkLog("info", "fit", "syncBindingsSkip", {
+            devId: runtime.devId,
+            data: { reason: "already_started" },
+        });
+        return;
+    }
+    runtime.sync.fitBindingsSyncStarted = true;
     try {
         const result = await syncFitToLockRise(fittingId);
         const instructions = Array.isArray(result.ins) ? result.ins : [];
@@ -29,6 +39,7 @@ export async function syncFitBindingsForRuntime(runtime) {
         });
     }
     catch (error) {
+        runtime.sync.fitBindingsSyncStarted = false;
         sdkLog("error", "fit", "syncBindingsFail", {
             devId: runtime.devId,
             duration: Date.now() - startedAt,
@@ -37,35 +48,65 @@ export async function syncFitBindingsForRuntime(runtime) {
         throw error;
     }
 }
-export async function syncFitReportForRuntime(runtime, ins) {
-    const startedAt = Date.now();
-    sdkLog("info", "fit", "syncReportStart", {
-        devId: runtime.devId,
-        data: { hasInstruction: !!ins },
-    });
-    try {
-        const result = await syncFitReportApi(runtime.devId, ins);
-        sdkLog("info", "fit", "syncReportSuccess", {
-            devId: runtime.devId,
-            duration: Date.now() - startedAt,
-        });
-        return result;
+export function startFitSyncReportForRuntime(runtime) {
+    if (runtime.sync.fitSyncReportHandler) {
+        return;
     }
-    catch (error) {
-        sdkLog("error", "fit", "syncReportFail", {
-            devId: runtime.devId,
-            duration: Date.now() - startedAt,
-            error,
+    const devId = runtime.devId;
+    subscribeBLETransparentDataReport(devId);
+    const handler = (params) => {
+        if (params?.deviceId !== devId || !params?.data) {
+            return;
+        }
+        if (shouldSuppressFitSyncReportFrame(devId, params.data)) {
+            sdkLog("info", "fit", "syncReportSuppressPrecautionaryUnbindAck", {
+                devId,
+            });
+            return;
+        }
+        syncFitReportApi(devId, params.data).catch((e) => {
+            sdkLog("warn", "fit", "syncReportAutoError", {
+                devId,
+                error: e,
+            });
         });
-        throw error;
+    };
+    runtime.sync.fitSyncReportHandler = handler;
+    onBLETransparentDataReport(handler);
+    sdkLog("info", "fit", "startSyncReport", { devId });
+}
+export function stopFitSyncReportForRuntime(runtime) {
+    const handler = runtime.sync.fitSyncReportHandler;
+    if (handler) {
+        offBLETransparentDataReport(handler);
+        runtime.sync.fitSyncReportHandler = null;
     }
+    runtime.sync.fitBindingsSyncStarted = false;
+    sdkLog("info", "fit", "stopSyncReport", { devId: runtime.devId });
 }
-export async function syncOpenModeRiseForRuntime(runtime, dpIds) {
+export async function syncOpenModeRiseForRuntime(runtime, dpCodes) {
     const startedAt = Date.now();
+    const codes = dpCodes?.length ? dpCodes : unlockMethodDpCodes;
+    const dpIds = [
+        ...new Set(codes.reduce((res, code) => {
+            const id = runtime.config.idsByCode[code];
+            if (id) {
+                res.push(String(id));
+            }
+            return res;
+        }, [])),
+    ];
     sdkLog("info", "fit", "syncOpenModeRiseStart", {
         devId: runtime.devId,
-        data: { hasDpIds: !!dpIds },
+        data: { isAll: !dpCodes?.length, dpIdCount: dpIds.length },
     });
+    if (!dpIds.length) {
+        sdkLog("info", "fit", "syncOpenModeRiseSkip", {
+            devId: runtime.devId,
+            data: { reason: "no_matched_dp" },
+        });
+        return { ins: "", distributed: false };
+    }
     try {
         const result = await syncOpenModeRiseApi(runtime.devId, dpIds);
         sdkLog("info", "fit", "syncOpenModeRiseSuccess", {

package/lib/feature/fit/temp-password.d.ts

@@ -25,3 +25,26 @@ export interface RenameFitTempPwdParams {
     name: string;
 }
 export declare const fitRenameTempPwdForRuntime: (runtime: LockDeviceRuntime, params: RenameFitTempPwdParams) => Promise<void>;
+export interface RenameFitOfflineTempPwdParams {
+    pwdId: number;
+    name: string;
+}
+export declare const fitRenameOfflineTempPwdForRuntime: (runtime: LockDeviceRuntime, params: RenameFitOfflineTempPwdParams) => Promise<void>;
+export interface RevokeFitOfflineTempPwdParams {
+    pwdId: number;
+    name?: string;
+}
+export interface FitOfflineClearCodeResult {
+    password: string;
+    pwdId: string;
+    name: string;
+    effectiveConfig: {
+        effectiveDate: number;
+        expiredDate: number;
+    };
+}
+export declare const fitRevokeOfflineTempPwdForRuntime: (runtime: LockDeviceRuntime, params: RevokeFitOfflineTempPwdParams) => Promise<FitOfflineClearCodeResult>;
+export interface ResendFitTempPwdParams {
+    id: number;
+}
+export declare const fitResendTempPwdForRuntime: (runtime: LockDeviceRuntime, params: ResendFitTempPwdParams) => Promise<boolean>;

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/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;