@ray-js/robot-data-stream 0.0.13-beta-7 → 0.0.13-beta-9

package/lib/api/p2pApi.js

@@ -1,9 +1,10 @@
+/* eslint-disable consistent-return */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable prefer-promise-reject-errors */
 import { p2p } from '@ray-js/ray';
 import dayjs from 'dayjs';
+import { logger } from '../utils';
 import { trace } from '../trace';
-import { apis } from '../ttt';
-import { createLogger } from '../utils';
-
 /**
  * P2P 工具类
  */
@@ -15,14 +16,6 @@ export default class P2pApi {
     this.isConnecting = false;
   }
 
-  /**
-   * 便捷的日志记录方法
-   * 使用 getter 确保每次访问时都使用最新的 onLogger
-   */
-  get log() {
-    return createLogger(this.onLogger);
-  }
-
   /**
    * 设备断开之后的重连
    */
@@ -34,23 +27,23 @@ export default class P2pApi {
      */
     // this.isConnected = false;
     if (this.isConnected) {
-      return this.log.info({
+      return logger('info', {
         msg: 'p2p isConnected or isConnecting'
-      });
+      }, this.onLogger);
     }
     if (this.isConnecting) {
-      return this.log.info({
+      return logger('info', {
         msg: 'p2p isConnecting'
-      });
+      }, this.onLogger);
     }
     // if (!this.isConnected) {
-    this.log.info({
+    logger('info', {
       msg: `${source} start p2p reconnect ==>  ${dayjs().format('YYYY-MM-DD HH:mm:ss')}`
-    });
+    }, this.onLogger);
     this.connectDevice(() => {
-      this.log.info({
+      logger('info', {
         msg: `${source} p2p reconnect success ==> ${dayjs().format('YYYY-MM-DD HH:mm:ss')}`
-      });
+      }, this.onLogger);
       this.isConnected = true;
       if (this.isConnected) {
         typeof successCb === 'function' && successCb();
@@ -58,13 +51,13 @@ export default class P2pApi {
     }, () => {
       //
     }, () => {
-      this.log.info({
+      logger('info', {
         msg: `${source} reconnect complete ==> ${String(this.isConnected)}`
-      });
+      }, this.onLogger);
       if (!this.isConnected) {
-        this.log.warn({
+        logger('warn', {
           msg: `${source} p2p reconnect failed ==> ${dayjs().format('YYYY-MM-DD HH:mm:ss')}`
-        });
+        }, this.onLogger);
         setTimeout(() => {
           this.reconnectP2p(successCb, '0000');
         }, 6000);
@@ -79,82 +72,111 @@ export default class P2pApi {
    * @returns
    */
   initP2pSdk = async devId => {
-    try {
-      this.devId = devId;
-      const result = await apis.initP2pSdk(this.onLogger);
-      return result;
-    } catch (e) {
-      this.log.error({
-        msg: 'P2PSDKInit occur an error',
-        e
-      });
-      return {
-        success: false,
-        error: e
-      };
-    }
+    return new Promise((resolve, reject) => {
+      try {
+        this.devId = devId;
+        p2p.P2PSDKInit({
+          success: () => {
+            logger('info', {
+              msg: 'P2PSDKInit success'
+            }, this.onLogger);
+            resolve(true);
+          },
+          fail: params => {
+            logger('warn', {
+              msg: 'P2PSDKInit success',
+              params
+            }, this.onLogger);
+            resolve(false);
+          }
+        });
+      } catch (e) {
+        reject(false);
+      }
+    });
   };
 
   /**
    * 连接设备
    * @returns
    */
-  connectDevice = async (successCb, failCb, completeCb) => {
-    try {
-      this.isConnecting = true;
-      this.isConnected = false;
-      const result = await apis.connectDevice(this.devId, this.onLogger);
-      if (result.success) {
-        this.isConnected = true;
-        this.isConnecting = false;
-        typeof successCb === 'function' && successCb();
-        typeof completeCb === 'function' && completeCb();
-        return true;
-      } else {
-        result.params || result.error;
+  connectDevice = (successCb, failCb, completeCb) => {
+    return new Promise((resolve, reject) => {
+      try {
+        this.isConnecting = true;
+        this.isConnected = false;
+        p2p.connectDevice({
+          deviceId: this.devId,
+          timeout: 5000,
+          mode: 0,
+          success: () => {
+            logger('info', {
+              msg: 'p2p connectDevice success'
+            }, this.onLogger);
+            this.isConnected = true;
+            this.isConnecting = false;
+            typeof successCb === 'function' && successCb();
+            resolve(true);
+          },
+          fail: params => {
+            logger('warn', {
+              msg: `p2p connectDevice failed ==> ${JSON.stringify(params.innerError)}`
+            }, this.onLogger);
+            this.isConnecting = false;
+            typeof failCb === 'function' && failCb();
+            resolve(false);
+          },
+          complete: () => {
+            this.isConnecting = false;
+            typeof completeCb === 'function' && completeCb();
+          }
+        });
+      } catch (e) {
         this.isConnecting = false;
-        typeof failCb === 'function' && failCb();
-        typeof completeCb === 'function' && completeCb();
-        return false;
+        this.isConnected = false;
+        logger('error', {
+          msg: 'p2p connectDevice occur an error ==>',
+          e
+        }, this.onLogger);
+        reject(false);
       }
-    } catch (e) {
-      this.isConnecting = false;
-      this.isConnected = false;
-      this.log.error({
-        msg: 'p2p connectDevice occur an error ==>',
-        e
-      });
-      typeof failCb === 'function' && failCb();
-      typeof completeCb === 'function' && completeCb();
-      return false;
-    }
+    });
   };
 
   /**
    * 断开P2P设备连接
    * @returns
    */
-  disconnectDevice = async () => {
-    try {
-      const result = await apis.disconnectDevice(this.devId, this.onLogger);
-      if (result.success) {
-        this.isConnected = false;
-        this.isConnecting = false;
-      } else {
-        this.isConnecting = false;
+  disconnectDevice = () => {
+    return new Promise((resolve, reject) => {
+      try {
+        p2p.disconnectDevice({
+          deviceId: this.devId,
+          success: () => {
+            this.isConnected = false;
+            logger('info', {
+              msg: 'p2p disconnectDevice success'
+            }, this.onLogger);
+            resolve(true);
+          },
+          fail: () => {
+            logger('warn', {
+              msg: 'p2p disconnectDevice failed'
+            }, this.onLogger);
+            resolve(false);
+          },
+          complete: () => {
+            this.isConnecting = false;
+          }
+        });
+      } catch (e) {
+        logger('warn', {
+          msg: 'p2p disconnectDevice occur an error ==>',
+          e
+        }, this.onLogger);
+        reject(false);
       }
-      return result;
-    } catch (e) {
-      this.isConnecting = false;
-      this.log.warn({
-        msg: 'p2p disconnectDevice occur an error ==>',
-        e
-      });
-      return {
-        success: false,
-        error: e
-      };
-    }
+    });
   };
 
   /**
@@ -166,33 +188,50 @@ export default class P2pApi {
    * @param failedCb
    * @returns
    */
-  downloadStream = async (files, albumName, successCb, failedCb) => {
+  downloadStream = (files, albumName, successCb, failedCb) => {
     try {
       if (this.isConnected) {
-        const result = await apis.downloadStream(this.devId, albumName, files.files, this.onLogger);
-        if (result.success) {
-          trace.pointFn({
-            devId: this.devId,
-            eventName: 'downloadStream'
+        return new Promise(resolve => {
+          p2p.downloadStream({
+            deviceId: this.devId,
+            albumName: albumName,
+            jsonfiles: JSON.stringify(files),
+            success: () => {
+              logger('info', {
+                msg: 'p2p downloadStream success'
+              }, this.onLogger);
+              trace.pointFn({
+                devId: this.devId,
+                eventName: 'downloadStream'
+              });
+              typeof successCb === 'function' && successCb();
+              resolve(true);
+            },
+            fail: params => {
+              logger('warn', {
+                msg: 'p2p downloadStream failed===>',
+                params
+              }, this.onLogger);
+              trace.pointFn({
+                devId: this.devId,
+                eventName: 'downloadStreamFailed'
+              });
+              setTimeout(() => {
+                typeof failedCb === 'function' && failedCb();
+              }, 500);
+              resolve(false);
+            },
+            complete: () => {
+              //
+            }
           });
-          typeof successCb === 'function' && successCb();
-        } else {
-          trace.pointFn({
-            devId: this.devId,
-            eventName: 'downloadStreamFailed'
-          });
-          setTimeout(() => {
-            typeof failedCb === 'function' && failedCb();
-          }, 500);
-        }
-        return result.success;
+        });
       }
     } catch (e) {
-      this.log.warn({
+      logger('warn', {
         msg: 'p2p downloadStream occur an error ==>',
         e
-      });
-      return false;
+      }, this.onLogger);
     }
   };
 
@@ -204,27 +243,42 @@ export default class P2pApi {
    * @param failedCb
    * @returns
    */
-  appendDownloadStream = async (files, albumName, successCb, failedCb) => {
+  appendDownloadStream = (files, albumName, successCb, failedCb) => {
     try {
       if (this.isConnected) {
-        const {
-          success
-        } = await apis.appendDownloadStream(this.devId, albumName, files.files, this.onLogger);
-        if (success) {
-          typeof successCb === 'function' && successCb();
-        } else {
-          setTimeout(() => {
-            typeof failedCb === 'function' && failedCb();
-          }, 500);
-        }
-        return success;
+        return new Promise(resolve => {
+          p2p.appendDownloadStream({
+            deviceId: this.devId,
+            albumName: albumName,
+            jsonfiles: JSON.stringify(files),
+            success: () => {
+              logger('info', {
+                msg: 'p2p appendDownloadStream success'
+              }, this.onLogger);
+              typeof successCb === 'function' && successCb();
+              resolve(true);
+            },
+            fail: params => {
+              logger('warn', {
+                msg: 'p2p appendDownloadStream failed===>',
+                params
+              }, this.onLogger);
+              setTimeout(() => {
+                typeof failedCb === 'function' && failedCb();
+              }, 500);
+              resolve(false);
+            },
+            complete: () => {
+              //
+            }
+          });
+        });
       }
     } catch (e) {
-      this.log.warn({
+      logger('warn', {
         msg: 'p2p appendDownloadStream failed===>',
         e
-      });
-      return false;
+      }, this.onLogger);
     }
   };
 
@@ -245,25 +299,43 @@ export default class P2pApi {
    * 开始下载文件
    * files : {"files":["filesname1", "filesname2", "filesname3" ]}
    */
-  downloadFile = async (files, albumName, filePath, successCb, failedCb) => {
+  downloadFile = (files, albumName, filePath, successCb, failedCb) => {
     try {
       if (this.isConnected) {
-        const result = await apis.downloadFile(this.devId, albumName, filePath, files.files, this.onLogger);
-        if (result.success) {
-          typeof successCb === 'function' && successCb();
-          return true;
-        } else {
-          setTimeout(() => {
-            typeof failedCb === 'function' && failedCb();
-          }, 500);
-          return false;
-        }
+        return new Promise(resolve => {
+          p2p.downloadFile({
+            deviceId: this.devId,
+            albumName: albumName,
+            filePath: filePath,
+            jsonfiles: JSON.stringify(files),
+            success: () => {
+              logger('info', {
+                msg: 'p2p downloadFile success'
+              }, this.onLogger);
+              typeof successCb === 'function' && successCb();
+              resolve(true);
+            },
+            fail: params => {
+              logger('warn', {
+                msg: 'p2p downloadFile success',
+                params
+              }, this.onLogger);
+              setTimeout(() => {
+                typeof failedCb === 'function' && failedCb();
+              }, 500);
+              resolve(false);
+            },
+            complete: () => {
+              //
+            }
+          });
+        });
       }
     } catch (e) {
-      this.log.error({
+      logger('error', {
         msg: 'p2p downloadFile occur an error ==>',
         e
-      });
+      }, this.onLogger);
     }
     return null;
   };
@@ -324,20 +396,26 @@ export default class P2pApi {
    * 取消进行下载
    * @returns
    */
-  cancelDownloadTask = async () => {
-    try {
-      const result = await apis.cancelDownloadTask(this.devId, this.onLogger);
-      return result;
-    } catch (e) {
-      this.log.error({
-        msg: 'cancelDownloadTask occur an error',
-        e
-      });
-      return {
-        success: false,
-        error: e
-      };
-    }
+  cancelDownloadTask = () => {
+    return new Promise((resolve, reject) => {
+      try {
+        p2p.cancelDownloadTask({
+          deviceId: this.devId,
+          success: () => {
+            resolve(true);
+          },
+          fail: () => {
+            reject(false);
+          }
+        });
+      } catch (e) {
+        logger('info', {
+          msg: 'cancelDownloadTask occur an error',
+          e
+        }, this.onLogger);
+        reject(false);
+      }
+    });
   };
 
   /**
@@ -345,17 +423,27 @@ export default class P2pApi {
    * @param albumName
    * @returns
    */
-  queryAlbumFileIndexs = async albumName => {
-    try {
-      const result = await apis.queryAlbumFileIndexs(this.devId, albumName, this.onLogger);
-      return result;
-    } catch (e) {
-      this.log.error({
-        msg: 'queryAlbumFileIndexs occur an error',
-        e
+  queryAlbumFileIndexs = albumName => {
+    return new Promise(resolve => {
+      p2p.queryAlbumFileIndexs({
+        deviceId: this.devId,
+        albumName,
+        success: params => {
+          logger('info', {
+            msg: 'queryAlbumFileIndexs ==>',
+            params
+          }, this.onLogger);
+          resolve(params);
+        },
+        fail: params => {
+          logger('warn', {
+            msg: 'queryAlbumFileIndexs failed ==>',
+            params
+          }, this.onLogger);
+          resolve(null);
+        }
       });
-      return null;
-    }
+    });
   };
 
   /**
@@ -363,18 +451,32 @@ export default class P2pApi {
    * @returns
    */
   deInitP2PSDK = async () => {
-    try {
-      const result = await apis.deInitP2pSdk(this.onLogger);
-      return result;
-    } catch (e) {
-      this.log.error({
-        msg: 'deInitP2pSDK occur an error ==>',
-        e
-      });
-      return {
-        success: false,
-        error: e
-      };
-    }
+    return new Promise((resolve, reject) => {
+      try {
+        p2p.deInitSDK({
+          success: () => {
+            logger('info', {
+              msg: 'deInitP2pSDK success'
+            }, this.onLogger);
+            resolve(true);
+          },
+          fail: () => {
+            logger('info', {
+              msg: 'deInitP2pSDK failed'
+            }, this.onLogger);
+            resolve(false);
+          },
+          complete: () => {
+            resolve(true);
+          }
+        });
+      } catch (e) {
+        logger('error', {
+          msg: 'deInitP2pSDK occur an error ==>',
+          e
+        }, this.onLogger);
+        reject(false);
+      }
+    });
   };
 }

package/lib/api/sweeperP2p.d.ts

@@ -1,4 +1,3 @@
-import { FileNameEnum } from '../constant';
 import P2pApi from './p2pApi';
 /**
  * 基于P2p工具类的扫地机扩展实现
@@ -12,6 +11,44 @@ interface FileInfo {
     idx: number;
     type: number;
 }
+declare const FILE_NAME_MAP: {
+    readonly 'map.bin': {
+        readonly type: 0;
+    };
+    readonly 'map_structured.bin': {
+        readonly type: 6;
+    };
+    readonly 'cleanPath.bin': {
+        readonly type: 1;
+    };
+    readonly 'map.bin.stream': {
+        readonly type: 0;
+    };
+    readonly 'map_structured.bin.stream': {
+        readonly type: 6;
+    };
+    readonly 'cleanPath.bin.stream': {
+        readonly type: 1;
+    };
+    readonly 'ai.bin': {
+        readonly type: 4;
+    };
+    readonly 'ai.bin.stream': {
+        readonly type: 4;
+    };
+    readonly 'aiHD_XXXX_YYYY.bin': {
+        readonly type: 5;
+    };
+    readonly 'aiHD_XXXX_YYYY.bin.stream': {
+        readonly type: 5;
+    };
+    readonly 'wifi_map.bin': {
+        readonly type: 7;
+    };
+    readonly 'wifi_map.bin.stream': {
+        readonly type: 7;
+    };
+};
 export declare class SweeperP2p extends P2pApi {
     file: {
         items: Array<FileInfo>;
@@ -29,10 +66,10 @@ export declare class SweeperP2p extends P2pApi {
     fileIndex: number;
     cacheData: any;
     exitFiles: Array<string>;
-    packetDataCacheMap: Map<FileNameEnum, Map<number, string>>;
-    packetSerialNumberCacheMap: Map<FileNameEnum, number>;
-    fileLengthCacheMap: Map<FileNameEnum, number>;
-    packetTotalMap: Map<FileNameEnum, number>;
+    packetDataCacheMap: Map<keyof typeof FILE_NAME_MAP, Map<number, string>>;
+    packetSerialNumberCacheMap: Map<keyof typeof FILE_NAME_MAP, number>;
+    fileLengthCacheMap: Map<keyof typeof FILE_NAME_MAP, number>;
+    packetTotalMap: Map<keyof typeof FILE_NAME_MAP, number>;
     firstPackageTime: number;
     onReceiveMapData: (data: string) => void;
     onReceivePathData: (data: string) => void;
@@ -44,6 +81,7 @@ export declare class SweeperP2p extends P2pApi {
     offDownLoadProgressUpdate: () => void;
     offTotalDownLoadProgressUpdate: () => void;
     onDefineStructuredMode: (isStructured: boolean) => void;
+    enableCustomLog: boolean;
     constructor();
     private setStreamFilePath;
     private setDataFilePath;
@@ -59,6 +97,18 @@ export declare class SweeperP2p extends P2pApi {
      * @returns
      */
     private getDataFilePath;
+    /**
+     * 创建文件路径文件夹
+     * @param filePath
+     * @returns
+     */
+    private createFilePath;
+    /**
+     * 检查当前文件目录是否存在
+     * @param filePath
+     * @returns
+     */
+    private checkIfDirIsExist;
     /**
      * 初始化文件目录
      * @param filePath
@@ -70,10 +120,6 @@ export declare class SweeperP2p extends P2pApi {
      * @param filename
      */
     private getFileType;
-    /**
-     * 根据文件类型处理数据并调用相应的回调函数
-     */
-    private handleDataByType;
     /**
      * 设备连接状态发生改变
      * @param data
@@ -82,14 +128,6 @@ export declare class SweeperP2p extends P2pApi {
         deviceId: string;
         status: number;
     }) => void;
-    /**
-     * 创建下载失败时的重连回调函数
-     */
-    private createReconnectCallback;
-    /**
-     * 执行文件下载逻辑
-     */
-    private executeDownload;
     /**
      * 开始进行文件下载
      * @param downloadType
@@ -129,10 +167,6 @@ export declare class SweeperP2p extends P2pApi {
      * @param filePath
      */
     private readFileFromPath;
-    /**
-     * 根据文件名获取对应的 reading 状态标志
-     */
-    private getReadingFlag;
     private setReading;
     private resetReading;
     /**