@ray-js/lock-sdk 1.1.1-beta.9 → 1.1.2-beta.1

package/lib/api/log.d.ts

@@ -24,6 +24,11 @@ interface LatestLogs {
         unionUnlockInfo?: UnionUnlockInfo[];
         unlockNameRosettaKey?: string;
         data: boolean | number | string;
+        matterRecordInfo?: {
+            matterSn: number;
+            matterSource: number;
+            matterType: number;
+        };
     }[];
 }
 export declare const getLatest2Log: (devId: string) => Promise<LatestLogs>;
@@ -55,6 +60,11 @@ interface LogInfo {
     data?: string;
     unionUnlockInfo?: UnionUnlockInfo[];
     localOperateRecordInfo?: LocalOperateRecordInfo;
+    matterRecordInfo?: {
+        matterSn: number;
+        matterSource: number;
+        matterType: number;
+    };
 }
 export interface LogsResult {
     datas: LogInfo[];

package/lib/api/user.d.ts

@@ -82,26 +82,6 @@ export declare const getUserList: (params: getUserListParams) => Promise<{
     user: UserListItem[];
     hasNext: boolean;
 }>;
-interface GetUserDetailParams {
-    devId: string;
-    userId: string;
-}
-interface UserDetail {
-    allOpenType: number[];
-    avatarUrl: string;
-    lockUserId: number;
-    nickName: string;
-    phase: number;
-    productAttribute: number;
-    status: number;
-    supportOpenType: number[];
-    uid: string;
-    userContact: string;
-    userId: string;
-    userTimeSet: string;
-    userType: number;
-}
-export declare const getUserDetail: (params: GetUserDetailParams) => Promise<UserDetail>;
 interface GetUserDetailQueryParams {
     devId: string;
     userId: string;

package/lib/api/user.js

@@ -38,13 +38,6 @@ export const getUserList = (params) => {
         data: params,
     });
 };
-export const getUserDetail = (params) => {
-    return requestApi({
-        api: "m.lock.device.member.detail",
-        version: "1.0",
-        data: params,
-    });
-};
 export const getUserDetailQuery = (params) => {
     return requestApi({
         api: "m.lock.user.detail.query",
@@ -55,7 +48,7 @@ export const getUserDetailQuery = (params) => {
 export const getUsersSyncLockData = (deviceId) => {
     return requestApi({
         api: `${THING}.m.device.lock.sync.batch`,
-        version: "2.0",
+        version: "1.0",
         data: {
             devId: deviceId,
         },
@@ -64,7 +57,7 @@ export const getUsersSyncLockData = (deviceId) => {
 export const removeUser = (devId, userId) => {
     return requestApi({
         api: `${THING}.m.device.member.remove`,
-        version: "2.0",
+        version: "1.0",
         data: {
             devId,
             userId,

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/config/dp-code/index.d.ts

@@ -58,6 +58,7 @@ declare const dpCodes: {
     doNotDisturb: string;
     muteModePeriod: string;
     matterLanUnlock: string;
+    unlockMatterKw: string;
     doorlockStatus: string;
     unlockInside: string;
     doorOpened: string;

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

@@ -1,5 +1,5 @@
 const dpCodes = {
-    lockMotorState: 'lock_motor_state',
+    lockMotorState: "lock_motor_state",
     remoteNoDpKey: "remote_no_dp_key",
     remoteNoPdSetkey: "remote_no_pd_setkey",
     synchMethodW: "synch_method_w",
@@ -58,6 +58,7 @@ const dpCodes = {
     doNotDisturb: "do_not_disturb",
     muteModePeriod: "mute_mode_period",
     matterLanUnlock: "matter_lan_unlock",
+    unlockMatterKw: "unlock_matter_kw",
     doorlockStatus: "doorlock_status",
     unlockInside: "unlock_inside",
     doorOpened: "door_opened",

package/lib/config/dp-map/unlock-method-big.js

@@ -89,7 +89,7 @@ const reportAdd = [
 const remove = [
     ...common,
     {
-        name: "category",
+        name: "operation",
     },
 ];
 const reportRemove = [

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

@@ -161,7 +161,7 @@ declare const remove: readonly [{
 }, {
     readonly name: "unlockId";
 }, {
-    readonly name: "target";
+    readonly name: "operation";
 }];
 declare const reportRemove: ({
     readonly name: "type";
@@ -176,7 +176,7 @@ declare const reportRemove: ({
 } | {
     readonly name: "unlockId";
 } | {
-    readonly name: "target";
+    readonly name: "operation";
 } | {
     name: string;
 })[];
@@ -649,7 +649,7 @@ declare const _default: {
     }, {
         readonly name: "unlockId";
     }, {
-        readonly name: "target";
+        readonly name: "operation";
     }];
     reportRemove: ({
         readonly name: "type";
@@ -664,7 +664,7 @@ declare const _default: {
     } | {
         readonly name: "unlockId";
     } | {
-        readonly name: "target";
+        readonly name: "operation";
     } | {
         name: string;
     })[];

package/lib/config/dp-map/unlock-method.js

@@ -87,7 +87,7 @@ const reportAdd = [
 const remove = [
     ...common,
     {
-        name: "target",
+        name: "operation",
     },
 ];
 const reportRemove = [

package/lib/index.d.ts

@@ -2,6 +2,7 @@ import { hasCapability, hasDp, updateConfig } from "./config";
 import { LockSDKOption } from "./interface";
 import { getCurrentUser, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, getCurrentUserSync, getMediaRotate } from "./state";
 import { syncUnlockMethod } from "./sync/unlock-method";
+import syncDeleteUsers from "./sync/user";
 import { publishDps } from "./utils/publishDps";
 import { publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache } from "./offline-dps";
 export * from "./user";
@@ -19,4 +20,4 @@ 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, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };
+export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, syncDeleteUsers, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };

package/lib/index.js

@@ -2,8 +2,9 @@ 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 { getDeviceInfo, getLaunchOptionsSync, trackEvent, } from "./utils/device";
 import { syncUnlockMethod } from "./sync/unlock-method";
+import syncDeleteUsers from "./sync/user";
 import { publishDps } from "./utils/publishDps";
 import { publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, } from "./offline-dps";
 export * from "./user";
@@ -63,10 +64,13 @@ export const init = async (options) => {
     config.preFetch = options?.preFetch ?? false;
     config.communication = getCapabilities(devInfo.capability).map((item) => item.id);
     addEvents();
+    trackEvent("t$y_UztB3Lj9Qns375R0r7dA0L5Kr2VytH3J".replace("$", ""), {
+        pid: devInfo.productId,
+    });
     await initState();
 };
 export const destroy = () => {
     clearState();
     removeEvents();
 };
-export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };
+export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, syncDeleteUsers, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };

package/lib/interface.d.ts

@@ -43,6 +43,7 @@ export interface DeviceInfo {
     activeTime: number;
     dpsTime: Record<string, string>;
     parentId?: string;
+    isMatter?: boolean;
 }
 export interface DpSchema {
     type: "raw" | "obj";
@@ -194,6 +195,7 @@ export interface DeviceStatus {
         end: number;
     };
     isWifiActive: boolean;
+    isWifiMatter: boolean;
 }
 export interface UnionUnlockInfo {
     userId: string;
@@ -265,6 +267,11 @@ export interface LogData {
     localRecord?: LocalOperateData;
     isHijack?: boolean;
     unlockMethod?: UnlockMethodType;
+    matterRecord?: {
+        sn: number;
+        source: number;
+        type: number;
+    };
 }
 export type TemporaryPasswordType = "custom" | "once" | "limit" | "clear" | "clearOne";
 export interface TempPasswordResult {

package/lib/log.js

@@ -42,7 +42,7 @@ export const getLatestLogs = async () => {
                 unlockName = item.userName;
                 userName = "";
             }
-            return {
+            const log = {
                 type,
                 logId: item.logId,
                 dpId: item.dpId,
@@ -66,6 +66,14 @@ export const getLatestLogs = async () => {
                 currentUser: !!item.currentUser,
                 bindable: item.memberBindableFlag,
             };
+            if (item.matterRecordInfo) {
+                log.matterRecord = {
+                    sn: item.matterRecordInfo.matterSn,
+                    type: item.matterRecordInfo.matterType,
+                    source: item.matterRecordInfo.matterSource,
+                };
+            }
+            return log;
         });
         return {
             data: list,
@@ -106,6 +114,7 @@ export const openDps = [
     dpCodes.unlockInside,
     dpCodes.doorOpened,
     dpCodes.unlockApp,
+    dpCodes.unlockMatterKw,
 ];
 const closeTypes = [
     "UNDEFINED",
@@ -154,7 +163,7 @@ export const getLogs = async (params) => {
                 unlockName = record.userName;
                 userName = "";
             }
-            return {
+            const log = {
                 type,
                 logId: record.historyId.toString(),
                 userId: record.userId,
@@ -178,6 +187,14 @@ export const getLogs = async (params) => {
                 unlockMethod: type === "unlock_record" ? unlockDp2Type[dpCode] : undefined,
                 localRecord: handleLocalOperation(record.localOperateRecordInfo, dpValue),
             };
+            if (record.matterRecordInfo) {
+                log.matterRecord = {
+                    sn: record.matterRecordInfo.matterSn,
+                    type: record.matterRecordInfo.matterType,
+                    source: record.matterRecordInfo.matterSource,
+                };
+            }
+            return log;
         });
         return {
             list: result,

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/open/ble-dedicated-dp.d.ts

@@ -0,0 +1,4 @@
+export declare const isDedicatedBleHexSuccess: (raw: string) => boolean;
+export declare const resolveDedicatedBleCommandDp: () => string | null;
+export declare const executeDedicatedBleManualLock: (timeout: number) => Promise<void>;
+export declare const executeDedicatedBleRawAction: (isOpen: boolean, timeout: number) => Promise<void>;

package/lib/open/ble-dedicated-dp.js

@@ -0,0 +1,148 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { getDoorKey } from "../api/lock";
+import config, { hasDp } from "../config";
+import dpCodes from "../config/dp-code";
+import { open as openMap, reportOpen as reportOpenMap, } from "../config/dp-map/open";
+import syncRemoteSerectKey from "../sync/remote-serect-key";
+import { stringToBytes } from "../utils/byte";
+import { decrypt } from "../utils/device";
+import { getError } from "../utils/errors";
+import { publishDps } from "../utils/publishDps";
+import { getOpenDoorMemberId } from "./ble-remote-no-dp-key";
+import { mapRemoteOpenReportStatus } from "./report-status";
+const normalizeHex = (raw) => raw.replace(/\s/g, "").toLowerCase();
+export const isDedicatedBleHexSuccess = (raw) => {
+    const n = normalizeHex(raw);
+    if (n.length < 2) {
+        return false;
+    }
+    return n.startsWith("00") || n.endsWith("00");
+};
+const parseDedicatedBleHexStatus = (raw) => {
+    const n = normalizeHex(raw);
+    if (n.length < 2) {
+        return false;
+    }
+    if (isDedicatedBleHexSuccess(raw)) {
+        return { status: 0 };
+    }
+    if (n.includes("06")) {
+        return { status: 0x06 };
+    }
+    return { status: 0x01 };
+};
+const tryParseStandardUnlockReport = (raw, memberId) => {
+    try {
+        const result = dpUtils.parse(raw, reportOpenMap);
+        if (result.memberId !== memberId) {
+            return false;
+        }
+        if (hasDp(dpCodes.lockMotorState) && result.status === 0) {
+            return false;
+        }
+        return result;
+    }
+    catch {
+        return false;
+    }
+};
+export const resolveDedicatedBleCommandDp = () => {
+    if (hasDp(dpCodes.bleUnlockCheck)) {
+        return dpCodes.bleUnlockCheck;
+    }
+    if (hasDp(dpCodes.bluetoothUnlock)) {
+        return dpCodes.bluetoothUnlock;
+    }
+    if (hasDp(dpCodes.unlockBle)) {
+        return dpCodes.unlockBle;
+    }
+    return null;
+};
+const createDedicatedBleCheckReport = (commandDp, memberId) => {
+    return (dpData) => {
+        if (hasDp(dpCodes.lockMotorState)) {
+            if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
+                return { status: 0 };
+            }
+        }
+        if (typeof dpData[commandDp] !== "undefined") {
+            const raw = dpData[commandDp];
+            const standard = tryParseStandardUnlockReport(raw, memberId);
+            if (standard) {
+                return standard;
+            }
+            const hexStatus = parseDedicatedBleHexStatus(raw);
+            if (hexStatus !== false) {
+                return hexStatus;
+            }
+        }
+        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;
+            }
+        }
+        return false;
+    };
+};
+export const executeDedicatedBleManualLock = async (timeout) => {
+    if (!hasDp(dpCodes.manualLock)) {
+        throw getError(1014);
+    }
+    await publishDps({
+        [dpCodes.manualLock]: true,
+    }, {
+        timeout,
+        checkReport: (dpData) => {
+            if (hasDp(dpCodes.lockMotorState)) {
+                if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
+                    return { status: 0 };
+                }
+            }
+            if (typeof dpData[dpCodes.manualLock] !== "undefined") {
+                return { status: 0 };
+            }
+            return false;
+        },
+    });
+};
+export const executeDedicatedBleRawAction = async (isOpen, timeout) => {
+    if (!isOpen && hasDp(dpCodes.manualLock)) {
+        await executeDedicatedBleManualLock(timeout);
+        return;
+    }
+    const commandDp = resolveDedicatedBleCommandDp();
+    if (!commandDp) {
+        throw getError(1014);
+    }
+    await syncRemoteSerectKey();
+    let pw = "";
+    try {
+        const { password } = await getDoorKey(config.devInfo.devId);
+        pw = await decrypt(config.devInfo.devId, password);
+    }
+    catch {
+        await syncRemoteSerectKey(true);
+        const { password } = await getDoorKey(config.devInfo.devId);
+        pw = await decrypt(config.devInfo.devId, password);
+    }
+    const memberId = await getOpenDoorMemberId();
+    const payload = dpUtils.format({
+        status: Number(isOpen),
+        memberId,
+        key: stringToBytes(pw),
+        type: 3,
+    }, openMap);
+    const response = (await publishDps({
+        [commandDp]: payload,
+    }, {
+        timeout,
+        checkReport: createDedicatedBleCheckReport(commandDp, memberId),
+    }));
+    if (response.status !== 0) {
+        throw mapRemoteOpenReportStatus(response.status);
+    }
+};

package/lib/open/ble-remote-no-dp-key.d.ts

@@ -0,0 +1,4 @@
+import { DpValue } from "../interface";
+export declare const createRemoteNoDpKeyBleCheckReport: (memberId: number) => (dpData: Record<string, DpValue>) => any;
+export declare const executeBleRemoteNoDpKeyAction: (isOpen: boolean, timeout: number, memberId: number) => Promise<void>;
+export declare const getOpenDoorMemberId: () => Promise<number>;

package/lib/open/ble-remote-no-dp-key.js

@@ -0,0 +1,69 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { getDoorKey } from "../api/lock";
+import config, { hasDp } from "../config";
+import dpCodes from "../config/dp-code";
+import { open as openMap, reportOpen as reportOpenMap, } from "../config/dp-map/open";
+import { getCurrentUser } from "../state";
+import syncRemoteSerectKey from "../sync/remote-serect-key";
+import { stringToBytes } from "../utils/byte";
+import { decrypt } from "../utils/device";
+import { publishDps } from "../utils/publishDps";
+import { mapRemoteOpenReportStatus } from "./report-status";
+export const createRemoteNoDpKeyBleCheckReport = (memberId) => {
+    return (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 {
+                console.warn("An incorrect member id was returned");
+            }
+        }
+        return false;
+    };
+};
+export const executeBleRemoteNoDpKeyAction = async (isOpen, timeout, memberId) => {
+    await syncRemoteSerectKey();
+    let pw = "";
+    try {
+        const { password } = await getDoorKey(config.devInfo.devId);
+        pw = await decrypt(config.devInfo.devId, password);
+    }
+    catch {
+        await syncRemoteSerectKey(true);
+        const { password } = await getDoorKey(config.devInfo.devId);
+        pw = await decrypt(config.devInfo.devId, password);
+    }
+    const response = (await publishDps({
+        [dpCodes.remoteNoDpKey]: dpUtils.format({
+            status: Number(isOpen),
+            memberId,
+            key: stringToBytes(pw),
+            type: 3,
+        }, openMap),
+    }, {
+        timeout,
+        checkReport: createRemoteNoDpKeyBleCheckReport(memberId),
+    }));
+    if (response.status !== 0) {
+        throw mapRemoteOpenReportStatus(response.status);
+    }
+};
+export const getOpenDoorMemberId = async () => {
+    const currentUser = await getCurrentUser();
+    if (currentUser.lockUserId !== 0) {
+        return Number(currentUser.lockUserId);
+    }
+    return Number(currentUser.userId);
+};

package/lib/open/report-status.d.ts

@@ -0,0 +1 @@
+export declare const mapRemoteOpenReportStatus: (status: number) => import("..").ErrorData;

package/lib/open/report-status.js

@@ -0,0 +1,23 @@
+import { getError } from "../utils/errors";
+export const mapRemoteOpenReportStatus = (status) => {
+    let error = getError(1004);
+    switch (status) {
+        case 0x02:
+            error = getError(1005);
+            break;
+        case 0x03:
+            error = getError(1006);
+            break;
+        case 0x04:
+            error = getError(1007);
+            break;
+        case 0x05:
+            error = getError(1008);
+            break;
+        case 0x06:
+            error = getError(1070);
+            break;
+        default:
+    }
+    return error;
+};

package/lib/open.js

@@ -48,6 +48,9 @@ export const checkRemoteEnabled = parallelMerge(async () => {
     if (isThreadLocalOnline || deviceStatus.onlineTypes.includes("ble")) {
         return;
     }
+    if (deviceStatus.isWifiMatter && isLocalOnline) {
+        return;
+    }
     if (isLocalOnline) {
         throw getError(1064);
     }
@@ -94,9 +97,17 @@ const _doAction = async (isOpen, timeout) => {
         }
         return false;
     };
-    if (hasThread && deviceStatus.onlineTypes.includes("local") && deviceStatus.onlineTypes.length === 1) {
+    console.log("-------", deviceStatus.isWifiMatter, deviceStatus.onlineTypes);
+    if ((hasThread || deviceStatus.isWifiMatter) &&
+        deviceStatus.onlineTypes.includes("local") &&
+        deviceStatus.onlineTypes.length === 1) {
         await publishDps({ [dpCodes.matterLanUnlock]: isOpen }, {
             checkReport: (dps) => {
+                if (hasDp(dpCodes.lockMotorState)) {
+                    if (typeof dps[dpCodes.lockMotorState] !== "undefined") {
+                        return true;
+                    }
+                }
                 return typeof dps[dpCodes.matterLanUnlock] !== "undefined";
             },
         });

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();