@onekeyfe/react-native-app-update 3.0.58 → 3.0.59

package/android/src/main/java/com/margelo/nitro/reactnativeappupdate/ReactNativeAppUpdate.kt

@@ -1191,6 +1191,53 @@ n2DMz6gqk326W6SFynYtvuiXo7wG4Cmn3SuIU8xfv9rJqunpZGYchMd7nZektmEJ
         return result
     }
 
+    /**
+     * Delete every file in cacheDir/apks/ (.apk / .partial / .progress /
+     * .SHA256SUMS.asc). Tolerates a missing directory and per-file delete
+     * failures (e.g. the OS reclaimed the cache mid-pass — see
+     * verifyExistingApk's Indeterminate handling for the same defensive
+     * stance). Pure file I/O: does NOT touch download/verification state, so
+     * it is safe to share between clearCache (full reset) and clearApkCache
+     * (JS-gated, no in-flight download to cancel). The [tag] flows into the
+     * log lines so the two callers stay distinguishable in logcat.
+     */
+    private fun wipeApkCacheFiles(tag: String, protectedPaths: Set<String> = emptySet()) {
+        val context = NitroModules.applicationContext
+        if (context == null) {
+            OneKeyLog.warn("AppUpdate", "$tag: application context unavailable, skipping file cleanup")
+            return
+        }
+        val apkDir = File(context.cacheDir, "apks")
+        if (!apkDir.exists()) {
+            OneKeyLog.info("AppUpdate", "$tag: apks cache directory does not exist, nothing to clean")
+            return
+        }
+        val filesToDelete = apkDir.listFiles() ?: emptyArray()
+        OneKeyLog.info("AppUpdate", "$tag: found ${filesToDelete.size} cached file(s) to delete in ${apkDir.absolutePath}")
+        var deletedCount = 0
+        var skippedCount = 0
+        filesToDelete.forEach { file ->
+            // Never delete a verified, pending-install APK (its canonical path is
+            // still in verifiedFiles). Protects the install flow from a racing
+            // cleanup that slipped past the JS status gate.
+            if (protectedPaths.isNotEmpty() && file.canonicalPath in protectedPaths) {
+                OneKeyLog.info("AppUpdate", "$tag: skipping verified pending-install file ${file.name}")
+                skippedCount++
+                return@forEach
+            }
+            val size = file.length()
+            // The file may already be gone (concurrent OS cache reclaim);
+            // treat a non-existent file as nothing to do, not a failure.
+            if (!file.exists() || file.delete()) {
+                OneKeyLog.debug("AppUpdate", "$tag: deleted ${file.name} (${size} bytes)")
+                deletedCount++
+            } else {
+                OneKeyLog.warn("AppUpdate", "$tag: failed to delete ${file.name}")
+            }
+        }
+        OneKeyLog.info("AppUpdate", "$tag: completed, deleted $deletedCount/${filesToDelete.size} files (skipped $skippedCount protected)")
+    }
+
     override fun clearCache(): Promise<Unit> {
         return Promise.async {
             OneKeyLog.info("AppUpdate", "clearCache: starting cleanup...")
@@ -1200,29 +1247,31 @@ n2DMz6gqk326W6SFynYtvuiXo7wG4Cmn3SuIU8xfv9rJqunpZGYchMd7nZektmEJ
             OneKeyLog.info("AppUpdate", "clearCache: reset download state, cleared $verifiedCount verified file entries")
 
             // Clean up downloaded APK and ASC files from cacheDir/apks/ directory
-            val context = NitroModules.applicationContext
-            if (context != null) {
-                val apkDir = File(context.cacheDir, "apks")
-                if (apkDir.exists()) {
-                    val filesToDelete = apkDir.listFiles() ?: emptyArray()
-                    OneKeyLog.info("AppUpdate", "clearCache: found ${filesToDelete.size} cached file(s) to delete in ${apkDir.absolutePath}")
-                    var deletedCount = 0
-                    filesToDelete.forEach { file ->
-                        val size = file.length()
-                        if (file.delete()) {
-                            OneKeyLog.debug("AppUpdate", "clearCache: deleted ${file.name} (${size} bytes)")
-                            deletedCount++
-                        } else {
-                            OneKeyLog.warn("AppUpdate", "clearCache: failed to delete ${file.name}")
-                        }
-                    }
-                    OneKeyLog.info("AppUpdate", "clearCache: completed, deleted $deletedCount/${filesToDelete.size} files")
-                } else {
-                    OneKeyLog.info("AppUpdate", "clearCache: apks cache directory does not exist, nothing to clean")
-                }
-            } else {
-                OneKeyLog.warn("AppUpdate", "clearCache: application context unavailable, skipping file cleanup")
+            wipeApkCacheFiles("clearCache")
+        }
+    }
+
+    override fun clearApkCache(): Promise<Unit> {
+        return Promise.async {
+            // Wipe downloaded APK artifacts from cacheDir/apks/ only. The JS
+            // layer gates on app-update status before calling, but that read is
+            // not atomic with this delete, so guard natively too:
+            //  - bail entirely if a download is in flight (would yank its
+            //    .partial/.progress out from under the writer);
+            //  - never delete a verified, pending-install APK (still tracked in
+            //    verifiedFiles) so an open installer keeps a readable file.
+            // Deliberately do NOT touch isDownloading / verifiedFiles state here
+            // (that's clearCache's job). Missing dir/files are tolerated.
+            if (isDownloading.get()) {
+                OneKeyLog.info("AppUpdate", "clearApkCache: download in progress, skipping APK cache cleanup")
+                return@async
             }
+            val protectedPaths = synchronized(verifiedFiles) { verifiedFiles.keys.toSet() }
+            OneKeyLog.info(
+                "AppUpdate",
+                "clearApkCache: starting stale APK cache cleanup (protecting ${protectedPaths.size} verified file(s))...",
+            )
+            wipeApkCacheFiles("clearApkCache", protectedPaths)
         }
     }
 }

package/ios/ReactNativeAppUpdate.swift

@@ -54,6 +54,13 @@ class ReactNativeAppUpdate: HybridReactNativeAppUpdateSpec {
         return Promise.resolved(withResult: ())
     }
 
+    func clearApkCache() throws -> Promise<Void> {
+        // APK is Android-only; nothing to wipe on iOS. Safe no-op so the
+        // cross-platform Nitro spec stays satisfied.
+        OneKeyLog.debug("AppUpdate", "clearApkCache not available on iOS")
+        return Promise.resolved(withResult: ())
+    }
+
     func addDownloadListener(callback: @escaping (DownloadEvent) -> Void) throws -> Double {
         let id = nextListenerId
         nextListenerId += 1

package/lib/typescript/src/ReactNativeAppUpdate.nitro.d.ts

@@ -22,6 +22,7 @@ export interface ReactNativeAppUpdate extends HybridObject<{
     verifyAPK(params: AppUpdateFileParams): Promise<void>;
     installAPK(params: AppUpdateFileParams): Promise<void>;
     clearCache(): Promise<void>;
+    clearApkCache(): Promise<void>;
     testVerification(): Promise<boolean>;
     testSkipVerification(): Promise<boolean>;
     isSkipGpgVerificationAllowed(): boolean;

package/nitrogen/generated/android/c++/JHybridReactNativeAppUpdateSpec.cpp

@@ -149,6 +149,21 @@ namespace margelo::nitro::reactnativeappupdate {
       return __promise;
     }();
   }
+  std::shared_ptr<Promise<void>> JHybridReactNativeAppUpdateSpec::clearApkCache() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearApkCache");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
   std::shared_ptr<Promise<bool>> JHybridReactNativeAppUpdateSpec::testVerification() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("testVerification");
     auto __result = method(_javaPart);

package/nitrogen/generated/android/c++/JHybridReactNativeAppUpdateSpec.hpp

@@ -60,6 +60,7 @@ namespace margelo::nitro::reactnativeappupdate {
     std::shared_ptr<Promise<void>> verifyAPK(const AppUpdateFileParams& params) override;
     std::shared_ptr<Promise<void>> installAPK(const AppUpdateFileParams& params) override;
     std::shared_ptr<Promise<void>> clearCache() override;
+    std::shared_ptr<Promise<void>> clearApkCache() override;
     std::shared_ptr<Promise<bool>> testVerification() override;
     std::shared_ptr<Promise<bool>> testSkipVerification() override;
     bool isSkipGpgVerificationAllowed() override;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativeappupdate/HybridReactNativeAppUpdateSpec.kt

@@ -70,6 +70,10 @@ abstract class HybridReactNativeAppUpdateSpec: HybridObject() {
   @Keep
   abstract fun clearCache(): Promise<Unit>
   
+  @DoNotStrip
+  @Keep
+  abstract fun clearApkCache(): Promise<Unit>
+  
   @DoNotStrip
   @Keep
   abstract fun testVerification(): Promise<Boolean>

package/nitrogen/generated/ios/c++/HybridReactNativeAppUpdateSpecSwift.hpp

@@ -118,6 +118,14 @@ namespace margelo::nitro::reactnativeappupdate {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<void>> clearApkCache() override {
+      auto __result = _swiftPart.clearApkCache();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<bool>> testVerification() override {
       auto __result = _swiftPart.testVerification();
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/HybridReactNativeAppUpdateSpec.swift

@@ -20,6 +20,7 @@ public protocol HybridReactNativeAppUpdateSpec_protocol: HybridObject {
   func verifyAPK(params: AppUpdateFileParams) throws -> Promise<Void>
   func installAPK(params: AppUpdateFileParams) throws -> Promise<Void>
   func clearCache() throws -> Promise<Void>
+  func clearApkCache() throws -> Promise<Void>
   func testVerification() throws -> Promise<Bool>
   func testSkipVerification() throws -> Promise<Bool>
   func isSkipGpgVerificationAllowed() throws -> Bool

package/nitrogen/generated/ios/swift/HybridReactNativeAppUpdateSpec_cxx.swift

@@ -231,6 +231,25 @@ open class HybridReactNativeAppUpdateSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func clearApkCache() -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.clearApkCache()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func testVerification() -> bridge.Result_std__shared_ptr_Promise_bool___ {
     do {

package/nitrogen/generated/shared/c++/HybridReactNativeAppUpdateSpec.cpp

@@ -20,6 +20,7 @@ namespace margelo::nitro::reactnativeappupdate {
       prototype.registerHybridMethod("verifyAPK", &HybridReactNativeAppUpdateSpec::verifyAPK);
       prototype.registerHybridMethod("installAPK", &HybridReactNativeAppUpdateSpec::installAPK);
       prototype.registerHybridMethod("clearCache", &HybridReactNativeAppUpdateSpec::clearCache);
+      prototype.registerHybridMethod("clearApkCache", &HybridReactNativeAppUpdateSpec::clearApkCache);
       prototype.registerHybridMethod("testVerification", &HybridReactNativeAppUpdateSpec::testVerification);
       prototype.registerHybridMethod("testSkipVerification", &HybridReactNativeAppUpdateSpec::testSkipVerification);
       prototype.registerHybridMethod("isSkipGpgVerificationAllowed", &HybridReactNativeAppUpdateSpec::isSkipGpgVerificationAllowed);

package/nitrogen/generated/shared/c++/HybridReactNativeAppUpdateSpec.hpp

@@ -63,6 +63,7 @@ namespace margelo::nitro::reactnativeappupdate {
       virtual std::shared_ptr<Promise<void>> verifyAPK(const AppUpdateFileParams& params) = 0;
       virtual std::shared_ptr<Promise<void>> installAPK(const AppUpdateFileParams& params) = 0;
       virtual std::shared_ptr<Promise<void>> clearCache() = 0;
+      virtual std::shared_ptr<Promise<void>> clearApkCache() = 0;
       virtual std::shared_ptr<Promise<bool>> testVerification() = 0;
       virtual std::shared_ptr<Promise<bool>> testSkipVerification() = 0;
       virtual bool isSkipGpgVerificationAllowed() = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-app-update",
-  "version": "3.0.58",
+  "version": "3.0.59",
   "description": "react-native-app-update",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/ReactNativeAppUpdate.nitro.ts

@@ -24,6 +24,10 @@ export interface ReactNativeAppUpdate
   verifyAPK(params: AppUpdateFileParams): Promise<void>;
   installAPK(params: AppUpdateFileParams): Promise<void>;
   clearCache(): Promise<void>;
+  // Wipe downloaded APK artifacts from cacheDir/apks (.apk / .partial /
+  // .SHA256SUMS.asc). Android-only; the JS layer gates on update status before
+  // calling so this does NOT cancel an in-flight download. iOS is a no-op stub.
+  clearApkCache(): Promise<void>;
 
   // Verification & testing
   testVerification(): Promise<boolean>;