@ray-js/lock-sdk 1.0.4 → 1.1.0-beta.1

package/lib/sync/offline-dps.js

@@ -0,0 +1,34 @@
+import { clearOfflineDpData } from "../api";
+import { getOfflineDps } from "../offline-dps";
+import config from "../config";
+import { isUseNearChannel } from "../utils";
+import { publishDpsOnly } from "../utils/publishDps";
+export const syncOfflineDps = async () => {
+    if (config.supportOfflineDps) {
+        const useNear = isUseNearChannel();
+        if (useNear) {
+            const offlineDps = await getOfflineDps();
+            try {
+                if (Object.keys(offlineDps).length) {
+                    const hasTask = Object.keys(offlineDps).some((code) => offlineDps[code].pushStatus === false);
+                    if (hasTask) {
+                        try {
+                            await clearOfflineDpData(config.devInfo.devId);
+                        }
+                        catch (error) {
+                            return;
+                        }
+                        const dpData = Object.keys(offlineDps).reduce((acc, code) => {
+                            acc[code] = offlineDps[code].value;
+                            return acc;
+                        }, {});
+                        publishDpsOnly(dpData);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(error);
+            }
+        }
+    }
+};

package/lib/sync/remote-serect-key.js

@@ -8,36 +8,32 @@ import { decrypt } from "../utils/device";
 import { publishDpsOnly } from "../utils/publishDps";
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { reportSetKey as reportSetKeyMap, setKey as setKeyMap, } from "../config/dp-map/open";
-import { ProductCommunicationType } from "../constant";
 const syncRemoteSerectKey = async (force) => {
     const useNear = isUseNearChannel();
     if (useNear) {
         try {
-            const isSupportBle = config.communication.includes(ProductCommunicationType.BLUETOOTH);
-            if (config.communication.length > 1 && isSupportBle) {
-                if (!force) {
-                    const keyValue = getDpValue(dpCodes.remoteNoPdSetkey);
-                    if (keyValue) {
-                        const keyData = dpUtils.parse(getDpValue(dpCodes.remoteNoPdSetkey), reportSetKeyMap);
-                        if (keyData.status === 0) {
-                            return;
-                        }
+            if (!force) {
+                const keyValue = getDpValue(dpCodes.remoteNoPdSetkey);
+                if (keyValue) {
+                    const keyData = dpUtils.parse(getDpValue(dpCodes.remoteNoPdSetkey), reportSetKeyMap);
+                    if (keyData.status === 0) {
+                        return;
                     }
                 }
-                const { lockUserId, userId } = await getCurrentUser();
-                const { password, invalidTime, effectiveTime } = await checkRemoteKey(config.devInfo.devId);
-                const pw = await decrypt(config.devInfo.devId, password);
-                publishDpsOnly({
-                    [dpCodes.remoteNoPdSetkey]: dpUtils.format({
-                        valid: true,
-                        memberId: lockUserId !== 0 ? lockUserId : userId,
-                        startTime: effectiveTime,
-                        endTime: invalidTime,
-                        validNum: 100,
-                        key: stringToBytes(pw),
-                    }, setKeyMap),
-                });
             }
+            const { lockUserId, userId } = await getCurrentUser();
+            const { password, invalidTime, effectiveTime } = await checkRemoteKey(config.devInfo.devId);
+            const pw = await decrypt(config.devInfo.devId, password);
+            publishDpsOnly({
+                [dpCodes.remoteNoPdSetkey]: dpUtils.format({
+                    valid: true,
+                    memberId: lockUserId !== 0 ? lockUserId : userId,
+                    startTime: effectiveTime,
+                    endTime: invalidTime,
+                    validNum: 100,
+                    key: stringToBytes(pw),
+                }, setKeyMap),
+            });
         }
         catch (e) {
             console.warn(e);

package/lib/sync/t0.js

@@ -1,5 +1,5 @@
 import { getActiveTime } from "../api";
-import config from "../config";
+import config, { hasCapability } from "../config";
 import dpCodes from "../config/dp-code";
 import { ProductCommunicationType } from "../constant";
 import { isUseNearChannel } from "../utils";
@@ -9,7 +9,7 @@ const isNeedSync = () => {
     const near = isUseNearChannel();
     return (near ||
         (config.devInfo.isOnline &&
-            config.communication.includes(ProductCommunicationType.THREAD)));
+            hasCapability(ProductCommunicationType.THREAD)));
 };
 const syncT0 = async () => {
     if (hasSysncT0) {

package/lib/sync/unlock-method.d.ts

@@ -0,0 +1,2 @@
+export declare const syncUnlockMethod: () => Promise<void>;
+export declare const autoSyncUnlockMethod: () => Promise<void>;

package/lib/sync/unlock-method.js

@@ -0,0 +1,42 @@
+import { fetchSyncUnlockMethodInfo } from "../api/lock";
+import config from "../config";
+import dpCodes from "../config/dp-code";
+import { getCurrentUser } from "../state";
+import { publishDps } from "../utils/publishDps";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { reportSync as reportSyncMap } from "../config/dp-map/unlock-method";
+import { reportSync as reportSyncBigMap } from "../config/dp-map/unlock-method-big";
+let syncUnlockMethodFirst = true;
+export const syncUnlockMethod = async () => {
+    syncUnlockMethodFirst = false;
+    const { allOpenDps = "" } = await getCurrentUser();
+    const { ins = "", distributed = false } = await fetchSyncUnlockMethodInfo({
+        devId: config.devInfo.devId,
+        dpIds: allOpenDps.split(","),
+    });
+    if (ins && distributed) {
+        const dpCode = config.supportBigData
+            ? dpCodes.synchMethodW
+            : dpCodes.synchMethod;
+        await publishDps({ [dpCode]: ins }, {
+            checkReport: (dpData) => {
+                if (typeof dpData[dpCode] !== "undefined") {
+                    const result = dpUtils.parse(dpData[dpCode], config.supportBigData ? reportSyncBigMap : reportSyncMap);
+                    if (result.stage === 1) {
+                        return true;
+                    }
+                }
+                return false;
+            },
+        });
+    }
+};
+export const autoSyncUnlockMethod = async () => {
+    try {
+        if (syncUnlockMethodFirst) {
+            await syncUnlockMethod();
+        }
+    }
+    catch (e) {
+    }
+};

package/lib/sync/user.d.ts

@@ -0,0 +1,2 @@
+declare const syncDeleteUsers: () => Promise<void>;
+export default syncDeleteUsers;

package/lib/sync/user.js

@@ -0,0 +1,76 @@
+import { getDeviceStatus } from "../state";
+import { ProductCommunicationType } from "../constant";
+import config, { hasCapability } from "../config";
+import { getUsersSyncLockData, removeUser } from "../api/user";
+import dpCodes from "../config/dp-code";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { remove as removeBigMap, reportRemove as reportRemoveBigMap, } from "../config/dp-map/unlock-method-big";
+import { remove as removeMap, reportRemove as reportRemoveMap, } from "../config/dp-map/unlock-method";
+import { publishDps } from "../utils/publishDps";
+const deleteUser = async (data) => {
+    const { admin, lockUserId, userId } = data;
+    const dpCode = config.supportBigData
+        ? dpCodes.unlockMethodDelW
+        : dpCodes.unlockMethodDel;
+    const dpData = {
+        type: 0,
+        stage: 0,
+        admin: !!admin,
+        memberId: lockUserId,
+        unlockId: config.supportBigData ? 0xffff : 0xff,
+        category: 0,
+    };
+    await publishDps({
+        [dpCode]: dpUtils.format(dpData, (config.supportBigData ? removeBigMap : removeMap)),
+    }, {
+        checkReport: (dps) => {
+            if (dps[dpCode]) {
+                const dpValue = dpUtils.parse(dps[dpCode], (config.supportBigData
+                    ? reportRemoveBigMap
+                    : reportRemoveMap));
+                if (dpValue.type === 0 &&
+                    dpValue.status == 255 &&
+                    dpValue.memberId === lockUserId) {
+                    return true;
+                }
+            }
+            return false;
+        },
+    });
+    await removeUser(config.devInfo.devId, userId);
+};
+let isSyncDone = false;
+const syncDeleteUsers = async () => {
+    const deviceStatus = getDeviceStatus();
+    if (deviceStatus.isWifiActive) {
+        return;
+    }
+    const hasThread = hasCapability(ProductCommunicationType.THREAD);
+    if (hasThread &&
+        (deviceStatus.onlineType === "local" || deviceStatus.onlineType === "cloud")) {
+        return;
+    }
+    if (isSyncDone)
+        return;
+    if (deviceStatus.type === "online" && deviceStatus.onlineType === "ble") {
+        isSyncDone = true;
+        let count = 0;
+        const handleSync = async () => {
+            try {
+                const { removedUser = [] } = await getUsersSyncLockData(config.devInfo.devId);
+                await Promise.all(removedUser.map((item) => deleteUser(item).catch(() => { })));
+                isSyncDone = false;
+            }
+            catch (e) {
+                if (e?.innerError?.errorCode === "DEVICE_KEY_NOT_FOUND" && count < 3) {
+                    count++;
+                    setTimeout(async () => {
+                        await handleSync();
+                    }, 2000);
+                }
+            }
+        };
+        handleSync();
+    }
+};
+export default syncDeleteUsers;

package/lib/utils/device.d.ts

@@ -168,4 +168,11 @@ export declare const getHomeInfo: () => Promise<{
 }>;
 export declare const navigateToMiniProgram: (params: ParamType<typeof ty.navigateToMiniProgram>) => void;
 export declare const navigateTo: (params: ParamType<typeof ty.navigateTo>) => void;
+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 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 {};

package/lib/utils/device.js

@@ -325,3 +325,42 @@ export const navigateToMiniProgram = (params) => {
 export const navigateTo = (params) => {
     return ty.navigateTo(params);
 };
+export const checkShowMatterMutilpleShare = (deviceId) => {
+    return new Promise((resolve, reject) => {
+        return ty.device.checkShowMatterMutilpleShare({
+            deviceId,
+            success: resolve,
+            fail: reject,
+        });
+    });
+};
+export const getBLEOnlineState = (deviceId) => {
+    return new Promise((resolve, reject) => {
+        ty.device.getBLEOnlineState({
+            deviceId,
+            success: (res) => resolve(res.isOnline),
+            fail: reject,
+        });
+    });
+};
+export const connectBLEDevice = (deviceId) => {
+    return new Promise((resolve, reject) => {
+        ty.device.connectBLEDevice({
+            deviceId,
+            success: () => resolve(),
+            fail: reject,
+        });
+    });
+};
+export const onAppShow = (cb) => {
+    ty.onAppShow(cb);
+};
+export const offAppShow = (cb) => {
+    ty.offAppShow(cb);
+};
+export const onAppHide = (cb) => {
+    ty.onAppShow(cb);
+};
+export const offAppHide = (cb) => {
+    ty.offAppShow(cb);
+};

package/lib/utils/errors.js

@@ -60,6 +60,9 @@ const errors = {
     1059: "Doorbell notification service not enabled",
     1060: "Does not support adding normal members",
     1061: "Hardware ID does not match When update face",
+    1062: "Device does not support active connection",
+    1063: "Password length only supports 4-6 digits",
+    1064: "Non-thread device, not supported in LAN connection to open and close locks",
 };
 export const getError = (code, ...places) => {
     if (errors[code]) {

package/lib/utils/index.js

@@ -1,6 +1,6 @@
-import config from "../config";
+import config, { hasCapability } from "../config";
 import dpCodes from "../config/dp-code";
-import { ProductCommunicationType, } from "../constant";
+import { ProductCommunicationType } from "../constant";
 import { LoopTypes } from "./constant";
 import { getBackgroundFetchData, getCurrentHomeInfo, onBackgroundFetchData, } from "./device";
 import { getError } from "./errors";
@@ -98,11 +98,11 @@ export const validateEffectiveConfig = (effective) => {
     }
 };
 export const isUseNearChannel = () => {
-    const { onlineType, devInfo, communication } = config;
+    const { onlineType, devInfo } = config;
     const isBleOnline = isOnlineByType(onlineType, 2);
-    const isSupportWifi = communication.includes(ProductCommunicationType.WIFI);
-    const isSupportBle = communication.includes(ProductCommunicationType.BLUETOOTH);
-    const isSupportThread = communication.includes(ProductCommunicationType.THREAD);
+    const isSupportWifi = hasCapability(ProductCommunicationType.WIFI);
+    const isSupportBle = hasCapability(ProductCommunicationType.BLUETOOTH);
+    const isSupportThread = hasCapability(ProductCommunicationType.THREAD);
     if (isSupportWifi && isSupportBle) {
         return isBleOnline;
     }

package/lib/utils/ipc.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    wakeUpDoorBell: (deviceId: string) => Promise<unknown>;
+    isConnected: (deviceId: string) => Promise<{
+        isConnected: boolean;
+    }>;
+    isConnecting: (deviceId: string) => Promise<{
+        isConnecting: boolean;
+    }>;
+    connect: (deviceId: string) => Promise<unknown>;
+};
+export default _default;

package/lib/utils/ipc.js

@@ -0,0 +1,26 @@
+const wakeUpDoorBell = (deviceId) => {
+    return new Promise((resolve, reject) => {
+        ty.ipc.wakeUpDoorBell({ deviceId, success: resolve, fail: reject });
+    });
+};
+const isConnected = (deviceId) => {
+    return new Promise((resolve, reject) => {
+        ty.ipc.isConnected({ deviceId, success: resolve, fail: reject });
+    });
+};
+const isConnecting = (deviceId) => {
+    return new Promise((resolve, reject) => {
+        ty.ipc.isConnecting({ deviceId, success: resolve, fail: reject });
+    });
+};
+const connect = (deviceId) => {
+    return new Promise((resolve, reject) => {
+        ty.ipc.connect({ deviceId, success: resolve, fail: reject });
+    });
+};
+export default {
+    wakeUpDoorBell,
+    isConnected,
+    isConnecting,
+    connect,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/lock-sdk",
-  "version": "1.0.4",
+  "version": "1.1.0-beta.1",
   "files": [
     "lib",
     "LICENSE.md"
@@ -31,7 +31,7 @@
     "react": "^19.0.0"
   },
   "dependencies": {
-    "@ray-js/tuya-dp-transform": "^0.0.6",
+    "@ray-js/tuya-dp-transform": "^0.0.7",
     "js-base64": "^3.7.7"
   }
 }