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

package/lib/config/index.d.ts

@@ -1,5 +1,5 @@
 import { ProductCommunicationType } from "../constant";
-import { CapabilityInfo, DeviceInfo, DpSchema, RemotePermission, DeviceStatus } from "../interface";
+import { CapabilityInfo, DeviceInfo, DpSchema, RemotePermission, DeviceStatus, LockSDKOption } from "../interface";
 declare const config: {
     devInfo: DeviceInfo;
     dpSchema: Record<string, DpSchema>;
@@ -17,6 +17,11 @@ declare const config: {
     imageAngle: number;
     videoAngle: number;
     supportMultipleFace: boolean;
+    supportOfflineDps: boolean;
     deviceStatus: DeviceStatus;
 };
+type UpdateConfigParams = Omit<LockSDKOption, "devInfo" | "deviceId">;
+export declare const updateConfig: (options: UpdateConfigParams) => void;
+export declare const hasCapability: (capability: ProductCommunicationType) => boolean;
+export declare const hasDp: (dpCode: string) => boolean;
 export default config;

package/lib/config/index.js

@@ -15,10 +15,26 @@ const config = {
     imageAngle: 0,
     videoAngle: 0,
     supportMultipleFace: false,
+    supportOfflineDps: false,
     deviceStatus: {
         type: "offline",
-        connectEanble: false,
+        connectEnable: false,
         onlineType: "none",
+        isWifiActive: false,
     },
 };
+export const updateConfig = (options) => {
+    Object.keys(options).forEach((key) => {
+        const value = options[key];
+        if (value !== undefined) {
+            config[key] = value;
+        }
+    });
+};
+export const hasCapability = (capability) => {
+    return config.communication.includes(capability);
+};
+export const hasDp = (dpCode) => {
+    return !!config.dpSchema[dpCode];
+};
 export default config;

package/lib/index.d.ts

@@ -1,6 +1,9 @@
+import { hasCapability, hasDp, updateConfig } from "./config";
 import { LockSDKOption } from "./interface";
 import { getCurrentUser, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, getCurrentUserSync, getMediaRotate } from "./state";
-import { syncUnlockMethod } from "./sync/unlock-mothod";
+import { syncUnlockMethod } from "./sync/unlock-method";
+import { publishDps } from "./utils/publishDps";
+import { publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache } from "./offline-dps";
 export * from "./user";
 export * from "./unlock-method";
 export * from "./temporary";
@@ -13,6 +16,7 @@ export * from "./constant";
 export * from "./other";
 export * from "./media";
 export * from "./linkage";
+export * from "./capability";
 export declare const init: (options?: LockSDKOption) => Promise<void>;
 export declare const destroy: () => void;
-export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, };
+export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };

package/lib/index.js

@@ -1,9 +1,11 @@
-import config from "./config";
+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 { syncUnlockMethod } from "./sync/unlock-mothod";
+import { syncUnlockMethod } from "./sync/unlock-method";
+import { publishDps } from "./utils/publishDps";
+import { publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, } from "./offline-dps";
 export * from "./user";
 export * from "./unlock-method";
 export * from "./temporary";
@@ -16,6 +18,7 @@ export * from "./constant";
 export * from "./other";
 export * from "./media";
 export * from "./linkage";
+export * from "./capability";
 export const init = async (options) => {
     let { devInfo, deviceId } = options || {};
     if (!devInfo && !deviceId) {
@@ -50,6 +53,8 @@ export const init = async (options) => {
     config.strictMode = options?.strictMode ?? true;
     config.passwordDigitalBase = options?.passwordDigitalBase ?? 10;
     config.passwordSupportZero = options?.passwordSupportZero ?? true;
+    config.supportMultipleFace = options?.supportMultipleFace ?? false;
+    config.supportOfflineDps = options?.supportOfflineDps ?? false;
     config.devInfo = devInfo;
     config.dpSchema = dpSchema;
     config.codesById = codesById;
@@ -63,4 +68,4 @@ export const destroy = () => {
     clearState();
     removeEvents();
 };
-export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, };
+export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };

package/lib/interface.d.ts

@@ -8,6 +8,8 @@ export interface LockSDKOption {
     strictMode?: boolean;
     passwordDigitalBase?: number;
     passwordSupportZero?: boolean;
+    supportMultipleFace?: boolean;
+    supportOfflineDps?: boolean;
 }
 export interface ErrorData {
     errorCode: number;
@@ -39,6 +41,7 @@ export interface DeviceInfo {
     wifiEnableState?: number;
     activeTime: number;
     dpsTime: Record<string, string>;
+    parentId?: string;
 }
 export interface DpSchema {
     type: "raw" | "obj";
@@ -180,12 +183,13 @@ export interface UnBindUnlockMethodGroup {
 }
 export interface DeviceStatus {
     type: "offline" | "online" | "sleep";
-    connectEanble: boolean;
+    connectEnable: boolean;
     onlineType: "local" | "cloud" | "ble" | "none" | "unknown";
     sleepPeriod?: {
         start: number;
         end: number;
     };
+    isWifiActive: boolean;
 }
 export interface UnionUnlockInfo {
     userId: string;
@@ -287,4 +291,32 @@ export interface AlbumMessage extends MediaInfo {
     type: number;
     createTime: number;
 }
+export interface DeviceAdvancedAbility {
+    cloudStorage: {
+        support: boolean;
+    };
+    ai: {
+        support: boolean;
+        config: Record<string, any>;
+    };
+    wechat: {
+        support: boolean;
+        config: Record<string, any>;
+    };
+    wechatVoip: {
+        support: boolean;
+        config: Record<string, any>;
+    };
+    voip: {
+        support: boolean;
+        config: Record<string, any>;
+    };
+}
+export interface OfflineDpInfo {
+    value: DpValue;
+    pushStatus: boolean;
+}
+export interface OfflineDps {
+    [code: string]: OfflineDpInfo;
+}
 export {};

package/lib/media.d.ts

@@ -10,4 +10,5 @@ interface MediaUrlResult {
     mediaUrl: string;
 }
 export declare const getMediaUrl: (params: GetMediaUrlParams | GetFileUrlParams) => Promise<MediaUrlResult>;
+export declare const isSupportMedia: () => boolean;
 export {};

package/lib/media.js

@@ -1,5 +1,7 @@
 import { getMediaUrl as getMediaUrlApi } from "./api/log";
-import config from "./config";
+import config, { hasDp } from "./config";
+import dpCodes from "./config/dp-code";
+import { VedioType } from "./constant";
 export const getMediaUrl = async (params) => {
     if ("mediaPath" in params && "mediaBucket" in params) {
         return getMediaUrlApi({
@@ -17,3 +19,9 @@ export const getMediaUrl = async (params) => {
     }
     throw new Error("Invalid parameters");
 };
+export const isSupportMedia = () => {
+    return (hasDp(dpCodes.linkMode) &&
+        hasDp(dpCodes.initiativeMessage) &&
+        (!hasDp(dpCodes.deviceInfo) ||
+            config.capabilities?.vedioType === VedioType.VEDIO_OR_SNAPSHOT));
+};

package/lib/offline-dps.d.ts

@@ -0,0 +1,9 @@
+import { DpValue, OfflineDps } from "./interface";
+export declare const getOfflineDps: (isForce?: boolean) => Promise<OfflineDps>;
+export declare const checkOfflineDpUpdate: (dps: Record<string, DpValue>, isForce?: boolean) => Promise<void>;
+export declare const getOfflineDpCache: (code: string) => import("./interface").OfflineDpInfo;
+export declare const publishOfflineDps: (dps: Record<string, DpValue>) => Promise<void>;
+export declare const clearOfflineDps: () => Promise<void>;
+export declare const onOfflineDpsUpdate: (callback: (dps: OfflineDps) => void) => void;
+export declare const offOfflineDpsUpdate: (callback: (dps: OfflineDps) => void) => void;
+export declare const isOfflineDpSyncing: (code: string) => boolean;

package/lib/offline-dps.js

@@ -0,0 +1,84 @@
+import { clearOfflineDpData, fetchOfflineDpData, publishOfflineDpData, } from "./api";
+import config from "./config";
+import base64ToHex from "./utils/base64-to-hex";
+import hexToBase64 from "./utils/hex-to-base64";
+import emitter from "./utils/event";
+let cache;
+export const getOfflineDps = async (isForce) => {
+    if (!isForce && cache) {
+        return cache;
+    }
+    const { devInfo, dpSchema } = config;
+    const res = await fetchOfflineDpData(devInfo.devId);
+    const result = res.reduce((acc, item) => {
+        const dps = JSON.parse(item.dps);
+        Object.keys(dps).forEach((code) => {
+            const schema = dpSchema[code];
+            let value = dps[code];
+            if (schema?.type === "raw") {
+                value = base64ToHex(value);
+            }
+            acc[code] = { value, pushStatus: item.pushStatus };
+        });
+        return acc;
+    }, {});
+    cache = result;
+    return result;
+};
+export const checkOfflineDpUpdate = async (dps, isForce) => {
+    if (!config.supportOfflineDps) {
+        return;
+    }
+    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];
+};
+export const publishOfflineDps = async (dps) => {
+    const { devInfo, dpSchema } = config;
+    const dpData = Object.keys(dps).reduce((acc, code) => {
+        const schema = dpSchema[code];
+        if (schema) {
+            let value = dps[code];
+            if (schema.type === "raw") {
+                value = hexToBase64(value);
+            }
+            acc[schema.id] = value;
+        }
+        return acc;
+    }, {});
+    await publishOfflineDpData(devInfo.devId, dpData);
+    try {
+        await checkOfflineDpUpdate({}, true);
+    }
+    catch {
+    }
+};
+export const clearOfflineDps = async () => {
+    const { devInfo } = config;
+    await clearOfflineDpData(devInfo.devId);
+    try {
+        await checkOfflineDpUpdate({}, true);
+    }
+    catch {
+    }
+};
+const OFFLINE_DPS_UPDATE = "offline_dps_update";
+export const onOfflineDpsUpdate = (callback) => {
+    emitter.on(OFFLINE_DPS_UPDATE, callback);
+};
+export const offOfflineDpsUpdate = (callback) => {
+    emitter.off(OFFLINE_DPS_UPDATE, callback);
+};
+export const isOfflineDpSyncing = (code) => {
+    const { supportOfflineDps } = config;
+    if (!supportOfflineDps) {
+        return false;
+    }
+    const cache = getOfflineDpCache(code);
+    return cache && cache.pushStatus === false;
+};

package/lib/open.d.ts

@@ -11,6 +11,9 @@ export declare const getRemoteEnabled: () => boolean;
 export declare const getRemotePermissionList: () => RemotePermission[];
 export declare const getRemotePermission: () => RemotePermission;
 export declare const updateRemotePermission: (permission: RemotePermission) => Promise<void>;
+export declare const getVoiceUnlockPwdEnabled: () => Promise<boolean>;
+export declare const voiceUnlockPwdDisabled: () => Promise<boolean>;
+export declare const updateVoiceUnlockPwd: (password: string) => Promise<boolean>;
 export declare const agreeOpenDoor: (option?: {
     timeout?: number;
 } | undefined) => Promise<unknown>;

package/lib/open.js

@@ -1,8 +1,8 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { getDoorKey, openDoorByCloud, isConfirmOpenDoorByWifiPro, } from "./api/lock";
-import config from "./config";
+import config, { hasCapability } from "./config";
 import { isUseNearChannel, parallelMerge, parallelOnly } from "./utils";
-import { decrypt } from "./utils/device";
+import { decrypt, encrypt } from "./utils/device";
 import { publishDps } from "./utils/publishDps";
 import { open as openMap, reportOpen as reportOpenMap, } from "./config/dp-map/open";
 import { stringToBytes } from "./utils/byte";
@@ -10,10 +10,11 @@ import emitter from "./utils/event";
 import { getError } from "./utils/errors";
 import { DPCHANGE } from "./utils/constant";
 import dpCodes from "./config/dp-code";
-import { getCurrentUser, permissions } from "./state";
+import { getCurrentUser, getDeviceStatus, permissions } from "./state";
 import { setDeviceProperties } from "./api/setting";
 import syncRemoteSerectKey from "./sync/remote-serect-key";
-import { ProductCommunicationType } from "./constant";
+import { ProductCommunicationType, UserType } from "./constant";
+import { getVoicePwdEnabled, setVoicePwd } from "./api";
 const getReportError = (status) => {
     let error = getError(1004);
     switch (status) {
@@ -34,25 +35,40 @@ const getReportError = (status) => {
     return error;
 };
 export const checkRemoteEnabled = parallelMerge(async () => {
-    const { devInfo, dpSchema, remoteOpenEnabled, remoteOpenPermission } = config;
+    const { dpSchema, remoteOpenEnabled, remoteOpenPermission } = config;
     const { userType } = await getCurrentUser();
-    if (!devInfo.isOnline) {
+    const deviceStatus = getDeviceStatus();
+    const hasThread = hasCapability(ProductCommunicationType.THREAD);
+    if (deviceStatus.type !== "online") {
         throw getError(1001);
     }
+    if (deviceStatus.onlineType === "local") {
+        if (!hasThread) {
+            throw getError(1064);
+        }
+    }
     if (dpSchema[dpCodes.remoteNoDpKey] === undefined) {
         throw getError(1045);
     }
+    if ((hasThread && deviceStatus.onlineType === "local") ||
+        deviceStatus.onlineType === "ble") {
+        return;
+    }
     if (!remoteOpenEnabled) {
         throw getError(1046);
     }
     if (remoteOpenPermission === "noOne" ||
-        (remoteOpenPermission === "adminsOnly" && +userType === 20)) {
+        (remoteOpenPermission === "adminsOnly" &&
+            +userType !== UserType.ADMIN &&
+            +userType !== UserType.OWNER)) {
         throw getError(1047);
     }
 });
 const _doAction = async (isOpen, timeout) => {
     const { devInfo, onlineType, capabilities, communication, dpSchema } = config;
     await checkRemoteEnabled();
+    const deviceStatus = getDeviceStatus();
+    const hasThread = hasCapability(ProductCommunicationType.THREAD);
     const isNear = isUseNearChannel();
     const currentUser = await getCurrentUser();
     const memberId = currentUser.lockUserId !== 0 ? currentUser.lockUserId : currentUser.userId;
@@ -68,9 +84,17 @@ const _doAction = async (isOpen, timeout) => {
         }
         return false;
     };
+    if (hasThread && deviceStatus.onlineType === "local") {
+        await publishDps({ [dpCodes.matterLanUnlock]: isOpen }, {
+            checkReport: (dps) => {
+                return typeof dps[dpCodes.matterLanUnlock] !== "undefined";
+            },
+        });
+        return;
+    }
     if (isNear) {
-        if (communication.includes(ProductCommunicationType.WIFI) ||
-            communication.includes(ProductCommunicationType.THREAD)) {
+        if (hasCapability(ProductCommunicationType.WIFI) ||
+            hasCapability(ProductCommunicationType.THREAD)) {
             await syncRemoteSerectKey();
             let pw = "";
             try {
@@ -99,7 +123,7 @@ const _doAction = async (isOpen, timeout) => {
             return;
         }
         if (communication.length === 1 &&
-            communication.includes(ProductCommunicationType.BLUETOOTH)) {
+            hasCapability(ProductCommunicationType.BLUETOOTH)) {
             throw new Error("Bluetooth lock opening is not supported yet");
         }
     }
@@ -187,6 +211,28 @@ const handleOpenDoor = (confirm, timeout) => {
         });
     });
 };
+export const getVoiceUnlockPwdEnabled = async () => {
+    const res = await getVoicePwdEnabled(config.devInfo.devId);
+    return res === true || res === 1;
+};
+export const voiceUnlockPwdDisabled = async () => {
+    return setVoicePwd({
+        devId: config.devInfo.devId,
+        open: false,
+        pwd: "",
+    });
+};
+export const updateVoiceUnlockPwd = async (password) => {
+    if (!/^\d{4,6}$/.test(password)) {
+        throw getError(1063);
+    }
+    const encryptedPassword = await encrypt(config.devInfo.devId, password);
+    return setVoicePwd({
+        devId: config.devInfo.devId,
+        open: false,
+        pwd: encryptedPassword,
+    });
+};
 export const agreeOpenDoor = parallelOnly((option) => {
     return handleOpenDoor(true, option?.timeout || 15000);
 });

package/lib/other.d.ts

@@ -1,3 +1,4 @@
+import { DpValue } from "./interface";
 type ExecutorRange = "unlock" | "lock";
 type Ability = "backHome" | "alarm" | "geographyArrive" | "geographyLeave" | "bleGeofence" | "siriUnlock" | "siriLock";
 interface OpenSceneOptions {
@@ -6,7 +7,7 @@ interface OpenSceneOptions {
     abilities?: Array<Ability>;
 }
 export declare const openScene: (options?: OpenSceneOptions) => Promise<unknown>;
-export declare const isSupportBleControl: () => import("./interface").DpValue;
+export declare const isSupportBleControl: () => boolean;
 export declare const getDpPeriodTime: (dpCode: string) => {
     start: number;
     end: number;
@@ -14,5 +15,16 @@ export declare const getDpPeriodTime: (dpCode: string) => {
 export declare const updateDpPeriodTime: (dpCode: string, data: {
     start: number;
     end: number;
-}) => Promise<Record<string, import("./interface").DpValue>>;
+}, option?: {
+    offlineDp?: boolean;
+}) => Promise<void> | Promise<Record<string, DpValue>>;
+export declare const parseDpPeriodTime: (dpValue: string) => {
+    start: number;
+    end: number;
+};
+export declare const formatDpPeriodTime: (start: number, end: number) => string;
+export declare const connectDevice: () => Promise<unknown>;
+export declare const gotoService: (params?: {
+    tab?: "cloudStorage" | "AI";
+}) => Promise<unknown>;
 export {};