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

package/lib/{capability.js → feature/misc/capability.js}

@@ -1,55 +1,54 @@
-import { getDeviceAdvancedAbility, getProductAbilities } from "./api";
-import config, { hasCapability } from "./config";
-import { ProductCommunicationType } from "./constant";
-import { getDeviceStatus } from "./state";
-import { checkShowMatterMutilpleShare } from "./utils/device";
-let isActiveThreadCache = false;
-export const isActiveThread = async () => {
-    const hasThread = hasCapability(ProductCommunicationType.THREAD);
+import { getDeviceAdvancedAbility, getProductAbilities } from "../../api";
+import { ProductCommunicationType } from "../../constant";
+import { checkShowMatterMutilpleShare } from "../../platform/device";
+export const hasCapabilityForRuntime = (runtime, capability) => runtime.config.communication.includes(capability);
+export const isBlePureDeviceForRuntime = (rt) => hasCapabilityForRuntime(rt, ProductCommunicationType.BLUETOOTH) &&
+    rt.config.communication.length === 1;
+export const isShareTheadForRuntime = (rt) => {
+    const hasThread = hasCapabilityForRuntime(rt, ProductCommunicationType.THREAD);
+    return (hasThread &&
+        !rt.config.devInfo.meta?.["threadWithBLE"] &&
+        !rt.config.devInfo.parentId);
+};
+export const isActiveThreadForRuntime = async (rt) => {
+    const hasThread = hasCapabilityForRuntime(rt, ProductCommunicationType.THREAD);
     if (hasThread) {
-        const deviceStatus = getDeviceStatus();
-        if (deviceStatus.onlineTypes.includes("cloud") ||
-            config.communication.length === 1) {
+        if (rt.deviceStatus.onlineTypes.includes("cloud") ||
+            rt.config.communication.length === 1) {
             return true;
         }
-        const hasBle = hasCapability(ProductCommunicationType.BLUETOOTH);
+        const hasBle = hasCapabilityForRuntime(rt, ProductCommunicationType.BLUETOOTH);
         if (hasBle) {
-            if (isActiveThreadCache) {
+            if (rt.cache.isActiveThreadCache) {
                 return true;
             }
             try {
-                await checkShowMatterMutilpleShare(config.devInfo.devId);
-                isActiveThreadCache = true;
+                await checkShowMatterMutilpleShare(rt.config.devInfo.devId);
+                rt.cache.isActiveThreadCache = true;
                 return true;
             }
-            catch (error) {
+            catch {
                 return false;
             }
         }
     }
     return false;
 };
-export const isShareThead = () => {
-    const hasThread = hasCapability(ProductCommunicationType.THREAD);
-    return (hasThread &&
-        !config.devInfo.meta?.["threadWithBLE"] &&
-        !config.devInfo.parentId);
-};
-let deviceAdvanceAbilityCache;
-export const getDeviceAdvancedAbilities = async () => {
-    if (deviceAdvanceAbilityCache) {
-        return deviceAdvanceAbilityCache;
+export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
+    if (rt.cache.deviceAdvanceAbilityCache) {
+        return rt.cache.deviceAdvanceAbilityCache;
     }
     const [productAbilities, deviceAdvancedAbility] = await Promise.all([
-        getProductAbilities(config.devInfo.devId, [
+        getProductAbilities(rt.config.devInfo.devId, [
             "tyabi4ucx5",
             "tyabis9tpe",
             "tyabiwxrn9",
             "tyabipd4hh",
+            "tyabin4u5v",
         ]),
-        getDeviceAdvancedAbility(config.devInfo.devId),
+        getDeviceAdvancedAbility(rt.config.devInfo.devId),
     ]);
-    deviceAdvanceAbilityCache = {
+    const deviceAdvanceAbilityCache = {
         cloudStorage: {
             support: deviceAdvancedAbility.types.includes(0),
         },
@@ -73,6 +72,10 @@ export const getDeviceAdvancedAbilities = async () => {
             support: false,
             config: {},
         },
+        yuChannel: {
+            support: false,
+            value: 2,
+        },
     };
     productAbilities.forEach((item) => {
         try {
@@ -110,6 +113,12 @@ export const getDeviceAdvancedAbilities = async () => {
                         deviceAdvanceAbilityCache.unlockGuide.config = data;
                         break;
                     }
+                    case "tyabin4u5v": {
+                        deviceAdvanceAbilityCache.yuChannel.support = true;
+                        deviceAdvanceAbilityCache.yuChannel.value =
+                            Number(Object.values(data)[0]) || 2;
+                        break;
+                    }
                 }
             }
         }
@@ -117,5 +126,6 @@ export const getDeviceAdvancedAbilities = async () => {
             console.warn(`setting [${item.abilityCode}] config error`, error);
         }
     });
+    rt.cache.deviceAdvanceAbilityCache = deviceAdvanceAbilityCache;
     return deviceAdvanceAbilityCache;
 };

package/lib/feature/misc/connect-device.d.ts

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

package/lib/feature/misc/connect-device.js

@@ -0,0 +1,206 @@
+import dpCodes from "../../config/dp-code";
+import { connectBLEDevice, getBLEOnlineState, onBleChange, onOnlineChange, offBleChange, offOnlineChange, yuChannelSyncSingleSync, } from "../../platform/device";
+import { DPCHANGE } from "../../utils/constant";
+import emitter from "../../utils/event";
+import { getError } from "../../utils/errors";
+import { ipc } from "../../platform";
+import { getDpValueForRuntime } from "../dp/get-dp-value";
+import { getDeviceStatusForRuntime } from "../state/device-status";
+import { isSupportBleControlForRuntime } from "./ble-control";
+import { sdkLog } from "../../utils/sdk-log";
+const { wirelessAwake } = dpCodes;
+const awakeDevice = async (devId, timeout) => {
+    const startedAt = Date.now();
+    sdkLog("info", "connectDevice", "awakeStart", {
+        devId,
+        data: { timeout: timeout || 15000 },
+    });
+    return new Promise((resolve, reject) => {
+        const handleChangeDp = (dpCodesArg) => {
+            if (dpCodesArg[wirelessAwake] === true) {
+                sdkLog("info", "connectDevice", "awakeReportSuccess", {
+                    devId,
+                    duration: Date.now() - startedAt,
+                });
+                resolve(true);
+                emitter.off(DPCHANGE, handleChangeDp);
+                clearTimeout(timer);
+            }
+        };
+        emitter.on(DPCHANGE, handleChangeDp);
+        const timer = setTimeout(() => {
+            emitter.off(DPCHANGE, handleChangeDp);
+            const error = getError(1002);
+            sdkLog("warn", "connectDevice", "awakeTimeout", {
+                devId,
+                duration: Date.now() - startedAt,
+                error,
+            });
+            reject(error);
+        }, timeout || 15000);
+        const run = async () => {
+            try {
+                ipc.wakeUpDoorBell(devId);
+                ipc.wakeUpDoorBell(devId);
+                ipc.wakeUpDoorBell(devId);
+                const connected = await ipc.isConnected(devId);
+                if (connected.isConnected) {
+                    sdkLog("info", "connectDevice", "awakeAlreadyConnected", {
+                        devId,
+                        duration: Date.now() - startedAt,
+                    });
+                    return resolve(true);
+                }
+                const connecting = await ipc.isConnecting(devId);
+                if (!connecting.isConnecting) {
+                    sdkLog("info", "connectDevice", "awakeIpcConnectStart", { devId });
+                    await ipc.connect(devId);
+                }
+                else {
+                    sdkLog("debug", "connectDevice", "awakeIpcConnecting", { devId });
+                }
+            }
+            catch (error) {
+                sdkLog("error", "connectDevice", "awakeFail", {
+                    devId,
+                    duration: Date.now() - startedAt,
+                    error,
+                });
+                reject(error);
+            }
+        };
+        run();
+    });
+};
+const connectBle = async (devId) => {
+    const startedAt = Date.now();
+    sdkLog("info", "connectDevice", "bleConnectStart", { devId });
+    return new Promise((resolve, reject) => {
+        const handleConnect = () => {
+            const handleStatusChange = ({ deviceId, status }) => {
+                if (deviceId === devId && status === "CONNECTED") {
+                    clearTimer();
+                    sdkLog("info", "connectDevice", "bleStatusConnected", {
+                        devId,
+                        duration: Date.now() - startedAt,
+                    });
+                    resolve(true);
+                }
+            };
+            const handleOnline = ({ deviceId, online }) => {
+                if (deviceId === devId && online) {
+                    clearTimer();
+                    sdkLog("info", "connectDevice", "bleOnline", {
+                        devId,
+                        duration: Date.now() - startedAt,
+                    });
+                    resolve(true);
+                }
+            };
+            onBleChange(handleStatusChange);
+            onOnlineChange(handleOnline);
+            const timer = setTimeout(() => {
+                offBleChange(handleStatusChange);
+                offOnlineChange(handleOnline);
+                const error = getError(1002);
+                sdkLog("warn", "connectDevice", "bleConnectTimeout", {
+                    devId,
+                    duration: Date.now() - startedAt,
+                    error,
+                });
+                reject(error);
+            }, 15000);
+            const clearTimer = () => {
+                clearTimeout(timer);
+                offBleChange(handleStatusChange);
+                offOnlineChange(handleOnline);
+            };
+            connectBLEDevice(devId).catch((e) => {
+                clearTimer();
+                sdkLog("error", "connectDevice", "bleConnectFail", {
+                    devId,
+                    duration: Date.now() - startedAt,
+                    error: e,
+                });
+                reject(e);
+            });
+        };
+        getBLEOnlineState(devId)
+            .then((isBleOnline) => {
+            if (isBleOnline) {
+                sdkLog("info", "connectDevice", "bleAlreadyOnline", {
+                    devId,
+                    duration: Date.now() - startedAt,
+                });
+                resolve(true);
+            }
+            else {
+                handleConnect();
+            }
+        })
+            .catch((e) => {
+            handleConnect();
+        });
+    });
+};
+export async function connectDeviceForRuntime(rt) {
+    const cfg = rt.config;
+    const devId = cfg.devInfo.devId;
+    const deviceStatus = getDeviceStatusForRuntime(rt);
+    const hasWirelessAwakeDp = !!cfg.dpSchema[wirelessAwake];
+    const startedAt = Date.now();
+    sdkLog("info", "connectDevice", "start", {
+        devId,
+        data: {
+            statusType: deviceStatus.type,
+            onlineTypes: deviceStatus.onlineTypes,
+            hasWirelessAwakeDp,
+        },
+    });
+    if (hasWirelessAwakeDp) {
+        if (cfg.devInfo.isCloudOnline && !getDpValueForRuntime(rt, wirelessAwake)) {
+            const result = await awakeDevice(devId);
+            sdkLog("info", "connectDevice", "success", {
+                devId,
+                duration: Date.now() - startedAt,
+                data: { route: "awake" },
+            });
+            return result;
+        }
+    }
+    if (isSupportBleControlForRuntime(rt)) {
+        if (deviceStatus.type === "online" &&
+            deviceStatus.onlineTypes.includes("ble")) {
+            sdkLog("info", "connectDevice", "success", {
+                devId,
+                duration: Date.now() - startedAt,
+                data: { route: "ble_already_online" },
+            });
+            return true;
+        }
+        await connectBle(devId);
+        if (rt.cache.deviceAdvanceAbilityCache?.yuChannel.support) {
+            if (rt.cache.deviceAdvanceAbilityCache?.yuChannel.value === 1) {
+                yuChannelSyncSingleSync(devId);
+            }
+        }
+        else {
+            if (cfg.devInfo.yuNetState === 1) {
+                yuChannelSyncSingleSync(devId);
+            }
+        }
+        sdkLog("info", "connectDevice", "success", {
+            devId,
+            duration: Date.now() - startedAt,
+            data: { route: "ble_connect" },
+        });
+        return true;
+    }
+    const error = getError(1062);
+    sdkLog("warn", "connectDevice", "unsupported", {
+        devId,
+        duration: Date.now() - startedAt,
+        error,
+    });
+    throw error;
+}

package/lib/feature/misc/dp-period.d.ts

@@ -0,0 +1,18 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface ParseDpPeriodTimeResult {
+    start: number;
+    end: number;
+}
+export declare const parseDpPeriodTime: (dpValue: string) => ParseDpPeriodTimeResult;
+export declare const formatDpPeriodTime: (start: number, end: number) => string;
+export interface GetDpPeriodTimeResult {
+    start: number;
+    end: number;
+}
+export declare function getDpPeriodTimeForRuntime(rt: LockDeviceRuntime, dpCode: string): GetDpPeriodTimeResult;
+export declare function updateDpPeriodTimeForRuntime(rt: LockDeviceRuntime, dpCode: string, data: {
+    start: number;
+    end: number;
+}, option?: {
+    offlineDp?: boolean;
+}): Promise<void>;

package/lib/feature/misc/dp-period.js

@@ -0,0 +1,75 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { hasDpForRuntime } from "../dp/has-dp";
+import { getError } from "../../utils/errors";
+import { publishDpsForRuntime } from "../dp/publish-dps";
+import { getOfflineDpCacheForRuntime, publishOfflineDpsForRuntime, } from "../offline-dps";
+import { getDpValueForRuntime } from "../dp/get-dp-value";
+import { getDeviceStatusForRuntime } from "../state/device-status";
+const periodDpMap = [
+    { name: "startHour" },
+    { name: "startMinute" },
+    { name: "endHour" },
+    { name: "endMinute" },
+];
+export const parseDpPeriodTime = (dpValue) => {
+    if (!dpValue) {
+        return {
+            start: 0,
+            end: 0,
+        };
+    }
+    const data = dpUtils.parse(dpValue, periodDpMap);
+    return {
+        start: (data.startHour ?? 0) * 60 + (data.startMinute ?? 0),
+        end: (data.endHour ?? 0) * 60 + (data.endMinute ?? 0),
+    };
+};
+export const formatDpPeriodTime = (start, end) => {
+    const startHour = Math.floor(start / 60);
+    const startMinute = start % 60;
+    const endHour = Math.floor(end / 60);
+    const endMinute = end % 60;
+    return dpUtils.format({
+        startHour,
+        startMinute,
+        endHour,
+        endMinute,
+    }, periodDpMap);
+};
+export function getDpPeriodTimeForRuntime(rt, dpCode) {
+    if (hasDpForRuntime(rt, dpCode)) {
+        const { supportOfflineDps } = rt.config;
+        let dpValue = getDpValueForRuntime(rt, dpCode);
+        if (supportOfflineDps) {
+            const cache = getOfflineDpCacheForRuntime(rt, dpCode);
+            if (cache && cache.pushStatus === false) {
+                dpValue = cache.value;
+            }
+        }
+        return parseDpPeriodTime(dpValue);
+    }
+    return {
+        start: 0,
+        end: 0,
+    };
+}
+export async function updateDpPeriodTimeForRuntime(rt, dpCode, data, option) {
+    const { supportOfflineDps } = rt.config;
+    if (!hasDpForRuntime(rt, dpCode)) {
+        throw getError(1014);
+    }
+    const dpValue = formatDpPeriodTime(data.start, data.end);
+    if (supportOfflineDps) {
+        const deviceStatus = getDeviceStatusForRuntime(rt);
+        if (deviceStatus.type !== "online" && option?.offlineDp) {
+            await publishOfflineDpsForRuntime(rt, {
+                [dpCode]: dpValue,
+            });
+            return;
+        }
+    }
+    await publishDpsForRuntime(rt, {
+        [dpCode]: dpValue,
+    });
+    return;
+}

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

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

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

@@ -0,0 +1,17 @@
+import { ProductCommunicationType } from "../../constant";
+import { isOnlineByType } from "../../utils";
+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);
+    const isSupportThread = hasCapabilityForRuntime(rt, ProductCommunicationType.THREAD);
+    if (isSupportWifi && isSupportBle) {
+        return isBleOnline;
+    }
+    if (isSupportThread && isSupportBle) {
+        return isBleOnline && !devInfo.isCloudOnline && !devInfo.isLocalOnline;
+    }
+    return isBleOnline;
+};

package/lib/feature/misc/open-scene.d.ts

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import type { OpenSceneOptions } from "./types";
+export declare function openSceneForRuntime(rt: LockDeviceRuntime, options?: OpenSceneOptions): Promise<void>;

package/lib/feature/misc/open-scene.js

@@ -0,0 +1,63 @@
+import dpCodes from "../../config/dp-code";
+import { openPanel } from "../../platform/device";
+const { alarmLock, unlockFingerprint, unlockPassword, unlockCard, unlockKey, unlockPhoneRemote, unlockTemporary, unlockDynamic, unlockFace, unlockHand, unlockEye, unlockFingerVein, unlockInside, doorOpened, unlockApp, unlockOfflinePd, openInside, lockRecord, unlockDoubleKit, lockLocalRecord, } = dpCodes;
+const abilityMap = {
+    backHome: "supportBackHome",
+    alarm: "supportAlarm",
+};
+export function openSceneForRuntime(rt, options) {
+    const cfg = rt.config;
+    const dpIds = [
+        unlockFingerprint,
+        unlockPassword,
+        unlockCard,
+        unlockKey,
+        unlockPhoneRemote,
+        unlockTemporary,
+        unlockDynamic,
+        unlockFace,
+        unlockHand,
+        unlockEye,
+        unlockFingerVein,
+        unlockInside,
+        doorOpened,
+        unlockApp,
+        unlockOfflinePd,
+        openInside,
+        lockRecord,
+        unlockDoubleKit,
+        lockLocalRecord,
+    ].reduce((acc, item) => {
+        const id = cfg.idsByCode[item];
+        if (id) {
+            acc.push(id);
+        }
+        return acc;
+    }, []);
+    const { themeColor = "#ff592a", executorRange = ["unlock", "lock"], abilities = [], } = options || {};
+    return new Promise((resolve, reject) => {
+        openPanel({
+            deviceId: cfg.devInfo.devId,
+            extraInfo: {
+                productId: cfg.devInfo.productId,
+                bizClientId: "tyqawbz9jf6oqvynya",
+                productVersion: "1.0.0",
+                i18nTime: "12344",
+                uiType: "SMART_MINIPG",
+            },
+            initialProps: {
+                openDpLists: dpIds.join(","),
+                dpCode: alarmLock,
+                themeColor,
+                withConfig: {
+                    powerCode: {
+                        tyabihqarm: abilities.map((ability) => abilityMap[ability] || ability),
+                        tyabixjkg8: executorRange,
+                    },
+                },
+            },
+            success: () => resolve(),
+            fail: reject,
+        });
+    });
+}

package/lib/feature/misc/signal.d.ts

@@ -0,0 +1,12 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function getWiFiSignalChangeEvent(runtime: LockDeviceRuntime): string;
+export declare function getWiFiSignalForRuntime(rt: LockDeviceRuntime): Promise<void>;
+export declare function getCurrentWiFiSignalForRuntime(rt: LockDeviceRuntime): number | "unknown";
+export interface WiFiSignalChangeParams {
+    signal: number;
+    level: "good" | "normal" | "weak" | "bad";
+    devId?: string;
+}
+export type WiFiSignalChangeListener = (params: WiFiSignalChangeParams) => void;
+export declare const onWiFiSignalChangeForRuntime: (runtime: LockDeviceRuntime, cb: WiFiSignalChangeListener) => void;
+export declare const offWiFiSignalChangeForRuntime: (runtime: LockDeviceRuntime, cb: WiFiSignalChangeListener) => void;

package/lib/feature/misc/signal.js

@@ -0,0 +1,36 @@
+import { sendMqttMessage } from "../../platform/device";
+import { getError } from "../../utils/errors";
+import emitter from "../../utils/event";
+const lastWiFiSignalByDevId = new Map();
+const WIFI_SIGNAL_EVENT = "onWiFiSignalChange";
+export function getWiFiSignalChangeEvent(runtime) {
+    return `${WIFI_SIGNAL_EVENT}_${runtime.devId}`;
+}
+export async function getWiFiSignalForRuntime(rt) {
+    const { devInfo } = rt.config;
+    if (devInfo.isCloudOnline) {
+        await sendMqttMessage({
+            deviceId: devInfo.devId,
+            protocol: 22,
+            message: {
+                reqType: "sigQry",
+            },
+        });
+        return;
+    }
+    throw getError(1001);
+}
+export function getCurrentWiFiSignalForRuntime(rt) {
+    return lastWiFiSignalByDevId.get(rt.devId) ?? "unknown";
+}
+export const onWiFiSignalChangeForRuntime = (runtime, cb) => {
+    emitter.on(getWiFiSignalChangeEvent(runtime), cb);
+};
+export const offWiFiSignalChangeForRuntime = (runtime, cb) => {
+    emitter.off(getWiFiSignalChangeEvent(runtime), cb);
+};
+emitter.on(WIFI_SIGNAL_EVENT, ({ signal, devId }) => {
+    if (devId) {
+        lastWiFiSignalByDevId.set(devId, signal);
+    }
+});

package/lib/feature/misc/sleep.d.ts

@@ -0,0 +1,14 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function isSleepForRuntime(rt: LockDeviceRuntime): boolean;
+export declare function hasSleepAbilityForRuntime(rt: LockDeviceRuntime): boolean;
+export declare const setSleepStatusForRuntime: (rt: LockDeviceRuntime, status: boolean, option?: {
+    offlineDp?: boolean;
+}) => Promise<void>;
+export declare const getSwitchStatusForRuntime: (rt: LockDeviceRuntime) => boolean;
+export interface SleepStatusChangeEvent {
+    sleep: boolean;
+}
+export type SleepStatusListener = (args: SleepStatusChangeEvent) => void;
+export declare function getSleepStatusEvent(runtime: LockDeviceRuntime): string;
+export declare const onSleepStatusChangeForRuntime: (rt: LockDeviceRuntime, callback: SleepStatusListener) => void;
+export declare const offSleepStatusChangeForRuntime: (rt: LockDeviceRuntime, callback: SleepStatusListener) => void;

package/lib/feature/misc/sleep.js

@@ -0,0 +1,66 @@
+import { getDpValueForRuntime } from "../dp/get-dp-value";
+import { hasDpForRuntime } from "../dp/has-dp";
+import { getDeviceStatusForRuntime } from "../state/device-status";
+import { getError } from "../../utils/errors";
+import { publishDpsForRuntime } from "../dp/publish-dps";
+import emitter from "../../utils/event";
+import { SLEEP_EVENT } from "../../utils/constant";
+import dpCodes from "../../config/dp-code";
+import { getOfflineDpCacheForRuntime, publishOfflineDpsForRuntime, } from "../offline-dps";
+export function isSleepForRuntime(rt) {
+    if (!hasDpForRuntime(rt, dpCodes.linkMode)) {
+        return false;
+    }
+    const linkMode = getDpValueForRuntime(rt, dpCodes.linkMode);
+    return linkMode === "sleep" || linkMode === "lock_sleep";
+}
+export function hasSleepAbilityForRuntime(rt) {
+    return (hasDpForRuntime(rt, dpCodes.dormantSwitch) ||
+        hasDpForRuntime(rt, dpCodes.onlineSwitch));
+}
+export const setSleepStatusForRuntime = async (rt, status, option) => {
+    const { supportOfflineDps } = rt.config;
+    if (hasSleepAbilityForRuntime(rt)) {
+        const dpCode = hasDpForRuntime(rt, dpCodes.onlineSwitch)
+            ? dpCodes.onlineSwitch
+            : dpCodes.dormantSwitch;
+        if (supportOfflineDps) {
+            const deviceStatus = getDeviceStatusForRuntime(rt);
+            if (deviceStatus.type !== "online" && option?.offlineDp) {
+                return publishOfflineDpsForRuntime(rt, {
+                    [dpCode]: status,
+                });
+            }
+        }
+        await publishDpsForRuntime(rt, {
+            [dpCode]: status,
+        });
+        return;
+    }
+    throw getError(1014);
+};
+export const getSwitchStatusForRuntime = (rt) => {
+    const { supportOfflineDps } = rt.config;
+    const hasOnlineSwitch = hasDpForRuntime(rt, dpCodes.onlineSwitch);
+    const hasDormantSwitch = hasDpForRuntime(rt, dpCodes.dormantSwitch);
+    if (!hasOnlineSwitch && !hasDormantSwitch) {
+        return false;
+    }
+    const dpCode = hasOnlineSwitch ? dpCodes.onlineSwitch : dpCodes.dormantSwitch;
+    if (supportOfflineDps) {
+        const cache = getOfflineDpCacheForRuntime(rt, dpCode);
+        if (cache && cache.pushStatus === false) {
+            return cache.value;
+        }
+    }
+    return getDpValueForRuntime(rt, dpCode);
+};
+export function getSleepStatusEvent(runtime) {
+    return `${SLEEP_EVENT}_${runtime.devId}`;
+}
+export const onSleepStatusChangeForRuntime = (rt, callback) => {
+    emitter.on(getSleepStatusEvent(rt), callback);
+};
+export const offSleepStatusChangeForRuntime = (rt, callback) => {
+    emitter.off(getSleepStatusEvent(rt), callback);
+};

package/lib/feature/misc/types.d.ts

@@ -0,0 +1,7 @@
+export type ExecutorRange = "unlock" | "lock";
+export type Ability = "backHome" | "alarm" | "geographyArrive" | "geographyLeave" | "bleGeofence" | "siriUnlock" | "siriLock";
+export interface OpenSceneOptions {
+    themeColor?: string;
+    executorRange?: Array<ExecutorRange>;
+    abilities?: Array<Ability>;
+}

package/lib/feature/misc/types.js

@@ -0,0 +1 @@
+export {};

package/lib/feature/misc/update-config.d.ts

@@ -0,0 +1,4 @@
+import type { LockSDKOption } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export type UpdateConfigParams = Omit<LockSDKOption, "devInfo" | "deviceId" | "preFetch">;
+export declare function updateConfigForRuntime(runtime: LockDeviceRuntime, options: UpdateConfigParams): void;

package/lib/feature/misc/update-config.js

@@ -0,0 +1,9 @@
+export function updateConfigForRuntime(runtime, options) {
+    const cfg = runtime.config;
+    Object.keys(options).forEach((key) => {
+        const value = options[key];
+        if (value !== undefined) {
+            cfg[key] = value;
+        }
+    });
+}