@ray-js/lock-sdk 1.1.3-beta.6 → 1.1.3-beta.8

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/temporary.js

@@ -49,71 +49,71 @@ export const createTempCustom = parallelOnly(async (params) => {
         password: aesPwd,
         schedule,
     };
-    if (useNear) {
-        await isValidPassword(baseData);
-        const { tyNum, name } = await createTemporaryPassword({
-            ...baseData,
-            sn: 0,
-            availTime: 0,
-            symbolic: false,
-            dpTunnel: 2,
-        });
-        if (!tyNum) {
-            throw getError(1043);
-        }
-        const dpData = {
-            cloudNo: tyNum,
-            valid: true,
-            validConfig: {
-                startTime: effective.effectiveDate,
-                endTime: effective.expiredDate,
-                loop: loopType,
-                loopConfig: 0,
-                weeks: effective.weeks ? effective.weeks : [0, 0, 0, 0, 0, 0, 0],
-                days: [],
-                startHour: Math.floor(effectiveTime / 60),
-                startMinute: effectiveTime % 60,
-                endHour: Math.floor(expiredTime / 60),
-                endMinute: expiredTime % 60,
-            },
-            validNum: 0,
-            pwdLength: params.password.length,
-            pwd: params.password.split("").map(Number),
-        };
-        const targetDpCode = config.supportBigData
-            ? dpCodes.tempPwdCreateW
-            : dpCodes.tempPwdCreate;
-        const result = await publishDps({
-            [targetDpCode]: dpUtils.format(dpData, (config.supportBigData
-                ? addTempPwdBigDpMap
-                : addTempPwdDpMap)),
-        }, {
-            checkReport: (dpData) => {
-                const reportData = dpData[targetDpCode];
-                if (reportData) {
-                    const data = dpUtils.parse(dpData[targetDpCode], (config.supportBigData
-                        ? reportAddTempPwdDBigpMap
-                        : reportAddTempPwdDpMap));
-                    if (data.cloudNo === tyNum) {
-                        return data;
-                    }
-                }
-                return false;
-            },
-        });
-        if (result.status === 0) {
-            return {
-                type: "custom",
-                name: name,
-                password: password,
-                unlockBindingId: result.unlockBindingId,
-                effectiveConfig: effective,
+    try {
+        if (useNear) {
+            await isValidPassword(baseData);
+            const { tyNum, name } = await createTemporaryPassword({
+                ...baseData,
+                sn: 0,
+                availTime: 0,
+                symbolic: false,
+                dpTunnel: 2,
+            });
+            if (!tyNum) {
+                throw getError(1043);
+            }
+            const dpData = {
+                cloudNo: tyNum,
+                valid: true,
+                validConfig: {
+                    startTime: effective.effectiveDate,
+                    endTime: effective.expiredDate,
+                    loop: loopType,
+                    loopConfig: 0,
+                    weeks: effective.weeks ? effective.weeks : [0, 0, 0, 0, 0, 0, 0],
+                    days: [],
+                    startHour: Math.floor(effectiveTime / 60),
+                    startMinute: effectiveTime % 60,
+                    endHour: Math.floor(expiredTime / 60),
+                    endMinute: expiredTime % 60,
+                },
+                validNum: 0,
+                pwdLength: params.password.length,
+                pwd: params.password.split("").map(Number),
             };
+            const targetDpCode = config.supportBigData
+                ? dpCodes.tempPwdCreateW
+                : dpCodes.tempPwdCreate;
+            const result = await publishDps({
+                [targetDpCode]: dpUtils.format(dpData, (config.supportBigData
+                    ? addTempPwdBigDpMap
+                    : addTempPwdDpMap)),
+            }, {
+                checkReport: (dpData) => {
+                    const reportData = dpData[targetDpCode];
+                    if (reportData) {
+                        const data = dpUtils.parse(dpData[targetDpCode], (config.supportBigData
+                            ? reportAddTempPwdDBigpMap
+                            : reportAddTempPwdDpMap));
+                        if (data.cloudNo === tyNum) {
+                            return data;
+                        }
+                    }
+                    return false;
+                },
+            });
+            if (result.status === 0) {
+                return {
+                    type: "custom",
+                    name: name,
+                    password: password,
+                    unlockBindingId: result.unlockBindingId,
+                    effectiveConfig: effective,
+                };
+            }
+            throw getError(result.status === 2 ? 1041 : 1042);
         }
-        throw getError(result.status === 2 ? 1041 : 1042);
-    }
-    else {
-        try {
+        else {
             const res = await createTemporaryPassword({
                 ...baseData,
                 sn: 0,
@@ -129,9 +129,9 @@ export const createTempCustom = parallelOnly(async (params) => {
                 effectiveConfig: effective,
             };
         }
-        catch (error) {
-            throw handleCloudError(error);
-        }
+    }
+    catch (error) {
+        throw handleCloudError(error);
     }
 });
 export const removeTempCustom = async (params) => {

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.6",
+  "version": "1.1.3-beta.8",
   "files": [
     "lib",
     "LICENSE.md"