@otakit/capacitor-updater 2.3.2 → 3.0.0

package/android/src/main/java/com/otakit/updater/EventOutbox.java

@@ -0,0 +1,174 @@
+package com.otakit.updater;
+
+import android.util.AtomicFile;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+/** A bounded, atomic snapshot. Transport never owns or changes event identity. */
+final class EventOutbox {
+
+  static final int LIMIT = 256;
+  static final long TTL = 7L * 24 * 60 * 60 * 1000;
+
+  static final class Entry {
+
+    final String id, url, appId, body;
+    final long createdAt, nextAt;
+    final int attempts;
+
+    Entry(String url, String appId, String body, long createdAt, int attempts, long nextAt)
+      throws Exception {
+      this.id = new JSONObject(body).getString("eventId");
+      this.url = url;
+      this.appId = appId;
+      this.body = body;
+      this.createdAt = createdAt;
+      this.attempts = attempts;
+      this.nextAt = nextAt;
+    }
+
+    JSONObject json() throws Exception {
+      return new JSONObject()
+        .put("url", url)
+        .put("appId", appId)
+        .put("body", body)
+        .put("createdAt", createdAt)
+        .put("attempts", attempts)
+        .put("nextAt", nextAt);
+    }
+  }
+
+  private final AtomicFile file;
+  private List<Entry> entries = new ArrayList<>();
+
+  EventOutbox(File directory) throws Exception {
+    if (!directory.isDirectory() && !directory.mkdirs()) throw new IOException(
+      "Cannot create event outbox"
+    );
+    file = new AtomicFile(new File(directory, "events.json"));
+    if (!file.getBaseFile().exists() && !new File(file.getBaseFile() + ".bak").exists()) return;
+    byte[] bytes;
+    try (java.io.InputStream input = file.openRead()) {
+      if (file.getBaseFile().length() > 4 * 1024 * 1024) throw new IOException(
+        "Event outbox too large"
+      );
+      java.io.ByteArrayOutputStream buffer = new java.io.ByteArrayOutputStream();
+      byte[] chunk = new byte[8192];
+      int count;
+      while ((count = input.read(chunk)) != -1) {
+        if (buffer.size() + count > 4 * 1024 * 1024) throw new IOException(
+          "Event outbox too large"
+        );
+        buffer.write(chunk, 0, count);
+      }
+      bytes = buffer.toByteArray();
+    }
+    try {
+      JSONArray stored = new JSONArray(new String(bytes, StandardCharsets.UTF_8));
+      for (int i = 0; i < stored.length(); i++) {
+        JSONObject item = stored.getJSONObject(i);
+        entries.add(
+          new Entry(
+            item.getString("url"),
+            item.getString("appId"),
+            item.getString("body"),
+            item.getLong("createdAt"),
+            item.getInt("attempts"),
+            item.getLong("nextAt")
+          )
+        );
+      }
+      if (entries.size() > LIMIT) throw new IllegalStateException("Invalid outbox length");
+    } catch (Exception corrupted) {
+      android.util.Log.w("OtaKit", "Discarding unreadable event outbox");
+      save(new ArrayList<>());
+    }
+  }
+
+  synchronized void enqueue(String url, String appId, String body, long now) throws Exception {
+    if (body.getBytes(StandardCharsets.UTF_8).length > 8192) throw new IOException(
+      "Device event too large"
+    );
+    List<Entry> next = live(now);
+    Entry entry = new Entry(url, appId, body, now, 0, now);
+    for (Entry existing : next) if (existing.id.equals(entry.id)) return;
+    while (next.size() >= LIMIT) next.remove(0);
+    next.add(entry);
+    save(next);
+  }
+
+  synchronized Entry ready(long now) throws Exception {
+    List<Entry> next = live(now);
+    if (next.size() != entries.size()) save(next);
+    for (Entry entry : entries) if (entry.nextAt <= now) return entry;
+    return null;
+  }
+
+  synchronized Long waitMilliseconds(long now) {
+    Long delay = null;
+    for (Entry entry : entries) {
+      long due = Math.min(entry.nextAt, entry.createdAt + TTL);
+      long candidate = Math.max(0, due - now);
+      delay = delay == null ? candidate : Math.min(delay, candidate);
+    }
+    return delay;
+  }
+
+  synchronized void complete(String id, int status, String retryAfter, long now, double random)
+    throws Exception {
+    List<Entry> next = live(now);
+    for (int i = 0; i < next.size(); i++) {
+      Entry entry = next.get(i);
+      if (!entry.id.equals(id)) continue;
+      if (
+        (status >= 200 && status < 300) ||
+        (status >= 300 && status < 500 && status != 408 && status != 425 && status != 429)
+      ) {
+        next.remove(i);
+      } else {
+        int attempts = Math.min(entry.attempts + 1, 20);
+        long backoff = (long) (Math.min(3_600_000, 5000L << Math.min(attempts - 1, 10)) *
+          (0.5 + random));
+        Long serverDelay = DownloadRetry.retryAfterMilliseconds(retryAfter, now);
+        long delay = serverDelay == null ? backoff : Math.max(backoff, serverDelay);
+        long due = delay > Long.MAX_VALUE - now ? Long.MAX_VALUE : now + delay;
+        next.set(i, new Entry(entry.url, entry.appId, entry.body, entry.createdAt, attempts, due));
+      }
+      break;
+    }
+    save(next);
+  }
+
+  private List<Entry> live(long now) {
+    List<Entry> result = new ArrayList<>();
+    for (Entry entry : entries) if (now < entry.createdAt + TTL) result.add(entry);
+    return result;
+  }
+
+  private void save(List<Entry> next) throws Exception {
+    JSONArray data = new JSONArray();
+    for (Entry entry : next) data.put(entry.json());
+    FileOutputStream output = null;
+    byte[] bytes = data.toString().getBytes(StandardCharsets.UTF_8);
+    try {
+      output = file.startWrite();
+      output.write(bytes);
+      output.getFD().sync();
+      file.finishWrite(output);
+      output = null;
+      if (!java.util.Arrays.equals(bytes, file.readFully())) throw new IOException(
+        "Event outbox commit failed"
+      );
+      entries = next;
+    } catch (Exception error) {
+      if (output != null) file.failWrite(output);
+      throw error;
+    }
+  }
+}

package/android/src/main/java/com/otakit/updater/FileDownloader.java

@@ -0,0 +1,80 @@
+package com.otakit.updater;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+final class FileDownloader {
+
+  static File download(URL url, File cacheDirectory, boolean allowInsecureUrls) throws Exception {
+    return download(url, cacheDirectory, allowInsecureUrls, new DownloadRetry());
+  }
+
+  static File download(URL url, File cacheDirectory, boolean allowInsecureUrls, DownloadRetry retry)
+    throws Exception {
+    ManifestClient.requireHTTPS(url, allowInsecureUrls);
+    return retry.run(() -> downloadOnce(url, cacheDirectory));
+  }
+
+  private static File downloadOnce(URL url, File cacheDirectory) throws Exception {
+    HttpURLConnection connection = (HttpURLConnection) DownloadRetry.network(url::openConnection);
+    File destination = null;
+    boolean complete = false;
+    try {
+      connection.setRequestMethod("GET");
+      connection.setConnectTimeout(15_000);
+      connection.setReadTimeout(60_000);
+      connection.setRequestProperty("Accept-Encoding", "identity");
+      int status = DownloadRetry.network(connection::getResponseCode);
+      if (status != 200) {
+        throw new DownloadRetry.HttpFailure(status, connection.getHeaderField("Retry-After"));
+      }
+      destination = File.createTempFile("otakit-", ".zip", cacheDirectory);
+      long receivedBytes = 0;
+      try (
+        InputStream input = DownloadRetry.network(connection::getInputStream);
+        FileOutputStream output = new FileOutputStream(destination)
+      ) {
+        byte[] buffer = new byte[8192];
+        int read;
+        while ((read = DownloadRetry.network(() -> input.read(buffer))) != -1) {
+          if (
+            Thread.currentThread().isInterrupted()
+          ) throw new java.util.concurrent.CancellationException("Download cancelled");
+          output.write(buffer, 0, read);
+          receivedBytes += read;
+        }
+      }
+      String declaredLength = connection.getHeaderField("Content-Length");
+      if (declaredLength != null && declaredLength.matches("[0-9]+")) {
+        long expectedBytes;
+        try {
+          expectedBytes = Long.parseLong(declaredLength);
+        } catch (NumberFormatException invalid) {
+          throw new java.io.IOException("Invalid download Content-Length");
+        }
+        if (receivedBytes != expectedBytes) {
+          throw new DownloadRetry.NetworkFailure(
+            new java.io.EOFException(
+              "body length mismatch; expectedBytes=" +
+                expectedBytes +
+                "; receivedBytes=" +
+                receivedBytes
+            )
+          );
+        }
+      }
+      complete = true;
+      return destination;
+    } finally {
+      // The caller cannot own the file until this method returns successfully.
+      if (!complete && destination != null) {
+        //noinspection ResultOfMethodCallIgnored
+        destination.delete();
+      }
+      connection.disconnect();
+    }
+  }
+}

package/android/src/main/java/com/otakit/updater/ForegroundDeadline.java

@@ -0,0 +1,84 @@
+package com.otakit.updater;
+
+import android.os.Handler;
+import android.os.SystemClock;
+import java.util.function.LongSupplier;
+
+/** Owned by the main thread. Only foreground time consumes the readiness budget. */
+final class ForegroundDeadline {
+
+  interface Scheduler {
+    Runnable schedule(long delayMs, Runnable callback);
+  }
+
+  private final LongSupplier now;
+  private final Scheduler scheduler;
+  private boolean foreground;
+  private long remainingMs;
+  private long startedAt;
+  private long generation;
+  private Runnable action;
+  private Runnable cancelScheduled;
+
+  ForegroundDeadline(Handler handler) {
+    this(SystemClock::uptimeMillis, (delay, callback) -> {
+      handler.postDelayed(callback, delay);
+      return () -> handler.removeCallbacks(callback);
+    });
+  }
+
+  ForegroundDeadline(LongSupplier now, Scheduler scheduler) {
+    this.now = now;
+    this.scheduler = scheduler;
+  }
+
+  void start(long timeoutMs, Runnable action) {
+    cancel();
+    remainingMs = Math.max(0, timeoutMs);
+    this.action = action;
+    arm();
+  }
+
+  void setForeground(boolean value) {
+    if (foreground == value) return;
+    if (foreground && action != null) {
+      remainingMs = Math.max(0, remainingMs - Math.max(0, now.getAsLong() - startedAt));
+    }
+    disarm();
+    foreground = value;
+    arm();
+  }
+
+  void cancel() {
+    disarm();
+    action = null;
+    remainingMs = 0;
+  }
+
+  private void disarm() {
+    generation++;
+    if (cancelScheduled != null) cancelScheduled.run();
+    cancelScheduled = null;
+  }
+
+  private void arm() {
+    if (!foreground || action == null) return;
+    startedAt = now.getAsLong();
+    long expectedGeneration = ++generation;
+    cancelScheduled = scheduler.schedule(remainingMs, () -> fire(expectedGeneration));
+  }
+
+  private void fire(long expectedGeneration) {
+    if (generation != expectedGeneration || !foreground || action == null) return;
+    remainingMs = Math.max(0, remainingMs - Math.max(0, now.getAsLong() - startedAt));
+    cancelScheduled = null;
+    if (remainingMs > 0) {
+      arm();
+      return;
+    }
+    Runnable expired = action;
+    action = null;
+    generation++;
+    expired.run();
+  }
+}

package/android/src/main/java/com/otakit/updater/HashUtils.java

@@ -45,4 +45,30 @@ final class HashUtils {
   static boolean verify(File file, String expectedSha256) throws Exception {
     return sha256(file).equalsIgnoreCase(expectedSha256);
   }
+
+  static void verifyDownload(File file, String expectedSha256, long expectedBytes, String kind)
+    throws Exception {
+    String actual = sha256(file);
+    boolean hashMatches = actual.equalsIgnoreCase(expectedSha256);
+    boolean sizeMatches = expectedBytes < 0 || expectedBytes == file.length();
+    if (!hashMatches || !sizeMatches) {
+      String safeExpected =
+        expectedSha256 != null && expectedSha256.matches("[a-fA-F0-9]{64}")
+          ? expectedSha256.toLowerCase(java.util.Locale.ROOT)
+          : "invalid";
+      throw new IllegalStateException(
+        "Downloaded " +
+          kind +
+          (hashMatches ? " size mismatch" : " hash mismatch") +
+          "; expectedSha256=" +
+          safeExpected +
+          "; actualSha256=" +
+          actual +
+          "; expectedBytes=" +
+          expectedBytes +
+          "; receivedBytes=" +
+          file.length()
+      );
+    }
+  }
 }

package/android/src/main/java/com/otakit/updater/ManifestClient.java

@@ -10,6 +10,16 @@ import org.json.JSONObject;
 
 final class ManifestClient {
 
+  static final class HttpFailure extends Exception {
+
+    final int status;
+
+    HttpFailure(int status) {
+      super("Latest request failed (" + status + ")");
+      this.status = status;
+    }
+  }
+
   private static final String BASE_CHANNEL_KEY = "__base__";
   private static final String DEFAULT_RUNTIME_KEY = "__default__";
 
@@ -155,12 +165,7 @@ final class ManifestClient {
         return null;
       }
       if (status != 200) {
-        String body = readStream(
-          connection.getErrorStream() != null
-            ? connection.getErrorStream()
-            : connection.getInputStream()
-        );
-        throw new IllegalStateException("Latest request failed (" + status + "): " + body);
+        throw new HttpFailure(status);
       }
 
       String payload = readStream(connection.getInputStream());
@@ -230,9 +235,7 @@ final class ManifestClient {
 
       if (manifestKeys != null && !manifestKeys.isEmpty()) {
         if (signature == null) {
-          throw new IllegalStateException(
-            "Manifest signature missing but signing keys are configured"
-          );
+          throw new ManifestVerifier.VerificationException("signature_missing");
         }
 
         ManifestVerifier.verify(

package/android/src/main/java/com/otakit/updater/ManifestKeyConfig.java

@@ -0,0 +1,47 @@
+package com.otakit.updater;
+
+import android.util.Base64;
+import java.util.ArrayList;
+import java.util.List;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+/** Empty means intentionally unconfigured; malformed explicit settings must never return empty. */
+final class ManifestKeyConfig {
+
+  private ManifestKeyConfig() {}
+
+  static List<ManifestVerifier.KeyEntry> parse(JSONObject config) {
+    List<ManifestVerifier.KeyEntry> keys = new ArrayList<>();
+    try {
+      Object raw = config.opt("manifestKeys");
+      if (raw == null) return keys;
+      if (!(raw instanceof JSONArray)) return invalid();
+      JSONArray entries = (JSONArray) raw;
+      if (entries.length() == 0) return keys;
+      for (int i = 0; i < entries.length(); i++) {
+        JSONObject entry = entries.optJSONObject(i);
+        if (entry == null) continue;
+        String kid = entry.optString("kid", null);
+        String key = entry.optString("key", null);
+        if (kid != null && key != null) {
+          keys.add(new ManifestVerifier.KeyEntry(kid, Base64.decode(key, Base64.DEFAULT)));
+        }
+      }
+      if (keys.isEmpty()) return invalid();
+      return keys;
+    } catch (Exception error) {
+      return invalid();
+    }
+  }
+
+  private static List<ManifestVerifier.KeyEntry> invalid() {
+    android.util.Log.e(
+      "OtaKit",
+      "Invalid manifestKeys configuration. Manifest verification will reject all updates."
+    );
+    return java.util.Collections.singletonList(
+      new ManifestVerifier.KeyEntry("_invalid_", new byte[0])
+    );
+  }
+}

package/android/src/main/java/com/otakit/updater/ManifestVerifier.java

@@ -22,6 +22,16 @@ final class ManifestVerifier {
 
   private ManifestVerifier() {}
 
+  static final class VerificationException extends Exception {
+
+    final String reason;
+
+    VerificationException(String reason) {
+      super("Manifest verification failed: " + reason);
+      this.reason = reason;
+    }
+  }
+
   /**
    * Verify a manifest signature using ES256 (ECDSA P-256 + SHA-256).
    *
@@ -54,7 +64,15 @@ final class ManifestVerifier {
       signature.iat,
       signature.exp
     );
-    verifyPayload(payload, signature, trustedKeys);
+    try {
+      verifyPayload(payload, signature, trustedKeys);
+    } catch (VerificationException error) {
+      throw error;
+    } catch (Exception error) {
+      VerificationException failure = new VerificationException("signature_invalid");
+      failure.initCause(error);
+      throw failure;
+    }
   }
 
   private static void verifyPayload(
@@ -65,7 +83,7 @@ final class ManifestVerifier {
     // Check expiry
     long now = System.currentTimeMillis() / 1000;
     if (signature.exp <= now) {
-      throw new IllegalStateException("Manifest signature expired");
+      throw new VerificationException("signature_expired");
     }
 
     // Find matching key
@@ -77,7 +95,7 @@ final class ManifestVerifier {
       }
     }
     if (keyEntry == null) {
-      throw new IllegalStateException("Unknown signing key ID: " + signature.kid);
+      throw new VerificationException("signature_unknown_key");
     }
 
     // Decode base64url signature
@@ -93,7 +111,7 @@ final class ManifestVerifier {
     verifier.update(payload.getBytes(java.nio.charset.StandardCharsets.UTF_8));
 
     if (!verifier.verify(sigBytes)) {
-      throw new IllegalStateException("Manifest signature verification failed");
+      throw new VerificationException("signature_invalid");
     }
   }
 

package/android/src/main/java/com/otakit/updater/SDKVersion.java

@@ -0,0 +1,9 @@
+package com.otakit.updater;
+
+// Generated from package.json by scripts/generate-native-sdk-version.mjs.
+final class SDKVersion {
+
+  static final String VALUE = "3.0.0";
+
+  private SDKVersion() {}
+}

package/android/src/main/java/com/otakit/updater/UpdateOwner.java

@@ -0,0 +1,27 @@
+package com.otakit.updater;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.CancellationException;
+import java.util.function.BooleanSupplier;
+
+/** Checked on the main thread together with state publication and activation. */
+final class UpdateOwner {
+
+  private final BooleanSupplier isAvailable;
+  private boolean closed;
+
+  UpdateOwner(BooleanSupplier isAvailable) {
+    this.isAvailable = isAvailable;
+  }
+
+  void close() {
+    closed = true;
+  }
+
+  <T> T run(Callable<T> action) throws Exception {
+    if (closed || !isAvailable.getAsBoolean()) throw new CancellationException(
+      "Updater bridge is no longer active"
+    );
+    return action.call();
+  }
+}