@ray-js/lock-sdk 1.1.3 → 1.2.0-beta.2

package/lib/feature/state/sync/remote-serect-key.js

@@ -0,0 +1,74 @@
+import { checkRemoteKey } from "../../../api/lock";
+import dpCodes from "../../../config/dp-code";
+import { getCurrentUserForRuntime } from "../../user/current-user";
+import { getDpValueForRuntime } from "../../dp/get-dp-value";
+import { isUseNearChannelForRuntime } from "../../misc/is-use-near-channel-for-runtime";
+import { stringToBytes } from "../../../utils/byte";
+import { decrypt } from "../../../platform/device";
+import { publishDpsOnlyWithRuntime } from "../../dp/publish-dps";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { reportSetKey as reportSetKeyMap, setKey as setKeyMap, } from "../../../config/dp-map/open";
+import { sdkLog } from "../../../utils/sdk-log";
+const syncRemoteSerectKey = async (runtime, force) => {
+    const rt = runtime;
+    const useNear = isUseNearChannelForRuntime(rt);
+    if (!useNear) {
+        sdkLog("debug", "syncKey", "skipped", {
+            devId: rt.devId,
+            data: { reason: "notNearChannel", force: !!force },
+        });
+        return;
+    }
+    const startedAt = Date.now();
+    sdkLog("info", "syncKey", "start", {
+        devId: rt.devId,
+        data: { force: !!force },
+    });
+    try {
+        if (!force) {
+            const keyValue = getDpValueForRuntime(rt, dpCodes.remoteNoPdSetkey);
+            if (keyValue) {
+                const keyData = dpUtils.parse(getDpValueForRuntime(rt, dpCodes.remoteNoPdSetkey), reportSetKeyMap);
+                if (keyData.status === 0) {
+                    sdkLog("debug", "syncKey", "skipped", {
+                        devId: rt.devId,
+                        duration: Date.now() - startedAt,
+                        data: { reason: "alreadySynced" },
+                    });
+                    return;
+                }
+            }
+        }
+        const { lockUserId, userId } = await getCurrentUserForRuntime(rt);
+        const { password, invalidTime, effectiveTime } = await checkRemoteKey(rt.config.devInfo.devId);
+        const pw = await decrypt(rt.config.devInfo.devId, password);
+        await publishDpsOnlyWithRuntime(rt, {
+            [dpCodes.remoteNoPdSetkey]: dpUtils.format({
+                valid: true,
+                memberId: lockUserId !== 0 ? lockUserId : userId,
+                startTime: effectiveTime,
+                endTime: invalidTime,
+                validNum: 100,
+                key: stringToBytes(pw),
+            }, setKeyMap),
+        });
+        sdkLog("info", "syncKey", "success", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: {
+                hasPassword: !!password,
+                hasEffectiveTime: typeof effectiveTime !== "undefined",
+                hasInvalidTime: typeof invalidTime !== "undefined",
+            },
+        });
+    }
+    catch (e) {
+        console.warn(e);
+        sdkLog("warn", "syncKey", "fail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error: e,
+        });
+    }
+};
+export default syncRemoteSerectKey;

package/lib/feature/state/sync/t0.d.ts

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+declare const syncT0: (runtime: LockDeviceRuntime) => Promise<void>;
+export default syncT0;

package/lib/feature/state/sync/t0.js

@@ -0,0 +1,64 @@
+import { getActiveTime } from "../../../api";
+import { hasCapabilityForRuntime } from "../../misc/capability";
+import dpCodes from "../../../config/dp-code";
+import { ProductCommunicationType } from "../../../constant";
+import { isUseNearChannelForRuntime } from "../../misc/is-use-near-channel-for-runtime";
+import { publishDpsOnlyWithRuntime } from "../../dp/publish-dps";
+import { sdkLog } from "../../../utils/sdk-log";
+const isNeedSyncForRuntime = (rt) => {
+    const near = isUseNearChannelForRuntime(rt);
+    return (near ||
+        (rt.config.devInfo.isOnline &&
+            hasCapabilityForRuntime(rt, ProductCommunicationType.THREAD)));
+};
+const syncT0 = async (runtime) => {
+    const rt = runtime;
+    if (rt.sync.hasSyncedT0) {
+        sdkLog("debug", "syncT0", "skipped", {
+            devId: rt.devId,
+            data: { reason: "alreadySynced" },
+        });
+        return;
+    }
+    if (!rt.config.dpSchema[dpCodes.passwordOfflineTime]) {
+        sdkLog("debug", "syncT0", "skipped", {
+            devId: rt.devId,
+            data: { reason: "noDp" },
+        });
+        return;
+    }
+    if (!isNeedSyncForRuntime(rt)) {
+        sdkLog("debug", "syncT0", "skipped", {
+            devId: rt.devId,
+            data: {
+                reason: "notNeedSync",
+                nearChannel: isUseNearChannelForRuntime(rt),
+                isOnline: !!rt.config.devInfo.isOnline,
+                hasThread: hasCapabilityForRuntime(rt, ProductCommunicationType.THREAD),
+            },
+        });
+        return;
+    }
+    const startedAt = Date.now();
+    sdkLog("info", "syncT0", "start", { devId: rt.devId });
+    rt.sync.hasSyncedT0 = true;
+    try {
+        const time = await getActiveTime(rt.config.devInfo.devId);
+        await publishDpsOnlyWithRuntime(rt, {
+            [dpCodes.passwordOfflineTime]: time.toString(),
+        });
+        sdkLog("info", "syncT0", "success", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+        });
+    }
+    catch (error) {
+        sdkLog("error", "syncT0", "fail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw error;
+    }
+};
+export default syncT0;

package/lib/feature/unlock/door/check-remote.d.ts

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

package/lib/feature/unlock/door/check-remote.js

@@ -0,0 +1,40 @@
+import { hasCapabilityForRuntime } from "../../misc/capability";
+import { ProductCommunicationType, UserType } from "../../../constant";
+import dpCodes from "../../../config/dp-code";
+import { getError } from "../../../utils/errors";
+import { parallelMergeForRuntime } from "../../utils";
+import { getCurrentUserForRuntime } from "../../user/current-user";
+import { getDeviceStatusForRuntime } from "../../state/device-status";
+export const checkRemoteEnabledForRuntime = parallelMergeForRuntime(async function checkRemoteEnabledForRuntime(rt) {
+    const { dpSchema, remoteOpenEnabled, remoteOpenPermission } = rt.config;
+    const { userType } = await getCurrentUserForRuntime(rt);
+    const deviceStatus = getDeviceStatusForRuntime(rt);
+    const hasThread = hasCapabilityForRuntime(rt, ProductCommunicationType.THREAD);
+    if (deviceStatus.type !== "online") {
+        throw getError(1001);
+    }
+    const isLocalOnline = deviceStatus.onlineTypes.length === 1 &&
+        deviceStatus.onlineTypes.includes("local");
+    const isThreadLocalOnline = hasThread && isLocalOnline;
+    if (isThreadLocalOnline || deviceStatus.onlineTypes.includes("ble")) {
+        return;
+    }
+    if (deviceStatus.isWifiMatter && isLocalOnline) {
+        return;
+    }
+    if (isLocalOnline) {
+        throw getError(1064);
+    }
+    if (dpSchema[dpCodes.remoteNoDpKey] === undefined) {
+        throw getError(1045);
+    }
+    if (!remoteOpenEnabled) {
+        throw getError(1046);
+    }
+    if (remoteOpenPermission === "noOne" ||
+        (remoteOpenPermission === "adminsOnly" &&
+            +userType !== UserType.ADMIN &&
+            +userType !== UserType.OWNER)) {
+        throw getError(1047);
+    }
+});

package/lib/feature/unlock/door/check-user-valid.d.ts

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

package/lib/feature/unlock/door/check-user-valid.js

@@ -0,0 +1,21 @@
+import { getError } from "../../../utils/errors";
+export const checkCurrentUserValid = async (runtime) => {
+    const { permanent, effectiveTime = 0, expireTime = 0, expireDay = 0, phase, } = runtime.cache.currentUser || {};
+    if (phase === 0) {
+        throw getError(1073);
+    }
+    if (phase === 5) {
+        throw getError(1074);
+    }
+    if (phase === 6) {
+        throw getError(1075);
+    }
+    if (!permanent) {
+        const now = Date.now() / 1000;
+        const isEffective = now >= effectiveTime && now <= expireTime;
+        if (!isEffective || expireDay > 0) {
+            throw getError(1074);
+        }
+    }
+    return true;
+};

package/lib/feature/unlock/door/door-action.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare const doOpenCloseActionForRuntime: (this: unknown, rt: LockDeviceRuntime, isOpen: boolean, timeout: number) => Promise<void>;

package/lib/feature/unlock/door/door-action.js

@@ -0,0 +1,32 @@
+import { parallelOnlyForRuntime } from "../../utils";
+import { checkRemoteEnabledForRuntime } from "./check-remote";
+import { getCurrentUserForRuntime } from "../../user/current-user";
+import { resolveOpenClosePath } from "./open-close-path";
+import { executeOpenCloseMatterLan } from "./door-matter-lan";
+import { executeOpenCloseNearDualMode } from "./door-near-dual-mode";
+import { executeOpenCloseBleOnly } from "./door-ble-only";
+import { executeOpenCloseRemoteCloud } from "./door-remote-cloud";
+export const doOpenCloseActionForRuntime = parallelOnlyForRuntime(async function doOpenCloseActionForRuntime(rt, isOpen, timeout) {
+    await checkRemoteEnabledForRuntime(rt);
+    const path = resolveOpenClosePath(rt);
+    const currentUser = await getCurrentUserForRuntime(rt);
+    const memberId = currentUser.lockUserId !== 0 ? currentUser.lockUserId : currentUser.userId;
+    switch (path) {
+        case "matter_lan":
+            await executeOpenCloseMatterLan(rt, isOpen);
+            return;
+        case "near_dual_mode":
+            await executeOpenCloseNearDualMode(rt, isOpen, timeout, memberId);
+            return;
+        case "ble_only":
+            await executeOpenCloseBleOnly(rt, isOpen, timeout, memberId);
+            return;
+        case "remote_cloud":
+            await executeOpenCloseRemoteCloud(rt, isOpen, timeout, memberId);
+            return;
+        default: {
+            const _exhaustive = path;
+            return _exhaustive;
+        }
+    }
+});

package/lib/feature/unlock/door/door-ble-only.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function executeOpenCloseBleOnly(rt: LockDeviceRuntime, isOpen: boolean, timeout: number, memberId: number | string): Promise<void>;

package/lib/feature/unlock/door/door-ble-only.js

@@ -0,0 +1,102 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import dpCodes from "../../../config/dp-code";
+import { bleUnlockCheckPublish } from "../../../config/dp-map/ble-unlock-check";
+import { bluetoothUnlockPublish } from "../../../config/dp-map/bluetooth-unlock";
+import { hasDpForRuntime } from "../../dp/has-dp";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import { getError } from "../../../utils/errors";
+import { isAdmin } from "../../../utils";
+import { getCurrentUserForRuntime } from "../../user/current-user";
+import { getBleUnlockCheckReportError } from "./internal/report-error";
+import { createBleUnlockCheckOpenCloseReport, createBluetoothUnlockOpenCloseReport, } from "./door-report";
+import { getUsersSyncLockData } from "../../../api/user";
+import hexToBytes from "../../../utils/hex-to-bytes";
+import { UserType } from "../../../constant";
+import { checkUserValidForUnlock } from "../../../api/lock";
+import { removeShareUserOnceForRuntime } from "./remove-share-user-once";
+import { sdkLog } from "../../../utils/sdk-log";
+function randomBytes(byteLength) {
+    const u = new Uint8Array(byteLength);
+    globalThis.crypto.getRandomValues(u);
+    return Array.from(u);
+}
+function bleUnlockMemberIdToByte(memberId) {
+    const raw = typeof memberId === "number"
+        ? memberId
+        : Number.parseInt(String(memberId), 10);
+    if (!Number.isFinite(raw)) {
+        return 1;
+    }
+    return Math.min(100, Math.max(1, Math.floor(raw)));
+}
+export async function executeOpenCloseBleOnly(rt, isOpen, timeout, memberId) {
+    const currentUser = await getCurrentUserForRuntime(rt);
+    const adminFlag = isAdmin(currentUser.userType) ? 0x01 : 0x00;
+    const memberByte = bleUnlockMemberIdToByte(memberId);
+    const isShareOrMemberUser = currentUser.userType === UserType.SHARE ||
+        currentUser.userType === UserType.MEMBER;
+    if (isShareOrMemberUser) {
+        const isValid = await checkUserValidForUnlock(rt.config.devInfo.devId);
+        if (!isValid) {
+            throw getError(1076);
+        }
+    }
+    if (!isOpen) {
+        await publishDpsForRuntime(rt, { [dpCodes.manualLock]: true }, {
+            timeout,
+            checkReport: (dps) => {
+                if (typeof dps[dpCodes.lockMotorState] !== "undefined") {
+                    return true;
+                }
+                return false;
+            },
+        });
+        return;
+    }
+    if (hasDpForRuntime(rt, dpCodes.bleUnlockCheck)) {
+        const { lockRandom: { devUnlockId, ins }, } = await getUsersSyncLockData(rt.config.devInfo.devId);
+        const publishMap = bleUnlockCheckPublish;
+        sdkLog("debug", "unlock", "bleUnlockCheckPrepared", {
+            devId: rt.devId,
+            data: { hasDevUnlockId: !!devUnlockId, hasIns: !!ins },
+        });
+        const formatted = dpUtils.format({
+            masterId: 0xffff,
+            slaveId: parseInt(devUnlockId, 16),
+            masterRandom: hexToBytes(ins),
+            operation: isOpen ? 0x01 : 0x00,
+            timestamp: Math.floor(Date.now() / 1000),
+            method: 0x00,
+            memberId: memberByte,
+            adminFlag,
+        }, publishMap);
+        const response = await publishDpsForRuntime(rt, { [dpCodes.bleUnlockCheck]: formatted }, {
+            timeout,
+            checkReport: (dps) => createBleUnlockCheckOpenCloseReport(rt)(dps),
+        });
+        removeShareUserOnceForRuntime(rt);
+        const status = response.status;
+        if (typeof status === "number" && status !== 0) {
+            throw getBleUnlockCheckReportError(status);
+        }
+        return;
+    }
+    if (hasDpForRuntime(rt, dpCodes.bluetoothUnlock)) {
+        const publishMap = bluetoothUnlockPublish;
+        const formatted = dpUtils.format({
+            function: isOpen ? 0x01 : 0x00,
+            memberId: memberByte,
+        }, publishMap);
+        const response = await publishDpsForRuntime(rt, { [dpCodes.bluetoothUnlock]: formatted }, {
+            timeout,
+            checkReport: (dps) => createBluetoothUnlockOpenCloseReport(rt)(dps),
+        });
+        removeShareUserOnceForRuntime(rt);
+        const status = response.status;
+        if (typeof status === "number" && status !== 0) {
+            throw getError(1004);
+        }
+        return;
+    }
+    throw getError(1045);
+}

package/lib/feature/unlock/door/door-matter-lan.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function executeOpenCloseMatterLan(rt: LockDeviceRuntime, isOpen: boolean): Promise<void>;

package/lib/feature/unlock/door/door-matter-lan.js

@@ -0,0 +1,15 @@
+import dpCodes from "../../../config/dp-code";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import { hasDpForRuntime } from "../../dp/has-dp";
+export async function executeOpenCloseMatterLan(rt, isOpen) {
+    await publishDpsForRuntime(rt, { [dpCodes.matterLanUnlock]: isOpen }, {
+        checkReport: (dps) => {
+            if (hasDpForRuntime(rt, dpCodes.lockMotorState)) {
+                if (typeof dps[dpCodes.lockMotorState] !== "undefined") {
+                    return true;
+                }
+            }
+            return typeof dps[dpCodes.matterLanUnlock] !== "undefined";
+        },
+    });
+}

package/lib/feature/unlock/door/door-near-dual-mode.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function executeOpenCloseNearDualMode(rt: LockDeviceRuntime, isOpen: boolean, timeout: number, memberId: number | string): Promise<void>;

package/lib/feature/unlock/door/door-near-dual-mode.js

@@ -0,0 +1,39 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { getDoorKey } from "../../../api/lock";
+import dpCodes from "../../../config/dp-code";
+import { open as openMap, } from "../../../config/dp-map/open";
+import { decrypt } from "../../../platform/device";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import syncRemoteSerectKey from "../../state/sync/remote-serect-key";
+import { stringToBytes } from "../../../utils/byte";
+import { createRemoteOpenCloseCheckReport } from "./door-report";
+import { getReportError } from "./internal/report-error";
+export async function executeOpenCloseNearDualMode(rt, isOpen, timeout, memberId) {
+    const { devInfo } = rt.config;
+    await syncRemoteSerectKey(rt);
+    let pw = "";
+    try {
+        const { password } = await getDoorKey(devInfo.devId);
+        pw = await decrypt(devInfo.devId, password);
+    }
+    catch (e) {
+        await syncRemoteSerectKey(rt, true);
+        const { password } = await getDoorKey(devInfo.devId);
+        pw = await decrypt(devInfo.devId, password);
+    }
+    const checkReport = createRemoteOpenCloseCheckReport(rt, memberId);
+    const response = await publishDpsForRuntime(rt, {
+        [dpCodes.remoteNoDpKey]: dpUtils.format({
+            status: Number(isOpen),
+            memberId,
+            key: stringToBytes(pw),
+            type: 3,
+        }, openMap),
+    }, {
+        timeout,
+        checkReport: (dps) => checkReport(dps),
+    });
+    if (response.status !== 0) {
+        throw getReportError(response.status);
+    }
+}

package/lib/feature/unlock/door/door-remote-cloud.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function executeOpenCloseRemoteCloud(rt: LockDeviceRuntime, isOpen: boolean, timeout: number, memberId: number | string): Promise<void>;

package/lib/feature/unlock/door/door-remote-cloud.js

@@ -0,0 +1,69 @@
+import { openDoorByCloud } from "../../../api/lock";
+import emitter from "../../../utils/event";
+import { getError } from "../../../utils/errors";
+import { DPCHANGE } from "../../../utils/constant";
+import { createRemoteOpenCloseCheckReport } from "./door-report";
+import { getReportError } from "./internal/report-error";
+import { removeShareUserOnceForRuntime } from "./remove-share-user-once";
+import { sdkLog } from "../../../utils/sdk-log";
+export async function executeOpenCloseRemoteCloud(rt, isOpen, timeout, memberId) {
+    const { devInfo } = rt.config;
+    const checkReport = createRemoteOpenCloseCheckReport(rt, memberId);
+    const startedAt = Date.now();
+    sdkLog("debug", "unlock", "remoteCloudStart", {
+        devId: rt.devId,
+        data: { isOpen, timeout },
+    });
+    return new Promise((resolve, reject) => {
+        const handleReport = (dpCodesArg) => {
+            const result = checkReport(dpCodesArg);
+            if (result) {
+                emitter.off(DPCHANGE, handleReport);
+                clearTimeout(timeoutTask);
+                removeShareUserOnceForRuntime(rt);
+                if (result.status !== 0) {
+                    const error = getReportError(result.status);
+                    sdkLog("warn", "unlock", "remoteCloudReportFail", {
+                        devId: rt.devId,
+                        duration: Date.now() - startedAt,
+                        data: { isOpen, status: result.status },
+                        error,
+                    });
+                    reject(error);
+                }
+                else {
+                    sdkLog("debug", "unlock", "remoteCloudReportMatched", {
+                        devId: rt.devId,
+                        duration: Date.now() - startedAt,
+                        data: { isOpen },
+                    });
+                    resolve();
+                }
+            }
+        };
+        const timeoutTask = setTimeout(() => {
+            emitter.off(DPCHANGE, handleReport);
+            const error = getError(1002);
+            sdkLog("warn", "unlock", "remoteCloudTimeout", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { isOpen, timeout },
+                error,
+            });
+            reject(error);
+        }, timeout);
+        emitter.on(DPCHANGE, handleReport);
+        openDoorByCloud(devInfo.devId, isOpen).catch(() => {
+            clearTimeout(timeoutTask);
+            emitter.off(DPCHANGE, handleReport);
+            const error = getError(1003);
+            sdkLog("error", "unlock", "remoteCloudInvokeFail", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { isOpen },
+                error,
+            });
+            reject(error);
+        });
+    });
+}

package/lib/feature/unlock/door/door-report.d.ts

@@ -0,0 +1,11 @@
+import type { DpValue } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function createRemoteOpenCloseCheckReport(rt: LockDeviceRuntime, memberId: number | string): (dpData: Record<string, DpValue>) => false | {
+    status: number;
+};
+export declare function createBleUnlockCheckOpenCloseReport(rt: LockDeviceRuntime): (dpData: Record<string, DpValue>) => false | {
+    status: number;
+};
+export declare function createBluetoothUnlockOpenCloseReport(rt: LockDeviceRuntime): (dpData: Record<string, DpValue>) => false | {
+    status: number;
+};

package/lib/feature/unlock/door/door-report.js

@@ -0,0 +1,96 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { hasDpForRuntime } from "../../dp/has-dp";
+import dpCodes from "../../../config/dp-code";
+import { bleUnlockCheckReport } from "../../../config/dp-map/ble-unlock-check";
+import { bluetoothUnlockReport } from "../../../config/dp-map/bluetooth-unlock";
+import { reportOpen as reportOpenMap } from "../../../config/dp-map/open";
+export function createRemoteOpenCloseCheckReport(rt, memberId) {
+    return (dpData) => {
+        if (hasDpForRuntime(rt, dpCodes.lockMotorState)) {
+            if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
+                return {
+                    status: 0,
+                };
+            }
+        }
+        if (typeof dpData[dpCodes.remoteNoDpKey] !== "undefined") {
+            const result = dpUtils.parse(dpData[dpCodes.remoteNoDpKey], reportOpenMap);
+            if (result.memberId === memberId) {
+                if (hasDpForRuntime(rt, dpCodes.lockMotorState) &&
+                    result.status === 0) {
+                    return false;
+                }
+                return result;
+            }
+            console.warn("An incorrect member id was returned");
+        }
+        return false;
+    };
+}
+export function createBleUnlockCheckOpenCloseReport(rt) {
+    const reportMap = bleUnlockCheckReport;
+    return (dpData) => {
+        if (hasDpForRuntime(rt, dpCodes.lockMotorState)) {
+            if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
+                return {
+                    status: 0,
+                };
+            }
+        }
+        if (typeof dpData[dpCodes.bleUnlockCheck] !== "undefined") {
+            try {
+                const result = dpUtils.parse(dpData[dpCodes.bleUnlockCheck], reportMap);
+                const rs = result.returnStatus;
+                if (rs === undefined) {
+                    return false;
+                }
+                if (rs !== 0) {
+                    return { status: rs };
+                }
+                if (hasDpForRuntime(rt, dpCodes.lockMotorState)) {
+                    return false;
+                }
+                return { status: 0 };
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    };
+}
+export function createBluetoothUnlockOpenCloseReport(rt) {
+    const reportMap = bluetoothUnlockReport;
+    return (dpData) => {
+        if (hasDpForRuntime(rt, dpCodes.lockMotorState)) {
+            if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
+                return {
+                    status: 0,
+                };
+            }
+        }
+        if (typeof dpData[dpCodes.bluetoothUnlock] !== "undefined") {
+            try {
+                const result = dpUtils.parse(dpData[dpCodes.bluetoothUnlock], reportMap);
+                const rs = result.returnStatus;
+                if (rs === undefined) {
+                    return false;
+                }
+                if (rs === 0 || rs === 0x00) {
+                    return { status: 1 };
+                }
+                if (rs === 1 || rs === 0x01) {
+                    if (hasDpForRuntime(rt, dpCodes.lockMotorState)) {
+                        return false;
+                    }
+                    return { status: 0 };
+                }
+                return { status: rs };
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    };
+}

package/lib/feature/unlock/door/internal/report-error.d.ts

@@ -0,0 +1,2 @@
+export declare function getReportError(status: number): import("../../../..").ErrorData;
+export declare function getBleUnlockCheckReportError(returnStatus: number): import("../../../..").ErrorData;

package/lib/feature/unlock/door/internal/report-error.js

@@ -0,0 +1,46 @@
+import { getError } from "../../../../utils/errors";
+export function getReportError(status) {
+    let error = getError(1004);
+    switch (status) {
+        case 0x02:
+            error = getError(1005);
+            break;
+        case 0x03:
+            error = getError(1006);
+            break;
+        case 0x04:
+            error = getError(1007);
+            break;
+        case 0x05:
+            error = getError(1008);
+            break;
+        default:
+            break;
+    }
+    return error;
+}
+export function getBleUnlockCheckReportError(returnStatus) {
+    let error = getError(1004);
+    switch (returnStatus) {
+        case 0x01:
+            break;
+        case 0x02:
+            error = getError(1077);
+            break;
+        case 0x03:
+            error = getError(1078);
+            break;
+        case 0x04:
+            error = getError(1079);
+            break;
+        case 0x05:
+            error = getError(1080);
+            break;
+        case 0x06:
+            error = getError(1081);
+            break;
+        default:
+            break;
+    }
+    return error;
+}

package/lib/feature/unlock/door/open-close-path.d.ts

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export type OpenClosePathKind = "matter_lan" | "near_dual_mode" | "ble_only" | "remote_cloud";
+export declare function resolveOpenClosePath(rt: LockDeviceRuntime): OpenClosePathKind;