@miot-rn/common-component 1.0.1

package/dist/service/specs/specCache.js

@@ -0,0 +1,421 @@
+/**
+ * Spec数据缓存管理器
+ *
+ * 功能说明：
+ * 1. 内存缓存：使用Map存储，提供快速读写
+ * 2. 持久化缓存：使用Host.storage，支持数据持久化
+ * 3. 批量持久化：减少storage写操作频率
+ * 4. 冲突解决：处理缓存数据与实时数据的冲突
+ * 5. 数据来源标识：区分缓存数据和实时数据的来源
+ *
+ * 缓存策略：
+ * - 内存缓存优先，减少storage访问
+ * - 批量持久化，最小持久化间隔
+ * - 缓存更新条件：值变化或时间戳更新
+ * - 数据来源标识：__cache_source__字段标识数据来源
+ */
+
+import { Host, Service, Device } from 'miot';
+import { encodeProp } from "../../utils/spec";
+import { deepEqual } from "../../utils/objects";
+import { OK } from "./error-code";
+// 缓存配置
+const CACHE_CONFIG = {
+  // 持久化间隔（毫秒）
+  PERSIST_INTERVAL: 2000,
+  // 存储键名
+  STORAGE_KEY: `${Service.account.ID}_${Device.deviceID}_spec_cache`
+};
+// 数据来源类型
+export const CACHE_SOURCE = {
+  CACHE: 'cache',
+  // 从缓存读取
+  GET: 'get',
+  // 通过get方法获取
+  SET: 'set',
+  // 通过set方法设置
+  SUBSCRIBE: 'subscribe',
+  // 通过subscribe订阅
+  ACTION: 'action' // 通过action调用
+};
+
+/**
+ * 缓存数据结构
+ * @typedef {Object} CacheItem
+ * @property {*} value - 属性值
+ * @property {number} updateTime - 更新时间戳（秒）
+ * @property {string} specDataSource - 数据来源（CACHE_SOURCE枚举）
+ * @property {number} timestamp - 缓存时间戳（毫秒)
+ */
+
+class SpecCache {
+  constructor() {
+    // 内存缓存：Map<key, CacheItem>
+    this.memoryCache = new Map();
+
+    // 持久化队列：Set<key>，待持久化的key集合
+    this.persistQueue = new Set();
+
+    // 最后持久化时间
+    this.lastPersistTime = 0;
+
+    // 持久化定时器
+    this.persistTimer = null;
+
+    // 是否已加载持久化数据
+    this.loaded = false;
+
+    // 批量持久化锁
+    this.persisting = false;
+  }
+
+  /**
+   * 初始化缓存，加载持久化数据
+   * @returns {Promise<void>}
+   */
+  init() {
+    if (this.loaded) {
+      return Promise.resolve(this.memoryCache);
+    }
+    return new Promise((resolve, reject) => {
+      this.loadFromStorage().then(() => {
+        resolve(this.memoryCache);
+      }).catch(error => {
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * 从持久化存储加载缓存
+   * @returns {Promise<void>}
+   */
+  loadFromStorage() {
+    return new Promise((resolve, reject) => {
+      Host.storage.get(CACHE_CONFIG.STORAGE_KEY).then(data => {
+        console.log('[SpecCache] Load from storage:', data);
+        if (data && typeof data === 'object') {
+          let validCount = 0;
+          Object.entries(data).forEach(([key, item]) => {
+            // 标记为缓存来源
+            this.memoryCache.set(key, {
+              ...item,
+              specDataSource: CACHE_SOURCE.CACHE,
+              fromStorage: true
+            });
+            validCount++;
+          });
+          console.log(`[SpecCache] Loaded ${validCount} items from storage`);
+        }
+        this.loaded = true;
+        resolve(this.memoryCache);
+      }).catch(error => {
+        console.error('[SpecCache] Load error:', error);
+        this.loaded = true;
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * 获取缓存数据
+   * @param {string} key - 缓存键
+   * @returns {CacheItem|null} 缓存项或null
+   */
+  get(key) {
+    const item = this.memoryCache.get(key);
+    if (!item) {
+      return null;
+    }
+    return {
+      ...item
+    };
+  }
+
+  /**
+   * 设置缓存数据
+   * @param {string} key - 缓存键
+   * @param {*} value - 值
+   * @param {number} updateTime - 更新时间戳（秒）
+   * @param {string} specDataSource - 数据来源
+   * @returns {boolean} 是否发生变化
+   */
+  put(key, value, updateTime, specDataSource = CACHE_SOURCE.GET) {
+    const now = Date.now();
+    const existing = this.memoryCache.get(key);
+
+    // 检查是否需要更新
+    const needUpdate = this.shouldUpdate(existing, value, updateTime);
+    if (needUpdate) {
+      const item = {
+        value,
+        updateTime: updateTime || Math.floor(now / 1000),
+        specDataSource,
+        fromCache: false,
+        timestamp: now
+      };
+      this.memoryCache.set(key, item);
+      this.addToPersistQueue(key);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * 判断是否需要更新缓存
+   * @param {CacheItem} existing - 现有缓存
+   * @param {*} newValue - 新值
+   * @param {number} newUpdateTime - 新时间戳
+   * @returns {boolean} 是否需要更新
+   */
+  shouldUpdate(existing, newValue, newUpdateTime) {
+    if (!existing) {
+      return true; // 无缓存，需要更新
+    }
+
+    // 值发生变化
+    if (!deepEqual(existing.value, newValue)) {
+      return true;
+    }
+
+    // 时间戳更新（严格大于）
+    if (newUpdateTime && existing.updateTime && newUpdateTime >= existing.updateTime) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * 添加到持久化队列
+   * @param {string} key - 缓存键
+   */
+  addToPersistQueue(key) {
+    this.persistQueue.add(key);
+    this.schedulePersist();
+  }
+
+  /**
+   * 安排持久化任务
+   */
+  schedulePersist() {
+    // 如果已有定时器或正在持久化，不重复调度
+    if (this.persistTimer || this.persisting) {
+      return;
+    }
+    const now = Date.now();
+    const timeSinceLastPersist = now - this.lastPersistTime;
+
+    // 如果距离上次持久化已超过间隔，立即执行
+    if (timeSinceLastPersist >= CACHE_CONFIG.PERSIST_INTERVAL) {
+      this.doPersist();
+      return;
+    }
+
+    // 否则调度到间隔后执行
+    const delay = CACHE_CONFIG.PERSIST_INTERVAL - timeSinceLastPersist;
+    this.persistTimer = setTimeout(() => {
+      this.persistTimer = null;
+      this.doPersist();
+    }, delay);
+  }
+
+  /**
+   * 执行持久化
+   * @returns {Promise<void>}
+   */
+  async doPersist() {
+    if (this.persisting || this.persistQueue.size === 0) {
+      return;
+    }
+    this.persisting = true;
+    try {
+      // 准备持久化数据
+      const dataToPersist = {};
+      const keysToPersist = Array.from(this.persistQueue);
+      for (const key of keysToPersist) {
+        const item = this.memoryCache.get(key);
+        if (item) {
+          dataToPersist[key] = {
+            value: item.value,
+            updateTime: item.updateTime,
+            timestamp: item.timestamp
+          };
+        }
+      }
+      console.log('[SpecCache] Persist data:', dataToPersist);
+
+      // 合并已有存储，避免未变更 key 被覆盖
+      let mergedData = {};
+      try {
+        const existingData = await Host.storage.get(CACHE_CONFIG.STORAGE_KEY);
+        if (existingData && typeof existingData === 'object') {
+          mergedData = {
+            ...existingData
+          };
+        }
+      } catch (error) {
+        console.warn('[SpecCache] Read storage before persist failed:', error);
+      }
+      mergedData = {
+        ...mergedData,
+        ...dataToPersist
+      };
+
+      // 执行持久化
+      await Host.storage.set(CACHE_CONFIG.STORAGE_KEY, mergedData);
+
+      // 清除已持久化的key
+      keysToPersist.forEach(key => this.persistQueue.delete(key));
+      this.lastPersistTime = Date.now();
+      console.log(`[SpecCache] Persisted ${keysToPersist.length} items`);
+    } catch (error) {
+      console.error('[SpecCache] Persist error:', error);
+    } finally {
+      this.persisting = false;
+
+      // 如果队列中还有数据，继续调度
+      if (this.persistQueue.size > 0) {
+        this.schedulePersist();
+      }
+    }
+  }
+
+  /**
+   * 立即持久化所有数据
+   * @returns {Promise<void>}
+   */
+  async flush() {
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+    }
+    await this.doPersist();
+  }
+
+  /**
+   * 清理最旧的缓存项
+   */
+  cleanupOldest() {
+    // 已移除内存上限限制，保留占位以兼容调用方
+  }
+
+  /**
+   * 清除指定key的缓存
+   * @param {string} key - 缓存键
+   */
+  remove(key) {
+    this.memoryCache.delete(key);
+    this.persistQueue.delete(key);
+  }
+
+  /**
+   * 清空所有缓存
+   * @param {boolean} clearStorage - 是否同时清除持久化数据
+   * @returns {Promise<void>}
+   */
+  async clear(clearStorage = false) {
+    this.memoryCache.clear();
+    this.persistQueue.clear();
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+    }
+    if (clearStorage) {
+      try {
+        await Host.storage.set(CACHE_CONFIG.STORAGE_KEY, {});
+      } catch (error) {
+        console.error('[SpecCache] Clear storage error:', error);
+      }
+    }
+  }
+
+  /**
+   * 获取缓存统计信息
+   * @returns {Object} 统计信息
+   */
+  getStats() {
+    const sourceCount = {};
+    for (const item of this.memoryCache.values()) {
+      const specDataSource = item.specDataSource || 'unknown';
+      sourceCount[specDataSource] = (sourceCount[specDataSource] || 0) + 1;
+    }
+    return {
+      memorySize: this.memoryCache.size,
+      persistQueueSize: this.persistQueue.size,
+      sourceCount,
+      lastPersistTime: this.lastPersistTime,
+      persisting: this.persisting
+    };
+  }
+
+  /**
+   * 生成缓存键
+   * @param {Object} prop - 属性对象
+   * @returns {string} 缓存键
+   */
+  getCacheKey(prop) {
+    if (!prop) return '';
+    return encodeProp(prop);
+  }
+
+  /**
+   * 获取缓存中的属性值（不触发源请求）
+   * @param {Array} props - 属性列表
+   * @returns {Array} 缓存结果
+   */
+  getCachedProps(props) {
+    const validProps = (props || []).filter(p => p && p.siid !== undefined && p.piid !== undefined);
+    return validProps.map(prop => {
+      const key = this.getCacheKey(prop);
+      const cached = this.get(key);
+      if (cached) {
+        return {
+          ...prop,
+          value: cached.value,
+          updateTime: cached.updateTime,
+          code: OK,
+          specDataSource: cached.specDataSource
+        };
+      }
+      return {
+        ...prop,
+        code: OK
+      };
+    });
+  }
+
+  /**
+   * 设置缓存中的属性值（不触发源请求）
+   * @param {Array} props - 属性列表
+   * @returns {Promise<Array>} 设置结果
+   */
+  setCachedProps(props) {
+    const validProps = (props || []).filter(p => p && p.siid !== undefined && p.piid !== undefined && p.value !== undefined);
+    validProps.forEach(prop => {
+      const key = this.getCacheKey(prop);
+      this.put(key, prop.value, Math.floor(Date.now() / 1000), CACHE_SOURCE.SET);
+    });
+    return Promise.resolve(validProps.map(p => ({
+      ...p,
+      code: OK
+    })));
+  }
+
+  /**
+   * 执行动作（缓存处理）
+   * @param {Object} prop - 动作参数
+   * @returns {Promise<Object>} 执行结果
+   */
+  doAction(prop) {
+    // 动作执行后可能需要更新相关属性缓存
+    // 这里可以添加具体的业务逻辑
+    return Promise.resolve({
+      ...prop,
+      code: 0 // OK
+    });
+  }
+}
+
+// 单例实例
+const instance = new SpecCache();
+export default instance;

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

@@ -0,0 +1,5 @@
+import { Spec } from '../../types';
+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): any;

package/dist/service/specs/std-spec.js

@@ -0,0 +1,228 @@
+import { Device, DeviceEvent, Service } from 'miot';
+import Subject from "./subject";
+import { genError, getEventGenerator, mapError } from "./utils";
+import { isTypeOf } from "../../utils/types";
+import { encodeProp, decodeProp, specsToSubscribeKeys, specAccess } from "../../utils/spec";
+import { OK } from "./error-code";
+const specSubject = new Subject(getEventGenerator('std_spec_subject', encodeProp));
+let receivedMessagesSubscription = null;
+export function getProps(props, chunkFn) {
+  // console.log('getProps---props', props);
+  // 处理固件不上报的情况，此时须将dataSource 设置为2，强行从固件读取
+  const ps = (props || []).reduce((ret, prop) => {
+    if (specAccess(prop, 'read')) {
+      const {
+        miid,
+        siid,
+        piid,
+        did = Device.deviceID,
+        dataSource = prop.fromSource ? 1 : 2
+      } = prop;
+      const p = {
+        siid,
+        piid,
+        did
+      };
+      if (miid && !isNaN(parseInt(miid, 10))) {
+        p.miid = miid;
+      }
+      if (!ret[dataSource]) {
+        ret[dataSource] = [];
+      }
+      ret[dataSource].push(p);
+    }
+    return ret;
+  }, {});
+  Service.smarthome.reportLog(Device.model, `[miot.plugin.spec, ${new Date()}, doSpecOperation (std channel - get) start: ]${JSON.stringify({
+    ps
+  })}`);
+  return Promise.all(Object.entries(ps).map(([dataSource, v]) => {
+    return Service.spec.getPropertiesValue(v, parseInt(dataSource, 10)).then(res => {
+      isTypeOf('Function', chunkFn) && chunkFn && chunkFn(res);
+      return res;
+    }).catch(reason => {
+      Service.smarthome.reportLog(Device.model, `[miot.plugin.spec, ${new Date()}, doSpecOperation (std channel - get) error: ]${JSON.stringify({
+        v,
+        dataSource,
+        reason
+      })}`);
+      mapError(props)(reason);
+    }).finally(() => {});
+  })).then(res => {
+    Service.smarthome.reportLog(Device.model, `[miot.plugin.spec, ${new Date()}, doSpecOperation (std channel - get) res: ]${JSON.stringify({
+      res
+    })}`);
+    return res.flat();
+  });
+}
+export function setProps(props) {
+  props = fillInfo(props);
+  console.log('std-spec---setProps', props, 'time', Math.floor(Date.now() / 1000));
+  Service.smarthome.reportLog(Device.model, `[miot.plugin.spec, ${new Date()}, doSpecOperation (std channel - set) start: ]${JSON.stringify({
+    props
+  })}`);
+  return Service.spec.setPropertiesValue(props.filter(prop => {
+    return !!prop;
+  }).map(prop => {
+    const t = {
+      did: prop.did,
+      siid: prop.siid,
+      piid: prop.piid,
+      value: prop.value
+    };
+    if (prop.miid) {
+      t.miid = prop.miid;
+    }
+    return t;
+  })).then(res => {
+    console.log('std-spec---setProps-res', res, 'time', Math.floor(Date.now() / 1000));
+    Service.smarthome.reportLog(Device.model, `[miot.plugin.spec, ${new Date()}, doSpecOperation (std channel - set) res: ]${JSON.stringify({
+      res
+    })}`);
+    return res;
+  }).catch(reason => {
+    Service.smarthome.reportLog(Device.model, `[miot.plugin.spec, ${new Date()}, doSpecOperation (std channel - set) error: ]${JSON.stringify({
+      props
+    })}`);
+    mapError(props)(reason);
+  });
+}
+export function doAction(prop) {
+  const action = {
+    ...prop,
+    did: prop.did ? prop.did : Device.deviceID
+  };
+  const t = {
+    did: action.did,
+    siid: action.siid,
+    aiid: action.aiid,
+    in: action.in
+  };
+  if (action.miid) {
+    t.miid = action.miid;
+  }
+  Service.smarthome.reportLog(Device.model, `[miot.plugin.spec, ${new Date()}, doSpecOperation (std channel - action) start: ]${JSON.stringify({
+    t
+  })}`);
+  return Service.spec.doAction(t).then(res => {
+    Service.smarthome.reportLog(Device.model, `[miot.plugin.spec, ${new Date()}, doSpecOperation (std channel - action) res: ]${JSON.stringify({
+      res
+    })}`);
+    return {
+      ...action,
+      ...res
+    };
+  }).catch(reason => {
+    Service.smarthome.reportLog(Device.model, `[miot.plugin.spec, ${new Date()}, doSpecOperation (std channel - action) error: ]${JSON.stringify({
+      reason
+    })}`);
+    genError(action)(reason);
+  });
+}
+function subscribeReceivedMessage() {
+  const deviceReceivedMessages = DeviceEvent.deviceReceivedMessages;
+  return deviceReceivedMessages.addListener((device, messages, data) => {
+    if (!device || device.deviceID !== Device.deviceID || !messages) {
+      return;
+    }
+    // console.log('miot.plugin.car-DeviceEvent.deviceReceivedMessages', messages);
+
+    Service.smarthome.reportLog(Device.model, `[miot.plugin.car, ${new Date()}, data-source::std-spec::subscribeReceivedMessage:]${JSON.stringify({
+      messages,
+      data
+    })}`);
+    const did = device.deviceID;
+    messages.forEach((v, k) => {
+      const prop = decodeProp(k);
+      const d = (data || []).find(({
+        key
+      }) => k === key);
+      if (!prop || !d) {
+        return;
+      }
+      const updateTime = d.time;
+      // prop
+      if (prop.piid) {
+        // const k = toKey(prop);
+        // // 如果本地spec值更新（本地的updateTime严格大于收到的updateTime，因为这里是秒级，不能包含等于），则不处理
+        // let { updateTime: updateTimeFromCache = 0 } = cache.get(k);
+        // if (updateTimeFromCache > updateTime) {
+        //   return;
+        // }
+        specSubject.publish({
+          ...prop,
+          value: Array.isArray(v) ? v[0] : v,
+          code: OK,
+          updateTime,
+          did
+        }, false);
+        return;
+      }
+      // event
+      if (prop.eiid) {
+        // 有关联属性
+        // 把event 本身更新一次
+        // 如果只有一个返回值，取第0个value
+        // 如果有多个返回值，返回value 数组
+        let parsedValue = v;
+        if (Array.isArray(v)) {
+          parsedValue = v.map(v1 => {
+            return isTypeOf('Object', v1) && v1.piid ? v1.value : v1;
+          });
+          parsedValue = parsedValue.length === 1 ? parsedValue[0] : parsedValue;
+        }
+        specSubject.publish({
+          ...prop,
+          fromEvent: true,
+          value: parsedValue,
+          code: OK,
+          updateTime,
+          did
+        }, false);
+      }
+    });
+  });
+}
+function fillInfo(props) {
+  const propsNew = props.filter(element => {
+    return element !== null;
+  });
+  return propsNew.map(prop => {
+    const {
+      did,
+      miid,
+      ...rest
+    } = prop;
+    const t = {
+      ...rest,
+      did: did || Device.deviceID
+    };
+    if (miid) {
+      t.miid = miid;
+    }
+    return t;
+  });
+}
+export function subscribe(props, listener) {
+  if (!receivedMessagesSubscription) {
+    receivedMessagesSubscription = subscribeReceivedMessage();
+  }
+  props = fillInfo(props);
+  const keys = specsToSubscribeKeys(props);
+  // return Device.getDeviceWifi().subscribeMessages(...keys).then(() => {
+  return Device.getDeviceWifi().listenMessages(...keys).then(() => {
+    const subscription = specSubject.subscribe(props, listener);
+    const subscribed = props.map(prop => {
+      return {
+        ...prop,
+        code: OK
+      };
+    });
+    return {
+      props: subscribed,
+      unsubscribe: () => {
+        subscription && subscription.unsubscribe && subscription.unsubscribe();
+      }
+    };
+  }).catch(mapError(props));
+}

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

@@ -0,0 +1,20 @@
+export default class Subject<T> {
+    keyOf: (topic: T) => string;
+    subscriptions: Set<any>;
+    handler: any;
+    filter: any;
+    constructor(keyOf: (topic: T) => string, handler?: any);
+    setFilter(filter: any): void;
+    subscribe(topics: T[], listener: any): {
+        unsubscribe: () => void;
+        isActive: () => boolean;
+        topics: T[];
+    };
+    getAllTopics(): T[];
+    publish(topic: T, active: boolean, callback?: (topic: T) => void): void;
+    unsubscribeAll(): void;
+}
+export declare function newSimpleFilter(): {
+    accept: (key: string, topic: any) => boolean;
+    reset: () => void;
+};