@ray-js/lock-sdk 1.2.0-beta.24 → 1.2.0-beta.25

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";
@@ -153,7 +153,7 @@ function handleLockLogs(list, cfg) {
             userId: item.userId,
             userName: userName || "",
             unlockName: unlockName || "",
-            mediaInfo: item.mediaInfoList?.map?.(item => {
+            mediaInfo: item.mediaInfoList?.map?.((item) => {
                 return {
                     mediaPath: item.mediaPath,
                     fileKey: item.fileKey,
@@ -241,7 +241,7 @@ export const openDps = [
     dpCodes.unlockApp,
     dpCodes.unlockMatterKw,
 ];
-const closeTypes = [
+export const closeTypes = [
     "UNDEFINED",
     "APP_REMOTE",
     "VOICE_REMOTE",
@@ -251,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 || {};
@@ -468,3 +468,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/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);
@@ -160,7 +160,7 @@ export async function connectDeviceForRuntime(rt) {
     });
     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,
@@ -179,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/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/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/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";
@@ -93,6 +94,9 @@ const globalHandleBleChange = ({ deviceId, status }) => {
     if (rt) {
         updateOnlineType(rt);
         if (status === "CONNECTED") {
+            if (rt.config.isFitting) {
+                syncFitBindingsForRuntime(rt).catch(() => { });
+            }
             void syncRemoteSerectKey(rt);
             autoSyncTemp(rt);
             void syncT0(rt);

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

@@ -1,5 +1,6 @@
 import type { UnlockMethodConfig } from "../../interface";
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const unlockMethodDpCodes: string[];
 export declare const getUnlockMethodTypeByDpCodeForRuntime: (rt: LockDeviceRuntime, dpCode: string) => UnlockMethodConfig;
 export declare const getUnlockMethodTypeByIdForRuntime: (rt: LockDeviceRuntime, id: number | string) => UnlockMethodConfig;
 export declare const getUnlockMethodTypeByTypeForRuntime: (rt: LockDeviceRuntime, type: string) => UnlockMethodConfig;

package/lib/feature/utils/index.js

@@ -33,6 +33,7 @@ const unlockMethodConfigs = [
         id: 6,
     },
 ];
+export const unlockMethodDpCodes = unlockMethodConfigs.reduce((res, item) => res.concat(item.codes), []);
 const getUnlockMethodTypeForRuntime = (rt, cb) => {
     const result = unlockMethodConfigs.find(cb);
     if (result) {

package/lib/interface.d.ts

@@ -182,6 +182,16 @@ export interface EffectiveConfig {
     effectiveTime?: number;
     expiredTime?: number;
 }
+export interface FitBleKeyItem {
+    id: string;
+    unlockBindingId: string;
+    name: string;
+    opModeSubType?: number;
+    effectiveConfig: EffectiveConfig;
+    sn?: number;
+    userName?: string;
+    devNameList?: string[];
+}
 export interface UnBindUnlockMethod {
     dpId: number;
     dpCode: string;
@@ -276,6 +286,8 @@ export interface LogData {
     dpCode: string;
     data: any;
     userName: string;
+    avatarUrl?: string;
+    relateDevName?: string;
     bindable: boolean;
     unlockName: string;
     mediaInfo?: MediaInfo[];

package/lib/runtime/LockDeviceRuntime.js

@@ -14,6 +14,7 @@ export class LockDeviceRuntime {
             offlineDpCache: undefined,
             isActiveThreadCache: false,
             deviceAdvanceAbilityCache: undefined,
+            fitDeviceBvCache: undefined,
         };
         this.sync = {
             hasSyncedT0: false,
@@ -21,6 +22,8 @@ export class LockDeviceRuntime {
             unlockMethodAutoSyncEnabled: true,
             tempAutoSyncEnabled: true,
             tempPayloadSyncing: false,
+            fitSyncReportHandler: null,
+            fitBindingsSyncStarted: false,
         };
         this.infra = {
             eventsRegistered: false,

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

@@ -26,6 +26,7 @@ export type LockConfigState = {
     isTwoWayTalk: boolean;
     cameraConfig: CameraConfig[];
     notSupportWake: boolean;
+    isFitting: boolean;
 };
 export declare function createDefaultDeviceStatus(): DeviceStatus;
 export declare function createLockConfigState(): LockConfigState;

package/lib/runtime/lock-config.js

@@ -35,6 +35,7 @@ export function createLockConfigState() {
         supportTalk: false,
         isTwoWayTalk: false,
         cameraConfig: [],
-        notSupportWake: false
+        notSupportWake: false,
+        isFitting: false
     };
 }

package/lib/runtime/runtime-state-types.d.ts

@@ -5,6 +5,7 @@ export interface LockRuntimeCacheFields {
     offlineDpCache: OfflineDps | undefined;
     isActiveThreadCache: boolean;
     deviceAdvanceAbilityCache: DeviceAdvancedAbility | undefined;
+    fitDeviceBvCache: Promise<number> | undefined;
 }
 export interface LockRuntimeSyncFlags {
     hasSyncedT0: boolean;
@@ -12,6 +13,11 @@ export interface LockRuntimeSyncFlags {
     unlockMethodAutoSyncEnabled: boolean;
     tempAutoSyncEnabled: boolean;
     tempPayloadSyncing: boolean;
+    fitSyncReportHandler: ((data: {
+        deviceId?: string;
+        data?: string;
+    }) => void) | null;
+    fitBindingsSyncStarted: boolean;
 }
 export interface LockRuntimeInfraFields {
     eventsRegistered: boolean;

package/package.json

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