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

package/lib/feature/media/media.js

@@ -0,0 +1,66 @@
+import { getMediaUrl as getMediaUrlApi } from "../../api/log";
+import { hasDpForRuntime } from "../dp/has-dp";
+import dpCodes from "../../config/dp-code";
+import { RotateType, VedioType } from "../../constant";
+import { isSupportShortLink } from "../../platform";
+import { getError } from "../../utils/errors";
+export const getMediaUrlForRuntime = async (runtime, params) => {
+    const devId = runtime.config.devInfo.devId;
+    if ("mediaPath" in params && "mediaBucket" in params) {
+        return getMediaUrlApi({
+            devId,
+            mediaPath: params.mediaPath,
+            mediaBucket: params.mediaBucket,
+        });
+    }
+    throw new Error("Invalid parameters");
+};
+export const isSupportMediaForRuntime = (runtime) => {
+    return (hasDpForRuntime(runtime, dpCodes.initiativeMessage) &&
+        (!hasDpForRuntime(runtime, dpCodes.deviceInfo) ||
+            runtime.config.capabilities === null ||
+            runtime.config.capabilities?.vedioType === VedioType.VEDIO_OR_SNAPSHOT));
+};
+export const openLocalAlbumForRuntime = async (runtime, params) => {
+    const link = await isSupportShortLink("ipc_album_panel");
+    if (link) {
+        let url = `tuyaSmart://${link}?extra_camera_uuid=${runtime.devId}&devId=${runtime.devId}`;
+        if (params) {
+            Object.keys(params).forEach((key) => {
+                const value = params[key];
+                if (value !== undefined) {
+                    if (key === "title") {
+                        url += `&ipc_album_nav_title=${value}`;
+                    }
+                    else {
+                        url += `&${key}=${value}`;
+                    }
+                }
+            });
+        }
+        return new Promise((resolve, reject) => {
+            ty.router({
+                url: url,
+                success: () => {
+                    resolve();
+                },
+                fail: (e) => {
+                    reject(e);
+                },
+            });
+        });
+    }
+    return Promise.reject(getError(1013));
+};
+export const getMediaInfoForRuntime = (runtime) => {
+    const isSEI = runtime.config.capabilities?.rotateType === RotateType.SEI;
+    return {
+        imageAngle: isSEI ? 0 : runtime.config.imageAngle,
+        videoAngle: isSEI ? 0 : runtime.config.videoAngle,
+        mediaWidth: runtime.config.mediaWidth,
+        mediaHeight: runtime.config.mediaHeight,
+        isSEI,
+        supportTalk: runtime.config.supportTalk,
+        isTwoWayTalk: runtime.config.isTwoWayTalk,
+    };
+};

package/lib/feature/media/rotate.d.ts

@@ -0,0 +1,6 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface MediaRotate {
+    imageAngle: number;
+    videoAngle: number;
+}
+export declare const getMediaRotateForRuntime: (runtime: LockDeviceRuntime) => MediaRotate;

package/lib/feature/media/rotate.js

@@ -0,0 +1,6 @@
+export const getMediaRotateForRuntime = (runtime) => {
+    return {
+        imageAngle: runtime.config.imageAngle,
+        videoAngle: runtime.config.videoAngle,
+    };
+};

package/lib/feature/misc/ble-control.d.ts

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

package/lib/feature/misc/ble-control.js

@@ -0,0 +1,38 @@
+import { hasCapabilityForRuntime } from "./capability";
+import { hasDpForRuntime } from "../dp/has-dp";
+import dpCodes from "../../config/dp-code";
+import { ProductCommunicationType } from "../../constant";
+export const isSupportBleControlForRuntime = (rt) => {
+    const { devInfo } = rt.config;
+    const hasThread = hasCapabilityForRuntime(rt, ProductCommunicationType.THREAD);
+    const hasWifi = hasCapabilityForRuntime(rt, ProductCommunicationType.WIFI);
+    const hasBle = hasCapabilityForRuntime(rt, ProductCommunicationType.BLUETOOTH);
+    if (!hasBle) {
+        return false;
+    }
+    if (hasWifi && hasBle) {
+        if (!hasDpForRuntime(rt, dpCodes.unlockBle)) {
+            return false;
+        }
+        if (devInfo.wifiEnableState === 1) {
+            return true;
+        }
+    }
+    if (hasThread && hasBle) {
+        if (!devInfo?.meta?.["threadWithBLE"]) {
+            return false;
+        }
+    }
+    const bleControlDp = rt.config.idsByCode[dpCodes.bleControl];
+    if (bleControlDp) {
+        const reportTIme = devInfo?.dpsTime?.[bleControlDp];
+        const hasReportTime = !reportTIme ||
+            Math.floor(Number(reportTIme) / 1000) <= devInfo.activeTime;
+        const bleVal = rt.cache.dpState[dpCodes.bleControl];
+        if (!bleVal || !hasReportTime) {
+            return true;
+        }
+        return bleVal;
+    }
+    return hasBle;
+};

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

@@ -0,0 +1,8 @@
+import { ProductCommunicationType } from "../../constant";
+import { DeviceAdvancedAbility } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const hasCapabilityForRuntime: (runtime: LockDeviceRuntime, capability: ProductCommunicationType) => boolean;
+export declare const isBlePureDeviceForRuntime: (rt: LockDeviceRuntime) => boolean;
+export declare const isShareTheadForRuntime: (rt: LockDeviceRuntime) => boolean;
+export declare const isActiveThreadForRuntime: (rt: LockDeviceRuntime) => Promise<boolean>;
+export declare const getDeviceAdvancedAbilitiesForRuntime: (rt: LockDeviceRuntime) => Promise<DeviceAdvancedAbility>;

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;