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

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;
+        }
+    });
+}

package/lib/feature/misc/validate-pwd.d.ts

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

package/lib/feature/misc/validate-pwd.js

@@ -0,0 +1,10 @@
+import { encrypt } from "../../platform/device";
+import { validatePasswordComplexity } from "../../api/lock";
+export async function validatePwdComplexityForRuntime(rt, password) {
+    const devId = rt.config.devInfo.devId;
+    const encryptedPassword = await encrypt(devId, password);
+    return validatePasswordComplexity({
+        devId,
+        password: encryptedPassword,
+    });
+}

package/lib/feature/misc/yu-channel.d.ts

@@ -0,0 +1,6 @@
+import { LockDeviceRuntime } from "../../runtime";
+export declare const isSupportYuChannelForRuntime: (rt: LockDeviceRuntime) => 0 | 1 | 2;
+export declare const isYuChannelOnlineForRuntime: (rt: LockDeviceRuntime) => boolean;
+export declare const updateYuChannelStateForRuntime: (rt: LockDeviceRuntime, enabled: boolean) => Promise<void>;
+export declare const getYuChannelStateForRuntime: (rt: LockDeviceRuntime) => boolean;
+export declare const getYuChannelNodesForRuntime: (rt: LockDeviceRuntime) => Promise<string[]>;

package/lib/feature/misc/yu-channel.js

@@ -0,0 +1,26 @@
+import { isYuDeviceOnlineSync, yuChannelQueryNodes, yuChannelSaveState, } from "../../platform";
+export const isSupportYuChannelForRuntime = (rt) => {
+    if (rt.cache.deviceAdvanceAbilityCache?.yuChannel.support) {
+        return rt.cache.deviceAdvanceAbilityCache?.yuChannel.value;
+    }
+    return 0;
+};
+export const isYuChannelOnlineForRuntime = (rt) => {
+    return isYuDeviceOnlineSync(rt.config.devInfo.devId);
+};
+export const updateYuChannelStateForRuntime = async (rt, enabled) => {
+    await yuChannelSaveState(rt.config.devInfo.devId, enabled);
+    rt.config.devInfo.yuNetState = enabled ? 1 : 0;
+};
+export const getYuChannelStateForRuntime = (rt) => {
+    if (rt.cache.deviceAdvanceAbilityCache?.yuChannel.support) {
+        if (rt.cache.deviceAdvanceAbilityCache?.yuChannel.value === 1) {
+            return true;
+        }
+        return rt.config.devInfo.yuNetState === 1;
+    }
+    return false;
+};
+export const getYuChannelNodesForRuntime = (rt) => {
+    return yuChannelQueryNodes(rt.config.devInfo.devId);
+};

package/lib/feature/offline-dps/index.d.ts

@@ -0,0 +1,10 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import { DpValue, OfflineDps } from "../../interface";
+export declare function getOfflineDpsUpdateEvent(runtime: LockDeviceRuntime): string;
+export declare const getOfflineDpsForRuntime: (runtime: LockDeviceRuntime, isForce?: boolean) => Promise<OfflineDps>;
+export declare const checkOfflineDpUpdateForRuntime: (runtime: LockDeviceRuntime, dps: Record<string, DpValue> | undefined, isForce?: boolean) => Promise<void>;
+export declare const getOfflineDpCacheForRuntime: (runtime: LockDeviceRuntime, code: string) => import("../../interface").OfflineDpInfo | undefined;
+export declare const publishOfflineDpsForRuntime: (runtime: LockDeviceRuntime, dps: Record<string, DpValue>) => Promise<void>;
+export declare const clearOfflineDpsForRuntime: (runtime: LockDeviceRuntime) => Promise<void>;
+export declare const onOfflineDpsUpdateForRuntime: (runtime: LockDeviceRuntime, callback: (dps: OfflineDps) => void) => void;
+export declare const offOfflineDpsUpdateForRuntime: (runtime: LockDeviceRuntime, callback: (dps: OfflineDps) => void) => void;

package/lib/feature/offline-dps/index.js

@@ -0,0 +1,133 @@
+import { clearOfflineDpData, fetchOfflineDpData, publishOfflineDpData, } from "../../api";
+import base64ToHex from "../../utils/base64-to-hex";
+import hexToBase64 from "../../utils/hex-to-base64";
+import emitter from "../../utils/event";
+import { sdkLog } from "../../utils/sdk-log";
+const OFFLINE_DPS_UPDATE = "offline_dps_update";
+export function getOfflineDpsUpdateEvent(runtime) {
+    return `${OFFLINE_DPS_UPDATE}_${runtime.devId}`;
+}
+export const getOfflineDpsForRuntime = async (runtime, isForce) => {
+    if (!isForce && runtime.cache.offlineDpCache) {
+        sdkLog("debug", "offlineDps", "cacheHit", {
+            devId: runtime.devId,
+            data: { count: Object.keys(runtime.cache.offlineDpCache).length },
+        });
+        return runtime.cache.offlineDpCache;
+    }
+    const { devInfo, dpSchema } = runtime.config;
+    const startedAt = Date.now();
+    sdkLog("info", "offlineDps", "fetchStart", {
+        devId: runtime.devId,
+        data: { force: !!isForce },
+    });
+    const res = await fetchOfflineDpData(devInfo.devId);
+    const result = res.reduce((acc, item) => {
+        const dps = JSON.parse(item.dps);
+        Object.keys(dps).forEach((code) => {
+            const schema = dpSchema[code];
+            let value = dps[code];
+            if (schema?.type === "raw") {
+                value = base64ToHex(value);
+            }
+            acc[code] = { value, pushStatus: item.pushStatus };
+        });
+        return acc;
+    }, {});
+    runtime.cache.offlineDpCache = result;
+    sdkLog("info", "offlineDps", "fetchSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: {
+            count: Object.keys(result).length,
+            cloudCount: res.length,
+            force: !!isForce,
+        },
+    });
+    return result;
+};
+export const checkOfflineDpUpdateForRuntime = async (runtime, dps, isForce) => {
+    const dpMap = dps ?? {};
+    if (!runtime.config.supportOfflineDps) {
+        return;
+    }
+    const cache = runtime.cache.offlineDpCache;
+    const hasOne = Object.keys(dpMap).some((code) => cache?.[code]?.pushStatus === false);
+    if (hasOne || isForce) {
+        const res = await getOfflineDpsForRuntime(runtime, true);
+        sdkLog("debug", "offlineDps", "emitUpdate", {
+            devId: runtime.devId,
+            data: { count: Object.keys(res).length, force: !!isForce },
+        });
+        emitter.emit(getOfflineDpsUpdateEvent(runtime), res);
+    }
+};
+export const getOfflineDpCacheForRuntime = (runtime, code) => {
+    return runtime.cache.offlineDpCache?.[code];
+};
+export const publishOfflineDpsForRuntime = async (runtime, dps) => {
+    const { devInfo, dpSchema } = runtime.config;
+    const startedAt = Date.now();
+    const dpData = Object.keys(dps).reduce((acc, code) => {
+        const schema = dpSchema[code];
+        if (schema) {
+            let value = dps[code];
+            if (schema.type === "raw") {
+                value = hexToBase64(value);
+            }
+            acc[schema.id] = value;
+        }
+        return acc;
+    }, {});
+    sdkLog("info", "offlineDps", "publishStart", {
+        devId: runtime.devId,
+        data: { codes: Object.keys(dps), count: Object.keys(dpData).length },
+    });
+    try {
+        await publishOfflineDpData(devInfo.devId, dpData);
+        await checkOfflineDpUpdateForRuntime(runtime, {}, true);
+        sdkLog("info", "offlineDps", "publishSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { codes: Object.keys(dps), count: Object.keys(dpData).length },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "offlineDps", "publishFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { codes: Object.keys(dps), count: Object.keys(dpData).length },
+            error,
+        });
+        throw error;
+    }
+};
+export const clearOfflineDpsForRuntime = async (runtime) => {
+    const { devInfo } = runtime.config;
+    const startedAt = Date.now();
+    sdkLog("info", "offlineDps", "clearStart", {
+        devId: runtime.devId,
+    });
+    try {
+        await clearOfflineDpData(devInfo.devId);
+        await checkOfflineDpUpdateForRuntime(runtime, {}, true);
+        sdkLog("info", "offlineDps", "clearSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+        });
+    }
+    catch (error) {
+        sdkLog("error", "offlineDps", "clearFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw error;
+    }
+};
+export const onOfflineDpsUpdateForRuntime = (runtime, callback) => {
+    emitter.on(getOfflineDpsUpdateEvent(runtime), callback);
+};
+export const offOfflineDpsUpdateForRuntime = (runtime, callback) => {
+    emitter.off(getOfflineDpsUpdateEvent(runtime), callback);
+};

package/lib/feature/password/ble-temp-payload.d.ts

@@ -0,0 +1,3 @@
+import { SyncTempPwdItem } from "../../api/temp";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function buildBleTempPwdSyncPayload(runtime: LockDeviceRuntime, pwdList: SyncTempPwdItem[]): Promise<string>;

package/lib/{sync → feature/password}/ble-temp-payload.js

@@ -1,7 +1,6 @@
-import config from "../config";
-import { formatWeek, parseWeek } from "../utils";
-import { bytesToHex, concatBytes, uintToBytesBE } from "../utils/byte";
-import { decrypt } from "../utils/device";
+import { formatWeek, parseWeek } from "../../utils";
+import { bytesToHex, concatBytes, uintToBytesBE } from "../../utils/byte";
+import { decrypt } from "../../platform/device";
 const SUB_CMD = 0x2003;
 const PROTO_VERSION = 0x01;
 const DATA_TYPE_TEMP_PWD = 0x01;
@@ -41,18 +40,18 @@ function mapState(phase) {
     }
     return 0x01;
 }
-async function resolvePwdBytes(password) {
+async function resolvePwdBytes(devId, password) {
     if (!password) {
         return [];
     }
-    const plainPwd = await decrypt(config.devInfo.devId, password);
+    const plainPwd = await decrypt(devId, password);
     return plainPwd.split("").map((char) => Number(char));
 }
-async function buildItemBody(item, opCode) {
+async function buildItemBody(devId, item, opCode) {
     if (opCode === OP_DEL) {
         return uintToBytesBE(item.sn, 2);
     }
-    const pwdBytes = await resolvePwdBytes(item.password);
+    const pwdBytes = await resolvePwdBytes(devId, item.password);
     const state = mapState(item.phase);
     const timeSet = buildTimeSet(item);
     const availTime = mapAvailTime(item.availTime);
@@ -74,14 +73,15 @@ function cloudOptToOpCode(opt) {
             return null;
     }
 }
-export async function buildBleTempPwdSyncPayload(pwdList) {
+export async function buildBleTempPwdSyncPayload(runtime, pwdList) {
+    const devId = runtime.config.devInfo.devId;
     const items = [];
     for (const item of pwdList) {
         const opCode = cloudOptToOpCode(item.opt);
         if (opCode === null) {
             continue;
         }
-        const body = await buildItemBody(item, opCode);
+        const body = await buildItemBody(devId, item, opCode);
         items.push(concatBytes(new Uint8Array([opCode]), uintToBytesBE(body.length, 2), body));
     }
     const itemsBuf = concatBytes(...items);

package/lib/feature/password/sync-temp.d.ts

@@ -0,0 +1,4 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const notifyBleSyncRequest: (runtime: LockDeviceRuntime) => Promise<void>;
+export declare const autoSyncTemp: (runtime: LockDeviceRuntime) => void;
+export declare const handleBleSyncRequestReport: (runtime: LockDeviceRuntime, rawValue: string) => Promise<void>;

package/lib/feature/password/sync-temp.js

@@ -0,0 +1,91 @@
+import { getSyncTempPasswords } from "../../api/temp";
+import dpCodes from "../../config/dp-code";
+import { bleSyncRequestPublish as bleSyncRequestPublishMap, bleSyncRequestReport as bleSyncRequestReportMap, } from "../../config/dp-map/ble-sync";
+import { isUseNearChannelForRuntime } from "../misc/is-use-near-channel-for-runtime";
+import { hasDpForRuntime } from "../dp/has-dp";
+import { publishDpsOnlyWithRuntime } from "../dp/publish-dps";
+import { publishBLETransparentData } from "../../platform/device";
+import { buildBleTempPwdSyncPayload } from "./ble-temp-payload";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { sdkLog } from "../../utils/sdk-log";
+const NOTIFY_DEBOUNCE_MS = 2000;
+const CMD_REQUEST_SYNC = 0x01;
+const DATA_TYPE_TEMP_PWD = 0x01;
+const isBleSyncEligible = (runtime) => isUseNearChannelForRuntime(runtime) &&
+    hasDpForRuntime(runtime, dpCodes.bleSyncRequest);
+export const notifyBleSyncRequest = async (runtime) => {
+    if (!isBleSyncEligible(runtime)) {
+        return;
+    }
+    const { count } = await getSyncTempPasswords({
+        devId: runtime.config.devInfo.devId,
+        isUpt: false,
+    });
+    await publishDpsOnlyWithRuntime(runtime, {
+        [dpCodes.bleSyncRequest]: dpUtils.format({ cmd: count > 0 ? 0x01 : 0x00 }, bleSyncRequestPublishMap),
+    });
+    sdkLog("info", "tempPassword", "bleSyncNotify", {
+        devId: runtime.devId,
+        data: { hasPending: count > 0 },
+    });
+};
+export const autoSyncTemp = (runtime) => {
+    if (!isBleSyncEligible(runtime) || !runtime.sync.tempAutoSyncEnabled) {
+        sdkLog("debug", "tempPassword", "autoSyncSkipped", {
+            devId: runtime.devId,
+            data: {
+                nearChannel: isUseNearChannelForRuntime(runtime),
+                hasDp: hasDpForRuntime(runtime, dpCodes.bleSyncRequest),
+                enabled: runtime.sync.tempAutoSyncEnabled,
+            },
+        });
+        return;
+    }
+    clearTimeout(runtime.infra.tempSyncNotifyTimer);
+    runtime.infra.tempSyncNotifyTimer = setTimeout(() => {
+        runtime.infra.tempSyncNotifyTimer = 0;
+        notifyBleSyncRequest(runtime).catch((e) => {
+            sdkLog("warn", "tempPassword", "bleSyncNotifyFail", {
+                devId: runtime.devId,
+                error: e,
+            });
+        });
+    }, NOTIFY_DEBOUNCE_MS);
+};
+export const handleBleSyncRequestReport = async (runtime, rawValue) => {
+    if (!isBleSyncEligible(runtime) || runtime.sync.tempPayloadSyncing) {
+        return;
+    }
+    const report = dpUtils.parse(rawValue, bleSyncRequestReportMap);
+    if (report.cmd !== CMD_REQUEST_SYNC ||
+        report.dataType !== DATA_TYPE_TEMP_PWD) {
+        return;
+    }
+    runtime.sync.tempPayloadSyncing = true;
+    const startedAt = Date.now();
+    try {
+        const { count, pwdList } = await getSyncTempPasswords({
+            devId: runtime.config.devInfo.devId,
+            isUpt: false,
+        });
+        if (count > 0 && pwdList?.length) {
+            const payload = await buildBleTempPwdSyncPayload(runtime, pwdList);
+            await publishBLETransparentData(runtime.config.devInfo.devId, payload);
+            sdkLog("info", "tempPassword", "bleSyncPayloadSent", {
+                devId: runtime.devId,
+                duration: Date.now() - startedAt,
+                data: { count },
+            });
+        }
+    }
+    catch (e) {
+        sdkLog("warn", "tempPassword", "bleSyncPayloadFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            error: e,
+        });
+    }
+    finally {
+        runtime.sync.tempPayloadSyncing = false;
+    }
+};

package/lib/feature/password/temporary/custom-dp-ble.d.ts

@@ -0,0 +1,6 @@
+import type { TempPasswordResult } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { CreateCustomParams, RemoveCustomProps, UpdateTempPasswordParams } from "./types";
+export declare const createTempCustomForRuntime: (this: unknown, rt: LockDeviceRuntime, params: CreateCustomParams) => Promise<TempPasswordResult>;
+export declare const updateTempCustomForRuntime: (this: unknown, rt: LockDeviceRuntime, params: UpdateTempPasswordParams) => Promise<boolean>;
+export declare const removeTempCustomForRuntime: (this: unknown, rt: LockDeviceRuntime, params: RemoveCustomProps) => Promise<boolean>;