@capgo/capacitor-updater 8.46.3 → 8.47.1

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

@@ -60,6 +60,7 @@ public class CapgoUpdater {
 
     private static final String FALLBACK_VERSION = "pastVersion";
     private static final String NEXT_VERSION = "nextVersion";
+    private static final String PREVIEW_FALLBACK_VERSION = "previewFallbackVersion";
     private static final String bundleDirectory = "versions";
     private static final String TEMP_UNZIP_PREFIX = "capgo_unzip_";
 
@@ -81,6 +82,7 @@ public class CapgoUpdater {
     public String channelUrl = "";
     public String defaultChannel = "";
     public String appId = "";
+    public boolean previewSession = false;
     public String publicKey = "";
     public String deviceID = "";
     public int timeout = 20000;
@@ -124,24 +126,32 @@ public class CapgoUpdater {
     }
 
     private boolean isEmulator() {
+        final String brand = String.valueOf(Build.BRAND);
+        final String device = String.valueOf(Build.DEVICE);
+        final String fingerprint = String.valueOf(Build.FINGERPRINT);
+        final String hardware = String.valueOf(Build.HARDWARE);
+        final String model = String.valueOf(Build.MODEL);
+        final String manufacturer = String.valueOf(Build.MANUFACTURER);
+        final String product = String.valueOf(Build.PRODUCT);
+
         return (
-            (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic")) ||
-            Build.FINGERPRINT.startsWith("generic") ||
-            Build.FINGERPRINT.startsWith("unknown") ||
-            Build.HARDWARE.contains("goldfish") ||
-            Build.HARDWARE.contains("ranchu") ||
-            Build.MODEL.contains("google_sdk") ||
-            Build.MODEL.contains("Emulator") ||
-            Build.MODEL.contains("Android SDK built for x86") ||
-            Build.MANUFACTURER.contains("Genymotion") ||
-            Build.PRODUCT.contains("sdk_google") ||
-            Build.PRODUCT.contains("google_sdk") ||
-            Build.PRODUCT.contains("sdk") ||
-            Build.PRODUCT.contains("sdk_x86") ||
-            Build.PRODUCT.contains("sdk_gphone64_arm64") ||
-            Build.PRODUCT.contains("vbox86p") ||
-            Build.PRODUCT.contains("emulator") ||
-            Build.PRODUCT.contains("simulator")
+            (brand.startsWith("generic") && device.startsWith("generic")) ||
+            fingerprint.startsWith("generic") ||
+            fingerprint.startsWith("unknown") ||
+            hardware.contains("goldfish") ||
+            hardware.contains("ranchu") ||
+            model.contains("google_sdk") ||
+            model.contains("Emulator") ||
+            model.contains("Android SDK built for x86") ||
+            manufacturer.contains("Genymotion") ||
+            product.contains("sdk_google") ||
+            product.contains("google_sdk") ||
+            product.contains("sdk") ||
+            product.contains("sdk_x86") ||
+            product.contains("sdk_gphone64_arm64") ||
+            product.contains("vbox86p") ||
+            product.contains("emulator") ||
+            product.contains("simulator")
         );
     }
 
@@ -345,6 +355,137 @@ public class CapgoUpdater {
         }
     }
 
+    private boolean verifyChecksum(final File file, final String expectedHash) {
+        if (expectedHash == null || expectedHash.isEmpty() || file == null || !file.exists()) {
+            return false;
+        }
+        final String actualHash = CryptoCipher.calcChecksum(file);
+        return expectedHash.equalsIgnoreCase(actualHash);
+    }
+
+    private String resolveManifestFileHash(final JSONObject entry, final String sessionKey) {
+        String fileHash = entry.optString("file_hash", "");
+        if (fileHash.isEmpty()) {
+            return "";
+        }
+        if (this.publicKey != null && !this.publicKey.isEmpty() && sessionKey != null && !sessionKey.isEmpty()) {
+            try {
+                fileHash = CryptoCipher.decryptChecksum(fileHash, this.publicKey);
+            } catch (Exception e) {
+                logger.error("Checksum decryption failed while checking missing manifest files");
+                logger.debug("File: " + entry.optString("file_name", "unknown") + ", Error: " + e.getMessage());
+                return "";
+            }
+        }
+        return fileHash;
+    }
+
+    private boolean isManifestEntryAvailableLocally(final JSONObject entry, final String sessionKey) {
+        final String fileName = entry.optString("file_name", "");
+        final String fileHash = resolveManifestFileHash(entry, sessionKey);
+        if (fileName.isEmpty() || fileHash.isEmpty() || this.activity == null) {
+            return false;
+        }
+
+        final File builtinFile = new File(this.activity.getFilesDir(), "public/" + fileName);
+        if (verifyChecksum(builtinFile, fileHash)) {
+            return true;
+        }
+
+        final boolean isBrotli = fileName.endsWith(".br");
+        final String fileNameWithoutPath = new File(fileName).getName();
+        final String cacheBaseName = isBrotli ? fileNameWithoutPath.substring(0, fileNameWithoutPath.length() - 3) : fileNameWithoutPath;
+        final File cacheFolder = new File(this.activity.getCacheDir(), "capgo_downloads");
+        final File cacheFile = new File(cacheFolder, fileHash + "_" + cacheBaseName);
+        if (verifyChecksum(cacheFile, fileHash)) {
+            return true;
+        }
+
+        if (isBrotli) {
+            final File legacyCacheFile = new File(cacheFolder, fileHash + "_" + fileNameWithoutPath);
+            return verifyChecksum(legacyCacheFile, fileHash);
+        }
+
+        return false;
+    }
+
+    public JSONArray getMissingBundleFiles(final JSONArray manifest, final String sessionKey) throws JSONException {
+        final JSONArray missing = new JSONArray();
+        for (int i = 0; i < manifest.length(); i++) {
+            final JSONObject entry = manifest.getJSONObject(i);
+            if (!isManifestEntryAvailableLocally(entry, sessionKey)) {
+                missing.put(entry);
+            }
+        }
+        return missing;
+    }
+
+    public JSONObject missingBundleFilesResult(final JSONArray manifest, final String sessionKey) throws JSONException {
+        final JSONArray missing = getMissingBundleFiles(manifest, sessionKey);
+        final JSONObject ret = new JSONObject();
+        ret.put("missing", missing);
+        ret.put("total", manifest.length());
+        ret.put("missingCount", missing.length());
+        ret.put("reusableCount", manifest.length() - missing.length());
+        return ret;
+    }
+
+    private String manifestSizeUrl(final String updateUrl) {
+        HttpUrl parsed = HttpUrl.parse(updateUrl);
+        if (parsed == null) {
+            return updateUrl;
+        }
+        return parsed.newBuilder().addPathSegment("manifest_size").query(null).build().toString();
+    }
+
+    private JSONObject unavailableBundleSizeResult(final JSONArray manifest, final String error) throws JSONException {
+        final JSONObject ret = new JSONObject();
+        final JSONArray files = new JSONArray();
+        for (int i = 0; i < manifest.length(); i++) {
+            final JSONObject entry = new JSONObject(manifest.getJSONObject(i).toString());
+            entry.put("error", error);
+            files.put(entry);
+        }
+        ret.put("totalSize", 0);
+        ret.put("knownFiles", 0);
+        ret.put("unknownFiles", manifest.length());
+        ret.put("files", files);
+        return ret;
+    }
+
+    public JSONObject getBundleDownloadSize(final String updateUrl, final String version, final JSONArray manifest) throws JSONException {
+        if (manifest.length() == 0) {
+            final JSONObject ret = new JSONObject();
+            ret.put("totalSize", 0);
+            ret.put("knownFiles", 0);
+            ret.put("unknownFiles", 0);
+            ret.put("files", new JSONArray());
+            return ret;
+        }
+
+        final JSONObject json = this.createInfoObject();
+        json.put("version", version != null ? version : "");
+        json.put("manifest", manifest);
+
+        Request request = new Request.Builder()
+            .url(manifestSizeUrl(updateUrl))
+            .post(RequestBody.create(json.toString(), MediaType.get("application/json; charset=utf-8")))
+            .build();
+
+        try (Response response = DownloadService.sharedClient.newCall(request).execute()) {
+            final ResponseBody responseBody = response.body();
+            final String responseData = responseBody != null ? responseBody.string() : "";
+            if (!response.isSuccessful() || responseData.isEmpty()) {
+                return unavailableBundleSizeResult(manifest, "response_error");
+            }
+            return new JSONObject(responseData);
+        } catch (IOException e) {
+            logger.error("Error getting bundle download size");
+            logger.debug("Error: " + e.getMessage());
+            return unavailableBundleSizeResult(manifest, "response_error");
+        }
+    }
+
     private void observeWorkProgress(Context context, String id, boolean setNext) {
         if (!(context instanceof LifecycleOwner)) {
             logger.error("Context is not a LifecycleOwner, cannot observe work progress");
@@ -941,6 +1082,17 @@ public class CapgoUpdater {
             logger.debug("Bundle ID: " + id);
             return false;
         }
+        final BundleInfo previewFallback = this.getPreviewFallbackBundle();
+        if (
+            previewFallback != null &&
+            !previewFallback.isDeleted() &&
+            !previewFallback.isErrorStatus() &&
+            previewFallback.getId().equals(id)
+        ) {
+            logger.error("Cannot delete the preview fallback bundle");
+            logger.debug("Bundle ID: " + id);
+            return false;
+        }
         final BundleInfo next = this.getNextBundle();
         if (next != null && !next.isDeleted() && !next.isErrorStatus() && next.getId().equals(id)) {
             logger.error("Cannot delete the next bundle");
@@ -1081,6 +1233,21 @@ public class CapgoUpdater {
         return true;
     }
 
+    boolean stagePreviewFallbackReload(final BundleInfo bundle) {
+        if (bundle == null || bundle.isErrorStatus()) {
+            return false;
+        }
+        if (bundle.isBuiltin()) {
+            this.setCurrentBundle(new File("public"));
+            return true;
+        }
+        if (!this.bundleExists(bundle.getId())) {
+            return false;
+        }
+        this.setCurrentBundle(this.getBundleDirectory(bundle.getId()));
+        return true;
+    }
+
     void finalizePendingReload(final BundleInfo bundle, final String previousBundleName) {
         if (bundle == null || bundle.isBuiltin()) {
             return;
@@ -1147,12 +1314,20 @@ public class CapgoUpdater {
     public void setSuccess(final BundleInfo bundle, Boolean autoDeletePrevious) {
         this.setBundleStatus(bundle.getId(), BundleStatus.SUCCESS);
         final BundleInfo fallback = this.getFallbackBundle();
+        final BundleInfo previewFallback = this.getPreviewFallbackBundle();
+        final boolean fallbackIsPreviewFallback = previewFallback != null && previewFallback.getId().equals(fallback.getId());
         logger.debug("Fallback bundle is: " + fallback);
         logger.info("Version successfully loaded: " + bundle.getVersionName());
         // Only attempt to delete when the fallback is a different bundle than the
         // currently loaded one. Otherwise we spam logs with "Cannot delete <id>"
         // because delete() protects the current bundle from removal.
-        if (autoDeletePrevious && !fallback.isBuiltin() && fallback.getId() != null && !fallback.getId().equals(bundle.getId())) {
+        if (
+            autoDeletePrevious &&
+            !fallback.isBuiltin() &&
+            fallback.getId() != null &&
+            !fallback.getId().equals(bundle.getId()) &&
+            !fallbackIsPreviewFallback
+        ) {
             final Boolean res = this.delete(fallback.getId());
             if (res) {
                 logger.info("Deleted previous bundle: " + fallback.getVersionName());
@@ -1175,10 +1350,14 @@ public class CapgoUpdater {
     }
 
     private JSONObject createInfoObject() throws JSONException {
+        return this.createInfoObject(null);
+    }
+
+    private JSONObject createInfoObject(final String appIdOverride) throws JSONException {
         JSONObject json = new JSONObject();
         json.put("platform", "android");
         json.put("device_id", this.deviceID);
-        json.put("app_id", this.appId);
+        json.put("app_id", appIdOverride == null || appIdOverride.trim().isEmpty() ? this.appId : appIdOverride);
         json.put("custom_id", this.customId);
         json.put("version_build", this.versionBuild);
         json.put("version_code", this.versionCode);
@@ -1204,7 +1383,7 @@ public class CapgoUpdater {
         if (response.code() == 429) {
             // Send a statistic about the rate limit BEFORE setting the flag
             // Only send once to prevent infinite loop if the stat request itself gets rate limited
-            if (!rateLimitExceeded && !rateLimitStatisticSent) {
+            if (!this.previewSession && !rateLimitExceeded && !rateLimitStatisticSent) {
                 rateLimitStatisticSent = true;
                 sendRateLimitStatistic();
             }
@@ -1362,9 +1541,13 @@ public class CapgoUpdater {
     }
 
     public void getLatest(final String updateUrl, final String channel, final Callback callback) {
+        this.getLatest(updateUrl, channel, null, callback);
+    }
+
+    public void getLatest(final String updateUrl, final String channel, final String appIdOverride, final Callback callback) {
         JSONObject json;
         try {
-            json = this.createInfoObject();
+            json = this.createInfoObject(appIdOverride);
             if (channel != null && json != null) {
                 json.put("defaultChannel", channel);
             }
@@ -1378,7 +1561,9 @@ public class CapgoUpdater {
             return;
         }
 
-        logger.info("Auto-update parameters: " + json);
+        if (logger != null) {
+            logger.info("Auto-update parameters: " + json);
+        }
 
         makeJsonRequest(updateUrl, json, callback);
     }
@@ -1749,6 +1934,13 @@ public class CapgoUpdater {
     }
 
     public void sendStats(final String action, final String versionName, final String oldVersionName, final Map<String, String> metadata) {
+        if (this.previewSession) {
+            if (logger != null) {
+                logger.debug("Skipping sendStats during preview session.");
+            }
+            return;
+        }
+
         // Check if rate limit was exceeded
         if (rateLimitExceeded) {
             logger.debug("Skipping sendStats due to rate limit (429). Stats will resume after app restart.");
@@ -1971,6 +2163,31 @@ public class CapgoUpdater {
         return this.getBundleInfo(id);
     }
 
+    public BundleInfo getPreviewFallbackBundle() {
+        final String id = this.prefs.getString(PREVIEW_FALLBACK_VERSION, null);
+        if (id == null) return null;
+        final BundleInfo bundle = this.getBundleInfo(id);
+        if (bundle.isErrorStatus() || (!bundle.isBuiltin() && !this.bundleExists(id))) {
+            this.setPreviewFallbackBundle(null);
+            return null;
+        }
+        return bundle;
+    }
+
+    public boolean setPreviewFallbackBundle(final String fallback) {
+        if (fallback == null) {
+            this.editor.remove(PREVIEW_FALLBACK_VERSION);
+        } else {
+            final BundleInfo newBundle = this.getBundleInfo(fallback);
+            if (newBundle.isErrorStatus() || (!newBundle.isBuiltin() && !this.bundleExists(fallback))) {
+                return false;
+            }
+            this.editor.putString(PREVIEW_FALLBACK_VERSION, fallback);
+        }
+        this.editor.commit();
+        return true;
+    }
+
     public boolean setNextBundle(final String next) {
         BundleInfo bundleToNotify = null;
         if (next == null) {

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

@@ -66,8 +66,9 @@ public class ShakeMenu implements ShakeDetector.Listener {
 
         isShowing = true;
 
-        // Check if channel selector mode is enabled
-        if (plugin.shakeChannelSelectorEnabled) {
+        if (plugin.hasActivePreviewSession()) {
+            showDefaultMenu();
+        } else if (plugin.shakeChannelSelectorEnabled) {
             showChannelSelector();
         } else {
             showDefaultMenu();
@@ -75,6 +76,98 @@ public class ShakeMenu implements ShakeDetector.Listener {
     }
 
     private void showDefaultMenu() {
+        activity.runOnUiThread(() -> {
+            try {
+                if (!plugin.hasActivePreviewSession()) {
+                    showConfiguredDefaultMenu();
+                    return;
+                }
+                String appName = activity.getPackageManager().getApplicationLabel(activity.getApplicationInfo()).toString();
+                String title = "Preview " + appName + " Menu";
+                String message = "Reload the current preview or leave the test app.";
+                String okButtonTitle = "Leave test app";
+                String reloadButtonTitle = "Reload app";
+                String cancelButtonTitle = "Close menu";
+
+                AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+                builder.setTitle(title);
+                builder.setMessage(message);
+
+                builder.setPositiveButton(okButtonTitle, null);
+                builder.setNeutralButton(reloadButtonTitle, null);
+
+                // Cancel button
+                builder.setNegativeButton(
+                    cancelButtonTitle,
+                    new DialogInterface.OnClickListener() {
+                        public void onClick(DialogInterface dialog, int id) {
+                            logger.info("Shake menu cancelled");
+                            dialog.dismiss();
+                            isShowing = false;
+                        }
+                    }
+                );
+
+                AlertDialog dialog = builder.create();
+                dialog.setOnDismissListener((dialogInterface) -> isShowing = false);
+                dialog.show();
+                dialog
+                    .getButton(AlertDialog.BUTTON_POSITIVE)
+                    .setOnClickListener((view) -> {
+                        setPreviewMenuButtonsEnabled(dialog, false);
+                        new Thread(() -> {
+                            try {
+                                if (!plugin.leavePreviewSessionFromShakeMenu()) {
+                                    activity.runOnUiThread(() -> showError("Could not leave the test app."));
+                                }
+                            } catch (Exception e) {
+                                logger.error("Error leaving test app: " + e.getMessage());
+                                activity.runOnUiThread(() -> showError("Error leaving test app: " + e.getMessage()));
+                            } finally {
+                                activity.runOnUiThread(() -> {
+                                    dialog.dismiss();
+                                    isShowing = false;
+                                });
+                            }
+                        })
+                            .start();
+                    });
+                dialog
+                    .getButton(AlertDialog.BUTTON_NEUTRAL)
+                    .setOnClickListener((view) -> {
+                        setPreviewMenuButtonsEnabled(dialog, false);
+                        new Thread(() -> {
+                            try {
+                                logger.info("Reloading webview");
+                                if (!plugin.reloadPreviewSessionFromShakeMenu()) {
+                                    activity.runOnUiThread(() -> showError("Could not reload the test app."));
+                                }
+                            } catch (Exception e) {
+                                logger.error("Error in Reload action: " + e.getMessage());
+                                activity.runOnUiThread(() -> showError("Error reloading test app: " + e.getMessage()));
+                            } finally {
+                                activity.runOnUiThread(() -> {
+                                    dialog.dismiss();
+                                    isShowing = false;
+                                });
+                            }
+                        })
+                            .start();
+                    });
+            } catch (Exception e) {
+                logger.error("Error showing shake menu: " + e.getMessage());
+                isShowing = false;
+            }
+        });
+    }
+
+    private void setPreviewMenuButtonsEnabled(AlertDialog dialog, boolean enabled) {
+        dialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(enabled);
+        dialog.getButton(AlertDialog.BUTTON_NEUTRAL).setEnabled(enabled);
+        dialog.getButton(AlertDialog.BUTTON_NEGATIVE).setEnabled(enabled);
+    }
+
+    private void showConfiguredDefaultMenu() {
         activity.runOnUiThread(() -> {
             try {
                 String appName = activity.getPackageManager().getApplicationLabel(activity.getApplicationInfo()).toString();
@@ -120,7 +213,6 @@ public class ShakeMenu implements ShakeDetector.Listener {
                                     bridge.setServerAssetPath(path);
                                 }
 
-                                // Try to delete the current bundle
                                 try {
                                     updater.delete(current.getId());
                                 } catch (Exception err) {