react-native-update 10.43.3 → 10.44.0

package/cpp/patch_core/update_core_android.cpp

@@ -4,56 +4,16 @@
 #include <vector>
 
 #include "archive_patch_core.h"
+#include "jni_util.h"
 #include "state_core.h"
+#include "state_ops.h"
 
 namespace {
 
-enum class StateOperation {
-  kSwitchVersion = 1,
-  kMarkSuccess = 2,
-  kRollback = 3,
-  kClearFirstTime = 4,
-  kClearRollbackMark = 5,
-  kResolveLaunch = 6,
-};
-
-std::string JStringToString(JNIEnv* env, jstring value) {
-  if (value == nullptr) {
-    return std::string();
-  }
-
-  const char* chars = env->GetStringUTFChars(value, nullptr);
-  if (chars == nullptr) {
-    return std::string();
-  }
-
-  std::string result(chars);
-  env->ReleaseStringUTFChars(value, chars);
-  return result;
-}
-
-std::vector<std::string> JArrayToVector(JNIEnv* env, jobjectArray values) {
-  std::vector<std::string> result;
-  if (values == nullptr) {
-    return result;
-  }
-
-  const jsize size = env->GetArrayLength(values);
-  result.reserve(static_cast<size_t>(size));
-  for (jsize index = 0; index < size; ++index) {
-    auto* item = static_cast<jstring>(env->GetObjectArrayElement(values, index));
-    result.push_back(JStringToString(env, item));
-    env->DeleteLocalRef(item);
-  }
-  return result;
-}
-
-void ThrowRuntimeException(JNIEnv* env, const std::string& message) {
-  jclass exception = env->FindClass("java/lang/RuntimeException");
-  if (exception != nullptr) {
-    env->ThrowNew(exception, message.c_str());
-  }
-}
+using pushy::jni_util::JArrayToVector;
+using pushy::jni_util::JStringToString;
+using pushy::jni_util::ThrowRuntimeException;
+using pushy::state_ops::StateOperation;
 
 void SetStringField(
     JNIEnv* env,
@@ -64,6 +24,9 @@ void SetStringField(
   jfieldID field =
       env->GetFieldID(target_class, field_name, "Ljava/lang/String;");
   if (field == nullptr) {
+    // Clear the pending NoSuchFieldError so subsequent JNI calls are not
+    // executed with an exception pending (undefined behavior / CheckJNI abort).
+    env->ExceptionClear();
     return;
   }
   if (value.empty()) {
@@ -83,9 +46,11 @@ void SetBooleanField(
     const char* field_name,
     bool value) {
   jfieldID field = env->GetFieldID(target_class, field_name, "Z");
-  if (field != nullptr) {
-    env->SetBooleanField(target, field, value ? JNI_TRUE : JNI_FALSE);
+  if (field == nullptr) {
+    env->ExceptionClear();
+    return;
   }
+  env->SetBooleanField(target, field, value ? JNI_TRUE : JNI_FALSE);
 }
 
 std::string GetStringField(
@@ -96,6 +61,7 @@ std::string GetStringField(
   jfieldID field =
       env->GetFieldID(target_class, field_name, "Ljava/lang/String;");
   if (field == nullptr) {
+    env->ExceptionClear();
     return std::string();
   }
   auto* value = static_cast<jstring>(env->GetObjectField(target, field));
@@ -112,7 +78,11 @@ bool GetBooleanField(
     jclass target_class,
     const char* field_name) {
   jfieldID field = env->GetFieldID(target_class, field_name, "Z");
-  return field != nullptr && env->GetBooleanField(target, field) == JNI_TRUE;
+  if (field == nullptr) {
+    env->ExceptionClear();
+    return false;
+  }
+  return env->GetBooleanField(target, field) == JNI_TRUE;
 }
 
 pushy::state::State ReadState(
@@ -241,13 +211,9 @@ jobject NewArchivePatchPlanResult(
 
 jobject NewCopyGroupResult(
     JNIEnv* env,
+    jclass result_class,
+    jclass string_class,
     const pushy::archive_patch::CopyGroup& group) {
-  jclass result_class =
-      env->FindClass("cn/reactnative/modules/update/CopyGroupResult");
-  if (result_class == nullptr) {
-    return nullptr;
-  }
-
   jmethodID constructor = env->GetMethodID(result_class, "<init>", "()V");
   if (constructor == nullptr) {
     return nullptr;
@@ -262,7 +228,6 @@ jobject NewCopyGroupResult(
   jfieldID to_paths_field =
       env->GetFieldID(result_class, "toPaths", "[Ljava/lang/String;");
   if (to_paths_field != nullptr) {
-    jclass string_class = env->FindClass("java/lang/String");
     jobjectArray to_paths = env->NewObjectArray(
         static_cast<jsize>(group.to_paths.size()), string_class, nullptr);
     if (to_paths != nullptr) {
@@ -275,22 +240,20 @@ jobject NewCopyGroupResult(
       env->SetObjectField(result, to_paths_field, to_paths);
       env->DeleteLocalRef(to_paths);
     }
+  } else {
+    env->ExceptionClear();
   }
 
   return result;
 }
 
-pushy::archive_patch::ArchivePatchType ToArchivePatchType(jint patch_type) {
-  switch (patch_type) {
-    case 1:
-      return pushy::archive_patch::ArchivePatchType::kFull;
-    case 2:
-      return pushy::archive_patch::ArchivePatchType::kPatchFromPackage;
-    case 3:
-      return pushy::archive_patch::ArchivePatchType::kPatchFromPpk;
-    default:
-      return pushy::archive_patch::ArchivePatchType::kFull;
-  }
+bool ToArchivePatchType(
+    jint patch_type,
+    pushy::archive_patch::ArchivePatchType* out) {
+  // Delegate to the shared parser so Android and HarmonyOS agree on which
+  // integer values are valid and neither silently falls back to kFull.
+  return pushy::archive_patch::TryParseArchivePatchType(
+      static_cast<int>(patch_type), out);
 }
 
 pushy::patch::PatchManifest BuildManifest(
@@ -411,9 +374,14 @@ Java_cn_reactnative_modules_update_DownloadTask_buildArchivePatchPlan(
 
   pushy::patch::PatchManifest manifest =
       BuildManifest(from_values, to_values, JArrayToVector(env, deletes));
+  pushy::archive_patch::ArchivePatchType archive_type;
+  if (!ToArchivePatchType(patch_type, &archive_type)) {
+    ThrowRuntimeException(env, "Unknown archive patch type");
+    return nullptr;
+  }
   pushy::archive_patch::ArchivePatchPlan plan;
   pushy::patch::Status status = pushy::archive_patch::BuildArchivePatchPlan(
-      ToArchivePatchType(patch_type),
+      archive_type,
       manifest,
       JArrayToVector(env, entry_names),
       &plan);
@@ -454,6 +422,11 @@ Java_cn_reactnative_modules_update_DownloadTask_buildCopyGroups(
     return nullptr;
   }
 
+  jclass string_class = env->FindClass("java/lang/String");
+  if (string_class == nullptr) {
+    return nullptr;
+  }
+
   jobjectArray result = env->NewObjectArray(
       static_cast<jsize>(groups.size()), result_class, nullptr);
   if (result == nullptr) {
@@ -461,9 +434,10 @@ Java_cn_reactnative_modules_update_DownloadTask_buildCopyGroups(
   }
 
   for (jsize index = 0; index < static_cast<jsize>(groups.size()); ++index) {
-    jobject group = NewCopyGroupResult(env, groups[index]);
+    jobject group = NewCopyGroupResult(env, result_class, string_class, groups[index]);
     env->SetObjectArrayElement(result, index, group);
     env->DeleteLocalRef(group);
   }
+  env->DeleteLocalRef(string_class);
   return result;
 }

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

@@ -8,6 +8,7 @@
 #include "archive_patch_core.h"
 #include "patch_core.h"
 #include "state_core.h"
+#include "state_ops.h"
 
 extern "C" {
 #include "hpatch.h"
@@ -15,14 +16,7 @@ extern "C" {
 
 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";
 
@@ -670,9 +664,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 +716,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 +796,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 +887,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(

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

@@ -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: [],
@@ -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) {
@@ -363,6 +412,7 @@ export class DownloadTask {
       });
 
       httpRequest.on('dataReceive', (data: ArrayBuffer) => {
+        refreshWatchdog();
         if (writeError) {
           return;
         }
@@ -377,22 +427,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 +454,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 +466,7 @@ export class DownloadTask {
       console.error('Download failed:', error);
       throw error;
     } finally {
+      clearWatchdog();
       try {
         await closeWriter();
       } catch (closeError) {
@@ -518,7 +568,7 @@ export class DownloadTask {
       manifestArrays.deletes,
       HARMONY_BUNDLE_PATCH_ENTRY,
     );
-    NativePatchCore.applyPatchFromFileSource({
+    await NativePatchCore.applyPatchFromFileSource({
       copyFroms: manifestArrays.copyFroms,
       copyTos: manifestArrays.copyTos,
       deletes: manifestArrays.deletes,
@@ -614,7 +664,7 @@ export class DownloadTask {
 
   private async doCleanUp(params: DownloadTaskParams): Promise<void> {
     try {
-      NativePatchCore.cleanupOldEntries(
+      await NativePatchCore.cleanupOldEntries(
         params.unzipDirectory,
         params.hash || '',
         params.originHash || '',

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

@@ -75,13 +75,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;