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

package/lib/entries/screen/exports/bind-events.d.ts

@@ -0,0 +1,4 @@
+import { type BindLockToScreenEvent, type BindLockToScreenListener } from "../../../feature/screen/bind-watch";
+export type { BindLockToScreenEvent, BindLockToScreenListener };
+export declare function onBindLockToScreen(listener: BindLockToScreenListener): void;
+export declare function offBindLockToScreen(listener: BindLockToScreenListener): void;

package/lib/entries/screen/exports/bind-events.js

@@ -0,0 +1,8 @@
+import { onBindLockToScreenForRuntime, offBindLockToScreenForRuntime, } from "../../../feature/screen/bind-watch";
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+export function onBindLockToScreen(listener) {
+    onBindLockToScreenForRuntime(resolveRuntimeFromExportThis(this), listener);
+}
+export function offBindLockToScreen(listener) {
+    offBindLockToScreenForRuntime(resolveRuntimeFromExportThis(this), listener);
+}

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

@@ -0,0 +1,6 @@
+import type { BindableLockItem, BindableLockListResult, BindingResult, BoundLockItem, BoundLockListResult, UnbindingResult } from "../../../api/screen";
+export type { BindableLockItem, BindableLockListResult, BindingResult, BoundLockItem, BoundLockListResult, UnbindingResult, };
+export declare function getBoundLockList(): Promise<BoundLockListResult>;
+export declare function getBindableLockList(): Promise<BindableLockListResult>;
+export declare function bindLock(lockDevId: string): Promise<BindingResult>;
+export declare function unbindLock(relationId: string): Promise<UnbindingResult>;

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

@@ -0,0 +1,15 @@
+import { getBoundLockListForRuntime, getBindableLockListForRuntime, } from "../../../feature/screen/list";
+import { bindLockForRuntime, unbindLockForRuntime, } from "../../../feature/screen/bind";
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+export function getBoundLockList() {
+    return getBoundLockListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getBindableLockList() {
+    return getBindableLockListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function bindLock(lockDevId) {
+    return bindLockForRuntime(resolveRuntimeFromExportThis(this), lockDevId);
+}
+export function unbindLock(relationId) {
+    return unbindLockForRuntime(resolveRuntimeFromExportThis(this), relationId);
+}

package/lib/entries/screen/exports/device.d.ts

@@ -0,0 +1,16 @@
+import type { WiFiSignalChangeListener } from "../../../feature/misc/signal";
+import { hasDpForRuntime } from "../../../feature/dp/has-dp";
+import type { ProductCommunicationType } from "../../../constant";
+import { type DeviceStatus, type DpValue } from "../../../interface";
+export type { WiFiSignalChangeListener } from "../../../feature/misc/signal";
+export declare function getDeviceStatus(): DeviceStatus;
+export declare function onDeviceStatusChange(callback: (status: DeviceStatus) => void): void;
+export declare function offDeviceStatusChange(callback: (status: DeviceStatus) => void): void;
+export declare function getWiFiSignal(): Promise<void>;
+export declare function onWiFiSignalChange(cb: WiFiSignalChangeListener): void;
+export declare function offWiFiSignalChange(cb: WiFiSignalChangeListener): void;
+export declare function isSupportMedia(): boolean;
+export declare function hasDp(dpCode: string): ReturnType<typeof hasDpForRuntime>;
+export declare function hasCapability(capability: ProductCommunicationType): boolean;
+export declare function publishOfflineDps(dps: Record<string, DpValue>): Promise<void>;
+export declare function getDeviceAdvancedAbilities(): Promise<import("../../../interface").DeviceAdvancedAbility>;

package/lib/entries/screen/exports/device.js

@@ -0,0 +1,41 @@
+import { getDeviceStatusForRuntime } from "../../../feature/state/device-status";
+import { onDeviceStatusChangeForRuntime, offDeviceStatusChangeForRuntime, } from "../../../feature/state/device-status-events";
+import { getWiFiSignalForRuntime, onWiFiSignalChangeForRuntime, offWiFiSignalChangeForRuntime, } from "../../../feature/misc/signal";
+import { isSupportMediaForRuntime } from "../../../feature/media/media";
+import { hasDpForRuntime } from "../../../feature/dp/has-dp";
+import { hasCapabilityForRuntime, getDeviceAdvancedAbilitiesForRuntime, } from "../../../feature/misc/capability";
+import { publishOfflineDpsForRuntime } from "../../../feature/offline-dps";
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+export function getDeviceStatus() {
+    return getDeviceStatusForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function onDeviceStatusChange(callback) {
+    onDeviceStatusChangeForRuntime(resolveRuntimeFromExportThis(this), callback);
+}
+export function offDeviceStatusChange(callback) {
+    offDeviceStatusChangeForRuntime(resolveRuntimeFromExportThis(this), callback);
+}
+export function getWiFiSignal() {
+    return getWiFiSignalForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function onWiFiSignalChange(cb) {
+    onWiFiSignalChangeForRuntime(resolveRuntimeFromExportThis(this), cb);
+}
+export function offWiFiSignalChange(cb) {
+    offWiFiSignalChangeForRuntime(resolveRuntimeFromExportThis(this), cb);
+}
+export function isSupportMedia() {
+    return isSupportMediaForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function hasDp(dpCode) {
+    return hasDpForRuntime(resolveRuntimeFromExportThis(this), dpCode);
+}
+export function hasCapability(capability) {
+    return hasCapabilityForRuntime(resolveRuntimeFromExportThis(this), capability);
+}
+export async function publishOfflineDps(dps) {
+    return publishOfflineDpsForRuntime(resolveRuntimeFromExportThis(this), dps);
+}
+export async function getDeviceAdvancedAbilities() {
+    return getDeviceAdvancedAbilitiesForRuntime(resolveRuntimeFromExportThis(this));
+}

package/lib/entries/screen/exports/event.d.ts

@@ -0,0 +1,3 @@
+import type { ScreenEventItem, ScreenEventListParams, ScreenEventListResult, ScreenEventLogType, ScreenEventType } from "../../../api/screen";
+export type { ScreenEventItem, ScreenEventListParams, ScreenEventListResult, ScreenEventLogType, ScreenEventType, };
+export declare function getEventList(params?: ScreenEventListParams): Promise<ScreenEventListResult>;

package/lib/entries/screen/exports/event.js

@@ -0,0 +1,5 @@
+import { getEventListForRuntime } from "../../../feature/screen/event";
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+export function getEventList(params) {
+    return getEventListForRuntime(resolveRuntimeFromExportThis(this), params);
+}

package/lib/entries/screen/exports/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./binding";
+export * from "./event";
+export * from "./user";
+export * from "./device";
+export * from "./bind-events";

package/lib/entries/screen/exports/index.js

@@ -0,0 +1,5 @@
+export * from "./binding";
+export * from "./event";
+export * from "./user";
+export * from "./device";
+export * from "./bind-events";

package/lib/entries/screen/exports/user.d.ts

@@ -0,0 +1,2 @@
+export declare function getCurrentUser(isForce?: boolean): Promise<import("../../..").CurrentUser>;
+export declare function getCurrentUserSync(): import("../../..").CurrentUser | null;

package/lib/entries/screen/exports/user.js

@@ -0,0 +1,8 @@
+import { getCurrentUserForRuntime } from "../../../feature/user/current-user";
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+export async function getCurrentUser(isForce) {
+    return getCurrentUserForRuntime(resolveRuntimeFromExportThis(this), isForce);
+}
+export function getCurrentUserSync() {
+    return resolveRuntimeFromExportThis(this).cache.currentUser;
+}

package/lib/entries/screen/index.d.ts

@@ -0,0 +1,8 @@
+import type { LockSDKOption } from "../../interface";
+import type { ScreenSDKInstance } from "./build-instance";
+export * from "./exports";
+export type { ScreenSDKInstance };
+export type { ScreenSdkBoundExportThis } from "./bootstrap/resolve-runtime-from-export-this";
+export declare const createScreenSDK: (options?: Omit<LockSDKOption, "preFetch">) => Promise<ScreenSDKInstance>;
+export declare const initScreen: (options?: LockSDKOption) => Promise<void>;
+export declare const destroyScreen: () => void;

package/lib/entries/screen/index.js

@@ -0,0 +1,36 @@
+import { clearStateForRuntime } from "../../feature/state/clear";
+import { removeEvents } from "../../feature/state/platform-routing";
+import { bootstrapRegisteredScreenInstance } from "./bootstrap/bootstrap-lock-instance";
+import { clearPrimaryScreenSDKInstance, setPrimaryScreenSDKInstance, } from "./bootstrap/primary-instance";
+import { clearAllRuntimes, listRegisteredRuntimes, } from "../../runtime/registry";
+import { getLaunchOptionsSync } from "../../platform/device";
+import { getError } from "../../utils/errors";
+export * from "./exports";
+export const createScreenSDK = async (options) => {
+    const { instance } = await bootstrapRegisteredScreenInstance({
+        ...options,
+        preFetch: false,
+    });
+    return instance;
+};
+export const initScreen = async (options) => {
+    const opts = { ...options };
+    const { devInfo, deviceId } = opts;
+    if (!devInfo && !deviceId) {
+        const { query } = getLaunchOptionsSync();
+        opts.deviceId = query.deviceId;
+        if (!opts.deviceId) {
+            throw getError(1000);
+        }
+    }
+    const { instance } = await bootstrapRegisteredScreenInstance(opts);
+    setPrimaryScreenSDKInstance(instance);
+};
+export const destroyScreen = () => {
+    removeEvents();
+    for (const rt of listRegisteredRuntimes()) {
+        clearStateForRuntime(rt);
+    }
+    clearAllRuntimes();
+    clearPrimaryScreenSDKInstance();
+};

package/lib/feature/ai/report.d.ts

@@ -0,0 +1,5 @@
+import type { AIReportPopup } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const isAIReportEnabledForRuntime: (runtime: LockDeviceRuntime) => Promise<boolean>;
+export declare const getAIReportForRuntime: (runtime: LockDeviceRuntime) => Promise<AIReportPopup | null>;
+export declare const acknowledgeAIReportForRuntime: (runtime: LockDeviceRuntime, reportId: string) => Promise<void>;

package/lib/feature/ai/report.js

@@ -0,0 +1,37 @@
+import { fetchAIReportPopup, acknowledgeAIReport as acknowledgeAIReportApi, } from "../../api";
+import { getDeviceProperties } from "../../api/setting";
+import { getDeviceAdvancedAbilitiesForRuntime } from "../misc/capability";
+const LOCK_UNLOCK_REPORT = "LOCK_UNLOCK_REPORT";
+export const isAIReportEnabledForRuntime = async (runtime) => {
+    const ability = await getDeviceAdvancedAbilitiesForRuntime(runtime);
+    const dataReport = !!ability?.ai?.config?.["ai_data_report"];
+    if (!dataReport) {
+        return false;
+    }
+    try {
+        const props = await getDeviceProperties(runtime.devId, [LOCK_UNLOCK_REPORT]);
+        return props?.[LOCK_UNLOCK_REPORT] !== "false";
+    }
+    catch {
+        return false;
+    }
+};
+export const getAIReportForRuntime = async (runtime) => {
+    const enabled = await isAIReportEnabledForRuntime(runtime);
+    if (!enabled) {
+        return null;
+    }
+    try {
+        const res = await fetchAIReportPopup(runtime.devId);
+        return res?.reportId ? res : null;
+    }
+    catch {
+        return null;
+    }
+};
+export const acknowledgeAIReportForRuntime = async (runtime, reportId) => {
+    if (!reportId) {
+        return;
+    }
+    await acknowledgeAIReportApi(runtime.devId, reportId);
+};

package/lib/feature/dp/get-dp-value.d.ts

@@ -0,0 +1,3 @@
+import type { DpValue } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function getDpValueForRuntime(runtime: LockDeviceRuntime, code: string): DpValue | undefined;

package/lib/feature/dp/get-dp-value.js

@@ -0,0 +1,3 @@
+export function getDpValueForRuntime(runtime, code) {
+    return runtime.cache.dpState[code];
+}

package/lib/feature/dp/has-dp.d.ts

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

package/lib/feature/dp/has-dp.js

@@ -0,0 +1 @@
+export const hasDpForRuntime = (runtime, dpCode) => !!runtime.config.dpSchema[dpCode];

package/lib/feature/dp/publish-dps.d.ts

@@ -0,0 +1,7 @@
+import type { DpValue } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const publishDpsOnlyWithRuntime: (runtime: LockDeviceRuntime, dpData: Record<string, string | number | boolean>) => Promise<void>;
+export declare const publishDpsForRuntime: (runtime: LockDeviceRuntime, dpData: Record<string, DpValue>, option?: {
+    timeout?: number;
+    checkReport?: (dps: Record<string, unknown>) => boolean | Record<string, unknown>;
+}) => Promise<Record<string, DpValue>>;

package/lib/feature/dp/publish-dps.js

@@ -0,0 +1,155 @@
+import { DPCHANGE } from "../../utils/constant";
+import emitter from "../../utils/event";
+import { getError } from "../../utils/errors";
+import { isOnlineByType } from "../../utils";
+import { isYuDeviceOnlineSync, publishDeviceDps } from "../../platform";
+import { sdkLog } from "../../utils/sdk-log";
+export const publishDpsOnlyWithRuntime = async (runtime, dpData) => {
+    if (runtime.deviceStatus.type === "offline") {
+        const error = getError(1001);
+        sdkLog("warn", "dp", "publishOffline", {
+            devId: runtime.devId,
+            data: { codes: Object.keys(dpData) },
+            error,
+        });
+        throw error;
+    }
+    const option = {};
+    if (runtime.deviceStatus.isWifiMatter &&
+        runtime.deviceStatus.onlineTypes.includes("cloud")) {
+        option.pipelines = [1];
+    }
+    if (isOnlineByType(runtime.config.onlineType, 2)) {
+        if (runtime.cache.deviceAdvanceAbilityCache?.yuChannel.support) {
+            const isYuOnline = isYuDeviceOnlineSync(runtime.config.devInfo.devId);
+            option.pipelines = [isYuOnline ? 12 : 3];
+        }
+        else {
+            option.pipelines = [3];
+        }
+    }
+    const { devInfo: { devId }, idsByCode, } = runtime.config;
+    const dps = Object.keys(dpData).reduce((acc, key) => {
+        const id = idsByCode[key];
+        if (id) {
+            acc[id] = dpData[key];
+        }
+        return acc;
+    }, {});
+    if (Object.keys(dps).length > 0) {
+        const startedAt = Date.now();
+        sdkLog("info", "dp", "publish", {
+            devId,
+            data: {
+                codes: Object.keys(dpData),
+                pipelines: option.pipelines,
+            },
+        });
+        try {
+            await publishDeviceDps({
+                deviceId: devId,
+                dps,
+                ...option,
+            });
+            sdkLog("debug", "dp", "publishSuccess", {
+                devId,
+                duration: Date.now() - startedAt,
+                data: {
+                    codes: Object.keys(dpData),
+                    pipelines: option.pipelines,
+                },
+            });
+        }
+        catch (error) {
+            sdkLog("error", "dp", "publishFail", {
+                devId,
+                duration: Date.now() - startedAt,
+                data: {
+                    codes: Object.keys(dpData),
+                    pipelines: option.pipelines,
+                },
+                error,
+            });
+            throw error;
+        }
+    }
+};
+export const publishDpsForRuntime = async (runtime, dpData, option) => {
+    const { timeout = 15000, checkReport } = option || {};
+    const startedAt = Date.now();
+    return new Promise((resolve, reject) => {
+        const codes = Object.keys(dpData);
+        const result = {};
+        const handleChangeDp = (dpCodes) => {
+            if (checkReport) {
+                const pass = checkReport(dpCodes);
+                if (pass) {
+                    emitter.off(DPCHANGE, handleChangeDp);
+                    clearTimeout(timer);
+                    sdkLog("debug", "dp", "reportMatched", {
+                        devId: runtime.devId,
+                        duration: Date.now() - startedAt,
+                        data: {
+                            codes: Object.keys(dpData),
+                            reportCodes: Object.keys(dpCodes),
+                        },
+                    });
+                    resolve(typeof pass !== "boolean"
+                        ? pass
+                        : dpCodes);
+                }
+            }
+            else {
+                Object.keys(dpCodes).forEach((code) => {
+                    const eixst = codes.indexOf(code);
+                    if (eixst > -1) {
+                        codes.splice(eixst, 1)[0];
+                        result[code] = dpCodes[code];
+                    }
+                });
+                if (codes.length === 0) {
+                    emitter.off(DPCHANGE, handleChangeDp);
+                    clearTimeout(timer);
+                    sdkLog("debug", "dp", "reportMatched", {
+                        devId: runtime.devId,
+                        duration: Date.now() - startedAt,
+                        data: {
+                            codes: Object.keys(dpData),
+                            reportCodes: Object.keys(dpCodes),
+                        },
+                    });
+                    resolve(result);
+                }
+            }
+        };
+        const timer = setTimeout(() => {
+            emitter.off(DPCHANGE, handleChangeDp);
+            const error = getError(1002);
+            sdkLog("warn", "dp", "reportTimeout", {
+                devId: runtime.devId,
+                duration: Date.now() - startedAt,
+                data: {
+                    codes: Object.keys(dpData),
+                    timeout,
+                },
+                error,
+            });
+            reject(error);
+        }, timeout);
+        emitter.on(DPCHANGE, handleChangeDp);
+        publishDpsOnlyWithRuntime(runtime, dpData).catch((e) => {
+            emitter.off(DPCHANGE, handleChangeDp);
+            clearTimeout(timer);
+            reject(e);
+            sdkLog("error", "dp", "publishDps", {
+                devId: runtime.devId,
+                duration: Date.now() - startedAt,
+                data: {
+                    codes: Object.keys(dpData),
+                    timeout,
+                },
+                error: e,
+            });
+        });
+    });
+};

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

@@ -0,0 +1,6 @@
+import { type BoundFitLockItem, type LockFitItemBase } from "../../api/fit";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function getBoundFitListForRuntime(runtime: LockDeviceRuntime): Promise<BoundFitLockItem[]>;
+export declare function getUnbindFitListForRuntime(runtime: LockDeviceRuntime): Promise<import("../../api/fit").UnbindFitItem[]>;
+export declare function bindFitToLockForRuntime(runtime: LockDeviceRuntime, fit: LockFitItemBase): Promise<unknown>;
+export declare function unbindFitToLockForRuntime(runtime: LockDeviceRuntime, fit: BoundFitLockItem): Promise<unknown>;

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

@@ -0,0 +1,222 @@
+import { bindLockAndFit, getBoundFitListApi, getUnbindFitListApi, unbindFitFromLockCloud, unbindLockFromFitCloud, } from "../../api/fit";
+import { getUsersSyncLockData } from "../../api/user";
+import dpCodes from "../../config/dp-code";
+import { getBLEOnlineState } from "../../platform/device";
+import { DPCHANGE } from "../../utils/constant";
+import emitter from "../../utils/event";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+import { publishDpsOnlyWithRuntime } from "../dp/publish-dps";
+import { FIT_BIND_TIMEOUT_MS, FIT_OPERATION_CODE, normalizeHex, buildLockCheckCodeTemplate, publishFitTransparentFlow, } from "./shared";
+const delay = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+export async function getBoundFitListForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "getBoundFitListStart", {
+        devId: runtime.devId,
+    });
+    const list = await getBoundFitListApi(runtime.devId);
+    sdkLog("info", "fit", "getBoundFitListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: Array.isArray(list) ? list.length : 0 },
+    });
+    return list;
+}
+export async function getUnbindFitListForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "getUnbindFitListStart", {
+        devId: runtime.devId,
+    });
+    const list = await getUnbindFitListApi(runtime.devId);
+    sdkLog("info", "fit", "getUnbindFitListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: Array.isArray(list) ? list.length : 0 },
+    });
+    return list;
+}
+function parseLockCheckCodeReport(raw) {
+    const hex = normalizeHex(raw).toLowerCase();
+    if (hex.length < 32) {
+        throw getError(1051);
+    }
+    return {
+        operation: hex.slice(24, 26),
+        targetMasterId: hex.slice(26, 30),
+        result: hex.slice(30, 32),
+    };
+}
+function waitLockCheckCodeResult(params) {
+    const { expectedOperation, timeout = FIT_BIND_TIMEOUT_MS } = params;
+    return new Promise((resolve, reject) => {
+        const onDp = (dps) => {
+            const raw = dps[dpCodes.checkCodeSet];
+            if (typeof raw !== "string") {
+                return;
+            }
+            let report;
+            try {
+                report = parseLockCheckCodeReport(raw);
+            }
+            catch {
+                return;
+            }
+            if (report.operation !== expectedOperation) {
+                return;
+            }
+            if (report.result === "00" && report.targetMasterId !== "ffff") {
+                clearTimeout(timer);
+                emitter.off(DPCHANGE, onDp);
+                resolve();
+                return;
+            }
+            clearTimeout(timer);
+            emitter.off(DPCHANGE, onDp);
+            reject(getError(1004));
+        };
+        const timer = setTimeout(() => {
+            emitter.off(DPCHANGE, onDp);
+            reject(getError(1002));
+        }, timeout);
+        emitter.on(DPCHANGE, onDp);
+    });
+}
+async function publishFitTransparent(runtime, operation, fit) {
+    sdkLog("info", "fit", "publishTransparentStart", {
+        devId: runtime.devId,
+        data: { operation, fittingId: fit.fittingId },
+    });
+    if (!(await getBLEOnlineState(fit.fittingId)) && fit.online) {
+        const error = getError(1013);
+        sdkLog("warn", "fit", "publishTransparentOffline", {
+            devId: runtime.devId,
+            data: { operation, fittingId: fit.fittingId },
+            error,
+        });
+        throw error;
+    }
+    await publishFitTransparentFlow(fit.fittingId, runtime.devId, operation, fit);
+    sdkLog("info", "fit", "publishTransparentSuccess", {
+        devId: runtime.devId,
+        data: { operation, fittingId: fit.fittingId },
+    });
+}
+async function publishLockCheckCode(runtime, operation, fit) {
+    sdkLog("info", "fit", "publishLockCheckCodeStart", {
+        devId: runtime.devId,
+        data: { operation, fittingId: fit.fittingId },
+    });
+    const { lockRandom } = await getUsersSyncLockData(runtime.devId);
+    const template = buildLockCheckCodeTemplate(operation, fit);
+    const payload = `${template.slice(0, 8)}${lockRandom.ins}${template.slice(8)}`;
+    const waitResult = waitLockCheckCodeResult({
+        expectedOperation: FIT_OPERATION_CODE[operation],
+    });
+    if (lockRandom.distributed) {
+        await delay(1000);
+        await publishDpsOnlyWithRuntime(runtime, {
+            [dpCodes.checkCodeSet]: lockRandom.wakeUpIns,
+        });
+        await delay(1000);
+    }
+    await publishDpsOnlyWithRuntime(runtime, {
+        [dpCodes.checkCodeSet]: payload,
+    });
+    await waitResult;
+    sdkLog("info", "fit", "publishLockCheckCodeSuccess", {
+        devId: runtime.devId,
+        data: { operation, fittingId: fit.fittingId },
+    });
+}
+export async function bindFitToLockForRuntime(runtime, fit) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "bindFitToLockStart", {
+        devId: runtime.devId,
+        data: { fittingId: fit.fittingId },
+    });
+    try {
+        await publishFitTransparent(runtime, "bind", fit);
+        await bindLockAndFit({
+            devId: runtime.devId,
+            fittingId: fit.fittingId,
+            stage: 1,
+        });
+        sdkLog("info", "fit", "bindFitToLockStage1Success", {
+            devId: runtime.devId,
+            data: { fittingId: fit.fittingId },
+        });
+        await publishLockCheckCode(runtime, "bind", fit);
+        const result = await bindLockAndFit({
+            devId: runtime.devId,
+            fittingId: fit.fittingId,
+            stage: 2,
+        });
+        sdkLog("info", "fit", "bindFitToLockSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { fittingId: fit.fittingId },
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fit", "bindFitToLockFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { fittingId: fit.fittingId },
+            error,
+        });
+        throw error;
+    }
+}
+export async function unbindFitToLockForRuntime(runtime, fit) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "unbindFitToLockStart", {
+        devId: runtime.devId,
+        data: { fittingId: fit.fittingId, bindingId: fit.bindingId },
+    });
+    try {
+        const fitBleOnline = await getBLEOnlineState(fit.fittingId);
+        if (fitBleOnline) {
+            await publishFitTransparent(runtime, "unbind", fit);
+            await unbindLockFromFitCloud({
+                fittingId: fit.fittingId,
+                bindingId: fit.bindingId,
+            });
+            sdkLog("info", "fit", "unbindFitToLockStage1Success", {
+                devId: runtime.devId,
+                data: { fittingId: fit.fittingId, bindingId: fit.bindingId },
+            });
+        }
+        else if (fit.online) {
+            throw getError(1013);
+        }
+        else {
+            sdkLog("info", "fit", "unbindFitToLockSkipFitBle", {
+                devId: runtime.devId,
+                data: { fittingId: fit.fittingId, bindingId: fit.bindingId },
+            });
+        }
+        await publishLockCheckCode(runtime, "unbind", fit);
+        const result = await unbindFitFromLockCloud({
+            devId: runtime.devId,
+            bindingId: fit.bindingId,
+        });
+        sdkLog("info", "fit", "unbindFitToLockSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { fittingId: fit.fittingId, bindingId: fit.bindingId },
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fit", "unbindFitToLockFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { fittingId: fit.fittingId, bindingId: fit.bindingId },
+            error,
+        });
+        throw error;
+    }
+}

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

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