@onekeyfe/react-native-app-update 3.0.61 → 3.0.63

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

@@ -1191,53 +1191,6 @@ 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...")
@@ -1247,31 +1200,29 @@ n2DMz6gqk326W6SFynYtvuiXo7wG4Cmn3SuIU8xfv9rJqunpZGYchMd7nZektmEJ
             OneKeyLog.info("AppUpdate", "clearCache: reset download state, cleared $verifiedCount verified file entries")
 
             // Clean up downloaded APK and ASC files from cacheDir/apks/ directory
-            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 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")
             }
-            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,13 +54,6 @@ 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,7 +22,6 @@ 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,21 +149,6 @@ 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,7 +60,6 @@ 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,10 +70,6 @@ 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,14 +118,6 @@ 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,7 +20,6 @@ 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,25 +231,6 @@ 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,7 +20,6 @@ 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,7 +63,6 @@ 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.61",
+  "version": "3.0.63",
   "description": "react-native-app-update",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/ReactNativeAppUpdate.nitro.ts

@@ -24,10 +24,6 @@ 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>;