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

package/lib/feature/unlock/door/open-close-path.js

@@ -0,0 +1,30 @@
+import { hasCapabilityForRuntime, isBlePureDeviceForRuntime, } from "../../misc/capability";
+import { isUseNearChannelForRuntime } from "../../misc/is-use-near-channel-for-runtime";
+import { ProductCommunicationType } from "../../../constant";
+import { getDeviceStatusForRuntime } from "../../state/device-status";
+export function resolveOpenClosePath(rt) {
+    const deviceStatus = getDeviceStatusForRuntime(rt);
+    const hasThread = hasCapabilityForRuntime(rt, ProductCommunicationType.THREAD);
+    if ((hasThread || deviceStatus.isWifiMatter) &&
+        deviceStatus.onlineTypes.includes("local") &&
+        deviceStatus.onlineTypes.length === 1) {
+        return "matter_lan";
+    }
+    const isDeviceOnline = isBlePureDeviceForRuntime(rt);
+    const isNear = isUseNearChannelForRuntime(rt);
+    if (isNear) {
+        if (hasCapabilityForRuntime(rt, ProductCommunicationType.WIFI) ||
+            hasCapabilityForRuntime(rt, ProductCommunicationType.THREAD)) {
+            return "near_dual_mode";
+        }
+        if (isDeviceOnline) {
+            if (!deviceStatus.onlineTypes.includes("cloud")) {
+                return "ble_only";
+            }
+        }
+    }
+    if (isDeviceOnline && deviceStatus.onlineTypes.includes("yuChannel")) {
+        return "ble_only";
+    }
+    return "remote_cloud";
+}

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

@@ -0,0 +1,5 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import { RemotePermissionType } from "../../../constant";
+export declare const remoteEnabledForRuntime: (this: unknown, rt: LockDeviceRuntime, state: boolean) => Promise<void>;
+export declare const getRemotePermissionList: () => RemotePermissionType[];
+export declare function updateRemotePermissionForRuntime(rt: LockDeviceRuntime, permission: RemotePermissionType): Promise<void>;

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

@@ -0,0 +1,67 @@
+import { parallelMergeForRuntime } from "../../utils";
+import { setDeviceProperties } from "../../../api/setting";
+import syncRemoteSerectKey from "../../state/sync/remote-serect-key";
+import { permissions } from "../../state/remote-permissions";
+import { sdkLog } from "../../../utils/sdk-log";
+export const remoteEnabledForRuntime = parallelMergeForRuntime(async function remoteEnabledForRuntime(rt, state) {
+    const startedAt = Date.now();
+    sdkLog("info", "remotePermission", "remoteEnabledStart", {
+        devId: rt.devId,
+        data: { state },
+    });
+    try {
+        await setDeviceProperties(rt.config.devInfo.devId, {
+            UNLOCK_PHONE_REMOTE: state,
+        });
+        rt.config.remoteOpenEnabled = state;
+        if (state) {
+            void syncRemoteSerectKey(rt);
+        }
+        sdkLog("info", "remotePermission", "remoteEnabledSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { state },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "remotePermission", "remoteEnabledFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { state },
+            error,
+        });
+        throw error;
+    }
+});
+export const getRemotePermissionList = () => {
+    return permissions;
+};
+export async function updateRemotePermissionForRuntime(rt, permission) {
+    const startedAt = Date.now();
+    const index = permissions.indexOf(permission);
+    const permissionIndex = index > 0 ? index : 0;
+    sdkLog("info", "remotePermission", "updateStart", {
+        devId: rt.devId,
+        data: { permission, permissionIndex },
+    });
+    try {
+        await setDeviceProperties(rt.config.devInfo.devId, {
+            REMOTE_UNLOCK_AUTH: permissionIndex,
+        });
+        rt.config.remoteOpenPermission = permission;
+        sdkLog("info", "remotePermission", "updateSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { permission, permissionIndex },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "remotePermission", "updateFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { permission, permissionIndex },
+            error,
+        });
+        throw error;
+    }
+}

package/lib/feature/unlock/door/remove-share-user-once.d.ts

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

package/lib/feature/unlock/door/remove-share-user-once.js

@@ -0,0 +1,21 @@
+import { removeLockVirtualKeyBinding } from "../../../api/ble";
+import { getuserAuthList } from "../../../api/user";
+import { UserType } from "../../../constant";
+import { isBlePureDeviceForRuntime } from "../../misc/capability";
+import { getCurrentUserForRuntime } from "../../user/current-user";
+export async function removeShareUserOnceForRuntime(rt) {
+    const currentUser = await getCurrentUserForRuntime(rt);
+    if (!isBlePureDeviceForRuntime(rt) || currentUser.userType !== UserType.SHARE) {
+        return;
+    }
+    const devId = rt.config.devInfo.devId;
+    const list = await getuserAuthList({
+        devId,
+        authTypes: ["LOCK_BLUE_PASSWORD"],
+    });
+    const first = list?.[0];
+    if (!first?.unlockBindingId || first.availTime !== 1) {
+        return;
+    }
+    await removeLockVirtualKeyBinding(devId, first.unlockBindingId);
+}

package/lib/feature/unlock/door/types.d.ts

@@ -0,0 +1,4 @@
+export declare const OPEN_CLOSE_ACTION_DEFAULT_TIMEOUT_MS = 15000;
+export interface OpenDoorCallOptions {
+    timeout?: number;
+}

package/lib/feature/unlock/door/types.js

@@ -0,0 +1 @@
+export const OPEN_CLOSE_ACTION_DEFAULT_TIMEOUT_MS = 15000;

package/lib/feature/unlock/door/voice-unlock-pwd.d.ts

@@ -0,0 +1,4 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function getVoiceUnlockPwdEnabledForRuntime(rt: LockDeviceRuntime): Promise<boolean>;
+export declare function voiceUnlockPwdDisabledForRuntime(rt: LockDeviceRuntime): Promise<boolean>;
+export declare function updateVoiceUnlockPwdForRuntime(rt: LockDeviceRuntime, password: string): Promise<boolean>;

package/lib/feature/unlock/door/voice-unlock-pwd.js

@@ -0,0 +1,25 @@
+import { encrypt } from "../../../platform/device";
+import { getVoicePwdEnabled, setVoicePwd } from "../../../api";
+import { getError } from "../../../utils/errors";
+export async function getVoiceUnlockPwdEnabledForRuntime(rt) {
+    const res = await getVoicePwdEnabled(rt.config.devInfo.devId);
+    return res === true || res === 1;
+}
+export async function voiceUnlockPwdDisabledForRuntime(rt) {
+    return setVoicePwd({
+        devId: rt.config.devInfo.devId,
+        open: false,
+        pwd: "",
+    });
+}
+export async function updateVoiceUnlockPwdForRuntime(rt, password) {
+    if (!/^\d{4,6}$/.test(password)) {
+        throw getError(1063);
+    }
+    const encryptedPassword = await encrypt(rt.config.devInfo.devId, password);
+    return setVoicePwd({
+        devId: rt.config.devInfo.devId,
+        open: true,
+        pwd: encryptedPassword,
+    });
+}

package/lib/feature/unlock/door/wifi-pro-confirm.d.ts

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

package/lib/feature/unlock/door/wifi-pro-confirm.js

@@ -0,0 +1,69 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { isConfirmOpenDoorByWifiPro } from "../../../api/lock";
+import { parallelOnlyForRuntime } from "../../utils";
+import { reportOpen as reportOpenMap, } from "../../../config/dp-map/open";
+import emitter from "../../../utils/event";
+import { getError } from "../../../utils/errors";
+import { DPCHANGE } from "../../../utils/constant";
+import dpCodes from "../../../config/dp-code";
+import { getReportError } from "./internal/report-error";
+import { sdkLog } from "../../../utils/sdk-log";
+export const handleOpenDoorForRuntime = parallelOnlyForRuntime(function handleOpenDoorForRuntime(rt, confirm, timeout) {
+    const { devInfo } = rt.config;
+    const startedAt = Date.now();
+    sdkLog("info", "unlock", "wifiProConfirmStart", {
+        devId: rt.devId,
+        data: { confirm, timeout },
+    });
+    return new Promise((resolve, reject) => {
+        const handleReport = (dpData) => {
+            if (typeof dpData[dpCodes.remoteNoDpKey] !== "undefined") {
+                timeoutTask && clearTimeout(timeoutTask);
+                emitter.off(DPCHANGE, handleReport);
+                const result = dpUtils.parse(dpData[dpCodes.remoteNoDpKey], reportOpenMap);
+                if (result.status !== 0x00) {
+                    const error = getReportError(result.status);
+                    sdkLog("warn", "unlock", "wifiProConfirmReportFail", {
+                        devId: rt.devId,
+                        duration: Date.now() - startedAt,
+                        data: { confirm, status: result.status },
+                        error,
+                    });
+                    reject(error);
+                }
+                else {
+                    sdkLog("info", "unlock", "wifiProConfirmReportSuccess", {
+                        devId: rt.devId,
+                        duration: Date.now() - startedAt,
+                        data: { confirm, status: result.status },
+                    });
+                    resolve();
+                }
+            }
+        };
+        const timeoutTask = setTimeout(() => {
+            emitter.off(DPCHANGE, handleReport);
+            const error = getError(1002);
+            sdkLog("warn", "unlock", "wifiProConfirmTimeout", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { confirm, timeout },
+                error,
+            });
+            reject(error);
+        }, timeout);
+        emitter.on(DPCHANGE, handleReport);
+        isConfirmOpenDoorByWifiPro(devInfo.devId, confirm).catch((e) => {
+            timeoutTask && clearTimeout(timeoutTask);
+            emitter.off(DPCHANGE, handleReport);
+            const error = getError(1003);
+            sdkLog("error", "unlock", "wifiProConfirmInvokeFail", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { confirm },
+                error: e || error,
+            });
+            reject(error);
+        });
+    });
+});

package/lib/feature/unlock/method/add-flow.d.ts

@@ -0,0 +1,7 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { CancelAddUnlockMethodParams, StartAddUnlockMethodParams } from "./types";
+export interface StartAddUnlockMethodResult {
+    total: number;
+}
+export declare function startAddUnlockMethodForRuntime(rt: LockDeviceRuntime, params: StartAddUnlockMethodParams): Promise<StartAddUnlockMethodResult>;
+export declare const cancelAddUnlockMethodForRuntime: (this: unknown, rt: LockDeviceRuntime, params: CancelAddUnlockMethodParams) => Promise<void>;

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

@@ -0,0 +1,403 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { createUnlockMethod } from "../../../api/lock";
+import { parallelOnlyForRuntime } from "../../utils";
+import { sleep } from "../../../utils";
+import { getError } from "../../../utils/errors";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import emitter from "../../../utils/event";
+import { DPCHANGE } from "../../../utils/constant";
+import { getUserInfoForRuntime } from "../../user/user";
+import { getUnlockMethodEvent } from "./add-method-events";
+import { getUnlockMethodBase } from "./internal/base";
+import { getAddUnlockError } from "./internal/errors";
+import { sdkLog } from "../../../utils/sdk-log";
+const ADD_UNLOCK_METHOD_EVENT_RELEASE_DELAY = 16;
+const addUnlockMethodData = {
+    unlockMethodConfig: {},
+    total: 0,
+    dpCode: "",
+    dpMap: {},
+    sn: 0,
+    lockUserId: 0,
+    timeoutId: 0,
+    userId: "",
+    unlockDpId: 0,
+    timeout: 15000,
+    runtime: null,
+    canEmitEvents: true,
+    pendingEvents: [],
+    releaseEmitTimer: 0,
+    eventSessionId: 0,
+};
+let isCancelAddUnlockMethod = false;
+const dispatchAddUnlockMethodEvent = (eventKey, eventData) => {
+    if (emitter.hasListener(eventKey)) {
+        emitter.emit(eventKey, eventData);
+    }
+    else {
+        emitter.cache(eventKey, eventData);
+    }
+};
+const emitAddUnlockMethodEvent = (rt, eventData) => {
+    const eventKey = getUnlockMethodEvent(rt);
+    if (!addUnlockMethodData.canEmitEvents) {
+        addUnlockMethodData.pendingEvents.push({ eventKey, eventData });
+        return;
+    }
+    dispatchAddUnlockMethodEvent(eventKey, eventData);
+};
+const releaseAddUnlockMethodEventsAfterStart = (eventSessionId) => {
+    clearTimeout(addUnlockMethodData.releaseEmitTimer);
+    addUnlockMethodData.releaseEmitTimer = setTimeout(() => {
+        if (addUnlockMethodData.eventSessionId !== eventSessionId) {
+            return;
+        }
+        addUnlockMethodData.releaseEmitTimer = setTimeout(() => {
+            if (addUnlockMethodData.eventSessionId !== eventSessionId) {
+                return;
+            }
+            addUnlockMethodData.canEmitEvents = true;
+            const pendingEvents = addUnlockMethodData.pendingEvents.splice(0);
+            pendingEvents.forEach(({ eventKey, eventData }) => {
+                dispatchAddUnlockMethodEvent(eventKey, eventData);
+            });
+        }, ADD_UNLOCK_METHOD_EVENT_RELEASE_DELAY);
+    }, 0);
+};
+const handleAddTimeout = (timeout = 15000) => {
+    clearTimeout(addUnlockMethodData.timeoutId);
+    addUnlockMethodData.timeoutId = setTimeout(() => {
+        emitter.off(DPCHANGE, handleAddReport);
+        const rt = addUnlockMethodData.runtime;
+        if (!rt)
+            return;
+        emitAddUnlockMethodEvent(rt, {
+            type: addUnlockMethodData.unlockMethodConfig.type,
+            stage: "fail",
+            lockUserId: addUnlockMethodData.lockUserId,
+            error: getError(1002),
+        });
+    }, timeout);
+};
+const handleAddReport = async (dps) => {
+    const rt = addUnlockMethodData.runtime;
+    if (!rt) {
+        return;
+    }
+    const cfg = rt.config;
+    if (dps[addUnlockMethodData.dpCode]) {
+        const result = dpUtils.parse(dps[addUnlockMethodData.dpCode], addUnlockMethodData.dpMap);
+        let eventData = null;
+        if (result.type !== addUnlockMethodData.unlockMethodConfig.id) {
+            return;
+        }
+        if (cfg.strictMode) {
+            if (result.sn !== addUnlockMethodData.sn ||
+                result.memberId !== addUnlockMethodData.lockUserId) {
+                return;
+            }
+        }
+        else {
+            if (result.sn !== addUnlockMethodData.sn) {
+                sdkLog("warn", "unlockMethod", "addReportSnMismatch", {
+                    devId: rt.devId,
+                    data: { type: addUnlockMethodData.unlockMethodConfig.type },
+                });
+            }
+            if (result.memberId !== addUnlockMethodData.lockUserId) {
+                sdkLog("warn", "unlockMethod", "addReportMemberMismatch", {
+                    devId: rt.devId,
+                    data: { type: addUnlockMethodData.unlockMethodConfig.type },
+                });
+            }
+        }
+        const type = addUnlockMethodData.unlockMethodConfig.type;
+        switch (result.stage) {
+            case 0xfc: {
+                handleAddTimeout(addUnlockMethodData.timeout);
+                sdkLog("debug", "unlockMethod", "addStep", {
+                    devId: rt.devId,
+                    data: {
+                        type,
+                        step: result.step,
+                        total: addUnlockMethodData.total,
+                    },
+                });
+                eventData = {
+                    type,
+                    stage: "step",
+                    lockUserId: result.memberId,
+                    step: result.step,
+                    total: addUnlockMethodData.total,
+                };
+                break;
+            }
+            case 0xfd: {
+                clearMonitoringAddReport();
+                sdkLog("warn", "unlockMethod", "addReportFail", {
+                    devId: rt.devId,
+                    data: { type, status: result.status },
+                });
+                eventData = {
+                    stage: "fail",
+                    type,
+                    lockUserId: result.memberId,
+                    error: getAddUnlockError(result.status),
+                };
+                break;
+            }
+            case 0xfe: {
+                clearMonitoringAddReport();
+                if (isCancelAddUnlockMethod) {
+                    isCancelAddUnlockMethod = false;
+                    sdkLog("info", "unlockMethod", "addCancelled", {
+                        devId: rt.devId,
+                        data: { type },
+                    });
+                    return;
+                }
+                sdkLog("warn", "unlockMethod", "addReportFail", {
+                    devId: rt.devId,
+                    data: { type, status: result.status },
+                });
+                eventData = {
+                    stage: "fail",
+                    type,
+                    lockUserId: result.memberId,
+                    error: getAddUnlockError(result.status),
+                };
+                break;
+            }
+            case 0xff: {
+                clearMonitoringAddReport();
+                try {
+                    await sleep(300);
+                    sdkLog("debug", "unlockMethod", "cloudCreateStart", {
+                        devId: rt.devId,
+                        data: { type },
+                    });
+                    let isAddEnabled = true;
+                    if (!cfg.supportMultipleFace && type === "face") {
+                        const user = await getUserInfoForRuntime(rt, {
+                            userId: addUnlockMethodData.userId,
+                        });
+                        const faceData = user.unlockDetails.find((item) => item.type === "face" && item.unlockList.length > 0);
+                        if (faceData) {
+                            const originUnlockId = faceData.unlockList[0].unlockId;
+                            if (originUnlockId !== result.unlockId) {
+                                eventData = {
+                                    stage: "fail",
+                                    type,
+                                    lockUserId: result.memberId,
+                                    error: getError(1061),
+                                };
+                            }
+                            else {
+                                eventData = {
+                                    stage: "success",
+                                    type,
+                                    id: faceData.unlockList[0].id,
+                                    name: faceData.unlockList[0].unlockName,
+                                };
+                            }
+                            isAddEnabled = false;
+                        }
+                    }
+                    if (isAddEnabled) {
+                        const res = await createUnlockMethod({
+                            devId: cfg.devInfo.devId,
+                            userId: addUnlockMethodData.userId,
+                            unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
+                            unlockName: "",
+                            unlockAttr: 0,
+                        });
+                        eventData = {
+                            stage: "success",
+                            type,
+                            id: res.opModeId,
+                            name: res.unlockName,
+                        };
+                        sdkLog("info", "unlockMethod", "addSuccess", {
+                            devId: rt.devId,
+                            data: { type, opModeId: res.opModeId },
+                        });
+                    }
+                }
+                catch (err) {
+                    sdkLog("warn", "unlockMethod", "cloudCreateFail", {
+                        devId: rt.devId,
+                        data: { type },
+                        error: err,
+                    });
+                    eventData = {
+                        stage: "fail",
+                        type,
+                        lockUserId: result.memberId,
+                        error: getError(1053),
+                    };
+                }
+                break;
+            }
+            default:
+        }
+        if (eventData) {
+            emitAddUnlockMethodEvent(rt, eventData);
+        }
+    }
+};
+const clearMonitoringAddReport = () => {
+    clearTimeout(addUnlockMethodData.timeoutId);
+    emitter.off(DPCHANGE, handleAddReport);
+    addUnlockMethodData.runtime = null;
+};
+const monitoringAddReport = (option) => {
+    Object.assign(addUnlockMethodData, option);
+    clearTimeout(addUnlockMethodData.releaseEmitTimer);
+    addUnlockMethodData.canEmitEvents = false;
+    addUnlockMethodData.pendingEvents = [];
+    addUnlockMethodData.eventSessionId += 1;
+    emitter.clearCache(getUnlockMethodEvent(option.runtime));
+    emitter.off(DPCHANGE, handleAddReport);
+    emitter.on(DPCHANGE, handleAddReport);
+    handleAddTimeout(option.timeout);
+    return addUnlockMethodData.eventSessionId;
+};
+export async function startAddUnlockMethodForRuntime(rt, params) {
+    const startedAt = Date.now();
+    const cfg = rt.config;
+    const { unlockMethodConfig, lockUserId, dpData, sn, addDpCode, addDpMap, addDpReportMap, dpId, } = await getUnlockMethodBase(rt, params.type, params.userId);
+    isCancelAddUnlockMethod = false;
+    sdkLog("info", "unlockMethod", "startAdd", {
+        devId: rt.devId,
+        data: {
+            type: params.type,
+            userId: params.userId,
+            dpCode: addDpCode,
+            timeout: params.timeout,
+        },
+    });
+    let addReportMonitoringStarted = false;
+    let addReportMonitoringSessionId = 0;
+    const startAddReportMonitoring = (total) => {
+        if (addReportMonitoringStarted) {
+            return addReportMonitoringSessionId;
+        }
+        addReportMonitoringStarted = true;
+        addReportMonitoringSessionId = monitoringAddReport({
+            runtime: rt,
+            timeout: params.timeout,
+            unlockMethodConfig,
+            total,
+            dpCode: addDpCode,
+            dpMap: addDpReportMap,
+            sn,
+            lockUserId,
+            userId: params.userId,
+            unlockDpId: dpId,
+        });
+        return addReportMonitoringSessionId;
+    };
+    const res = await publishDpsForRuntime(rt, {
+        [addDpCode]: dpUtils.format(dpData, addDpMap),
+    }, {
+        timeout: params.timeout,
+        checkReport: (dpDataIn) => {
+            if (typeof dpDataIn[addDpCode] !== "undefined") {
+                const result = dpUtils.parse(dpDataIn[addDpCode], addDpReportMap);
+                let hasReport = result.type === unlockMethodConfig.id;
+                if (cfg.strictMode) {
+                    hasReport =
+                        hasReport && result.memberId === lockUserId && result.sn === sn;
+                }
+                if (hasReport) {
+                    if (result.memberId !== lockUserId) {
+                        sdkLog("warn", "unlockMethod", "startReportMemberMismatch", {
+                            devId: rt.devId,
+                            data: { type: params.type },
+                        });
+                    }
+                    if (result.sn !== sn) {
+                        sdkLog("warn", "unlockMethod", "startReportSnMismatch", {
+                            devId: rt.devId,
+                            data: { type: params.type },
+                        });
+                    }
+                    if (result.stage === 0) {
+                        startAddReportMonitoring(result.total);
+                    }
+                    return result;
+                }
+                return false;
+            }
+            sdkLog("warn", "unlockMethod", "startInvalidReport", {
+                devId: rt.devId,
+                data: { type: params.type, dpCode: addDpCode },
+            });
+            return false;
+        },
+    });
+    if (res.stage === 0) {
+        const eventSessionId = startAddReportMonitoring(res.total);
+        sdkLog("info", "unlockMethod", "startAddSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { type: params.type, total: res.total },
+        });
+        releaseAddUnlockMethodEventsAfterStart(eventSessionId);
+        return { total: res.total };
+    }
+    if (res.stage === 0xfd) {
+        const error = getAddUnlockError(res.status);
+        sdkLog("warn", "unlockMethod", "startAddRejected", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { type: params.type, status: res.status },
+            error,
+        });
+        throw error;
+    }
+    const error = getError(1027);
+    sdkLog("warn", "unlockMethod", "startAddUnexpectedStage", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { type: params.type, stage: res.stage },
+        error,
+    });
+    throw error;
+}
+export const cancelAddUnlockMethodForRuntime = parallelOnlyForRuntime(async function cancelAddUnlockMethodForRuntime(rt, params) {
+    const cfg = rt.config;
+    sdkLog("info", "unlockMethod", "cancelAdd", {
+        devId: rt.devId,
+        data: { type: params.type, userId: params.userId },
+    });
+    const { dpData, addDpCode, addDpMap, addDpReportMap, unlockMethodConfig, lockUserId, sn, } = await getUnlockMethodBase(rt, params.type, params.userId);
+    dpData.stage = 0xfe;
+    isCancelAddUnlockMethod = true;
+    await publishDpsForRuntime(rt, {
+        [addDpCode]: dpUtils.format(dpData, addDpMap),
+    }, {
+        checkReport: (dpDataIn) => {
+            if (typeof dpDataIn[addDpCode] !== "undefined") {
+                const result = dpUtils.parse(dpDataIn[addDpCode], addDpReportMap);
+                let hasReport = result.type === unlockMethodConfig.id;
+                if (cfg.strictMode) {
+                    hasReport =
+                        hasReport &&
+                            result.stage === 0xfe &&
+                            result.memberId === lockUserId &&
+                            result.sn === sn;
+                }
+                if (hasReport) {
+                    return result;
+                }
+                sdkLog("warn", "unlockMethod", "cancelInvalidReport", {
+                    devId: rt.devId,
+                    data: { type: params.type },
+                });
+            }
+            return false;
+        },
+    });
+    return;
+});

package/lib/feature/unlock/method/add-method-events.d.ts

@@ -0,0 +1,5 @@
+import type { AddUnlockMethodListener } from "./types";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function getUnlockMethodEvent(runtime: LockDeviceRuntime): string;
+export declare const onAddUnlockMethodForRuntime: (runtime: LockDeviceRuntime, listener: AddUnlockMethodListener) => void;
+export declare const offAddUnlockMethodForRuntime: (runtime: LockDeviceRuntime, listener: AddUnlockMethodListener) => void;

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

@@ -0,0 +1,11 @@
+import emitter from "../../../utils/event";
+import { UNLOCK_METHOD_EVENT } from "../../../utils/constant";
+export function getUnlockMethodEvent(runtime) {
+    return `${UNLOCK_METHOD_EVENT}_${runtime.devId}`;
+}
+export const onAddUnlockMethodForRuntime = (runtime, listener) => {
+    emitter.on(getUnlockMethodEvent(runtime), listener);
+};
+export const offAddUnlockMethodForRuntime = (runtime, listener) => {
+    emitter.off(getUnlockMethodEvent(runtime), listener);
+};