@capgo/capacitor-updater 8.52.0 → 8.52.1-beta.pr937.1951.1

package/CapgoCapacitorUpdater.podspec

@@ -11,6 +11,8 @@ Pod::Spec.new do |s|
   s.author = package['author']
   s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
   s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  # Shared Rust updater core (core/), built by scripts/build-core.sh ios.
+  s.vendored_frameworks = 'ios/Frameworks/CapgoUpdaterCore.xcframework'
   s.ios.deployment_target = '15.0'
   s.dependency 'Capacitor'
   s.swift_version = '5.1'

package/Package.swift

@@ -13,9 +13,14 @@ let package = Package(
         .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0")
     ],
     targets: [
+        // Shared Rust updater core (core/), built by scripts/build-core.sh ios.
+        .binaryTarget(
+            name: "CapgoUpdaterCore",
+            path: "ios/Frameworks/CapgoUpdaterCore.xcframework"),
         .target(
             name: "CapacitorUpdaterPlugin",
             dependencies: [
+                "CapgoUpdaterCore",
                 .product(name: "Capacitor", package: "capacitor-swift-pm"),
                 .product(name: "Cordova", package: "capacitor-swift-pm")
             ],

package/README.md

@@ -86,7 +86,7 @@ First follow the migration guide of Capacitor:
 
 The minimum iOS version is now **15.0** to match Capacitor 7/8 requirements.
 
-The plugin has no third-party iOS dependencies besides Capacitor: ZIP extraction uses a built-in reader on top of Apple's native `Compression` framework, and networking uses `URLSession`.
+The plugin has no third-party iOS dependencies besides Capacitor: the updater logic (downloads, ZIP extraction, decryption, checksums, bundle storage) runs in the shared Rust core, also used on Android, shipped prebuilt as `CapgoUpdaterCore.xcframework`. It has its own HTTPS client (rustls) that checks certificates against the system trust store.
 
 ## Compatibility
 
@@ -312,7 +312,7 @@ CapacitorUpdater can be configured with these options:
 | Prop                                   | Type                                                                                                       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Default                                                                       | Since   |
 | -------------------------------------- | ---------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ------- |
 | **`appReadyTimeout`**                  | <code>number</code>                                                                                        | Configure the number of milliseconds the native plugin should wait before considering an update 'failed'. Only available for Android and iOS.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | <code>10000 // (10 seconds)</code>                                            |         |
-| **`responseTimeout`**                  | <code>number</code>                                                                                        | Configure the number of seconds the native plugin should wait before considering an HTTP timeout. Applies to update checks and file downloads. On Android these are idle connect/read/write timeouts and do not cap total download time; on iOS the request timeout also bounds the total download duration. Only available for Android and iOS.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | <code>20 // (20 second)</code>                                                |         |
+| **`responseTimeout`**                  | <code>number</code>                                                                                        | Configure the number of seconds the native plugin should wait before considering an HTTP timeout. Applies to update checks, channel and statistics requests, and file downloads. On Android and iOS these are idle connect/read/write timeouts: they do not cap the total download time. Bundle and preview payload transfers always allow at least 60 seconds per read. Only available for Android and iOS.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | <code>20 // (20 second)</code>                                                |         |
 | **`autoDeleteFailed`**                 | <code>boolean</code>                                                                                       | Configure whether the plugin should use automatically delete failed bundles. Only available for Android and iOS.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | <code>true</code>                                                             |         |
 | **`autoDeletePrevious`**               | <code>boolean</code>                                                                                       | Configure whether the plugin should use automatically delete previous bundles after a successful update. Only available for Android and iOS.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | <code>true</code>                                                             |         |
 | **`autoUpdate`**                       | <code>boolean \| 'always' \| 'off' \| 'atBackground' \| 'atInstall' \| 'onLaunch' \| 'onlyDownload'</code> | Configure how the plugin checks for, downloads, and applies live updates. The plugin checks for updates when the app moves to the foreground. When {@link periodCheckDelay} is greater than 0, it also checks on a repeating timer while the app stays open. Boolean values keep their existing behavior: - `true`: Same as `"atBackground"`. - `false`: Same as `"off"`. String values merge the previous Auto Update and Direct Update configuration: - `"off"`: Disable automatic update checks. - `"atBackground"`: Check and download automatically on each foreground check, then apply the update the next time the app moves to background. - `"atInstall"`: Apply immediately only after a fresh install or native app store update; otherwise use `"atBackground"` behavior. - `"onLaunch"`: Apply immediately only when the app is brought to the foreground from a killed state (cold start). After that first check, fall back to `"atBackground"` behavior. - `"always"`: Check on every foreground transition and apply immediately whenever an update is available. - `"onlyDownload"`: Check and download automatically, emit `updateAvailable`, and never set the next bundle or apply an update automatically. Instant apply modes (`"atInstall"`, `"onLaunch"`, `"always"`) apply while the user is waiting. Upload with `npx @capgo/cli@latest bundle upload --delta` so only changed files download. A full zip upload slows the user experience. These modes require `autoSplashscreen: true` and `@capacitor/splash-screen` installed with `launchAutoHide: false`. Only available for Android and iOS. | <code>true</code>                                                             |         |

package/android/build.gradle

@@ -1,9 +1,6 @@
 ext {
     junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
     androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
-    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.3.0'
-    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.7.0'
-    okhttpVersion = project.hasProperty('okhttpVersion') ? rootProject.ext.okhttpVersion : '4.12.0'
 }
 
 buildscript {
@@ -26,7 +23,7 @@ android {
         targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
         versionCode 1
         versionName "1.0"
-        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        consumerProguardFiles "consumer-rules.pro"
     }
     buildTypes {
         release {
@@ -57,17 +54,100 @@ dependencies {
     implementation "com.google.android.gms:play-services-tasks:18.4.1"
     implementation fileTree(dir: 'libs', include: ['*.jar'])
     implementation project(':capacitor-android')
+    // BridgeActivity extends AppCompatActivity: the plugin needs AppCompat on its compile classpath.
     implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
     // Play Core library for in-app updates
     implementation 'com.google.android.play:app-update:2.1.0'
     testImplementation "junit:junit:$junitVersion"
-    testImplementation 'org.mockito:mockito-core:5.23.0'
+    testImplementation "androidx.work:work-testing:$work_version"
+    testImplementation 'org.mockito:mockito-core:5.24.0'
     testImplementation 'org.json:json:20250517'
     testImplementation 'org.robolectric:robolectric:4.17'
-    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
-    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
-    implementation 'org.brotli:dec:0.1.2'
-    implementation "com.squareup.okhttp3:okhttp:$okhttpVersion"
+}
+
+// JVM unit tests load the shared Rust core (../core) built for the host machine.
+// The npm package does not ship core/, so app builds never run cargo; they use
+// the prebuilt src/main/jniLibs from scripts/build-core.sh android.
+def capgoCoreDir = file("../core")
+
+// Some ld releases end the indirect symbol table of the host dylib on a 4-byte boundary and
+// put the string table right after it; newer dyld refuses that ("mis-aligned LINKEDIT string
+// pool"). Host test library only: move the string table to an 8-byte boundary and re-sign.
+def alignMachOStringTable = { File dylib ->
+    def read = { java.nio.ByteBuffer.wrap(dylib.bytes).order(java.nio.ByteOrder.LITTLE_ENDIAN) }
+    def stringTableOffset = { java.nio.ByteBuffer buffer ->
+        int offset = 32
+        for (int index = 0; index < buffer.getInt(16); index++) {
+            if (buffer.getInt(offset) == 0x2) {
+                return offset
+            }
+            offset += buffer.getInt(offset + 4)
+        }
+        return -1
+    }
+    def buffer = read()
+    if (buffer.getInt(0) != (int) 0xfeedfacf) {
+        return
+    }
+    int symtab = stringTableOffset(buffer)
+    if (symtab < 0 || buffer.getInt(symtab + 16) % 8 == 0) {
+        return
+    }
+    def sign = { List<String> args ->
+        def process = (["codesign"] + args + [dylib.absolutePath]).execute()
+        process.waitForProcessOutput(System.out, System.err)
+        if (process.exitValue() != 0) {
+            throw new GradleException("codesign ${args} failed for ${dylib}")
+        }
+    }
+    sign(["--remove-signature"])
+    buffer = read()
+    int stroff = buffer.getInt(symtab + 16)
+    int pad = 8 - stroff % 8
+    byte[] original = buffer.array()
+    byte[] patched = new byte[original.length + pad]
+    System.arraycopy(original, 0, patched, 0, stroff)
+    System.arraycopy(original, stroff, patched, stroff + pad, original.length - stroff)
+    def out = java.nio.ByteBuffer.wrap(patched).order(java.nio.ByteOrder.LITTLE_ENDIAN)
+    out.putInt(symtab + 16, stroff + pad)
+    int offset = 32
+    for (int index = 0; index < out.getInt(16); index++) {
+        if (out.getInt(offset) == 0x19 && new String(patched, offset + 8, 10, "US-ASCII") == "__LINKEDIT") {
+            long filesize = out.getLong(offset + 48) + pad
+            out.putLong(offset + 48, filesize)
+            out.putLong(offset + 32, Math.max(out.getLong(offset + 32), (filesize + 0x3fff) & ~0x3fffL))
+        }
+        offset += out.getInt(offset + 4)
+    }
+    dylib.bytes = patched
+    sign(["-s", "-", "-f"])
+}
+
+if (capgoCoreDir.exists()) {
+    def capgoCoreHostLibDir = new File(capgoCoreDir, "target/host/release")
+    def buildCapgoCoreHost = tasks.register("buildCapgoCoreHost", Exec) {
+        description = "Builds the Capgo Rust core for the host JVM (unit tests)"
+        workingDir capgoCoreDir
+        def cargoHome = System.getenv("CARGO_HOME") ?: "${System.getProperty('user.home')}/.cargo"
+        def rustupCargo = new File(cargoHome, "bin/cargo")
+        executable rustupCargo.exists() ? rustupCargo.absolutePath : "cargo"
+        args "build", "--release", "--locked", "--features", "jni", "--target-dir", "target/host"
+        inputs.dir(new File(capgoCoreDir, "src"))
+        inputs.file(new File(capgoCoreDir, "Cargo.toml"))
+        inputs.file(new File(capgoCoreDir, "Cargo.lock"))
+        outputs.dir(capgoCoreHostLibDir)
+        doLast {
+            if (System.getProperty("os.name").toLowerCase().contains("mac")) {
+                alignMachOStringTable(new File(capgoCoreHostLibDir, System.mapLibraryName("capgo_updater_core")))
+            }
+        }
+    }
+    tasks.withType(Test).configureEach {
+        dependsOn buildCapgoCoreHost
+        // Re-run the JVM tests whenever the core library changes.
+        inputs.files(buildCapgoCoreHost)
+        systemProperty "capgo.core.hostLibrary", new File(capgoCoreHostLibDir, System.mapLibraryName("capgo_updater_core")).absolutePath
+    }
 }
 
 tasks.withType(Test) {

package/android/consumer-rules.pro

@@ -0,0 +1,15 @@
+# Applied to apps that use this plugin (consumerProguardFiles).
+
+# The Rust core (JNI) binds its native methods by name and calls the host
+# callbacks by name and signature. R8 cannot see those references.
+-keepclasseswithmembernames,includedescriptorclasses class ee.forgr.capacitor_updater.CapgoCoreNative {
+    native <methods>;
+}
+-keep class ee.forgr.capacitor_updater.CapgoEngineHost { *; }
+-keep class * extends ee.forgr.capacitor_updater.CapgoEngineHost { *; }
+
+# WorkManager stores the worker class name with each queued download: keep it
+# stable so jobs queued before an app update still run after it.
+-keep class ee.forgr.capacitor_updater.CapgoDownloadWorker {
+    public <init>(android.content.Context, androidx.work.WorkerParameters);
+}

package/android/src/main/java/ee/forgr/capacitor_updater/AndroidAppExitReporter.java

@@ -10,83 +10,55 @@ import android.annotation.TargetApi;
 import android.app.ActivityManager;
 import android.app.ApplicationExitInfo;
 import android.content.Context;
-import android.content.SharedPreferences;
 import android.os.Build;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
+import org.json.JSONArray;
+import org.json.JSONObject;
 
+/**
+ * Reads the previous process exits ({@link ApplicationExitInfo}, API 30+) for the engine, which reports the
+ * ones worth a statistic ({@code previousExits} of {@code pluginLoad}). Kept out of the plugin class so older
+ * Android versions never resolve {@link ApplicationExitInfo} while reflecting plugin methods.
+ */
 @TargetApi(Build.VERSION_CODES.R)
 final class AndroidAppExitReporter {
 
+    private static final int MAX_EXITS = 8;
+
     private AndroidAppExitReporter() {}
 
-    static void reportPreviousAppExitReasons(
-        final Context context,
-        final SharedPreferences prefs,
-        final CapgoUpdater implementation,
-        final Logger logger,
-        final String lastReportedAppExitTimestampPrefKey
-    ) {
+    /** Newest first; empty when unavailable. */
+    static JSONArray previousExits(final Context context, final Logger logger) {
+        final JSONArray exits = new JSONArray();
         try {
             final ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             if (activityManager == null) {
-                return;
+                return exits;
             }
-
-            final List<ApplicationExitInfo> exitReasons = activityManager.getHistoricalProcessExitReasons(context.getPackageName(), 0, 8);
-            if (exitReasons == null || exitReasons.isEmpty()) {
-                return;
+            final List<ApplicationExitInfo> infos = activityManager.getHistoricalProcessExitReasons(context.getPackageName(), 0, MAX_EXITS);
+            if (infos == null) {
+                return exits;
             }
-
-            final long lastReportedTimestamp = prefs.getLong(lastReportedAppExitTimestampPrefKey, 0L);
-            long newestReportedTimestamp = lastReportedTimestamp;
-            final BundleInfo current = implementation.getCurrentBundle();
-            final String versionName = current == null ? "" : current.getVersionName();
-
-            for (final ApplicationExitInfo exitInfo : exitReasons) {
-                if (exitInfo == null || exitInfo.getTimestamp() <= lastReportedTimestamp) {
+            for (final ApplicationExitInfo info : infos) {
+                if (info == null) {
                     continue;
                 }
-
-                final String action = CapacitorUpdaterPlugin.statsActionForApplicationExitReason(exitInfo.getReason());
-                if (action == null) {
-                    continue;
-                }
-
-                implementation.sendStats(action, versionName, "", buildApplicationExitMetadata(exitInfo));
-                newestReportedTimestamp = Math.max(newestReportedTimestamp, exitInfo.getTimestamp());
-            }
-
-            if (newestReportedTimestamp > lastReportedTimestamp) {
-                prefs.edit().putLong(lastReportedAppExitTimestampPrefKey, newestReportedTimestamp).apply();
+                exits.put(
+                    new JSONObject()
+                        .put("reason", info.getReason())
+                        .put("status", info.getStatus())
+                        .put("importance", info.getImportance())
+                        .put("timestamp", info.getTimestamp())
+                        .put("pid", info.getPid())
+                        .put("pss", info.getPss())
+                        .put("rss", info.getRss())
+                        .put("processName", info.getProcessName() == null ? "" : info.getProcessName())
+                        .put("description", info.getDescription() == null ? "" : info.getDescription())
+                );
             }
         } catch (final Exception e) {
-            logger.warn("Unable to report previous app exit reason: " + e.getMessage());
+            logger.warn("Unable to read previous app exit reasons: " + e.getMessage());
         }
-    }
-
-    private static Map<String, String> buildApplicationExitMetadata(final ApplicationExitInfo exitInfo) {
-        final Map<String, String> metadata = new HashMap<>();
-        metadata.put("exit_reason", CapacitorUpdaterPlugin.applicationExitReasonName(exitInfo.getReason()));
-        metadata.put("exit_reason_code", Integer.toString(exitInfo.getReason()));
-        metadata.put("exit_status", Integer.toString(exitInfo.getStatus()));
-        metadata.put("exit_importance", Integer.toString(exitInfo.getImportance()));
-        metadata.put("exit_timestamp", Long.toString(exitInfo.getTimestamp()));
-        metadata.put("pid", Integer.toString(exitInfo.getPid()));
-        metadata.put("pss_kb", Long.toString(exitInfo.getPss()));
-        metadata.put("rss_kb", Long.toString(exitInfo.getRss()));
-
-        final String processName = exitInfo.getProcessName();
-        if (processName != null && !processName.isEmpty()) {
-            metadata.put("process_name", CapacitorUpdaterPlugin.truncateStatsMetadataValue(processName, 128));
-        }
-
-        final String description = exitInfo.getDescription();
-        if (description != null && !description.isEmpty()) {
-            metadata.put("exit_description", CapacitorUpdaterPlugin.truncateStatsMetadataValue(description, 512));
-        }
-
-        return metadata;
+        return exits;
     }
 }