@ray-js/lock-sdk 1.1.1-beta.15 → 1.1.1-beta.17

package/lib/api/user.js

@@ -48,7 +48,7 @@ export const getUserDetailQuery = (params) => {
 export const getUsersSyncLockData = (deviceId) => {
     return requestApi({
         api: `${THING}.m.device.lock.sync.batch`,
-        version: "2.0",
+        version: "1.0",
         data: {
             devId: deviceId,
         },

package/lib/index.js

@@ -2,7 +2,7 @@ import config, { hasCapability, hasDp, updateConfig } from "./config";
 import dpCodes from "./config/dp-code";
 import { addEvents, clearState, initState, removeEvents, getCurrentUser, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, getCurrentUserSync, getMediaRotate, } from "./state";
 import { getCapabilities } from "./utils";
-import { getDeviceInfo, getLaunchOptionsSync } from "./utils/device";
+import { getDeviceInfo, getLaunchOptionsSync, trackEvent, } from "./utils/device";
 import { syncUnlockMethod } from "./sync/unlock-method";
 import { publishDps } from "./utils/publishDps";
 import { publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, } from "./offline-dps";
@@ -63,6 +63,9 @@ export const init = async (options) => {
     config.preFetch = options?.preFetch ?? false;
     config.communication = getCapabilities(devInfo.capability).map((item) => item.id);
     addEvents();
+    trackEvent("t$y_UztB3Lj9Qns375R0r7dA0L5Kr2VytH3J".replace("$", ""), {
+        pid: devInfo.productId,
+    });
     await initState();
 };
 export const destroy = () => {

package/lib/open/ble-dedicated-dp.d.ts

@@ -0,0 +1,4 @@
+export declare const isDedicatedBleHexSuccess: (raw: string) => boolean;
+export declare const resolveDedicatedBleCommandDp: () => string | null;
+export declare const executeDedicatedBleManualLock: (timeout: number) => Promise<void>;
+export declare const executeDedicatedBleRawAction: (isOpen: boolean, timeout: number) => Promise<void>;

package/lib/open/ble-dedicated-dp.js

@@ -0,0 +1,148 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { getDoorKey } from "../api/lock";
+import config, { hasDp } from "../config";
+import dpCodes from "../config/dp-code";
+import { open as openMap, reportOpen as reportOpenMap, } from "../config/dp-map/open";
+import syncRemoteSerectKey from "../sync/remote-serect-key";
+import { stringToBytes } from "../utils/byte";
+import { decrypt } from "../utils/device";
+import { getError } from "../utils/errors";
+import { publishDps } from "../utils/publishDps";
+import { getOpenDoorMemberId } from "./ble-remote-no-dp-key";
+import { mapRemoteOpenReportStatus } from "./report-status";
+const normalizeHex = (raw) => raw.replace(/\s/g, "").toLowerCase();
+export const isDedicatedBleHexSuccess = (raw) => {
+    const n = normalizeHex(raw);
+    if (n.length < 2) {
+        return false;
+    }
+    return n.startsWith("00") || n.endsWith("00");
+};
+const parseDedicatedBleHexStatus = (raw) => {
+    const n = normalizeHex(raw);
+    if (n.length < 2) {
+        return false;
+    }
+    if (isDedicatedBleHexSuccess(raw)) {
+        return { status: 0 };
+    }
+    if (n.includes("06")) {
+        return { status: 0x06 };
+    }
+    return { status: 0x01 };
+};
+const tryParseStandardUnlockReport = (raw, memberId) => {
+    try {
+        const result = dpUtils.parse(raw, reportOpenMap);
+        if (result.memberId !== memberId) {
+            return false;
+        }
+        if (hasDp(dpCodes.lockMotorState) && result.status === 0) {
+            return false;
+        }
+        return result;
+    }
+    catch {
+        return false;
+    }
+};
+export const resolveDedicatedBleCommandDp = () => {
+    if (hasDp(dpCodes.bleUnlockCheck)) {
+        return dpCodes.bleUnlockCheck;
+    }
+    if (hasDp(dpCodes.bluetoothUnlock)) {
+        return dpCodes.bluetoothUnlock;
+    }
+    if (hasDp(dpCodes.unlockBle)) {
+        return dpCodes.unlockBle;
+    }
+    return null;
+};
+const createDedicatedBleCheckReport = (commandDp, memberId) => {
+    return (dpData) => {
+        if (hasDp(dpCodes.lockMotorState)) {
+            if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
+                return { status: 0 };
+            }
+        }
+        if (typeof dpData[commandDp] !== "undefined") {
+            const raw = dpData[commandDp];
+            const standard = tryParseStandardUnlockReport(raw, memberId);
+            if (standard) {
+                return standard;
+            }
+            const hexStatus = parseDedicatedBleHexStatus(raw);
+            if (hexStatus !== false) {
+                return hexStatus;
+            }
+        }
+        if (typeof dpData[dpCodes.remoteNoDpKey] !== "undefined") {
+            const result = dpUtils.parse(dpData[dpCodes.remoteNoDpKey], reportOpenMap);
+            if (result.memberId === memberId) {
+                if (hasDp(dpCodes.lockMotorState) && result.status === 0) {
+                    return false;
+                }
+                return result;
+            }
+        }
+        return false;
+    };
+};
+export const executeDedicatedBleManualLock = async (timeout) => {
+    if (!hasDp(dpCodes.manualLock)) {
+        throw getError(1014);
+    }
+    await publishDps({
+        [dpCodes.manualLock]: true,
+    }, {
+        timeout,
+        checkReport: (dpData) => {
+            if (hasDp(dpCodes.lockMotorState)) {
+                if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
+                    return { status: 0 };
+                }
+            }
+            if (typeof dpData[dpCodes.manualLock] !== "undefined") {
+                return { status: 0 };
+            }
+            return false;
+        },
+    });
+};
+export const executeDedicatedBleRawAction = async (isOpen, timeout) => {
+    if (!isOpen && hasDp(dpCodes.manualLock)) {
+        await executeDedicatedBleManualLock(timeout);
+        return;
+    }
+    const commandDp = resolveDedicatedBleCommandDp();
+    if (!commandDp) {
+        throw getError(1014);
+    }
+    await syncRemoteSerectKey();
+    let pw = "";
+    try {
+        const { password } = await getDoorKey(config.devInfo.devId);
+        pw = await decrypt(config.devInfo.devId, password);
+    }
+    catch {
+        await syncRemoteSerectKey(true);
+        const { password } = await getDoorKey(config.devInfo.devId);
+        pw = await decrypt(config.devInfo.devId, password);
+    }
+    const memberId = await getOpenDoorMemberId();
+    const payload = dpUtils.format({
+        status: Number(isOpen),
+        memberId,
+        key: stringToBytes(pw),
+        type: 3,
+    }, openMap);
+    const response = (await publishDps({
+        [commandDp]: payload,
+    }, {
+        timeout,
+        checkReport: createDedicatedBleCheckReport(commandDp, memberId),
+    }));
+    if (response.status !== 0) {
+        throw mapRemoteOpenReportStatus(response.status);
+    }
+};

package/lib/open/ble-remote-no-dp-key.d.ts

@@ -0,0 +1,4 @@
+import { DpValue } from "../interface";
+export declare const createRemoteNoDpKeyBleCheckReport: (memberId: number) => (dpData: Record<string, DpValue>) => any;
+export declare const executeBleRemoteNoDpKeyAction: (isOpen: boolean, timeout: number, memberId: number) => Promise<void>;
+export declare const getOpenDoorMemberId: () => Promise<number>;

package/lib/open/ble-remote-no-dp-key.js

@@ -0,0 +1,69 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { getDoorKey } from "../api/lock";
+import config, { hasDp } from "../config";
+import dpCodes from "../config/dp-code";
+import { open as openMap, reportOpen as reportOpenMap, } from "../config/dp-map/open";
+import { getCurrentUser } from "../state";
+import syncRemoteSerectKey from "../sync/remote-serect-key";
+import { stringToBytes } from "../utils/byte";
+import { decrypt } from "../utils/device";
+import { publishDps } from "../utils/publishDps";
+import { mapRemoteOpenReportStatus } from "./report-status";
+export const createRemoteNoDpKeyBleCheckReport = (memberId) => {
+    return (dpData) => {
+        if (hasDp(dpCodes.lockMotorState)) {
+            if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
+                return {
+                    status: 0,
+                };
+            }
+        }
+        if (typeof dpData[dpCodes.remoteNoDpKey] !== "undefined") {
+            const result = dpUtils.parse(dpData[dpCodes.remoteNoDpKey], reportOpenMap);
+            if (result.memberId === memberId) {
+                if (hasDp(dpCodes.lockMotorState) && result.status === 0) {
+                    return false;
+                }
+                return result;
+            }
+            else {
+                console.warn("An incorrect member id was returned");
+            }
+        }
+        return false;
+    };
+};
+export const executeBleRemoteNoDpKeyAction = async (isOpen, timeout, memberId) => {
+    await syncRemoteSerectKey();
+    let pw = "";
+    try {
+        const { password } = await getDoorKey(config.devInfo.devId);
+        pw = await decrypt(config.devInfo.devId, password);
+    }
+    catch {
+        await syncRemoteSerectKey(true);
+        const { password } = await getDoorKey(config.devInfo.devId);
+        pw = await decrypt(config.devInfo.devId, password);
+    }
+    const response = (await publishDps({
+        [dpCodes.remoteNoDpKey]: dpUtils.format({
+            status: Number(isOpen),
+            memberId,
+            key: stringToBytes(pw),
+            type: 3,
+        }, openMap),
+    }, {
+        timeout,
+        checkReport: createRemoteNoDpKeyBleCheckReport(memberId),
+    }));
+    if (response.status !== 0) {
+        throw mapRemoteOpenReportStatus(response.status);
+    }
+};
+export const getOpenDoorMemberId = async () => {
+    const currentUser = await getCurrentUser();
+    if (currentUser.lockUserId !== 0) {
+        return Number(currentUser.lockUserId);
+    }
+    return Number(currentUser.userId);
+};

package/lib/open/report-status.d.ts

@@ -0,0 +1 @@
+export declare const mapRemoteOpenReportStatus: (status: number) => import("..").ErrorData;

package/lib/open/report-status.js

@@ -0,0 +1,23 @@
+import { getError } from "../utils/errors";
+export const mapRemoteOpenReportStatus = (status) => {
+    let error = getError(1004);
+    switch (status) {
+        case 0x02:
+            error = getError(1005);
+            break;
+        case 0x03:
+            error = getError(1006);
+            break;
+        case 0x04:
+            error = getError(1007);
+            break;
+        case 0x05:
+            error = getError(1008);
+            break;
+        case 0x06:
+            error = getError(1070);
+            break;
+        default:
+    }
+    return error;
+};

package/lib/state.js

@@ -297,6 +297,9 @@ const handleAppShow = () => {
     getCurrentUser(true);
     fetchDeviceProperties();
     checkOfflineDpUpdate({}, true);
+    setTimeout(() => {
+        syncDeleteUsers();
+    }, 1000);
 };
 const handleAppHide = () => { };
 export const addEvents = () => {

package/lib/sync/user.js

@@ -2,12 +2,8 @@ import { getDeviceStatus } from "../state";
 import config from "../config";
 import { getUsersSyncLockData } from "../api/user";
 import { deleteUser } from "../utils/user";
-import { onAppShow } from "../utils/device";
 import { isUseNearChannel } from "../utils";
 let isSyncing = false;
-onAppShow(() => {
-    syncDeleteUsers();
-});
 const syncDeleteUsers = async () => {
     const deviceStatus = getDeviceStatus();
     if (deviceStatus.isWifiActive) {

package/lib/utils/device.d.ts

@@ -176,4 +176,5 @@ export declare const onAppShow: (cb: () => void) => void;
 export declare const offAppShow: (cb: () => void) => void;
 export declare const onAppHide: (cb: () => void) => void;
 export declare const offAppHide: (cb: () => void) => void;
+export declare const trackEvent: (event: string, data: Record<string, any>) => void;
 export {};

package/lib/utils/device.js

@@ -364,3 +364,9 @@ export const onAppHide = (cb) => {
 export const offAppHide = (cb) => {
     ty.offAppShow(cb);
 };
+export const trackEvent = (event, data) => {
+    ty.event({
+        eventId: event,
+        event: data,
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/lock-sdk",
-  "version": "1.1.1-beta.15",
+  "version": "1.1.1-beta.17",
   "files": [
     "lib",
     "LICENSE.md"