@ray-js/robot-data-stream 0.0.1-beta-1

package/README.md

@@ -0,0 +1,69 @@
+English | [简体中文](./README-zh_CN.md)
+
+# @ray-js/robot-data-stream
+
+[![latest](https://img.shields.io/npm/v/@ray-js/robot-data-stream/latest.svg)](https://www.npmjs.com/package/@ray-js/robot-data-stream) [![download](https://img.shields.io/npm/dt/@ray-js/robot-data-stream.svg)](https://www.npmjs.com/package/@ray-js/robot-data-stream)
+
+> Robot P2P data stream hooks
+
+## Installation
+
+```sh
+$ npm install @ray-js/robot-data-stream
+# or
+$ yarn add @ray-js/robot-data-stream
+```
+
+## Develop
+
+```sh
+# watch compile component code
+yarn watch
+# watch compile demo
+yarn start:tuya
+```
+
+## Usage
+
+```tsx
+
+import React, { useEffect } from 'react';
+import { View, Text } from '@ray-js/ray';
+import { useP2PDataStream, StreamDataNotificationCenter } from '@ray-js/robot-data-stream';
+import styles from './index.module.less';
+
+const DemoBlock = ({ devId }) => {
+  
+  const onReceiveMapData = (data: string) => {
+    StreamDataNotificationCenter.emit('receiveMapData', data)
+  }
+
+  const onReceivePathData = (data:string) => {
+    StreamDataNotificationCenter.emit('receivePathData', data)
+  }
+
+
+  useEffect(() => {
+
+    useP2PDataStream(devId, onReceiveMapData, onReceivePathData);
+
+  }, []);
+
+  return (
+    <View className={styles.demoBlock}>
+      <View className={styles.demoBlockTitle}>
+        <Text className={styles.demoBlockTitleText}>{devId}</Text>
+      </View>
+     </View>
+  )
+};
+
+export default function Home() {
+  return (
+    <View className={styles.view}>
+      <DemoBlock devId="" />
+    </View>
+  );
+}
+```
+

package/lib/api/index.d.ts

@@ -0,0 +1,2 @@
+import SweeperP2pInstance from "./sweeperP2p";
+export { SweeperP2pInstance };

package/lib/api/index.js

@@ -0,0 +1,2 @@
+import SweeperP2pInstance from "./sweeperP2p";
+export { SweeperP2pInstance };

package/lib/api/p2pApi.d.ts

@@ -0,0 +1,93 @@
+/**
+ * P2P 工具类
+ */
+export default class P2pApi {
+    isConnected: boolean;
+    offSessionStatusChange: () => void;
+    devId: string;
+    constructor();
+    /**
+     * 设备断开之后的重连
+     */
+    reconnectP2p: (successCb?: () => void) => void;
+    /**
+     * 初始化P2P SDK
+     * @param id 用户Id
+     * @returns
+     */
+    initP2pSdk: (devId: string) => Promise<boolean>;
+    /**
+     * 连接设备
+     * @returns
+     */
+    connectDevice: (successCb?: () => void, failCb?: () => void, completeCb?: () => void) => Promise<boolean>;
+    /**
+     * 断开P2P设备连接
+     * @returns
+     */
+    disconnectDevice: () => Promise<boolean>;
+    /**
+     * 开始P2p流传输
+     * @param files
+     * @param albumName
+     * @param filePath
+     * @param successCb
+     * @param failedCb
+     * @returns
+     */
+    downloadStream: (files: {
+        files: Array<string>;
+    }, albumName: string, successCb?: () => void, failedCb?: () => void) => Promise<unknown> | undefined;
+    /**
+     * 监听p2p传输数据流
+     * @param callback
+     * @returns
+     */
+    onP2pStreamPacketReceive: (callback: (...args: any[]) => void) => () => void;
+    /**
+     * 开始下载文件
+     * files : {"files":["filesname1", "filesname2", "filesname3" ]}
+     */
+    downloadFile: (files: {
+        files: Array<string>;
+    }, albumName: string, filePath: string, successCb?: () => void, failedCb?: () => void) => Promise<unknown> | null;
+    /**
+     * 注册下载监听事件
+     * @param callback
+     * @returns
+     */
+    onDownloadProgressUpdate: (callback: (...args: any[]) => void) => () => void;
+    /**
+     * 注册多文件下载进度监听
+     * @param callback
+     * @returns
+     */
+    onDownloadTotalProgressUpdate: (callback: (...args: any[]) => void) => () => void;
+    /**
+     * 注册单文件下载进度完成监听
+     * @param callback
+     * @returns
+     */
+    onFileDownloadComplete: (callback: (...args: any[]) => void) => () => void;
+    /**
+     * 注册设备因为其他异常断开连接的事件
+     * @returns
+     */
+    onSessionStatusChange: (callback: (...args: any[]) => void) => () => void;
+    /**
+     * 取消进行下载
+     * @returns
+     */
+    cancelDownloadTask: () => Promise<unknown>;
+    /**
+     * 查询设备相册文件列表
+     * @param albumName
+     * @returns
+     */
+    queryAlbumFileIndexs: (albumName: string) => Promise<unknown>;
+    /**
+     * P2p SDK 销毁
+     * @returns
+     */
+    deInitP2PSDK: () => Promise<boolean>;
+}

package/lib/api/p2pApi.js

@@ -0,0 +1,342 @@
+/* eslint-disable prefer-promise-reject-errors */
+import { p2p } from '@ray-js/ray';
+import moment from 'moment';
+import { Logger } from '@/utils';
+/**
+ * P2P 工具类
+ */
+export default class P2pApi {
+  // P2p连接状态
+
+  constructor() {
+    this.isConnected = false;
+  }
+
+  /**
+   * 设备断开之后的重连
+   */
+  reconnectP2p = successCb => {
+    /**
+     * 监听到断开事件后
+     * 连接成功后设置flag为true
+     * 并清除定时器
+     */
+    this.isConnected = false;
+    if (!this.isConnected) {
+      Logger.info('start p2p reconnect ==>', moment().format('YYYY-MM-DD HH:mm:ss'));
+      this.connectDevice(() => {
+        Logger.info('p2p reconnect success ==>', moment().format('YYYY-MM-DD HH:mm:ss'));
+        this.isConnected = true;
+        if (this.isConnected) {
+          typeof successCb === 'function' && successCb();
+        }
+      }, () => {}, () => {
+        Logger.log('reconnect complete ==>', String(this.isConnected));
+        if (!this.isConnected) {
+          Logger.warn('p2p reconnect failed ==>', moment().format('YYYY-MM-DD HH:mm:ss'));
+          this.reconnectP2p(successCb);
+        }
+      });
+    }
+  };
+
+  /**
+   * 初始化P2P SDK
+   * @param id 用户Id
+   * @returns
+   */
+  initP2pSdk = async devId => {
+    return new Promise((resolve, reject) => {
+      try {
+        this.devId = devId;
+        p2p.P2PSDKInit({
+          success: () => {
+            Logger.info('P2PSDKInit success');
+            resolve(true);
+          },
+          fail: params => {
+            Logger.warn('P2PSDKInit fail', params);
+            resolve(false);
+          }
+        });
+      } catch (e) {
+        reject(false);
+      }
+    });
+  };
+
+  /**
+   * 连接设备
+   * @returns
+   */
+  connectDevice = (successCb, failCb, completeCb) => {
+    return new Promise((resolve, reject) => {
+      try {
+        p2p.connectDevice({
+          deviceId: this.devId,
+          timeout: 5000,
+          mode: 0,
+          success: () => {
+            Logger.info('p2p connectDevice success');
+            this.isConnected = true;
+            typeof successCb === 'function' && successCb();
+            resolve(true);
+          },
+          fail: params => {
+            Logger.warn('p2p connectDevice failed ==>', params);
+            typeof failCb === 'function' && failCb();
+            resolve(false);
+          },
+          complete: () => {
+            typeof completeCb === 'function' && completeCb();
+          }
+        });
+      } catch (e) {
+        Logger.error('p2p connectDevice occur an error ==>', e);
+        reject(false);
+      }
+    });
+  };
+
+  /**
+   * 断开P2P设备连接
+   * @returns
+   */
+  disconnectDevice = () => {
+    return new Promise((resolve, reject) => {
+      try {
+        p2p.disconnectDevice({
+          deviceId: this.devId,
+          success: () => {
+            this.isConnected = false;
+            Logger.info('p2p disconnectDevice success');
+            resolve(true);
+          },
+          fail: () => {
+            Logger.warn('p2p disconnectDevice failed');
+            resolve(false);
+          }
+        });
+      } catch (e) {
+        Logger.warn('p2p disconnectDevice occur an error ==>', e);
+        reject(false);
+      }
+    });
+  };
+
+  /**
+   * 开始P2p流传输
+   * @param files
+   * @param albumName
+   * @param filePath
+   * @param successCb
+   * @param failedCb
+   * @returns
+   */
+  downloadStream = (files, albumName, successCb, failedCb) => {
+    try {
+      if (this.isConnected) {
+        return new Promise(resolve => {
+          p2p.downloadStream({
+            deviceId: this.devId,
+            albumName: albumName,
+            jsonfiles: JSON.stringify(files),
+            success: () => {
+              Logger.info('p2p downloadStream success');
+              typeof successCb === 'function' && successCb();
+              resolve(true);
+            },
+            fail: params => {
+              Logger.warn('p2p downloadStream failed ==>', params);
+              setTimeout(() => {
+                typeof failedCb === 'function' && failedCb();
+              }, 500);
+              resolve(false);
+            },
+            complete: () => {}
+          });
+        });
+      }
+    } catch (e) {
+      Logger.warn('p2p downloadStream occur an error ==>', e);
+    }
+  };
+
+  /**
+   * 监听p2p传输数据流
+   * @param callback
+   * @returns
+   */
+  onP2pStreamPacketReceive = callback => {
+    p2p.onStreamPacketReceive(callback);
+    return () => {
+      // 反注册监听
+      p2p.offStreamPacketReceive(callback);
+    };
+  };
+
+  /**
+   * 开始下载文件
+   * files : {"files":["filesname1", "filesname2", "filesname3" ]}
+   */
+  downloadFile = (files, albumName, filePath, successCb, failedCb) => {
+    try {
+      if (this.isConnected) {
+        return new Promise(resolve => {
+          p2p.downloadFile({
+            deviceId: this.devId,
+            albumName: albumName,
+            filePath: filePath,
+            jsonfiles: JSON.stringify(files),
+            success: () => {
+              Logger.info('p2p downloadFile success');
+              typeof successCb === 'function' && successCb();
+              resolve(true);
+            },
+            fail: params => {
+              Logger.warn('p2p downloadFile failed ==>', params);
+              setTimeout(() => {
+                typeof failedCb === 'function' && failedCb();
+              }, 500);
+              resolve(false);
+            },
+            complete: () => {}
+          });
+        });
+      }
+    } catch (e) {
+      Logger.error('p2p downloadFile occur an error ==>', e);
+    }
+    return null;
+  };
+
+  /**
+   * 注册下载监听事件
+   * @param callback
+   * @returns
+   */
+  onDownloadProgressUpdate = callback => {
+    p2p.onDownloadProgressUpdate(callback);
+    return () => {
+      // 反注册监听
+      p2p.offDownloadProgressUpdate(callback);
+    };
+  };
+
+  /**
+   * 注册多文件下载进度监听
+   * @param callback
+   * @returns
+   */
+  onDownloadTotalProgressUpdate = callback => {
+    p2p.onDownloadTotalProgressUpdate(callback);
+    return () => {
+      // 反注册监听
+      p2p.offDownloadTotalProgressUpdate(callback);
+    };
+  };
+
+  /**
+   * 注册单文件下载进度完成监听
+   * @param callback
+   * @returns
+   */
+  onFileDownloadComplete = callback => {
+    p2p.onFileDownloadComplete(callback);
+    return () => {
+      // 反注册监听
+      p2p.offFileDownloadComplete(callback);
+    };
+  };
+
+  /**
+   * 注册设备因为其他异常断开连接的事件
+   * @returns
+   */
+  onSessionStatusChange = callback => {
+    p2p.onSessionStatusChange(callback);
+    this.offSessionStatusChange = () => {
+      // 反注册监听
+      p2p.offSessionStatusChange(callback);
+    };
+    return this.offSessionStatusChange;
+  };
+
+  /**
+   * 取消进行下载
+   * @returns
+   */
+  cancelDownloadTask = () => {
+    return new Promise((resolve, reject) => {
+      try {
+        p2p.cancelDownloadTask({
+          deviceId: this.devId,
+          success: () => {
+            resolve(true);
+          },
+          fail: () => {
+            reject(false);
+          }
+        });
+      } catch (e) {
+        Logger.info('cancelDownloadTask occur an error', e);
+        reject(false);
+      }
+    });
+  };
+
+  /**
+   * 查询设备相册文件列表
+   * @param albumName
+   * @returns
+   */
+  queryAlbumFileIndexs = albumName => {
+    return new Promise(resolve => {
+      p2p.queryAlbumFileIndexs({
+        deviceId: this.devId,
+        albumName,
+        success: params => {
+          Logger.info('queryAlbumFileIndexs ==>', params);
+          resolve(params);
+        },
+        fail: params => {
+          Logger.warn('queryAlbumFileIndexs failed ==>', params);
+          resolve(null);
+        }
+      });
+    });
+  };
+
+  /**
+   * P2p SDK 销毁
+   * @returns
+   */
+  deInitP2PSDK = async () => {
+    // 先销毁断开监听
+    typeof this.offSessionStatusChange === 'function' && this.offSessionStatusChange();
+    // 销毁初始化时,先进行断连操作
+    if (this.isConnected) {
+      await this.disconnectDevice();
+    }
+    return new Promise((resolve, reject) => {
+      try {
+        p2p.deInitSDK({
+          success: () => {
+            Logger.info('deInitP2pSDK success');
+            resolve(true);
+          },
+          fail: () => {
+            Logger.info('deInitP2pSDK failed');
+            resolve(false);
+          },
+          complete: () => {
+            resolve(true);
+          }
+        });
+      } catch (e) {
+        Logger.error('deInitP2pSDK occur an error ==>', e);
+        reject(false);
+      }
+    });
+  };
+}

package/lib/api/sweeperP2p.d.ts

@@ -0,0 +1,157 @@
+import P2pApi from './p2pApi';
+/**
+ * 基于P2p工具类的扫地机扩展实现
+ */
+interface FileInfo {
+    channel: number;
+    createTime: number;
+    dir: number;
+    duration: number;
+    filename: string;
+    idx: number;
+    type: number;
+}
+declare const FILE_NAME_MAP: {
+    readonly 'map.bin': {
+        readonly type: 0;
+    };
+    readonly 'cleanPath.bin': {
+        readonly type: 1;
+    };
+    readonly 'map.bin.stream': {
+        readonly type: 0;
+    };
+    readonly 'cleanPath.bin.stream': {
+        readonly type: 1;
+    };
+};
+export declare class SweeperP2p extends P2pApi {
+    file: {
+        items: Array<FileInfo>;
+        count: number;
+    } | undefined;
+    albumName: string;
+    streamFilePath: string;
+    dataFilePath: string;
+    mapBinData: string;
+    navPathBinData: string;
+    cleanPathBinData: string;
+    mapBinStream: string;
+    navPathBinStream: string;
+    cleanPathBinStream: string;
+    downloadType: number;
+    readingMap: boolean;
+    readingClean: boolean;
+    readingNav: boolean;
+    cacheDir: string;
+    fileIndex: number;
+    cacheData: any;
+    packetDataCacheMap: Map<keyof typeof FILE_NAME_MAP, Map<number, string>>;
+    packetSerialNumberCacheMap: Map<keyof typeof FILE_NAME_MAP, number>;
+    packetTotalMap: Map<keyof typeof FILE_NAME_MAP, number>;
+    onReceiveMapData: (data: string) => void;
+    onReceivePathData: (data: string) => void;
+    offFileDownloadComplete: () => void;
+    offP2pStreamPacketReceive: () => void;
+    offDownLoadProgressUpdate: () => void;
+    offTotalDownLoadProgressUpdate: () => void;
+    constructor();
+    private setStreamFilePath;
+    private setDataFilePath;
+    /**
+     * 获取流文件存储地址
+     * @param fileName
+     * @returns
+     */
+    private getStreamFilePath;
+    /**
+     * 获取完整文件存储地址
+     * @param fileName
+     * @returns
+     */
+    private getDataFilePath;
+    /**
+     * 创建文件路径文件夹
+     * @param filePath
+     * @returns
+     */
+    private createFilePath;
+    /**
+     * 检查当前文件目录是否存在
+     * @param filePath
+     * @returns
+     */
+    private checkIfDirIsExist;
+    /**
+     * 初始化文件目录
+     * @param filePath
+     * @returns
+     */
+    private initFilePath;
+    /**
+     * 根据文件名返回对应的fileType
+     * @param filename
+     */
+    private getFileType;
+    /**
+     * 设备连接状态发生改变
+     * @param data
+     */
+    sessionStatusCallback: (data: {
+        deviceId: string;
+        status: number;
+    }) => void;
+    /**
+     * 开始进行文件下载
+     * @param downloadType
+     * 0: 下载断开 1: 持续下载
+     */
+    startObserverSweeperDataByP2P: (downloadType: number, devId: string, onReceiveMapData: (data: string) => void, onReceivePathData: (data: string) => void) => Promise<void>;
+    /**
+     * 注册下载有关的监听
+     */
+    private registerP2pDownloadEvent;
+    /**
+     * 移除下载有关的监听
+     */
+    private removeP2pDownloadEvent;
+    /**
+     * 单文件下载完成回调
+     * @param downloadComplete
+     */
+    private fileDownloadCompleteCallback;
+    /**
+     * p2p数据流回调
+     * @param downloadComplete
+     */
+    private p2pStreamPacketReceiveCallback;
+    /**
+     * 单文件下载完成回调
+     * @param data
+     */
+    private fileDownloadProgressCallback;
+    /**
+     * 多文件下载进度监听
+     * @param data
+     */
+    private fileTotalDownloadProgressCallback;
+    /**
+     * 从指定的文件路径获取文件
+     * @param fileName
+     * @param filePath
+     */
+    private readFileFromPath;
+    private setReading;
+    private resetReading;
+    /**
+     * 查询返回的文件中是否包含了所需文件
+     * @param fileList
+     */
+    private queryNeedFiles;
+    /**
+     * 停止文件下载
+     */
+    stopObserverSweeperDataByP2P: () => Promise<unknown>;
+}
+declare const sweeperP2pInstance: SweeperP2p;
+export default sweeperP2pInstance;

package/lib/api/sweeperP2p.js

@@ -0,0 +1,479 @@
+/* eslint-disable no-shadow */
+import P2pApi from './p2pApi';
+import Base64 from 'base64-js';
+import { padStart } from 'lodash-es';
+import { Logger } from '@/utils';
+/**
+ * 基于P2p工具类的扫地机扩展实现
+ */
+
+const FILE_NAME_MAP = {
+  'map.bin': {
+    type: 0
+  },
+  'cleanPath.bin': {
+    type: 1
+  },
+  'map.bin.stream': {
+    type: 0
+  },
+  'cleanPath.bin.stream': {
+    type: 1
+  }
+};
+
+// 走p2p流传输(新) or 读取bin文件(旧)
+const shouldDownloadStream = Boolean(ty.p2p.downloadStream && ty.p2p.onStreamPacketReceive);
+export class SweeperP2p extends P2pApi {
+  constructor() {
+    super();
+    this.file = undefined;
+    this.downloadType = 1;
+    this.fileIndex = -1; // -1 表示所有文件下载完成
+    this.albumName = 'ipc_sweeper_robot';
+    this.mapBinData = 'map.bin';
+    this.navPathBinData = 'navPath.bin';
+    this.cleanPathBinData = 'cleanPath.bin';
+    this.mapBinStream = 'map.bin.stream';
+    this.navPathBinStream = 'navPath.bin.stream';
+    this.cleanPathBinStream = 'cleanPath.bin.stream';
+    this.cacheDir = ty.env.USER_DATA_PATH;
+    this.readingMap = false;
+    this.readingClean = false;
+    this.readingNav = false;
+    this.cacheData = {};
+    this.packetTotalMap = new Map([['map.bin', -1], ['cleanPath.bin', -1], ['map.bin.stream', -1], ['cleanPath.bin.stream', -1]]);
+    this.packetSerialNumberCacheMap = new Map([['map.bin', -1], ['cleanPath.bin', -1], ['map.bin.stream', -1], ['cleanPath.bin.stream', -1]]);
+    this.packetDataCacheMap = new Map([['map.bin', new Map()], ['cleanPath.bin', new Map()], ['map.bin.stream', new Map()], ['cleanPath.bin.stream', new Map()]]);
+  }
+  setStreamFilePath = () => {
+    // this.streamFilePath = this.cacheDir + `/${this.albumName}/${devId}/stream`;
+    if (/usr/.test(this.cacheDir)) {
+      this.streamFilePath = this.cacheDir;
+    } else {
+      this.streamFilePath = this.cacheDir + 'usr';
+    }
+    // 检查存储文件目录是否存在
+    // this.initFilePath(this.streamFilePath);
+  };
+  setDataFilePath = () => {
+    // this.dataFilePath = this.cacheDir + `/${this.albumName}/${devId}/data`;
+    if (/usr/.test(this.cacheDir)) {
+      this.dataFilePath = this.cacheDir;
+    } else {
+      this.streamFilePath = this.cacheDir + 'usr';
+    }
+    // 检查存储文件目录是否存在
+    // this.initFilePath(this.dataFilePath);
+  };
+
+  /**
+   * 获取流文件存储地址
+   * @param fileName
+   * @returns
+   */
+  getStreamFilePath = fileName => {
+    return this.streamFilePath + '/' + fileName;
+  };
+
+  /**
+   * 获取完整文件存储地址
+   * @param fileName
+   * @returns
+   */
+  getDataFilePath = fileName => {
+    return this.dataFilePath + '/' + fileName;
+  };
+
+  /**
+   * 创建文件路径文件夹
+   * @param filePath
+   * @returns
+   */
+  createFilePath = filePath => {
+    try {
+      ty.getFileSystemManager().mkdirSync({
+        dirPath: filePath,
+        recursive: true
+      });
+      console.log('mkdirSync success: filePath ==>', filePath);
+      return true;
+    } catch (e) {
+      console.log('mkdirSync error ==>', e);
+      return false;
+    }
+  };
+
+  /**
+   * 检查当前文件目录是否存在
+   * @param filePath
+   * @returns
+   */
+  checkIfDirIsExist = filePath => {
+    return new Promise(resolve => {
+      ty.getFileSystemManager().access({
+        path: filePath,
+        success(params) {
+          console.info('file access success ==>', params);
+          resolve(true);
+        },
+        fail(params) {
+          console.info('file access fail ==>', params);
+          resolve(false);
+        }
+      });
+    });
+  };
+
+  /**
+   * 初始化文件目录
+   * @param filePath
+   * @returns
+   */
+  initFilePath = async filePath => {
+    const isDir = await this.checkIfDirIsExist(filePath);
+    if (!isDir) {
+      const result = this.createFilePath(filePath);
+      return result;
+    }
+    return isDir;
+  };
+
+  /**
+   * 根据文件名返回对应的fileType
+   * @param filename
+   */
+  getFileType = filename => {
+    if (filename.indexOf('map') !== -1) {
+      return 0;
+    }
+    if (filename.indexOf('cleanPath') !== -1) {
+      return 1;
+    }
+    if (filename.indexOf('navPath') !== -1) {
+      return 3;
+    }
+    return 2;
+  };
+
+  /**
+   * 设备连接状态发生改变
+   * @param data
+   */
+  sessionStatusCallback = data => {
+    Logger.info('sessionStatusCallback ==>', data);
+    if (data) {
+      const {
+        status
+      } = data;
+      if (status < 0) {
+        Logger.info('receive disconnect notice ==>', status);
+        this.reconnectP2p(() => {
+          // 重连之后重新开启文件下载, 这里的成功不需要注册断开事件
+          this.startObserverSweeperDataByP2P(this.downloadType, this.devId, this.onReceiveMapData, this.onReceivePathData);
+        });
+      }
+    }
+  };
+
+  /**
+   * 开始进行文件下载
+   * @param downloadType
+   * 0: 下载断开 1: 持续下载
+   */
+  startObserverSweeperDataByP2P = async (downloadType, devId, onReceiveMapData, onReceivePathData) => {
+    var _this$file$items;
+    if (![0, 1].some(item => item === downloadType)) {
+      Logger.warn('download type must be 0 or 1');
+      return;
+    }
+    this.onReceiveMapData = onReceiveMapData;
+    this.onReceivePathData = onReceivePathData;
+    Logger.info('startObserverSweeperDataByP2P ==>');
+    this.downloadType = downloadType;
+    this.setDataFilePath(devId);
+    this.setStreamFilePath(devId);
+    // 先移除监听,再重新注册
+    this.removeP2pDownloadEvent();
+    this.registerP2pDownloadEvent();
+    if (!this.file) {
+      //@ts-ignore
+      this.file = await this.queryAlbumFileIndexs(this.albumName);
+    }
+    if (this.file && ((_this$file$items = this.file.items) === null || _this$file$items === void 0 ? void 0 : _this$file$items.length) > 0) {
+      if (this.downloadType === 0) {
+        const exitFiles = this.queryNeedFiles(this.file.items);
+        if (exitFiles.length > 0) {
+          if (shouldDownloadStream) {
+            // 开启p2p流传输
+            this.downloadStream({
+              files: exitFiles
+            }, this.albumName);
+          } else if (await this.initFilePath(this.dataFilePath)) {
+            this.downloadFile({
+              files: exitFiles
+            }, this.albumName, this.dataFilePath);
+          }
+        }
+      } else if (this.downloadType === 1) {
+        const exitFiles = this.queryNeedFiles(this.file.items);
+        if (exitFiles.length > 0) {
+          if (shouldDownloadStream) {
+            // 开启p2p流传输
+            this.downloadStream({
+              files: exitFiles
+            }, this.albumName);
+          } else if (await this.initFilePath(this.streamFilePath)) {
+            // 每次要下载前都需要先检查文件目录是否存在 防止中间过程被删除掉文件目录
+            this.downloadFile({
+              files: exitFiles
+            }, this.albumName, this.streamFilePath);
+          }
+        }
+      }
+    }
+  };
+
+  /**
+   * 注册下载有关的监听
+   */
+  registerP2pDownloadEvent = () => {
+    if (shouldDownloadStream) {
+      // p2p数据流监听
+      this.offP2pStreamPacketReceive = this.onP2pStreamPacketReceive(this.p2pStreamPacketReceiveCallback);
+    } else {
+      // 注册下载完成的监听
+      this.offFileDownloadComplete = this.onFileDownloadComplete(this.fileDownloadCompleteCallback);
+    }
+
+    // this.offDownLoadProgressUpdate = this.onDownloadProgressUpdate(
+    //   this.fileDownloadProgressCallback
+    // );
+    // this.offTotalDownLoadProgressUpdate = this.onDownloadTotalProgressUpdate(
+    //   this.fileTotalDownloadProgressCallback
+    // );
+  };
+
+  /**
+   * 移除下载有关的监听
+   */
+  removeP2pDownloadEvent = () => {
+    this.offFileDownloadComplete && this.offFileDownloadComplete();
+    this.offP2pStreamPacketReceive && this.offP2pStreamPacketReceive();
+    if (shouldDownloadStream) {
+      [...this.packetSerialNumberCacheMap.keys()].forEach(key => {
+        this.packetSerialNumberCacheMap.set(key, -1);
+      });
+      [...this.packetTotalMap.keys()].forEach(key => {
+        this.packetTotalMap.set(key, -1);
+      });
+      [...this.packetDataCacheMap.keys()].forEach(key => {
+        this.packetDataCacheMap.set(key, new Map());
+      });
+    } else {
+      this.cacheData = {};
+    }
+
+    // this.offDownLoadProgressUpdate && this.offDownLoadProgressUpdate();
+    // this.offTotalDownLoadProgressUpdate && this.offTotalDownLoadProgressUpdate();
+  };
+
+  /**
+   * 单文件下载完成回调
+   * @param downloadComplete
+   */
+  fileDownloadCompleteCallback = data => {
+    if (data) {
+      const {
+        fileName,
+        index
+      } = data;
+      if (fileName) {
+        this.fileIndex = index;
+        const path = this.downloadType === 0 ? this.getDataFilePath(fileName) : this.getStreamFilePath(fileName);
+        this.readFileFromPath(fileName, path);
+      }
+    }
+  };
+
+  /**
+   * p2p数据流回调
+   * @param downloadComplete
+   */
+  p2pStreamPacketReceiveCallback = data => {
+    const {
+      fileName,
+      packetData,
+      fileSerialNumber,
+      packetIndex,
+      packetType
+    } = data;
+    const cachePacketMap = this.packetDataCacheMap.get(fileName);
+    const cacheSerialNumber = this.packetSerialNumberCacheMap.get(fileName);
+
+    // 说明收到了过时包的数据
+    if (fileSerialNumber < cacheSerialNumber) return;
+
+    // 说明收到了新的整包数据
+    if (fileSerialNumber > cacheSerialNumber) {
+      this.packetSerialNumberCacheMap.set(fileName, fileSerialNumber);
+      this.packetTotalMap.set(fileName, -1);
+      cachePacketMap.clear();
+    }
+    if (packetType === 2 || packetType === 3) {
+      // 收到了末尾包, packetIndex + 1代表这组包的总数
+      this.packetTotalMap.set(fileName, packetIndex + 1);
+    }
+    const packetTotal = this.packetTotalMap.get(fileName);
+    cachePacketMap.set(packetIndex, packetData);
+    if (packetTotal > -1) {
+      // 说明收到过末尾包了，只需要验证总包数是否吻合
+      const packetDatas = [...cachePacketMap.entries()];
+      if (packetDatas.length === packetTotal) {
+        packetDatas.sort((a, b) => a[0] - b[0]);
+
+        // 排序 - 组装 - 发出
+        const hexValue = packetDatas.map(_ref => {
+          let [index, data] = _ref;
+          return data;
+        }).join('');
+        const {
+          type
+        } = FILE_NAME_MAP[fileName];
+        if (this.cacheData[type] !== hexValue) {
+          if (type === 0) {
+            this.onReceiveMapData(hexValue);
+          }
+          if (type === 1) {
+            this.onReceivePathData(hexValue);
+          }
+          this.cacheData[type] = hexValue;
+        }
+      }
+    }
+  };
+
+  /**
+   * 单文件下载完成回调
+   * @param data
+   */
+  fileDownloadProgressCallback = () => {
+    // console.log('fileDownloadProgressCallback', data);
+  };
+
+  /**
+   * 多文件下载进度监听
+   * @param data
+   */
+  fileTotalDownloadProgressCallback = () => {
+    // console.log('fileTotalDownloadProgressCallback', data );
+  };
+
+  /**
+   * 从指定的文件路径获取文件
+   * @param fileName
+   * @param filePath
+   */
+  readFileFromPath = (fileName, filePath) => {
+    if (!this.setReading(fileName)) return;
+    try {
+      ty.getFileSystemManager().readFile({
+        filePath,
+        encoding: 'base64',
+        position: 0,
+        success: params => {
+          this.resetReading(fileName);
+          const bytes = Base64.toByteArray(params.data);
+          const hexValue = _(bytes).map(d => padStart(d.toString(16), 2, '0')).value().join('');
+          const type = this.getFileType(fileName);
+          if (this.cacheData[type] !== hexValue) {
+            if (hexValue.length === 0) {
+              Logger.warn('receive empty data');
+              return;
+            }
+            if (type === 0) {
+              this.onReceiveMapData(hexValue);
+            }
+            if (type === 1) {
+              this.onReceivePathData(hexValue);
+            }
+            this.cacheData[type] = hexValue;
+          }
+        },
+        fail: e => {
+          Logger.warn('readFileFromPath failed ==>', e);
+          this.resetReading(fileName);
+        }
+      });
+    } catch (e) {
+      this.resetReading(fileName);
+      Logger.error('readFileFromPath ==>', e);
+    }
+  };
+  setReading = fileName => {
+    if (fileName.indexOf('map') !== -1) {
+      if (this.readingMap === true) return false;
+      this.readingMap = true;
+      return true;
+    }
+    if (fileName.indexOf('cleanPath') !== -1) {
+      if (this.readingClean === true) return false;
+      this.readingClean = true;
+      return true;
+    }
+    if (fileName.indexOf('navPath') !== -1) {
+      if (this.readingNav === true) return false;
+      this.readingNav = true;
+      return true;
+    }
+    return true;
+  };
+  resetReading = fileName => {
+    if (fileName.indexOf('map') !== -1) {
+      this.readingMap = false;
+    } else if (fileName.indexOf('cleanPath') !== -1) {
+      this.readingClean = false;
+    } else if (fileName.indexOf('navPath') !== -1) {
+      this.readingNav = false;
+    }
+  };
+
+  /**
+   * 查询返回的文件中是否包含了所需文件
+   * @param fileList
+   */
+  queryNeedFiles = fileList => {
+    const exitFiles = [];
+    const streamPattern = /bin.stream$/;
+    const dataPattern = /bin$/;
+    fileList && fileList.forEach(item => {
+      if (this.downloadType === 0) {
+        if (dataPattern.test(item.filename)) {
+          exitFiles.push(item.filename);
+        }
+      } else if (this.downloadType === 1) {
+        if (streamPattern.test(item.filename)) {
+          exitFiles.push(item.filename);
+        }
+      }
+    });
+    return exitFiles;
+  };
+
+  /**
+   * 停止文件下载
+   */
+  stopObserverSweeperDataByP2P = async () => {
+    try {
+      this.removeP2pDownloadEvent();
+      const isCancel = await this.cancelDownloadTask();
+      Logger.info('cancelDownloadTask ==>', isCancel);
+      return isCancel;
+    } catch (e) {
+      Logger.error('stopObserverSweeperDataByP2P occur error ==>', e);
+      return false;
+    }
+  };
+}
+const sweeperP2pInstance = new SweeperP2p();
+export default sweeperP2pInstance;

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+declare const useP2PDataStream: (devId: string, onReceiveMapData: (data: string) => void, onReceivePathData: (data: string) => void) => void;
+declare const StreamDataNotificationCenter: import("mitt").Emitter<Record<import("mitt").EventType, unknown>>;
+export { useP2PDataStream, StreamDataNotificationCenter };

package/lib/index.js

@@ -0,0 +1,93 @@
+import { useEffect, useRef } from 'react';
+import mitt from 'mitt';
+import { SweeperP2pInstance } from '@/api';
+import { Logger } from './utils';
+const useP2PDataStream = (devId, onReceiveMapData, onReceivePathData) => {
+  const isInit = useRef(null);
+  const offSessionStatusChange = useRef(null);
+  const isAppOnBackground = useRef(false);
+  const timer = useRef(null);
+  useEffect(() => {
+    if (devId.startsWith('vdevo')) {
+      Logger.warn('virtual device cannot use p2p');
+      return;
+    }
+    isInitP2p();
+    onEnterBackground();
+    onEnterForeground();
+    return () => {
+      unmount();
+      timer && clearInterval(timer);
+    };
+  }, []);
+
+  /**
+   * p2p连接
+   */
+  const isInitP2p = async () => {
+    Logger.info('hooks has been started initP2p');
+    isInit.current = await SweeperP2pInstance.initP2pSdk(devId);
+    if (isInit.current) {
+      SweeperP2pInstance.connectDevice(() => {
+        SweeperP2pInstance.startObserverSweeperDataByP2P(1, devId, onReceiveMapData, onReceivePathData);
+        offSessionStatusChange.current = SweeperP2pInstance.onSessionStatusChange(SweeperP2pInstance.sessionStatusCallback);
+      }, () => {
+        SweeperP2pInstance.reconnectP2p(() => {
+          SweeperP2pInstance.startObserverSweeperDataByP2P(1, devId, onReceiveMapData, onReceivePathData);
+          // 这里失败重连需要注册断开重连的事件
+          offSessionStatusChange.current = SweeperP2pInstance.onSessionStatusChange(SweeperP2pInstance.sessionStatusCallback);
+        });
+      });
+    }
+  };
+
+  /**
+   * 进入后台时断开P2P连接
+   */
+  const onEnterBackground = () => {
+    ty.onAppHide(() => {
+      Logger.info('hooks onAppHide');
+      isAppOnBackground.current = true;
+      if (isInit.current) {
+        // 判断进入后台之后，维持定时器，如果进入后台超过2分钟, 则断开P2P
+        timer.current = setTimeout(() => {
+          Logger.info('background timer has been exe');
+          if (isAppOnBackground.current) {
+            unmount();
+          }
+          clearTimeout(timer.current);
+          timer.current = null;
+        }, 2 * 60 * 1000);
+      }
+    });
+  };
+
+  /**
+   * p2p断开
+   */
+  const unmount = async () => {
+    Logger.info('hooks has been started unmount');
+    isInit.current = false;
+    if (offSessionStatusChange.current) {
+      offSessionStatusChange.current();
+      offSessionStatusChange.current = null;
+    }
+    await SweeperP2pInstance.stopObserverSweeperDataByP2P();
+    await SweeperP2pInstance.deInitP2PSDK();
+  };
+
+  /**
+   * 进入前台时开启P2P连接
+   */
+  const onEnterForeground = () => {
+    ty.onAppShow(() => {
+      Logger.info('hooks onAppShow');
+      isAppOnBackground.current = false;
+      if (!isInit.current) {
+        isInitP2p();
+      }
+    });
+  };
+};
+const StreamDataNotificationCenter = mitt();
+export { useP2PDataStream, StreamDataNotificationCenter };

package/lib/utils/index.d.ts

@@ -0,0 +1,2 @@
+import Logger from './logger';
+export { Logger };

package/lib/utils/index.js

@@ -0,0 +1,2 @@
+import Logger from './logger';
+export { Logger };

package/lib/utils/logger.d.ts

@@ -0,0 +1,15 @@
+declare class Logger {
+    options: {
+        performance: string;
+        error: string;
+        info: string;
+        warn: string;
+    };
+    log(color: string, title: string, ...args: any): void;
+    performance(title: string, ...args: any): void;
+    warn(title: string, ...args: any): void;
+    error(title: string, ...args: any): void;
+    info(title: string, ...args: any): void;
+}
+declare const logger: Logger;
+export default logger;

package/lib/utils/logger.js

@@ -0,0 +1,44 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+class Logger {
+  options = {
+    performance: '#00cca3',
+    error: '#f81c1c',
+    info: '#5091f3',
+    warn: '#ffaa00'
+  };
+  log(color, title) {
+    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      args[_key - 2] = arguments[_key];
+    }
+    console.log(`%c 【Robot Data Stream Log】: ${title}`, `background: ${color}; color: #FFFFFF; font-size: 20px`, ...args);
+  }
+  performance(title) {
+    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
+    }
+    this.log(this.options.performance, title, ...args);
+  }
+  warn(title) {
+    for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      args[_key3 - 1] = arguments[_key3];
+    }
+    this.log(this.options.warn, title, ...args);
+  }
+  error(title) {
+    if (title === 'system error') {
+      debugger;
+    }
+    for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+      args[_key4 - 1] = arguments[_key4];
+    }
+    this.log(this.options.error, title, ...args);
+  }
+  info(title) {
+    for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+      args[_key5 - 1] = arguments[_key5];
+    }
+    this.log(this.options.info, title, ...args);
+  }
+}
+const logger = new Logger();
+export default logger;

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@ray-js/robot-data-stream",
+  "version": "0.0.1-beta-1",
+  "description": "扫地机P2P数据流标准化组件",
+  "main": "lib/index",
+  "files": [
+    "lib"
+  ],
+  "license": "MIT",
+  "types": "lib/index.d.ts",
+  "maintainers": [
+    "tuya_npm",
+    {
+      "name": "tuyafe",
+      "email": "tuyafe@tuya.com"
+    }
+  ],
+  "scripts": {
+    "lint": "eslint src --ext .js,.jsx,.ts,.tsx --fix",
+    "build": "patch-package && ray build --type=component",
+    "watch": "ray start --type=component --output ./example/src/lib",
+    "build:tuya": "ray build ./example",
+    "build:wechat": "ray build ./example --target=wechat",
+    "build:web": "ray build ./example --target=web",
+    "build:native": "ray build ./example --target=native",
+    "start:native": "ray start ./example -t native --verbose",
+    "start:tuya": "ray start ./example",
+    "start:wechat": "ray start ./example -t wechat --verbose",
+    "start:web": "ray start ./example -t web",
+    "prepublishOnly": "yarn build",
+    "release-it": "standard-version"
+  },
+  "peerDependencies": {
+    "@ray-js/ray": "^1.5.0"
+  },
+  "dependencies": {
+    "clsx": "^1.2.1",
+    "lodash-es": "^4.17.21",
+    "moment": "^2.30.1",
+    "mitt": "^3.0.1"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^7.2.1",
+    "@commitlint/config-conventional": "^9.0.1",
+    "@ray-js/cli": "^1.5.20",
+    "@ray-js/ray": "^1.5.0",
+    "core-js": "^3.19.1",
+    "eslint-config-tuya-panel": "^0.4.2",
+    "husky": "^1.2.0",
+    "lint-staged": "^10.2.11",
+    "patch-package": "^8.0.0",
+    "standard-version": "9.3.2"
+  },
+  "resolutions": {
+    "@ray-js/builder-mp": "1.4.15"
+  },
+  "husky": {
+    "hooks": {
+      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS --config commitlint.config.js",
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.{ts,tsx,js,jsx}": [
+      "eslint --fix",
+      "git add"
+    ],
+    "*.{json,md,yml,yaml}": [
+      "prettier --write",
+      "git add"
+    ]
+  }
+}