@ray-js/lock-sdk 1.1.3-beta.5 → 1.1.3-beta.7

package/lib/api/temp.d.ts

@@ -197,11 +197,31 @@ interface ReNameOfflineParams {
     unlockBindingId: string;
 }
 export declare const reNameOffline: (params: ReNameOfflineParams) => Promise<unknown>;
+export interface SyncTempPwdScheduleItem {
+    allDay: boolean;
+    effectiveTime: number;
+    invalidTime: number;
+    workingDay: number;
+}
+export interface SyncTempPwdItem {
+    id: number;
+    opt: 4 | 5 | 6;
+    sn: number;
+    tyNum: number;
+    password: string;
+    availTime: number;
+    phase: number;
+    effectiveTime: number;
+    invalidTime: number;
+    scheduleList: SyncTempPwdScheduleItem[];
+}
+export interface GetSyncTempPasswordsResult {
+    count: number;
+    pwdList: SyncTempPwdItem[];
+}
 interface GetSyncTempPasswordsParams {
     devId: string;
     isUpt: boolean;
 }
-export declare const getSyncTempPasswords: (params: GetSyncTempPasswordsParams) => Promise<{
-    pwdList: any[];
-}>;
+export declare const getSyncTempPasswords: (params: GetSyncTempPasswordsParams) => Promise<GetSyncTempPasswordsResult>;
 export {};

package/lib/config/dp-code/index.d.ts

@@ -16,6 +16,7 @@ declare const dpCodes: {
     tempPwdDel: string;
     tempPwdEditW: string;
     tempPwdEdit: string;
+    bleSyncRequest: string;
     unlockPassword: string;
     unlockFingerprint: string;
     unlockFingerVein: string;

package/lib/config/dp-code/index.js

@@ -16,6 +16,7 @@ const dpCodes = {
     tempPwdDel: "temporary_password_delete",
     tempPwdEditW: "temporary_password_modify_w",
     tempPwdEdit: "temporary_password_modify",
+    bleSyncRequest: "ble_sync_request",
     unlockPassword: "unlock_password",
     unlockFingerprint: "unlock_fingerprint",
     unlockFingerVein: "unlock_finger_vein",

package/lib/config/dp-map/ble-sync.d.ts

@@ -0,0 +1,3 @@
+import { DpMap } from "@ray-js/tuya-dp-transform";
+export declare const bleSyncRequest: DpMap;
+export declare const reportBleSyncRequest: DpMap;

package/lib/config/dp-map/ble-sync.js

@@ -0,0 +1,17 @@
+export const bleSyncRequest = [
+    {
+        name: "cmd",
+    },
+];
+export const reportBleSyncRequest = [
+    {
+        name: "cmd",
+    },
+    {
+        condition: {
+            prop: "cmd",
+            value: 0x01,
+        },
+        name: "dataType",
+    },
+];

package/lib/state.js

@@ -11,7 +11,7 @@ import { getRotateInfo } from "./api/video";
 import syncT0 from "./sync/t0";
 import syncRemoteSerectKey from "./sync/remote-serect-key";
 import { autoSyncUnlockMethod } from "./sync/unlock-method";
-import { autoSyncTemp } from "./sync/temp";
+import { autoSyncTemp, handleBleSyncRequestReport } from "./sync/temp";
 import { DEVICE_STATUS_CHANGE_EVENT, SLEEP_EVENT } from "./event";
 import { getSleepPeriod, isSleep } from "./sleep";
 import { ProductCommunicationType } from "./constant";
@@ -165,6 +165,9 @@ const handleDpChange = (dps, notEmit) => {
             }, 2000);
         }
         checkOfflineDpUpdate(dpData);
+        if (typeof dpData[dpCodes.bleSyncRequest] !== "undefined") {
+            handleBleSyncRequestReport(dpData[dpCodes.bleSyncRequest]);
+        }
     }
 };
 const handleDeviceDpsChange = ({ dps, deviceId, }) => {

package/lib/sync/ble-temp-payload.d.ts

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

package/lib/sync/ble-temp-payload.js

@@ -0,0 +1,91 @@
+import config from "../config";
+import { formatWeek, parseWeek } from "../utils";
+import { bytesToHex, concatBytes, uintToBytesBE } from "../utils/byte";
+import { decrypt } from "../utils/device";
+const SUB_CMD = 0x2003;
+const PROTO_VERSION = 0x01;
+const DATA_TYPE_TEMP_PWD = 0x01;
+const OP_ADD = 0x01;
+const OP_DEL = 0x02;
+const OP_MOD = 0x03;
+const PHASE_WAIT_FROZEN = 5;
+const PHASE_FROZEN = 4;
+let s_msgId = 0;
+function buildTimeSet(item) {
+    const schedule = item.scheduleList?.[0];
+    const allDay = schedule?.allDay !== false;
+    const loopType = allDay ? 0x00 : 0x02;
+    let loopFlags = new Uint8Array(4);
+    if (!allDay && schedule) {
+        const weeks = parseWeek(schedule.workingDay);
+        loopFlags = uintToBytesBE(formatWeek(weeks), 4);
+    }
+    const startHour = allDay ? 0 : Math.floor((schedule?.effectiveTime ?? 0) / 60);
+    const startMinute = allDay ? 0 : (schedule?.effectiveTime ?? 0) % 60;
+    const endHour = allDay ? 0 : Math.floor((schedule?.invalidTime ?? 0) / 60);
+    const endMinute = allDay ? 0 : (schedule?.invalidTime ?? 0) % 60;
+    return concatBytes(uintToBytesBE(item.effectiveTime, 4), uintToBytesBE(item.invalidTime, 4), new Uint8Array([loopType]), loopFlags, new Uint8Array([startHour, startMinute, endHour, endMinute]));
+}
+function mapAvailTime(availTime) {
+    if (availTime === 0) {
+        return 0x00;
+    }
+    if (availTime >= 0xff) {
+        return 0xff;
+    }
+    return availTime & 0xff;
+}
+function mapState(phase) {
+    if (phase === PHASE_FROZEN || phase === PHASE_WAIT_FROZEN) {
+        return 0x00;
+    }
+    return 0x01;
+}
+async function resolvePwdBytes(password) {
+    if (!password) {
+        return [];
+    }
+    const plainPwd = await decrypt(config.devInfo.devId, password);
+    return plainPwd.split("").map((char) => Number(char));
+}
+async function buildItemBody(item, opCode) {
+    if (opCode === OP_DEL) {
+        return uintToBytesBE(item.sn, 2);
+    }
+    const pwdBytes = await resolvePwdBytes(item.password);
+    const state = mapState(item.phase);
+    const timeSet = buildTimeSet(item);
+    const availTime = mapAvailTime(item.availTime);
+    const commonTail = concatBytes(new Uint8Array([state]), timeSet, new Uint8Array([availTime, pwdBytes.length]), new Uint8Array(pwdBytes));
+    if (opCode === OP_ADD) {
+        return concatBytes(uintToBytesBE(item.tyNum, 2), commonTail);
+    }
+    return concatBytes(uintToBytesBE(item.sn, 2), commonTail);
+}
+function cloudOptToOpCode(opt) {
+    switch (opt) {
+        case 5:
+            return OP_ADD;
+        case 4:
+            return OP_DEL;
+        case 6:
+            return OP_MOD;
+        default:
+            return null;
+    }
+}
+export async function buildBleTempPwdSyncPayload(pwdList) {
+    const items = [];
+    for (const item of pwdList) {
+        const opCode = cloudOptToOpCode(item.opt);
+        if (opCode === null) {
+            continue;
+        }
+        const body = await buildItemBody(item, opCode);
+        items.push(concatBytes(new Uint8Array([opCode]), uintToBytesBE(body.length, 2), body));
+    }
+    const itemsBuf = concatBytes(...items);
+    s_msgId = (s_msgId + 1) & 0xffff;
+    const header = concatBytes(uintToBytesBE(SUB_CMD, 2), new Uint8Array([PROTO_VERSION, DATA_TYPE_TEMP_PWD]), uintToBytesBE(s_msgId, 2), new Uint8Array([items.length]), uintToBytesBE(itemsBuf.length, 2), itemsBuf);
+    return bytesToHex(header);
+}

package/lib/sync/temp.d.ts

@@ -1,2 +1,3 @@
-export declare const syncTemp: () => Promise<void>;
+export declare const notifyBleSyncRequest: () => Promise<void>;
 export declare const autoSyncTemp: () => void;
+export declare const handleBleSyncRequestReport: (rawValue: string) => Promise<void>;

package/lib/sync/temp.js

@@ -1,78 +1,70 @@
 import { getSyncTempPasswords } from "../api/temp";
-import config from "../config";
+import config, { hasDp } from "../config";
 import dpCodes from "../config/dp-code";
-import { addTempPwd as addTempPwdDpMap, removeTempPwd as removeTempPwdDpMap, } from "../config/dp-map/unlock-method";
-import { addTempPwd as addTempPwdBigDpMap, removeTempPwd as removeTempPwdBigDpMap, } from "../config/dp-map/unlock-method-big";
-import { isUseNearChannel, parseWeek } from "../utils";
-import { decrypt } from "../utils/device";
-import { publishDps } from "../utils/publishDps";
+import { bleSyncRequest as bleSyncRequestMap, reportBleSyncRequest as reportBleSyncRequestMap, } from "../config/dp-map/ble-sync";
+import { isUseNearChannel, parallelOnly } from "../utils";
+import { publishBLETransparentData } from "../utils/device";
+import { publishDpsOnly } from "../utils/publishDps";
+import { buildBleTempPwdSyncPayload } from "./ble-temp-payload";
 import dpUtils from "@ray-js/tuya-dp-transform";
-let syncTempFirst = true;
-export const syncTemp = async () => {
+const CMD_REQUEST_SYNC = 0x01;
+const DATA_TYPE_TEMP_PWD = 0x01;
+const NOTIFY_DEBOUNCE_MS = 2000;
+let notifyTimer = null;
+let isSyncingPayload = false;
+const hasBleSyncDp = () => hasDp(dpCodes.bleSyncRequest);
+const publishBleSyncNotify = async (hasPending) => {
+    await publishDpsOnly({
+        [dpCodes.bleSyncRequest]: dpUtils.format({ cmd: hasPending ? 0x01 : 0x00 }, bleSyncRequestMap),
+    });
+};
+export const notifyBleSyncRequest = parallelOnly(async () => {
+    if (!isUseNearChannel() || !hasBleSyncDp()) {
+        return;
+    }
+    const { count } = await getSyncTempPasswords({
+        devId: config.devInfo.devId,
+        isUpt: false,
+    });
+    await publishBleSyncNotify(count > 0);
+});
+export const autoSyncTemp = () => {
+    if (!isUseNearChannel() || !hasBleSyncDp()) {
+        return;
+    }
+    if (notifyTimer) {
+        clearTimeout(notifyTimer);
+    }
+    notifyTimer = setTimeout(() => {
+        notifyTimer = null;
+        notifyBleSyncRequest().catch((e) => {
+            console.warn("ble_sync_request notify error", e);
+        });
+    }, NOTIFY_DEBOUNCE_MS);
+};
+export const handleBleSyncRequestReport = async (rawValue) => {
+    if (!hasBleSyncDp() || !isUseNearChannel() || isSyncingPayload) {
+        return;
+    }
+    const report = dpUtils.parse(rawValue, reportBleSyncRequestMap);
+    if (report.cmd !== CMD_REQUEST_SYNC || report.dataType !== DATA_TYPE_TEMP_PWD) {
+        return;
+    }
+    isSyncingPayload = true;
     try {
-        syncTempFirst = false;
-        const { pwdList } = await getSyncTempPasswords({
+        const { count, pwdList } = await getSyncTempPasswords({
             devId: config.devInfo.devId,
             isUpt: false,
         });
-        const delDpCode = config.supportBigData
-            ? dpCodes.tempPwdDelW
-            : dpCodes.tempPwdDel;
-        const delDpMap = config.supportBigData
-            ? removeTempPwdBigDpMap
-            : removeTempPwdDpMap;
-        const addDpCode = config.supportBigData
-            ? dpCodes.tempPwdCreateW
-            : dpCodes.tempPwdCreate;
-        const addDpMap = config.supportBigData
-            ? addTempPwdBigDpMap
-            : addTempPwdDpMap;
-        pwdList?.forEach(async (syncItem) => {
-            try {
-                if (syncItem?.opt === 4) {
-                    publishDps({
-                        [delDpCode]: dpUtils.format({
-                            unlockId: syncItem?.sn,
-                        }, delDpMap),
-                    });
-                }
-                if (syncItem?.opt === 5) {
-                    const { allDay, invalidTime, effectiveTime, workingDay } = syncItem.scheduleList[0];
-                    const pwd = await decrypt(config.devInfo.devId, syncItem.password);
-                    const pswData = pwd.split("").map((item) => Number(item));
-                    publishDps({
-                        [addDpCode]: dpUtils.format({
-                            cloudNo: syncItem.tyNum,
-                            valid: true,
-                            validConfig: {
-                                startTime: syncItem.effectiveTime,
-                                endTime: syncItem.invalidTime,
-                                loop: allDay ? 0x00 : 0x01,
-                                loopConfig: 0,
-                                weeks: parseWeek(workingDay),
-                                days: 0,
-                                startHour: Math.floor(effectiveTime / 60),
-                                startMinute: effectiveTime % 60,
-                                endHour: Math.floor(invalidTime / 60),
-                                endMinute: invalidTime % 60,
-                            },
-                            validNum: 0,
-                            pwdLength: pswData.length,
-                            pwd: pswData,
-                        }, addDpMap),
-                    });
-                }
-            }
-            catch (e) {
-                console.warn("sync temp password error", e);
-            }
-        });
+        if (count > 0 && pwdList?.length) {
+            const payload = await buildBleTempPwdSyncPayload(pwdList);
+            await publishBLETransparentData(config.devInfo.devId, payload);
+        }
     }
     catch (e) {
-        console.warn(e, "sync temp password error");
+        console.warn("ble_sync_request data transfer error", e);
     }
-};
-export const autoSyncTemp = () => {
-    if (isUseNearChannel()) {
+    finally {
+        isSyncingPayload = false;
     }
 };

package/lib/unlock-method.js

@@ -228,7 +228,9 @@ const addUnlockMethodData = {
     canEmitEvents: true,
     pendingEvents: [],
     releaseEmitTimer: 0,
+    eventSessionId: 0,
 };
+const ADD_UNLOCK_METHOD_EVENT_RELEASE_DELAY = 16;
 const dispatchAddUnlockMethodEvent = (eventData) => {
     if (emitter.hasListener(UNLOCK_METHOD_EVENT)) {
         emitter.emit(UNLOCK_METHOD_EVENT, eventData);
@@ -244,14 +246,22 @@ const emitAddUnlockMethodEvent = (eventData) => {
     }
     dispatchAddUnlockMethodEvent(eventData);
 };
-const releaseAddUnlockMethodEventsAfterStart = () => {
+const releaseAddUnlockMethodEventsAfterStart = (eventSessionId) => {
     clearTimeout(addUnlockMethodData.releaseEmitTimer);
     addUnlockMethodData.releaseEmitTimer = setTimeout(() => {
-        addUnlockMethodData.canEmitEvents = true;
-        const pendingEvents = addUnlockMethodData.pendingEvents.splice(0);
-        pendingEvents.forEach((eventData) => {
-            dispatchAddUnlockMethodEvent(eventData);
-        });
+        if (addUnlockMethodData.eventSessionId !== eventSessionId) {
+            return;
+        }
+        addUnlockMethodData.releaseEmitTimer = setTimeout(() => {
+            if (addUnlockMethodData.eventSessionId !== eventSessionId) {
+                return;
+            }
+            addUnlockMethodData.canEmitEvents = true;
+            const pendingEvents = addUnlockMethodData.pendingEvents.splice(0);
+            pendingEvents.forEach((eventData) => {
+                dispatchAddUnlockMethodEvent(eventData);
+            });
+        }, ADD_UNLOCK_METHOD_EVENT_RELEASE_DELAY);
     }, 0);
 };
 const handleAddTimeout = (timeout = 15000) => {
@@ -398,21 +408,24 @@ const monitoringAddReport = (option) => {
     clearTimeout(addUnlockMethodData.releaseEmitTimer);
     addUnlockMethodData.canEmitEvents = false;
     addUnlockMethodData.pendingEvents = [];
+    addUnlockMethodData.eventSessionId += 1;
     emitter.clearCache(UNLOCK_METHOD_EVENT);
     emitter.off(DPCHANGE, handleAddReport);
     emitter.on(DPCHANGE, handleAddReport);
     handleAddTimeout(option.timeout);
+    return addUnlockMethodData.eventSessionId;
 };
 export const startAddUnlockMethod = async (params) => {
     const { unlockMethodConfig, lockUserId, dpData, sn, addDpCode, addDpMap, addDpReportMap, dpId, } = await getUnlockMethodBase(params.type, params.userId);
     isCancelAddUnlockMethod = false;
     let addReportMonitoringStarted = false;
+    let addReportMonitoringSessionId = 0;
     const startAddReportMonitoring = (total) => {
         if (addReportMonitoringStarted) {
-            return;
+            return addReportMonitoringSessionId;
         }
         addReportMonitoringStarted = true;
-        monitoringAddReport({
+        addReportMonitoringSessionId = monitoringAddReport({
             timeout: params.timeout,
             unlockMethodConfig,
             total,
@@ -423,6 +436,7 @@ export const startAddUnlockMethod = async (params) => {
             userId: params.userId,
             unlockDpId: dpId,
         });
+        return addReportMonitoringSessionId;
     };
     const res = await publishDps({
         [addDpCode]: dpUtils.format(dpData, addDpMap),
@@ -455,8 +469,8 @@ export const startAddUnlockMethod = async (params) => {
         },
     });
     if (res.stage === 0) {
-        startAddReportMonitoring(res.total);
-        releaseAddUnlockMethodEventsAfterStart();
+        const eventSessionId = startAddReportMonitoring(res.total);
+        releaseAddUnlockMethodEventsAfterStart(eventSessionId);
         return { total: res.total };
     }
     if (res.stage === 0xfd) {

package/lib/utils/byte.d.ts

@@ -1,3 +1,5 @@
 export declare function bytesToUint(data: Uint8Array): number;
 export declare function bytesToHex(data: Uint8Array): string;
+export declare function uintToBytesBE(value: number, byteLen: number): Uint8Array;
+export declare function concatBytes(...parts: Uint8Array[]): Uint8Array;
 export declare function stringToBytes(str: string): Uint8Array<ArrayBuffer>;

package/lib/utils/byte.js

@@ -35,6 +35,25 @@ export function bytesToHex(data) {
         .join("")
         .toUpperCase();
 }
+export function uintToBytesBE(value, byteLen) {
+    const out = new Uint8Array(byteLen);
+    let num = value >>> 0;
+    for (let i = byteLen - 1; i >= 0; i--) {
+        out[i] = num & 0xff;
+        num >>>= 8;
+    }
+    return out;
+}
+export function concatBytes(...parts) {
+    const total = parts.reduce((sum, part) => sum + part.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    parts.forEach((part) => {
+        out.set(part, offset);
+        offset += part.length;
+    });
+    return out;
+}
 export function stringToBytes(str) {
     const bytes = [];
     const len = str.length;

package/lib/utils/device.d.ts

@@ -172,6 +172,7 @@ export declare const navigateTo: (params: ParamType<typeof ty.navigateTo>) => vo
 export declare const checkShowMatterMutilpleShare: (deviceId: string) => Promise<unknown>;
 export declare const getBLEOnlineState: (deviceId: string) => Promise<boolean>;
 export declare const connectBLEDevice: (deviceId: string) => Promise<void>;
+export declare const publishBLETransparentData: (deviceId: string, data: string) => Promise<void>;
 export declare const onAppShow: (cb: () => void) => void;
 export declare const offAppShow: (cb: () => void) => void;
 export declare const onAppHide: (cb: () => void) => void;

package/lib/utils/device.js

@@ -364,6 +364,16 @@ export const connectBLEDevice = (deviceId) => {
         });
     });
 };
+export const publishBLETransparentData = (deviceId, data) => {
+    return new Promise((resolve, reject) => {
+        ty.device.publishBLETransparentData({
+            deviceId,
+            data,
+            success: () => resolve(),
+            fail: reject,
+        });
+    });
+};
 export const onAppShow = (cb) => {
     ty.onAppShow(cb);
 };

package/lib/utils/log.js

@@ -12,12 +12,12 @@ const localRecordUserOperate = [
 ];
 const unlockMethodMap = [
     "finger",
-    "face",
     "password",
     "card",
+    "face",
     "fingerVein",
-    "hand",
     "eye",
+    "hand",
     "remoteControl",
 ];
 export const handleLocalOperation = (log, dpValue) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/lock-sdk",
-  "version": "1.1.3-beta.5",
+  "version": "1.1.3-beta.7",
   "files": [
     "lib",
     "LICENSE.md"