@ray-js/lock-sdk 1.1.0 → 1.1.1-beta.10

package/lib/api/index.d.ts

@@ -27,4 +27,12 @@ export declare const fetchOfflineDpData: (deviceId: string) => Promise<{
 }[]>;
 export declare const publishOfflineDpData: (deviceId: string, dpData: Record<string, DpValue>) => Promise<unknown>;
 export declare const clearOfflineDpData: (deviceId: string) => Promise<unknown>;
+export declare const getFileRemoteUrl: ({ biz, resources, }: {
+    biz: string;
+    resources: {
+        objectKey: string;
+    }[];
+}) => Promise<{
+    signedUrls: Record<string, string>;
+}>;
 export {};

package/lib/api/index.js

@@ -70,3 +70,13 @@ export const clearOfflineDpData = async (deviceId) => {
         version: "1.0",
     });
 };
+export const getFileRemoteUrl = ({ biz, resources, }) => {
+    return requestApi({
+        api: `${THING}.web.fastroute.download.sign`,
+        version: "2.0",
+        data: {
+            biz,
+            signedRequest: { resources },
+        },
+    });
+};

package/lib/api/lock.d.ts

@@ -124,4 +124,9 @@ interface BindUnlockMethodToUserByRecordParams {
     unlockIds: string[];
 }
 export declare const bindUnlockMethodToUserByRecord: (params: BindUnlockMethodToUserByRecordParams) => Promise<boolean>;
+interface ValidatePasswordComplexityParams {
+    devId: string;
+    password: string;
+}
+export declare const validatePasswordComplexity: (params: ValidatePasswordComplexityParams) => Promise<boolean>;
 export {};

package/lib/api/lock.js

@@ -116,3 +116,10 @@ export const bindUnlockMethodToUserByRecord = (params) => {
         data: params,
     });
 };
+export const validatePasswordComplexity = (params) => {
+    return requestApi({
+        api: "m.lock.password.simplicity.check",
+        version: "1.0",
+        data: params,
+    });
+};

package/lib/api/temp.js

@@ -38,7 +38,7 @@ export const getTempPassword = (params) => {
 export const deleteTempPassword = (params) => {
     return requestApi({
         api: `${THING}.m.device.lock.temppwd.remove`,
-        version: "2.0",
+        version: "5.0",
         data: params,
     });
 };

package/lib/api/user.d.ts

@@ -102,6 +102,12 @@ interface UserDetail {
     userType: number;
 }
 export declare const getUserDetail: (params: GetUserDetailParams) => Promise<UserDetail>;
+interface GetUserDetailQueryParams {
+    devId: string;
+    userId: string;
+    dpIds: string;
+}
+export declare const getUserDetailQuery: (params: GetUserDetailQueryParams) => Promise<UserListItem>;
 export interface RemovedUserData {
     userId: string;
     lockUserId: number;

package/lib/api/user.js

@@ -40,8 +40,15 @@ export const getUserList = (params) => {
 };
 export const getUserDetail = (params) => {
     return requestApi({
-        api: `${THING}.m.device.member.detail`,
-        version: "4.0",
+        api: "m.lock.device.member.detail",
+        version: "1.0",
+        data: params,
+    });
+};
+export const getUserDetailQuery = (params) => {
+    return requestApi({
+        api: "m.lock.user.detail.query",
+        version: "1.0",
         data: params,
     });
 };

package/lib/capability.js

@@ -45,6 +45,7 @@ export const getDeviceAdvancedAbilities = async () => {
             "tyabi4ucx5",
             "tyabis9tpe",
             "tyabiwxrn9",
+            "tyabipd4hh",
         ]),
         getDeviceAdvancedAbility(config.devInfo.devId),
     ]);
@@ -68,27 +69,52 @@ export const getDeviceAdvancedAbilities = async () => {
             support: false,
             config: {},
         },
+        unlockGuide: {
+            support: false,
+            config: {},
+        },
     };
     productAbilities.forEach((item) => {
-        const data = JSON.parse(item.extConfig);
-        if (item.abilityCode === "tyabi4ucx5" && item.isOpen) {
-            deviceAdvanceAbilityCache.ai.config = data;
-            const dataReport = data?.ai_data_report ?? false;
-            const itemRecognition = data?.ai_recognition?.[0]?.item_recognition ?? false;
-            const petRecognition = data?.ai_recognition?.[0]?.pet_recognition ?? false;
-            const voice = data?.ai_voice ?? false;
-            const message = data?.ai_message ?? false;
-            deviceAdvanceAbilityCache.ai.support =
-                dataReport || itemRecognition || petRecognition || voice || message;
-        }
-        else if (item.abilityCode === "tyabis9tpe" && item.isOpen) {
-            deviceAdvanceAbilityCache.wechat.support = true;
-            deviceAdvanceAbilityCache.wechat.config = data;
+        try {
+            if (item.isOpen) {
+                const data = JSON.parse(item.extConfig);
+                switch (item.abilityCode) {
+                    case "tyabi4ucx5": {
+                        deviceAdvanceAbilityCache.ai.config = data;
+                        const dataReport = data?.ai_data_report ?? false;
+                        const itemRecognition = data?.ai_recognition?.[0]?.item_recognition ?? false;
+                        const petRecognition = data?.ai_recognition?.[0]?.pet_recognition ?? false;
+                        const voice = data?.ai_voice ?? false;
+                        const message = data?.ai_message ?? false;
+                        deviceAdvanceAbilityCache.ai.support =
+                            dataReport ||
+                                itemRecognition ||
+                                petRecognition ||
+                                voice ||
+                                message;
+                        break;
+                    }
+                    case "tyabis9tpe": {
+                        deviceAdvanceAbilityCache.wechat.support = true;
+                        deviceAdvanceAbilityCache.wechat.config = data;
+                        break;
+                    }
+                    case "tyabiwxrn9": {
+                        deviceAdvanceAbilityCache.wechatVoip.support =
+                            !!data?.voipType?.includes("0");
+                        deviceAdvanceAbilityCache.wechatVoip.config = data;
+                        break;
+                    }
+                    case "tyabipd4hh": {
+                        deviceAdvanceAbilityCache.unlockGuide.support = true;
+                        deviceAdvanceAbilityCache.unlockGuide.config = data;
+                        break;
+                    }
+                }
+            }
         }
-        else if (item.abilityCode === "tyabiwxrn9" && item.isOpen) {
-            deviceAdvanceAbilityCache.wechatVoip.support =
-                !!data?.voipType?.includes("0");
-            deviceAdvanceAbilityCache.wechatVoip.config = data;
+        catch (error) {
+            console.warn(`setting [${item.abilityCode}] config error`, error);
         }
     });
     return deviceAdvanceAbilityCache;

package/lib/config/dp-code/index.d.ts

@@ -1,4 +1,5 @@
 declare const dpCodes: {
+    lockMotorState: string;
     remoteNoDpKey: string;
     remoteNoPdSetkey: string;
     synchMethodW: string;

package/lib/config/dp-code/index.js

@@ -1,4 +1,5 @@
 const dpCodes = {
+    lockMotorState: 'lock_motor_state',
     remoteNoDpKey: "remote_no_dp_key",
     remoteNoPdSetkey: "remote_no_pd_setkey",
     synchMethodW: "synch_method_w",

package/lib/config/dp-map/common.js

@@ -52,7 +52,7 @@ export const validConfigDpMap = {
                     .slice(0, 7);
             },
             format: (value) => {
-                const weekHex = parseInt(value.reverse().join(""), 2)
+                const weekHex = parseInt([...value].reverse().join(""), 2)
                     .toString(16)
                     .padStart(2, "0");
                 return `000000${weekHex}`;

package/lib/config/dp-map/unlock-method-big.d.ts

@@ -382,17 +382,16 @@ declare const reportAddTempPwd: ({
     name: string;
     bytes?: undefined;
 })[];
-declare const removeTempPwd: {
-    name: string;
-    bytes: number;
-}[];
-declare const reportRemoveTempPwd: ({
-    name: string;
-    bytes: number;
-} | {
-    name: string;
-    bytes?: undefined;
-})[];
+declare const removeTempPwd: readonly [{
+    readonly name: "unlockId";
+    readonly bytes: 2;
+}];
+declare const reportRemoveTempPwd: readonly [{
+    readonly name: "unlockId";
+    readonly bytes: 2;
+}, {
+    readonly name: "status";
+}];
 declare const updateTempPwd: ({
     readonly name: "validConfig";
     readonly type: "child";

package/lib/config/index.d.ts

@@ -18,9 +18,10 @@ declare const config: {
     videoAngle: number;
     supportMultipleFace: boolean;
     supportOfflineDps: boolean;
+    preFetch: boolean;
     deviceStatus: DeviceStatus;
 };
-type UpdateConfigParams = Omit<LockSDKOption, "devInfo" | "deviceId">;
+type UpdateConfigParams = Omit<LockSDKOption, "devInfo" | "deviceId" | "preFetch">;
 export declare const updateConfig: (options: UpdateConfigParams) => void;
 export declare const hasCapability: (capability: ProductCommunicationType) => boolean;
 export declare const hasDp: (dpCode: string) => boolean;

package/lib/config/index.js

@@ -16,6 +16,7 @@ const config = {
     videoAngle: 0,
     supportMultipleFace: false,
     supportOfflineDps: false,
+    preFetch: false,
     deviceStatus: {
         type: "offline",
         connectEnable: false,

package/lib/index.js

@@ -60,9 +60,10 @@ export const init = async (options) => {
     config.codesById = codesById;
     config.idsByCode = idsByCode;
     config.supportBigData = !!dpSchema[dpCodes.synchMethodW];
+    config.preFetch = options?.preFetch ?? false;
     config.communication = getCapabilities(devInfo.capability).map((item) => item.id);
-    await initState();
     addEvents();
+    await initState();
 };
 export const destroy = () => {
     clearState();

package/lib/interface.d.ts

@@ -10,6 +10,7 @@ export interface LockSDKOption {
     passwordSupportZero?: boolean;
     supportMultipleFace?: boolean;
     supportOfflineDps?: boolean;
+    preFetch?: boolean;
 }
 export interface ErrorData {
     errorCode: number;
@@ -81,7 +82,7 @@ export interface CurrentUser {
     permanent: boolean;
 }
 export interface UnlockMethodBaseInfo {
-    unlockId: string;
+    unlockId: number;
     unlockName: string;
     isBound: boolean;
     id: number;
@@ -143,11 +144,13 @@ export type DpMapDataType<T extends DpMapType> = {
 };
 export interface NotifyInfo {
     appSend?: boolean;
+    msgSend?: boolean;
     msgPhone?: string;
     countryCode?: string;
 }
 export interface UnlockMethodDetail {
     isBound: boolean;
+    type: UnlockMethodType;
     phase: number;
     dpId: number;
     isSpecial: boolean;
@@ -185,6 +188,7 @@ export interface DeviceStatus {
     type: "offline" | "online" | "sleep";
     connectEnable: boolean;
     onlineType: "local" | "cloud" | "ble" | "none" | "unknown";
+    onlineTypes: Array<"local" | "cloud" | "ble" | "localMatter" | "unknown">;
     sleepPeriod?: {
         start: number;
         end: number;
@@ -311,6 +315,10 @@ export interface DeviceAdvancedAbility {
         support: boolean;
         config: Record<string, any>;
     };
+    unlockGuide: {
+        support: boolean;
+        config: Record<string, any>;
+    };
 }
 export interface OfflineDpInfo {
     value: DpValue;
@@ -319,4 +327,9 @@ export interface OfflineDpInfo {
 export interface OfflineDps {
     [code: string]: OfflineDpInfo;
 }
+export interface UnlockGuide {
+    videoUrl: string;
+    picUrl: string;
+    expireTime: number;
+}
 export {};

package/lib/log.js

@@ -36,6 +36,12 @@ export const getLatestLogs = async () => {
                 catch {
                 }
             }
+            let userName = item.userName;
+            let unlockName = item.unlockName;
+            if (item.dpId === 89 || item.dpId === 69) {
+                unlockName = item.userName;
+                userName = "";
+            }
             return {
                 type,
                 logId: item.logId,
@@ -43,8 +49,8 @@ export const getLatestLogs = async () => {
                 dpCode,
                 data: itemData,
                 userId: item.userId,
-                userName: item.userName,
-                unlockName: item.unlockName,
+                userName,
+                unlockName,
                 mediaInfo: item.mediaInfoList,
                 unionUnlockInfo: item.unionUnlockInfo?.map((item1) => {
                     return {
@@ -142,6 +148,12 @@ export const getLogs = async (params) => {
             if (dpCode === dpCodes.lockLocalRecord) {
                 type = "local_operation";
             }
+            let userName = record.userName;
+            let unlockName = record.unlockName;
+            if (record.dpId === 89 || record.dpId === 69) {
+                unlockName = record.userName;
+                userName = "";
+            }
             return {
                 type,
                 logId: record.historyId.toString(),
@@ -149,8 +161,8 @@ export const getLogs = async (params) => {
                 dpId: record.dpId,
                 data: dpValue,
                 dpCode,
-                userName: record.userName,
-                unlockName: record.unlockName,
+                userName,
+                unlockName,
                 mediaInfo: record.mediaInfoList,
                 unionUnlockInfo: record.unionUnlockInfo?.map((item) => ({
                     userId: item.userId,

package/lib/open.js

@@ -1,6 +1,6 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { getDoorKey, openDoorByCloud, isConfirmOpenDoorByWifiPro, } from "./api/lock";
-import config, { hasCapability } from "./config";
+import config, { hasCapability, hasDp } from "./config";
 import { isUseNearChannel, parallelMerge, parallelOnly } from "./utils";
 import { decrypt, encrypt } from "./utils/device";
 import { publishDps } from "./utils/publishDps";
@@ -42,18 +42,18 @@ export const checkRemoteEnabled = parallelMerge(async () => {
     if (deviceStatus.type !== "online") {
         throw getError(1001);
     }
-    if (deviceStatus.onlineType === "local") {
-        if (!hasThread) {
-            throw getError(1064);
-        }
+    const isLocalOnline = deviceStatus.onlineTypes.length === 1 &&
+        deviceStatus.onlineTypes.includes("local");
+    const isThreadLocalOnline = hasThread && isLocalOnline;
+    if (isThreadLocalOnline || deviceStatus.onlineTypes.includes("ble")) {
+        return;
+    }
+    if (isLocalOnline) {
+        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);
     }
@@ -65,7 +65,7 @@ export const checkRemoteEnabled = parallelMerge(async () => {
     }
 });
 const _doAction = async (isOpen, timeout) => {
-    const { devInfo, onlineType, capabilities, communication, dpSchema } = config;
+    const { devInfo, communication } = config;
     await checkRemoteEnabled();
     const deviceStatus = getDeviceStatus();
     const hasThread = hasCapability(ProductCommunicationType.THREAD);
@@ -73,9 +73,19 @@ const _doAction = async (isOpen, timeout) => {
     const currentUser = await getCurrentUser();
     const memberId = currentUser.lockUserId !== 0 ? currentUser.lockUserId : currentUser.userId;
     const checkReport = (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 {
@@ -84,7 +94,7 @@ const _doAction = async (isOpen, timeout) => {
         }
         return false;
     };
-    if (hasThread && deviceStatus.onlineType === "local") {
+    if (hasThread && deviceStatus.onlineTypes.includes("local") && deviceStatus.onlineTypes.length === 1) {
         await publishDps({ [dpCodes.matterLanUnlock]: isOpen }, {
             checkReport: (dps) => {
                 return typeof dps[dpCodes.matterLanUnlock] !== "undefined";
@@ -229,7 +239,7 @@ export const updateVoiceUnlockPwd = async (password) => {
     const encryptedPassword = await encrypt(config.devInfo.devId, password);
     return setVoicePwd({
         devId: config.devInfo.devId,
-        open: false,
+        open: true,
         pwd: encryptedPassword,
     });
 };

package/lib/other.d.ts

@@ -27,4 +27,5 @@ export declare const connectDevice: () => Promise<unknown>;
 export declare const gotoService: (params?: {
     tab?: "cloudStorage" | "AI";
 }) => Promise<unknown>;
+export declare const validatePwdComplexity: (password: string) => Promise<boolean>;
 export {};

package/lib/other.js

@@ -3,13 +3,14 @@ import config, { hasCapability, hasDp } from "./config";
 import dpCodes from "./config/dp-code";
 import { ProductCommunicationType } from "./constant";
 import { getDeviceStatus, getDpValue } from "./state";
-import { connectBLEDevice, getBLEOnlineState, navigateToMiniProgram, offBleChange, offOnlineChange, onBleChange, onOnlineChange, openPanel, } from "./utils/device";
+import { connectBLEDevice, encrypt, getBLEOnlineState, navigateToMiniProgram, offBleChange, offOnlineChange, onBleChange, onOnlineChange, openPanel, } from "./utils/device";
 import { getError } from "./utils/errors";
 import { publishDps } from "./utils/publishDps";
 import ipc from "./utils/ipc";
 import { DPCHANGE } from "./utils/constant";
 import emitter from "./utils/event";
 import { getOfflineDpCache, publishOfflineDps } from "./offline-dps";
+import { validatePasswordComplexity } from "./api/lock";
 const { alarmLock, unlockFingerprint, unlockPassword, unlockCard, unlockKey, unlockPhoneRemote, unlockTemporary, unlockDynamic, unlockFace, unlockHand, unlockEye, unlockFingerVein, unlockInside, doorOpened, unlockApp, unlockOfflinePd, openInside, lockRecord, unlockDoubleKit, lockLocalRecord, wirelessAwake, } = dpCodes;
 const abilityMap = {
     backHome: "supportBackHome",
@@ -71,26 +72,26 @@ export const openScene = async (options) => {
     });
 };
 export const isSupportBleControl = () => {
-    const { devInfo, idsByCode, communication } = config;
-    if (!idsByCode[dpCodes.unlockBle]) {
-        return false;
-    }
+    const { devInfo, idsByCode } = config;
     const hasThread = hasCapability(ProductCommunicationType.THREAD);
     const hasWifi = hasCapability(ProductCommunicationType.WIFI);
     const hasBle = hasCapability(ProductCommunicationType.BLUETOOTH);
     if (!hasBle) {
         return false;
     }
-    if (hasThread) {
-        if (!devInfo?.meta?.["threadWithBLE"]) {
+    if (hasWifi && hasBle) {
+        if (!hasDp(dpCodes.unlockBle)) {
             return false;
         }
-    }
-    if (hasWifi && hasBle) {
         if (devInfo.wifiEnableState === 1) {
             return true;
         }
     }
+    if (hasThread && hasBle) {
+        if (!devInfo?.meta?.["threadWithBLE"]) {
+            return false;
+        }
+    }
     const bleControlDp = idsByCode[dpCodes.bleControl];
     if (bleControlDp) {
         const reportTIme = devInfo?.dpsTime?.[bleControlDp];
@@ -101,7 +102,7 @@ export const isSupportBleControl = () => {
         }
         return getDpValue(dpCodes.bleControl);
     }
-    return true;
+    return hasBle;
 };
 const periodDpMap = [
     { name: "startHour" },
@@ -281,3 +282,10 @@ export const gotoService = async (params) => {
         });
     });
 };
+export const validatePwdComplexity = async (password) => {
+    const encryptedPassword = await encrypt(config.devInfo.devId, password);
+    return validatePasswordComplexity({
+        devId: config.devInfo.devId,
+        password: encryptedPassword,
+    });
+};