cronapp-cordova-ota-plugin 4.4.0-RC.8

package/README.md

@@ -0,0 +1,28 @@
+# Cronapp Cordova OTA Plugin
+
+Plugin Cordova para aplicar atualizacoes OTA de assets usando `cronapp-cordova-plugin-contentsync`.
+
+## Configuracao
+
+O plugin e instalado como dependencia de `cordova-plugin-cronapp`. Por padrao, nada e executado ate que a aplicacao tenha `CRONAPP_OTA_UPDATE` configurada como `true` no `config.xml` principal do projeto e `window.hostApp` esteja preenchido.
+
+```xml
+<preference name="CRONAPP_OTA_UPDATE" value="true" />
+```
+
+O plugin inicia automaticamente no `deviceready`, aguarda 5 segundos e verifica o manifest em `window.hostApp + "/liveupdate/manifest.json"` quando OTA estiver habilitado. Depois disso, repete a verificacao a cada 20 minutos.
+
+Se `window.hostApp` nao existir, ou `CRONAPP_OTA_UPDATE` estiver ausente ou diferente de `true`, o OTA nao executa nenhuma verificacao.
+
+A versao atual e calculada a partir da versao salva da ultima atualizacao OTA ou da versao nativa do app, o que for maior.
+
+## Manifest
+
+```json
+{
+  "url": "https://server.com.br/live-update/bundle-production-1.0.0-20260519-182452.zip",
+  "version": "1.0.1"
+}
+```
+
+Somente versoes semanticamente maiores que a versao atual armazenada sao recomendadas ao usuario.

package/example-manifest.json

@@ -0,0 +1,4 @@
+{
+  "url": "https://s3.us-east-1.amazonaws.com/static.cronapp.io/www.zip",
+  "version": "1.0.2"
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "cronapp-cordova-ota-plugin",
+  "version": "4.4.0-RC.8",
+  "description": "Cronapp Cordova over-the-air update plugin.",
+  "main": "www/cronapp-ota.js",
+  "scripts": {
+    "build": "exit 0"
+  },
+  "cordova": {
+    "id": "cronapp-cordova-ota-plugin",
+    "platforms": [
+      "android",
+      "ios"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CronApp/cronapp-framework"
+  },
+  "keywords": [
+    "cordova",
+    "ecosystem:cordova",
+    "cordova-android",
+    "cordova-ios",
+    "cronapp",
+    "ota",
+    "contentsync"
+  ],
+  "license": "MIT"
+}

package/plugin.xml

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0" xmlns:android="http://schemas.android.com/apk/res/android" id="cronapp-cordova-ota-plugin" version="4.4.0-RC.8">
+    <name>Cronapp OTA Plugin</name>
+    <description>Cronapp Cordova over-the-air update plugin.</description>
+    <license>MIT</license>
+    <keywords>cordova,cronapp,ota,contentsync,live-update</keywords>
+    <repo>https://github.com/CronApp/cronapp-framework</repo>
+    <issue>https://github.com/CronApp/cronapp-framework/issues</issue>
+
+    <dependency id="cronapp-cordova-plugin-contentsync" version="4.4.0-RC.8"/>
+    <dependency id="cordova-plugin-dialogs" version="^2.0.1"/>
+
+    <js-module name="CronappOTA" src="www/cronapp-ota.js">
+        <clobbers target="cordova.plugins.cronappOTA"/>
+    </js-module>
+
+    <js-module name="CronappOTABootstrap" src="www/cronapp-ota-bootstrap.js">
+        <runs/>
+    </js-module>
+
+    <platform name="android">
+        <config-file parent="/*" target="res/xml/config.xml">
+            <feature name="CronappOTA">
+                <param name="android-package" value="br.com.cronapp.cordova.ota.CronappOTA"/>
+            </feature>
+        </config-file>
+
+        <source-file src="src/android/br/com/cronapp/cordova/ota/CronappOTA.java" target-dir="src/br/com/cronapp/cordova/ota"/>
+    </platform>
+
+    <platform name="ios">
+        <config-file parent="/*" target="config.xml">
+            <feature name="CronappOTA">
+                <param name="ios-package" value="CronappOTA"/>
+            </feature>
+        </config-file>
+
+        <header-file src="src/ios/CronappOTA.h"/>
+        <source-file src="src/ios/CronappOTA.m"/>
+    </platform>
+</plugin>

package/src/android/br/com/cronapp/cordova/ota/CronappOTA.java

@@ -0,0 +1,84 @@
+package br.com.cronapp.cordova.ota;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaPlugin;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class CronappOTA extends CordovaPlugin {
+    private static final String PREFERENCES_NAME = "CronappOTA";
+
+    @Override
+    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+        if ("getConfig".equals(action)) {
+            callbackContext.success(getConfig());
+            return true;
+        }
+
+        if ("getStoredVersion".equals(action)) {
+            callbackContext.success(getPreferences().getString(args.getString(0), ""));
+            return true;
+        }
+
+        if ("setStoredVersion".equals(action)) {
+            getPreferences().edit().putString(args.getString(0), args.getString(1)).apply();
+            callbackContext.success();
+            return true;
+        }
+
+        if ("clearStoredVersion".equals(action)) {
+            getPreferences().edit().remove(args.getString(0)).apply();
+            callbackContext.success();
+            return true;
+        }
+
+        return false;
+    }
+
+    private JSONObject getConfig() throws JSONException {
+        JSONObject config = new JSONObject();
+        config.put("otaUpdate", getPreference("CRONAPP_OTA_UPDATE"));
+        config.put("currentVersion", getAppVersion());
+        config.put("applicationId", getApplicationId());
+        return config;
+    }
+
+    private String getPreference(String key) {
+        return getPreference(key, "");
+    }
+
+    private String getPreference(String key, String defaultValue) {
+        String value = preferences.getString(key, null);
+
+        if (value == null) {
+            value = preferences.getString(key.toLowerCase(), null);
+        }
+
+        return value == null ? defaultValue : value;
+    }
+
+    private String getApplicationId() {
+        return cordova.getActivity().getPackageName();
+    }
+
+    private String getAppVersion() {
+        try {
+            PackageManager packageManager = cordova.getActivity().getPackageManager();
+            PackageInfo packageInfo = packageManager.getPackageInfo(getApplicationId(), 0);
+            return packageInfo.versionName == null ? "" : packageInfo.versionName;
+        } catch (PackageManager.NameNotFoundException e) {
+            return "";
+        }
+    }
+
+    private SharedPreferences getPreferences() {
+        Context context = cordova.getActivity().getApplicationContext();
+        return context.getSharedPreferences(PREFERENCES_NAME, Context.MODE_PRIVATE);
+    }
+}

package/src/ios/CronappOTA.h

@@ -0,0 +1,10 @@
+#import <Cordova/CDV.h>
+
+@interface CronappOTA : CDVPlugin
+
+- (void)getConfig:(CDVInvokedUrlCommand*)command;
+- (void)getStoredVersion:(CDVInvokedUrlCommand*)command;
+- (void)setStoredVersion:(CDVInvokedUrlCommand*)command;
+- (void)clearStoredVersion:(CDVInvokedUrlCommand*)command;
+
+@end

package/src/ios/CronappOTA.m

@@ -0,0 +1,81 @@
+#import "CronappOTA.h"
+
+static NSString *const CronappOTAPreferencesName = @"CronappOTA";
+
+@implementation CronappOTA
+
+- (void)getConfig:(CDVInvokedUrlCommand*)command
+{
+    NSDictionary *config = @{
+        @"otaUpdate": [self getPreference:@"CRONAPP_OTA_UPDATE" defaultValue:@""],
+        @"currentVersion": [self appVersion],
+        @"applicationId": [self applicationId]
+    };
+
+    [self.commandDelegate sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:config] callbackId:command.callbackId];
+}
+
+- (void)getStoredVersion:(CDVInvokedUrlCommand*)command
+{
+    NSString *key = [self storageKeyFromCommand:command];
+    NSString *value = [[NSUserDefaults standardUserDefaults] stringForKey:[self namespacedKey:key]];
+
+    [self.commandDelegate sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:value ?: @""] callbackId:command.callbackId];
+}
+
+- (void)setStoredVersion:(CDVInvokedUrlCommand*)command
+{
+    NSString *key = [self storageKeyFromCommand:command];
+    NSString *value = [command argumentAtIndex:1 withDefault:@"" andClass:[NSString class]];
+
+    [[NSUserDefaults standardUserDefaults] setObject:value forKey:[self namespacedKey:key]];
+    [[NSUserDefaults standardUserDefaults] synchronize];
+    [self.commandDelegate sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_OK] callbackId:command.callbackId];
+}
+
+- (void)clearStoredVersion:(CDVInvokedUrlCommand*)command
+{
+    NSString *key = [self storageKeyFromCommand:command];
+
+    [[NSUserDefaults standardUserDefaults] removeObjectForKey:[self namespacedKey:key]];
+    [[NSUserDefaults standardUserDefaults] synchronize];
+    [self.commandDelegate sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_OK] callbackId:command.callbackId];
+}
+
+- (NSString*)getPreference:(NSString*)key defaultValue:(NSString*)defaultValue
+{
+    id value = [self.commandDelegate.settings objectForKey:[key lowercaseString]];
+
+    if (value == nil) {
+        value = [self.commandDelegate.settings objectForKey:key];
+    }
+
+    if (value == nil) {
+        return defaultValue;
+    }
+
+    return [NSString stringWithFormat:@"%@", value];
+}
+
+- (NSString*)applicationId
+{
+    return [[NSBundle mainBundle] bundleIdentifier] ?: @"";
+}
+
+- (NSString*)appVersion
+{
+    NSString *version = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleShortVersionString"];
+    return version ?: @"";
+}
+
+- (NSString*)storageKeyFromCommand:(CDVInvokedUrlCommand*)command
+{
+    return [command argumentAtIndex:0 withDefault:@"cronapp_ota_version" andClass:[NSString class]];
+}
+
+- (NSString*)namespacedKey:(NSString*)key
+{
+    return [NSString stringWithFormat:@"%@.%@", CronappOTAPreferencesName, key];
+}
+
+@end

package/www/cronapp-ota-bootstrap.js

@@ -0,0 +1,5 @@
+var ota = require('cronapp-cordova-ota-plugin.CronappOTA');
+
+document.addEventListener('deviceready', function () {
+  ota.autoStart();
+}, false);

package/www/cronapp-ota.js

@@ -0,0 +1,448 @@
+var exec = require('cordova/exec');
+
+var SERVICE = 'CronappOTA';
+var STORAGE_KEY = 'cronapp_ota_version';
+var DEFAULT_INITIAL_DELAY = 5000;
+var DEFAULT_CHECK_INTERVAL = 20 * 60 * 1000;
+
+var options = {};
+var timer = null;
+var initialized = false;
+var checking = false;
+var applying = false;
+var lastManifest = null;
+
+function native(action, args) {
+  return new Promise(function (resolve, reject) {
+    exec(resolve, reject, SERVICE, action, args || []);
+  });
+}
+
+function isBlank(value) {
+  return value === undefined || value === null || String(value).trim() === '';
+}
+
+function isTrue(value) {
+  return value === true || String(value).trim().toLowerCase() === 'true';
+}
+
+function buildManifestUrl(hostApp) {
+  if (isBlank(hostApp)) {
+    return '';
+  }
+
+  return String(hostApp).trim().replace(/\/+$/, '') + '/liveupdate/manifest.json';
+}
+
+function cleanVersion(value) {
+  if (isBlank(value)) {
+    return null;
+  }
+
+  return String(value).trim().replace(/^v/i, '');
+}
+
+function parseSemver(value) {
+  var version = cleanVersion(value);
+  var match;
+
+  if (!version) {
+    return null;
+  }
+
+  match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+  if (!match) {
+    return null;
+  }
+
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10),
+    prerelease: match[4] ? match[4].split('.') : []
+  };
+}
+
+function comparePrerelease(left, right) {
+  var max = Math.max(left.length, right.length);
+  var i;
+  var leftPart;
+  var rightPart;
+  var leftNumber;
+  var rightNumber;
+
+  if (!left.length && right.length) {
+    return 1;
+  }
+
+  if (left.length && !right.length) {
+    return -1;
+  }
+
+  for (i = 0; i < max; i += 1) {
+    leftPart = left[i];
+    rightPart = right[i];
+
+    if (leftPart === undefined) {
+      return -1;
+    }
+
+    if (rightPart === undefined) {
+      return 1;
+    }
+
+    leftNumber = /^[0-9]+$/.test(leftPart) ? parseInt(leftPart, 10) : null;
+    rightNumber = /^[0-9]+$/.test(rightPart) ? parseInt(rightPart, 10) : null;
+
+    if (leftNumber !== null && rightNumber !== null) {
+      if (leftNumber > rightNumber) {
+        return 1;
+      }
+      if (leftNumber < rightNumber) {
+        return -1;
+      }
+    } else if (leftNumber !== null) {
+      return -1;
+    } else if (rightNumber !== null) {
+      return 1;
+    } else if (leftPart > rightPart) {
+      return 1;
+    } else if (leftPart < rightPart) {
+      return -1;
+    }
+  }
+
+  return 0;
+}
+
+function compareSemver(left, right) {
+  var leftVersion = parseSemver(left);
+  var rightVersion = parseSemver(right);
+  var fields = ['major', 'minor', 'patch'];
+  var i;
+
+  if (!leftVersion || !rightVersion) {
+    return 0;
+  }
+
+  for (i = 0; i < fields.length; i += 1) {
+    if (leftVersion[fields[i]] > rightVersion[fields[i]]) {
+      return 1;
+    }
+    if (leftVersion[fields[i]] < rightVersion[fields[i]]) {
+      return -1;
+    }
+  }
+
+  return comparePrerelease(leftVersion.prerelease, rightVersion.prerelease);
+}
+
+function requestJson(url, headers) {
+  return new Promise(function (resolve, reject) {
+    var xhr = new XMLHttpRequest();
+    var finalUrl = url;
+    var separator = url.indexOf('?') === -1 ? '?' : '&';
+
+    finalUrl += separator + '_cronapp_ota=' + Date.now();
+    xhr.open('GET', finalUrl, true);
+    xhr.timeout = options.requestTimeout || 30000;
+
+    Object.keys(headers || {}).forEach(function (key) {
+      xhr.setRequestHeader(key, headers[key]);
+    });
+
+    xhr.onreadystatechange = function () {
+      var response;
+
+      if (xhr.readyState !== 4) {
+        return;
+      }
+
+      if (xhr.status < 200 || xhr.status >= 300) {
+        reject(new Error('Manifest request failed with status ' + xhr.status));
+        return;
+      }
+
+      try {
+        response = JSON.parse(xhr.responseText);
+      } catch (error) {
+        reject(error);
+        return;
+      }
+
+      resolve(response);
+    };
+
+    xhr.onerror = function () {
+      reject(new Error('Manifest request failed'));
+    };
+
+    xhr.ontimeout = function () {
+      reject(new Error('Manifest request timed out'));
+    };
+
+    xhr.send();
+  });
+}
+
+function confirmUpdate(version) {
+  return new Promise(function (resolve) {
+    var message = 'A versao ' + version + ' esta disponivel. Deseja implantar agora?';
+
+    if (navigator.notification && navigator.notification.confirm) {
+      navigator.notification.confirm(message, function (buttonIndex) {
+        resolve(buttonIndex === 1);
+      }, 'Atualizacao disponivel', ['Sim', 'Nao']);
+      return;
+    }
+
+    resolve(window.confirm(message));
+  });
+}
+
+function getCurrentVersion(config) {
+  var configuredVersion = cleanVersion(options.currentVersion) || cleanVersion(config.currentVersion);
+
+  if (!parseSemver(configuredVersion)) {
+    configuredVersion = null;
+  }
+
+  return native('getStoredVersion', [STORAGE_KEY]).then(function (storedVersion) {
+    storedVersion = cleanVersion(storedVersion);
+    if (!parseSemver(storedVersion)) {
+      storedVersion = null;
+    }
+
+    if (storedVersion && configuredVersion && compareSemver(configuredVersion, storedVersion) > 0) {
+      return configuredVersion;
+    }
+
+    return storedVersion || configuredVersion || '0.0.0';
+  }, function () {
+    return configuredVersion || '0.0.0';
+  });
+}
+
+function validateManifest(manifest, config) {
+  if (!manifest || isBlank(manifest.url) || isBlank(manifest.version)) {
+    throw new Error('Invalid OTA manifest');
+  }
+
+  if (!parseSemver(manifest.version)) {
+    throw new Error('Invalid OTA manifest version: ' + manifest.version);
+  }
+
+  if (!isBlank(config.applicationId) && !isBlank(manifest.applicationId) && config.applicationId !== manifest.applicationId) {
+    throw new Error('Manifest applicationId does not match this application');
+  }
+}
+
+function buildSyncUrl(manifest) {
+  var url = String(manifest.url);
+
+  if (options.appendVersionToBundleUrl === false) {
+    return url;
+  }
+
+  return url + (url.indexOf('?') === -1 ? '?' : '&') + '_cronapp_ota_version=' + encodeURIComponent(manifest.version);
+}
+
+function refreshApplication(localPath) {
+  var url = String(localPath || '');
+
+  if (url) {
+    url = url.replace(/^file:\/\//, '').replace(/\/$/, '');
+    url = 'file://' + url + '/index.html';
+  }
+
+  if (window.ContentSync && typeof window.ContentSync.loadUrl === 'function' && localPath) {
+    window.ContentSync.loadUrl(url, function () {}, function () {
+      window.location.reload();
+    });
+    return;
+  }
+
+  if (localPath) {
+    window.location.replace(url);
+    return;
+  }
+
+  window.location.reload();
+}
+
+function applyManifest(manifest) {
+  return new Promise(function (resolve, reject) {
+    var sync;
+
+    if (!window.ContentSync || typeof window.ContentSync.sync !== 'function') {
+      reject(new Error('ContentSync is not available'));
+      return;
+    }
+
+    if (applying) {
+      reject(new Error('OTA update is already being applied'));
+      return;
+    }
+
+    applying = true;
+    sync = window.ContentSync.sync({
+      src: buildSyncUrl(manifest),
+      id: options.contentSyncId || 'cronapp',
+      type: 'replace',
+      copyCordovaAssets: true,
+      headers: options.bundleHeaders || {}
+    });
+
+    sync.on('complete', function (data) {
+      native('setStoredVersion', [STORAGE_KEY, cleanVersion(manifest.version)]).then(function () {
+        applying = false;
+        refreshApplication(data && data.localPath);
+        resolve(data);
+      }, function (error) {
+        applying = false;
+        reject(error);
+      });
+    });
+
+    sync.on('error', function (error) {
+      applying = false;
+      reject(error);
+    });
+
+    sync.on('cancel', function () {
+      applying = false;
+      reject(new Error('OTA update was cancelled'));
+    });
+  });
+}
+
+function getConfig() {
+  return native('getConfig', []).then(function (config) {
+    config = config || {};
+    config.otaUpdate = options.otaUpdate !== undefined ? options.otaUpdate : config.otaUpdate;
+    config.manifestUrl = isTrue(config.otaUpdate) ? buildManifestUrl(window.hostApp) : '';
+    config.currentVersion = options.currentVersion || config.currentVersion;
+    config.applicationId = config.applicationId || '';
+    return config;
+  });
+}
+
+function scheduleNext() {
+  var interval = options.checkInterval || DEFAULT_CHECK_INTERVAL;
+
+  if (timer) {
+    clearTimeout(timer);
+  }
+
+  timer = setTimeout(function () {
+    module.exports.checkNow({ silent: true }).then(scheduleNext, scheduleNext);
+  }, interval);
+}
+
+module.exports.configure = function (newOptions) {
+  options = newOptions || {};
+  return module.exports;
+};
+
+module.exports.start = function () {
+  if (initialized) {
+    return Promise.resolve();
+  }
+
+  initialized = true;
+  return new Promise(function (resolve) {
+    setTimeout(function () {
+      module.exports.checkNow({ silent: true }).then(resolve, resolve);
+      scheduleNext();
+    }, options.initialDelay || DEFAULT_INITIAL_DELAY);
+  });
+};
+
+module.exports.stop = function () {
+  initialized = false;
+
+  if (timer) {
+    clearTimeout(timer);
+    timer = null;
+  }
+};
+
+module.exports.autoStart = function () {
+  return module.exports.start();
+};
+
+module.exports.checkNow = function (checkOptions) {
+  checkOptions = checkOptions || {};
+
+  if (checking || applying) {
+    return Promise.resolve(null);
+  }
+
+  checking = true;
+
+  return getConfig().then(function (config) {
+    if (isBlank(config.manifestUrl)) {
+      return null;
+    }
+
+    return requestJson(config.manifestUrl, options.manifestHeaders || {}).then(function (manifest) {
+      return getCurrentVersion(config).then(function (currentVersion) {
+        validateManifest(manifest, config);
+        lastManifest = manifest;
+
+        if (compareSemver(manifest.version, currentVersion) <= 0) {
+          return null;
+        }
+
+        if (checkOptions.prompt === false) {
+          return manifest;
+        }
+
+        return confirmUpdate(manifest.version).then(function (accepted) {
+          if (!accepted) {
+            return manifest;
+          }
+
+          return applyManifest(manifest);
+        });
+      });
+    });
+  }).then(function (result) {
+    checking = false;
+    return result;
+  }, function (error) {
+    checking = false;
+
+    if (!checkOptions.silent && window.console && console.warn) {
+      console.warn('Cronapp OTA check failed', error);
+    }
+
+    throw error;
+  });
+};
+
+module.exports.applyLastManifest = function () {
+  if (!lastManifest) {
+    return Promise.reject(new Error('No OTA manifest available'));
+  }
+
+  return applyManifest(lastManifest);
+};
+
+module.exports.getStoredVersion = function () {
+  return native('getStoredVersion', [STORAGE_KEY]);
+};
+
+module.exports.setStoredVersion = function (version) {
+  if (!parseSemver(version)) {
+    return Promise.reject(new Error('Invalid semver version: ' + version));
+  }
+
+  return native('setStoredVersion', [STORAGE_KEY, cleanVersion(version)]);
+};
+
+module.exports.clearStoredVersion = function () {
+  return native('clearStoredVersion', [STORAGE_KEY]);
+};
+
+module.exports.compareSemver = compareSemver;