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

package/lib/entries/fit/exports/binding.d.ts

@@ -7,3 +7,4 @@ export declare function bindLockToFit(lock: UnbindLockItem): Promise<unknown>;
 export declare function unbindLockToFit(lock: BoundFitLockItem & {
     bindingId: string;
 }): Promise<unknown>;
+export declare function activateLockToFit(lock: BoundFitLockItem): Promise<void>;

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

@@ -1,5 +1,5 @@
 import { getBoundLockListForRuntime, getUnbindLockListForRuntime, } from "../../../feature/fit/list";
-import { bindLockToFitForRuntime, unbindLockToFitForRuntime, } from "../../../feature/fit/bind-lock-to-fit";
+import { activateLockToFitForRuntime, bindLockToFitForRuntime, unbindLockToFitForRuntime, } from "../../../feature/fit/bind-lock-to-fit";
 import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
 export function getBoundLockList() {
     return getBoundLockListForRuntime(resolveRuntimeFromExportThis(this));
@@ -13,3 +13,6 @@ export function bindLockToFit(lock) {
 export function unbindLockToFit(lock) {
     return unbindLockToFitForRuntime(resolveRuntimeFromExportThis(this), lock);
 }
+export function activateLockToFit(lock) {
+    return activateLockToFitForRuntime(resolveRuntimeFromExportThis(this), lock);
+}

package/lib/feature/fit/bind-lock-to-fit.d.ts

@@ -2,3 +2,4 @@ import { BoundFitLockItem, LockFitItemBase } from "../../api/fit";
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
 export declare function bindLockToFitForRuntime(runtime: LockDeviceRuntime, lock: LockFitItemBase): Promise<unknown>;
 export declare function unbindLockToFitForRuntime(runtime: LockDeviceRuntime, lock: BoundFitLockItem): Promise<unknown>;
+export declare function activateLockToFitForRuntime(runtime: LockDeviceRuntime, lock: LockFitItemBase): Promise<void>;

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

@@ -1,9 +1,10 @@
 import { bindLockAndFit, unbindFitFromLockCloud, unbindLockFromFitCloud, } from "../../api/fit";
+import { setDeviceProperties } from "../../api/setting";
 import { getUsersSyncLockData } from "../../api/user";
-import { getDeviceProperties, offDpDataChange, onDpDataChange, publishDeviceDps, setDeviceProperty, } from "../../platform/device";
+import { offDpDataChange, onDpDataChange, publishDeviceDps, } from "../../platform/device";
 import { getError } from "../../utils/errors";
 import { sdkLog } from "../../utils/sdk-log";
-import { isFitSecurityChannelEnabledForRuntime } from "./security-channel";
+import { getSecurityUpdatedLockIds, 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)) {
@@ -11,28 +12,15 @@ const markSecurityUpdated = async (runtime, lock) => {
     }
     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 : []);
-        }
+        const list = await getSecurityUpdatedLockIds(fittingId);
         if (list.includes(lock.devId)) {
             return;
         }
-        await setDeviceProperty(fittingId, "SECURITY_UPDATED", {
-            key: fittingId,
-            value: [...list, lock.devId],
+        await setDeviceProperties(fittingId, {
+            SECURITY_UPDATED: JSON.stringify({
+                key: fittingId,
+                value: [...list, lock.devId],
+            }),
         });
     }
     catch (e) {
@@ -205,3 +193,28 @@ export async function unbindLockToFitForRuntime(runtime, lock) {
         throw error;
     }
 }
+export async function activateLockToFitForRuntime(runtime, lock) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "activateLockToFitStart", {
+        devId: runtime.devId,
+        data: { lockDevId: lock.devId },
+    });
+    try {
+        await publishToFitting(runtime, "bind", lock);
+        await markSecurityUpdated(runtime, lock);
+        sdkLog("info", "fit", "activateLockToFitSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { lockDevId: lock.devId },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fit", "activateLockToFitFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { lockDevId: lock.devId },
+            error,
+        });
+        throw error;
+    }
+}

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

@@ -7,6 +7,7 @@ export interface UnbindLockListItem extends UnbindLockItem {
 }
 export interface BoundLockListItem extends BoundFitLockItem {
     securityVersionMismatch: boolean;
+    securityNeedUpdate: boolean;
 }
 export declare function getBoundLockListForRuntime(runtime: LockDeviceRuntime): Promise<BoundLockListItem[]>;
 export declare function getUnbindLockListForRuntime(runtime: LockDeviceRuntime): Promise<UnbindLockListItem[]>;

package/lib/feature/fit/list.js

@@ -1,7 +1,7 @@
 import { getBoundLockListApi, getUnbindLockListApi, } from "../../api/fit";
 import { sdkLog } from "../../utils/sdk-log";
 import { getFitDeviceBvForRuntime } from "./device-bv";
-import { isFitSecurityChannelEnabledForRuntime } from "./security-channel";
+import { getSecurityUpdatedLockIds, isFitSecurityChannelEnabledForRuntime, } from "./security-channel";
 const isSecurityVersionMismatch = (runtime, lock) => !!lock.isSupportScy && !isFitSecurityChannelEnabledForRuntime(runtime);
 const resolveUnbindableReason = (runtime, lock, fitBv) => {
     const lockBv = Number(lock.protocolVersion) || 0;
@@ -19,9 +19,17 @@ export async function getBoundLockListForRuntime(runtime) {
         devId: runtime.devId,
     });
     const list = await getBoundLockListApi(runtime.devId);
-    const items = (Array.isArray(list) ? list : []).map((lock) => ({
+    const rawItems = Array.isArray(list) ? list : [];
+    const securityEnabled = isFitSecurityChannelEnabledForRuntime(runtime);
+    const securityUpdatedIds = securityEnabled && rawItems.some((lock) => lock.isSupportScy)
+        ? await getSecurityUpdatedLockIds(runtime.devId)
+        : [];
+    const items = rawItems.map((lock) => ({
         ...lock,
         securityVersionMismatch: isSecurityVersionMismatch(runtime, lock),
+        securityNeedUpdate: securityEnabled &&
+            !!lock.isSupportScy &&
+            !securityUpdatedIds.includes(lock.devId),
     }));
     sdkLog("info", "fit", "getBoundLockListSuccess", {
         devId: runtime.devId,
@@ -29,6 +37,8 @@ export async function getBoundLockListForRuntime(runtime) {
         data: {
             count: items.length,
             securityMismatchCount: items.filter((item) => item.securityVersionMismatch).length,
+            securityNeedUpdateCount: items.filter((item) => item.securityNeedUpdate)
+                .length,
         },
     });
     return items;

package/lib/feature/fit/method/add-flow.js

@@ -1,6 +1,6 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { addFitOpenMode } from "../../../api/fit";
-import { sleep } from "../../../utils";
+import { formatCloudUnlockId, sleep } from "../../../utils";
 import { DPCHANGE } from "../../../utils/constant";
 import { getError } from "../../../utils/errors";
 import emitter from "../../../utils/event";
@@ -195,7 +195,7 @@ const handleAddReport = async (dps) => {
                     await addFitOpenMode({
                         devIdList: [addUnlockMethodData.lockDevId],
                         fittingId: rt.devId,
-                        unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
+                        unlockId: formatCloudUnlockId(addUnlockMethodData.unlockDpId, result.unlockId),
                         unlockName: "",
                         userId: addUnlockMethodData.userId,
                         hijack: false,

package/lib/feature/fit/method/add-password.js

@@ -1,6 +1,6 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { addFitOpenMode } from "../../../api/fit";
-import { sleep } from "../../../utils";
+import { formatCloudUnlockId, sleep } from "../../../utils";
 import { getError, handleCloudError } from "../../../utils/errors";
 import { publishDpsForRuntime } from "../../dp/publish-dps";
 import { getFitUnlockMethodBase } from "./internal/base";
@@ -75,7 +75,7 @@ export async function fitAddPasswordForRuntime(rt, params) {
         await addFitOpenMode({
             devIdList: [lockDevId],
             fittingId,
-            unlockId: `${dpId}-${res.unlockId}`,
+            unlockId: formatCloudUnlockId(dpId, res.unlockId),
             unlockName: params.name,
             userId: params.userId,
             hijack: !!params.hijack,

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

@@ -1,2 +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

@@ -1,3 +1,5 @@
+import { getDeviceProperties } from "../../api/setting";
+import { sdkLog } from "../../utils/sdk-log";
 export const isFitSecurityChannelEnabledForRuntime = (rt) => {
     const raw = rt.config.devInfo?.meta?.["btScyChannel"];
     if (!raw) {
@@ -13,3 +15,29 @@ export const isFitSecurityChannelEnabledForRuntime = (rt) => {
         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.js

@@ -2,6 +2,7 @@ import { syncFitToLockRise, syncFitReport as syncFitReportApi, syncOpenModeRise
 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;
@@ -57,6 +58,12 @@ export function startFitSyncReportForRuntime(runtime) {
         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,

package/lib/feature/log/log.js

@@ -391,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,

package/lib/feature/misc/capability.js

@@ -1,5 +1,5 @@
 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";
@@ -17,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 {

package/lib/feature/misc/is-use-near-channel-for-runtime.js

@@ -1,17 +1,24 @@
+import dpCodes from "src/config/dp-code";
 import { ProductCommunicationType } from "../../constant";
 import { isOnlineByType } from "../../utils";
+import { hasDpForRuntime } from "../dp/has-dp";
 import { hasCapabilityForRuntime } from "./capability";
 export const isUseNearChannelForRuntime = (rt) => {
     const { onlineType, devInfo } = rt.config;
     const isBleOnline = isOnlineByType(onlineType, 2);
     const isSupportWifi = hasCapabilityForRuntime(rt, ProductCommunicationType.WIFI);
     const isSupportBle = hasCapabilityForRuntime(rt, ProductCommunicationType.BLUETOOTH);
+    if (isSupportWifi &&
+        isSupportBle &&
+        !hasDpForRuntime(rt, dpCodes.unlockBle)) {
+        return false;
+    }
     const isSupportThread = hasCapabilityForRuntime(rt, ProductCommunicationType.THREAD);
     if (isSupportWifi && isSupportBle) {
         return isBleOnline;
     }
     if (isSupportThread && isSupportBle) {
-        return isBleOnline && !devInfo.isCloudOnline && !devInfo.isLocalOnline;
+        return isBleOnline && !devInfo.isCloudOnline;
     }
     return isBleOnline;
 };

package/lib/feature/state/device-status.js

@@ -1,4 +1,4 @@
-import { hasCapabilityForRuntime } from "../misc/capability";
+import { hasCapabilityForRuntime, isActiveThreadForRuntime, } from "../misc/capability";
 import { hasDpForRuntime } from "../dp/has-dp";
 import dpCodes from "../../config/dp-code";
 import { ProductCommunicationType } from "../../constant";
@@ -13,9 +13,14 @@ import { getDpValueForRuntime } from "../dp/get-dp-value";
 import { readIsSleepForRuntime } from "./internal/read-is-sleep";
 import { isShareThreadRuntimeLocal } from "./internal/share-thread-local";
 export const updateOnlineType = async (runtime) => {
+    const hasThreadBle = hasCapabilityForRuntime(runtime, ProductCommunicationType.THREAD) &&
+        hasCapabilityForRuntime(runtime, ProductCommunicationType.BLUETOOTH);
     const [devInfo, onlineType] = await Promise.all([
         getDeviceInfo(runtime.config.devInfo.devId),
         getDeviceOnlineType(runtime.config.devInfo.devId),
+        hasThreadBle && runtime.cache.isActiveThreadCache !== true
+            ? isActiveThreadForRuntime(runtime)
+            : Promise.resolve(false),
     ]);
     runtime.config.onlineType = onlineType;
     runtime.config.devInfo = devInfo;
@@ -34,10 +39,17 @@ export const getDeviceStatusForRuntime = (runtime) => {
         onlineTypes: [],
         isWifiActive: wifiEnableState !== 1,
         isWifiMatter: !!isMatter && supportWifi,
+        isActiveThread: runtime.cache.isActiveThreadCache ?? false,
+        isShareThread: isShareThreadRuntimeLocal(runtime),
     };
     const isMatterLocal = isOnlineByType(onlineType, 8);
     const isBleOnline = isOnlineByType(onlineType, 2);
-    const isLocalOnline = !isCloudOnline && isOnlineByType(onlineType, 1);
+    let isLocalOnline = !isCloudOnline && isOnlineByType(onlineType, 1);
+    if (isLocalOnline &&
+        runtime.cache.isActiveThreadCache !== true &&
+        supportThread) {
+        isLocalOnline = false;
+    }
     const hasWirelessAwakeDp = !notSupportWake && hasDpForRuntime(runtime, dpCodes.wirelessAwake);
     const wirelessAwake = getDpValueForRuntime(runtime, dpCodes.wirelessAwake);
     status.connectEnable = isSupportBleControlForRuntime(runtime) && !isOnline;
@@ -76,8 +88,7 @@ export const getDeviceStatusForRuntime = (runtime) => {
         }
     }
     if (supportThread && supportBle) {
-        const isShareThread = isShareThreadRuntimeLocal(runtime);
-        if (isShareThread && isOnline) {
+        if (status.isShareThread && isOnline) {
             if (!status.onlineTypes.includes("local")) {
                 status.onlineTypes = ["local"];
             }

package/lib/feature/state/init-state.js

@@ -2,7 +2,7 @@ import dpCodes from "../../config/dp-code";
 import { getDeviceSkill, getIPCConfig, getRotateInfo } from "../../api/video";
 import { getDataWithPreFetchForRuntime } from "../utils";
 import { getWithLocalCache } from "../storage/swr-cache";
-import { getDeviceAdvancedAbilitiesForRuntime, } from "../misc/capability";
+import { getDeviceAdvancedAbilitiesForRuntime, hasCapabilityForRuntime, isActiveThreadForRuntime, } from "../misc/capability";
 import { getCurrentUserForRuntime } from "../user/current-user";
 import { checkOfflineDpUpdateForRuntime } from "../offline-dps";
 import { autoSyncTemp } from "../password/sync-temp";
@@ -14,9 +14,9 @@ import syncT0 from "./sync/t0";
 import { getDeviceStatusForRuntime, updateOnlineType } from "./device-status";
 import { handleDpChange } from "./dp-change";
 import { fetchDeviceProperties } from "./remote-permissions";
-import { ipc, yuChannelSyncSingleSync } from "../../platform";
+import { ipc, yuChannelSyncSingleSync, } from "../../platform";
 import { sdkLog } from "../../utils/sdk-log";
-import { RotateType } from "../../constant";
+import { ProductCommunicationType, RotateType } from "../../constant";
 import { isHarmony } from "../../utils";
 export const initState = async (runtime) => {
     const { devInfo: { dps, devId, yuNetState }, dpSchema, } = runtime.config;
@@ -31,6 +31,7 @@ export const initState = async (runtime) => {
     try {
         handleDpChange(runtime, dps, true);
         const isSupportVideo = !!dpSchema[dpCodes.initiativeMessage];
+        const hasThread = hasCapabilityForRuntime(runtime, ProductCommunicationType.THREAD);
         runtime.deviceStatus = getDeviceStatusForRuntime(runtime);
         sdkLog("debug", "initState", "baseStateReady", {
             devId,
@@ -40,11 +41,12 @@ export const initState = async (runtime) => {
                 isSupportVideo,
             },
         });
-        const [, , , advanceAbilities, rotateInfo, deviceSkill, ipcConfig] = await Promise.allSettled([
+        const [, , , advanceAbilities, isActiveThread, rotateInfo, deviceSkill, ipcConfig,] = await Promise.allSettled([
             updateOnlineType(runtime),
             getCurrentUserForRuntime(runtime),
             fetchDeviceProperties(runtime),
             getDeviceAdvancedAbilitiesForRuntime(runtime),
+            hasThread ? isActiveThreadForRuntime(runtime) : Promise.resolve(false),
             isSupportVideo
                 ?
                     getDataWithPreFetchForRuntime(runtime, "getRotate", () => getWithLocalCache(runtime, "rotateInfo", () => getRotateInfo(devId), {

package/lib/feature/state/platform-routing.js

@@ -39,7 +39,6 @@ const globalHandleDeviceInfoChange = async ({ dps, deviceId, }) => {
         handleDpChange(rt, dps);
     }
     await updateOnlineType(rt);
-    updateDeviceStatus(rt);
 };
 const globalUpdateAllOnlineTypes = async (data) => {
     if (!data?.deviceId) {

package/lib/feature/unlock/method/add-flow.js

@@ -1,7 +1,7 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { createUnlockMethod } from "../../../api/lock";
 import { parallelOnlyForRuntime } from "../../utils";
-import { sleep } from "../../../utils";
+import { formatCloudUnlockId, sleep } from "../../../utils";
 import { getError } from "../../../utils/errors";
 import { publishDpsForRuntime } from "../../dp/publish-dps";
 import emitter from "../../../utils/event";
@@ -207,7 +207,7 @@ const handleAddReport = async (dps) => {
                         const res = await createUnlockMethod({
                             devId: cfg.devInfo.devId,
                             userId: addUnlockMethodData.userId,
-                            unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
+                            unlockId: formatCloudUnlockId(addUnlockMethodData.unlockDpId, result.unlockId),
                             unlockName: "",
                             unlockAttr: 0,
                         });

package/lib/feature/unlock/method/add-password.js

@@ -1,7 +1,7 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { createUnlockMethod } from "../../../api/lock";
 import { encrypt } from "../../../platform/device";
-import { sleep } from "../../../utils";
+import { formatCloudUnlockId, sleep } from "../../../utils";
 import { getError, handleCloudError } from "../../../utils/errors";
 import { publishDpsForRuntime } from "../../dp/publish-dps";
 import { getUnlockMethodBase } from "./internal/base";
@@ -76,7 +76,7 @@ export async function addPasswordForRuntime(rt, params) {
         const result = await createUnlockMethod({
             devId: devId,
             userId: params.userId,
-            unlockId: `${dpId}-${res.unlockId}`,
+            unlockId: formatCloudUnlockId(dpId, res.unlockId),
             unlockName: params.name,
             unlockDetail: aesPwd,
             ...specialInfo,

package/lib/feature/user/sync-user.js

@@ -3,10 +3,12 @@ import { deleteUserForRuntime } from "./delete-user-dp";
 import { isUseNearChannelForRuntime } from "../misc/is-use-near-channel-for-runtime";
 import { publishDpsOnlyWithRuntime, } from "../dp/publish-dps";
 import dpCodes from "../../config/dp-code";
-import { isBlePureDeviceForRuntime } from "../misc/capability";
+import { hasCapabilityForRuntime, isBlePureDeviceForRuntime } from "../misc/capability";
 import { sdkLog } from "../../utils/sdk-log";
+import { ProductCommunicationType } from "src/constant";
 export async function syncDeleteUsersWithRuntime(runtime) {
-    if (runtime.config.devInfo.wifiEnableState !== 1) {
+    const hasWifi = hasCapabilityForRuntime(runtime, ProductCommunicationType.WIFI);
+    if (hasWifi && runtime.config.devInfo.wifiEnableState !== 1) {
         sdkLog("debug", "syncUser", "deleteUsersSkipped", {
             devId: runtime.devId,
             data: { reason: "wifiActive" },

package/lib/interface.d.ts

@@ -216,6 +216,8 @@ export interface DeviceStatus {
     };
     isWifiActive: boolean;
     isWifiMatter: boolean;
+    isActiveThread: boolean;
+    isShareThread: boolean;
 }
 export interface UnionUnlockInfo {
     userId: string;

package/lib/runtime/lock-config.js

@@ -7,6 +7,8 @@ export function createDefaultDeviceStatus() {
         onlineTypes: [],
         isWifiActive: false,
         isWifiMatter: false,
+        isActiveThread: false,
+        isShareThread: false,
     };
 }
 export function createLockConfigState() {

package/lib/utils/index.d.ts

@@ -121,6 +121,7 @@ export declare function getCapabilities(capability: number): ({
     readonly short: "thread";
 })[];
 export declare const formatWeek: (value: number[]) => number;
+export declare const formatCloudUnlockId: (dpId: number | string, sn: number) => string;
 export declare const parseWeek: (value: number) => Week;
 export declare const getPermanentSetting: () => {
     startTime: number;

package/lib/utils/index.js

@@ -56,6 +56,7 @@ export const formatWeek = (value) => {
     const temp = value.slice(0, 7);
     return parseInt(temp.reverse().join(""), 2);
 };
+export const formatCloudUnlockId = (dpId, sn) => `${dpId}-${sn.toString(16).padStart(2, "0")}`;
 export const parseWeek = (value) => {
     return Number(value)
         .toString(2)

package/package.json

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