@capawesome/cordova-live-update 0.1.0

package/src/android/io/capawesome/cordova/plugins/liveupdate/LiveUpdateConfig.java

@@ -0,0 +1,105 @@
+package io.capawesome.cordova.plugins.liveupdate;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.security.Key;
+
+public class LiveUpdateConfig {
+
+    @Nullable
+    private String appId = null;
+
+    private boolean autoBlockRolledBackBundles = false;
+
+    private boolean autoDeleteBundles = false;
+
+    @NonNull
+    private String autoUpdateStrategy = "none";
+
+    @Nullable
+    private String defaultChannel = null;
+
+    private int httpTimeout = 60000;
+
+    @Nullable
+    private String publicKey = null;
+
+    private int readyTimeout = 0;
+    private String serverDomain = "api.cloud.capawesome.io";
+
+    @Nullable
+    public String getAppId() {
+        return appId;
+    }
+
+    public boolean getAutoBlockRolledBackBundles() {
+        return autoBlockRolledBackBundles;
+    }
+
+    public boolean getAutoDeleteBundles() {
+        return autoDeleteBundles;
+    }
+
+    @NonNull
+    public String getAutoUpdateStrategy() {
+        return autoUpdateStrategy;
+    }
+
+    @Nullable
+    public String getDefaultChannel() {
+        return defaultChannel;
+    }
+
+    public int getHttpTimeout() {
+        return httpTimeout;
+    }
+
+    @Nullable
+    public String getPublicKey() {
+        return publicKey;
+    }
+
+    public int getReadyTimeout() {
+        return readyTimeout;
+    }
+
+    public String getServerDomain() {
+        return serverDomain;
+    }
+
+    public void setAppId(@Nullable String appId) {
+        this.appId = appId;
+    }
+
+    public void setAutoBlockRolledBackBundles(boolean autoBlockRolledBackBundles) {
+        this.autoBlockRolledBackBundles = autoBlockRolledBackBundles;
+    }
+
+    public void setAutoDeleteBundles(boolean autoDeleteBundles) {
+        this.autoDeleteBundles = autoDeleteBundles;
+    }
+
+    public void setAutoUpdateStrategy(@NonNull String autoUpdateStrategy) {
+        this.autoUpdateStrategy = autoUpdateStrategy;
+    }
+
+    public void setDefaultChannel(@Nullable String defaultChannel) {
+        this.defaultChannel = defaultChannel;
+    }
+
+    public void setHttpTimeout(int httpTimeout) {
+        this.httpTimeout = httpTimeout;
+    }
+
+    public void setPublicKey(@Nullable String publicKey) {
+        this.publicKey = publicKey;
+    }
+
+    public void setReadyTimeout(int readyTimeout) {
+        this.readyTimeout = readyTimeout;
+    }
+
+    public void setServerDomain(String serverDomain) {
+        this.serverDomain = serverDomain;
+    }
+}

package/src/android/io/capawesome/cordova/plugins/liveupdate/LiveUpdateHttpClient.java

@@ -0,0 +1,114 @@
+package io.capawesome.cordova.plugins.liveupdate;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import io.capawesome.cordova.plugins.liveupdate.interfaces.DownloadProgressCallback;
+import io.capawesome.cordova.plugins.liveupdate.interfaces.EmptyCallback;
+import io.capawesome.cordova.plugins.liveupdate.interfaces.NonEmptyCallback;
+import java.io.File;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import okhttp3.Call;
+import okhttp3.Callback;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+import okio.Buffer;
+import okio.BufferedSink;
+import okio.BufferedSource;
+import okio.Okio;
+
+public class LiveUpdateHttpClient {
+
+    @NonNull
+    private final LiveUpdateConfig config;
+
+    @Nullable
+    private String deviceId;
+
+    @NonNull
+    private final OkHttpClient okHttpClient;
+
+    @Nullable
+    public static String getChecksumFromResponse(Response response) {
+        String checksum = response.header("X-Checksum");
+        if (checksum == null) {
+            return null;
+        }
+        return checksum;
+    }
+
+    @Nullable
+    public static String getSignatureFromResponse(Response response) {
+        String signature = response.header("X-Signature");
+        if (signature == null) {
+            return null;
+        }
+        return signature;
+    }
+
+    public LiveUpdateHttpClient(@NonNull LiveUpdateConfig config) {
+        this.config = config;
+        int httpTimeout = config.getHttpTimeout();
+
+        // Increase max requests per host to allow multiple parallel downloads from the same host
+        okhttp3.Dispatcher dispatcher = new okhttp3.Dispatcher();
+        dispatcher.setMaxRequestsPerHost(30);
+
+        this.okHttpClient = new OkHttpClient.Builder()
+            .dispatcher(dispatcher)
+            .connectTimeout(httpTimeout, TimeUnit.MILLISECONDS)
+            .readTimeout(httpTimeout, TimeUnit.MILLISECONDS)
+            .writeTimeout(httpTimeout, TimeUnit.MILLISECONDS)
+            .build();
+    }
+
+    public void setDeviceId(@NonNull String deviceId) {
+        this.deviceId = deviceId;
+    }
+
+    public Call enqueue(String url, NonEmptyCallback<Response> callback) {
+        Request.Builder builder = new Request.Builder().url(url);
+        if (deviceId != null) {
+            builder.addHeader("X-Capawesome-Device-Id", deviceId);
+        }
+        Request request = builder.build();
+
+        Call call = okHttpClient.newCall(request);
+        call.enqueue(
+            new Callback() {
+                @Override
+                public void onResponse(@NonNull Call call, @NonNull Response response) {
+                    callback.success(response);
+                }
+
+                @Override
+                public void onFailure(@NonNull Call call, @NonNull IOException e) {
+                    callback.error(new Exception(e));
+                }
+            }
+        );
+        return call;
+    }
+
+    public static void writeResponseBodyToFile(ResponseBody body, File file, @Nullable DownloadProgressCallback callback)
+        throws IOException {
+        long contentLength = body.contentLength();
+        BufferedSource source = body.source();
+        BufferedSink sink = Okio.buffer(Okio.sink(file));
+        Buffer sinkBuffer = sink.getBuffer();
+        long totalBytesRead = 0;
+        int bufferSize = 8 * 1024;
+        for (long bytesRead; (bytesRead = source.read(sinkBuffer, bufferSize)) != -1;) {
+            sink.emit();
+            totalBytesRead += bytesRead;
+            if (callback != null) {
+                callback.onProgress(totalBytesRead, contentLength);
+            }
+        }
+        sink.flush();
+        sink.close();
+        source.close();
+    }
+}

package/src/android/io/capawesome/cordova/plugins/liveupdate/LiveUpdatePathHandler.java

@@ -0,0 +1,96 @@
+package io.capawesome.cordova.plugins.liveupdate;
+
+import android.util.Log;
+import android.webkit.MimeTypeMap;
+import android.webkit.WebResourceResponse;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.webkit.WebViewAssetLoader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * {@link WebViewAssetLoader.PathHandler} that serves files from the active live-update
+ * bundle directory when one is set. Returns {@code null} otherwise so that Cordova's
+ * default {@code www/} asset handler can serve the original APK assets.
+ */
+public class LiveUpdatePathHandler implements WebViewAssetLoader.PathHandler {
+
+    private final AtomicReference<File> activeBundleDir = new AtomicReference<>(null);
+
+    public void setActiveBundleDir(@Nullable File dir) {
+        activeBundleDir.set(dir);
+    }
+
+    @Nullable
+    public File getActiveBundleDir() {
+        return activeBundleDir.get();
+    }
+
+    @Override
+    @Nullable
+    public WebResourceResponse handle(@NonNull String path) {
+        File baseDir = activeBundleDir.get();
+        if (baseDir == null) {
+            // No live bundle active — fall through to Cordova's default www/ handler.
+            return null;
+        }
+
+        String resolvedPath = path;
+        if (resolvedPath.isEmpty() || resolvedPath.endsWith("/")) {
+            resolvedPath = resolvedPath + "index.html";
+        }
+
+        File file = new File(baseDir, resolvedPath);
+
+        // Defense-in-depth against path traversal: ensure the resolved file is inside baseDir.
+        try {
+            String canonicalBase = baseDir.getCanonicalPath();
+            String canonicalFile = file.getCanonicalPath();
+            if (!canonicalFile.equals(canonicalBase) && !canonicalFile.startsWith(canonicalBase + File.separator)) {
+                return null;
+            }
+        } catch (IOException e) {
+            return null;
+        }
+
+        if (!file.isFile()) {
+            // Not in active bundle — let the default handler try.
+            return null;
+        }
+
+        try {
+            InputStream stream = new FileInputStream(file);
+            String mimeType = guessMimeType(resolvedPath);
+            return new WebResourceResponse(mimeType, null, stream);
+        } catch (IOException e) {
+            Log.e(LiveUpdatePlugin.TAG, "Failed to open bundle file: " + file.getAbsolutePath(), e);
+            return null;
+        }
+    }
+
+    private String guessMimeType(@NonNull String path) {
+        // Mirror Cordova's SystemWebViewClient logic so behavior is consistent
+        // whether we serve from the bundle or fall through to the default handler.
+        if (path.endsWith(".js") || path.endsWith(".mjs")) {
+            return "application/javascript";
+        }
+        if (path.endsWith(".wasm")) {
+            return "application/wasm";
+        }
+        String extension = MimeTypeMap.getFileExtensionFromUrl(path);
+        if (extension != null) {
+            String mime = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
+            if (mime != null) {
+                return mime;
+            }
+        }
+        if (path.endsWith(".html") || path.endsWith(".htm")) {
+            return "text/html";
+        }
+        return "application/octet-stream";
+    }
+}