react-native-update 10.37.4 → 10.37.6

package/harmony/pushy/src/main/ets/DownloadTask.ts

@@ -18,7 +18,6 @@ interface ZipFile {
 export class DownloadTask {
   private context: common.Context;
   private hash: string;
-  private readonly DOWNLOAD_CHUNK_SIZE = 4096;
   private eventHub: EventHub;
 
   constructor(context: common.Context) {
@@ -53,27 +52,104 @@ export class DownloadTask {
   private async downloadFile(params: DownloadTaskParams): Promise<void> {
     const httpRequest = http.createHttp();
     this.hash = params.hash;
+    let writer: fileIo.File | null = null;
+    let contentLength = 0;
+    let received = 0;
+    let writeError: Error | null = null;
+    let writeQueue = Promise.resolve();
+
+    const closeWriter = async () => {
+      if (writer) {
+        await fileIo.close(writer);
+        writer = null;
+      }
+    };
+
+    const dataEndPromise = new Promise<void>((resolve, reject) => {
+      httpRequest.on('dataEnd', () => {
+        writeQueue
+          .then(async () => {
+            if (writeError) {
+              throw writeError;
+            }
+            await closeWriter();
+            resolve();
+          })
+          .catch(async error => {
+            await closeWriter();
+            reject(error);
+          });
+      });
+    });
 
     try {
-      try {
-        let exists = fileIo.accessSync(params.targetFile);
-        if (exists) {
-          await fileIo.unlink(params.targetFile);
-        } else {
-          const targetDir = params.targetFile.substring(
-            0,
-            params.targetFile.lastIndexOf('/'),
-          );
-          exists = fileIo.accessSync(targetDir);
-          if (!exists) {
-            await fileIo.mkdir(targetDir);
-          }
+      let exists = fileIo.accessSync(params.targetFile);
+      if (exists) {
+        await fileIo.unlink(params.targetFile);
+      } else {
+        const targetDir = params.targetFile.substring(
+          0,
+          params.targetFile.lastIndexOf('/'),
+        );
+        exists = fileIo.accessSync(targetDir);
+        if (!exists) {
+          await fileIo.mkdir(targetDir);
         }
-      } catch (error) {
-        throw error;
       }
 
-      const response = await httpRequest.request(params.url, {
+      writer = await fileIo.open(
+        params.targetFile,
+        fileIo.OpenMode.CREATE | fileIo.OpenMode.READ_WRITE,
+      );
+
+      httpRequest.on('headersReceive', (header: Record<string, string>) => {
+        if (!header) {
+          return;
+        }
+        const lengthKey = Object.keys(header).find(
+          key => key.toLowerCase() === 'content-length',
+        );
+        if (!lengthKey) {
+          return;
+        }
+        const length = parseInt(header[lengthKey], 10);
+        if (!Number.isNaN(length)) {
+          contentLength = length;
+        }
+      });
+
+      httpRequest.on('dataReceive', (data: ArrayBuffer) => {
+        if (writeError) {
+          return;
+        }
+        received += data.byteLength;
+        writeQueue = writeQueue.then(async () => {
+          if (!writer || writeError) {
+            return;
+          }
+          try {
+            await fileIo.write(writer.fd, data);
+          } catch (error) {
+            writeError = error as Error;
+          }
+        });
+        this.onProgressUpdate(received, contentLength);
+      });
+
+      httpRequest.on(
+        'dataReceiveProgress',
+        (data: http.DataReceiveProgressInfo) => {
+          if (data.totalSize > 0) {
+            contentLength = data.totalSize;
+          }
+          if (data.receiveSize > received) {
+            received = data.receiveSize;
+          }
+          this.onProgressUpdate(received, contentLength);
+        },
+      );
+
+      const responseCode = await httpRequest.requestInStream(params.url, {
         method: http.RequestMethod.GET,
         readTimeout: 60000,
         connectTimeout: 60000,
@@ -81,32 +157,14 @@ export class DownloadTask {
           'Content-Type': 'application/octet-stream',
         },
       });
-      if (response.responseCode > 299) {
-        throw Error(`Server error: ${response.responseCode}`);
+      if (responseCode > 299) {
+        throw Error(`Server error: ${responseCode}`);
       }
 
-      const contentLength = parseInt(response.header['content-length'] || '0');
-      const writer = await fileIo.open(
-        params.targetFile,
-        fileIo.OpenMode.CREATE | fileIo.OpenMode.READ_WRITE,
-      );
-      let received = 0;
-      const data = response.result as ArrayBuffer;
-      const chunks = Math.ceil(data.byteLength / this.DOWNLOAD_CHUNK_SIZE);
-      for (let i = 0; i < chunks; i++) {
-        const start = i * this.DOWNLOAD_CHUNK_SIZE;
-        const end = Math.min(start + this.DOWNLOAD_CHUNK_SIZE, data.byteLength);
-        const chunk = data.slice(start, end);
-
-        await fileIo.write(writer.fd, chunk);
-        received += chunk.byteLength;
-
-        this.onProgressUpdate(received, contentLength);
-      }
-      await fileIo.close(writer);
+      await dataEndPromise;
       const stats = await fileIo.stat(params.targetFile);
       const fileSize = stats.size;
-      if (fileSize !== contentLength) {
+      if (contentLength > 0 && fileSize !== contentLength) {
         throw Error(
           `Download incomplete: expected ${contentLength} bytes but got ${stats.size} bytes`,
         );
@@ -115,6 +173,15 @@ export class DownloadTask {
       console.error('Download failed:', error);
       throw error;
     } finally {
+      try {
+        await closeWriter();
+      } catch (closeError) {
+        console.error('Failed to close file:', closeError);
+      }
+      httpRequest.off('headersReceive');
+      httpRequest.off('dataReceive');
+      httpRequest.off('dataReceiveProgress');
+      httpRequest.off('dataEnd');
       httpRequest.destroy();
     }
   }
@@ -432,7 +499,6 @@ export class DownloadTask {
         default:
           throw Error(`Unknown task type: ${params.type}`);
       }
-
     } catch (error) {
       console.error('Task execution failed:', error.message);
       if (params.type !== DownloadTaskParams.TASK_TYPE_CLEANUP) {

package/harmony/pushy/src/main/ets/PushyTurboModule.ts

@@ -86,7 +86,7 @@ export class PushyTurboModule extends TurboModule {
     return UpdateModuleImpl.getLocalHashInfo(this.context, hash);
   }
 
-  async setUuid(uuid: string): Promise<boolean> {
+  async setUuid(uuid: string): Promise<void> {
     logger.debug(TAG, ',call setUuid');
     return UpdateModuleImpl.setUuid(this.context, uuid);
   }
@@ -131,15 +131,6 @@ export class PushyTurboModule extends TurboModule {
     return UpdateModuleImpl.downloadFullUpdate(this.context, options);
   }
 
-  async downloadAndInstallApk(options: {
-    url: string;
-    target: string;
-    hash: string;
-  }): Promise<void> {
-    logger.debug(TAG, ',call downloadAndInstallApk');
-    return UpdateModuleImpl.downloadAndInstallApk(this.mUiCtx, options);
-  }
-
   addListener(_eventName: string): void {
     logger.debug(TAG, ',call addListener');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-update",
-  "version": "10.37.4",
+  "version": "10.37.6",
   "description": "react-native hot update",
   "main": "src/index",
   "scripts": {

package/src/client.ts

@@ -282,19 +282,23 @@ export class Pushy {
         type: 'errorChecking',
         message: this.t('error_cannot_connect_backup', { message: e.message }),
       });
-      const backupEndpoints = await this.getBackupEndpoints();
+      const backupEndpoints = await this.getBackupEndpoints().catch();
       if (backupEndpoints) {
-        try {
-          resp = await promiseAny(
-            backupEndpoints.map(endpoint =>
-              enhancedFetch(this.getCheckUrl(endpoint), fetchPayload),
-            ),
-          );
-        } catch (err: any) {
-          this.throwIfEnabled(Error('errorCheckingUseBackup'));
-        }
+        resp = await promiseAny(
+          backupEndpoints.map(endpoint =>
+            enhancedFetch(this.getCheckUrl(endpoint), fetchPayload),
+          ),
+        ).catch(() => {
+          this.report({
+            type: 'errorChecking',
+            message: this.t('errorCheckingUseBackup'),
+          });
+        });
       } else {
-        this.throwIfEnabled(Error('errorCheckingGetBackup'));
+        this.report({
+          type: 'errorChecking',
+          message: this.t('errorCheckingGetBackup'),
+        });
       }
     }
     if (!resp) {
@@ -316,7 +320,7 @@ export class Pushy {
         type: 'errorChecking',
         message: errorMessage,
       });
-      this.throwIfEnabled(Error(errorMessage));
+      this.throwIfEnabled(Error('errorChecking: ' + errorMessage));
       return this.lastRespJson ? await this.lastRespJson : emptyObj;
     }
     this.lastRespJson = resp.json();