@ray-js/lock-sdk 1.0.1 → 1.0.2

package/lib/media.js

@@ -1,80 +1,9 @@
 import { getMediaUrl as getMediaUrlApi } from "./api/log";
 import config from "./config";
-import dpCodes from "./config/dp-code";
-import { openNativeRouter } from "./utils/device";
-import { publishDps } from "./utils/publishDps";
-
-/**
- * 多媒体相关接口
- */
-
-/**
- * 获取视频的实际播放地址参数
- */
-
-/**
- * 获取视频的实际播放地址
- * @param params
- * @returns
- */
-export const getMediaUrl = async params => {
-  return getMediaUrlApi({
-    devId: config.devInfo.devId,
-    mediaPath: params.mediaPath,
-    mediaBucket: params.mediaBucket
-  });
+export const getMediaUrl = async (params) => {
+    return getMediaUrlApi({
+        devId: config.devInfo.devId,
+        mediaPath: params.mediaPath,
+        mediaBucket: params.mediaBucket,
+    });
 };
-
-/**
- * 跳转到本地相册页面
- */
-export const goToLocalAlbum = async params => {
-  return openNativeRouter("ipc_album_panel", {
-    extra_camera_uuid: config.devInfo.devId,
-    theme: typeof (params === null || params === void 0 ? void 0 : params.theme) === "string" ? params.theme === "dark" ? 1 : 2 : undefined
-  });
-};
-
-/**
- * 跳转到回放页面
- * @param params { theme?: "dark" | "light" }
- * @returns Promise<boolean>
- */
-export const goToPlayback = async params => {
-  const tabs = [];
-  if (config.codesById[dpCodes.recordModeAovSwitch]) {
-    tabs.push("cloud");
-
-    // 如果存在 dp updataInfo，则进行一次同步更新
-    if (config.codesById[dpCodes.updataInfo] && config.deviceStatus.type === "online") {
-      try {
-        await publishDps({
-          updata_info: "010001FF"
-        }, {
-          timeout: 6000
-        });
-      } catch (e) {
-        // 不处理
-      }
-    }
-  }
-  // 有 SD 卡时，支持本地回放
-  if (config.codesById[dpCodes.sdStatus]) {
-    tabs.push("local");
-  }
-  return openNativeRouter("camera_playbacks_panel", {
-    extra_camera_uuid: config.devInfo.devId,
-    defaultShowTabs: true,
-    isLowPowerDevice: true,
-    rotate: config.videoAngle,
-    tabs: JSON.stringify(tabs),
-    bizType: "doorLock",
-    theme: typeof (params === null || params === void 0 ? void 0 : params.theme) === "string" ? params.theme === "dark" ? 1 : 2 : undefined
-  });
-};
-export const openCameraSettings = async params => {
-  return openNativeRouter("camera_base_setting", {
-    extra_camera_uuid: config.devInfo.devId,
-    theme: typeof (params === null || params === void 0 ? void 0 : params.theme) === "string" ? params.theme === "dark" ? 1 : 2 : undefined
-  });
-};

package/lib/open.d.ts

@@ -1,48 +1,13 @@
 import { RemotePermission } from "./interface";
-/**
- * 校验是否可以远程开关门
- */
 export declare const checkRemoteEnabled: () => Promise<void>;
-/**
- * 开锁
- * @param option 开锁选项
- * @param option.timeout 超时时间，默认 15000 毫秒
- * @returns Promise<void>
- */
 export declare const openDoor: (option?: {
     timeout?: number;
 } | undefined) => Promise<void>;
-/**
- * 关锁
- * @param option 关锁选项
- * @param option.timeout 超时时间，默认 15000 毫秒
- * @returns Promise<void>
- */
 export declare const closeDoor: (option?: {
     timeout?: number;
 } | undefined) => Promise<void>;
-/**
- * 是否开启远程开关门功能
- * @param state
- */
 export declare const remoteEnabled: (state: boolean) => Promise<void>;
-/**
- * 获取远程开关门是否开启
- * @returns boolean
- */
 export declare const getRemoteEnabled: () => boolean;
-/**
- * 获取远程开关门权限列表
- * @returns
- */
 export declare const getRemotePermissionList: () => RemotePermission[];
-/**
- * 获取远程开关门当前权限
- * @returns 远程开关门权限
- */
 export declare const getRemotePermission: () => RemotePermission;
-/**
- * 更新远程开关门权限
- * @param permission
- */
 export declare const updateRemotePermission: (permission: RemotePermission) => Promise<void>;

package/lib/open.js

@@ -1,13 +1,10 @@
-/**
- * 远程开关锁 API
- */
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { getDoorKey, openDoorByCloud } from "./api/lock";
 import config from "./config";
 import { isUseNearChannel, parallelMerge, parallelOnly } from "./utils";
 import { decrypt } from "./utils/device";
 import { publishDps } from "./utils/publishDps";
-import { open as openMap, reportOpen as reportOpenMap } from "./config/dp-map/open";
+import { open as openMap, reportOpen as reportOpenMap, } from "./config/dp-map/open";
 import { stringToBytes } from "./utils/byte";
 import emitter from "./utils/event";
 import { getError } from "./utils/errors";
@@ -17,241 +14,149 @@ import { getCurrentUser, permissions } from "./state";
 import { setDeviceProperties } from "./api/setting";
 import syncRemoteSerectKey from "./sync/remote-serect-key";
 import { ProductCommunicationType } from "./constant";
-const getReportError = status => {
-  // 状态码为 0 表示开锁成功，其他  0x01：失败  0x02：失效  0x03：秘钥次数使用完  0x04：秘钥不在有效期内  0x05：秘钥比对错误
-  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;
-    default:
-  }
-  return error;
+const getReportError = (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;
+        default:
+    }
+    return error;
 };
-
-/**
- * 校验是否可以远程开关门
- */
 export const checkRemoteEnabled = parallelMerge(async () => {
-  const {
-    devInfo,
-    dpSchema,
-    remoteOpenEnabled,
-    remoteOpenPermission
-  } = config;
-  const {
-    userType
-  } = await getCurrentUser();
-  if (!devInfo.isOnline) {
-    // 设备不在线
-    throw getError(1001);
-  }
-
-  // 是否支持远程开门
-  if (dpSchema[dpCodes.remoteNoDpKey] === undefined) {
-    // 不支持远程开门
-    throw getError(1045);
-  }
-  // 是否开启远程开关门
-  if (!remoteOpenEnabled) {
-    // 远程开关门未开启
-    throw getError(1046);
-  }
-  // 是否有权限开关门
-  if (remoteOpenPermission === "noOne" || remoteOpenPermission === "adminsOnly" && +userType === 20) {
-    throw getError(1047);
-  }
-});
-const _doAction = async (isOpen, timeout) => {
-  const {
-    devInfo,
-    onlineType,
-    capabilities,
-    communication,
-    dpSchema
-  } = config;
-
-  // 校验远程开关门是否可用
-  await checkRemoteEnabled();
-  const isNear = isUseNearChannel();
-  const currentUser = await getCurrentUser();
-  const memberId = currentUser.lockUserId !== 0 ? currentUser.lockUserId : currentUser.userId;
-  const checkReport = dpData => {
-    if (typeof dpData[dpCodes.remoteNoDpKey] !== "undefined") {
-      const result = dpUtils.parse(dpData[dpCodes.remoteNoDpKey], reportOpenMap);
-      // 由于有两端操作的可能，所以需要判断是否有相同的成员id
-      if (result.memberId === memberId) {
-        // 有相同的成员开锁，表示此操作有结果
-        return result;
-      } else {
-        // 提示可能返回了一个错误的成员id
-        console.warn("An incorrect member id was returned");
-      }
+    const { devInfo, dpSchema, remoteOpenEnabled, remoteOpenPermission } = config;
+    const { userType } = await getCurrentUser();
+    if (!devInfo.isOnline) {
+        throw getError(1001);
+    }
+    if (dpSchema[dpCodes.remoteNoDpKey] === undefined) {
+        throw getError(1045);
     }
-    return false;
-  };
-
-  // 是否为蓝牙在线
-  if (isNear) {
-    // 为双模支持蓝牙控制且蓝牙在线
-    if (communication.includes(ProductCommunicationType.WIFI) || communication.includes(ProductCommunicationType.THREAD)) {
-      // 先尝试同步密钥
-      await syncRemoteSerectKey();
-
-      // 蓝牙在线时，通过蓝牙开锁
-      let pw = "";
-      try {
-        const {
-          password
-        } = await getDoorKey(devInfo.devId);
-        pw = await decrypt(devInfo.devId, password);
-      } catch (e) {
-        // 获取密钥失败，则尝试同步密钥
-        await syncRemoteSerectKey(true);
-        const {
-          password
-        } = await getDoorKey(devInfo.devId);
-        pw = await decrypt(devInfo.devId, password);
-      }
-      const response = await publishDps({
-        [dpCodes.remoteNoDpKey]: dpUtils.format({
-          status: Number(isOpen),
-          memberId,
-          key: stringToBytes(pw),
-          type: 3 // 0x03 表示蓝牙方式开锁
-        }, openMap)
-      }, {
-        timeout,
-        checkReport
-      });
-
-      // 状态码为 0 表示开锁成功，其他  0x01：失败  0x02：失效  0x03：秘钥次数使用完  0x04：秘钥不在有效期内  0x05：秘钥比对错误
-      if (response.status !== 0) {
-        throw getReportError(response.status);
-      }
-
-      // 开锁成功
-      return;
+    if (!remoteOpenEnabled) {
+        throw getError(1046);
     }
-
-    // 纯蓝牙设备
-    if (communication.length === 1 && communication.includes(ProductCommunicationType.BLUETOOTH)) {
-      // TODO 后继实际蓝牙门锁开锁
-      throw new Error("Bluetooth lock opening is not supported yet");
+    if (remoteOpenPermission === "noOne" ||
+        (remoteOpenPermission === "adminsOnly" && +userType === 20)) {
+        throw getError(1047);
     }
-  }
-
-  // 其他情况默认为云端开锁
-  return new Promise((resolve, reject) => {
-    // 走云端远程开锁逻辑
-    const handleReport = dpCodes => {
-      const result = checkReport(dpCodes);
-      if (result) {
-        emitter.off(DPCHANGE, handleReport);
-        clearTimeout(timeoutTask);
-        if (result.status !== 0) {
-          // 失败
-          reject(getReportError(result.status));
-        } else {
-          // 开锁成功
-          resolve();
+});
+const _doAction = async (isOpen, timeout) => {
+    const { devInfo, onlineType, capabilities, communication, dpSchema } = config;
+    await checkRemoteEnabled();
+    const isNear = isUseNearChannel();
+    const currentUser = await getCurrentUser();
+    const memberId = currentUser.lockUserId !== 0 ? currentUser.lockUserId : currentUser.userId;
+    const checkReport = (dpData) => {
+        if (typeof dpData[dpCodes.remoteNoDpKey] !== "undefined") {
+            const result = dpUtils.parse(dpData[dpCodes.remoteNoDpKey], reportOpenMap);
+            if (result.memberId === memberId) {
+                return result;
+            }
+            else {
+                console.warn("An incorrect member id was returned");
+            }
         }
-      }
+        return false;
     };
-    // 监听开锁结果
-    // 设置超时任务
-    const timeoutTask = setTimeout(() => {
-      emitter.off(DPCHANGE, handleReport);
-      // 超时处理
-      reject(getError(1002));
-    }, timeout);
-    // 加入监听器
-    emitter.on(DPCHANGE, handleReport);
-    openDoorByCloud(devInfo.devId, isOpen).catch(() => {
-      clearTimeout(timeoutTask);
-      emitter.off(DPCHANGE, handleReport);
-      // 开锁失败
-      reject(getError(1003));
+    if (isNear) {
+        if (communication.includes(ProductCommunicationType.WIFI) ||
+            communication.includes(ProductCommunicationType.THREAD)) {
+            await syncRemoteSerectKey();
+            let pw = "";
+            try {
+                const { password } = await getDoorKey(devInfo.devId);
+                pw = await decrypt(devInfo.devId, password);
+            }
+            catch (e) {
+                await syncRemoteSerectKey(true);
+                const { password } = await getDoorKey(devInfo.devId);
+                pw = await decrypt(devInfo.devId, password);
+            }
+            const response = await publishDps({
+                [dpCodes.remoteNoDpKey]: dpUtils.format({
+                    status: Number(isOpen),
+                    memberId,
+                    key: stringToBytes(pw),
+                    type: 3,
+                }, openMap),
+            }, {
+                timeout,
+                checkReport,
+            });
+            if (response.status !== 0) {
+                throw getReportError(response.status);
+            }
+            return;
+        }
+        if (communication.length === 1 &&
+            communication.includes(ProductCommunicationType.BLUETOOTH)) {
+            throw new Error("Bluetooth lock opening is not supported yet");
+        }
+    }
+    return new Promise((resolve, reject) => {
+        const handleReport = (dpCodes) => {
+            const result = checkReport(dpCodes);
+            if (result) {
+                emitter.off(DPCHANGE, handleReport);
+                clearTimeout(timeoutTask);
+                if (result.status !== 0) {
+                    reject(getReportError(result.status));
+                }
+                else {
+                    resolve();
+                }
+            }
+        };
+        const timeoutTask = setTimeout(() => {
+            emitter.off(DPCHANGE, handleReport);
+            reject(getError(1002));
+        }, timeout);
+        emitter.on(DPCHANGE, handleReport);
+        openDoorByCloud(devInfo.devId, isOpen).catch((e) => {
+            clearTimeout(timeoutTask);
+            emitter.off(DPCHANGE, handleReport);
+            reject(getError(1003));
+        });
     });
-  });
 };
-
-/**
- * 开锁
- * @param option 开锁选项
- * @param option.timeout 超时时间，默认 15000 毫秒
- * @returns Promise<void>
- */
-export const openDoor = parallelOnly(option => {
-  return _doAction(true, (option === null || option === void 0 ? void 0 : option.timeout) || 15000);
+export const openDoor = parallelOnly((option) => {
+    return _doAction(true, option?.timeout || 15000);
 });
-
-/**
- * 关锁
- * @param option 关锁选项
- * @param option.timeout 超时时间，默认 15000 毫秒
- * @returns Promise<void>
- */
-export const closeDoor = parallelOnly(option => {
-  return _doAction(false, (option === null || option === void 0 ? void 0 : option.timeout) || 15000);
+export const closeDoor = parallelOnly((option) => {
+    return _doAction(false, option?.timeout || 15000);
 });
-
-/**
- * 是否开启远程开关门功能
- * @param state
- */
-export const remoteEnabled = parallelMerge(async state => {
-  await setDeviceProperties(config.devInfo.devId, {
-    UNLOCK_PHONE_REMOTE: state
-  });
-  config.remoteOpenEnabled = state;
-  if (state) {
-    // 同步密钥
-    syncRemoteSerectKey();
-  }
+export const remoteEnabled = parallelMerge(async (state) => {
+    await setDeviceProperties(config.devInfo.devId, {
+        UNLOCK_PHONE_REMOTE: state,
+    });
+    config.remoteOpenEnabled = state;
+    if (state) {
+        syncRemoteSerectKey();
+    }
 });
-
-/**
- * 获取远程开关门是否开启
- * @returns boolean
- */
 export const getRemoteEnabled = () => {
-  return config.remoteOpenEnabled;
+    return config.remoteOpenEnabled;
 };
-
-/**
- * 获取远程开关门权限列表
- * @returns
- */
 export const getRemotePermissionList = () => {
-  return permissions;
+    return permissions;
 };
-
-/**
- * 获取远程开关门当前权限
- * @returns 远程开关门权限
- */
 export const getRemotePermission = () => {
-  return config.remoteOpenPermission;
+    return config.remoteOpenPermission;
+};
+export const updateRemotePermission = async (permission) => {
+    const index = permissions.indexOf(permission);
+    await setDeviceProperties(config.devInfo.devId, {
+        REMOTE_UNLOCK_AUTH: index > 0 ? index : 0,
+    });
+    config.remoteOpenPermission = permission;
 };
-
-/**
- * 更新远程开关门权限
- * @param permission
- */
-export const updateRemotePermission = async permission => {
-  const index = permissions.indexOf(permission);
-  await setDeviceProperties(config.devInfo.devId, {
-    REMOTE_UNLOCK_AUTH: index > 0 ? index : 0
-  });
-  config.remoteOpenPermission = permission;
-};

package/lib/other.d.ts

@@ -1,35 +1,11 @@
-/**
- * 打开场景
- * @param options - 打开场景的参数
- * @param options.themeColor - 主题颜色
- */
 export declare const openScene: (options?: {
     themeColor?: string;
 }) => Promise<unknown>;
-/**
- * 判断是否支持蓝牙控制
- * @returns boolean
- */
 export declare const isSupportBleControl: () => import("./interface").DpValue;
-/**
- * 获取休眠时间段
- * @param dpCode - 待获取时段的 dp
- * @returns 返回时间段
- * start: 开始时间（分钟）
- * end: 结束时间（分钟）
- */
 export declare const getDpPeriodTime: (dpCode: string) => {
     start: number;
     end: number;
 };
-/**
- * 设置时间段
- * @param dpCode - 待设置时段的 dp
- * @param params 休眠时间段数据
- * start: 开始时间（分钟）
- * end: 结束时间（分钟）
- * @returns Promise<void>
- */
 export declare const updateDpPeriodTime: (dpCode: string, data: {
     start: number;
     end: number;