@capgo/cordova-updater 8.1.4 → 8.2.1

package/src/android/app/capgo/cordova/updater/Version.java

@@ -0,0 +1,312 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * Parsing and comparison logic ported from version-compare 1.5.0
+ * (https://github.com/G00fY2/version-compare), Copyright G00fY2,
+ * licensed under the Apache License, Version 2.0
+ * (https://www.apache.org/licenses/LICENSE-2.0).
+ */
+
+package app.capgo.cordova.updater;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Lenient version parser and comparator.
+ *
+ * <p>Behavior-compatible port of {@code io.github.g00fy2:versioncompare:1.5.0} (Apache-2.0), kept in-repo so the
+ * plugin does not ship an extra third-party dependency. Parsing never throws for non-null input that starts with a
+ * digit; unparsable input (null or not starting with a digit) yields an empty version equal to {@code 0}.
+ *
+ * <p>Pre-release suffix ordering: {@code snapshot < pre-alpha < alpha < beta < rc < stable}, with an optional number
+ * right after the qualifier ({@code 1.0.0-rc2 > 1.0.0-rc1}).
+ */
+public class Version implements Comparable<Version> {
+
+    enum ReleaseType {
+        SNAPSHOT,
+        PRE_ALPHA,
+        ALPHA,
+        BETA,
+        RC,
+        STABLE
+    }
+
+    private static final String SNAPSHOT_STRING = "snapshot";
+    private static final String PRE_STRING = "pre";
+    private static final String ALPHA_STRING = "alpha";
+    private static final String BETA_STRING = "beta";
+    private static final String RC_STRING = "rc";
+
+    @Nullable
+    private final String originalString;
+
+    private final List<Long> subversionNumbers = new ArrayList<>();
+    private final List<Long> trimmedSubversionNumbers = new ArrayList<>();
+    private final String suffix;
+    private final ReleaseType releaseType;
+    private final long preReleaseVersion;
+
+    public Version(@Nullable String versionString) {
+        originalString = versionString;
+        if (originalString != null && startsNumeric(originalString)) {
+            String normalized = originalString.replaceAll("\\s", "");
+            final int buildMetadata = normalized.indexOf('+');
+            if (buildMetadata >= 0) {
+                normalized = normalized.substring(0, buildMetadata);
+            }
+            String[] versionTokens = normalized.split("\\.");
+            boolean suffixFound = false;
+            StringBuilder suffixSb = null;
+
+            for (String versionToken : versionTokens) {
+                if (suffixFound) {
+                    suffixSb.append(".");
+                    suffixSb.append(versionToken);
+                } else if (isNumeric(versionToken)) {
+                    subversionNumbers.add(safeParseLong(versionToken));
+                } else {
+                    for (int i = 0; i < versionToken.length(); i++) {
+                        if (!Character.isDigit(versionToken.charAt(i))) {
+                            suffixSb = new StringBuilder();
+                            if (i > 0) {
+                                subversionNumbers.add(safeParseLong(versionToken.substring(0, i)));
+                                suffixSb.append(versionToken.substring(i));
+                            } else {
+                                suffixSb.append(versionToken);
+                            }
+                            suffixFound = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            suffix = (suffixSb != null) ? suffixSb.toString() : "";
+            trimmedSubversionNumbers.addAll(subversionNumbers);
+            while (!trimmedSubversionNumbers.isEmpty() && trimmedSubversionNumbers.get(trimmedSubversionNumbers.size() - 1) == 0L) {
+                trimmedSubversionNumbers.remove(trimmedSubversionNumbers.size() - 1);
+            }
+        } else {
+            suffix = "";
+        }
+        releaseType = qualifierToReleaseType(suffix);
+        preReleaseVersion = preReleaseVersion(suffix, releaseType);
+    }
+
+    public long getMajor() {
+        return trimmedSubversionNumbers.size() > 0 ? trimmedSubversionNumbers.get(0) : 0L;
+    }
+
+    public long getMinor() {
+        return trimmedSubversionNumbers.size() > 1 ? trimmedSubversionNumbers.get(1) : 0L;
+    }
+
+    public long getPatch() {
+        return trimmedSubversionNumbers.size() > 2 ? trimmedSubversionNumbers.get(2) : 0L;
+    }
+
+    @NonNull
+    public List<Long> getSubversionNumbers() {
+        return subversionNumbers;
+    }
+
+    @NonNull
+    public String getSuffix() {
+        return suffix;
+    }
+
+    @Nullable
+    public String getOriginalString() {
+        return originalString;
+    }
+
+    public boolean isHigherThan(String otherVersion) {
+        return isHigherThan(new Version(otherVersion));
+    }
+
+    public boolean isHigherThan(Version otherVersion) {
+        return compareTo(otherVersion) > 0;
+    }
+
+    public boolean isLowerThan(String otherVersion) {
+        return isLowerThan(new Version(otherVersion));
+    }
+
+    public boolean isLowerThan(Version otherVersion) {
+        return compareTo(otherVersion) < 0;
+    }
+
+    public boolean isEqual(String otherVersion) {
+        return isEqual(new Version(otherVersion));
+    }
+
+    public boolean isEqual(Version otherVersion) {
+        return compareTo(otherVersion) == 0;
+    }
+
+    public boolean isAtLeast(String otherVersion) {
+        return isAtLeast(new Version(otherVersion));
+    }
+
+    public boolean isAtLeast(Version otherVersion) {
+        return compareTo(otherVersion) >= 0;
+    }
+
+    public boolean isAtLeast(String otherVersion, boolean ignoreSuffix) {
+        return isAtLeast(new Version(otherVersion), ignoreSuffix);
+    }
+
+    public boolean isAtLeast(Version otherVersion, boolean ignoreSuffix) {
+        return compareTo(otherVersion, ignoreSuffix) >= 0;
+    }
+
+    @Override
+    public final int compareTo(@NonNull Version version) {
+        return compareTo(version, false);
+    }
+
+    private int compareTo(@NonNull Version version, boolean ignoreSuffix) {
+        int versionNumberResult = compareSubversionNumbers(trimmedSubversionNumbers, version.trimmedSubversionNumbers);
+        if (versionNumberResult != 0 || ignoreSuffix) {
+            return versionNumberResult;
+        }
+        int releaseTypeResult = releaseType.compareTo(version.releaseType);
+        if (releaseTypeResult != 0) {
+            return releaseTypeResult;
+        }
+        return Long.compare(preReleaseVersion, version.preReleaseVersion);
+    }
+
+    @Override
+    public final boolean equals(Object o) {
+        return o instanceof Version && isEqual((Version) o);
+    }
+
+    @Override
+    public final int hashCode() {
+        int result = trimmedSubversionNumbers.hashCode();
+        result = 31 * result + releaseType.hashCode();
+        result = 31 * result + (int) (preReleaseVersion ^ (preReleaseVersion >>> 32));
+        return result;
+    }
+
+    @NonNull
+    @Override
+    public String toString() {
+        return String.valueOf(originalString);
+    }
+
+    // helpers
+
+    private static int compareSubversionNumbers(@NonNull final List<Long> versionNumbersA, @NonNull final List<Long> versionNumbersB) {
+        final int numbersSizeA = versionNumbersA.size();
+        final int numbersSizeB = versionNumbersB.size();
+        final int maxSize = Math.max(numbersSizeA, numbersSizeB);
+
+        for (int i = 0; i < maxSize; i++) {
+            final long a = i < numbersSizeA ? versionNumbersA.get(i) : 0L;
+            final long b = i < numbersSizeB ? versionNumbersB.get(i) : 0L;
+            if (a > b) {
+                return 1;
+            } else if (a < b) {
+                return -1;
+            }
+        }
+        return 0;
+    }
+
+    static ReleaseType qualifierToReleaseType(@NonNull String suffix) {
+        if (suffix.length() > 0) {
+            suffix = suffix.toLowerCase(Locale.ROOT);
+            if (suffix.contains(RC_STRING)) return ReleaseType.RC;
+            if (suffix.contains(BETA_STRING)) return ReleaseType.BETA;
+            if (suffix.contains(ALPHA_STRING)) {
+                if (suffix.substring(0, suffix.indexOf(ALPHA_STRING)).contains(PRE_STRING)) {
+                    return ReleaseType.PRE_ALPHA;
+                }
+                return ReleaseType.ALPHA;
+            }
+            if (suffix.contains(SNAPSHOT_STRING)) return ReleaseType.SNAPSHOT;
+        }
+        return ReleaseType.STABLE;
+    }
+
+    private static long preReleaseVersion(@NonNull final String suffix, final ReleaseType releaseType) {
+        if (releaseType == ReleaseType.STABLE || releaseType == ReleaseType.SNAPSHOT) return 0;
+
+        final int startIndex = indexOfQualifier(suffix, releaseType);
+        if (startIndex < suffix.length()) {
+            final int maxStartIndex = Math.min(startIndex + 2, suffix.length());
+            if (containsNumeric(suffix.substring(startIndex, maxStartIndex))) {
+                final StringBuilder versionNumber = new StringBuilder();
+                for (int i = startIndex; i < suffix.length(); i++) {
+                    final char c = suffix.charAt(i);
+                    if (Character.isDigit(c)) {
+                        versionNumber.append(c);
+                    } else if (i != startIndex) {
+                        break;
+                    }
+                }
+                return safeParseLong(versionNumber.toString());
+            }
+        }
+        return 0;
+    }
+
+    private static int indexOfQualifier(@NonNull String suffix, final ReleaseType releaseType) {
+        suffix = suffix.toLowerCase(Locale.ROOT);
+        switch (releaseType) {
+            case RC:
+                return suffix.indexOf(RC_STRING) + RC_STRING.length();
+            case BETA:
+                return suffix.indexOf(BETA_STRING) + BETA_STRING.length();
+            case ALPHA:
+            case PRE_ALPHA:
+                return suffix.indexOf(ALPHA_STRING) + ALPHA_STRING.length();
+            default:
+                return 0;
+        }
+    }
+
+    private static boolean startsNumeric(@NonNull String str) {
+        str = str.trim();
+        return str.length() > 0 && Character.isDigit(str.charAt(0));
+    }
+
+    private static long safeParseLong(@NonNull String numbers) {
+        try {
+            return Long.parseLong(numbers);
+        } catch (NumberFormatException e) {
+            return Long.MAX_VALUE;
+        }
+    }
+
+    private static boolean isNumeric(@NonNull final CharSequence cs) {
+        final int sz = cs.length();
+        if (sz > 0) {
+            for (int i = 0; i < sz; i++) {
+                if (!Character.isDigit(cs.charAt(i))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    private static boolean containsNumeric(@NonNull final CharSequence cs) {
+        final int sz = cs.length();
+        for (int i = 0; i < sz; i++) {
+            if (Character.isDigit(cs.charAt(i))) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/src/android/capgo-cordova-updater.gradle

@@ -5,15 +5,13 @@ repositories {
 }
 
 dependencies {
-    implementation "androidx.work:work-runtime:2.10.5"
-    implementation "androidx.lifecycle:lifecycle-process:2.10.0"
+    implementation "androidx.work:work-runtime:2.12.0"
+    implementation "androidx.lifecycle:lifecycle-process:2.11.0"
     implementation "com.google.android.gms:play-services-tasks:18.4.1"
-    implementation "com.google.guava:guava:33.6.0-android"
-    implementation "io.github.g00fy2:versioncompare:1.5.0"
     implementation "com.google.android.play:app-update:2.1.0"
     implementation "com.google.android.play:app-update-ktx:2.1.0"
     implementation "org.brotli:dec:0.1.2"
     implementation "com.squareup.okhttp3:okhttp:4.12.0"
-    implementation "androidx.webkit:webkit:1.11.0"
+    implementation "androidx.webkit:webkit:1.17.1"
     implementation "androidx.appcompat:appcompat:1.7.1"
 }

package/src/android/test/app/capgo/cordova/updater/BackgroundDownloadSettlementTest.java

@@ -0,0 +1,29 @@
+package app.capgo.cordova.updater;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(manifest = Config.NONE)
+public class BackgroundDownloadSettlementTest {
+
+    @Test
+    public void acceptsMatchingSettlementToken() {
+        assertTrue(CordovaUpdaterPlugin.shouldAcceptBackgroundDownloadSettlement(3L, 3L));
+    }
+
+    @Test
+    public void rejectsStaleSettlementToken() {
+        assertFalse(CordovaUpdaterPlugin.shouldAcceptBackgroundDownloadSettlement(2L, 3L));
+    }
+
+    @Test
+    public void rejectsUnsetSettlementToken() {
+        assertFalse(CordovaUpdaterPlugin.shouldAcceptBackgroundDownloadSettlement(0L, 3L));
+    }
+}

package/src/android/test/app/capgo/cordova/updater/CapacitorUpdaterUnitTest.java.skip

@@ -281,17 +281,6 @@ public class CapacitorUpdaterUnitTest {
             return this.existingLatestBundle;
         }
 
-        @Override
-        public void downloadBackground(
-            final String url,
-            final String version,
-            final String sessionKey,
-            final String checksum,
-            final JSONArray manifest
-        ) {
-            this.downloadBackground(url, version, sessionKey, checksum, manifest, true);
-        }
-
         @Override
         public void downloadBackground(
             final String url,
@@ -299,7 +288,8 @@ public class CapacitorUpdaterUnitTest {
             final String sessionKey,
             final String checksum,
             final JSONArray manifest,
-            final boolean setNext
+            final boolean setNext,
+            final long settlementToken
         ) {
             this.downloadBackgroundCalled = true;
             this.downloadBackgroundSetNext = setNext;

package/src/android/test/app/capgo/cordova/updater/DelayUpdateUtilsTest.java

@@ -7,7 +7,6 @@ import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.*;
 
 import android.content.SharedPreferences;
-import io.github.g00fy2.versioncompare.Version;
 import java.util.ArrayList;
 import org.json.JSONArray;
 import org.json.JSONObject;

package/src/android/test/app/capgo/cordova/updater/RsaContractTest.java

@@ -0,0 +1,137 @@
+package app.capgo.cordova.updater;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.security.GeneralSecurityException;
+import java.security.PublicKey;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(manifest = Config.NONE)
+public class RsaContractTest {
+
+    private static JSONObject contract;
+
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        CryptoCipher.setLogger(new Logger("RsaContractTest", new Logger.Options(Logger.LogLevel.silent)));
+        contract = new JSONObject(new String(Files.readAllBytes(contractFile()), StandardCharsets.UTF_8));
+    }
+
+    private static Path contractFile() throws IOException {
+        Path current = Path.of(System.getProperty("user.dir")).toAbsolutePath();
+        while (current != null) {
+            Path candidate = current.resolve("native-contract-tests/crypto-rsa.json");
+            if (Files.exists(candidate)) {
+                return candidate;
+            }
+            current = current.getParent();
+        }
+        throw new IOException("native-contract-tests/crypto-rsa.json not found");
+    }
+
+    private static byte[] hexToBytes(String hex) {
+        final byte[] out = new byte[hex.length() / 2];
+        for (int i = 0; i < out.length; i++) {
+            out[i] = (byte) Integer.parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+        }
+        return out;
+    }
+
+    @Test
+    public void rsaPublicDecryptMatchesNativeContract() throws Exception {
+        final PublicKey publicKey = CryptoCipher.stringToPublicKey(contract.getString("publicKeyPem"));
+        final JSONArray cases = contract.getJSONArray("rsaPublicDecrypt");
+        for (int index = 0; index < cases.length(); index++) {
+            final JSONObject testCase = cases.getJSONObject(index);
+            final String id = testCase.getString("id");
+            final JSONObject input = testCase.getJSONObject("input");
+            final JSONObject expect = testCase.getJSONObject("expect");
+            final byte[] ciphertext = hexToBytes(input.getString("ciphertextHex"));
+            final byte[] expected = hexToBytes(expect.getString("plaintextHex"));
+            final byte[] decrypted = CryptoCipher.decryptRSA(ciphertext, publicKey);
+            assertArrayEquals(id, expected, decrypted);
+        }
+    }
+
+    @Test
+    public void decryptChecksumMatchesNativeContract() throws Exception {
+        final String publicKey = contract.getString("publicKeyPem");
+        final JSONArray cases = contract.getJSONArray("decryptChecksum");
+        for (int index = 0; index < cases.length(); index++) {
+            final JSONObject testCase = cases.getJSONObject(index);
+            final String id = testCase.getString("id");
+            final JSONObject input = testCase.getJSONObject("input");
+            final JSONObject expect = testCase.getJSONObject("expect");
+            final String result = CryptoCipher.decryptChecksum(input.getString("checksumHex"), publicKey);
+            assertEquals(id, expect.getString("decryptedHex"), result);
+        }
+    }
+
+    @Test
+    public void decryptChecksumInvalidMatchesNativeContract() throws Exception {
+        final String publicKey = contract.getString("publicKeyPem");
+        final JSONArray cases = contract.getJSONArray("decryptChecksumInvalid");
+        for (int index = 0; index < cases.length(); index++) {
+            final JSONObject testCase = cases.getJSONObject(index);
+            final String id = testCase.getString("id");
+            final JSONObject input = testCase.getJSONObject("input");
+            final boolean shouldThrow = testCase.getJSONObject("expect").getBoolean("throws");
+            try {
+                CryptoCipher.decryptChecksum(input.getString("checksumHex"), publicKey);
+                if (shouldThrow) {
+                    fail(id + " expected IOException");
+                }
+            } catch (IOException e) {
+                if (!shouldThrow) {
+                    fail(id + " unexpected IOException: " + e.getMessage());
+                }
+            }
+        }
+    }
+
+    @Test
+    public void calcKeyIdMatchesNativeContract() throws Exception {
+        final JSONArray cases = contract.getJSONArray("calcKeyId");
+        for (int index = 0; index < cases.length(); index++) {
+            final JSONObject testCase = cases.getJSONObject(index);
+            final String id = testCase.getString("id");
+            final JSONObject input = testCase.getJSONObject("input");
+            final JSONObject expect = testCase.getJSONObject("expect");
+            assertEquals(id, expect.getString("keyId"), CryptoCipher.calcKeyId(input.getString("publicKeyPem")));
+        }
+    }
+
+    @Test
+    public void rsaPublicKeyLoadMatchesNativeContract() throws Exception {
+        final JSONArray cases = contract.getJSONArray("rsaPublicKeyLoad");
+        for (int index = 0; index < cases.length(); index++) {
+            final JSONObject testCase = cases.getJSONObject(index);
+            final String id = testCase.getString("id");
+            final String publicKeyPem = testCase.getJSONObject("input").getString("publicKeyPem");
+            final boolean shouldLoad = testCase.getJSONObject("expect").getBoolean("loads");
+            boolean loaded = false;
+            try {
+                CryptoCipher.stringToPublicKey(publicKeyPem);
+                loaded = true;
+            } catch (Exception ignored) {
+                loaded = false;
+            }
+            assertEquals(id, shouldLoad, loaded);
+        }
+    }
+}