react-native-ota-sdk 1.0.0

package/android/src/main/java/com/otaupdater/react/OTAUnknownException.java

@@ -0,0 +1,12 @@
+package com.otaupdater.react;
+
+public class OTAUnknownException extends RuntimeException {
+    public OTAUnknownException(String message) {
+        super(message);
+    }
+
+    public OTAUnknownException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
+

package/android/src/main/java/com/otaupdater/react/OTAUtils.java

@@ -0,0 +1,212 @@
+package com.otaupdater.react;
+
+import android.util.Log;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.NoSuchKeyException;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.Iterator;
+
+public class OTAUtils {
+
+    public static String appendPathComponent(String basePath, String appendPathComponent) {
+        return new File(basePath, appendPathComponent).getAbsolutePath();
+    }
+
+    public static WritableArray convertJsonArrayToWritable(JSONArray jsonArr) {
+        WritableArray arr = Arguments.createArray();
+        for (int i=0; i<jsonArr.length(); i++) {
+            Object obj = null;
+            try {
+                obj = jsonArr.get(i);
+            } catch (JSONException jsonException) {
+                throw new OTAUnknownException(i + " should be within bounds of array " + jsonArr.toString(), jsonException);
+            }
+
+            if (obj instanceof JSONObject)
+                arr.pushMap(convertJsonObjectToWritable((JSONObject) obj));
+            else if (obj instanceof JSONArray)
+                arr.pushArray(convertJsonArrayToWritable((JSONArray) obj));
+            else if (obj instanceof String)
+                arr.pushString((String) obj);
+            else if (obj instanceof Double)
+                arr.pushDouble((Double) obj);
+            else if (obj instanceof Integer)
+                arr.pushInt((Integer) obj);
+            else if (obj instanceof Boolean)
+                arr.pushBoolean((Boolean) obj);
+            else if (obj == null)
+                arr.pushNull();
+            else
+                throw new OTAUnknownException("Unrecognized object: " + obj);
+        }
+
+        return arr;
+    }
+
+    public static WritableMap convertJsonObjectToWritable(JSONObject jsonObj) {
+        WritableMap map = Arguments.createMap();
+        Iterator<String> it = jsonObj.keys();
+        while(it.hasNext()){
+            String key = it.next();
+            Object obj = null;
+            try {
+                if (!jsonObj.isNull(key)) {
+                    obj = jsonObj.get(key);
+                }
+            } catch (JSONException jsonException) {
+                throw new OTAUnknownException("Key " + key + " should exist in " + jsonObj.toString() + ".", jsonException);
+            }
+
+            if (obj instanceof JSONObject)
+                map.putMap(key, convertJsonObjectToWritable((JSONObject) obj));
+            else if (obj instanceof JSONArray)
+                map.putArray(key, convertJsonArrayToWritable((JSONArray) obj));
+            else if (obj instanceof String)
+                map.putString(key, (String) obj);
+            else if (obj instanceof Double)
+                map.putDouble(key, (Double) obj);
+            else if (obj instanceof Long)
+                map.putDouble(key, ((Long) obj).doubleValue());
+            else if (obj instanceof Integer)
+                map.putInt(key, (Integer) obj);
+            else if (obj instanceof Boolean)
+                map.putBoolean(key, (Boolean) obj);
+            else if (obj == null)
+                map.putNull(key);
+            else
+                throw new OTAUnknownException("Unrecognized object: " + obj);
+        }
+
+        return map;
+    }
+
+    public static JSONArray convertReadableToJsonArray(ReadableArray arr) {
+        JSONArray jsonArr = new JSONArray();
+        for (int i=0; i<arr.size(); i++) {
+            ReadableType type = arr.getType(i);
+            switch (type) {
+                case Map:
+                    jsonArr.put(convertReadableToJsonObject(arr.getMap(i)));
+                    break;
+                case Array:
+                    jsonArr.put(convertReadableToJsonArray(arr.getArray(i)));
+                    break;
+                case String:
+                    jsonArr.put(arr.getString(i));
+                    break;
+                case Number:
+                    Double number = arr.getDouble(i);
+                    if ((number == Math.floor(number)) && !Double.isInfinite(number)) {
+                        jsonArr.put(number.longValue());
+                    } else {
+                        try {
+                            jsonArr.put(number.doubleValue());
+                        } catch (JSONException jsonException) {
+                            throw new OTAUnknownException("Unable to put value " + arr.getDouble(i) + " in JSONArray");
+                        }
+                    }
+                    break;
+                case Boolean:
+                    jsonArr.put(arr.getBoolean(i));
+                    break;
+                case Null:
+                    jsonArr.put(null);
+                    break;
+            }
+        }
+
+        return jsonArr;
+    }
+
+    public static JSONObject convertReadableToJsonObject(ReadableMap map) {
+        JSONObject jsonObj = new JSONObject();
+        ReadableMapKeySetIterator it = map.keySetIterator();
+        while (it.hasNextKey()) {
+            String key = it.nextKey();
+            ReadableType type = map.getType(key);
+            try {
+                switch (type) {
+                    case Map:
+                        jsonObj.put(key, convertReadableToJsonObject(map.getMap(key)));
+                        break;
+                    case Array:
+                        jsonObj.put(key, convertReadableToJsonArray(map.getArray(key)));
+                        break;
+                    case String:
+                        jsonObj.put(key, map.getString(key));
+                        break;
+                    case Number:
+                        jsonObj.put(key, map.getDouble(key));
+                        break;
+                    case Boolean:
+                        jsonObj.put(key, map.getBoolean(key));
+                        break;
+                    case Null:
+                        jsonObj.put(key, null);
+                        break;
+                    default:
+                        throw new OTAUnknownException("Unrecognized type: " + type + " of key: " + key);
+                }
+            } catch (JSONException jsonException) {
+                throw new OTAUnknownException("Error setting key: " + key + " in JSONObject", jsonException);
+            }
+        }
+
+        return jsonObj;
+    }
+
+    public static JSONObject getJsonObjectFromFile(String filePath) throws IOException {
+        String content = FileUtils.readFileToString(filePath);
+        try {
+            return new JSONObject(content);
+        } catch (JSONException jsonException) {
+            throw new OTAMalformedDataException(filePath, jsonException);
+        }
+    }
+
+    public static void log(String message) {
+        Log.d(OTAConstants.REACT_NATIVE_LOG_TAG, "[OTAUpdater] " + message);
+    }
+
+    public static void log(Throwable tr) {
+        Log.e(OTAConstants.REACT_NATIVE_LOG_TAG, "[OTAUpdater] Exception", tr);
+    }
+
+    public static void setJSONValueForKey(JSONObject json, String key, Object value) {
+        try {
+            json.put(key, value);
+        } catch (JSONException e) {
+            throw new OTAUnknownException("Unable to set value " + value + " for key " + key + " to JSONObject");
+        }
+    }
+
+    public static String tryGetString(ReadableMap map, String key) {
+        try {
+            return map.getString(key);
+        } catch (NoSuchKeyException e) {
+            return null;
+        }
+    }
+
+    public static void writeJsonToFile(JSONObject json, String filePath) throws IOException {
+        String jsonString = json.toString();
+        FileUtils.writeStringToFile(jsonString, filePath);
+    }
+}
+

package/android/src/main/java/com/otaupdater/react/SettingsManager.java

@@ -0,0 +1,124 @@
+package com.otaupdater.react;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class SettingsManager {
+
+    private SharedPreferences mSettings;
+
+    public SettingsManager(Context applicationContext) {
+        mSettings = applicationContext.getSharedPreferences(OTAConstants.CODE_PUSH_PREFERENCES, 0);
+    }
+
+    public JSONArray getFailedUpdates() {
+        String failedUpdatesString = mSettings.getString(OTAConstants.FAILED_UPDATES_KEY, null);
+        if (failedUpdatesString == null) {
+            return new JSONArray();
+        }
+
+        try {
+            return new JSONArray(failedUpdatesString);
+        } catch (JSONException e) {
+            JSONArray emptyArray = new JSONArray();
+            mSettings.edit().putString(OTAConstants.FAILED_UPDATES_KEY, emptyArray.toString()).commit();
+            return emptyArray;
+        }
+    }
+
+    public JSONObject getPendingUpdate() {
+        String pendingUpdateString = mSettings.getString(OTAConstants.PENDING_UPDATE_KEY, null);
+        if (pendingUpdateString == null) {
+            return null;
+        }
+
+        try {
+            return new JSONObject(pendingUpdateString);
+        } catch (JSONException e) {
+            OTAUtils.log("Unable to parse pending update metadata " + pendingUpdateString +
+                    " stored in SharedPreferences");
+            return null;
+        }
+    }
+
+    public boolean isFailedHash(String packageHash) {
+        JSONArray failedUpdates = getFailedUpdates();
+        if (packageHash != null) {
+            for (int i = 0; i < failedUpdates.length(); i++) {
+                try {
+                    JSONObject failedPackage = failedUpdates.getJSONObject(i);
+                    String failedPackageHash = failedPackage.getString(OTAConstants.PACKAGE_HASH_KEY);
+                    if (packageHash.equals(failedPackageHash)) {
+                        return true;
+                    }
+                } catch (JSONException e) {
+                    throw new OTAUnknownException("Unable to read failedUpdates data stored in SharedPreferences.", e);
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public boolean isPendingUpdate(String packageHash) {
+        JSONObject pendingUpdate = getPendingUpdate();
+
+        try {
+            return pendingUpdate != null &&
+                    !pendingUpdate.getBoolean(OTAConstants.PENDING_UPDATE_IS_LOADING_KEY) &&
+                    (packageHash == null || pendingUpdate.getString(OTAConstants.PENDING_UPDATE_HASH_KEY).equals(packageHash));
+        } catch (JSONException e) {
+            throw new OTAUnknownException("Unable to read pending update metadata in isPendingUpdate.", e);
+        }
+    }
+
+    public void removeFailedUpdates() {
+        mSettings.edit().remove(OTAConstants.FAILED_UPDATES_KEY).commit();
+    }
+
+    public void removePendingUpdate() {
+        mSettings.edit().remove(OTAConstants.PENDING_UPDATE_KEY).commit();
+    }
+
+    public void saveFailedUpdate(JSONObject failedPackage) {
+        try {
+            if (isFailedHash(failedPackage.getString(OTAConstants.PACKAGE_HASH_KEY))) {
+                return;
+            }
+        } catch (JSONException e) {
+            throw new OTAUnknownException("Unable to read package hash from package.", e);
+        }
+
+        String failedUpdatesString = mSettings.getString(OTAConstants.FAILED_UPDATES_KEY, null);
+        JSONArray failedUpdates;
+        if (failedUpdatesString == null) {
+            failedUpdates = new JSONArray();
+        } else {
+            try {
+                failedUpdates = new JSONArray(failedUpdatesString);
+            } catch (JSONException e) {
+                throw new OTAMalformedDataException("Unable to parse failed updates information " +
+                        failedUpdatesString + " stored in SharedPreferences", e);
+            }
+        }
+
+        failedUpdates.put(failedPackage);
+        mSettings.edit().putString(OTAConstants.FAILED_UPDATES_KEY, failedUpdates.toString()).commit();
+    }
+
+    public void savePendingUpdate(String packageHash, boolean isLoading) {
+        JSONObject pendingUpdate = new JSONObject();
+        try {
+            pendingUpdate.put(OTAConstants.PENDING_UPDATE_HASH_KEY, packageHash);
+            pendingUpdate.put(OTAConstants.PENDING_UPDATE_IS_LOADING_KEY, isLoading);
+            mSettings.edit().putString(OTAConstants.PENDING_UPDATE_KEY, pendingUpdate.toString()).commit();
+        } catch (JSONException e) {
+            throw new OTAUnknownException("Unable to save pending update.", e);
+        }
+    }
+}
+

package/android/src/main/java/com/otaupdater/react/TLSSocketFactory.java

@@ -0,0 +1,73 @@
+package com.otaupdater.react;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+
+public class TLSSocketFactory extends SSLSocketFactory {
+
+    private SSLSocketFactory delegate;
+
+    public TLSSocketFactory() throws KeyManagementException, NoSuchAlgorithmException {
+        SSLContext context = SSLContext.getInstance("TLS");
+        context.init(null, null, null);
+        delegate = context.getSocketFactory();
+    }
+
+    @Override
+    public String[] getDefaultCipherSuites() {
+        return delegate.getDefaultCipherSuites();
+    }
+
+    @Override
+    public String[] getSupportedCipherSuites() {
+        return delegate.getSupportedCipherSuites();
+    }
+
+    @Override
+    public Socket createSocket() throws IOException {
+        return enableTLSOnSocket(delegate.createSocket());
+    }
+
+    @Override
+    public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException {
+        return enableTLSOnSocket(delegate.createSocket(s, host, port, autoClose));
+    }
+
+    @Override
+    public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
+        return enableTLSOnSocket(delegate.createSocket(host, port));
+    }
+
+    @Override
+    public Socket createSocket(String host, int port, InetAddress localHost, int localPort)
+            throws IOException, UnknownHostException {
+        return enableTLSOnSocket(delegate.createSocket(host, port, localHost, localPort));
+    }
+
+    @Override
+    public Socket createSocket(InetAddress host, int port) throws IOException {
+        return enableTLSOnSocket(delegate.createSocket(host, port));
+    }
+
+    @Override
+    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort)
+            throws IOException {
+        return enableTLSOnSocket(delegate.createSocket(address, port, localAddress, localPort));
+    }
+
+    private Socket enableTLSOnSocket(Socket socket) {
+        if (socket != null && (socket instanceof SSLSocket)) {
+            ((SSLSocket) socket).setEnabledProtocols(new String[] { "TLSv1.1", "TLSv1.2" });
+        }
+        return socket;
+    }
+}
+

package/android/src/main/res/xml/file_provider_paths.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- Entire cache dir - required for APK install from cache/OTA_Updates/ -->
+    <cache-path name="cache" path="." />
+    <cache-path name="ota_updates" path="OTA_Updates/" />
+    <external-path name="ota_updates_external" path="OTA_Updates/" />
+    <external-path name="downloads" path="Download/" />
+    <files-path name="ota_updates_files" path="OTA_Updates/" />
+</paths>
+

package/functions/.env.example

@@ -0,0 +1,7 @@
+# Optional: Override APK path prefix (default: apks/default/)
+# Only process files uploaded under this path, e.g. apks/myapp/v2.apk
+APK_PATH_PREFIX=apks/myapp/
+
+# Optional: Override function region (default: us-central1)
+# Should be close to your Firebase Storage bucket for lower latency
+REGION=us-central1

package/functions/README.md

@@ -0,0 +1,125 @@
+# Firebase Cloud Functions for OTA Updates
+
+When an APK is uploaded to Firebase Storage, this Cloud Function automatically updates Firebase Remote Config with the download URL and version. Your React Native app reads these values to show OTA update prompts.
+
+## Prerequisites
+
+- **Firebase Blaze (pay-as-you-go) plan** – required for Cloud Functions
+- Firebase project with Storage and Remote Config enabled
+- Node.js 18+
+
+## Architecture
+
+1. **Upload APK** → Firebase Storage (e.g. `apks/myapp/v2.apk`)
+2. **Cloud Function** (`onApkUploaded`) triggers on upload
+3. **Function** updates Remote Config with `apk_url` and `latest_version`
+4. **App** fetches Remote Config and downloads from `apk_url` when update is needed
+
+## Setup
+
+### 1. Configure your app's firebase.json
+
+In your React Native app root, create or update `firebase.json`:
+
+```json
+{
+  "functions": {
+    "source": "node_modules/react-native-ota-sdk/functions"
+  }
+}
+```
+
+### 2. Install dependencies
+
+```bash
+cd node_modules/react-native-ota-sdk/functions
+npm install
+```
+
+### 3. Configure the function
+
+Copy `.env.example` to `.env` and set your values:
+
+```bash
+cp .env.example .env
+```
+
+| Variable | Purpose | Example |
+|----------|---------|---------|
+| `APK_PATH_PREFIX` | Storage path to watch | `apks/myapp/` |
+| `REGION` | Function region | `us-central1` |
+
+Or set via Firebase config when deploying:
+
+```bash
+firebase functions:config:set ota.apk_path_prefix="apks/myapp/"
+```
+
+For `defineString` params, use Firebase's built-in secret/param system or set environment variables in your deployment.
+
+### 4. Create Remote Config parameters
+
+In [Firebase Console](https://console.firebase.google.com) → Remote Config, ensure these parameters exist:
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `min_version` | Number | `1` | Users below this MUST update (blocked) |
+| `latest_version` | Number | `1` | Current version (optional update) |
+| `apk_url` | String | (empty) | Auto-updated by Cloud Function |
+| `update_message` | String | Message | Shown in update UI |
+
+The function updates `apk_url` and `latest_version` automatically. Create `min_version` and `update_message` manually if needed.
+
+## Deploy
+
+From your app root (where `firebase.json` lives):
+
+```bash
+firebase deploy --only functions
+```
+
+Or from the functions directory:
+
+```bash
+cd node_modules/react-native-ota-sdk/functions
+npm run deploy
+```
+
+(Requires `firebase.json` in a parent directory with the correct project.)
+
+## IAM Permissions
+
+The default compute service account needs:
+
+- **Firebase Remote Config Admin** – to update Remote Config
+- **Service Usage Consumer** – required by Remote Config API
+- **Storage Object Viewer** – to read file metadata
+
+Add these in [Google Cloud IAM](https://console.cloud.google.com/iam-admin/iam) for your project.
+
+## Version from filename
+
+Upload APKs with version in the filename:
+
+- `v2.apk` or `2.apk` → sets `latest_version = 2`
+- `v1_2_3.apk` → sets `latest_version = 1`
+
+## App integration
+
+Use `@react-native-firebase/remote-config` in your app. The function expects your app to read:
+
+- `min_version` – force update if `versionCode < min_version`
+- `latest_version` – optional update if `versionCode < latest_version`
+- `apk_url` – download URL for the APK
+- `update_message` – message shown to users
+
+See the main [react-native-ota-sdk README](../README.md) for app-side integration.
+
+## Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| "Permission denied" when updating Remote Config | Add **Firebase Remote Config Admin** and **Service Usage Consumer** to the compute service account |
+| `apk_url` not updating | Check Functions logs; ensure file is under `APK_PATH_PREFIX` |
+| Function not triggering | Ensure upload path matches `APK_PATH_PREFIX`; check Storage bucket is the default |
+| 0 logs after upload | Grant **Storage Object Viewer** to the Eventarc service account |