@ray-js/lock-sdk 1.2.1-beta.8 → 1.2.1

package/lib/entries/main/exports/misc.d.ts

@@ -20,3 +20,7 @@ export interface AwakeDeviceOptions {
     timeout?: number;
 }
 export declare function awakeDevice(options?: AwakeDeviceOptions): Promise<true>;
+interface DisconnectDeviceOptions {
+    disconnetBle?: boolean;
+}
+export declare function disconnectDevice(options?: DisconnectDeviceOptions): Promise<void>;

package/lib/entries/main/exports/misc.js

@@ -2,7 +2,7 @@ import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-
 import { openSceneForRuntime } from "../../../feature/misc/open-scene";
 import { isSupportBleControlForRuntime } from "../../../feature/misc/ble-control";
 import { getDpPeriodTimeForRuntime, updateDpPeriodTimeForRuntime, } from "../../../feature/misc/dp-period";
-import { awakeDeviceForRuntime, connectDeviceForRuntime, } from "../../../feature/misc/connect-device";
+import { awakeDeviceForRuntime, connectDeviceForRuntime, disconnectDeviceForRuntime, } from "../../../feature/misc/connect-device";
 import { validatePwdComplexityForRuntime } from "../../../feature/misc/validate-pwd";
 import { gotoServiceForRuntime, } from "../../../feature/service/goto-service";
 export { parseDpPeriodTime } from "../../../feature/misc/dp-period";
@@ -31,3 +31,6 @@ export async function validatePwdComplexity(password) {
 export async function awakeDevice(options) {
     return awakeDeviceForRuntime(resolveRuntimeFromExportThis(this), options);
 }
+export async function disconnectDevice(options) {
+    return disconnectDeviceForRuntime(resolveRuntimeFromExportThis(this), options);
+}

package/lib/feature/misc/connect-device.d.ts

@@ -3,3 +3,6 @@ export declare function connectDeviceForRuntime(rt: LockDeviceRuntime, timeout?:
 export declare const awakeDeviceForRuntime: (runtime: LockDeviceRuntime, options?: {
     timeout?: number;
 }) => Promise<true>;
+export declare const disconnectDeviceForRuntime: (rt: LockDeviceRuntime, options?: {
+    disconnetBle?: boolean;
+}) => Promise<void>;

package/lib/feature/misc/connect-device.js

@@ -1,5 +1,5 @@
 import dpCodes from "../../config/dp-code";
-import { connectBLEDevice, getBLEOnlineState, onBleChange, onOnlineChange, offBleChange, offOnlineChange, yuChannelSyncSingleSync, } from "../../platform/device";
+import { connectBLEDevice, getBLEOnlineState, onBleChange, onOnlineChange, offBleChange, offOnlineChange, yuChannelSyncSingleSync, disconnectBLEDevice, } from "../../platform/device";
 import { DPCHANGE } from "../../utils/constant";
 import emitter from "../../utils/event";
 import { getError } from "../../utils/errors";
@@ -8,70 +8,8 @@ import { getDpValueForRuntime } from "../dp/get-dp-value";
 import { getDeviceStatusForRuntime } from "../state/device-status";
 import { isSupportBleControlForRuntime } from "./ble-control";
 import { sdkLog } from "../../utils/sdk-log";
+import { hasDpForRuntime } from "../dp/has-dp";
 const { wirelessAwake } = dpCodes;
-const awakeDevice = async (devId, timeout) => {
-    const startedAt = Date.now();
-    sdkLog("info", "connectDevice", "awakeStart", {
-        devId,
-        data: { timeout: timeout || 15000 },
-    });
-    return new Promise((resolve, reject) => {
-        const handleChangeDp = (dpCodesArg) => {
-            if (dpCodesArg[wirelessAwake] === true) {
-                sdkLog("info", "connectDevice", "awakeReportSuccess", {
-                    devId,
-                    duration: Date.now() - startedAt,
-                });
-                resolve(true);
-                emitter.off(DPCHANGE, handleChangeDp);
-                clearTimeout(timer);
-            }
-        };
-        emitter.on(DPCHANGE, handleChangeDp);
-        const timer = setTimeout(() => {
-            emitter.off(DPCHANGE, handleChangeDp);
-            const error = getError(1002);
-            sdkLog("warn", "connectDevice", "awakeTimeout", {
-                devId,
-                duration: Date.now() - startedAt,
-                error,
-            });
-            reject(error);
-        }, timeout || 15000);
-        const run = async () => {
-            try {
-                ipc.wakeUpDoorBell(devId);
-                ipc.wakeUpDoorBell(devId);
-                ipc.wakeUpDoorBell(devId);
-                const connected = await ipc.isConnected(devId);
-                if (connected.isConnected) {
-                    sdkLog("info", "connectDevice", "awakeAlreadyConnected", {
-                        devId,
-                        duration: Date.now() - startedAt,
-                    });
-                    return resolve(true);
-                }
-                const connecting = await ipc.isConnecting(devId);
-                if (!connecting.isConnecting) {
-                    sdkLog("info", "connectDevice", "awakeIpcConnectStart", { devId });
-                    await ipc.connect(devId);
-                }
-                else {
-                    sdkLog("debug", "connectDevice", "awakeIpcConnecting", { devId });
-                }
-            }
-            catch (error) {
-                sdkLog("error", "connectDevice", "awakeFail", {
-                    devId,
-                    duration: Date.now() - startedAt,
-                    error,
-                });
-                reject(error);
-            }
-        };
-        run();
-    });
-};
 const connectBle = async (devId, timeout) => {
     const startedAt = Date.now();
     sdkLog("info", "connectDevice", "bleConnectStart", { devId });
@@ -147,7 +85,7 @@ export async function connectDeviceForRuntime(rt, timeout) {
     const cfg = rt.config;
     const devId = cfg.devInfo.devId;
     const deviceStatus = getDeviceStatusForRuntime(rt);
-    const hasWirelessAwakeDp = !!cfg.dpSchema[wirelessAwake];
+    const hasWirelessAwakeDp = hasDpForRuntime(rt, wirelessAwake) && !cfg.notSupportWake;
     const startedAt = Date.now();
     sdkLog("info", "connectDevice", "start", {
         devId,
@@ -160,7 +98,7 @@ export async function connectDeviceForRuntime(rt, timeout) {
     });
     if (deviceStatus.connectEnable && hasWirelessAwakeDp) {
         if (cfg.devInfo.isCloudOnline && !getDpValueForRuntime(rt, wirelessAwake)) {
-            const result = await awakeDevice(devId, timeout);
+            const result = await awakeDeviceForRuntime(rt, { timeout });
             sdkLog("info", "connectDevice", "success", {
                 devId,
                 duration: Date.now() - startedAt,
@@ -208,5 +146,99 @@ export async function connectDeviceForRuntime(rt, timeout) {
 export const awakeDeviceForRuntime = (runtime, options) => {
     const cfg = runtime.config;
     const devId = cfg.devInfo.devId;
-    return awakeDevice(devId, options?.timeout);
+    const timeout = options?.timeout || 15000;
+    const startedAt = Date.now();
+    const hasWirelessAwake = hasDpForRuntime(runtime, wirelessAwake) && !cfg.notSupportWake;
+    sdkLog("info", "connectDevice", "awakeStart", {
+        devId,
+        data: { timeout, hasWirelessAwake },
+    });
+    return new Promise((resolve, reject) => {
+        const handleChangeDp = (dpCodesArg) => {
+            if (dpCodesArg[wirelessAwake] === true) {
+                sdkLog("info", "connectDevice", "awakeReportSuccess", {
+                    devId,
+                    duration: Date.now() - startedAt,
+                });
+                resolve(true);
+                emitter.off(DPCHANGE, handleChangeDp);
+                clearTimeout(timer);
+            }
+        };
+        hasWirelessAwake && emitter.on(DPCHANGE, handleChangeDp);
+        const timer = setTimeout(() => {
+            emitter.off(DPCHANGE, handleChangeDp);
+            const error = getError(1002);
+            sdkLog("warn", "connectDevice", "awakeTimeout", {
+                devId,
+                duration: Date.now() - startedAt,
+                error,
+            });
+            reject(error);
+        }, timeout);
+        const run = async () => {
+            try {
+                ipc.wakeUpDoorBell(devId);
+                ipc.wakeUpDoorBell(devId);
+                ipc.wakeUpDoorBell(devId);
+                const connected = await ipc.isConnected(devId);
+                if (connected.isConnected) {
+                    sdkLog("info", "connectDevice", "awakeAlreadyConnected", {
+                        devId,
+                        duration: Date.now() - startedAt,
+                    });
+                    clearTimeout(timer);
+                    return resolve(true);
+                }
+                const connecting = await ipc.isConnecting(devId);
+                if (!connecting.isConnecting) {
+                    sdkLog("info", "connectDevice", "awakeIpcConnectStart", { devId });
+                    await ipc.connect(devId);
+                    if (!hasWirelessAwake) {
+                        clearTimeout(timer);
+                        return resolve(true);
+                    }
+                }
+                else {
+                    sdkLog("debug", "connectDevice", "awakeIpcConnecting", { devId });
+                }
+            }
+            catch (error) {
+                sdkLog("error", "connectDevice", "awakeFail", {
+                    devId,
+                    duration: Date.now() - startedAt,
+                    error,
+                });
+                reject(error);
+            }
+        };
+        run();
+    });
+};
+export const disconnectDeviceForRuntime = async (rt, options) => {
+    const cfg = rt.config;
+    const devId = cfg.devInfo.devId;
+    const startedAt = Date.now();
+    sdkLog("info", "disconnectDevice", "start", {
+        devId,
+    });
+    try {
+        const deviceStatus = getDeviceStatusForRuntime(rt);
+        await ipc.disConnect(devId);
+        if (deviceStatus.onlineTypes.includes("ble") && !!options?.disconnetBle) {
+            await disconnectBLEDevice(devId);
+        }
+        sdkLog("info", "disconnectDevice", "success", {
+            devId,
+            duration: Date.now() - startedAt,
+        });
+    }
+    catch (e) {
+        sdkLog("error", "disconnectDevice", "Fail", {
+            devId,
+            duration: Date.now() - startedAt,
+            error: e,
+        });
+        throw e;
+    }
 };

package/lib/platform/device.d.ts

@@ -173,6 +173,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 disconnectBLEDevice: (deviceId: string) => Promise<void>;
 export interface BLEFileTransferParams {
     deviceId: string;
     fileId: number;

package/lib/platform/device.js

@@ -365,6 +365,15 @@ export const connectBLEDevice = (deviceId) => {
         });
     });
 };
+export const disconnectBLEDevice = (deviceId) => {
+    return new Promise((resolve, reject) => {
+        ty.device.disconnectBLEDevice({
+            deviceId,
+            success: () => resolve(),
+            fail: reject,
+        });
+    });
+};
 export const postBLEFileTransfer = (params) => {
     return new Promise((resolve, reject) => {
         const device = ty.device;
@@ -450,10 +459,10 @@ export const offAppShow = (cb) => {
     ty.offAppShow(cb);
 };
 export const onAppHide = (cb) => {
-    ty.onAppShow(cb);
+    ty.onAppHide(cb);
 };
 export const offAppHide = (cb) => {
-    ty.offAppShow(cb);
+    ty.offAppHide(cb);
 };
 export const trackEvent = (event, data) => {
     ty.event({

package/lib/platform/ipc.d.ts

@@ -6,6 +6,7 @@ declare const _default: {
     isConnecting: (deviceId: string) => Promise<{
         isConnecting: boolean;
     }>;
+    disConnect: (deviceId: string) => Promise<unknown>;
     connect: (deviceId: string) => Promise<unknown>;
     getCurrentSupportedTalkMode: (deviceId: string) => Promise<{
         talkbackMode: number;

package/lib/platform/ipc.js

@@ -18,6 +18,11 @@ const connect = (deviceId) => {
         ty.ipc.connect({ deviceId, success: resolve, fail: reject });
     });
 };
+const disConnect = (deviceId) => {
+    return new Promise((resolve, reject) => {
+        ty.ipc.disConnect({ deviceId, success: resolve, fail: reject });
+    });
+};
 const getCurrentSupportedTalkMode = (deviceId) => {
     if (ty.ipc.getCurrentSupportedTalkMode) {
         return new Promise((resolve, reject) => {
@@ -47,6 +52,7 @@ export default {
     wakeUpDoorBell,
     isConnected,
     isConnecting,
+    disConnect,
     connect,
     getCurrentSupportedTalkMode,
     getTTTAbilityKeyList,

package/package.json

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