@miot-rn/common-component 1.0.1

package/dist/service/specs/index.js

@@ -0,0 +1,412 @@
+/**
+ * Spec服务统一入口
+ *
+ * 功能说明：
+ * 1. 封装std-spec.js，提供统一的set/get/action/subscribe接口
+ * 2. 集成specCache，提供缓存支持
+ * 3. 支持多种数据源（std-spec、未来可扩展ble-spec等）
+ * 4. 处理缓存与实时数据的冲突
+ * 5. 提供数据来源标识
+ *
+ * 设计原则：
+ * - 向后兼容：保持与原有std-spec.js接口一致
+ * - 性能优先：内存缓存优先，减少重复请求
+ * - 可扩展：支持未来新增的spec类型
+ * - 冲突解决：时间戳优先，值变化更新
+ */
+
+import { Device } from 'miot';
+import Subject from "./subject";
+import { getEventGenerator } from "./utils";
+import { encodeProp } from "../../utils/spec";
+import { OK, PLUGIN_NULL_ERROR } from "./error-code";
+import * as spec from "./spec";
+import specCache, { CACHE_SOURCE } from "./specCache";
+import { copy } from "../../utils/objects";
+// 事件主题 management
+const specSubject = new Subject(getEventGenerator('spec_subject', encodeProp));
+export { CACHE_SOURCE };
+
+// 模块级缓存开关，默认关闭
+let cacheEnabled = false;
+export function enableCache(enabled) {
+  cacheEnabled = !!enabled;
+}
+export function isCacheEnabled() {
+  return cacheEnabled;
+}
+
+// Type definitions
+
+/**
+ * 读取属性值
+ *
+ * 功能说明：
+ * 1. 支持缓存初始化
+ * 2. 根据useCache选项决定是否使用缓存
+ * 3. 如果useCache为true且缓存中有数据，先使用缓存数据通知更新
+ * 4. 获取真实数据后先更新缓存，再返回数据
+ *
+ * @param {Array} props - 属性列表，如 [ { siid: 1, piid: 2 }, ... ]
+ * @param {Object} options - 配置选项
+ *   @param {boolean} [options.useCache=true] - 是否使用缓存
+ *   @param {boolean} [options.forceRefresh=false] - 是否强制刷新
+ *   @param {boolean} [options.fromSourceIfNeed=true] - 缓存未命中时是否从源获取
+ * @returns {Promise<Array>} 读取结果，如 [ { siid: 1, piid: 2, value: 3, code: 0 }, ... ]
+ */
+export function getProps(props, options = {}) {
+  const {
+    useCache = cacheEnabled,
+    // 受全局开关控制
+    forceRefresh = false,
+    // 是否强制刷新
+    fromSourceIfNeed = true // 缓存未命中时是否从源获取
+  } = options;
+
+  // 确保缓存已初始化
+  const ensureCache = () => {
+    return specCache.init();
+  };
+
+  // 从缓存读取并通知更新
+  const readFromCacheAndNotify = () => {
+    if (!useCache) {
+      return Promise.resolve(null);
+    }
+    return ensureCache().then(() => {
+      // 获取缓存数据
+      const cachedData = props.map(prop => {
+        const key = specCache.getCacheKey(prop);
+        const cached = specCache.get(key);
+        if (cached && cached.value !== undefined) {
+          return {
+            ...prop,
+            value: cached.value,
+            updateTime: cached.updateTime,
+            code: OK,
+            specDataSource: cached.specDataSource,
+            fromCache: true
+          };
+        }
+        return null;
+      });
+
+      // 如果有缓存数据，先通知更新
+      const hasCache = cachedData.some(item => item !== null);
+      if (hasCache) {
+        cachedData.forEach(item => {
+          if (item) {
+            specSubject.publish({
+              ...item
+            }, false);
+          }
+        });
+      }
+      return hasCache ? cachedData : null;
+    });
+  };
+
+  // 从源获取数据并更新缓存
+  const fetchFromSourceAndUpdateCache = cachedData => {
+    // 如果强制刷新或缓存未命中，从源获取
+    if (forceRefresh || !cachedData || !useCache) {
+      return spec.getProps(props).then(results => {
+        // 更新缓存
+        return ensureCache().then(() => {
+          results.forEach(result => {
+            if (result.code === OK && result.value !== undefined) {
+              const key = specCache.getCacheKey(result);
+              specCache.put(key, result.value, result.updateTime || Math.floor(Date.now() / 1000), CACHE_SOURCE.GET);
+            }
+          });
+          return results.map(r => ({
+            ...r,
+            specDataSource: r.specDataSource || CACHE_SOURCE.GET
+          }));
+        });
+      });
+    }
+
+    // 如果缓存中有数据，且fromSourceIfNeed为true，仍然从源获取并更新
+    if (fromSourceIfNeed && cachedData) {
+      return spec.getProps(props).then(results => {
+        // 更新缓存
+        return ensureCache().then(() => {
+          results.forEach(result => {
+            if (result.code === OK && result.value !== undefined) {
+              const key = specCache.getCacheKey(result);
+              specCache.put(key, result.value, result.updateTime || Math.floor(Date.now() / 1000), CACHE_SOURCE.GET);
+            }
+          });
+          // 返回设备最新数据，缓存仅作为提前通知使用
+          return results.map(r => ({
+            ...r,
+            specDataSource: r.specDataSource || CACHE_SOURCE.GET
+          }));
+        });
+      });
+    }
+
+    // 直接返回缓存数据
+    return Promise.resolve(cachedData);
+  };
+
+  // 执行流程
+  return readFromCacheAndNotify().then(cachedData => fetchFromSourceAndUpdateCache(cachedData)).catch(e => {
+    console.log('getProps error:', props, e);
+    return Promise.reject(e);
+  });
+}
+export function getCachedProps(props) {
+  return specCache.getCachedProps(props);
+}
+
+/**
+ * 设置属性值
+ *
+ * 功能说明：
+ * 1. 支持缓存初始化
+ * 2. 向设备发送设置请求
+ * 3. 设置成功后更新缓存
+ * 4. 通过事件通知缓存更新
+ *
+ * @param {Array} props - 属性列表，如 [ { siid: 1, piid: 2, value: 3 }, ... ]
+ * @param {Object} options - 配置选项
+ *   @param {boolean} [options.updateCache=true] - 是否更新缓存
+ * @returns {Promise<Array>} 设置结果，如 [ { siid: 1, piid: 2, value: 3, code: 0 }, ... ]
+ */
+export function setProps(props, options = {}) {
+  const {
+    updateCache = cacheEnabled // 受全局开关控制
+  } = options;
+  props = copy(props || []).filter(p => !!p);
+
+  // 确保缓存已初始化
+  const ensureCache = () => {
+    return specCache.init();
+  };
+
+  // 执行设置操作
+  const executeSet = () => {
+    return spec.setProps(props);
+  };
+
+  // 更新缓存
+  const updateCacheData = results => {
+    if (!updateCache || !props.length) {
+      return Promise.resolve(results);
+    }
+    return ensureCache().then(() => {
+      // 更新缓存
+      props.forEach((prop, index) => {
+        const result = results[index];
+        if (result && result.code === OK) {
+          const key = specCache.getCacheKey(prop);
+          const updateTime = result.updateTime || Math.floor(Date.now() / 1000);
+
+          // 更新缓存
+          specCache.put(key, prop.value, updateTime, CACHE_SOURCE.SET);
+
+          // 通过事件通知缓存更新
+          // specSubject.publish({
+          //   ...prop,
+          //   value: prop.value,
+          //   code: OK,
+          //   updateTime: updateTime,
+          //   did: Device.deviceID,
+          //   specDataSource: CACHE_SOURCE.SET
+
+          // }, false);
+        }
+      });
+      return results;
+    });
+  };
+
+  // 执行流程
+  return executeSet().then(results => updateCacheData(results)).catch(e => {
+    console.log('setProps error: ', props, e);
+    return Promise.reject(e);
+  });
+}
+
+/**
+ * 设置缓存中的属性值（不触发设备请求）
+ *
+ * 功能说明：
+ * 1. 仅更新本地缓存
+ * 2. 不会向设备发送请求
+ * 3. 通过事件通知缓存更新
+ *
+ * @param {Array} props - 属性列表，如 [ { siid: 1, piid: 2, value: 3 }, ... ]
+ * @returns {Promise<Array>} 设置结果
+ */
+export function setCachedProps(props) {
+  props = copy(props || []).filter(p => !!p);
+
+  // 确保缓存已初始化
+  const ensureCache = () => {
+    return specCache.init();
+  };
+
+  // 仅更新缓存
+  const updateCacheOnly = () => {
+    if (!props.length) {
+      return Promise.resolve([]);
+    }
+    return ensureCache().then(() => {
+      // 更新缓存
+      props.forEach(prop => {
+        const key = specCache.getCacheKey(prop);
+        const updateTime = Math.floor(Date.now() / 1000);
+
+        // 更新缓存
+        specCache.put(key, prop.value, updateTime, CACHE_SOURCE.SET);
+
+        // 通过事件通知缓存更新
+        specSubject.publish({
+          ...prop,
+          value: prop.value,
+          code: OK,
+          updateTime,
+          did: Device.deviceID
+        }, false);
+      });
+      return props.map(p => ({
+        ...p,
+        code: OK
+      }));
+    });
+  };
+
+  // 执行流程
+  return updateCacheOnly().catch(e => {
+    console.log('setCachedProps error: ', props, e);
+    return Promise.reject(e);
+  });
+}
+
+/**
+ * 调用方法
+ * @param { Object } prop 方法和参数， 如 { siid: 1, aiid: 2, in: [17, 'shanghai', ...] }
+ * @returns { Promise<Object> } 执行结果，如 { siid: 1, aiid: 2, code: 0 } 或 { code:-9999, message:xxx }
+ */
+export function doAction(prop) {
+  prop = copy(prop);
+  let result;
+  if (!prop) {
+    result = Promise.resolve({
+      code: PLUGIN_NULL_ERROR,
+      message: 'action is null'
+    });
+  } else {
+    result = spec.doAction(prop).then(() => {
+      return specCache.doAction(prop);
+    }).catch(e => {
+      console.log('doAction error:', prop, e);
+      return Promise.reject(e);
+    });
+  }
+  return result.finally(() => {});
+}
+
+/**
+ * 监听事件和属性
+ *
+ * 功能说明：
+ * 1. 支持缓存初始化
+ * 2. 订阅设备属性或事件变化
+ * 3. 如果publishImmediately为true，先从缓存读取并通知
+ * 4. 收到变化时更新缓存
+ * 5. 返回可取消的订阅对象
+ *
+ * @param {Array} props - 事件或属性，如 [ { siid: 1, eiid: 2 }, ...]
+ * @param {Function} listener - 监听器, 参数为 prop
+ * @param {Object} options - 配置选项
+ *   @param {boolean} [options.publishImmediately=true] - 是否立即发布当前值
+ *   @param {boolean} [options.updateCache=true] - 收到变化时是否更新缓存
+ * @returns {Promise<Object>} 订阅结果，格式如下
+ * {
+ *   props: [ ]                   // 数组，输入参数的每个 prop 的订阅结果
+ *   unsubscribe(): () => { }     // 取消监听
+ * }
+ */
+export function subscribe(props, listener, options = {}) {
+  props = copy(props || []).filter(p => !!p);
+  const {
+    publishImmediately = cacheEnabled,
+    // 受全局开关控制
+    updateCache = cacheEnabled // 受全局开关控制
+  } = options;
+
+  // 确保缓存已初始化
+  const ensureCache = () => {
+    return specCache.init();
+  };
+
+  // 如果需要立即发布当前值，从缓存读取并通知
+  const publishFromCache = () => {
+    if (!publishImmediately) {
+      return Promise.resolve();
+    }
+    return ensureCache().then(() => {
+      // 从缓存读取并通知
+      props.forEach(prop => {
+        const key = specCache.getCacheKey(prop);
+        const cached = specCache.get(key);
+        if (cached && cached.value !== undefined) {
+          // 通过listener通知
+          if (listener) {
+            listener({
+              ...prop,
+              value: cached.value,
+              updateTime: cached.updateTime,
+              code: OK,
+              specDataSource: cached.specDataSource
+            });
+          }
+        }
+      });
+    });
+  };
+
+  // 包装监听器以更新缓存
+  const wrappedListener = data => {
+    // 更新缓存
+    if (updateCache && data.piid !== undefined && data.code === OK) {
+      ensureCache().then(() => {
+        const key = specCache.getCacheKey(data);
+        specCache.put(key, data.value, data.updateTime || Math.floor(Date.now() / 1000), CACHE_SOURCE.SUBSCRIBE);
+      });
+    }
+
+    // 调用原始监听器
+    if (listener) {
+      listener({
+        ...data,
+        specDataSource: data.specDataSource || CACHE_SOURCE.SUBSCRIBE
+      });
+    }
+  };
+
+  // 执行订阅
+  const executeSubscribe = () => {
+    return spec.subscribe(props, wrappedListener);
+  };
+
+  // 执行流程
+  return publishFromCache().then(() => executeSubscribe()).then(result => {
+    // 返回订阅对象，包含取消订阅方法
+    return {
+      props: result.props,
+      unsubscribe: () => {
+        if (result && result.unsubscribe) {
+          result.unsubscribe();
+        }
+      }
+    };
+  }).catch(e => {
+    console.log('subscribe error:', props, e);
+    return Promise.reject(e);
+  });
+}

package/dist/service/specs/spec.d.ts

@@ -0,0 +1,10 @@
+import { Spec } from '../../types';
+export declare const ServiceSourceType: {
+    WIFI: number;
+    BLE: number;
+    WIFI_BLE: number;
+};
+export declare function getProps(props: Spec[], chunkFn?: (data: any) => void): Promise<any>;
+export declare function setProps(props: Spec[]): Promise<any>;
+export declare function doAction(prop: Spec): Promise<any>;
+export declare function subscribe(props: Spec[], listener: any): Promise<any>;

package/dist/service/specs/spec.js

@@ -0,0 +1,109 @@
+/**
+ * Spec服务统一入口
+ *
+ * 功能说明：
+ * 1. 封装std-spec.js，提供统一的set/get/action/subscribe接口
+ * 2. 集成specCache，提供缓存支持
+ * 3. 支持多种数据源（std-spec、未来可扩展ble-spec等）
+ * 4. 处理缓存与实时数据的冲突
+ * 5. 提供数据来源标识
+ *
+ * 设计原则：
+ * - 向后兼容：保持与原有std-spec.js接口一致
+ * - 性能优先：内存缓存优先，减少重复请求
+ * - 可扩展：支持未来新增的spec类型
+ * - 冲突解决：时间戳优先，值变化更新
+ */
+import { reduceResults } from "./utils";
+import { isSuccess } from "./error-code";
+// 引入std-spec
+import * as stdSpec from "./std-spec";
+export const ServiceSourceType = {
+  WIFI: 1,
+  BLE: 2,
+  WIFI_BLE: 3
+};
+const specs = [stdSpec];
+const subscriptions = new Set();
+function current(props, _type) {
+  const stdSpecProps = [];
+  props.forEach(prop => {
+    if (!prop) {
+      return;
+    }
+    stdSpecProps.push(prop);
+  });
+  return [stdSpecProps];
+}
+function mergePromise(promises) {
+  return Promise.all(promises).then(res => {
+    return reduceResults(res);
+  }).catch(error => {
+    return reduceResults(error);
+  });
+}
+export function getProps(props, chunkFn) {
+  const groupProps = current(props, 'read');
+  const promises = specs.reduce((preSpec, current, index) => {
+    return groupProps[index].length ? [...preSpec, current.getProps(groupProps[index], chunkFn)] : [...preSpec];
+  }, []);
+  return mergePromise(promises);
+}
+export function setProps(props) {
+  const groupProps = current(props, 'write');
+  const promises = specs.reduce((preSpec, currentSpec, index) => {
+    return groupProps[index].length ? [...preSpec, currentSpec.setProps(groupProps[index])] : [...preSpec];
+  }, []);
+  return mergePromise(promises);
+}
+export function doAction(prop) {
+  const groupProps = current([prop]);
+  const promises = specs.reduce((preSpec, current, index) => {
+    return groupProps[index].length ? [...preSpec, current.doAction(groupProps[index][0]).then(r => {
+      return [r];
+    }).catch(e => {
+      return [e];
+    })] : [...preSpec];
+  }, []);
+  // 处理返回结果 直接mergePromise 不能直接区别出错误
+  return mergePromise(promises).then(res => {
+    let res1 = Array.isArray(res) ? res[0] || res[1] : res;
+    let b = true;
+    if (Array.isArray(res)) {
+      for (let i = 0; i < res.length; i++) {
+        b = isSuccess(res[i]?.code || 0);
+        if (b === false) {
+          res1 = res[i];
+          break;
+        }
+      }
+    } else {
+      b = isSuccess(res?.code || 0);
+    }
+    // 统一处理返回{code: 0, sid}
+    if (b) {
+      return res1;
+    }
+    throw res1;
+  });
+}
+export function subscribe(props, listener) {
+  const specSubscribeProps = current(props);
+  const ps = specs.map((spec, index) => spec.subscribe(specSubscribeProps[index], listener));
+  return Promise.all(ps).then(arr => {
+    const result = {
+      props: arr[0].props,
+      unsubscribe: () => {
+        subscriptions.delete(result);
+        arr.forEach(sub => {
+          if (sub && sub.unsubscribe) {
+            sub.unsubscribe();
+            sub.unsubscribe = null;
+          }
+        });
+      }
+    };
+    subscriptions.add(result);
+    return result;
+  });
+}

package/dist/service/specs/specCache.d.ts

@@ -0,0 +1,85 @@
+/// <reference types="react-native" />
+import { Spec } from '../../types';
+export declare const CACHE_SOURCE: {
+    CACHE: string;
+    GET: string;
+    SET: string;
+    SUBSCRIBE: string;
+    ACTION: string;
+};
+declare class SpecCache {
+    memoryCache: Map<string, any>;
+    persistQueue: Set<string>;
+    lastPersistTime: number;
+    persistTimer: ReturnType<typeof setTimeout> | null;
+    loaded: boolean;
+    persisting: boolean;
+    constructor();
+    init(): Promise<unknown>;
+    loadFromStorage(): Promise<unknown>;
+    get(key: string): any;
+    put(key: string, value: unknown, updateTime: number, specDataSource?: string): boolean;
+    shouldUpdate(existing: any, newValue: unknown, newUpdateTime: number): boolean;
+    addToPersistQueue(key: string): void;
+    schedulePersist(): void;
+    doPersist(): Promise<void>;
+    flush(): Promise<void>;
+    cleanupOldest(): void;
+    remove(key: string): void;
+    clear(clearStorage?: boolean): Promise<void>;
+    getStats(): {
+        memorySize: number;
+        persistQueueSize: number;
+        sourceCount: Record<string, number>;
+        lastPersistTime: number;
+        persisting: boolean;
+    };
+    getCacheKey(prop: Spec): string;
+    getCachedProps(props: Spec[]): ({
+        value: any;
+        updateTime: any;
+        code: number;
+        specDataSource: any;
+        did?: string | undefined;
+        siid: number;
+        piid?: number | undefined;
+        aiid?: number | undefined;
+        miid?: number | undefined;
+        in?: any[] | undefined;
+        dataSource?: number | undefined;
+    } | {
+        code: number;
+        did?: string | undefined;
+        siid: number;
+        piid?: number | undefined;
+        aiid?: number | undefined;
+        miid?: number | undefined;
+        value?: any;
+        in?: any[] | undefined;
+        dataSource?: number | undefined;
+    })[];
+    setCachedProps(props: Spec[]): Promise<{
+        code: number;
+        did?: string | undefined;
+        siid: number;
+        piid?: number | undefined;
+        aiid?: number | undefined;
+        miid?: number | undefined;
+        value?: any;
+        in?: any[] | undefined;
+        dataSource?: number | undefined;
+    }[]>;
+    doAction(prop: Spec): Promise<{
+        code: number;
+        did?: string | undefined;
+        siid: number;
+        piid?: number | undefined;
+        aiid?: number | undefined;
+        miid?: number | undefined;
+        value?: any;
+        in?: any[] | undefined;
+        dataSource?: number | undefined;
+    }>;
+}
+declare const instance: SpecCache;
+export default instance;