@ray-js/lock-sdk 1.0.0-beta-1

package/lib/sleep.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 判断锁是否处于休眠状态
+ * @returns true 表示为休眠中
+ */
+export declare const isSleep: () => boolean;
+/**
+ * 判断锁是否支持休眠功能
+ * @returns true 表示支持休眠功能
+ */
+export declare const hasSleepAbility: () => boolean;
+/**
+ * 判断休眠功能是否已启用
+ * @returns true 表示休眠功能已启用
+ * false 表示休眠功能已禁用
+ */
+export declare const isEnabledSleep: () => import("./interface").DpValue;
+/**
+ * 启用休眠
+ * @returns Promise<void>
+ */
+export declare const enableSleep: () => Promise<Record<string, import("./interface").DpValue>>;
+/**
+ * 禁用休眠
+ * @returns Promise<void>
+ */
+export declare const disableSleep: () => Promise<Record<string, import("./interface").DpValue>>;
+/**
+ * 获取休眠时间段
+ * @returns 返回休眠时间段
+ * start: 开始时间（分钟）
+ * end: 结束时间（分钟）
+ */
+export declare const getSleepPeriod: () => {
+    start: number;
+    end: number;
+};
+/**
+ * 设置休眠时间段
+ * @param params 休眠时间段
+ * startTime: 开始时间（分钟）
+ * endTime: 结束时间（分钟）
+ * @returns Promise<void>
+ */
+export declare const updateSleepPeriod: (params: {
+    start: number;
+    end: number;
+}) => Promise<Record<string, import("./interface").DpValue>>;
+/**
+ * 注册休眠状态变更事件
+ * @param callback 休眠状态变更回调
+ */
+export declare const onSleepStatusChange: (callback: (args: {
+    sleep: boolean;
+}) => void) => void;
+/**
+ * 注销休眠状态变更事件
+ * @param callback 休眠状态变更回调
+ */
+export declare const offSleepStatusChange: (callback: (args: {
+    sleep: boolean;
+}) => void) => void;

package/lib/sleep.js

@@ -0,0 +1,121 @@
+import config from "./config";
+import { getDpValue } from "./state";
+import { getError } from "./utils/errors";
+import { publishDps } from "./utils/publishDps";
+import emitter from "./utils/event";
+import { SLEEP_EVENT } from "./event";
+import dpCodes from "./config/dp-code";
+import { getDpPeriodTime, updateDpPeriodTime } from "./other";
+
+/**
+ * 判断锁是否处于休眠状态
+ * @returns true 表示为休眠中
+ */
+export const isSleep = () => {
+  const {
+    dpSchema
+  } = config;
+  if (typeof dpSchema[dpCodes.linkMode] === "undefined") {
+    return false;
+  }
+  const linkMode = getDpValue(dpCodes.linkMode);
+  return linkMode === "sleep" || linkMode === "lock_sleep";
+};
+
+/**
+ * 判断锁是否支持休眠功能
+ * @returns true 表示支持休眠功能
+ */
+export const hasSleepAbility = () => {
+  const {
+    dpSchema
+  } = config;
+  return (typeof dpSchema[dpCodes.dormantSwitch] !== "undefined" || typeof dpSchema[dpCodes.onlineSwitch] !== "undefined") && typeof dpSchema[dpCodes.dormantSwitch] === "undefined";
+};
+const setSleepStatus = async status => {
+  const {
+    dpSchema
+  } = config;
+  if (typeof dpSchema[dpCodes.onlineSwitch] !== "undefined") {
+    return publishDps({
+      [dpCodes.onlineSwitch]: status
+    });
+  }
+  if (typeof dpSchema[dpCodes.dormantSwitch] !== "undefined") {
+    return publishDps({
+      [dpCodes.dormantSwitch]: status
+    });
+  }
+  throw getError(1014);
+};
+
+/**
+ * 判断休眠功能是否已启用
+ * @returns true 表示休眠功能已启用
+ * false 表示休眠功能已禁用
+ */
+export const isEnabledSleep = () => {
+  const {
+    dpSchema
+  } = config;
+  if (typeof dpSchema[dpCodes.onlineSwitch] !== "undefined") {
+    return getDpValue(dpCodes.onlineSwitch);
+  }
+  if (typeof dpSchema[dpCodes.dormantSwitch] !== "undefined") {
+    return getDpValue(dpCodes.dormantSwitch);
+  }
+  throw getError(1014);
+};
+
+/**
+ * 启用休眠
+ * @returns Promise<void>
+ */
+export const enableSleep = async () => {
+  return setSleepStatus(true);
+};
+
+/**
+ * 禁用休眠
+ * @returns Promise<void>
+ */
+export const disableSleep = async () => {
+  return setSleepStatus(false);
+};
+
+/**
+ * 获取休眠时间段
+ * @returns 返回休眠时间段
+ * start: 开始时间（分钟）
+ * end: 结束时间（分钟）
+ */
+export const getSleepPeriod = () => {
+  return getDpPeriodTime(dpCodes.dormantTimeSet);
+};
+
+/**
+ * 设置休眠时间段
+ * @param params 休眠时间段
+ * startTime: 开始时间（分钟）
+ * endTime: 结束时间（分钟）
+ * @returns Promise<void>
+ */
+export const updateSleepPeriod = params => {
+  return updateDpPeriodTime(dpCodes.dormantTimeSet, params);
+};
+
+/**
+ * 注册休眠状态变更事件
+ * @param callback 休眠状态变更回调
+ */
+export const onSleepStatusChange = callback => {
+  emitter.on(SLEEP_EVENT, callback);
+};
+
+/**
+ * 注销休眠状态变更事件
+ * @param callback 休眠状态变更回调
+ */
+export const offSleepStatusChange = callback => {
+  emitter.off(SLEEP_EVENT, callback);
+};

package/lib/state.d.ts

@@ -0,0 +1,54 @@
+import { DpValue, CurrentUser, RemotePermission, DeviceStatus } from "./interface";
+export declare const clearState: () => void;
+export declare const getDpValue: (code: string) => DpValue;
+/**
+ * 获取设备状态信息
+ * @returns
+ */
+export declare const getDeviceStatus: () => DeviceStatus;
+/**
+ * 获取当前用户信息
+ * @param isForce 是否强制刷新
+ * @returns
+ */
+export declare const getCurrentUser: (isForce?: boolean) => Promise<CurrentUser>;
+/**
+ * 获取当前用户信息
+ * 注意：此方法只能在初始化后使用
+ * @returns
+ */
+export declare const getCurrentUserSync: () => CurrentUser | null;
+/**
+ * 获取设备旋转角度
+ * @returns
+ */
+export declare const getMediaRotate: () => {
+    imageAngle: number;
+    videoAngle: number;
+};
+/**
+ * 远程开关门权限列表
+ */
+export declare const permissions: RemotePermission[];
+/**
+ * 初始化数据状态
+ */
+export declare const initState: () => Promise<void>;
+/**
+ * 添加事件
+ */
+export declare const addEvents: () => void;
+/**
+ * 添加事件
+ */
+export declare const removeEvents: () => void;
+/**
+ * 注册设备状态信息变更事件
+ * @param callback 回调函数
+ */
+export declare const onDeviceStatusChange: (callback: (status: DeviceStatus) => void) => void;
+/**
+ * 注销设备状态信息变更事件
+ * @param callback 回调函数
+ */
+export declare const offDeviceStatusChange: (callback: (status: DeviceStatus) => void) => void;

package/lib/state.js

@@ -0,0 +1,429 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.reduce.js";
+/**
+ * 数据状态管理
+ */
+import config from "./config";
+import { onDpDataChange, onDeviceInfoUpdated, offDeviceInfoUpdated, offDpDataChange, registerDevice, getDeviceOnlineType, onOnlineChange, offOnlineChange, onBleChange, offBleChange, registerBleStatus, getDeviceInfo, onMqttMessage, registerMQTTDeviceListener, registerMQTTProtocolListener, offMqttMessage } from "./utils/device";
+import { getDeviceProperties } from "./api/setting";
+import { parseCapabilities } from "./parse";
+import emitter from "./utils/event";
+import { DPCHANGE, LOGCHANGE } from "./utils/constant";
+import dpCodes, { latLogDpCodes } from "./config/dp-code";
+import { getCurrentUserInfo } from "./api/user";
+import { equels, getDataWithPreFetch, isOnlineByType } from "./utils";
+import { getRotateInfo } from "./api/video";
+import syncT0 from "./sync/t0";
+import syncRemoteSerectKey from "./sync/remote-serect-key";
+import { autoSyncUnlockMethod } from "./sync/unlock-mothod";
+import { autoSyncTemp } from "./sync/temp";
+import { DEVICE_STATUS_CHANGE_EVENT, SLEEP_EVENT } from "./event";
+import { getSleepPeriod, isSleep } from "./sleep";
+import { ProductCommunicationType } from "./constant";
+
+// 设备详细信息
+let dpState = {};
+let logRefreshTimer = 0;
+export const clearState = () => {
+  dpState = {};
+};
+export const getDpValue = code => {
+  return dpState[code];
+};
+
+/**
+ * 更新设备在线类型
+ */
+const updateOnlineType = async () => {
+  const [devInfo, onlineType] = await Promise.all([getDeviceInfo(config.devInfo.devId), getDeviceOnlineType(config.devInfo.devId)]);
+  config.onlineType = onlineType;
+  config.devInfo = devInfo;
+  updateDeviceStatus();
+};
+
+/**
+ * 获取设备状态信息
+ * @returns
+ */
+export const getDeviceStatus = () => {
+  const {
+    onlineType,
+    dpSchema,
+    communication,
+    capabilities,
+    devInfo: {
+      isCloudOnline,
+      isLocalOnline,
+      isOnline
+    }
+  } = config;
+  // 在线状态处理
+  const status = {
+    type: isOnline ? "online" : "offline",
+    connectEanble: false,
+    onlineType: "unknown"
+  };
+  switch (communication.length) {
+    case 1:
+      {
+        // 单模设备
+        switch (communication[0]) {
+          case ProductCommunicationType.WIFI:
+            const hasWirelessAwakeDp = !!dpSchema[dpCodes.wirelessWwake];
+            const isDeviceOnline = hasWirelessAwakeDp ? getDpValue(dpCodes.wirelessWwake) && isCloudOnline : isCloudOnline;
+            if (!isDeviceOnline) {
+              // 判断是否设备是否休眠
+              const sleep = isSleep();
+              status.type = sleep ? "sleep" : "offline";
+            } else {
+              status.type = "online";
+              status.onlineType = "cloud";
+            }
+            break;
+          case ProductCommunicationType.BLUETOOTH:
+            status.connectEanble = true;
+            if (isOnline) {
+              status.type = "online";
+              status.onlineType = "ble";
+            }
+            break;
+        }
+        break;
+      }
+    case 2:
+      {
+        // 双模设备
+        // wifi + ble
+        if (communication.includes(ProductCommunicationType.WIFI) && communication.includes(ProductCommunicationType.BLUETOOTH)) {
+          const hasWirelessAwakeDp = !!dpSchema[dpCodes.wirelessWwake];
+          const isDeviceOnline = hasWirelessAwakeDp ? getDpValue(dpCodes.wirelessWwake) && isCloudOnline : isCloudOnline;
+          if (!isDeviceOnline) {
+            // 判断是否支持蓝牙在线
+            // 是否蓝牙在线
+            if (isOnline && isOnlineByType(onlineType, 2)) {
+              status.type = "online";
+              status.onlineType = "ble";
+              break;
+            }
+            // 判断是否设备是否休眠
+            const sleep = isSleep();
+            status.type = sleep ? "sleep" : "offline";
+          } else {
+            status.type = "online";
+            status.onlineType = "cloud";
+          }
+          break;
+        }
+        // metter + ble
+        if (communication.includes(ProductCommunicationType.THREAD) && communication.includes(ProductCommunicationType.BLUETOOTH)) {
+          // TODO 后继支持
+        }
+        break;
+      }
+  }
+  if (status.type === "sleep") {
+    if (getDpValue(dpCodes.dormantSwitch) || getDpValue(dpCodes.onlineSwitch)) {
+      status.sleepPeriod = getSleepPeriod();
+    }
+  }
+  return status;
+};
+const updateDeviceStatus = () => {
+  const status = getDeviceStatus();
+  // 是否存在变更，如果是，则触发事件
+  if (!equels(config.deviceStatus, status)) {
+    config.deviceStatus = status;
+    emitter.emit(DEVICE_STATUS_CHANGE_EVENT, status);
+  }
+};
+
+/**
+ * 处理dp上报
+ * @param dps
+ */
+const handleDpChange = (dps, notEmit) => {
+  let refleshLogsEnabled = false;
+  // 将id => value 转为 code => value
+  const dpData = Object.keys(dps).reduce((acc, key) => {
+    const code = config.codesById[key];
+    if (code) {
+      acc[code] = dps[key];
+      if (!refleshLogsEnabled && latLogDpCodes.includes(code)) {
+        refleshLogsEnabled = true;
+      }
+    }
+    return acc;
+  }, {});
+  if (dpData["device_info"]) {
+    // 设备能力处理
+    config.capabilities = parseCapabilities(dpData["device_info"]);
+  }
+  Object.assign(dpState, dpData);
+  if (!notEmit) {
+    emitter.emit(DPCHANGE, dpData);
+
+    // 是否休眠状态变更
+    if (typeof dpData[dpCodes.linkMode] !== "undefined") {
+      emitter.emit(SLEEP_EVENT, {
+        sleep: isSleep()
+      });
+    }
+
+    // 是否触发日志更新
+    if (refleshLogsEnabled) {
+      clearTimeout(logRefreshTimer);
+      // 2 秒后触发刷新
+      // @ts-expect-error
+      logRefreshTimer = setTimeout(() => {
+        emitter.emit(LOGCHANGE, dpData);
+      }, 2000);
+    }
+  }
+};
+
+/**
+ * 设备 dp 变化事件
+ * @param param0
+ */
+const handleDeviceDpsChange = _ref => {
+  let {
+    dps,
+    deviceId
+  } = _ref;
+  if (deviceId === config.devInfo.devId) {
+    // 处理dp
+    handleDpChange(dps);
+
+    // 更新设备状态
+    updateDeviceStatus();
+  }
+};
+
+/**
+ * 设备信息变化事件
+ * @param param0
+ */
+const handleDeviceInfoChange = _ref2 => {
+  let {
+    dps,
+    deviceId
+  } = _ref2;
+  if (deviceId === config.devInfo.devId && dps) {
+    // 处理dp
+    handleDpChange(dps);
+  }
+  // 更新在线状态
+  updateOnlineType();
+
+  // 更新设备状态
+  updateDeviceStatus();
+};
+let currentUser = null;
+
+/**
+ * 获取当前用户信息
+ * @param isForce 是否强制刷新
+ * @returns
+ */
+export const getCurrentUser = async isForce => {
+  if (currentUser && !isForce) {
+    return currentUser;
+  }
+  if (isForce) {
+    currentUser = await getCurrentUserInfo(config.devInfo.devId);
+  } else {
+    currentUser = await getDataWithPreFetch("getCurrentUser", () => getCurrentUserInfo(config.devInfo.devId));
+  }
+  currentUser.allOpenDps = currentUser.allOpenDps || "";
+  return currentUser;
+};
+
+/**
+ * 获取当前用户信息
+ * 注意：此方法只能在初始化后使用
+ * @returns
+ */
+export const getCurrentUserSync = () => {
+  return currentUser;
+};
+
+/**
+ * 获取设备旋转角度
+ * @returns
+ */
+export const getMediaRotate = () => {
+  return {
+    imageAngle: config.imageAngle,
+    videoAngle: config.videoAngle
+  };
+};
+
+/**
+ * 远程开关门权限列表
+ */
+export const permissions = ["adminsOnly", "everyOne", "noOne"];
+
+/**
+ * 初始化数据状态
+ */
+export const initState = async () => {
+  const {
+    devInfo: {
+      dps,
+      devId
+    }
+  } = config;
+  handleDpChange(dps, true);
+
+  // 设备状态信息
+  config.deviceStatus = getDeviceStatus();
+  const [,, rotateInfo] = await Promise.all([
+  // 更新在线状态
+  updateOnlineType(),
+  // 获取当前用户
+  getCurrentUser(),
+  // 获取角度
+  getDataWithPreFetch("getRotate", () => getRotateInfo(devId))]);
+
+  // 处理角度
+  config.imageAngle = rotateInfo.angle;
+  config.videoAngle = rotateInfo.actualAngle;
+
+  // 近场通讯时，尝试同步密钥
+  syncRemoteSerectKey();
+
+  // 由于 密钥 和 T0 时间都需要缓存，设备侧处理没这么快，这里间隔 2 秒后下发 T0
+
+  // 2秒后, 尝试同步开锁方式
+  setTimeout(() => {
+    syncT0();
+    autoSyncUnlockMethod();
+  }, 2000);
+
+  // 近场通讯时，尝试临时密码同步
+  setTimeout(() => {
+    autoSyncTemp();
+  }, 3000);
+
+  // TODO 近场通讯时，尝试同步用户删除状态
+
+  // 异步获取总倒计时时间
+  getDataWithPreFetch("getDeviceProperties", () => {
+    return getDeviceProperties(devId, ["REMOTE_UNLOCK_AUTH", "UNLOCK_PHONE_REMOTE"]);
+  }).then(data => {
+    // 远程开锁是否开启
+    config.remoteOpenEnabled = data["UNLOCK_PHONE_REMOTE"] === "true";
+    // 远程开锁权限
+    config.remoteOpenPermission = permissions[+data["REMOTE_UNLOCK_AUTH"] || 0];
+  }).catch(() => {
+    // 不处理
+  });
+};
+
+/**
+ * 处理 MQTT 消息
+ * @param param0
+ */
+const handleMqttMessage = _ref3 => {
+  let {
+    deviceId,
+    messageData,
+    protocol
+  } = _ref3;
+  const {
+    devId
+  } = config.devInfo;
+  if (devId === deviceId) {
+    switch (+protocol) {
+      case 23:
+        {
+          var _messageData$data, _messageData$data2;
+          // 处理信号强度变化
+          if (messageData !== null && messageData !== void 0 && (_messageData$data = messageData.data) !== null && _messageData$data !== void 0 && _messageData$data.signal || (messageData === null || messageData === void 0 || (_messageData$data2 = messageData.data) === null || _messageData$data2 === void 0 ? void 0 : _messageData$data2.signal) === 0) {
+            const signal = messageData.data.signal;
+            let signalText = "bad";
+            if (signal > -50) {
+              signalText = "good";
+            } else if (signal <= -50 && signal > -65) {
+              signalText = "normal";
+            } else if (signal <= -65 && signal > -75) {
+              signalText = "weak";
+            }
+            emitter.emit("onWiFiSignalChange", {
+              signal,
+              level: signalText
+            });
+          }
+          break;
+        }
+    }
+  }
+};
+let hasEvent = false;
+const handleBleChange = _ref4 => {
+  let {
+    deviceId,
+    status
+  } = _ref4;
+  if (status === "CONNECTED") {
+    // 当蓝牙连接成功时，尝试同步密钥
+    syncRemoteSerectKey();
+    // 近场通讯时，尝试临时密码同步
+    autoSyncTemp();
+    // TODO 尝试同步 T0 时间
+    syncT0();
+  }
+};
+
+/**
+ * 添加事件
+ */
+export const addEvents = () => {
+  if (hasEvent) {
+    return;
+  }
+  const {
+    devId
+  } = config.devInfo;
+  hasEvent = true;
+  registerDevice([devId]);
+  registerBleStatus(devId);
+  registerMQTTDeviceListener(devId);
+  registerMQTTProtocolListener(23);
+  onMqttMessage(handleMqttMessage);
+  onDpDataChange(handleDeviceDpsChange);
+  onDeviceInfoUpdated(handleDeviceInfoChange);
+  onOnlineChange(updateOnlineType);
+  onBleChange(handleBleChange);
+};
+
+/**
+ * 添加事件
+ */
+export const removeEvents = () => {
+  if (hasEvent) {
+    return;
+  }
+  hasEvent = false;
+  offDpDataChange(handleDeviceDpsChange);
+  offDeviceInfoUpdated(handleDeviceInfoChange);
+  offOnlineChange(updateOnlineType);
+  offBleChange(handleBleChange);
+  offMqttMessage(handleMqttMessage);
+};
+
+/**
+ * 注册设备状态信息变更事件
+ * @param callback 回调函数
+ */
+export const onDeviceStatusChange = callback => {
+  emitter.on(DEVICE_STATUS_CHANGE_EVENT, callback);
+};
+
+/**
+ * 注销设备状态信息变更事件
+ * @param callback 回调函数
+ */
+export const offDeviceStatusChange = callback => {
+  emitter.off(DEVICE_STATUS_CHANGE_EVENT, callback);
+};

package/lib/sync/remote-serect-key.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 同步密钥
+ */
+declare const syncRemoteSerectKey: () => Promise<void>;
+export default syncRemoteSerectKey;