react-native-update 10.43.3 → 10.45.0

package/harmony/pushy/src/main/cpp/pushy.cpp

@@ -8,21 +8,14 @@
 #include "archive_patch_core.h"
 #include "patch_core.h"
 #include "state_core.h"
+#include "state_ops.h"
 
 extern "C" {
-#include "hpatch.h"
 }
 
 namespace {
 
-enum class StateOperation {
-  kSwitchVersion = 1,
-  kMarkSuccess = 2,
-  kRollback = 3,
-  kClearFirstTime = 4,
-  kClearRollbackMark = 5,
-  kResolveLaunch = 6,
-};
+using pushy::state_ops::StateOperation;
 
 constexpr const char* kDefaultBundlePatchEntryName = "index.bundlejs.patch";
 
@@ -413,96 +406,6 @@ pushy::patch::PatchManifest BuildManifest(
   return manifest;
 }
 
-napi_value HdiffPatch(napi_env env, napi_callback_info info) {
-  napi_value args[2] = {nullptr, nullptr};
-  size_t argc = 2;
-  if (!GetArgCount(env, info, &argc, args) || argc < 2) {
-    ThrowError(env, "Wrong number of arguments");
-    return nullptr;
-  }
-
-  bool is_typed_array = false;
-  if (napi_is_typedarray(env, args[0], &is_typed_array) != napi_ok || !is_typed_array) {
-    ThrowError(env, "First argument must be a TypedArray");
-    return nullptr;
-  }
-
-  uint8_t* origin_ptr = nullptr;
-  size_t origin_length = 0;
-  if (napi_get_typedarray_info(
-          env,
-          args[0],
-          nullptr,
-          &origin_length,
-          reinterpret_cast<void**>(&origin_ptr),
-          nullptr,
-          nullptr) != napi_ok) {
-    ThrowError(env, "Failed to get origin buffer");
-    return nullptr;
-  }
-
-  if (napi_is_typedarray(env, args[1], &is_typed_array) != napi_ok || !is_typed_array) {
-    ThrowError(env, "Second argument must be a TypedArray");
-    return nullptr;
-  }
-
-  uint8_t* patch_ptr = nullptr;
-  size_t patch_length = 0;
-  if (napi_get_typedarray_info(
-          env,
-          args[1],
-          nullptr,
-          &patch_length,
-          reinterpret_cast<void**>(&patch_ptr),
-          nullptr,
-          nullptr) != napi_ok) {
-    ThrowError(env, "Failed to get patch buffer");
-    return nullptr;
-  }
-
-  hpatch_singleCompressedDiffInfo patch_info;
-  if (!((origin_length == 0) || origin_ptr) || !patch_ptr || patch_length == 0) {
-    ThrowError(env, "Corrupt patch");
-    return nullptr;
-  }
-  if (kHPatch_ok != hpatch_getInfo_by_mem(&patch_info, patch_ptr, patch_length)) {
-    ThrowError(env, "Error info in hpatch");
-    return nullptr;
-  }
-  if (origin_length != patch_info.oldDataSize) {
-    ThrowError(env, "Error oldDataSize in hpatch");
-    return nullptr;
-  }
-
-  size_t new_size = static_cast<size_t>(patch_info.newDataSize);
-  if (sizeof(size_t) != sizeof(hpatch_StreamPos_t) &&
-      new_size != patch_info.newDataSize) {
-    ThrowError(env, "Error newDataSize in hpatch");
-    return nullptr;
-  }
-
-  void* output_data = nullptr;
-  napi_value result = nullptr;
-  if (napi_create_arraybuffer(env, new_size, &output_data, &result) != napi_ok) {
-    ThrowError(env, "Failed to create result buffer");
-    return nullptr;
-  }
-
-  if (kHPatch_ok != hpatch_by_mem(
-                       origin_ptr,
-                       origin_length,
-                       static_cast<uint8_t*>(output_data),
-                       new_size,
-                       patch_ptr,
-                       patch_length,
-                       &patch_info)) {
-    ThrowError(env, "hpatch");
-    return nullptr;
-  }
-
-  return result;
-}
-
 napi_value SyncStateWithBinaryVersion(napi_env env, napi_callback_info info) {
   napi_value args[3] = {nullptr, nullptr, nullptr};
   size_t argc = 3;
@@ -670,9 +573,14 @@ napi_value BuildArchivePatchPlan(napi_env env, napi_callback_info info) {
 
   const pushy::patch::PatchManifest manifest =
       BuildManifest(copy_froms, copy_tos, deletes);
+  pushy::archive_patch::ArchivePatchType archive_type;
+  if (!pushy::archive_patch::TryParseArchivePatchType(patch_type, &archive_type)) {
+    ThrowError(env, "Unknown archive patch type");
+    return nullptr;
+  }
   pushy::archive_patch::ArchivePatchPlan plan;
   const pushy::patch::Status status = pushy::archive_patch::BuildArchivePatchPlan(
-      static_cast<pushy::archive_patch::ArchivePatchType>(patch_type),
+      archive_type,
       manifest,
       entry_names,
       &plan,
@@ -717,6 +625,47 @@ napi_value BuildCopyGroups(napi_env env, napi_callback_info info) {
   return NewCopyGroupArray(env, groups);
 }
 
+// ---------------------------------------------------------------------------
+// Async work plumbing for the heavy patch operations.
+//
+// applyPatchFromFileSource and cleanupOldEntries run hdiff / recursive file IO
+// that can take hundreds of ms to seconds. The Pushy TurboModule executes on
+// the UI thread, so running these synchronously froze the UI. These are now
+// wrapped in napi_create_async_work: arguments are parsed on the JS thread, the
+// heavy work runs on a libuv worker thread, and the returned Promise is settled
+// back on the JS thread.
+// ---------------------------------------------------------------------------
+
+// Reject an already-created deferred with an Error(message). Used when async
+// work fails to be created/queued, so the Promise never hangs pending.
+void RejectDeferredWithMessage(
+    napi_env env,
+    napi_deferred deferred,
+    const char* message) {
+  napi_value error = nullptr;
+  napi_value message_value = nullptr;
+  napi_create_string_utf8(env, message, NAPI_AUTO_LENGTH, &message_value);
+  napi_create_error(env, nullptr, message_value, &error);
+  napi_reject_deferred(env, deferred, error);
+}
+
+struct ApplyPatchWork {
+  napi_async_work work = nullptr;
+  napi_deferred deferred = nullptr;
+  pushy::patch::FileSourcePatchOptions options;
+  pushy::patch::Status status{false, ""};
+};
+
+struct CleanupWork {
+  napi_async_work work = nullptr;
+  napi_deferred deferred = nullptr;
+  std::string root_dir;
+  std::string keep_current;
+  std::string keep_previous;
+  int32_t max_age_days = 0;
+  pushy::patch::Status status{false, ""};
+};
+
 napi_value ApplyPatchFromFileSource(napi_env env, napi_callback_info info) {
   napi_value args[1] = {nullptr};
   size_t argc = 1;
@@ -756,26 +705,69 @@ napi_value ApplyPatchFromFileSource(napi_env env, napi_callback_info info) {
     return nullptr;
   }
 
-  pushy::patch::FileSourcePatchOptions options;
-  options.manifest = BuildManifest(copy_froms, copy_tos, deletes);
-  options.source_root = source_root;
-  options.target_root = target_root;
-  options.origin_bundle_path = origin_bundle_path;
-  options.bundle_patch_path = bundle_patch_path;
-  options.bundle_output_path = bundle_output_path;
-  options.merge_source_subdir = merge_source_subdir;
-  options.enable_merge = enable_merge;
+  auto* work_data = new ApplyPatchWork();
+  work_data->options.manifest = BuildManifest(copy_froms, copy_tos, deletes);
+  work_data->options.source_root = source_root;
+  work_data->options.target_root = target_root;
+  work_data->options.origin_bundle_path = origin_bundle_path;
+  work_data->options.bundle_patch_path = bundle_patch_path;
+  work_data->options.bundle_output_path = bundle_output_path;
+  work_data->options.merge_source_subdir = merge_source_subdir;
+  work_data->options.enable_merge = enable_merge;
 
-  const pushy::patch::Status status =
-      pushy::patch::ApplyPatchFromFileSource(options);
-  if (!status.ok) {
-    ThrowError(env, status.message);
+  napi_value promise = nullptr;
+  if (napi_create_promise(env, &work_data->deferred, &promise) != napi_ok) {
+    delete work_data;
+    ThrowError(env, "Unable to create promise");
     return nullptr;
   }
 
-  napi_value undefined_value = nullptr;
-  napi_get_undefined(env, &undefined_value);
-  return undefined_value;
+  napi_value resource_name = nullptr;
+  napi_create_string_utf8(
+      env, "applyPatchFromFileSource", NAPI_AUTO_LENGTH, &resource_name);
+  if (napi_create_async_work(
+          env,
+          nullptr,
+          resource_name,
+          [](napi_env, void* data) {
+            auto* w = static_cast<ApplyPatchWork*>(data);
+            w->status = pushy::patch::ApplyPatchFromFileSource(w->options);
+          },
+          [](napi_env cb_env, napi_status, void* data) {
+            auto* w = static_cast<ApplyPatchWork*>(data);
+            if (w->status.ok) {
+              napi_value undefined_value = nullptr;
+              napi_get_undefined(cb_env, &undefined_value);
+              napi_resolve_deferred(cb_env, w->deferred, undefined_value);
+            } else {
+              napi_value error = nullptr;
+              napi_value message = nullptr;
+              napi_create_string_utf8(
+                  cb_env, w->status.message.c_str(), NAPI_AUTO_LENGTH, &message);
+              napi_create_error(cb_env, nullptr, message, &error);
+              napi_reject_deferred(cb_env, w->deferred, error);
+            }
+            napi_delete_async_work(cb_env, w->work);
+            delete w;
+          },
+          work_data,
+          &work_data->work) != napi_ok) {
+    // Work was never created: settle the promise and free the data so it does
+    // not leak / hang pending forever.
+    RejectDeferredWithMessage(
+        env, work_data->deferred, "Unable to create async work");
+    delete work_data;
+    return promise;
+  }
+  if (napi_queue_async_work(env, work_data->work) != napi_ok) {
+    // Queued failed: the complete callback will never run, so clean up here.
+    napi_delete_async_work(env, work_data->work);
+    RejectDeferredWithMessage(
+        env, work_data->deferred, "Unable to queue async work");
+    delete work_data;
+    return promise;
+  }
+  return promise;
 }
 
 napi_value CleanupOldEntries(napi_env env, napi_callback_info info) {
@@ -804,19 +796,63 @@ napi_value CleanupOldEntries(napi_env env, napi_callback_info info) {
     return nullptr;
   }
 
-  const pushy::patch::Status status = pushy::patch::CleanupOldEntries(
-      root_dir,
-      keep_current,
-      keep_previous,
-      max_age_days);
-  if (!status.ok) {
-    ThrowError(env, status.message);
+  auto* work_data = new CleanupWork();
+  work_data->root_dir = root_dir;
+  work_data->keep_current = keep_current;
+  work_data->keep_previous = keep_previous;
+  work_data->max_age_days = max_age_days;
+
+  napi_value promise = nullptr;
+  if (napi_create_promise(env, &work_data->deferred, &promise) != napi_ok) {
+    delete work_data;
+    ThrowError(env, "Unable to create promise");
     return nullptr;
   }
 
-  napi_value undefined_value = nullptr;
-  napi_get_undefined(env, &undefined_value);
-  return undefined_value;
+  napi_value resource_name = nullptr;
+  napi_create_string_utf8(
+      env, "cleanupOldEntries", NAPI_AUTO_LENGTH, &resource_name);
+  if (napi_create_async_work(
+          env,
+          nullptr,
+          resource_name,
+          [](napi_env, void* data) {
+            auto* w = static_cast<CleanupWork*>(data);
+            w->status = pushy::patch::CleanupOldEntries(
+                w->root_dir, w->keep_current, w->keep_previous, w->max_age_days);
+          },
+          [](napi_env cb_env, napi_status, void* data) {
+            auto* w = static_cast<CleanupWork*>(data);
+            if (w->status.ok) {
+              napi_value undefined_value = nullptr;
+              napi_get_undefined(cb_env, &undefined_value);
+              napi_resolve_deferred(cb_env, w->deferred, undefined_value);
+            } else {
+              napi_value error = nullptr;
+              napi_value message = nullptr;
+              napi_create_string_utf8(
+                  cb_env, w->status.message.c_str(), NAPI_AUTO_LENGTH, &message);
+              napi_create_error(cb_env, nullptr, message, &error);
+              napi_reject_deferred(cb_env, w->deferred, error);
+            }
+            napi_delete_async_work(cb_env, w->work);
+            delete w;
+          },
+          work_data,
+          &work_data->work) != napi_ok) {
+    RejectDeferredWithMessage(
+        env, work_data->deferred, "Unable to create async work");
+    delete work_data;
+    return promise;
+  }
+  if (napi_queue_async_work(env, work_data->work) != napi_ok) {
+    napi_delete_async_work(env, work_data->work);
+    RejectDeferredWithMessage(
+        env, work_data->deferred, "Unable to queue async work");
+    delete work_data;
+    return promise;
+  }
+  return promise;
 }
 
 bool ExportFunction(
@@ -841,8 +877,7 @@ bool ExportFunction(
 }  // namespace
 
 napi_value Init(napi_env env, napi_value exports) {
-  if (!ExportFunction(env, exports, "hdiffPatch", HdiffPatch) ||
-      !ExportFunction(env, exports, "syncStateWithBinaryVersion", SyncStateWithBinaryVersion) ||
+  if (!ExportFunction(env, exports, "syncStateWithBinaryVersion", SyncStateWithBinaryVersion) ||
       !ExportFunction(env, exports, "runStateCore", RunStateCore) ||
       !ExportFunction(env, exports, "buildArchivePatchPlan", BuildArchivePatchPlan) ||
       !ExportFunction(env, exports, "buildCopyGroups", BuildCopyGroups) ||

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

@@ -69,7 +69,7 @@ const FILE_COPY_BUFFER_SIZE = 64 * 1024;
 
 export class DownloadTask {
   private context: common.Context;
-  private hash: string;
+  private hash = '';
   private eventHub: EventHub;
 
   constructor(context: common.Context) {
@@ -233,7 +233,7 @@ export class DownloadTask {
     const originBundlePath = `${workingDirectory}/${TEMP_ORIGIN_BUNDLE_ENTRY}`;
     try {
       await this.writeFileContent(originBundlePath, originContent);
-      NativePatchCore.applyPatchFromFileSource({
+      await NativePatchCore.applyPatchFromFileSource({
         copyFroms: [],
         copyTos: [],
         deletes: [],
@@ -244,7 +244,7 @@ export class DownloadTask {
         bundleOutputPath: outputFile,
         enableMerge: false,
       });
-    } catch (error) {
+    } catch (error: any) {
       error.message = `Failed to process bundle patch: ${error.message}`;
       throw error;
     } finally {
@@ -308,6 +308,26 @@ export class DownloadTask {
     let received = 0;
     let writeError: Error | null = null;
     let writeQueue = Promise.resolve();
+    let lastReportedPercentage = -1;
+    let lastReportedBytes = 0;
+
+    // Emit at most one progress event per whole-percent change (or per 256KB
+    // when the total is unknown), and only from the dataReceive handler, so the
+    // two HarmonyOS callbacks don't each fire an event per chunk.
+    const reportProgress = () => {
+      if (contentLength > 0) {
+        const percentage = Math.round((received * 100) / contentLength);
+        if (percentage <= lastReportedPercentage) {
+          return;
+        }
+        lastReportedPercentage = percentage;
+      } else if (received - lastReportedBytes < 256 * 1024) {
+        return;
+      } else {
+        lastReportedBytes = received;
+      }
+      this.onProgressUpdate(received, contentLength);
+    };
 
     const closeWriter = async () => {
       if (writer) {
@@ -316,8 +336,37 @@ export class DownloadTask {
       }
     };
 
+    // Watchdog: reject the download if no data is received for a while, so a
+    // stalled transfer after requestInStream resolves cannot hang the download
+    // Promise (and the JS caller) forever.
+    const INACTIVITY_TIMEOUT_MS = 60000;
+    let watchdogTimer: number | null = null;
+    let inactivityReject: ((error: Error) => void) | null = null;
+    const clearWatchdog = () => {
+      if (watchdogTimer !== null) {
+        clearTimeout(watchdogTimer);
+        watchdogTimer = null;
+      }
+    };
+    const refreshWatchdog = () => {
+      clearWatchdog();
+      watchdogTimer = setTimeout(() => {
+        if (inactivityReject) {
+          inactivityReject(
+            Error(
+              `Download stalled: no data received for ${INACTIVITY_TIMEOUT_MS}ms`,
+            ),
+          );
+        }
+      }, INACTIVITY_TIMEOUT_MS);
+    };
+    const inactivityPromise = new Promise<void>((_, reject) => {
+      inactivityReject = reject;
+    });
+
     const dataEndPromise = new Promise<void>((resolve, reject) => {
       httpRequest.on('dataEnd', () => {
+        clearWatchdog();
         writeQueue
           .then(async () => {
             if (writeError) {
@@ -346,23 +395,25 @@ export class DownloadTask {
         fileIo.OpenMode.CREATE | fileIo.OpenMode.READ_WRITE,
       );
 
-      httpRequest.on('headersReceive', (header: Record<string, string>) => {
+      httpRequest.on('headersReceive', (header: Object) => {
         if (!header) {
           return;
         }
-        const lengthKey = Object.keys(header).find(
+        const headers = header as Record<string, string>;
+        const lengthKey = Object.keys(headers).find(
           key => key.toLowerCase() === 'content-length',
         );
         if (!lengthKey) {
           return;
         }
-        const length = parseInt(header[lengthKey], 10);
+        const length = parseInt(headers[lengthKey], 10);
         if (!Number.isNaN(length)) {
           contentLength = length;
         }
       });
 
       httpRequest.on('dataReceive', (data: ArrayBuffer) => {
+        refreshWatchdog();
         if (writeError) {
           return;
         }
@@ -377,22 +428,21 @@ export class DownloadTask {
             writeError = error as Error;
           }
         });
-        this.onProgressUpdate(received, contentLength);
+        reportProgress();
       });
 
       httpRequest.on(
         'dataReceiveProgress',
         (data: http.DataReceiveProgressInfo) => {
+          // Only refine the known total here; progress events are emitted from
+          // the dataReceive handler to avoid double-firing.
           if (data.totalSize > 0) {
             contentLength = data.totalSize;
           }
-          if (data.receiveSize > received) {
-            received = data.receiveSize;
-          }
-          this.onProgressUpdate(received, contentLength);
         },
       );
 
+      refreshWatchdog();
       const responseCode = await httpRequest.requestInStream(params.url, {
         method: http.RequestMethod.GET,
         readTimeout: 60000,
@@ -405,7 +455,7 @@ export class DownloadTask {
         throw Error(`Server error: ${responseCode}`);
       }
 
-      await dataEndPromise;
+      await Promise.race([dataEndPromise, inactivityPromise]);
       const stats = await fileIo.stat(params.targetFile);
       const fileSize = stats.size;
       if (contentLength > 0 && fileSize !== contentLength) {
@@ -417,6 +467,7 @@ export class DownloadTask {
       console.error('Download failed:', error);
       throw error;
     } finally {
+      clearWatchdog();
       try {
         await closeWriter();
       } catch (closeError) {
@@ -518,7 +569,7 @@ export class DownloadTask {
       manifestArrays.deletes,
       HARMONY_BUNDLE_PATCH_ENTRY,
     );
-    NativePatchCore.applyPatchFromFileSource({
+    await NativePatchCore.applyPatchFromFileSource({
       copyFroms: manifestArrays.copyFroms,
       copyTos: manifestArrays.copyTos,
       deletes: manifestArrays.deletes,
@@ -556,9 +607,11 @@ export class DownloadTask {
         }
 
         if (currentFrom.startsWith('resources/base/media/')) {
+          // Strip only the final extension: 'icon.round.png' -> 'icon.round',
+          // not 'icon' (getMediaByName expects the full resource name).
           const mediaName = currentFrom
             .replace('resources/base/media/', '')
-            .split('.')[0];
+            .replace(/\.[^.]+$/, '');
           const mediaBuffer = await resourceManager.getMediaByName(mediaName);
           const parentDirs = [
             ...new Set(
@@ -599,7 +652,7 @@ export class DownloadTask {
           }
         }
       }
-    } catch (error) {
+    } catch (error: any) {
       error.message =
         'Copy from resource failed:' +
         currentFrom +
@@ -614,13 +667,13 @@ export class DownloadTask {
 
   private async doCleanUp(params: DownloadTaskParams): Promise<void> {
     try {
-      NativePatchCore.cleanupOldEntries(
+      await NativePatchCore.cleanupOldEntries(
         params.unzipDirectory,
         params.hash || '',
         params.originHash || '',
         3,
       );
-    } catch (error) {
+    } catch (error: any) {
       error.message = 'Cleanup failed:' + error.message;
       console.error(error);
       throw error;
@@ -648,7 +701,7 @@ export class DownloadTask {
         default:
           throw Error(`Unknown task type: ${params.type}`);
       }
-    } catch (error) {
+    } catch (error: any) {
       console.error('Task execution failed:', error.message);
       if (params.type !== DownloadTaskParams.TASK_TYPE_CLEANUP) {
         try {
@@ -657,7 +710,7 @@ export class DownloadTask {
           } else {
             await this.removeDirectory(params.unzipDirectory);
           }
-        } catch (cleanupError) {
+        } catch (cleanupError: any) {
           console.error('Cleanup after error failed:', cleanupError.message);
         }
       }

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

@@ -50,10 +50,6 @@ export interface FileSourcePatchRequest {
 }
 
 interface NativePatchCoreBindings {
-  hdiffPatch(
-    origin: Uint8Array,
-    patch: Uint8Array,
-  ): ArrayBuffer | Uint8Array;
   syncStateWithBinaryVersion(
     packageVersion: string,
     buildTime: string,
@@ -75,13 +71,13 @@ interface NativePatchCoreBindings {
     bundlePatchEntryName?: string,
   ): ArchivePatchPlanResult;
   buildCopyGroups(copyFroms: string[], copyTos: string[]): CopyGroupResult[];
-  applyPatchFromFileSource(options: FileSourcePatchRequest): void;
+  applyPatchFromFileSource(options: FileSourcePatchRequest): Promise<void>;
   cleanupOldEntries(
     rootDir: string,
     keepCurrent: string,
     keepPrevious: string,
     maxAgeDays: number,
-  ): void;
+  ): Promise<void>;
 }
 
 export default NativeUpdateCore as unknown as NativePatchCoreBindings;

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

@@ -93,23 +93,23 @@ export class PushyTurboModule extends UITurboModule {
       }
     } else {
       logger.debug(TAG, 'reloadBridge via restartAbility (release mode)');
-      let restarted = false;
+      // If the process truly restarts, this timer dies with it. It only fires
+      // when the app is still alive after 1.5s — i.e. restartApp resolved but
+      // was silently suppressed (HarmonyOS rate-limits restarts within a few
+      // seconds of cold start / of a previous call) — which is exactly when the
+      // soft reload must take over. So the timer is NOT cleared on the success
+      // path, only in the catch branch where the soft reload runs immediately.
       const fallbackTimer = setTimeout(() => {
-        if (!restarted) {
-          logger.warn(TAG, 'restartAbility did not restart the app within 1.5s, triggering soft reload fallback');
-          const devToolsController = (this.ctx as Record<string, any>).devToolsController;
-          if (devToolsController) {
-            devToolsController.eventEmitter.emit("RELOAD", { reason: 'HotReload2' });
-          }
+        logger.warn(TAG, 'restartAbility did not restart the app within 1.5s, triggering soft reload fallback');
+        const devToolsController = (this.ctx as Record<string, any>).devToolsController;
+        if (devToolsController) {
+          devToolsController.eventEmitter.emit("RELOAD", { reason: 'HotReload2' });
         }
       }, 1500);
 
       try {
         await this.restartAbility();
-        restarted = true;
-        clearTimeout(fallbackTimer);
       } catch (error) {
-        restarted = false;
         clearTimeout(fallbackTimer);
         logger.error(TAG, `restartAbility failed: ${getErrorMessage(error)}, triggering soft reload fallback`);
         const devToolsController = (this.ctx as Record<string, any>).devToolsController;