@ray-js/lock-sdk 1.1.1-beta.12 → 1.1.1-beta.13

package/lib/capability.js

@@ -8,7 +8,7 @@ export const isActiveThread = async () => {
     const hasThread = hasCapability(ProductCommunicationType.THREAD);
     if (hasThread) {
         const deviceStatus = getDeviceStatus();
-        if (deviceStatus.onlineType === "cloud" ||
+        if (deviceStatus.onlineTypes.includes("cloud") ||
             config.communication.length === 1) {
             return true;
         }

package/lib/offline-dps.js

@@ -29,14 +29,14 @@ export const checkOfflineDpUpdate = async (dps, isForce) => {
     if (!config.supportOfflineDps) {
         return;
     }
-    const hasOne = Object.keys(dps).some((code) => cache[code]?.pushStatus === false);
+    const hasOne = Object.keys(dps).some((code) => cache?.[code]?.pushStatus === false);
     if (hasOne || isForce) {
         const res = await getOfflineDps(true);
         emitter.emit(OFFLINE_DPS_UPDATE, res);
     }
 };
 export const getOfflineDpCache = (code) => {
-    return cache[code];
+    return cache?.[code];
 };
 export const publishOfflineDps = async (dps) => {
     const { devInfo, dpSchema } = config;
@@ -52,20 +52,12 @@ export const publishOfflineDps = async (dps) => {
         return acc;
     }, {});
     await publishOfflineDpData(devInfo.devId, dpData);
-    try {
-        await checkOfflineDpUpdate({}, true);
-    }
-    catch {
-    }
+    checkOfflineDpUpdate({}, true);
 };
 export const clearOfflineDps = async () => {
     const { devInfo } = config;
     await clearOfflineDpData(devInfo.devId);
-    try {
-        await checkOfflineDpUpdate({}, true);
-    }
-    catch {
-    }
+    checkOfflineDpUpdate({}, true);
 };
 const OFFLINE_DPS_UPDATE = "offline_dps_update";
 export const onOfflineDpsUpdate = (callback) => {

package/lib/other.js

@@ -260,7 +260,7 @@ export const connectDevice = async () => {
         }
     }
     if (isSupportBleControl()) {
-        if (deviceStatus.type === "online" && deviceStatus.onlineType === "ble") {
+        if (deviceStatus.type === "online" && deviceStatus.onlineTypes.includes("ble")) {
             return true;
         }
         return await connectBle();

package/lib/state.js

@@ -243,12 +243,14 @@ export const initState = async () => {
     fetchDeviceProperties();
     getDeviceAdvancedAbilities();
     syncRemoteSerectKey();
+    checkOfflineDpUpdate({}, true).then(() => {
+        setTimeout(() => {
+            syncOfflineDps();
+        }, 3000);
+    });
     setTimeout(() => {
         syncT0();
         autoSyncUnlockMethod();
-        checkOfflineDpUpdate({}, true).then(() => {
-            syncOfflineDps();
-        });
     }, 2000);
     setTimeout(() => {
         autoSyncTemp();

package/lib/sync/offline-dps.js

@@ -12,12 +12,7 @@ export const syncOfflineDps = async () => {
                 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;
-                        }
+                        clearOfflineDpData(config.devInfo.devId);
                         const dpData = Object.keys(offlineDps).reduce((acc, code) => {
                             acc[code] = offlineDps[code].value;
                             return acc;

package/lib/sync/unlock-method.js

@@ -32,11 +32,7 @@ export const syncUnlockMethod = async () => {
     }
 };
 export const autoSyncUnlockMethod = async () => {
-    try {
-        if (syncUnlockMethodFirst) {
-            await syncUnlockMethod();
-        }
-    }
-    catch (e) {
+    if (syncUnlockMethodFirst) {
+        await syncUnlockMethod();
     }
 };

package/lib/sync/user.js

@@ -1,40 +1,43 @@
 import { getDeviceStatus } from "../state";
-import { ProductCommunicationType } from "../constant";
-import config, { hasCapability } from "../config";
+import config from "../config";
 import { getUsersSyncLockData } from "../api/user";
 import { deleteUser } from "../utils/user";
-let isSyncDone = false;
+import { onAppShow } from "../utils/device";
+import { isUseNearChannel } from "../utils";
+let isSyncing = false;
+onAppShow(() => {
+    syncDeleteUsers();
+});
 const syncDeleteUsers = async () => {
     const deviceStatus = getDeviceStatus();
     if (deviceStatus.isWifiActive) {
         return;
     }
-    const hasThread = hasCapability(ProductCommunicationType.THREAD);
-    if (hasThread &&
-        (deviceStatus.onlineType === "local" || deviceStatus.onlineType === "cloud")) {
+    if (!isUseNearChannel()) {
         return;
     }
-    if (isSyncDone)
+    if (isSyncing)
         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;
+    isSyncing = true;
+    let count = 0;
+    const handleSync = async () => {
+        try {
+            const { removedUser = [] } = await getUsersSyncLockData(config.devInfo.devId);
+            await Promise.all(removedUser.map((item) => deleteUser(item).catch(() => { })));
+            isSyncing = false;
+        }
+        catch (e) {
+            if (e?.innerError?.errorCode === "DEVICE_KEY_NOT_FOUND" && count < 3) {
+                count++;
+                setTimeout(async () => {
+                    await handleSync();
+                }, 2000);
             }
-            catch (e) {
-                if (e?.innerError?.errorCode === "DEVICE_KEY_NOT_FOUND" && count < 3) {
-                    count++;
-                    setTimeout(async () => {
-                        await handleSync();
-                    }, 2000);
-                }
+            else {
+                isSyncing = false;
             }
-        };
-        handleSync();
-    }
+        }
+    };
+    handleSync();
 };
 export default syncDeleteUsers;

package/lib/unlock-method.js

@@ -20,7 +20,10 @@ const getAddUnlockError = (status) => {
     if (status === 0xfe) {
         return getError(1026);
     }
-    return getError(1016);
+    return {
+        ...getError(1016),
+        devCode: status,
+    };
 };
 export const getUnlockMethodDetail = async (id) => {
     const cloudData = await getUnlockMethodInfo({
@@ -338,7 +341,8 @@ const handleAddReport = async (dps) => {
                         };
                     }
                 }
-                catch {
+                catch (err) {
+                    console.warn("AddUnlockMethod failed", err);
                     eventData = {
                         stage: "fail",
                         type,

package/package.json

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