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

package/lib/entries/fit/exports/temp.js

@@ -1,9 +1,17 @@
-import { getFitPasswordListForRuntime } from "../../../feature/fit/password-list";
+import { getFitPasswordListForRuntime, getFitOnlinePasswordListForRuntime, getFitOfflinePasswordListForRuntime, } from "../../../feature/fit/password-list";
 import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
-import { fitAddTempPwdForRuntime, fitRemoveTempPwdForRuntime, fitRenameTempPwdForRuntime, fitUpdateTempPwdForRuntime, } from "../../../feature/fit/temp-password";
+import { fitAddTempPwdForRuntime, fitRemoveTempPwdForRuntime, fitRenameTempPwdForRuntime, fitRenameOfflineTempPwdForRuntime, fitRevokeOfflineTempPwdForRuntime, fitResendTempPwdForRuntime, fitUpdateTempPwdForRuntime, } from "../../../feature/fit/temp-password";
+import { clearFitInvalidPwdForRuntime, getFitInvalidPwdListForRuntime, } from "../../../feature/fit/invalid-password";
+import { createTempDynamicForRuntime, createFitOfflineOnceForRuntime, createFitOfflineLimitForRuntime, createFitOfflineClearAllForRuntime, getFitOfflineRevocableListForRuntime, getFitOfflinePwdAvailableForRuntime, } from "../../../feature/password/temporary/offline-create";
 export function getFitPasswordList() {
     return getFitPasswordListForRuntime(resolveRuntimeFromExportThis(this));
 }
+export function getFitOnlinePasswordList() {
+    return getFitOnlinePasswordListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getFitOfflinePasswordList() {
+    return getFitOfflinePasswordListForRuntime(resolveRuntimeFromExportThis(this));
+}
 export function addFitTempPwd(params) {
     return fitAddTempPwdForRuntime(resolveRuntimeFromExportThis(this), params);
 }
@@ -16,3 +24,36 @@ export function updateFitTempPwd(params) {
 export function renameFitTempPwd(params) {
     return fitRenameTempPwdForRuntime(resolveRuntimeFromExportThis(this), params);
 }
+export function renameFitOfflineTempPwd(params) {
+    return fitRenameOfflineTempPwdForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function revokeFitOfflineTempPwd(params) {
+    return fitRevokeOfflineTempPwdForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function resendFitTempPwd(params) {
+    return fitResendTempPwdForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function getFitInvalidPwdList(params) {
+    return getFitInvalidPwdListForRuntime(resolveRuntimeFromExportThis(this), params ?? {});
+}
+export function clearFitInvalidPwd(params) {
+    return clearFitInvalidPwdForRuntime(resolveRuntimeFromExportThis(this), params ?? {});
+}
+export function getFitDynamicPassword() {
+    return createTempDynamicForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getFitOfflineOncePassword() {
+    return createFitOfflineOnceForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getFitOfflineLimitPassword(params) {
+    return createFitOfflineLimitForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function getFitOfflineClearAllCode() {
+    return createFitOfflineClearAllForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getFitOfflineRevocableList() {
+    return getFitOfflineRevocableListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getFitOfflinePwdAvailable(pwdType) {
+    return getFitOfflinePwdAvailableForRuntime(resolveRuntimeFromExportThis(this), pwdType);
+}

package/lib/entries/fit/index.js

@@ -5,6 +5,7 @@ import { clearPrimaryFitSDKInstance, setPrimaryFitSDKInstance, } from "./bootstr
 import { clearAllRuntimes, listRegisteredRuntimes, } from "../../runtime/registry";
 import { getLaunchOptionsSync } from "../../platform/device";
 import { getError } from "../../utils/errors";
+import { stopFitSyncReportForRuntime } from "../../feature/fit/sync";
 export * from "./exports";
 export const createFitSDK = async (options) => {
     const { instance } = await bootstrapRegisteredFitInstance({
@@ -29,6 +30,7 @@ export const initFit = async (options) => {
 export const destroyFit = () => {
     removeEvents();
     for (const rt of listRegisteredRuntimes()) {
+        stopFitSyncReportForRuntime(rt);
         clearStateForRuntime(rt);
     }
     clearAllRuntimes();

package/lib/entries/main/exports/log.d.ts

@@ -8,3 +8,5 @@ export declare function getLogs(params?: GetLogsParams): Promise<import("../../.
 export declare function getAlarms(params?: GetAlarmsParams): Promise<import("../../../feature/log/log").GetAlarmsResult>;
 export declare function getAlbums(params?: GetAlbumsParams): Promise<import("../../../feature/log/log").GetAlbumsResult>;
 export declare function getLockLogList(params: GetLockLogListParams): Promise<import("../../../feature/log/log").GetLockLogListResult>;
+export declare function getAlarmUnreadCount(): Promise<number>;
+export declare function getActivePeriod(): Promise<number>;

package/lib/entries/main/exports/log.js

@@ -1,5 +1,5 @@
 import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
-import { getLatestLogsForRuntime, getLogsForRuntime, getAlarmsForRuntime, getAlbumsForRuntime, onLogsRefreshForRuntime, offLogsRefreshForRuntime, getLockLogListForRuntime, } from "../../../feature/log/log";
+import { getLatestLogsForRuntime, getLogsForRuntime, getAlarmsForRuntime, getAlbumsForRuntime, onLogsRefreshForRuntime, offLogsRefreshForRuntime, getLockLogListForRuntime, getAlarmUnreadCountForRuntime, getActivePeriodForRuntime, } from "../../../feature/log/log";
 export function onLogsRefresh(cb) {
     onLogsRefreshForRuntime(resolveRuntimeFromExportThis(this), cb);
 }
@@ -22,3 +22,9 @@ export async function getAlbums(params) {
 export async function getLockLogList(params) {
     return getLockLogListForRuntime(resolveRuntimeFromExportThis(this), params);
 }
+export async function getAlarmUnreadCount() {
+    return getAlarmUnreadCountForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function getActivePeriod() {
+    return getActivePeriodForRuntime(resolveRuntimeFromExportThis(this));
+}

package/lib/entries/main/exports/misc.d.ts

@@ -13,6 +13,8 @@ export interface UpdateDpPeriodTimeOption {
     offlineDp?: boolean;
 }
 export declare function updateDpPeriodTime(dpCode: string, data: UpdateDpPeriodTimeParams, option?: UpdateDpPeriodTimeOption): Promise<void>;
-export declare function connectDevice(): Promise<true>;
+export declare function connectDevice(options?: {
+    timeout?: number;
+}): Promise<true>;
 export declare function gotoService(params?: GotoServiceParams): Promise<void>;
 export declare function validatePwdComplexity(password: string): Promise<boolean>;

package/lib/entries/main/exports/misc.js

@@ -19,8 +19,8 @@ export function getDpPeriodTime(dpCode) {
 export function updateDpPeriodTime(dpCode, data, option) {
     return updateDpPeriodTimeForRuntime(resolveRuntimeFromExportThis(this), dpCode, data, option);
 }
-export async function connectDevice() {
-    return connectDeviceForRuntime(resolveRuntimeFromExportThis(this));
+export async function connectDevice(options) {
+    return connectDeviceForRuntime(resolveRuntimeFromExportThis(this), options?.timeout);
 }
 export async function gotoService(params) {
     return gotoServiceForRuntime(resolveRuntimeFromExportThis(this), params);

package/lib/feature/fit/bind-lock-to-fit.js

@@ -1,9 +1,48 @@
 import { bindLockAndFit, unbindFitFromLockCloud, unbindLockFromFitCloud, } from "../../api/fit";
 import { getUsersSyncLockData } from "../../api/user";
-import { offDpDataChange, onDpDataChange, publishDeviceDps, } from "../../platform/device";
+import { getDeviceProperties, offDpDataChange, onDpDataChange, publishDeviceDps, setDeviceProperty, } from "../../platform/device";
 import { getError } from "../../utils/errors";
 import { sdkLog } from "../../utils/sdk-log";
+import { isFitSecurityChannelEnabledForRuntime } from "./security-channel";
 import { FIT_BIND_TIMEOUT_MS, FIT_OPERATION_CODE, normalizeHex, buildLockCheckCodeTemplate, publishFitTransparentFlow, } from "./shared";
+const markSecurityUpdated = async (runtime, lock) => {
+    if (!lock.isSupportScy || !isFitSecurityChannelEnabledForRuntime(runtime)) {
+        return;
+    }
+    const fittingId = runtime.devId;
+    try {
+        const props = await getDeviceProperties(fittingId);
+        const raw = props?.["SECURITY_UPDATED"];
+        let list = [];
+        if (typeof raw === "string") {
+            try {
+                list = JSON.parse(raw).value || [];
+            }
+            catch {
+                list = [];
+            }
+        }
+        else if (raw && typeof raw === "object") {
+            list =
+                raw.value ||
+                    (Array.isArray(raw) ? raw : []);
+        }
+        if (list.includes(lock.devId)) {
+            return;
+        }
+        await setDeviceProperty(fittingId, "SECURITY_UPDATED", {
+            key: fittingId,
+            value: [...list, lock.devId],
+        });
+    }
+    catch (e) {
+        sdkLog("warn", "fit", "markSecurityUpdatedError", {
+            devId: fittingId,
+            data: { lockDevId: lock.devId },
+            error: e,
+        });
+    }
+};
 const CHECK_CODE_SET_DP_ID = "70";
 const delay = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
@@ -104,6 +143,7 @@ export async function bindLockToFitForRuntime(runtime, lock) {
             devId: runtime.devId,
             data: { lockDevId: lock.devId },
         });
+        await markSecurityUpdated(runtime, lock);
         await publishToLock(runtime, "bind", lock);
         const result = await bindLockAndFit({
             devId: lock.devId,

package/lib/feature/fit/ble-key.d.ts

@@ -1,13 +1,19 @@
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
-import { EffectiveConfig } from "../../interface";
-export declare function getFitBleKeyListForRuntime(runtime: LockDeviceRuntime): Promise<unknown[]>;
+import { EffectiveConfig, FitBleKeyItem } from "../../interface";
+export declare function getFitBleKeyListForRuntime(runtime: LockDeviceRuntime): Promise<FitBleKeyItem[]>;
+export interface CreateTemporaryBleKeyParams {
+    name?: string;
+    effective: EffectiveConfig;
+}
+export declare function createFitPermanentBleKeyForRuntime(runtime: LockDeviceRuntime, userId: string): Promise<unknown>;
+export declare function createFitTemporaryBleKeyForRuntime(runtime: LockDeviceRuntime, params: CreateTemporaryBleKeyParams): Promise<unknown>;
 export declare function addFitBleKeyForRuntime(runtime: LockDeviceRuntime, params: Record<string, unknown>): Promise<unknown>;
-export interface UpdateFitBleKeyParams {
+export interface UpdateTemporaryBleKeyParams {
     id: string;
     name: string;
     effective: EffectiveConfig;
 }
-export declare function updateFitBleKeyForRuntime(runtime: LockDeviceRuntime, params: UpdateFitBleKeyParams): Promise<unknown>;
+export declare function updateFitTemporaryBleKeyForRuntime(runtime: LockDeviceRuntime, params: UpdateTemporaryBleKeyParams): Promise<unknown>;
 export declare function removeFitBleKeyForRuntime(runtime: LockDeviceRuntime, unlockBindingId: string): Promise<unknown>;
 export interface RenameFitBleKeyParams {
     id: string;

package/lib/feature/fit/ble-key.js

@@ -1,18 +1,141 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
 import { getFitBleKeyListApi, addFitBleKeyApi, updateFitBleKeyApi, removeFitBleKeyApi, renameFitBleKeyApi, } from "../../api/fit";
+import dpCodes from "../../config/dp-code";
+import { fitAddBleKey, fitModifyBleKey } from "../../config/dp-map/ble-key-fit";
+import { publishDpsForRuntime } from "../dp/publish-dps";
+import { getError } from "../../utils/errors";
 import { sdkLog } from "../../utils/sdk-log";
-import { formatWeek } from "../../utils";
+import { UserType } from "../../constant";
+import { getFitUsersForRuntime } from "./users";
+import { formatWeek, parseWeek, transformEffectiveConfigToValidConfig, validateEffectiveConfig, } from "../../utils";
+function normalizeBleKey(item) {
+    const effectiveConfig = {
+        effectiveDate: item.effectiveTime,
+        expiredDate: item.invalidTime,
+    };
+    const schedule = item.scheduleDetails?.[0];
+    if (schedule) {
+        if (schedule.allDay === false) {
+            effectiveConfig.repeat = "week";
+            effectiveConfig.weeks = parseWeek(schedule.workingDay);
+            effectiveConfig.effectiveTime = schedule.effectiveTime;
+            effectiveConfig.expiredTime = schedule.invalidTime;
+        }
+        else {
+            effectiveConfig.repeat = "none";
+        }
+    }
+    return {
+        id: item.id,
+        unlockBindingId: item.unlockBindingId,
+        name: item.name,
+        opModeSubType: item.opModeSubType,
+        effectiveConfig,
+        sn: item.sn,
+        userName: item.userName,
+        devNameList: item.devNameList,
+    };
+}
 export async function getFitBleKeyListForRuntime(runtime) {
     const startedAt = Date.now();
     sdkLog("info", "fit", "getBleKeyListStart", {
         devId: runtime.devId,
     });
     const list = await getFitBleKeyListApi(runtime.devId);
+    const result = (list || []).map(normalizeBleKey);
     sdkLog("info", "fit", "getBleKeyListSuccess", {
         devId: runtime.devId,
         duration: Date.now() - startedAt,
-        data: { count: Array.isArray(list) ? list.length : 0 },
+        data: { count: result.length },
+    });
+    return result;
+}
+async function createFitBleKeyWithPayload(runtime, keyType, startedAt, payload, addToCloud) {
+    const report = await publishDpsForRuntime(runtime, { [dpCodes.bleKeyCreate]: payload }, {
+        checkReport: (dps) => {
+            const raw = dps[dpCodes.bleKeyCreate];
+            if (!raw || raw.length < 44)
+                return false;
+            return { sn: raw.slice(4, 6), status: raw.slice(42, 44) };
+        },
+    });
+    if (report.status !== "00") {
+        sdkLog("warn", "fit", "createBleKeyDeviceFail", {
+            devId: runtime.devId,
+            data: { type: keyType, status: report.status },
+        });
+        throw getError(1042);
+    }
+    try {
+        const result = await addToCloud(parseInt(report.sn, 16));
+        sdkLog("info", "fit", "createBleKeySuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { type: keyType },
+        });
+        return result;
+    }
+    catch (error) {
+        publishDpsForRuntime(runtime, { [dpCodes.bleKeyDelete]: "0000" }, { timeout: 5000 }).catch(() => {
+        });
+        sdkLog("error", "fit", "createBleKeyCloudFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { type: keyType },
+            error,
+        });
+        throw error;
+    }
+}
+export async function createFitPermanentBleKeyForRuntime(runtime, userId) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "createBleKeyStart", {
+        devId: runtime.devId,
+        data: { type: "permanent" },
+    });
+    const users = await getFitUsersForRuntime(runtime);
+    const user = users.find((item) => item.userId === userId);
+    if (!user) {
+        sdkLog("warn", "fit", "createBleKeyUserNotFound", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { userCount: users.length },
+        });
+        throw getError(1048);
+    }
+    const admin = user.userType === UserType.ADMIN;
+    const payload = `000000${admin ? "01" : "00"}${user.userTimeSet}`;
+    return createFitBleKeyWithPayload(runtime, "permanent", startedAt, payload, (sn) => addFitBleKeyApi(runtime.devId, { sn, userId, timeSetType: 10 }));
+}
+export async function createFitTemporaryBleKeyForRuntime(runtime, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "createBleKeyStart", {
+        devId: runtime.devId,
+        data: { type: "temporary" },
     });
-    return list;
+    validateEffectiveConfig(params.effective);
+    const { effective } = params;
+    const payload = dpUtils.format({
+        slaveId: 0,
+        memberId: 0,
+        admin: false,
+        validConfig: transformEffectiveConfigToValidConfig(effective),
+    }, fitAddBleKey);
+    return createFitBleKeyWithPayload(runtime, "temporary", startedAt, payload, (sn) => addFitBleKeyApi(runtime.devId, {
+        sn,
+        effectiveTime: effective.effectiveDate,
+        invalidTime: effective.expiredDate,
+        schedule: [
+            {
+                allDay: effective.repeat !== "week",
+                effectiveTime: effective.effectiveTime ?? 0,
+                invalidTime: effective.expiredTime ?? 0,
+                workingDay: formatWeek(effective.weeks ?? [0]),
+            },
+        ],
+        name: params.name,
+        timeSetType: effective.repeat !== "week" ? 20 : 30,
+    }));
 }
 export async function addFitBleKeyForRuntime(runtime, params) {
     const startedAt = Date.now();
@@ -31,7 +154,7 @@ export async function addFitBleKeyForRuntime(runtime, params) {
     });
     return result;
 }
-export async function updateFitBleKeyForRuntime(runtime, params) {
+export async function updateFitTemporaryBleKeyForRuntime(runtime, params) {
     const startedAt = Date.now();
     const logParams = params ?? {};
     sdkLog("info", "fit", "updateBleKeyStart", {
@@ -41,6 +164,24 @@ export async function updateFitBleKeyForRuntime(runtime, params) {
             hasId: typeof logParams["id"] === "string",
         },
     });
+    validateEffectiveConfig(params.effective);
+    const validConfig = transformEffectiveConfigToValidConfig(params.effective);
+    const payload = dpUtils.format({ slaveId: 0, memberId: 0, admin: false, validConfig }, fitModifyBleKey);
+    const report = await publishDpsForRuntime(runtime, { [dpCodes.bleKeyModify]: payload }, {
+        checkReport: (dps) => {
+            const raw = dps[dpCodes.bleKeyModify];
+            if (!raw || raw.length < 44)
+                return false;
+            return { status: raw.slice(42, 44) };
+        },
+    });
+    if (report.status !== "00") {
+        sdkLog("warn", "fit", "updateBleKeyDeviceFail", {
+            devId: runtime.devId,
+            data: { status: report.status },
+        });
+        throw getError(1042);
+    }
     const schedule = [
         {
             allDay: params.effective.repeat !== "week",

package/lib/feature/fit/device-bv.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const getFitDeviceBvForRuntime: (runtime: LockDeviceRuntime) => Promise<number>;

package/lib/feature/fit/device-bv.js

@@ -0,0 +1,15 @@
+import { getFitDeviceBVApi } from "../../api/fit";
+export const getFitDeviceBvForRuntime = (runtime) => {
+    const cached = runtime.cache.fitDeviceBvCache;
+    if (cached) {
+        return cached;
+    }
+    const pending = getFitDeviceBVApi(runtime.devId).catch((error) => {
+        if (runtime.cache.fitDeviceBvCache === pending) {
+            runtime.cache.fitDeviceBvCache = undefined;
+        }
+        throw error;
+    });
+    runtime.cache.fitDeviceBvCache = pending;
+    return pending;
+};

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

@@ -0,0 +1,10 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import { type FitInvalidPwdQuery, type FitInvalidPwdListResult } from "../../api/fit";
+export type { FitInvalidPwdQuery, FitInvalidPwdListResult };
+export interface GetFitInvalidPwdListParams extends FitInvalidPwdQuery {
+}
+export interface ClearFitInvalidPwdParams {
+    opMode?: number | string;
+}
+export declare function getFitInvalidPwdListForRuntime(runtime: LockDeviceRuntime, params?: GetFitInvalidPwdListParams): Promise<FitInvalidPwdListResult>;
+export declare function clearFitInvalidPwdForRuntime(runtime: LockDeviceRuntime, params?: ClearFitInvalidPwdParams): Promise<boolean>;

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

@@ -0,0 +1,43 @@
+import { clearFitInvalidPwdApi, getFitInvalidPwdListApi, } from "../../api/fit";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+export async function getFitInvalidPwdListForRuntime(runtime, params = {}) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitInvalidPwd", "getListStart", {
+        devId: runtime.devId,
+        data: { hasOpMode: params.opMode !== undefined },
+    });
+    try {
+        const result = await getFitInvalidPwdListApi(runtime.devId, params);
+        return result;
+    }
+    catch (error) {
+        throw error;
+    }
+}
+export async function clearFitInvalidPwdForRuntime(runtime, params = {}) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitInvalidPwd", "clearStart", {
+        devId: runtime.devId,
+        data: { hasOpMode: params.opMode !== undefined },
+    });
+    try {
+        const result = await clearFitInvalidPwdApi(runtime.devId, params.opMode);
+        sdkLog("info", "fitInvalidPwd", "clearSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fitInvalidPwd", "clearFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        if (typeof error?.errorCode === "number") {
+            throw error;
+        }
+        throw getError(1028);
+    }
+}

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

@@ -1,3 +1,12 @@
+import { type BoundFitLockItem, type UnbindLockItem } from "../../api/fit";
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
-export declare function getBoundLockListForRuntime(runtime: LockDeviceRuntime): Promise<import("../../api/fit").BoundFitLockItem[]>;
-export declare function getUnbindLockListForRuntime(runtime: LockDeviceRuntime): Promise<import("../../api/fit").UnbindLockItem[]>;
+export type FitLockUnbindableReason = "ble_version_mismatch" | "security_version_mismatch";
+export interface UnbindLockListItem extends UnbindLockItem {
+    bindable: boolean;
+    unbindableReason?: FitLockUnbindableReason;
+}
+export interface BoundLockListItem extends BoundFitLockItem {
+    securityVersionMismatch: boolean;
+}
+export declare function getBoundLockListForRuntime(runtime: LockDeviceRuntime): Promise<BoundLockListItem[]>;
+export declare function getUnbindLockListForRuntime(runtime: LockDeviceRuntime): Promise<UnbindLockListItem[]>;

package/lib/feature/fit/list.js

@@ -1,28 +1,67 @@
 import { getBoundLockListApi, getUnbindLockListApi, } from "../../api/fit";
 import { sdkLog } from "../../utils/sdk-log";
+import { getFitDeviceBvForRuntime } from "./device-bv";
+import { isFitSecurityChannelEnabledForRuntime } from "./security-channel";
+const isSecurityVersionMismatch = (runtime, lock) => !!lock.isSupportScy && !isFitSecurityChannelEnabledForRuntime(runtime);
+const resolveUnbindableReason = (runtime, lock, fitBv) => {
+    const lockBv = Number(lock.protocolVersion) || 0;
+    if (lockBv && fitBv && lockBv !== fitBv) {
+        return "ble_version_mismatch";
+    }
+    if (isSecurityVersionMismatch(runtime, lock)) {
+        return "security_version_mismatch";
+    }
+    return undefined;
+};
 export async function getBoundLockListForRuntime(runtime) {
     const startedAt = Date.now();
     sdkLog("info", "fit", "getBoundLockListStart", {
         devId: runtime.devId,
     });
     const list = await getBoundLockListApi(runtime.devId);
+    const items = (Array.isArray(list) ? list : []).map((lock) => ({
+        ...lock,
+        securityVersionMismatch: isSecurityVersionMismatch(runtime, lock),
+    }));
     sdkLog("info", "fit", "getBoundLockListSuccess", {
         devId: runtime.devId,
         duration: Date.now() - startedAt,
-        data: { count: Array.isArray(list) ? list.length : 0 },
+        data: {
+            count: items.length,
+            securityMismatchCount: items.filter((item) => item.securityVersionMismatch).length,
+        },
     });
-    return list;
+    return items;
 }
 export async function getUnbindLockListForRuntime(runtime) {
     const startedAt = Date.now();
     sdkLog("info", "fit", "getUnbindLockListStart", {
         devId: runtime.devId,
     });
-    const list = await getUnbindLockListApi(runtime.devId);
+    const [list, fitBv] = await Promise.all([
+        getUnbindLockListApi(runtime.devId),
+        getFitDeviceBvForRuntime(runtime).catch((error) => {
+            sdkLog("warn", "fit", "getUnbindLockListBvFailed", {
+                devId: runtime.devId,
+                error,
+            });
+            return 0;
+        }),
+    ]);
+    const items = (Array.isArray(list) ? list : []).map((lock) => {
+        const unbindableReason = resolveUnbindableReason(runtime, lock, fitBv);
+        return unbindableReason
+            ? { ...lock, bindable: false, unbindableReason }
+            : { ...lock, bindable: true };
+    });
     sdkLog("info", "fit", "getUnbindLockListSuccess", {
         devId: runtime.devId,
         duration: Date.now() - startedAt,
-        data: { count: Array.isArray(list) ? list.length : 0 },
+        data: {
+            count: items.length,
+            fitBv,
+            bindableCount: items.filter((item) => item.bindable).length,
+        },
     });
-    return list;
+    return items;
 }

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

@@ -0,0 +1,7 @@
+import { type GetLogsResult } from "../log/log";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface GetFitLogsParams {
+    page?: number;
+    pageSize?: number;
+}
+export declare function getFitLogsForRuntime(rt: LockDeviceRuntime, params?: GetFitLogsParams): Promise<GetLogsResult>;