cordova-plugin-in-app-updates 1.0.5

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 andreszs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,163 @@
+
+ ![License](https://img.shields.io/badge/license-MIT-orange.svg) ![Platform](https://img.shields.io/badge/platform-android-green.svg) [![Donate](https://img.shields.io/badge/donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=G33QACCVKYD7U)
+
+# cordova-plugin-in-app-update
+
+Cordova Android plugin for checking for updates and auto updating app with Google Play Store In-App updates API.
+
+# Platforms
+
+- Android
+- Browser
+
+# Features
+
+- AndroidX ready (plugin version 2.0.x)
+- Checks for updates
+- Install flexible updates
+- Install immediate updates
+- Customize snackbar message and button for Flexible updates
+- Customize snackbar button color for Flexible updates
+
+# Installation
+
+## Version Requirements
+
+| Plugin version | Cordova CLI | Cordova Android | AndroidX support |
+| --- | --- | --- | --- |
+| 1.0.5| 9.0.0 | 8.0.0 | No |
+| 2.0.5 | 10.0.0 | 9.0.0 | Yes |
+
+## Install latest version via CLI
+
+```bash
+  cordova plugin add cordova-plugin-in-app-updates
+```
+
+# Methods
+
+## getUpdateAvailability
+
+Invokes the AppUpdateManager and return one of the [updateAvailability](https://developer.android.com/reference/com/google/android/play/core/install/model/UpdateAvailability.html) codes as string.
+
+### Return values
+
+- **UPDATE_AVAILABLE**
+- **UPDATE_NOT_AVAILABLE**
+- **DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS**
+- **UNKNOWN**
+
+When this method returns **UPDATE_AVAILABLE**, your app is ready to use the following methods to prompt the user for update.
+
+### Example
+
+ ```javascript
+var onSuccess = function (strSuccess) {
+    console.log(strSuccess);
+};
+var onFailure = function (strError) {
+    console.warn(strError);
+};
+cordova.plugins.InAppUpdate.getUpdateAvailability(onSuccess, onFailure);
+```
+
+## updateFlexible
+
+Starts a [flexible update](https://developer.android.com/guide/playcore/in-app-updates/kotlin-java#flexible "flexible update") process and prompts the user with a dialog to download the new version now or when Wi-Fi is available.
+
+:warning: The **successCallback** from this method can be triggered repeatedly according to its status.
+
+### Return values
+
+- **UPDATE_NOT_AVAILABLE**: No updates available in Play Store.
+- **DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS**: Either flexible or immadiate update is in progress.
+- **UPDATE_PROMPT**: The user has been presented with the Play Store dialog to download or ignore the flexible update.
+- **RESULT_OK**: User accepted to download flexible update.
+- **RESULT_CANCELED**: User declined the flexible update dialog or update was aborted while in progress.
+- **RESULT_IN_APP_UPDATE_FAILED**: Something went wrong with the update dialog response.
+- **ACTIVITY_RESULT_UNKNOWN**: Unknown result code returned by the dialog.
+- **DOWNLOADING**: An update is currently being downloaded in the background.
+- **DOWNLOADED**: The update was downloaded and the snackbar with RESTART button has been shown.
+
+### Example
+
+```javascript
+var onSuccess = function (strSuccess) {
+    console.log(strSuccess);
+};
+var onFailure = function (strError) {
+    console.warn(strError);
+};
+cordova.plugins.InAppUpdate.updateFlexible(onSuccess, onFailure);
+```
+
+:warning: Make sure to call **getUpdateAvailability** as often as needed to ensure there are no **flexible** updates downloaded pending install, as they will consume storage space until installed.
+
+## updateImmediate
+
+Starts an [immediate update](https://developer.android.com/guide/playcore/in-app-updates/kotlin-java#immediate "immediate update") process and prompts the user with a fullscreen dialog to download now or when Wi-Fi is available. The update is downloaded and installed in the foreground, preventing the user from interacting with your app until the installation succeeds and the app is automatically restarted.
+
+:warning: The **successCallback** from this method can be triggered repeatedly according to its status.
+
+### Return values
+
+- **UPDATE_NOT_AVAILABLE**: No updates available in Play Store.
+- **DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS**: Either flexible or immadiate update is in progress.
+- **RESULT_OK**: User accepted to download immediate update.
+- **RESULT_CANCELED**: User declined the immediate update dialog.
+- **RESULT_IN_APP_UPDATE_FAILED**: Something went wrong with the update dialog response.
+- **ACTIVITY_RESULT_UNKNOWN**: Unknown result code returned by the dialog.
+- **DOWNLOADING**: An update is currently being downloaded in the foreground.
+- **DOWNLOADED**: The update was downloaded and will be installed immediately.
+
+### Example
+
+```javascript
+var onSuccess = function (strSuccess) {
+    console.log(strSuccess);
+};
+var onFailure = function (strError) {
+    console.warn(strError);
+};
+cordova.plugins.InAppUpdate.updateImmediate(onSuccess, onFailure);
+```
+
+## setSnackbarOptions
+
+Sets the label and the button text for the snackbar shown after downloading a flexible update. You are free to call this method at any time. You can also call it again to show different snackbar messages after the snackbar was shown.
+
+If not called, default messages in English will be shown.
+
+### Example
+
+```javascript
+var onSuccess = function (strSuccess) {
+    console.log(strSuccess);
+};
+var onFailure = function (strError) {
+    console.warn(strError);
+};
+var snackbarText = "An update has just been downloaded.";
+var snackbarButton = "RESTART";
+var snackbarButtonColor = "#76FF03";
+cordova.plugins.InAppUpdate.setSnackbarOptions(onSuccess, onFailure, snackbarText, snackbarButton, snackbarButtonColor);
+```
+
+### Default messages when not called
+
+- **snackbarText** = "An update has just been downloaded."
+- **snackbarButton** = "RESTART"
+- **snackbarText** = "#76FF03"
+
+### Return values
+
+- **onSuccess** = "SUCCESS"
+- **onFail** = *Internal error description.*
+
+# Plugin demo app
+
+Get the [In-App Update Plugin Demo app](https://www.andreszsogon.com/cordova-in-app-update-plugin-demo-app/ "In-App Update Plugin Demo app") to test the plugin in all possible scenarios. This app is available in the Store, please follow the linked  instructions to test the update flow.
+
+# Reporting issues
+
+Please report any issue with this plugin in GitHub by providing detailed context and sample code.

package/nbproject/project.properties

@@ -0,0 +1,4 @@
+file.reference.cordova-plugin-in-app-update-www=www
+files.encoding=UTF-8
+site.root.folder=${file.reference.cordova-plugin-in-app-update-www}
+source.folder=

package/nbproject/project.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://www.netbeans.org/ns/project/1">
+    <type>org.netbeans.modules.web.clientproject</type>
+    <configuration>
+        <data xmlns="http://www.netbeans.org/ns/clientside-project/1">
+            <name>cordova-plugin-in-app-updates</name>
+        </data>
+    </configuration>
+</project>

package/package.json

@@ -0,0 +1,48 @@
+{
+	"name": "cordova-plugin-in-app-updates",
+	"version": "1.0.5",
+	"description": "In-App updates from Play Store for your Apache Cordova app.",
+	"cordova": {
+		"id": "cordova-plugin-in-app-updates",
+		"platforms": [
+			"android"
+		]
+	},
+	"engines": {
+		"cordovaDependencies": {
+			"1.0.5": {
+				"cordova": ">=9.0.0",
+				"cordova-android": ">=8.0.0"
+			},
+			"2.0.5": {
+				"cordova": ">=10.0.0",
+				"cordova-android": ">=9.0.0"
+			}
+		}
+	},
+	"main": "index.js",
+	"scripts": {
+		"test": "echo \"Error: no test specified\" && exit 1"
+	},
+	"keywords": [
+		"ecosystem:cordova",
+		"cordova-android",
+		"cordova-browser",
+		"cordova",
+		"android",
+		"playstore",
+		"update",
+		"autoupdate",
+		"in-app update"
+	],
+	"author": "Andres Zsogon",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/andreszs/cordova-plugin-in-app-updates.git"
+	},
+	"homepage": "https://github.com/andreszs/cordova-plugin-in-app-updates#readme",
+	"bugs": {
+		"url": "https://github.com/andreszs/cordova-plugin-in-app-updates/issues"
+	}
+}

package/plugin.xml

@@ -0,0 +1,50 @@
+<?xml version='1.0' encoding='utf-8'?>
+<plugin id="cordova-plugin-in-app-updates" version="1.0.5" xmlns="http://apache.org/cordova/ns/plugins/1.0" xmlns:android="http://schemas.android.com/apk/res/android">
+	<name>InAppUpdate</name>
+	<description>In-App updates from Play Store for your Apache Cordova app.</description>
+	<license>MIT</license>
+	<keywords>android,in-app,update</keywords>
+
+	<engines>
+		<engine name="cordova" version=">=9.0.0" />
+		<engine name="cordova-android" version=">=8.0.0" />
+	</engines>
+
+	<js-module name="InAppUpdate" src="www/InAppUpdate.js">
+		<clobbers target="cordova.plugins.InAppUpdate" />
+	</js-module>
+
+	<platform name="android">
+		<preference name="ANDROID_APPCOMPAT_VERSION" default="28.0.0" />
+		<framework src="com.android.support:appcompat-v7:$ANDROID_APPCOMPAT_VERSION" />
+
+		<preference name="ANDROID_PLAY_CORE_VERSION" default="1.7.2" />
+		<framework src="com.google.android.play:core:$ANDROID_PLAY_CORE_VERSION" />
+
+		<preference name="ANDROID_DESIGN_VERSION" default="28.0.0" />
+		<framework src="com.android.support:design:$ANDROID_DESIGN_VERSION" />
+
+		<config-file target="res/xml/config.xml" parent="/*">
+			<feature name="InAppUpdate">
+				<param name="android-package" value="com.andreszs.inappupdate.InAppUpdate" />
+			</feature>
+		</config-file>
+
+		<edit-config file="AndroidManifest.xml" target="/manifest/application/activity[@android:name='MainActivity']" mode="merge">
+			<activity android:name="MainActivity" android:theme="@style/Theme.AppCompat.NoActionBar" />
+		</edit-config>
+
+		<source-file src="src/android/InAppUpdate.java" target-dir="src/com/andreszs/inappupdate" />
+	</platform>
+
+	<platform name="browser">
+		<config-file target="config.xml" parent="/*">
+			<feature name="InAppUpdate">
+				<param name="browser-package" value="InAppUpdate" />
+			</feature>
+		</config-file>
+		<js-module src="src/browser/InAppUpdateProxy.js" name="InAppUpdateProxy">
+			<runs />
+		</js-module>
+	</platform>
+</plugin>

package/src/android/InAppUpdate.java

@@ -0,0 +1,478 @@
+package com.andreszs.inappupdate;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.content.IntentSender;
+import android.graphics.Color;
+import android.support.design.widget.Snackbar;
+import android.util.Log;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.TextView;
+
+import com.google.android.play.core.appupdate.AppUpdateInfo;
+import com.google.android.play.core.appupdate.AppUpdateManager;
+import com.google.android.play.core.appupdate.AppUpdateManagerFactory;
+import com.google.android.play.core.install.model.AppUpdateType;
+import com.google.android.play.core.install.model.UpdateAvailability;
+
+import com.google.android.play.core.install.model.InstallStatus;
+import com.google.android.play.core.install.InstallState;
+import com.google.android.play.core.install.InstallStateUpdatedListener;
+import com.google.android.play.core.tasks.Task;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.PluginResult;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import static android.app.Activity.RESULT_CANCELED;
+import static android.app.Activity.RESULT_OK;
+import static com.google.android.play.core.install.model.ActivityResult.RESULT_IN_APP_UPDATE_FAILED;
+
+/**
+ * @author https://github.com/andreszs/cordova-plugin-in-app-update
+ */
+public class InAppUpdate extends CordovaPlugin {
+
+	private static String LOG_TAG;
+	private static boolean PROMPTED = false;
+	private static int currentUpdateType;
+	private static AppUpdateManager appUpdateManager;
+
+	private final int activityResultRequestCode = 777;
+	private CordovaPlugin activityResultCallback;
+	private FrameLayout layout;
+	private Snackbar snackbar;
+	private CallbackContext callbackContext;
+
+	private String snackbarText = "An update has just been downloaded.";
+	private String snackbarButton = "RESTART";
+	private String snackbarButtonColor = "#76FF03";
+
+	public InAppUpdate() {
+		this.LOG_TAG = InAppUpdate.class.getSimpleName();
+		Log.i(LOG_TAG, "Constructed");
+	}
+
+	@Override
+	public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+		super.initialize(cordova, webView);
+		layout = (FrameLayout) webView.getView().getParent();
+	}
+
+	@Override
+	public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+		this.callbackContext = callbackContext;
+		this.PROMPTED = false;
+
+		Log.i(LOG_TAG, String.format("Executing the %s action started", action));
+		if (action.equals("getUpdateAvailability")) {
+			getUpdateAvailability(callbackContext);
+			return true;
+		} else if (action.equals("updateFlexible")) {
+			updateFlexible();
+			return true;
+		} else if (action.equals("updateImmediate")) {
+			updateImmediate();
+			return true;
+		} else if (action.equals("setSnackbarOptions")) {
+			setSnackbarOptions(args);
+			return true;
+		}
+
+		return false;
+	}
+
+	private void getUpdateAvailability(CallbackContext callbackContext) {
+
+		cordova.getThreadPool().execute(new Runnable() {
+			public void run() {
+
+				// Creates instance of the manager.
+				appUpdateManager = AppUpdateManagerFactory.create(cordova.getContext());
+
+				// Returns an intent object that you use to check for an update.
+				Task<AppUpdateInfo> appUpdateInfoTask = appUpdateManager.getAppUpdateInfo();
+
+				appUpdateInfoTask.addOnSuccessListener(appUpdateInfo -> {
+					Log.i(LOG_TAG, String.format("appUpdateInfo.updateAvailability = %s", String.valueOf(appUpdateInfo.updateAvailability())));
+					PluginResult result;
+					switch (appUpdateInfo.updateAvailability()) {
+						case UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS:
+							result = new PluginResult(PluginResult.Status.OK, "DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS");
+							callbackContext.sendPluginResult(result);
+							break;
+
+						case UpdateAvailability.UPDATE_AVAILABLE:
+							result = new PluginResult(PluginResult.Status.OK, "UPDATE_AVAILABLE");
+							callbackContext.sendPluginResult(result);
+							break;
+
+						case UpdateAvailability.UPDATE_NOT_AVAILABLE:
+							result = new PluginResult(PluginResult.Status.OK, "UPDATE_NOT_AVAILABLE");
+							callbackContext.sendPluginResult(result);
+							break;
+
+						default:
+							result = new PluginResult(PluginResult.Status.OK, "UNKNOWN");
+							callbackContext.sendPluginResult(result);
+					}
+
+				}).addOnFailureListener(e -> {
+					// Returns "com.google.android.play.core.internal.al: Failed to bind to the service." whenever the Play Store is not available.
+					e.printStackTrace();
+					Log.e(LOG_TAG, e.toString());
+					callbackContext.error(e.toString());
+
+				});
+
+			}
+		});
+
+	}
+
+	public void setActivityResultCallback(CordovaPlugin plugin) {
+		Log.i(LOG_TAG, "setActivityResultCallback");
+
+		// Cancel any previously pending activity.
+		if (this.activityResultCallback != null) {
+			this.activityResultCallback.onActivityResult(this.activityResultRequestCode, Activity.RESULT_CANCELED, null);
+		}
+		this.activityResultCallback = plugin;
+	}
+
+	private void popupSnackbarForCompleteUpdate() {
+		Log.i(LOG_TAG, "popupSnackbarForCompleteUpdate");
+		this.PROMPTED = true;
+
+		cordova.getActivity().runOnUiThread(new Runnable() {
+			public void run() {
+				try {
+					snackbar = Snackbar.make(layout, snackbarText, Snackbar.LENGTH_INDEFINITE);
+					snackbar.setAction(snackbarButton, new View.OnClickListener() {
+						public void onClick(View view) {
+							appUpdateManager.completeUpdate();
+						}
+					});
+					snackbar.setActionTextColor(Color.parseColor(snackbarButtonColor));
+					snackbar.show();
+				} catch (Exception e) {
+					e.printStackTrace();
+					Log.e(LOG_TAG, e.getMessage());
+				}
+			}
+		});
+
+	}
+
+	private void setSnackbarOptions(JSONArray args) {
+
+		PluginResult result;
+		Log.i(LOG_TAG, "setSnackbarOptions");
+
+		try {
+
+			JSONObject arg_object = args.getJSONObject(0);
+			this.snackbarText = arg_object.getString("strText");
+			this.snackbarButton = arg_object.getString("strButton");
+			String colorHex = arg_object.getString("strButtonColor");
+			if (colorHex != null && colorHex.length() == 7) {
+				this.snackbarButtonColor = colorHex;
+				result = new PluginResult(PluginResult.Status.OK, "SUCCESS");
+			} else {
+				result = new PluginResult(PluginResult.Status.OK, "SUCCESS (Invalid HEX color specified; ignored)");
+			}
+			this.callbackContext.sendPluginResult(result);
+
+		} catch (Exception e) {
+
+			Log.e(LOG_TAG, e.getMessage());
+			result = new PluginResult(PluginResult.Status.ERROR, e.getMessage());
+			this.callbackContext.sendPluginResult(result);
+
+		}
+
+	}
+
+	private void updateFlexible() {
+
+		currentUpdateType = AppUpdateType.FLEXIBLE;
+		cordova.setActivityResultCallback(this);
+
+		cordova.getThreadPool().execute(new Runnable() {
+			//@Override
+			InstallStateUpdatedListener installStateUpdatedListener;
+
+			public void run() {
+
+				// Creates instance of the manager.
+				appUpdateManager = AppUpdateManagerFactory.create(cordova.getContext());
+
+				// Returns an intent object that you use to check for an update.
+				Task<AppUpdateInfo> appUpdateInfoTask = appUpdateManager.getAppUpdateInfo();
+
+				// Create a listener to track request state updates.
+				installStateUpdatedListener = new InstallStateUpdatedListener() {
+					@Override
+					public void onStateUpdate(InstallState state) {
+						if (state.installStatus() == InstallStatus.DOWNLOADED) {
+							// Update downloaded.
+							Log.i(LOG_TAG, "InstallStateUpdatedListener: InstallStatus.DOWNLOADED");
+
+							// Unregister listener
+							appUpdateManager.unregisterListener(installStateUpdatedListener);
+
+							// Prevent multiple consecutive prompts of this event
+							if (!PROMPTED) {
+								popupSnackbarForCompleteUpdate();
+								PluginResult result = new PluginResult(PluginResult.Status.OK, "DOWNLOADED");
+								callbackContext.sendPluginResult(result);
+							}
+						} else if (state.installStatus() == InstallStatus.INSTALLED) {
+							// Update installed.
+							Log.i(LOG_TAG, "InstallStateUpdatedListener: InstallStatus.INSTALLED");
+							if (appUpdateManager != null) {
+								// Unregister listener.
+								appUpdateManager.unregisterListener(installStateUpdatedListener);
+							}
+						} else if (state.installStatus() == InstallStatus.DOWNLOADING) {
+							// Now downloading...
+							Log.i(LOG_TAG, "InstallStateUpdatedListener: InstallStatus.DOWNLOADING");
+							PluginResult result = new PluginResult(PluginResult.Status.OK, "DOWNLOADING");
+							result.setKeepCallback(true);
+							callbackContext.sendPluginResult(result);
+						} else {
+							// Other status.
+							Log.i(LOG_TAG, "InstallStateUpdatedListener: state: " + state.installStatus());
+						}
+					}
+				};
+
+				// Before starting an update, register a listener for updates.
+				appUpdateManager.registerListener(installStateUpdatedListener);
+
+				// Start an update.
+				appUpdateInfoTask.addOnSuccessListener(appUpdateInfo -> {
+					Log.i(LOG_TAG, "Updated success listener called");
+
+					if (appUpdateInfo.installStatus() == InstallStatus.DOWNLOADED) {
+						// If the update is downloaded but not installed, notify the user to complete the update.
+						Log.i(LOG_TAG, "InstallStatus.DOWNLOADED");
+
+						// When status updates are no longer needed, unregister the listener.
+						appUpdateManager.unregisterListener(installStateUpdatedListener);
+
+						popupSnackbarForCompleteUpdate();
+						PluginResult result = new PluginResult(PluginResult.Status.OK, "DOWNLOADED");
+						callbackContext.sendPluginResult(result);
+
+					} else {
+						// Check for update availability.
+						switch (appUpdateInfo.updateAvailability()) {
+							case UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS:
+								// An update has been triggered by the developer and is in progress.
+								Log.i(LOG_TAG, "DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS");
+								callbackContext.success("DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS");
+								break;
+
+							case UpdateAvailability.UPDATE_AVAILABLE:
+								// Update is available.
+								Log.i(LOG_TAG, "UPDATE_AVAILABLE");
+								if (appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.FLEXIBLE)) {
+									// Request the update.
+									startUpdate(AppUpdateType.FLEXIBLE, appUpdateInfo);
+
+								} else {
+									// Update type not allowed.
+									Log.e(LOG_TAG, "Flexible update type not allowed");
+									callbackContext.error("UPDATE_TYPE_NOT_ALLOWED");
+								}
+								break;
+
+							case UpdateAvailability.UPDATE_NOT_AVAILABLE:
+								// Update not available.
+								Log.i(LOG_TAG, "UPDATE_NOT_AVAILABLE");
+								callbackContext.success("UPDATE_NOT_AVAILABLE");
+								break;
+
+							default:
+								// Unknown update status.
+								Log.i(LOG_TAG, "UNKNOWN");
+								callbackContext.success("UNKNOWN");
+						}
+					}
+
+				}).addOnFailureListener(e -> {
+					// Returns "com.google.android.play.core.internal.al: Failed to bind to the service." whenever the Play Store is not available.
+					e.printStackTrace();
+					Log.e(LOG_TAG, e.toString());
+					callbackContext.error(e.toString());
+
+				});
+
+			}
+		});
+	}
+
+	private void updateImmediate() {
+
+		currentUpdateType = AppUpdateType.IMMEDIATE;
+		cordova.setActivityResultCallback(this);
+		cordova.getThreadPool().execute(new Runnable() {
+			@Override
+			public void run() {
+
+				// Creates instance of the manager.
+				appUpdateManager = AppUpdateManagerFactory.create(cordova.getContext());
+
+				// Returns an intent object that you use to check for an update.
+				Task<AppUpdateInfo> appUpdateInfoTask = appUpdateManager.getAppUpdateInfo();
+
+				appUpdateInfoTask.addOnSuccessListener(appUpdateInfo -> {
+					Log.i(LOG_TAG, "Updated success listener called");
+
+					if (appUpdateInfo.installStatus() == InstallStatus.DOWNLOADED) {
+						// If the update is downloaded but not installed, complete the update now.
+						startUpdate(AppUpdateType.IMMEDIATE, appUpdateInfo);
+
+					} else {
+						// Check for update availability.
+						switch (appUpdateInfo.updateAvailability()) {
+							case UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS:
+								// An update has been triggered by the developer and is in progress.
+								Log.i(LOG_TAG, "DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS");
+								callbackContext.success("DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS");
+								break;
+
+							case UpdateAvailability.UPDATE_AVAILABLE:
+								// Update is available.
+								Log.i(LOG_TAG, "UPDATE_AVAILABLE");
+								if (appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE)) {
+									// Request the update.
+									startUpdate(AppUpdateType.IMMEDIATE, appUpdateInfo);
+								} else {
+									// Update type not allowed.
+									Log.e(LOG_TAG, "Flexible update type not allowed");
+									callbackContext.error("Flexible update type not allowed");
+								}
+								break;
+
+							case UpdateAvailability.UPDATE_NOT_AVAILABLE:
+								// Update not available.
+								Log.i(LOG_TAG, "UPDATE_NOT_AVAILABLE");
+								callbackContext.success("UPDATE_NOT_AVAILABLE");
+								break;
+
+							default:
+								// Unknown update status.
+								Log.i(LOG_TAG, "UNKNOWN");
+								callbackContext.success("UNKNOWN");
+						}
+					}
+
+				}).addOnFailureListener(e -> {
+					// Returns "com.google.android.play.core.internal.al: Failed to bind to the service." whenever the Play Store is not available.
+					Log.e(LOG_TAG, e.toString());
+					e.printStackTrace();
+					callbackContext.error(e.toString());
+
+				});
+
+			}
+		});
+
+	}
+
+	@Override
+	public void onActivityResult(int requestCode, int resultCode, Intent intent) {
+
+		PluginResult result;
+		Log.i(LOG_TAG, "onActivityResult");
+
+		if (requestCode == this.activityResultRequestCode && this.callbackContext != null) {
+			switch (resultCode) {
+				case RESULT_OK:
+					// User accepted the update.
+					Log.i(LOG_TAG, "RESULT_OK");
+					result = new PluginResult(PluginResult.Status.OK, "RESULT_OK");
+					result.setKeepCallback(true);
+					this.callbackContext.sendPluginResult(result);
+					break;
+
+				case RESULT_CANCELED:
+					// User cancelled the update.
+					Log.i(LOG_TAG, "RESULT_CANCELED");
+					result = new PluginResult(PluginResult.Status.OK, "RESULT_CANCELED");
+					this.callbackContext.sendPluginResult(result);
+					break;
+
+				case RESULT_IN_APP_UPDATE_FAILED:
+					// Update failured.
+					Log.e(LOG_TAG, "RESULT_IN_APP_UPDATE_FAILED");
+					result = new PluginResult(PluginResult.Status.ERROR, "RESULT_IN_APP_UPDATE_FAILED");
+					this.callbackContext.sendPluginResult(result);
+					break;
+
+				default:
+					// Unknown activity result.
+					Log.e(LOG_TAG, "ACTIVITY_RESULT_UNKNOWN");
+					result = new PluginResult(PluginResult.Status.ERROR, "ACTIVITY_RESULT_UNKNOWN");
+					this.callbackContext.sendPluginResult(result);
+			}
+		}
+		super.onActivityResult(requestCode, resultCode, intent);
+
+	}
+
+	@Override
+	public void onResume(final boolean multitasking) {
+
+		//Log.i(LOG_TAG, String.format("onResume: currentUpdateType = %s", String.valueOf(currentUpdateType)));
+		appUpdateManager.getAppUpdateInfo().addOnSuccessListener(appUpdateInfo -> {
+			if (appUpdateInfo.installStatus() == InstallStatus.DOWNLOADED) {
+				// If the update is downloaded but not installed, notify the user to complete the update.
+				if (currentUpdateType == AppUpdateType.FLEXIBLE) {
+					Log.i(LOG_TAG, "onResume: popupSnackbarForCompleteUpdate");
+					popupSnackbarForCompleteUpdate();
+				} else {
+					Log.i(LOG_TAG, "onResume: startUpdate");
+					try {
+						startUpdate(AppUpdateType.IMMEDIATE, appUpdateInfo);
+					} catch (Exception e) {
+						e.printStackTrace();
+					}
+				}
+			}
+		});
+
+		super.onResume(multitasking);
+
+	}
+
+	public void startUpdate(final int updateType, final AppUpdateInfo appUpdateInfo) {
+
+		PluginResult result;
+		Log.i(LOG_TAG, "startUpdate");
+
+		try {
+			appUpdateManager.startUpdateFlowForResult(appUpdateInfo, updateType, cordova.getActivity(), this.activityResultRequestCode);
+			result = new PluginResult(PluginResult.Status.OK, "UPDATE_PROMPT");
+			result.setKeepCallback(true);
+			this.callbackContext.sendPluginResult(result);
+
+		} catch (Exception e) {
+			Log.e(LOG_TAG, e.getMessage());
+			result = new PluginResult(PluginResult.Status.ERROR, e.getMessage());
+			this.callbackContext.sendPluginResult(result);
+
+		}
+
+	}
+
+}

package/src/browser/InAppUpdateProxy.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var InAppUpdate = {
+	getUpdateAvailability: function (successCallback, failureCallback) {
+		successCallback('UPDATE_NOT_AVAILABLE');
+	},
+	setSnackbarOptions: function (successCallback, failureCallback, snackbarText, snackbarButton, snackbarButtonColor) {
+		successCallback('SUCCESS');
+	},
+	updateFlexible: function (successCallback, failureCallback) {
+		successCallback('UPDATE_NOT_AVAILABLE');
+	},
+	updateImmediate: function (successCallback, failureCallback) {
+		successCallback('UPDATE_NOT_AVAILABLE');
+	}
+};
+
+module.exports = InAppUpdate;
+
+require("cordova/exec/proxy").add("InAppUpdate", module.exports);

package/www/InAppUpdate.js

@@ -0,0 +1,25 @@
+var exec = require('cordova/exec');
+
+var InAppUpdate = {
+	getUpdateAvailability: function (successCallback, failureCallback) {
+		exec(successCallback, failureCallback, 'InAppUpdate', 'getUpdateAvailability');
+	},
+	setSnackbarOptions: function (successCallback, failureCallback, snackbarText, snackbarButton, snackbarButtonColor) {
+		snackbarText = (typeof (snackbarText) == 'undefined' || snackbarText.length == 0) ? 'An update has just been downloaded.' : snackbarText;
+		snackbarButton = (typeof (snackbarButton) == 'undefined' || snackbarButton.length == 0) ? 'RESTART' : snackbarButton;
+		snackbarButtonColor = (typeof (snackbarButtonColor) == 'undefined' || snackbarButtonColor.length == 0) ? '#76FF03' : snackbarButtonColor;
+		exec(successCallback, failureCallback, 'InAppUpdate', 'setSnackbarOptions', [
+			{strText: snackbarText, strButton: snackbarButton, strButtonColor: snackbarButtonColor}
+		]);
+	},
+	updateFlexible: function (successCallback, failureCallback) {
+		exec(successCallback, failureCallback, 'InAppUpdate', 'updateFlexible');
+	},
+	updateImmediate: function (successCallback, failureCallback) {
+		exec(successCallback, failureCallback, 'InAppUpdate', 'updateImmediate');
+	}
+
+};
+
+module.exports = InAppUpdate;
+