();
+ result.add(eventResult);
+ result.add(pluginResult);
+
+ CoreAndroid appPlugin = (CoreAndroid) pluginManager.getPlugin(CoreAndroid.PLUGIN_NAME);
+ appPlugin.sendResumeEvent(new PluginResult(PluginResult.Status.OK, result));
+ }
+}
diff --git a/node_modules/cordova-android/framework/src/org/apache/cordova/allowlist/index.html b/node_modules/cordova-android/framework/src/org/apache/cordova/allowlist/index.html
new file mode 100644
index 0000000..24cac6e
--- /dev/null
+++ b/node_modules/cordova-android/framework/src/org/apache/cordova/allowlist/index.html
@@ -0,0 +1,45 @@
+
+
+
+
+ Cordova Tests
+ Allow List Page 1
+
+
Cordova:
+ Deviceready:
+
+
+ Loading Page 2 should be successful.
+ Page 2
+ Page 3
+ Page 2 with target=_blank
+
+
diff --git a/node_modules/cordova-android/framework/src/org/apache/cordova/allowlist/index2.html b/node_modules/cordova-android/framework/src/org/apache/cordova/allowlist/index2.html
new file mode 100644
index 0000000..bb475a8
--- /dev/null
+++ b/node_modules/cordova-android/framework/src/org/apache/cordova/allowlist/index2.html
@@ -0,0 +1,39 @@
+
+
+
+
+ Cordova Tests
+ Allow List Page 2
+
+
Cordova:
+ Deviceready:
+
+
+ Press "backbutton"
+
+
+
diff --git a/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemCookieManager.java b/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemCookieManager.java
new file mode 100644
index 0000000..f8128bc
--- /dev/null
+++ b/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemCookieManager.java
@@ -0,0 +1,62 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+package org.apache.cordova.engine;
+
+import android.annotation.TargetApi;
+import android.os.Build;
+import android.webkit.CookieManager;
+import android.webkit.WebView;
+
+import org.apache.cordova.ICordovaCookieManager;
+
+class SystemCookieManager implements ICordovaCookieManager {
+
+ protected final WebView webView;
+ private final CookieManager cookieManager;
+
+ public SystemCookieManager(WebView webview) {
+ webView = webview;
+ cookieManager = CookieManager.getInstance();
+
+ cookieManager.setAcceptFileSchemeCookies(true);
+ cookieManager.setAcceptThirdPartyCookies(webView, true);
+ }
+
+ public void setCookiesEnabled(boolean accept) {
+ cookieManager.setAcceptCookie(accept);
+ }
+
+ public void setCookie(final String url, final String value) {
+ cookieManager.setCookie(url, value);
+ }
+
+ public String getCookie(final String url) {
+ return cookieManager.getCookie(url);
+ }
+
+ @SuppressWarnings("deprecation")
+ public void clearCookies() {
+ cookieManager.removeAllCookies(null);
+ }
+
+ public void flush() {
+ cookieManager.flush();
+ }
+};
diff --git a/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemExposedJsApi.java b/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemExposedJsApi.java
new file mode 100644
index 0000000..94c3d93
--- /dev/null
+++ b/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemExposedJsApi.java
@@ -0,0 +1,53 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+package org.apache.cordova.engine;
+
+import android.webkit.JavascriptInterface;
+
+import org.apache.cordova.CordovaBridge;
+import org.apache.cordova.ExposedJsApi;
+import org.json.JSONException;
+
+/**
+ * Contains APIs that the JS can call. All functions in here should also have
+ * an equivalent entry in CordovaChromeClient.java, and be added to
+ * cordova-js/lib/android/plugin/android/promptbasednativeapi.js
+ */
+class SystemExposedJsApi implements ExposedJsApi {
+ private final CordovaBridge bridge;
+
+ SystemExposedJsApi(CordovaBridge bridge) {
+ this.bridge = bridge;
+ }
+
+ @JavascriptInterface
+ public String exec(int bridgeSecret, String service, String action, String callbackId, String arguments) throws JSONException, IllegalAccessException {
+ return bridge.jsExec(bridgeSecret, service, action, callbackId, arguments);
+ }
+
+ @JavascriptInterface
+ public void setNativeToJsBridgeMode(int bridgeSecret, int value) throws IllegalAccessException {
+ bridge.jsSetNativeToJsBridgeMode(bridgeSecret, value);
+ }
+
+ @JavascriptInterface
+ public String retrieveJsMessages(int bridgeSecret, boolean fromOnlineEvent) throws IllegalAccessException {
+ return bridge.jsRetrieveJsMessages(bridgeSecret, fromOnlineEvent);
+ }
+}
diff --git a/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemWebChromeClient.java b/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemWebChromeClient.java
new file mode 100644
index 0000000..cad098e
--- /dev/null
+++ b/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemWebChromeClient.java
@@ -0,0 +1,270 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+package org.apache.cordova.engine;
+
+import java.util.Arrays;
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.content.Context;
+import android.content.ActivityNotFoundException;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup.LayoutParams;
+import android.webkit.ConsoleMessage;
+import android.webkit.GeolocationPermissions.Callback;
+import android.webkit.JsPromptResult;
+import android.webkit.JsResult;
+import android.webkit.ValueCallback;
+import android.webkit.WebChromeClient;
+import android.webkit.WebStorage;
+import android.webkit.WebView;
+import android.webkit.PermissionRequest;
+import android.widget.LinearLayout;
+import android.widget.ProgressBar;
+import android.widget.RelativeLayout;
+
+import org.apache.cordova.CordovaDialogsHelper;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.LOG;
+
+/**
+ * This class is the WebChromeClient that implements callbacks for our web view.
+ * The kind of callbacks that happen here are on the chrome outside the document,
+ * such as onCreateWindow(), onConsoleMessage(), onProgressChanged(), etc. Related
+ * to but different than CordovaWebViewClient.
+ */
+public class SystemWebChromeClient extends WebChromeClient {
+
+ private static final int FILECHOOSER_RESULTCODE = 5173;
+ private static final String LOG_TAG = "SystemWebChromeClient";
+ private long MAX_QUOTA = 100 * 1024 * 1024;
+ protected final SystemWebViewEngine parentEngine;
+
+ // the video progress view
+ private View mVideoProgressView;
+
+ private CordovaDialogsHelper dialogsHelper;
+ private Context appContext;
+
+ private WebChromeClient.CustomViewCallback mCustomViewCallback;
+ private View mCustomView;
+
+ public SystemWebChromeClient(SystemWebViewEngine parentEngine) {
+ this.parentEngine = parentEngine;
+ appContext = parentEngine.webView.getContext();
+ dialogsHelper = new CordovaDialogsHelper(appContext);
+ }
+
+ /**
+ * Tell the client to display a javascript alert dialog.
+ */
+ @Override
+ public boolean onJsAlert(WebView view, String url, String message, final JsResult result) {
+ dialogsHelper.showAlert(message, new CordovaDialogsHelper.Result() {
+ @Override public void gotResult(boolean success, String value) {
+ if (success) {
+ result.confirm();
+ } else {
+ result.cancel();
+ }
+ }
+ });
+ return true;
+ }
+
+ /**
+ * Tell the client to display a confirm dialog to the user.
+ */
+ @Override
+ public boolean onJsConfirm(WebView view, String url, String message, final JsResult result) {
+ dialogsHelper.showConfirm(message, new CordovaDialogsHelper.Result() {
+ @Override
+ public void gotResult(boolean success, String value) {
+ if (success) {
+ result.confirm();
+ } else {
+ result.cancel();
+ }
+ }
+ });
+ return true;
+ }
+
+ /**
+ * Tell the client to display a prompt dialog to the user.
+ * If the client returns true, WebView will assume that the client will
+ * handle the prompt dialog and call the appropriate JsPromptResult method.
+ *
+ * Since we are hacking prompts for our own purposes, we should not be using them for
+ * this purpose, perhaps we should hack console.log to do this instead!
+ */
+ @Override
+ public boolean onJsPrompt(WebView view, String origin, String message, String defaultValue, final JsPromptResult result) {
+ // Unlike the @JavascriptInterface bridge, this method is always called on the UI thread.
+ String handledRet = parentEngine.bridge.promptOnJsPrompt(origin, message, defaultValue);
+ if (handledRet != null) {
+ result.confirm(handledRet);
+ } else {
+ dialogsHelper.showPrompt(message, defaultValue, new CordovaDialogsHelper.Result() {
+ @Override
+ public void gotResult(boolean success, String value) {
+ if (success) {
+ result.confirm(value);
+ } else {
+ result.cancel();
+ }
+ }
+ });
+ }
+ return true;
+ }
+
+ /**
+ * Handle database quota exceeded notification.
+ */
+ @Override
+ @SuppressWarnings("deprecation")
+ public void onExceededDatabaseQuota(String url, String databaseIdentifier, long currentQuota, long estimatedSize,
+ long totalUsedQuota, WebStorage.QuotaUpdater quotaUpdater)
+ {
+ LOG.d(LOG_TAG, "onExceededDatabaseQuota estimatedSize: %d currentQuota: %d totalUsedQuota: %d", estimatedSize, currentQuota, totalUsedQuota);
+ quotaUpdater.updateQuota(MAX_QUOTA);
+ }
+
+ @Override
+ /**
+ * Instructs the client to show a prompt to ask the user to set the Geolocation permission state for the specified origin.
+ *
+ * This also checks for the Geolocation Plugin and requests permission from the application to use Geolocation.
+ *
+ * @param origin
+ * @param callback
+ */
+ public void onGeolocationPermissionsShowPrompt(String origin, Callback callback) {
+ super.onGeolocationPermissionsShowPrompt(origin, callback);
+ callback.invoke(origin, true, false);
+ //Get the plugin, it should be loaded
+ CordovaPlugin geolocation = parentEngine.pluginManager.getPlugin("Geolocation");
+ if(geolocation != null && !geolocation.hasPermisssion())
+ {
+ geolocation.requestPermissions(0);
+ }
+ }
+
+ // API level 7 is required for this, see if we could lower this using something else
+ @Override
+ @SuppressWarnings("deprecation")
+ public void onShowCustomView(View view, WebChromeClient.CustomViewCallback callback) {
+ parentEngine.getCordovaWebView().showCustomView(view, callback);
+ }
+
+ @Override
+ @SuppressWarnings("deprecation")
+ public void onHideCustomView() {
+ parentEngine.getCordovaWebView().hideCustomView();
+ }
+
+ @Override
+ /**
+ * Ask the host application for a custom progress view to show while
+ * a is loading.
+ * @return View The progress view.
+ */
+ public View getVideoLoadingProgressView() {
+ if (mVideoProgressView == null) {
+ // Create a new Loading view programmatically.
+
+ // create the linear layout
+ LinearLayout layout = new LinearLayout(parentEngine.getView().getContext());
+ layout.setOrientation(LinearLayout.VERTICAL);
+ RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
+ layoutParams.addRule(RelativeLayout.CENTER_IN_PARENT);
+ layout.setLayoutParams(layoutParams);
+ // the proress bar
+ ProgressBar bar = new ProgressBar(parentEngine.getView().getContext());
+ LinearLayout.LayoutParams barLayoutParams = new LinearLayout.LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
+ barLayoutParams.gravity = Gravity.CENTER;
+ bar.setLayoutParams(barLayoutParams);
+ layout.addView(bar);
+
+ mVideoProgressView = layout;
+ }
+ return mVideoProgressView;
+ }
+
+ @Override
+ public boolean onShowFileChooser(WebView webView, final ValueCallback filePathsCallback, final WebChromeClient.FileChooserParams fileChooserParams) {
+ // Check if multiple-select is specified
+ Boolean selectMultiple = false;
+ if (fileChooserParams.getMode() == WebChromeClient.FileChooserParams.MODE_OPEN_MULTIPLE) {
+ selectMultiple = true;
+ }
+ Intent intent = fileChooserParams.createIntent();
+ intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, selectMultiple);
+
+ // Uses Intent.EXTRA_MIME_TYPES to pass multiple mime types.
+ String[] acceptTypes = fileChooserParams.getAcceptTypes();
+ if (acceptTypes.length > 1) {
+ intent.setType("*/*"); // Accept all, filter mime types by Intent.EXTRA_MIME_TYPES.
+ intent.putExtra(Intent.EXTRA_MIME_TYPES, acceptTypes);
+ }
+ try {
+ parentEngine.cordova.startActivityForResult(new CordovaPlugin() {
+ @Override
+ public void onActivityResult(int requestCode, int resultCode, Intent intent) {
+ Uri[] result = null;
+ if (resultCode == Activity.RESULT_OK && intent != null) {
+ if (intent.getClipData() != null) {
+ // handle multiple-selected files
+ final int numSelectedFiles = intent.getClipData().getItemCount();
+ result = new Uri[numSelectedFiles];
+ for (int i = 0; i < numSelectedFiles; i++) {
+ result[i] = intent.getClipData().getItemAt(i).getUri();
+ LOG.d(LOG_TAG, "Receive file chooser URL: " + result[i]);
+ }
+ }
+ else if (intent.getData() != null) {
+ // handle single-selected file
+ result = WebChromeClient.FileChooserParams.parseResult(resultCode, intent);
+ LOG.d(LOG_TAG, "Receive file chooser URL: " + result);
+ }
+ }
+ filePathsCallback.onReceiveValue(result);
+ }
+ }, intent, FILECHOOSER_RESULTCODE);
+ } catch (ActivityNotFoundException e) {
+ LOG.w("No activity found to handle file chooser intent.", e);
+ filePathsCallback.onReceiveValue(null);
+ }
+ return true;
+ }
+
+ @Override
+ public void onPermissionRequest(final PermissionRequest request) {
+ LOG.d(LOG_TAG, "onPermissionRequest: " + Arrays.toString(request.getResources()));
+ request.grant(request.getResources());
+ }
+
+ public void destroyLastDialog(){
+ dialogsHelper.destroyLastDialog();
+ }
+}
diff --git a/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemWebView.java b/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemWebView.java
new file mode 100644
index 0000000..01c2f00
--- /dev/null
+++ b/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemWebView.java
@@ -0,0 +1,88 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+package org.apache.cordova.engine;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.KeyEvent;
+import android.webkit.WebChromeClient;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.CordovaWebViewEngine;
+
+/**
+ * Custom WebView subclass that enables us to capture events needed for Cordova.
+ */
+public class SystemWebView extends WebView implements CordovaWebViewEngine.EngineView {
+ private SystemWebViewClient viewClient;
+ SystemWebChromeClient chromeClient;
+ private SystemWebViewEngine parentEngine;
+ private CordovaInterface cordova;
+
+ public SystemWebView(Context context) {
+ this(context, null);
+ }
+
+ public SystemWebView(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ }
+
+ // Package visibility to enforce that only SystemWebViewEngine should call this method.
+ void init(SystemWebViewEngine parentEngine, CordovaInterface cordova) {
+ this.cordova = cordova;
+ this.parentEngine = parentEngine;
+ if (this.viewClient == null) {
+ setWebViewClient(new SystemWebViewClient(parentEngine));
+ }
+
+ if (this.chromeClient == null) {
+ setWebChromeClient(new SystemWebChromeClient(parentEngine));
+ }
+ }
+
+ @Override
+ public CordovaWebView getCordovaWebView() {
+ return parentEngine != null ? parentEngine.getCordovaWebView() : null;
+ }
+
+ @Override
+ public void setWebViewClient(WebViewClient client) {
+ viewClient = (SystemWebViewClient)client;
+ super.setWebViewClient(client);
+ }
+
+ @Override
+ public void setWebChromeClient(WebChromeClient client) {
+ chromeClient = (SystemWebChromeClient)client;
+ super.setWebChromeClient(client);
+ }
+
+ @Override
+ public boolean dispatchKeyEvent(KeyEvent event) {
+ Boolean ret = parentEngine.client.onDispatchKeyEvent(event);
+ if (ret != null) {
+ return ret.booleanValue();
+ }
+ return super.dispatchKeyEvent(event);
+ }
+}
diff --git a/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemWebViewClient.java b/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemWebViewClient.java
new file mode 100644
index 0000000..2fea4fe
--- /dev/null
+++ b/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemWebViewClient.java
@@ -0,0 +1,425 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+package org.apache.cordova.engine;
+
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.res.AssetManager;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.net.http.SslError;
+import android.webkit.ClientCertRequest;
+import android.webkit.HttpAuthHandler;
+import android.webkit.MimeTypeMap;
+import android.webkit.SslErrorHandler;
+import android.webkit.WebResourceRequest;
+import android.webkit.WebResourceResponse;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+
+import org.apache.cordova.AuthenticationToken;
+import org.apache.cordova.CordovaClientCertRequest;
+import org.apache.cordova.CordovaHttpAuthHandler;
+import org.apache.cordova.CordovaPluginPathHandler;
+import org.apache.cordova.CordovaResourceApi;
+import org.apache.cordova.LOG;
+import org.apache.cordova.PluginManager;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Hashtable;
+
+import androidx.webkit.WebViewAssetLoader;
+
+/**
+ * This class is the WebViewClient that implements callbacks for our web view.
+ * The kind of callbacks that happen here are regarding the rendering of the
+ * document instead of the chrome surrounding it, such as onPageStarted(),
+ * shouldOverrideUrlLoading(), etc. Related to but different than
+ * CordovaChromeClient.
+ */
+public class SystemWebViewClient extends WebViewClient {
+
+ private static final String TAG = "SystemWebViewClient";
+ protected final SystemWebViewEngine parentEngine;
+ private final WebViewAssetLoader assetLoader;
+ private boolean doClearHistory = false;
+ boolean isCurrentlyLoading;
+
+ /** The authorization tokens. */
+ private Hashtable authenticationTokens = new Hashtable();
+
+ public SystemWebViewClient(SystemWebViewEngine parentEngine) {
+ this.parentEngine = parentEngine;
+
+ WebViewAssetLoader.Builder assetLoaderBuilder = new WebViewAssetLoader.Builder()
+ .setDomain(parentEngine.preferences.getString("hostname", "localhost"))
+ .setHttpAllowed(true);
+
+ assetLoaderBuilder.addPathHandler("/", path -> {
+ try {
+ // Check if there a plugins with pathHandlers
+ PluginManager pluginManager = this.parentEngine.pluginManager;
+ if (pluginManager != null) {
+ for (CordovaPluginPathHandler handler : pluginManager.getPluginPathHandlers()) {
+ if (handler.getPathHandler() != null) {
+ WebResourceResponse response = handler.getPathHandler().handle(path);
+ if (response != null) {
+ return response;
+ }
+ };
+ }
+ }
+
+ if (path.isEmpty()) {
+ path = "index.html";
+ }
+ InputStream is = parentEngine.webView.getContext().getAssets().open("www/" + path, AssetManager.ACCESS_STREAMING);
+ String mimeType = "text/html";
+ String extension = MimeTypeMap.getFileExtensionFromUrl(path);
+ if (extension != null) {
+ if (path.endsWith(".js") || path.endsWith(".mjs")) {
+ // Make sure JS files get the proper mimetype to support ES modules
+ mimeType = "application/javascript";
+ } else if (path.endsWith(".wasm")) {
+ mimeType = "application/wasm";
+ } else {
+ mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
+ }
+ }
+
+ return new WebResourceResponse(mimeType, null, is);
+ } catch (Exception e) {
+ e.printStackTrace();
+ LOG.e(TAG, e.getMessage());
+ }
+ return null;
+ });
+
+ this.assetLoader = assetLoaderBuilder.build();
+ }
+
+ /**
+ * Give the host application a chance to take over the control when a new url
+ * is about to be loaded in the current WebView.
+ *
+ * @param view The WebView that is initiating the callback.
+ * @param url The url to be loaded.
+ * @return true to override, false for default behavior
+ */
+ @Override
+ @SuppressWarnings("deprecation")
+ public boolean shouldOverrideUrlLoading(WebView view, String url) {
+ return parentEngine.client.onNavigationAttempt(url);
+ }
+
+ /**
+ * On received http auth request.
+ * The method reacts on all registered authentication tokens. There is one and only one authentication token for any host + realm combination
+ */
+ @Override
+ public void onReceivedHttpAuthRequest(WebView view, HttpAuthHandler handler, String host, String realm) {
+
+ // Get the authentication token (if specified)
+ AuthenticationToken token = this.getAuthenticationToken(host, realm);
+ if (token != null) {
+ handler.proceed(token.getUserName(), token.getPassword());
+ return;
+ }
+
+ // Check if there is some plugin which can resolve this auth challenge
+ PluginManager pluginManager = this.parentEngine.pluginManager;
+ if (pluginManager != null && pluginManager.onReceivedHttpAuthRequest(null, new CordovaHttpAuthHandler(handler), host, realm)) {
+ parentEngine.client.clearLoadTimeoutTimer();
+ return;
+ }
+
+ // By default handle 401 like we'd normally do!
+ super.onReceivedHttpAuthRequest(view, handler, host, realm);
+ }
+
+ /**
+ * On received client cert request.
+ * The method forwards the request to any running plugins before using the default implementation.
+ *
+ * @param view
+ * @param request
+ */
+ @Override
+ public void onReceivedClientCertRequest (WebView view, ClientCertRequest request)
+ {
+
+ // Check if there is some plugin which can resolve this certificate request
+ PluginManager pluginManager = this.parentEngine.pluginManager;
+ if (pluginManager != null && pluginManager.onReceivedClientCertRequest(null, new CordovaClientCertRequest(request))) {
+ parentEngine.client.clearLoadTimeoutTimer();
+ return;
+ }
+
+ // By default pass to WebViewClient
+ super.onReceivedClientCertRequest(view, request);
+ }
+
+ /**
+ * Notify the host application that a page has started loading.
+ * This method is called once for each main frame load so a page with iframes or framesets will call onPageStarted
+ * one time for the main frame. This also means that onPageStarted will not be called when the contents of an
+ * embedded frame changes, i.e. clicking a link whose target is an iframe.
+ *
+ * @param view The webview initiating the callback.
+ * @param url The url of the page.
+ */
+ @Override
+ public void onPageStarted(WebView view, String url, Bitmap favicon) {
+ super.onPageStarted(view, url, favicon);
+ isCurrentlyLoading = true;
+ // Flush stale messages & reset plugins.
+ parentEngine.bridge.reset();
+ parentEngine.client.onPageStarted(url);
+ }
+
+ /**
+ * Notify the host application that a page has finished loading.
+ * This method is called only for main frame. When onPageFinished() is called, the rendering picture may not be updated yet.
+ *
+ *
+ * @param view The webview initiating the callback.
+ * @param url The url of the page.
+ */
+ @Override
+ public void onPageFinished(WebView view, String url) {
+ super.onPageFinished(view, url);
+ // Ignore excessive calls, if url is not about:blank (CB-8317).
+ if (!isCurrentlyLoading && !url.startsWith("about:")) {
+ return;
+ }
+ isCurrentlyLoading = false;
+
+ /**
+ * Because of a timing issue we need to clear this history in onPageFinished as well as
+ * onPageStarted. However we only want to do this if the doClearHistory boolean is set to
+ * true. You see when you load a url with a # in it which is common in jQuery applications
+ * onPageStared is not called. Clearing the history at that point would break jQuery apps.
+ */
+ if (this.doClearHistory) {
+ view.clearHistory();
+ this.doClearHistory = false;
+ }
+ parentEngine.client.onPageFinishedLoading(url);
+
+ }
+
+ /**
+ * Report an error to the host application. These errors are unrecoverable (i.e. the main resource is unavailable).
+ * The errorCode parameter corresponds to one of the ERROR_* constants.
+ *
+ * @param view The WebView that is initiating the callback.
+ * @param errorCode The error code corresponding to an ERROR_* value.
+ * @param description A String describing the error.
+ * @param failingUrl The url that failed to load.
+ */
+ @Override
+ @SuppressWarnings("deprecation")
+ public void onReceivedError(WebView view, int errorCode, String description, String failingUrl) {
+ // Ignore error due to stopLoading().
+ if (!isCurrentlyLoading) {
+ return;
+ }
+ LOG.d(TAG, "CordovaWebViewClient.onReceivedError: Error code=%s Description=%s URL=%s", errorCode, description, failingUrl);
+
+ // If this is a "Protocol Not Supported" error, then revert to the previous
+ // page. If there was no previous page, then punt. The application's config
+ // is likely incorrect (start page set to sms: or something like that)
+ if (errorCode == WebViewClient.ERROR_UNSUPPORTED_SCHEME) {
+ parentEngine.client.clearLoadTimeoutTimer();
+
+ if (view.canGoBack()) {
+ view.goBack();
+ return;
+ } else {
+ super.onReceivedError(view, errorCode, description, failingUrl);
+ }
+ }
+ parentEngine.client.onReceivedError(errorCode, description, failingUrl);
+ }
+
+ /**
+ * Notify the host application that an SSL error occurred while loading a resource.
+ * The host application must call either handler.cancel() or handler.proceed().
+ * Note that the decision may be retained for use in response to future SSL errors.
+ * The default behavior is to cancel the load.
+ *
+ * @param view The WebView that is initiating the callback.
+ * @param handler An SslErrorHandler object that will handle the user's response.
+ * @param error The SSL error object.
+ */
+ @Override
+ public void onReceivedSslError(WebView view, SslErrorHandler handler, SslError error) {
+
+ final String packageName = parentEngine.cordova.getActivity().getPackageName();
+ final PackageManager pm = parentEngine.cordova.getActivity().getPackageManager();
+
+ ApplicationInfo appInfo;
+ try {
+ appInfo = pm.getApplicationInfo(packageName, PackageManager.GET_META_DATA);
+ if ((appInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
+ // debug = true
+ handler.proceed();
+ return;
+ } else {
+ // debug = false
+ super.onReceivedSslError(view, handler, error);
+ }
+ } catch (NameNotFoundException e) {
+ // When it doubt, lock it out!
+ super.onReceivedSslError(view, handler, error);
+ }
+ }
+
+
+ /**
+ * Sets the authentication token.
+ *
+ * @param authenticationToken
+ * @param host
+ * @param realm
+ */
+ public void setAuthenticationToken(AuthenticationToken authenticationToken, String host, String realm) {
+ if (host == null) {
+ host = "";
+ }
+ if (realm == null) {
+ realm = "";
+ }
+ this.authenticationTokens.put(host.concat(realm), authenticationToken);
+ }
+
+ /**
+ * Removes the authentication token.
+ *
+ * @param host
+ * @param realm
+ *
+ * @return the authentication token or null if did not exist
+ */
+ public AuthenticationToken removeAuthenticationToken(String host, String realm) {
+ return this.authenticationTokens.remove(host.concat(realm));
+ }
+
+ /**
+ * Gets the authentication token.
+ *
+ * In order it tries:
+ * 1- host + realm
+ * 2- host
+ * 3- realm
+ * 4- no host, no realm
+ *
+ * @param host
+ * @param realm
+ *
+ * @return the authentication token
+ */
+ public AuthenticationToken getAuthenticationToken(String host, String realm) {
+ AuthenticationToken token = null;
+ token = this.authenticationTokens.get(host.concat(realm));
+
+ if (token == null) {
+ // try with just the host
+ token = this.authenticationTokens.get(host);
+
+ // Try the realm
+ if (token == null) {
+ token = this.authenticationTokens.get(realm);
+ }
+
+ // if no host found, just query for default
+ if (token == null) {
+ token = this.authenticationTokens.get("");
+ }
+ }
+
+ return token;
+ }
+
+ /**
+ * Clear all authentication tokens.
+ */
+ public void clearAuthenticationTokens() {
+ this.authenticationTokens.clear();
+ }
+
+ @Override
+ @SuppressWarnings("deprecation")
+ public WebResourceResponse shouldInterceptRequest(WebView view, String url) {
+ try {
+ // Check the against the allow list and lock out access to the WebView directory
+ // Changing this will cause problems for your application
+ if (!parentEngine.pluginManager.shouldAllowRequest(url)) {
+ LOG.w(TAG, "URL blocked by allow list: " + url);
+ // Results in a 404.
+ return new WebResourceResponse("text/plain", "UTF-8", null);
+ }
+
+ CordovaResourceApi resourceApi = parentEngine.resourceApi;
+ Uri origUri = Uri.parse(url);
+ // Allow plugins to intercept WebView requests.
+ Uri remappedUri = resourceApi.remapUri(origUri);
+
+ if (!origUri.equals(remappedUri) || needsSpecialsInAssetUrlFix(origUri) || needsContentUrlFix(origUri)) {
+ CordovaResourceApi.OpenForReadResult result = resourceApi.openForRead(remappedUri, true);
+ return new WebResourceResponse(result.mimeType, "UTF-8", result.inputStream);
+ }
+ // If we don't need to special-case the request, let the browser load it.
+ return null;
+ } catch (IOException e) {
+ if (!(e instanceof FileNotFoundException)) {
+ LOG.e(TAG, "Error occurred while loading a file (returning a 404).", e);
+ }
+ // Results in a 404.
+ return new WebResourceResponse("text/plain", "UTF-8", null);
+ }
+ }
+
+ private static boolean needsContentUrlFix(Uri uri) {
+ return "content".equals(uri.getScheme());
+ }
+
+ private static boolean needsSpecialsInAssetUrlFix(Uri uri) {
+ if (CordovaResourceApi.getUriType(uri) != CordovaResourceApi.URI_TYPE_ASSET) {
+ return false;
+ }
+ if (uri.getQuery() != null || uri.getFragment() != null) {
+ return true;
+ }
+
+ if (!uri.toString().contains("%")) {
+ return false;
+ }
+
+ return false;
+ }
+
+ @Override
+ public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
+ return this.assetLoader.shouldInterceptRequest(request.getUrl());
+ }
+}
diff --git a/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemWebViewEngine.java b/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemWebViewEngine.java
new file mode 100644
index 0000000..71fa33d
--- /dev/null
+++ b/node_modules/cordova-android/framework/src/org/apache/cordova/engine/SystemWebViewEngine.java
@@ -0,0 +1,317 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+package org.apache.cordova.engine;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.ApplicationInfo;
+import android.os.Build;
+import android.view.View;
+import android.webkit.ValueCallback;
+import android.webkit.WebSettings;
+import android.webkit.WebSettings.LayoutAlgorithm;
+import android.webkit.WebView;
+
+import org.apache.cordova.CordovaBridge;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPreferences;
+import org.apache.cordova.CordovaResourceApi;
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.CordovaWebViewEngine;
+import org.apache.cordova.ICordovaCookieManager;
+import org.apache.cordova.LOG;
+import org.apache.cordova.NativeToJsMessageQueue;
+import org.apache.cordova.PluginManager;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+
+/**
+ * Glue class between CordovaWebView (main Cordova logic) and SystemWebView (the actual View).
+ * We make the Engine separate from the actual View so that:
+ * A) We don't need to worry about WebView methods clashing with CordovaWebViewEngine methods
+ * (e.g.: goBack() is void for WebView, and boolean for CordovaWebViewEngine)
+ * B) Separating the actual View from the Engine makes API surfaces smaller.
+ * Class uses two-phase initialization. However, CordovaWebView is responsible for calling .init().
+ */
+public class SystemWebViewEngine implements CordovaWebViewEngine {
+ public static final String TAG = "SystemWebViewEngine";
+
+ protected final SystemWebView webView;
+ protected final SystemCookieManager cookieManager;
+ protected CordovaPreferences preferences;
+ protected CordovaBridge bridge;
+ protected CordovaWebViewEngine.Client client;
+ protected CordovaWebView parentWebView;
+ protected CordovaInterface cordova;
+ protected PluginManager pluginManager;
+ protected CordovaResourceApi resourceApi;
+ protected NativeToJsMessageQueue nativeToJsMessageQueue;
+ private BroadcastReceiver receiver;
+
+ /** Used when created via reflection. */
+ public SystemWebViewEngine(Context context, CordovaPreferences preferences) {
+ this(new SystemWebView(context), preferences);
+ }
+
+ public SystemWebViewEngine(SystemWebView webView) {
+ this(webView, null);
+ }
+
+ public SystemWebViewEngine(SystemWebView webView, CordovaPreferences preferences) {
+ this.preferences = preferences;
+ this.webView = webView;
+ cookieManager = new SystemCookieManager(webView);
+ }
+
+ @Override
+ public void init(CordovaWebView parentWebView, CordovaInterface cordova, CordovaWebViewEngine.Client client,
+ CordovaResourceApi resourceApi, PluginManager pluginManager,
+ NativeToJsMessageQueue nativeToJsMessageQueue) {
+ if (this.cordova != null) {
+ throw new IllegalStateException();
+ }
+ // Needed when prefs are not passed by the constructor
+ if (preferences == null) {
+ preferences = parentWebView.getPreferences();
+ }
+ this.parentWebView = parentWebView;
+ this.cordova = cordova;
+ this.client = client;
+ this.resourceApi = resourceApi;
+ this.pluginManager = pluginManager;
+ this.nativeToJsMessageQueue = nativeToJsMessageQueue;
+ webView.init(this, cordova);
+
+ initWebViewSettings();
+
+ nativeToJsMessageQueue.addBridgeMode(new NativeToJsMessageQueue.OnlineEventsBridgeMode(new NativeToJsMessageQueue.OnlineEventsBridgeMode.OnlineEventsBridgeModeDelegate() {
+ @Override
+ public void setNetworkAvailable(boolean value) {
+ //sometimes this can be called after calling webview.destroy() on destroy()
+ //thus resulting in a NullPointerException
+ if(webView!=null) {
+ webView.setNetworkAvailable(value);
+ }
+ }
+ @Override
+ public void runOnUiThread(Runnable r) {
+ SystemWebViewEngine.this.cordova.getActivity().runOnUiThread(r);
+ }
+ }));
+ nativeToJsMessageQueue.addBridgeMode(new NativeToJsMessageQueue.EvalBridgeMode(this, cordova));
+ bridge = new CordovaBridge(pluginManager, nativeToJsMessageQueue);
+ exposeJsInterface(webView, bridge);
+ }
+
+ @Override
+ public CordovaWebView getCordovaWebView() {
+ return parentWebView;
+ }
+
+ @Override
+ public ICordovaCookieManager getCookieManager() {
+ return cookieManager;
+ }
+
+ @Override
+ public View getView() {
+ return webView;
+ }
+
+ @SuppressLint({"NewApi", "SetJavaScriptEnabled"})
+ @SuppressWarnings("deprecation")
+ private void initWebViewSettings() {
+ webView.setInitialScale(0);
+ webView.setVerticalScrollBarEnabled(false);
+ // Enable JavaScript
+ final WebSettings settings = webView.getSettings();
+ settings.setJavaScriptEnabled(true);
+ settings.setJavaScriptCanOpenWindowsAutomatically(true);
+ settings.setLayoutAlgorithm(LayoutAlgorithm.NORMAL);
+
+ String manufacturer = android.os.Build.MANUFACTURER;
+ LOG.d(TAG, "CordovaWebView is running on device made by: " + manufacturer);
+
+ // We don't save any form data in the application
+ // @todo remove when Cordova drop API level 26 support
+ settings.setSaveFormData(false);
+
+ if (preferences.getBoolean("AndroidInsecureFileModeEnabled", false)) {
+ //These settings are deprecated and loading content via file:// URLs is generally discouraged,
+ //but we allow this for compatibility reasons
+ LOG.d(TAG, "Enabled insecure file access");
+ settings.setAllowFileAccess(true);
+ settings.setAllowUniversalAccessFromFileURLs(true);
+ }
+
+ settings.setMediaPlaybackRequiresUserGesture(false);
+
+ // Enable database
+ // We keep this disabled because we use or shim to get around DOM_EXCEPTION_ERROR_16
+ String databasePath = webView.getContext().getApplicationContext().getDir("database", Context.MODE_PRIVATE).getPath();
+ settings.setDatabaseEnabled(true);
+
+ //Determine whether we're in debug or release mode, and turn on Debugging!
+ ApplicationInfo appInfo = webView.getContext().getApplicationContext().getApplicationInfo();
+ if ((appInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
+ enableRemoteDebugging();
+ }
+
+ // @todo remove when Cordova drop API level 24 support
+ settings.setGeolocationDatabasePath(databasePath);
+
+ // Enable DOM storage
+ settings.setDomStorageEnabled(true);
+
+ // Enable built-in geolocation
+ settings.setGeolocationEnabled(true);
+
+ // Fix for CB-1405
+ // Google issue 4641
+ String defaultUserAgent = settings.getUserAgentString();
+
+ // Fix for CB-3360
+ String overrideUserAgent = preferences.getString("OverrideUserAgent", null);
+ if (overrideUserAgent != null) {
+ settings.setUserAgentString(overrideUserAgent);
+ } else {
+ String appendUserAgent = preferences.getString("AppendUserAgent", null);
+ if (appendUserAgent != null) {
+ settings.setUserAgentString(defaultUserAgent + " " + appendUserAgent);
+ }
+ }
+ // End CB-3360
+
+ IntentFilter intentFilter = new IntentFilter();
+ intentFilter.addAction(Intent.ACTION_CONFIGURATION_CHANGED);
+ if (this.receiver == null) {
+ this.receiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ settings.getUserAgentString();
+ }
+ };
+ webView.getContext().registerReceiver(this.receiver, intentFilter);
+ }
+ // end CB-1405
+ }
+
+ private void enableRemoteDebugging() {
+ try {
+ WebView.setWebContentsDebuggingEnabled(true);
+ } catch (IllegalArgumentException e) {
+ LOG.d(TAG, "You have one job! To turn on Remote Web Debugging! YOU HAVE FAILED! ");
+ e.printStackTrace();
+ }
+ }
+
+ // Yeah, we know. It'd be great if lint was just a little smarter.
+ @SuppressLint("AddJavascriptInterface")
+ private static void exposeJsInterface(WebView webView, CordovaBridge bridge) {
+ SystemExposedJsApi exposedJsApi = new SystemExposedJsApi(bridge);
+ webView.addJavascriptInterface(exposedJsApi, "_cordovaNative");
+ }
+
+
+ /**
+ * Load the url into the webview.
+ */
+ @Override
+ public void loadUrl(final String url, boolean clearNavigationStack) {
+ webView.loadUrl(url);
+ }
+
+ @Override
+ public String getUrl() {
+ return webView.getUrl();
+ }
+
+ @Override
+ public void stopLoading() {
+ webView.stopLoading();
+ }
+
+ @Override
+ public void clearCache() {
+ webView.clearCache(true);
+ }
+
+ @Override
+ public void clearHistory() {
+ webView.clearHistory();
+ }
+
+ @Override
+ public boolean canGoBack() {
+ return webView.canGoBack();
+ }
+
+ /**
+ * Go to previous page in history. (We manage our own history)
+ *
+ * @return true if we went back, false if we are already at top
+ */
+ @Override
+ public boolean goBack() {
+ // Check webview first to see if there is a history
+ // This is needed to support curPage#diffLink, since they are added to parentEngine's history, but not our history url array (JQMobile behavior)
+ if (webView.canGoBack()) {
+ webView.goBack();
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public void setPaused(boolean value) {
+ if (value) {
+ webView.onPause();
+ webView.pauseTimers();
+ } else {
+ webView.onResume();
+ webView.resumeTimers();
+ }
+ }
+
+ @Override
+ public void destroy() {
+ webView.chromeClient.destroyLastDialog();
+ webView.destroy();
+ // unregister the receiver
+ if (receiver != null) {
+ try {
+ webView.getContext().unregisterReceiver(receiver);
+ } catch (Exception e) {
+ LOG.e(TAG, "Error unregistering configuration receiver: " + e.getMessage(), e);
+ }
+ }
+ }
+
+ @Override
+ public void evaluateJavascript(String js, ValueCallback callback) {
+ webView.evaluateJavascript(js, callback);
+ }
+}
diff --git a/node_modules/cordova-android/lib/Adb.js b/node_modules/cordova-android/lib/Adb.js
new file mode 100644
index 0000000..9326269
--- /dev/null
+++ b/node_modules/cordova-android/lib/Adb.js
@@ -0,0 +1,97 @@
+/**
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+var os = require('os');
+var execa = require('execa');
+var events = require('cordova-common').events;
+var CordovaError = require('cordova-common').CordovaError;
+
+var Adb = {};
+
+/**
+ * Lists available/connected devices and emulators
+ *
+ * @return {Promise} list of available/connected
+ * devices/emulators
+ */
+Adb.devices = async function () {
+ const { stdout } = await execa('adb', ['devices'], { cwd: os.tmpdir() });
+
+ // Split into lines & drop first one (header)
+ const rawDeviceLines = stdout.trim().split(/\r?\n/).slice(1);
+
+ return rawDeviceLines
+ .map(line => line.split('\t'))
+
+ // We are only interested in fully booted devices & emulators. These
+ // have a state of `device`. For a list of all the other possible states
+ // see https://github.com/aosp-mirror/platform_system_core/blob/2abdb1eb5b83c8f39874644af576c869815f5c5b/adb/transport.cpp#L1129
+ .filter(([, state]) => state === 'device')
+
+ .map(([id]) => id);
+};
+
+Adb.install = function (target, packagePath, { replace = false, execOptions = {} } = {}) {
+ events.emit('verbose', 'Installing apk ' + packagePath + ' on target ' + target + '...');
+
+ var args = ['-s', target, 'install'];
+ if (replace) args.push('-r');
+
+ const opts = { cwd: os.tmpdir(), ...execOptions };
+
+ return execa('adb', args.concat(packagePath), opts).then(({ stdout: output }) => {
+ // adb does not return an error code even if installation fails. Instead it puts a specific
+ // message to stdout, so we have to use RegExp matching to detect installation failure.
+ if (output.match(/Failure/)) {
+ if (output.match(/INSTALL_PARSE_FAILED_NO_CERTIFICATES/)) {
+ output += '\n\n' + 'Sign the build using \'-- --keystore\' or \'--buildConfig\'' +
+ ' or sign and deploy the unsigned apk manually using Android tools.';
+ } else if (output.match(/INSTALL_FAILED_VERSION_DOWNGRADE/)) {
+ output += '\n\n' + 'You\'re trying to install apk with a lower versionCode that is already installed.' +
+ '\nEither uninstall an app or increment the versionCode.';
+ }
+
+ throw new CordovaError('Failed to install apk to target: ' + output);
+ }
+ });
+};
+
+Adb.uninstall = function (target, packageId) {
+ events.emit('verbose', 'Uninstalling package ' + packageId + ' from target ' + target + '...');
+ return execa('adb', ['-s', target, 'uninstall', packageId], { cwd: os.tmpdir() }).then(({ stdout }) => stdout);
+};
+
+Adb.shell = function (target, shellCommand) {
+ events.emit('verbose', 'Running adb shell command "' + shellCommand + '" on target ' + target + '...');
+ var args = ['-s', target, 'shell'];
+ shellCommand = shellCommand.split(/\s+/);
+ return execa('adb', args.concat(shellCommand), { cwd: os.tmpdir() })
+ .then(({ stdout }) => stdout)
+ .catch(error => Promise.reject(new CordovaError(`Failed to execute shell command "${shellCommand}" on device: ${error}`)));
+};
+
+Adb.start = function (target, activityName) {
+ events.emit('verbose', 'Starting application "' + activityName + '" on target ' + target + '...');
+ return Adb.shell(target, 'am start -W -a android.intent.action.MAIN -n' + activityName).catch((error) => {
+ return Promise.reject(new CordovaError('Failed to start application "' +
+ activityName + '"" on device: ' + error));
+ });
+};
+
+module.exports = Adb;
diff --git a/node_modules/cordova-android/lib/AndroidManifest.js b/node_modules/cordova-android/lib/AndroidManifest.js
new file mode 100644
index 0000000..be4fecc
--- /dev/null
+++ b/node_modules/cordova-android/lib/AndroidManifest.js
@@ -0,0 +1,128 @@
+/**
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+var fs = require('fs');
+var xml = require('cordova-common').xmlHelpers;
+
+var DEFAULT_ORIENTATION = 'default';
+
+/** Wraps an AndroidManifest file */
+class AndroidManifest {
+ constructor (path) {
+ this.path = path;
+ this.doc = xml.parseElementtreeSync(path);
+ if (this.doc.getroot().tag !== 'manifest') {
+ throw new Error('AndroidManifest at ' + path + ' has incorrect root node name (expected "manifest")');
+ }
+ }
+
+ getVersionName () {
+ return this.doc.getroot().attrib['android:versionName'];
+ }
+
+ setVersionName (versionName) {
+ this.doc.getroot().attrib['android:versionName'] = versionName;
+ return this;
+ }
+
+ getVersionCode () {
+ return this.doc.getroot().attrib['android:versionCode'];
+ }
+
+ setVersionCode (versionCode) {
+ this.doc.getroot().attrib['android:versionCode'] = versionCode;
+ return this;
+ }
+
+ getPackageId () {
+ return this.doc.getroot().attrib.package;
+ }
+
+ setPackageId (pkgId) {
+ this.doc.getroot().attrib.package = pkgId;
+ return this;
+ }
+
+ getActivity () {
+ var activity = this.doc.getroot().find('./application/activity');
+ return {
+ getName: function () {
+ return activity.attrib['android:name'];
+ },
+ setName: function (name) {
+ if (!name) {
+ delete activity.attrib['android:name'];
+ } else {
+ activity.attrib['android:name'] = name;
+ }
+ return this;
+ },
+ getOrientation: function () {
+ return activity.attrib['android:screenOrientation'];
+ },
+ setOrientation: function (orientation) {
+ if (!orientation || orientation.toLowerCase() === DEFAULT_ORIENTATION) {
+ delete activity.attrib['android:screenOrientation'];
+ } else {
+ activity.attrib['android:screenOrientation'] = orientation;
+ }
+ return this;
+ },
+ getLaunchMode: function () {
+ return activity.attrib['android:launchMode'];
+ },
+ setLaunchMode: function (launchMode) {
+ if (!launchMode) {
+ delete activity.attrib['android:launchMode'];
+ } else {
+ activity.attrib['android:launchMode'] = launchMode;
+ }
+ return this;
+ }
+ };
+ }
+
+ getDebuggable () {
+ return this.doc.getroot().find('./application').attrib['android:debuggable'] === 'true';
+ }
+
+ setDebuggable (value) {
+ var application = this.doc.getroot().find('./application');
+ if (value) {
+ application.attrib['android:debuggable'] = 'true';
+ } else {
+ // The default value is "false", so we can remove attribute at all.
+ delete application.attrib['android:debuggable'];
+ }
+ return this;
+ }
+
+ /**
+ * Writes manifest to disk syncronously. If filename is specified, then manifest
+ * will be written to that file
+ *
+ * @param {String} [destPath] File to write manifest to. If omitted,
+ * manifest will be written to file it has been read from.
+ */
+ write (destPath) {
+ fs.writeFileSync(destPath || this.path, this.doc.write({ indent: 4 }), 'utf-8');
+ }
+}
+
+module.exports = AndroidManifest;
diff --git a/node_modules/cordova-android/lib/AndroidProject.js b/node_modules/cordova-android/lib/AndroidProject.js
new file mode 100644
index 0000000..5d1c3c3
--- /dev/null
+++ b/node_modules/cordova-android/lib/AndroidProject.js
@@ -0,0 +1,202 @@
+/**
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+var fs = require('fs');
+var path = require('path');
+var properties_parser = require('properties-parser');
+var AndroidManifest = require('./AndroidManifest');
+var pluginHandlers = require('./pluginHandlers');
+
+var projectFileCache = {};
+
+function addToPropertyList (projectProperties, key, value) {
+ var i = 1;
+ while (projectProperties.get(key + '.' + i)) { i++; }
+
+ projectProperties.set(key + '.' + i, value);
+ projectProperties.dirty = true;
+}
+
+function removeFromPropertyList (projectProperties, key, value) {
+ var i = 1;
+ var currentValue;
+ while ((currentValue = projectProperties.get(key + '.' + i))) {
+ if (currentValue === value) {
+ while ((currentValue = projectProperties.get(key + '.' + (i + 1)))) {
+ projectProperties.set(key + '.' + i, currentValue);
+ i++;
+ }
+ projectProperties.set(key + '.' + i);
+ break;
+ }
+ i++;
+ }
+ projectProperties.dirty = true;
+}
+
+function getRelativeLibraryPath (parentDir, subDir) {
+ var libraryPath = path.relative(parentDir, subDir);
+ return (path.sep === '\\') ? libraryPath.replace(/\\/g, '/') : libraryPath;
+}
+
+class AndroidProject {
+ constructor (projectDir) {
+ this._propertiesEditors = {};
+ this._subProjectDirs = {};
+ this._dirty = false;
+ this.projectDir = projectDir;
+ this.platformWww = path.join(this.projectDir, 'platform_www');
+ this.www = path.join(this.projectDir, 'app/src/main/assets/www');
+ }
+
+ /**
+ * Reads the package name out of the Android Manifest file
+ *
+ * @param {String} projectDir The absolute path to the directory containing the project
+ * @return {String} The name of the package
+ */
+ getPackageName () {
+ var manifestPath = path.join(this.projectDir, 'app/src/main/AndroidManifest.xml');
+ return new AndroidManifest(manifestPath).getPackageId();
+ }
+
+ getCustomSubprojectRelativeDir (plugin_id, src) {
+ // All custom subprojects are prefixed with the last portion of the package id.
+ // This is to avoid collisions when opening multiple projects in Eclipse that have subprojects with the same name.
+ var packageName = this.getPackageName();
+ var lastDotIndex = packageName.lastIndexOf('.');
+ var prefix = packageName.substring(lastDotIndex + 1);
+ var subRelativeDir = path.join(plugin_id, prefix + '-' + path.basename(src));
+ return subRelativeDir;
+ }
+
+ addSubProject (parentDir, subDir) {
+ var parentProjectFile = path.resolve(parentDir, 'project.properties');
+ var subProjectFile = path.resolve(subDir, 'project.properties');
+ var parentProperties = this._getPropertiesFile(parentProjectFile);
+ // TODO: Setting the target needs to happen only for pre-3.7.0 projects
+ if (fs.existsSync(subProjectFile)) {
+ var subProperties = this._getPropertiesFile(subProjectFile);
+ subProperties.set('target', parentProperties.get('target'));
+ subProperties.dirty = true;
+ this._subProjectDirs[subDir] = true;
+ }
+ addToPropertyList(parentProperties, 'android.library.reference', getRelativeLibraryPath(parentDir, subDir));
+
+ this._dirty = true;
+ }
+
+ removeSubProject (parentDir, subDir) {
+ var parentProjectFile = path.resolve(parentDir, 'project.properties');
+ var parentProperties = this._getPropertiesFile(parentProjectFile);
+ removeFromPropertyList(parentProperties, 'android.library.reference', getRelativeLibraryPath(parentDir, subDir));
+ delete this._subProjectDirs[subDir];
+ this._dirty = true;
+ }
+
+ addGradleReference (parentDir, subDir) {
+ var parentProjectFile = path.resolve(parentDir, 'project.properties');
+ var parentProperties = this._getPropertiesFile(parentProjectFile);
+ addToPropertyList(parentProperties, 'cordova.gradle.include', getRelativeLibraryPath(parentDir, subDir));
+ this._dirty = true;
+ }
+
+ removeGradleReference (parentDir, subDir) {
+ var parentProjectFile = path.resolve(parentDir, 'project.properties');
+ var parentProperties = this._getPropertiesFile(parentProjectFile);
+ removeFromPropertyList(parentProperties, 'cordova.gradle.include', getRelativeLibraryPath(parentDir, subDir));
+ this._dirty = true;
+ }
+
+ addSystemLibrary (parentDir, value) {
+ var parentProjectFile = path.resolve(parentDir, 'project.properties');
+ var parentProperties = this._getPropertiesFile(parentProjectFile);
+ addToPropertyList(parentProperties, 'cordova.system.library', value);
+ this._dirty = true;
+ }
+
+ removeSystemLibrary (parentDir, value) {
+ var parentProjectFile = path.resolve(parentDir, 'project.properties');
+ var parentProperties = this._getPropertiesFile(parentProjectFile);
+ removeFromPropertyList(parentProperties, 'cordova.system.library', value);
+ this._dirty = true;
+ }
+
+ write () {
+ if (!this._dirty) {
+ return;
+ }
+ this._dirty = false;
+
+ for (var filename in this._propertiesEditors) {
+ var editor = this._propertiesEditors[filename];
+ if (editor.dirty) {
+ fs.writeFileSync(filename, editor.toString());
+ editor.dirty = false;
+ }
+ }
+ }
+
+ getInstaller (type) {
+ return pluginHandlers.getInstaller(type);
+ }
+
+ getUninstaller (type) {
+ return pluginHandlers.getUninstaller(type);
+ }
+
+ /*
+ * This checks if an Android project is clean or has old build artifacts
+ */
+ isClean () {
+ var build_path = path.join(this.projectDir, 'build');
+ // If the build directory doesn't exist, it's clean
+ return !(fs.existsSync(build_path));
+ }
+
+ _getPropertiesFile (filename) {
+ if (!this._propertiesEditors[filename]) {
+ if (fs.existsSync(filename)) {
+ this._propertiesEditors[filename] = properties_parser.createEditor(filename);
+ } else {
+ this._propertiesEditors[filename] = properties_parser.createEditor();
+ }
+ }
+
+ return this._propertiesEditors[filename];
+ }
+
+ static getProjectFile (projectDir) {
+ if (!projectFileCache[projectDir]) {
+ projectFileCache[projectDir] = new AndroidProject(projectDir);
+ }
+
+ return projectFileCache[projectDir];
+ }
+
+ static purgeCache (projectDir) {
+ if (projectDir) {
+ delete projectFileCache[projectDir];
+ } else {
+ projectFileCache = {};
+ }
+ }
+}
+
+module.exports = AndroidProject;
diff --git a/node_modules/cordova-android/lib/Api.js b/node_modules/cordova-android/lib/Api.js
new file mode 100644
index 0000000..b9b5192
--- /dev/null
+++ b/node_modules/cordova-android/lib/Api.js
@@ -0,0 +1,378 @@
+/**
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+var path = require('path');
+
+var AndroidProject = require('./AndroidProject');
+var PluginManager = require('cordova-common').PluginManager;
+
+var CordovaLogger = require('cordova-common').CordovaLogger;
+var selfEvents = require('cordova-common').events;
+var ConfigParser = require('cordova-common').ConfigParser;
+const prepare = require('./prepare').prepare;
+
+var PLATFORM = 'android';
+const VERSION = require('../package').version;
+
+function setupEvents (externalEventEmitter) {
+ if (externalEventEmitter) {
+ // This will make the platform internal events visible outside
+ selfEvents.forwardEventsTo(externalEventEmitter);
+ return externalEventEmitter;
+ }
+
+ // There is no logger if external emitter is not present,
+ // so attach a console logger
+ CordovaLogger.get().subscribe(selfEvents);
+ return selfEvents;
+}
+
+/**
+ * Class, that acts as abstraction over particular platform. Encapsulates the
+ * platform's properties and methods.
+ *
+ * Platform that implements own PlatformApi instance _should implement all
+ * prototype methods_ of this class to be fully compatible with cordova-lib.
+ *
+ * The PlatformApi instance also should define the following field:
+ *
+ * * platform: String that defines a platform name.
+ * @class Api
+ */
+class Api {
+ constructor (platform, platformRootDir, events) {
+ this.platform = PLATFORM;
+ this.root = platformRootDir;
+
+ setupEvents(events);
+
+ const appMain = path.join(this.root, 'app', 'src', 'main');
+ const appRes = path.join(appMain, 'res');
+
+ this.locations = {
+ root: this.root,
+ www: path.join(appMain, 'assets', 'www'),
+ res: appRes,
+ platformWww: path.join(this.root, 'platform_www'),
+ configXml: path.join(appRes, 'xml', 'config.xml'),
+ defaultConfigXml: path.join(this.root, 'cordova', 'defaults.xml'),
+ strings: path.join(appRes, 'values', 'strings.xml'),
+ manifest: path.join(appMain, 'AndroidManifest.xml'),
+ build: path.join(this.root, 'build'),
+ javaSrc: path.join(appMain, 'java')
+ };
+
+ this._builder = require('./builders/builders').getBuilder(this.root);
+ }
+
+ /**
+ * Gets a CordovaPlatform object, that represents the platform structure.
+ *
+ * @return {CordovaPlatform} A structure that contains the description of
+ * platform's file structure and other properties of platform.
+ */
+ getPlatformInfo () {
+ var result = {};
+ result.locations = this.locations;
+ result.root = this.root;
+ result.name = this.platform;
+ result.version = Api.version();
+ result.projectConfig = this._config;
+
+ return result;
+ }
+
+ /**
+ * Updates installed platform with provided www assets and new app
+ * configuration. This method is required for CLI workflow and will be called
+ * each time before build, so the changes, made to app configuration and www
+ * code, will be applied to platform.
+ *
+ * @param {CordovaProject} cordovaProject A CordovaProject instance, that defines a
+ * project structure and configuration, that should be applied to platform
+ * (contains project's www location and ConfigParser instance for project's
+ * config).
+ *
+ * @return {Promise} Return a promise either fulfilled, or rejected with
+ * CordovaError instance.
+ */
+ prepare (cordovaProject, prepareOptions) {
+ cordovaProject.projectConfig = new ConfigParser(cordovaProject.locations.rootConfigXml || cordovaProject.projectConfig.path);
+
+ return prepare.call(this, cordovaProject, prepareOptions);
+ }
+
+ /**
+ * Installs a new plugin into platform. This method only copies non-www files
+ * (sources, libs, etc.) to platform. It also doesn't resolves the
+ * dependencies of plugin. Both of handling of www files, such as assets and
+ * js-files and resolving dependencies are the responsibility of caller.
+ *
+ * @param {PluginInfo} plugin A PluginInfo instance that represents plugin
+ * that will be installed.
+ * @param {Object} installOptions An options object. Possible options below:
+ * @param {Boolean} installOptions.link: Flag that specifies that plugin
+ * sources will be symlinked to app's directory instead of copying (if
+ * possible).
+ * @param {Object} installOptions.variables An object that represents
+ * variables that will be used to install plugin. See more details on plugin
+ * variables in documentation:
+ * https://cordova.apache.org/docs/en/4.0.0/plugin_ref_spec.md.html
+ *
+ * @return {Promise} Return a promise either fulfilled, or rejected with
+ * CordovaError instance.
+ */
+ addPlugin (plugin, installOptions) {
+ var project = AndroidProject.getProjectFile(this.root);
+ var self = this;
+
+ installOptions = installOptions || {};
+ installOptions.variables = installOptions.variables || {};
+ // Add PACKAGE_NAME variable into vars
+ if (!installOptions.variables.PACKAGE_NAME) {
+ installOptions.variables.PACKAGE_NAME = project.getPackageName();
+ }
+
+ return Promise.resolve().then(function () {
+ return PluginManager.get(self.platform, self.locations, project).addPlugin(plugin, installOptions);
+ }).then(function () {
+ if (plugin.getFrameworks(this.platform).length === 0) return;
+ selfEvents.emit('verbose', 'Updating build files since android plugin contained ');
+ // This should pick the correct builder, not just get gradle
+ this._builder.prepBuildFiles();
+ }.bind(this))
+ // CB-11022 Return truthy value to prevent running prepare after
+ .then(() => true);
+ }
+
+ /**
+ * Removes an installed plugin from platform.
+ *
+ * Since method accepts PluginInfo instance as input parameter instead of plugin
+ * id, caller shoud take care of managing/storing PluginInfo instances for
+ * future uninstalls.
+ *
+ * @param {PluginInfo} plugin A PluginInfo instance that represents plugin
+ * that will be installed.
+ *
+ * @return {Promise} Return a promise either fulfilled, or rejected with
+ * CordovaError instance.
+ */
+ removePlugin (plugin, uninstallOptions) {
+ var project = AndroidProject.getProjectFile(this.root);
+
+ if (uninstallOptions && uninstallOptions.usePlatformWww === true) {
+ uninstallOptions.usePlatformWww = false;
+ }
+
+ return PluginManager.get(this.platform, this.locations, project)
+ .removePlugin(plugin, uninstallOptions)
+ .then(function () {
+ if (plugin.getFrameworks(this.platform).length === 0) return;
+
+ selfEvents.emit('verbose', 'Updating build files since android plugin contained ');
+ this._builder.prepBuildFiles();
+ }.bind(this))
+ // CB-11022 Return truthy value to prevent running prepare after
+ .then(() => true);
+ }
+
+ /**
+ * Builds an application package for current platform.
+ *
+ * @param {Object} buildOptions A build options. This object's structure is
+ * highly depends on platform's specific. The most common options are:
+ * @param {Boolean} buildOptions.debug Indicates that packages should be
+ * built with debug configuration. This is set to true by default unless the
+ * 'release' option is not specified.
+ * @param {Boolean} buildOptions.release Indicates that packages should be
+ * built with release configuration. If not set to true, debug configuration
+ * will be used.
+ * @param {Boolean} buildOptions.device Specifies that built app is intended
+ * to run on device
+ * @param {Boolean} buildOptions.emulator: Specifies that built app is
+ * intended to run on emulator
+ * @param {String} buildOptions.target Specifies the device id that will be
+ * used to run built application.
+ * @param {Boolean} buildOptions.nobuild Indicates that this should be a
+ * dry-run call, so no build artifacts will be produced.
+ * @param {String[]} buildOptions.archs Specifies chip architectures which
+ * app packages should be built for. List of valid architectures is depends on
+ * platform.
+ * @param {String} buildOptions.buildConfig The path to build configuration
+ * file. The format of this file is depends on platform.
+ * @param {String[]} buildOptions.argv Raw array of command-line arguments,
+ * passed to `build` command. The purpose of this property is to pass a
+ * platform-specific arguments, and eventually let platform define own
+ * arguments processing logic.
+ *
+ * @return {Promise} A promise either fulfilled with an array of build
+ * artifacts (application packages) if package was built successfully,
+ * or rejected with CordovaError. The resultant build artifact objects is not
+ * strictly typed and may conatin arbitrary set of fields as in sample below.
+ *
+ * {
+ * architecture: 'x86',
+ * buildType: 'debug',
+ * path: '/path/to/build',
+ * type: 'app'
+ * }
+ *
+ * The return value in most cases will contain only one item but in some cases
+ * there could be multiple items in output array, e.g. when multiple
+ * arhcitectures is specified.
+ */
+ build (buildOptions) {
+ var self = this;
+
+ return require('./check_reqs').run().then(function () {
+ return require('./build').run.call(self, buildOptions);
+ }).then(function (buildResults) {
+ // Cast build result to array of build artifacts
+ return buildResults.paths.map(function (apkPath) {
+ return {
+ buildType: buildResults.buildType,
+ buildMethod: buildResults.buildMethod,
+ path: apkPath,
+ type: path.extname(apkPath).replace(/\./g, '')
+ };
+ });
+ });
+ }
+
+ /**
+ * Builds an application package for current platform and runs it on
+ * specified/default device. If no 'device'/'emulator'/'target' options are
+ * specified, then tries to run app on default device if connected, otherwise
+ * runs the app on emulator.
+ *
+ * @param {Object} runOptions An options object. The structure is the same
+ * as for build options.
+ *
+ * @return {Promise} A promise either fulfilled if package was built and ran
+ * successfully, or rejected with CordovaError.
+ */
+ run (runOptions) {
+ var self = this;
+ return require('./check_reqs').run().then(function () {
+ return require('./run').run.call(self, runOptions);
+ });
+ }
+
+ /**
+ * Cleans out the build artifacts from platform's directory, and also
+ * cleans out the platform www directory if called without options specified.
+ *
+ * @return {Promise} Return a promise either fulfilled, or rejected with
+ * CordovaError.
+ */
+ clean (cleanOptions) {
+ var self = this;
+ // This will lint, checking for null won't
+ if (typeof cleanOptions === 'undefined') {
+ cleanOptions = {};
+ }
+
+ return require('./check_reqs').run().then(function () {
+ return require('./build').runClean.call(self, cleanOptions);
+ }).then(function () {
+ return require('./prepare').clean.call(self, cleanOptions);
+ });
+ }
+
+ /**
+ * Performs a requirements check for current platform. Each platform defines its
+ * own set of requirements, which should be resolved before platform can be
+ * built successfully.
+ *
+ * @return {Promise} Promise, resolved with set of Requirement
+ * objects for current platform.
+ */
+ requirements () {
+ return require('./check_reqs').check_all(this.root);
+ }
+
+ /**
+ * Installs platform to specified directory and creates a platform project.
+ *
+ * @param {String} destination Destination directory, where insatll platform to
+ * @param {ConfigParser} [config] ConfgiParser instance, used to retrieve
+ * project creation options, such as package id and project name.
+ * @param {Object} [options] An options object. The most common options are:
+ * @param {String} [options.customTemplate] A path to custom template, that
+ * should override the default one from platform.
+ * @param {Boolean} [options.link] Flag that indicates that platform's
+ * sources will be linked to installed platform instead of copying.
+ * @param {EventEmitter} [events] An EventEmitter instance that will be used for
+ * logging purposes. If no EventEmitter provided, all events will be logged to
+ * console
+ *
+ * @return {Promise} Promise either fulfilled with PlatformApi
+ * instance or rejected with CordovaError.
+ */
+ static createPlatform (destination, config, options, events) {
+ events = setupEvents(events);
+ var result;
+ try {
+ result = require('./create').create(destination, config, options, events).then(function (destination) {
+ return new Api(PLATFORM, destination, events);
+ });
+ } catch (e) {
+ events.emit('error', 'createPlatform is not callable from the android project API.');
+ throw (e);
+ }
+ return result;
+ }
+
+ /**
+ * Updates already installed platform.
+ *
+ * @param {String} destination Destination directory, where platform installed
+ * @param {Object} [options] An options object. The most common options are:
+ * @param {String} [options.customTemplate] A path to custom template, that
+ * should override the default one from platform.
+ * @param {Boolean} [options.link] Flag that indicates that platform's
+ * sources will be linked to installed platform instead of copying.
+ * @param {EventEmitter} [events] An EventEmitter instance that will be used for
+ * logging purposes. If no EventEmitter provided, all events will be logged to
+ * console
+ *
+ * @return {Promise} Promise either fulfilled with PlatformApi
+ * instance or rejected with CordovaError.
+ */
+ static updatePlatform (destination, options, events) {
+ events = setupEvents(events);
+ var result;
+ try {
+ result = require('../../lib/create').update(destination, options, events).then(function (destination) {
+ return new Api(PLATFORM, destination, events);
+ });
+ } catch (e) {
+ events.emit('error', 'updatePlatform is not callable from the android project API, you will need to do this manually.');
+ throw (e);
+ }
+ return result;
+ }
+
+ static version () {
+ return VERSION;
+ }
+}
+
+module.exports = Api;
diff --git a/node_modules/cordova-android/lib/PackageType.js b/node_modules/cordova-android/lib/PackageType.js
new file mode 100644
index 0000000..fd129f1
--- /dev/null
+++ b/node_modules/cordova-android/lib/PackageType.js
@@ -0,0 +1,25 @@
+/**
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+const PackageType = {
+ APK: 'apk',
+ BUNDLE: 'bundle'
+};
+
+module.exports = PackageType;
diff --git a/node_modules/cordova-android/lib/android_sdk.js b/node_modules/cordova-android/lib/android_sdk.js
new file mode 100644
index 0000000..5d9da08
--- /dev/null
+++ b/node_modules/cordova-android/lib/android_sdk.js
@@ -0,0 +1,90 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+const execa = require('execa');
+
+var suffix_number_regex = /(\d+)$/;
+// Used for sorting Android targets, example strings to sort:
+// android-19
+// android-L
+// Google Inc.:Google APIs:20
+// Google Inc.:Glass Development Kit Preview:20
+// The idea is to sort based on largest "suffix" number - meaning the bigger
+// the number at the end, the more recent the target, the closer to the
+// start of the array.
+function sort_by_largest_numerical_suffix (a, b) {
+ let suffix_a = a.match(suffix_number_regex);
+ let suffix_b = b.match(suffix_number_regex);
+ // If no number is detected (eg: preview version like android-R),
+ // designate a suffix of 0 so it gets moved to the end
+ suffix_a = suffix_a || ['0', '0'];
+ suffix_b = suffix_b || ['0', '0'];
+ // Return < zero, or > zero, based on which suffix is larger.
+ return (parseInt(suffix_a[1]) > parseInt(suffix_b[1]) ? -1 : 1);
+}
+
+module.exports.print_newest_available_sdk_target = function () {
+ return module.exports.list_targets().then(function (targets) {
+ targets.sort(sort_by_largest_numerical_suffix);
+ console.log(targets[0]);
+ });
+};
+
+// Versions should not be represented as float, so we disable quote-props here
+/* eslint-disable quote-props */
+module.exports.version_string_to_api_level = {
+ '4.0': 14,
+ '4.0.3': 15,
+ '4.1': 16,
+ '4.2': 17,
+ '4.3': 18,
+ '4.4': 19,
+ '4.4W': 20,
+ '5.0': 21,
+ '5.1': 22,
+ '6.0': 23,
+ '7.0': 24,
+ '7.1.1': 25,
+ '8.0': 26
+};
+/* eslint-enable quote-props */
+
+function parse_targets (output) {
+ var target_out = output.split('\n');
+ var targets = [];
+ for (var i = target_out.length - 1; i >= 0; i--) {
+ if (target_out[i].match(/id:/)) { // if "id:" is in the line...
+ targets.push(target_out[i].match(/"(.+)"/)[1]); // .. match whatever is in quotes.
+ }
+ }
+ return targets;
+}
+
+module.exports.list_targets_with_avdmanager = function () {
+ return execa('avdmanager', ['list', 'target']).then(result => parse_targets(result.stdout));
+};
+
+module.exports.list_targets = function () {
+ return module.exports.list_targets_with_avdmanager().then(function (targets) {
+ if (targets.length === 0) {
+ return Promise.reject(new Error('No android targets (SDKs) installed!'));
+ }
+ return targets;
+ });
+};
diff --git a/node_modules/cordova-android/lib/build.js b/node_modules/cordova-android/lib/build.js
new file mode 100644
index 0000000..1a5c54d
--- /dev/null
+++ b/node_modules/cordova-android/lib/build.js
@@ -0,0 +1,246 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+var path = require('path');
+var fs = require('fs');
+var nopt = require('nopt');
+const untildify = require('untildify');
+
+var Adb = require('./Adb');
+
+var events = require('cordova-common').events;
+var PackageType = require('./PackageType');
+
+module.exports.parseBuildOptions = parseOpts;
+function parseOpts (options, resolvedTarget, projectRoot) {
+ options = options || {};
+ options.argv = nopt({
+ prepenv: Boolean,
+ versionCode: String,
+ minSdkVersion: String,
+ maxSdkVersion: String,
+ targetSdkVersion: String,
+ gradleArg: [String, Array],
+ keystore: path,
+ alias: String,
+ storePassword: String,
+ password: String,
+ keystoreType: String,
+ packageType: String
+ }, {}, options.argv, 0);
+
+ // Android Studio Build method is the default
+ var ret = {
+ buildType: options.release ? 'release' : 'debug',
+ prepEnv: options.argv.prepenv,
+ arch: resolvedTarget && resolvedTarget.arch,
+ extraArgs: []
+ };
+
+ if (options.argv.versionCode) { ret.extraArgs.push('-PcdvVersionCode=' + options.argv.versionCode); }
+ if (options.argv.minSdkVersion) { ret.extraArgs.push('-PcdvMinSdkVersion=' + options.argv.minSdkVersion); }
+ if (options.argv.maxSdkVersion) { ret.extraArgs.push('-PcdvMaxSdkVersion=' + options.argv.maxSdkVersion); }
+ if (options.argv.targetSdkVersion) { ret.extraArgs.push('-PcdvTargetSdkVersion=' + options.argv.targetSdkVersion); }
+ if (options.argv.gradleArg) {
+ ret.extraArgs = ret.extraArgs.concat(options.argv.gradleArg);
+ }
+
+ var packageArgs = {};
+
+ if (options.argv.keystore) { packageArgs.keystore = path.relative(projectRoot, path.resolve(options.argv.keystore)); }
+
+ ['alias', 'storePassword', 'password', 'keystoreType', 'packageType'].forEach(function (flagName) {
+ if (options.argv[flagName]) { packageArgs[flagName] = options.argv[flagName]; }
+ });
+
+ var buildConfig = options.buildConfig;
+
+ // If some values are not specified as command line arguments - use build config to supplement them.
+ // Command line arguments have precedence over build config.
+ if (buildConfig) {
+ if (!fs.existsSync(buildConfig)) {
+ throw new Error('Specified build config file does not exist: ' + buildConfig);
+ }
+ events.emit('log', 'Reading build config file: ' + path.resolve(buildConfig));
+ var buildjson = fs.readFileSync(buildConfig, 'utf8');
+ var config = JSON.parse(buildjson.replace(/^\ufeff/, '')); // Remove BOM
+ if (config.android && config.android[ret.buildType]) {
+ var androidInfo = config.android[ret.buildType];
+ if (androidInfo.keystore && !packageArgs.keystore) {
+ androidInfo.keystore = untildify(androidInfo.keystore);
+ packageArgs.keystore = path.resolve(path.dirname(buildConfig), androidInfo.keystore);
+ events.emit('log', 'Reading the keystore from: ' + packageArgs.keystore);
+ }
+
+ ['alias', 'storePassword', 'password', 'keystoreType', 'packageType'].forEach(function (key) {
+ packageArgs[key] = packageArgs[key] || androidInfo[key];
+ });
+ }
+ }
+
+ if (packageArgs.keystore && packageArgs.alias) {
+ ret.packageInfo = new PackageInfo(packageArgs.keystore, packageArgs.alias, packageArgs.storePassword,
+ packageArgs.password, packageArgs.keystoreType);
+ }
+
+ if (!ret.packageInfo) {
+ // The following loop is to decide whether to print a warning about generating a signed archive
+ // We only want to produce a warning if they are using a config property that is related to signing, but
+ // missing the required properties for signing. We don't want to produce a warning if they are simply
+ // using a build property that isn't related to signing, such as --packageType
+ let shouldWarn = false;
+ const signingKeys = ['keystore', 'alias', 'storePassword', 'password', 'keystoreType'];
+
+ for (const key in packageArgs) {
+ if (!shouldWarn && signingKeys.indexOf(key) > -1) {
+ // If we enter this condition, we have a key used for signing a build,
+ // but we are missing some required signing properties
+ shouldWarn = true;
+ }
+ }
+
+ if (shouldWarn) {
+ events.emit('warn', '\'keystore\' and \'alias\' need to be specified to generate a signed archive.');
+ }
+ }
+
+ if (packageArgs.packageType) {
+ const VALID_PACKAGE_TYPES = [PackageType.APK, PackageType.BUNDLE];
+ if (VALID_PACKAGE_TYPES.indexOf(packageArgs.packageType) === -1) {
+ events.emit('warn', '"' + packageArgs.packageType + '" is an invalid packageType. Valid values are: ' + VALID_PACKAGE_TYPES.join(', ') + '\nDefaulting packageType to ' + PackageType.APK);
+ ret.packageType = PackageType.APK;
+ } else {
+ ret.packageType = packageArgs.packageType;
+ }
+ } else {
+ if (ret.buildType === 'release') {
+ ret.packageType = PackageType.BUNDLE;
+ } else {
+ ret.packageType = PackageType.APK;
+ }
+ }
+
+ return ret;
+}
+
+/*
+ * Builds the project with the specifed options
+ * Returns a promise.
+ */
+module.exports.runClean = function (options) {
+ var opts = parseOpts(options, null, this.root);
+ var builder = this._builder;
+
+ return builder.prepEnv(opts).then(function () {
+ return builder.clean(opts);
+ });
+};
+
+/**
+ * Builds the project with the specifed options.
+ *
+ * @param {BuildOptions} options A set of options. See PlatformApi.build
+ * method documentation for reference.
+ * @param {Object} optResolvedTarget A deployment target. Used to pass
+ * target architecture from upstream 'run' call. TODO: remove this option in
+ * favor of setting buildOptions.archs field.
+ *
+ * @return {Promise} Promise, resolved with built packages
+ * information.
+ */
+module.exports.run = function (options, optResolvedTarget) {
+ var opts = parseOpts(options, optResolvedTarget, this.root);
+ var builder = this._builder;
+
+ return builder.prepEnv(opts).then(function () {
+ if (opts.prepEnv) {
+ events.emit('verbose', 'Build file successfully prepared.');
+ return;
+ }
+ return builder.build(opts).then(function () {
+ var paths;
+ if (opts.packageType === PackageType.BUNDLE) {
+ paths = builder.findOutputBundles(opts.buildType);
+ events.emit('log', 'Built the following bundle(s): \n\t' + paths.join('\n\t'));
+ } else {
+ paths = builder.findOutputApks(opts.buildType, opts.arch);
+ events.emit('log', 'Built the following apk(s): \n\t' + paths.join('\n\t'));
+ }
+
+ return {
+ paths: paths,
+ buildType: opts.buildType
+ };
+ });
+ });
+};
+
+/*
+ * Detects the architecture of a device/emulator
+ * Returns "arm" or "x86".
+ */
+module.exports.detectArchitecture = function (target) {
+ return Adb.shell(target, 'cat /proc/cpuinfo').then(function (output) {
+ return /intel/i.exec(output) ? 'x86' : 'arm';
+ });
+};
+
+module.exports.findBestApkForArchitecture = function (buildResults, arch) {
+ var paths = buildResults.apkPaths.filter(function (p) {
+ var apkName = path.basename(p);
+ if (buildResults.buildType === 'debug') {
+ return /-debug/.exec(apkName);
+ }
+ return !/-debug/.exec(apkName);
+ });
+ var archPattern = new RegExp('-' + arch);
+ var hasArchPattern = /-x86|-arm/;
+ for (var i = 0; i < paths.length; ++i) {
+ var apkName = path.basename(paths[i]);
+ if (hasArchPattern.exec(apkName)) {
+ if (archPattern.exec(apkName)) {
+ return paths[i];
+ }
+ } else {
+ return paths[i];
+ }
+ }
+ throw new Error('Could not find apk architecture: ' + arch + ' build-type: ' + buildResults.buildType);
+};
+
+function PackageInfo (keystore, alias, storePassword, password, keystoreType) {
+ const createNameKeyObject = (name, value) => ({ name, value: value.replace(/\\/g, '\\\\') });
+
+ this.data = [
+ createNameKeyObject('key.store', keystore),
+ createNameKeyObject('key.alias', alias)
+ ];
+
+ if (storePassword) this.data.push(createNameKeyObject('key.store.password', storePassword));
+ if (password) this.data.push(createNameKeyObject('key.alias.password', password));
+ if (keystoreType) this.data.push(createNameKeyObject('key.store.type', keystoreType));
+}
+
+PackageInfo.prototype = {
+ appendToProperties: function (propertiesParser) {
+ for (const { name, value } of this.data) propertiesParser.set(name, value);
+
+ propertiesParser.save();
+ }
+};
diff --git a/node_modules/cordova-android/lib/builders/ProjectBuilder.js b/node_modules/cordova-android/lib/builders/ProjectBuilder.js
new file mode 100644
index 0000000..f92e358
--- /dev/null
+++ b/node_modules/cordova-android/lib/builders/ProjectBuilder.js
@@ -0,0 +1,364 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+var fs = require('fs-extra');
+var path = require('path');
+const execa = require('execa');
+const glob = require('fast-glob');
+var events = require('cordova-common').events;
+var CordovaError = require('cordova-common').CordovaError;
+var check_reqs = require('../check_reqs');
+var PackageType = require('../PackageType');
+const { compareByAll } = require('../utils');
+const { createEditor } = require('properties-parser');
+
+const MARKER = 'YOUR CHANGES WILL BE ERASED!';
+const SIGNING_PROPERTIES = '-signing.properties';
+const TEMPLATE =
+ '# This file is automatically generated.\n' +
+ '# Do not modify this file -- ' + MARKER + '\n';
+
+const isPathArchSpecific = p => /-x86|-arm/.test(path.basename(p));
+
+const outputFileComparator = compareByAll([
+ // Sort arch specific builds after generic ones
+ isPathArchSpecific,
+
+ // Sort unsigned builds after signed ones
+ filePath => /-unsigned/.test(path.basename(filePath)),
+
+ // Sort by file modification time, latest first
+ filePath => -fs.statSync(filePath).mtime.getTime(),
+
+ // Sort by file name length, ascending
+ filePath => filePath.length
+]);
+
+/**
+ * @param {'apk' | 'aab'} bundleType
+ * @param {'debug' | 'release'} buildType
+ * @param {{arch?: string}} options
+ */
+function findOutputFiles (bundleType, buildType, { arch } = {}) {
+ let files = glob.sync(`**/*.${bundleType}`, {
+ absolute: true,
+ cwd: path.resolve(this[`${bundleType}Dir`], buildType)
+ }).map(path.normalize);
+
+ if (files.length === 0) return files;
+
+ // Assume arch-specific build if newest apk has -x86 or -arm.
+ const archSpecific = isPathArchSpecific(files[0]);
+
+ // And show only arch-specific ones (or non-arch-specific)
+ files = files.filter(p => isPathArchSpecific(p) === archSpecific);
+
+ if (archSpecific && files.length > 1 && arch) {
+ files = files.filter(p => path.basename(p).includes('-' + arch));
+ }
+
+ return files.sort(outputFileComparator);
+}
+
+class ProjectBuilder {
+ constructor (rootDirectory) {
+ this.root = rootDirectory;
+ this.apkDir = path.join(this.root, 'app', 'build', 'outputs', 'apk');
+ this.aabDir = path.join(this.root, 'app', 'build', 'outputs', 'bundle');
+ }
+
+ getArgs (cmd, opts) {
+ let args;
+ let buildCmd = cmd;
+ if (opts.packageType === PackageType.BUNDLE) {
+ if (cmd === 'release') {
+ buildCmd = ':app:bundleRelease';
+ } else if (cmd === 'debug') {
+ buildCmd = ':app:bundleDebug';
+ }
+
+ args = [buildCmd, '-b', path.join(this.root, 'build.gradle')];
+ } else {
+ if (cmd === 'release') {
+ buildCmd = 'cdvBuildRelease';
+ } else if (cmd === 'debug') {
+ buildCmd = 'cdvBuildDebug';
+ }
+
+ args = [buildCmd, '-b', path.join(this.root, 'build.gradle')];
+
+ if (opts.arch) {
+ args.push('-PcdvBuildArch=' + opts.arch);
+ }
+ }
+
+ args.push.apply(args, opts.extraArgs);
+
+ return args;
+ }
+
+ /*
+ * This returns a promise
+ */
+ runGradleWrapper (gradle_cmd) {
+ var gradlePath = path.join(this.root, 'gradlew');
+ var wrapperGradle = path.join(this.root, 'wrapper.gradle');
+ if (fs.existsSync(gradlePath)) {
+ // Literally do nothing, for some reason this works, while !fs.existsSync didn't on Windows
+ } else {
+ return execa(gradle_cmd, ['-p', this.root, 'wrapper', '-b', wrapperGradle], { stdio: 'inherit' });
+ }
+ }
+
+ readProjectProperties () {
+ function findAllUniq (data, r) {
+ var s = {};
+ var m;
+ while ((m = r.exec(data))) {
+ s[m[1]] = 1;
+ }
+ return Object.keys(s);
+ }
+
+ var data = fs.readFileSync(path.join(this.root, 'project.properties'), 'utf8');
+ return {
+ libs: findAllUniq(data, /^\s*android\.library\.reference\.\d+=(.*)(?:\s|$)/mg),
+ gradleIncludes: findAllUniq(data, /^\s*cordova\.gradle\.include\.\d+=(.*)(?:\s|$)/mg),
+ systemLibs: findAllUniq(data, /^\s*cordova\.system\.library\.\d+=(.*)(?:\s|$)/mg)
+ };
+ }
+
+ extractRealProjectNameFromManifest () {
+ var manifestPath = path.join(this.root, 'app', 'src', 'main', 'AndroidManifest.xml');
+ var manifestData = fs.readFileSync(manifestPath, 'utf8');
+ var m = / {
+ const config = this._getCordovaConfig();
+ // update/set the distributionUrl in the gradle-wrapper.properties
+ const gradleWrapperPropertiesPath = path.join(self.root, 'gradle/wrapper/gradle-wrapper.properties');
+ const gradleWrapperProperties = createEditor(gradleWrapperPropertiesPath);
+ const distributionUrl = process.env.CORDOVA_ANDROID_GRADLE_DISTRIBUTION_URL || `https://services.gradle.org/distributions/gradle-${config.GRADLE_VERSION}-all.zip`;
+ gradleWrapperProperties.set('distributionUrl', distributionUrl);
+ gradleWrapperProperties.save();
+
+ events.emit('verbose', `Gradle Distribution URL: ${distributionUrl}`);
+ })
+ .then(() => {
+ const signingPropertiesPath = path.join(self.root, `${opts.buildType}${SIGNING_PROPERTIES}`);
+
+ if (fs.existsSync(signingPropertiesPath)) fs.removeSync(signingPropertiesPath);
+ if (opts.packageInfo) {
+ fs.ensureFileSync(signingPropertiesPath);
+ const signingProperties = createEditor(signingPropertiesPath);
+ signingProperties.addHeadComment(TEMPLATE);
+ opts.packageInfo.appendToProperties(signingProperties);
+ }
+ });
+ }
+
+ /**
+ * @private
+ * @returns The user defined configs
+ */
+ _getCordovaConfig () {
+ return fs.readJSONSync(path.join(this.root, 'cdv-gradle-config.json'));
+ }
+
+ /*
+ * Builds the project with gradle.
+ * Returns a promise.
+ */
+ async build (opts) {
+ var wrapper = path.join(this.root, 'gradlew');
+ var args = this.getArgs(opts.buildType === 'debug' ? 'debug' : 'release', opts);
+
+ try {
+ return await execa(wrapper, args, { stdio: 'inherit', cwd: path.resolve(this.root) });
+ } catch (error) {
+ if (error.toString().includes('failed to find target with hash string')) {
+ // Add hint from check_android_target to error message
+ try {
+ await check_reqs.check_android_target(this.root);
+ } catch (checkAndroidTargetError) {
+ error.message += '\n' + checkAndroidTargetError.message;
+ }
+ }
+ throw error;
+ }
+ }
+
+ clean (opts) {
+ const wrapper = path.join(this.root, 'gradlew');
+ const args = this.getArgs('clean', opts);
+ return execa(wrapper, args, { stdio: 'inherit', cwd: path.resolve(this.root) })
+ .then(() => {
+ fs.removeSync(path.join(this.root, 'out'));
+
+ ['debug', 'release'].map(config => path.join(this.root, `${config}${SIGNING_PROPERTIES}`))
+ .forEach(file => {
+ const hasFile = fs.existsSync(file);
+ const hasMarker = hasFile && fs.readFileSync(file, 'utf8')
+ .includes(MARKER);
+
+ if (hasFile && hasMarker) fs.removeSync(file);
+ });
+ });
+ }
+
+ findOutputApks (build_type, arch) {
+ return findOutputFiles.call(this, 'apk', build_type, { arch });
+ }
+
+ findOutputBundles (build_type) {
+ return findOutputFiles.call(this, 'aab', build_type);
+ }
+
+ fetchBuildResults (build_type, arch) {
+ return {
+ apkPaths: this.findOutputApks(build_type, arch),
+ buildType: build_type
+ };
+ }
+}
+
+module.exports = ProjectBuilder;
diff --git a/node_modules/cordova-android/lib/builders/builders.js b/node_modules/cordova-android/lib/builders/builders.js
new file mode 100644
index 0000000..edc1a52
--- /dev/null
+++ b/node_modules/cordova-android/lib/builders/builders.js
@@ -0,0 +1,34 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+const CordovaError = require('cordova-common').CordovaError;
+
+/**
+ * Helper method that instantiates and returns a builder for specified build type.
+ *
+ * @return {Builder} A builder instance for specified build type.
+ */
+module.exports.getBuilder = function (projectPath) {
+ try {
+ const Builder = require('./ProjectBuilder');
+ return new Builder(projectPath);
+ } catch (err) {
+ throw new CordovaError('Failed to instantiate ProjectBuilder builder: ' + err);
+ }
+};
diff --git a/node_modules/cordova-android/lib/builders/plugin-build.gradle b/node_modules/cordova-android/lib/builders/plugin-build.gradle
new file mode 100644
index 0000000..985f1d6
--- /dev/null
+++ b/node_modules/cordova-android/lib/builders/plugin-build.gradle
@@ -0,0 +1,69 @@
+/* Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+// GENERATED FILE! DO NOT EDIT!
+
+buildscript {
+ repositories {
+ google()
+ mavenCentral()
+ }
+
+ // Switch the Android Gradle plugin version requirement depending on the
+ // installed version of Gradle. This dependency is documented at
+ // http://tools.android.com/tech-docs/new-build-system/version-compatibility
+ // and https://issues.apache.org/jira/browse/CB-8143
+ dependencies {
+ classpath 'com.android.tools.build:gradle:1.0.0+'
+ }
+}
+
+apply plugin: 'com.android.library'
+
+dependencies {
+ implementation fileTree(dir: 'libs', include: '*.jar')
+ debugCompile project(path: ":CordovaLib", configuration: "debug")
+ releaseCompile project(path: ":CordovaLib", configuration: "release")
+}
+
+android {
+ compileSdkVersion cordovaConfig.SDK_VERSION
+ buildToolsVersion cordovaConfig.BUILD_TOOLS_VERSION
+
+ compileOptions {
+ sourceCompatibility JavaVersion.VERSION_1_6
+ targetCompatibility JavaVersion.VERSION_1_6
+ }
+
+ sourceSets {
+ main {
+ manifest.srcFile 'AndroidManifest.xml'
+ java.srcDirs = ['src']
+ resources.srcDirs = ['src']
+ aidl.srcDirs = ['src']
+ renderscript.srcDirs = ['src']
+ res.srcDirs = ['res']
+ assets.srcDirs = ['assets']
+ jniLibs.srcDirs = ['libs']
+ }
+ }
+}
+
+if (file('build-extras.gradle').exists()) {
+ apply from: 'build-extras.gradle'
+}
diff --git a/node_modules/cordova-android/lib/check_reqs.js b/node_modules/cordova-android/lib/check_reqs.js
new file mode 100644
index 0000000..8c18db9
--- /dev/null
+++ b/node_modules/cordova-android/lib/check_reqs.js
@@ -0,0 +1,327 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+const execa = require('execa');
+var path = require('path');
+var fs = require('fs-extra');
+const { forgivingWhichSync, isWindows, isDarwin } = require('./utils');
+const java = require('./env/java');
+const { CordovaError, ConfigParser, events } = require('cordova-common');
+var android_sdk = require('./android_sdk');
+const { SDK_VERSION } = require('./gradle-config-defaults');
+
+// Re-exporting these for backwards compatibility and for unit testing.
+// TODO: Remove uses and use the ./utils module directly.
+Object.assign(module.exports, { isWindows, isDarwin });
+
+/**
+ * @param {string} projectRoot
+ * @returns {string} The android target in format "android-${target}"
+ */
+module.exports.get_target = function (projectRoot) {
+ const userTargetSdkVersion = getUserTargetSdkVersion(projectRoot);
+
+ if (userTargetSdkVersion && userTargetSdkVersion < SDK_VERSION) {
+ events.emit('warn', `android-targetSdkVersion should be greater than or equal to ${SDK_VERSION}.`);
+ }
+
+ return `android-${Math.max(userTargetSdkVersion, SDK_VERSION)}`;
+};
+
+/**
+ * @param {string} projectRoot
+ * @returns {number} target sdk or 0 if undefined
+ */
+function getUserTargetSdkVersion (projectRoot) {
+ // If the repo config.xml file exists, find the desired targetSdkVersion.
+ // We need to use the cordova project's config.xml here, since the platform
+ // project's config.xml does not yet have the user's preferences when this
+ // function is called during `Api.createPlatform`.
+ const configFile = path.join(projectRoot, '../../config.xml');
+ if (!fs.existsSync(configFile)) return 0;
+
+ const configParser = new ConfigParser(configFile);
+ const targetSdkVersion = parseInt(configParser.getPreference('android-targetSdkVersion', 'android'), 10);
+ return isNaN(targetSdkVersion) ? 0 : targetSdkVersion;
+}
+
+module.exports.get_gradle_wrapper = function () {
+ var androidStudioPath;
+ var i = 0;
+ var foundStudio = false;
+ var program_dir;
+ // OK, This hack only works on Windows, not on Mac OS or Linux. We will be deleting this eventually!
+ if (module.exports.isWindows()) {
+ var result = execa.sync(path.join(__dirname, 'getASPath.bat'));
+ // console.log('result.stdout =' + result.stdout.toString());
+ // console.log('result.stderr =' + result.stderr.toString());
+
+ if (result.stderr.toString().length > 0) {
+ var androidPath = path.join(process.env.ProgramFiles, 'Android') + '/';
+ if (fs.existsSync(androidPath)) {
+ program_dir = fs.readdirSync(androidPath);
+ while (i < program_dir.length && !foundStudio) {
+ if (program_dir[i].startsWith('Android Studio')) {
+ foundStudio = true;
+ androidStudioPath = path.join(process.env.ProgramFiles, 'Android', program_dir[i], 'gradle');
+ } else { ++i; }
+ }
+ }
+ } else {
+ // console.log('got android studio path from registry');
+ // remove the (os independent) new line char at the end of stdout
+ // add gradle to match the above.
+ androidStudioPath = path.join(result.stdout.toString().split('\r\n')[0], 'gradle');
+ }
+ }
+
+ if (androidStudioPath !== null && fs.existsSync(androidStudioPath)) {
+ var dirs = fs.readdirSync(androidStudioPath);
+ if (dirs[0].split('-')[0] === 'gradle') {
+ return path.join(androidStudioPath, dirs[0], 'bin', 'gradle');
+ }
+ } else {
+ // OK, let's try to check for Gradle!
+ return forgivingWhichSync('gradle');
+ }
+};
+
+// Returns a promise. Called only by build and clean commands.
+module.exports.check_gradle = function () {
+ var sdkDir = process.env.ANDROID_SDK_ROOT || process.env.ANDROID_HOME;
+ if (!sdkDir) {
+ return Promise.reject(new CordovaError('Could not find gradle wrapper within Android SDK. Could not find Android SDK directory.\n' +
+ 'Might need to install Android SDK or set up \'ANDROID_SDK_ROOT\' env variable.'));
+ }
+
+ var gradlePath = module.exports.get_gradle_wrapper();
+
+ if (gradlePath.length !== 0) return Promise.resolve(gradlePath);
+
+ return Promise.reject(new CordovaError('Could not find an installed version of Gradle either in Android Studio,\n' +
+ 'or on your system to install the gradle wrapper. Please include gradle \n' +
+ 'in your path, or install Android Studio'));
+};
+
+/**
+ * Checks for the java installation and correct version
+ *
+ * Despite the name, it should return the Java version value, it's used by the Cordova CLI.
+ */
+module.exports.check_java = async function () {
+ const javaVersion = await java.getVersion();
+ return javaVersion;
+};
+
+// Returns a promise.
+module.exports.check_android = function () {
+ return Promise.resolve().then(function () {
+ function maybeSetAndroidHome (value) {
+ if (!hasAndroidHome && fs.existsSync(value)) {
+ hasAndroidHome = true;
+ process.env.ANDROID_SDK_ROOT = value;
+ }
+ }
+
+ var adbInPath = forgivingWhichSync('adb');
+ var avdmanagerInPath = forgivingWhichSync('avdmanager');
+ var hasAndroidHome = false;
+
+ if (process.env.ANDROID_SDK_ROOT) {
+ maybeSetAndroidHome(path.resolve(process.env.ANDROID_SDK_ROOT));
+ }
+
+ // First ensure ANDROID_HOME is set
+ // If we have no hints (nothing in PATH), try a few default locations
+ if (!hasAndroidHome && !adbInPath && !avdmanagerInPath) {
+ if (process.env.ANDROID_HOME) {
+ // Fallback to deprecated `ANDROID_HOME` variable
+ maybeSetAndroidHome(path.join(process.env.ANDROID_HOME));
+ }
+ if (module.exports.isWindows()) {
+ // Android Studio 1.0 installer
+ if (process.env.LOCALAPPDATA) {
+ maybeSetAndroidHome(path.join(process.env.LOCALAPPDATA, 'Android', 'sdk'));
+ }
+ if (process.env.ProgramFiles) {
+ maybeSetAndroidHome(path.join(process.env.ProgramFiles, 'Android', 'sdk'));
+ }
+
+ // Android Studio pre-1.0 installer
+ if (process.env.LOCALAPPDATA) {
+ maybeSetAndroidHome(path.join(process.env.LOCALAPPDATA, 'Android', 'android-studio', 'sdk'));
+ }
+ if (process.env.ProgramFiles) {
+ maybeSetAndroidHome(path.join(process.env.ProgramFiles, 'Android', 'android-studio', 'sdk'));
+ }
+
+ // Stand-alone installer
+ if (process.env.LOCALAPPDATA) {
+ maybeSetAndroidHome(path.join(process.env.LOCALAPPDATA, 'Android', 'android-sdk'));
+ }
+ if (process.env.ProgramFiles) {
+ maybeSetAndroidHome(path.join(process.env.ProgramFiles, 'Android', 'android-sdk'));
+ }
+ } else if (module.exports.isDarwin()) {
+ // Android Studio 1.0 installer
+ if (process.env.HOME) {
+ maybeSetAndroidHome(path.join(process.env.HOME, 'Library', 'Android', 'sdk'));
+ }
+ // Android Studio pre-1.0 installer
+ maybeSetAndroidHome('/Applications/Android Studio.app/sdk');
+ // Stand-alone zip file that user might think to put under /Applications
+ maybeSetAndroidHome('/Applications/android-sdk-macosx');
+ maybeSetAndroidHome('/Applications/android-sdk');
+ }
+ if (process.env.HOME) {
+ // Stand-alone zip file that user might think to put under their home directory
+ maybeSetAndroidHome(path.join(process.env.HOME, 'android-sdk-macosx'));
+ maybeSetAndroidHome(path.join(process.env.HOME, 'android-sdk'));
+ }
+ }
+
+ if (!hasAndroidHome) {
+ // If we dont have ANDROID_SDK_ROOT, but we do have some tools on the PATH, try to infer from the tooling PATH.
+ var parentDir, grandParentDir;
+ if (adbInPath) {
+ parentDir = path.dirname(adbInPath);
+ grandParentDir = path.dirname(parentDir);
+ if (path.basename(parentDir) === 'platform-tools') {
+ maybeSetAndroidHome(grandParentDir);
+ } else {
+ throw new CordovaError('Failed to find \'ANDROID_SDK_ROOT\' environment variable. Try setting it manually.\n' +
+ 'Detected \'adb\' command at ' + parentDir + ' but no \'platform-tools\' directory found near.\n' +
+ 'Try reinstall Android SDK or update your PATH to include valid path to SDK' + path.sep + 'platform-tools directory.');
+ }
+ }
+ if (avdmanagerInPath) {
+ parentDir = path.dirname(avdmanagerInPath);
+ grandParentDir = path.dirname(parentDir);
+ if (path.basename(parentDir) === 'bin' && path.basename(grandParentDir) === 'tools') {
+ maybeSetAndroidHome(path.dirname(grandParentDir));
+ } else {
+ throw new CordovaError('Failed to find \'ANDROID_SDK_ROOT\' environment variable. Try setting it manually.\n' +
+ 'Detected \'avdmanager\' command at ' + parentDir + ' but no \'tools' + path.sep + 'bin\' directory found near.\n' +
+ 'Try reinstall Android SDK or update your PATH to include valid path to SDK' + path.sep + 'tools' + path.sep + 'bin directory.');
+ }
+ }
+ }
+ if (!process.env.ANDROID_SDK_ROOT) {
+ throw new CordovaError('Failed to find \'ANDROID_SDK_ROOT\' environment variable. Try setting it manually.\n' +
+ 'Failed to find \'android\' command in your \'PATH\'. Try update your \'PATH\' to include path to valid SDK directory.');
+ }
+ if (!fs.existsSync(process.env.ANDROID_SDK_ROOT)) {
+ throw new CordovaError('\'ANDROID_SDK_ROOT\' environment variable is set to non-existent path: ' + process.env.ANDROID_SDK_ROOT +
+ '\nTry update it manually to point to valid SDK directory.');
+ }
+ // Next let's make sure relevant parts of the SDK tooling is in our PATH
+ if (hasAndroidHome && !adbInPath) {
+ process.env.PATH += path.delimiter + path.join(process.env.ANDROID_SDK_ROOT, 'platform-tools');
+ }
+ if (hasAndroidHome && !avdmanagerInPath) {
+ process.env.PATH += path.delimiter + path.join(process.env.ANDROID_SDK_ROOT, 'tools', 'bin');
+ }
+ return hasAndroidHome;
+ });
+};
+
+module.exports.check_android_target = function (projectRoot) {
+ // valid_target can look like:
+ // android-19
+ // android-L
+ // Google Inc.:Google APIs:20
+ // Google Inc.:Glass Development Kit Preview:20
+ var desired_api_level = module.exports.get_target(projectRoot);
+ return android_sdk.list_targets().then(function (targets) {
+ if (targets.indexOf(desired_api_level) >= 0) {
+ return targets;
+ }
+ throw new CordovaError(`Please install the Android SDK Platform "platforms;${desired_api_level}"`);
+ });
+};
+
+// Returns a promise.
+module.exports.run = function () {
+ console.log('Checking Java JDK and Android SDK versions');
+ console.log('ANDROID_SDK_ROOT=' + process.env.ANDROID_SDK_ROOT + ' (recommended setting)');
+ console.log('ANDROID_HOME=' + process.env.ANDROID_HOME + ' (DEPRECATED)');
+
+ return Promise.all([this.check_java(), this.check_android()]).then(function (values) {
+ console.log('Using Android SDK: ' + process.env.ANDROID_SDK_ROOT);
+
+ if (!values[1]) {
+ throw new CordovaError('Requirements check failed for Android SDK! Android SDK was not detected.');
+ }
+ });
+};
+
+/**
+ * Object thar represents one of requirements for current platform.
+ * @param {String} id The unique identifier for this requirements.
+ * @param {String} name The name of requirements. Human-readable field.
+ * @param {String} version The version of requirement installed. In some cases could be an array of strings
+ * (for example, check_android_target returns an array of android targets installed)
+ * @param {Boolean} installed Indicates whether the requirement is installed or not
+ */
+var Requirement = function (id, name, version, installed) {
+ this.id = id;
+ this.name = name;
+ this.installed = installed || false;
+ this.metadata = {
+ version: version
+ };
+};
+
+/**
+ * Methods that runs all checks one by one and returns a result of checks
+ * as an array of Requirement objects. This method intended to be used by cordova-lib check_reqs method
+ *
+ * @param {string} projectRoot
+ * @return Promise Array of requirements. Due to implementation, promise is always fulfilled.
+ */
+module.exports.check_all = function (projectRoot) {
+ var requirements = [
+ new Requirement('java', 'Java JDK'),
+ new Requirement('androidSdk', 'Android SDK'),
+ new Requirement('androidTarget', 'Android target'),
+ new Requirement('gradle', 'Gradle')
+ ];
+
+ var checkFns = [
+ this.check_java,
+ this.check_android,
+ this.check_android_target.bind(this, projectRoot),
+ this.check_gradle
+ ];
+
+ // Then execute requirement checks one-by-one
+ return checkFns.reduce(function (promise, checkFn, idx) {
+ // Update each requirement with results
+ var requirement = requirements[idx];
+ return promise.then(checkFn).then(function (version) {
+ requirement.installed = true;
+ requirement.metadata.version = version;
+ }, function (err) {
+ requirement.metadata.reason = err instanceof Error ? err.message : err;
+ });
+ }, Promise.resolve()).then(function () {
+ // When chain is completed, return requirements array to upstream API
+ return requirements;
+ });
+};
diff --git a/node_modules/cordova-android/lib/config/GradlePropertiesParser.js b/node_modules/cordova-android/lib/config/GradlePropertiesParser.js
new file mode 100644
index 0000000..9189a91
--- /dev/null
+++ b/node_modules/cordova-android/lib/config/GradlePropertiesParser.js
@@ -0,0 +1,147 @@
+/**
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+const fs = require('fs');
+const path = require('path');
+const propertiesParser = require('properties-parser');
+const events = require('cordova-common').events;
+
+class GradlePropertiesParser {
+ /**
+ * Loads and Edits Gradle Properties File.
+ *
+ * @param {String} platformDir is the path of the Android platform directory
+ */
+ constructor (platformDir) {
+ this._defaults = {
+ // to allow dex in process
+ 'org.gradle.jvmargs': '-Xmx2048m',
+
+ // Android X
+ 'android.useAndroidX': 'true',
+ 'android.enableJetifier': 'true'
+
+ // Shaves another 100ms, but produces a "try at own risk" warning. Not worth it (yet):
+ // 'org.gradle.parallel': 'true'
+ };
+
+ this.gradleFilePath = path.join(platformDir, 'gradle.properties');
+ }
+
+ configure (userConfigs) {
+ events.emit('verbose', '[Gradle Properties] Preparing Configuration');
+
+ this._initializeEditor();
+
+ events.emit('verbose', '[Gradle Properties] Appending default configuration properties');
+ this._configureProperties(this._defaults);
+
+ events.emit('verbose', '[Gradle Properties] Appending custom configuration properties');
+ this._configureProperties(userConfigs);
+
+ this._save();
+ }
+
+ /**
+ * Initialize the properties editor for parsing, setting, etc.
+ */
+ _initializeEditor () {
+ // Touch empty gradle.properties file if missing.
+ if (!fs.existsSync(this.gradleFilePath)) {
+ events.emit('verbose', '[Gradle Properties] File missing, creating file with Cordova defaults.');
+ fs.writeFileSync(this.gradleFilePath, '', 'utf-8');
+ }
+
+ // Create an editor for parsing, getting, and setting configurations.
+ this.gradleFile = propertiesParser.createEditor(this.gradleFilePath);
+ }
+
+ /**
+ * Validate that defaults or user configuration properties are set and
+ * set the missing items.
+ */
+ _configureProperties (properties) {
+ // Iterate though the properties and set only if missing.
+ Object.keys(properties).forEach(key => {
+ const value = this.gradleFile.get(key);
+
+ if (!value) {
+ // Handles the case of adding missing defaults or new properties that are missing.
+ events.emit('verbose', `[Gradle Properties] Appending configuration item: ${key}=${properties[key]}`);
+ this.gradleFile.set(key, properties[key]);
+ } else if (value !== properties[key]) {
+ if (this._defaults[key] && this._defaults[key] !== properties[key]) {
+ let shouldEmit = true;
+ if (key === 'org.gradle.jvmargs') {
+ shouldEmit = this._isJVMMemoryLessThanRecommended(properties[key], this._defaults[key]);
+ }
+
+ if (shouldEmit) {
+ // Since the value does not match default, we will notify the discrepancy with Cordova's recommended value.
+ events.emit('info', `[Gradle Properties] Detected Gradle property "${key}" with the value of "${properties[key]}", Cordova's recommended value is "${this._defaults[key]}"`);
+ }
+ } else {
+ // When the current value exists but does not match the new value or does matches the default key value, the new value it set.
+ events.emit('verbose', `[Gradle Properties] Updating Gradle property "${key}" with the value of "${properties[key]}"`);
+ }
+
+ // We will set the new value in either case.
+ this.gradleFile.set(key, properties[key]);
+ }
+ });
+ }
+
+ _isJVMMemoryLessThanRecommended (memoryValue, recommendedMemoryValue) {
+ const UNIT = 2;
+ const SIZE = 1;
+ const regex = /-Xmx+([0-9]+)+([mMgGkK])/;
+
+ const recommendedCapture = regex.exec(recommendedMemoryValue);
+ const recommendedBase = this._getBaseJVMSize(recommendedCapture[SIZE], recommendedCapture[UNIT]);
+ const memoryCapture = regex.exec(memoryValue);
+ const memoryBase = this._getBaseJVMSize(memoryCapture[SIZE], memoryCapture[UNIT]);
+
+ return memoryBase < recommendedBase;
+ }
+
+ _getBaseJVMSize (size, unit) {
+ const KILOBYTE = 1024;
+ const MEGABYTE = 1048576;
+ const GIGABYTE = 1073741824;
+
+ switch (unit.toLowerCase()) {
+ case 'k': return size * KILOBYTE;
+ case 'm': return size * MEGABYTE;
+ case 'g': return size * GIGABYTE;
+ }
+
+ events.emit('warn', `[Gradle Properties] Unknown memory size unit (${unit})`);
+ return null;
+ }
+
+ /**
+ * Saves any changes that has been made to the properties file.
+ */
+ _save () {
+ events.emit('verbose', '[Gradle Properties] Updating and Saving File');
+ this.gradleFile.save();
+ }
+}
+
+module.exports = GradlePropertiesParser;
diff --git a/node_modules/cordova-android/lib/create.js b/node_modules/cordova-android/lib/create.js
new file mode 100644
index 0000000..da75631
--- /dev/null
+++ b/node_modules/cordova-android/lib/create.js
@@ -0,0 +1,300 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+var path = require('path');
+var fs = require('fs-extra');
+var utils = require('./utils');
+var check_reqs = require('./check_reqs');
+var ROOT = path.join(__dirname, '..');
+const { createEditor } = require('properties-parser');
+
+var CordovaError = require('cordova-common').CordovaError;
+var AndroidManifest = require('./AndroidManifest');
+
+// Export all helper functions, and make sure internally within this module, we
+// reference these methods via the `exports` object - this helps with testing
+// (since we can then mock and control behaviour of all of these functions)
+exports.validatePackageName = validatePackageName;
+exports.validateProjectName = validateProjectName;
+exports.copyJsAndLibrary = copyJsAndLibrary;
+exports.copyScripts = copyScripts;
+exports.copyBuildRules = copyBuildRules;
+exports.writeProjectProperties = writeProjectProperties;
+exports.prepBuildFiles = prepBuildFiles;
+
+function getFrameworkDir (projectPath, shared) {
+ return shared ? path.join(ROOT, 'framework') : path.join(projectPath, 'CordovaLib');
+}
+
+function copyJsAndLibrary (projectPath, shared, projectName, targetAPI) {
+ var nestedCordovaLibPath = getFrameworkDir(projectPath, false);
+ var srcCordovaJsPath = path.join(ROOT, 'templates', 'project', 'assets', 'www', 'cordova.js');
+ var app_path = path.join(projectPath, 'app', 'src', 'main');
+ const platform_www = path.join(projectPath, 'platform_www');
+
+ fs.copySync(srcCordovaJsPath, path.join(app_path, 'assets', 'www', 'cordova.js'));
+
+ // Copy the cordova.js file to platforms//platform_www/
+ // The www dir is nuked on each prepare so we keep cordova.js in platform_www
+ fs.ensureDirSync(platform_www);
+ fs.copySync(srcCordovaJsPath, path.join(platform_www, 'cordova.js'));
+
+ if (shared) {
+ var relativeFrameworkPath = path.relative(projectPath, getFrameworkDir(projectPath, true));
+ fs.symlinkSync(relativeFrameworkPath, nestedCordovaLibPath, 'dir');
+ } else {
+ fs.ensureDirSync(nestedCordovaLibPath);
+ fs.copySync(path.join(ROOT, 'framework', 'AndroidManifest.xml'), path.join(nestedCordovaLibPath, 'AndroidManifest.xml'));
+ const propertiesEditor = createEditor(path.join(ROOT, 'framework', 'project.properties'));
+ propertiesEditor.set('target', targetAPI);
+ propertiesEditor.save(path.join(nestedCordovaLibPath, 'project.properties'));
+ fs.copySync(path.join(ROOT, 'framework', 'build.gradle'), path.join(nestedCordovaLibPath, 'build.gradle'));
+ fs.copySync(path.join(ROOT, 'framework', 'cordova.gradle'), path.join(nestedCordovaLibPath, 'cordova.gradle'));
+ fs.copySync(path.join(ROOT, 'framework', 'repositories.gradle'), path.join(nestedCordovaLibPath, 'repositories.gradle'));
+ fs.copySync(path.join(ROOT, 'framework', 'src'), path.join(nestedCordovaLibPath, 'src'));
+ fs.copySync(path.join(ROOT, 'framework', 'cdv-gradle-config-defaults.json'), path.join(projectPath, 'cdv-gradle-config.json'));
+ }
+}
+
+function extractSubProjectPaths (data) {
+ var ret = {};
+ var r = /^\s*android\.library\.reference\.\d+=(.*)(?:\s|$)/mg;
+ var m;
+ while ((m = r.exec(data))) {
+ ret[m[1]] = 1;
+ }
+ return Object.keys(ret);
+}
+
+function writeProjectProperties (projectPath, target_api) {
+ var dstPath = path.join(projectPath, 'project.properties');
+ var templatePath = path.join(ROOT, 'templates', 'project', 'project.properties');
+ var srcPath = fs.existsSync(dstPath) ? dstPath : templatePath;
+
+ var data = fs.readFileSync(srcPath, 'utf8');
+ data = data.replace(/^target=.*/m, 'target=' + target_api);
+ var subProjects = extractSubProjectPaths(data);
+ subProjects = subProjects.filter(function (p) {
+ return !(/^CordovaLib$/m.exec(p) ||
+ /[\\/]cordova-android[\\/]framework$/m.exec(p) ||
+ /^(\.\.[\\/])+framework$/m.exec(p));
+ });
+ subProjects.unshift('CordovaLib');
+ data = data.replace(/^\s*android\.library\.reference\.\d+=.*\n/mg, '');
+ if (!/\n$/.exec(data)) {
+ data += '\n';
+ }
+ for (var i = 0; i < subProjects.length; ++i) {
+ data += 'android.library.reference.' + (i + 1) + '=' + subProjects[i] + '\n';
+ }
+ fs.writeFileSync(dstPath, data);
+}
+
+// This makes no sense, what if you're building with a different build system?
+function prepBuildFiles (projectPath) {
+ var buildModule = require('./builders/builders');
+ buildModule.getBuilder(projectPath).prepBuildFiles();
+}
+
+function copyBuildRules (projectPath, isLegacy) {
+ var srcDir = path.join(ROOT, 'templates', 'project');
+
+ if (isLegacy) {
+ // The project's build.gradle is identical to the earlier build.gradle, so it should still work
+ fs.copySync(path.join(srcDir, 'legacy', 'build.gradle'), path.join(projectPath, 'legacy', 'build.gradle'));
+ fs.copySync(path.join(srcDir, 'wrapper.gradle'), path.join(projectPath, 'wrapper.gradle'));
+ } else {
+ fs.copySync(path.join(srcDir, 'build.gradle'), path.join(projectPath, 'build.gradle'));
+ fs.copySync(path.join(srcDir, 'app', 'build.gradle'), path.join(projectPath, 'app', 'build.gradle'));
+ fs.copySync(path.join(srcDir, 'app', 'repositories.gradle'), path.join(projectPath, 'app', 'repositories.gradle'));
+ fs.copySync(path.join(srcDir, 'repositories.gradle'), path.join(projectPath, 'repositories.gradle'));
+ fs.copySync(path.join(srcDir, 'wrapper.gradle'), path.join(projectPath, 'wrapper.gradle'));
+ }
+}
+
+function copyScripts (projectPath) {
+ var srcScriptsDir = path.join(ROOT, 'templates', 'cordova');
+ var destScriptsDir = path.join(projectPath, 'cordova');
+ // Delete old scripts directory if this is an update.
+ fs.removeSync(destScriptsDir);
+ // Copy in the new ones.
+ fs.copySync(srcScriptsDir, destScriptsDir);
+}
+
+/**
+ * Test whether a package name is acceptable for use as an android project.
+ * Returns a promise, fulfilled if the package name is acceptable; rejected
+ * otherwise.
+ */
+function validatePackageName (package_name) {
+ // Make the package conform to Java package types
+ // http://developer.android.com/guide/topics/manifest/manifest-element.html#package
+ // Enforce underscore limitation
+ var msg = 'Error validating package name. ';
+
+ if (!/^[a-zA-Z][a-zA-Z0-9_]+(\.[a-zA-Z][a-zA-Z0-9_]*)+$/.test(package_name)) {
+ return Promise.reject(new CordovaError(msg + 'Must look like: `com.company.Name`. Currently is: `' + package_name + '`'));
+ }
+
+ // Class is a reserved word
+ if (/\b[Cc]lass\b/.test(package_name)) {
+ return Promise.reject(new CordovaError(msg + '"class" is a reserved word'));
+ }
+
+ return Promise.resolve();
+}
+
+/**
+ * Test whether given string is acceptable for use as a project name
+ * Returns a promise, fulfilled if the project name is acceptable; rejected
+ * otherwise.
+ */
+function validateProjectName (project_name) {
+ var msg = 'Error validating project name. ';
+ // Make sure there's something there
+ if (project_name === '') {
+ return Promise.reject(new CordovaError(msg + 'Project name cannot be empty'));
+ }
+
+ return Promise.resolve();
+}
+
+/**
+ * Creates an android application with the given options.
+ *
+ * @param {String} project_path Path to the new Cordova android project.
+ * @param {ConfigParser} config Instance of ConfigParser to retrieve basic
+ * project properties.
+ * @param {Object} [options={}] Various options
+ * @param {String} [options.activityName='MainActivity'] Name for the
+ * activity
+ * @param {Boolean} [options.link=false] Specifies whether javascript files
+ * and CordovaLib framework will be symlinked to created application.
+ * @param {String} [options.customTemplate] Path to project template
+ * (override)
+ * @param {EventEmitter} [events] An EventEmitter instance for logging
+ * events
+ *
+ * @return {Promise} Directory where application has been created
+ */
+exports.create = function (project_path, config, options, events) {
+ options = options || {};
+
+ // Set default values for path, package and name
+ project_path = path.relative(process.cwd(), project_path);
+ // Check if project already exists
+ if (fs.existsSync(project_path)) {
+ return Promise.reject(new CordovaError('Project already exists! Delete and recreate'));
+ }
+
+ var package_name = config.android_packageName() || config.packageName() || 'io.cordova.helloCordova';
+ var project_name = config.name() || 'Hello Cordova';
+
+ var safe_activity_name = config.android_activityName() || options.activityName || 'MainActivity';
+ var target_api = check_reqs.get_target(project_path);
+
+ // Make the package conform to Java package types
+ return exports.validatePackageName(package_name)
+ .then(function () {
+ return exports.validateProjectName(project_name);
+ }).then(function () {
+ // Log the given values for the project
+ events.emit('log', 'Creating Cordova project for the Android platform:');
+ events.emit('log', '\tPath: ' + project_path);
+ events.emit('log', '\tPackage: ' + package_name);
+ events.emit('log', '\tName: ' + project_name);
+ events.emit('log', '\tActivity: ' + safe_activity_name);
+ events.emit('log', '\tAndroid target: ' + target_api);
+
+ events.emit('verbose', 'Copying android template project to ' + project_path);
+
+ var project_template_dir = options.customTemplate || path.join(ROOT, 'templates', 'project');
+ var app_path = path.join(project_path, 'app', 'src', 'main');
+
+ // copy project template
+ fs.ensureDirSync(app_path);
+ fs.copySync(path.join(project_template_dir, 'assets'), path.join(app_path, 'assets'));
+ fs.copySync(path.join(project_template_dir, 'res'), path.join(app_path, 'res'));
+ fs.copySync(path.join(project_template_dir, 'gitignore'), path.join(project_path, '.gitignore'));
+
+ // Manually create directories that would be empty within the template (since git doesn't track directories).
+ fs.ensureDirSync(path.join(app_path, 'libs'));
+
+ // copy cordova.js, cordova.jar
+ exports.copyJsAndLibrary(project_path, options.link, safe_activity_name, target_api);
+
+ // Set up ther Android Studio paths
+ var java_path = path.join(app_path, 'java');
+ var assets_path = path.join(app_path, 'assets');
+ var resource_path = path.join(app_path, 'res');
+ fs.ensureDirSync(java_path);
+ fs.ensureDirSync(assets_path);
+ fs.ensureDirSync(resource_path);
+
+ // interpolate the activity name and package
+ var packagePath = package_name.replace(/\./g, path.sep);
+ var activity_dir = path.join(java_path, packagePath);
+ var activity_path = path.join(activity_dir, safe_activity_name + '.java');
+
+ fs.ensureDirSync(activity_dir);
+ fs.copySync(path.join(project_template_dir, 'Activity.java'), activity_path);
+ utils.replaceFileContents(activity_path, /__ACTIVITY__/, safe_activity_name);
+ utils.replaceFileContents(path.join(app_path, 'res', 'values', 'strings.xml'), /__NAME__/, utils.escape(project_name));
+ utils.replaceFileContents(activity_path, /__ID__/, package_name);
+
+ var manifest = new AndroidManifest(path.join(project_template_dir, 'AndroidManifest.xml'));
+ manifest.setPackageId(package_name)
+ .getActivity().setName(safe_activity_name);
+
+ var manifest_path = path.join(app_path, 'AndroidManifest.xml');
+ manifest.write(manifest_path);
+
+ exports.copyScripts(project_path);
+ exports.copyBuildRules(project_path);
+
+ // Link it to local android install.
+ exports.writeProjectProperties(project_path, target_api);
+ exports.prepBuildFiles(project_path);
+ events.emit('log', generateDoneMessage('create', options.link));
+ }).then(() => project_path);
+};
+
+function generateDoneMessage (type, link) {
+ var pkg = require('../package');
+ var msg = 'Android project ' + (type === 'update' ? 'updated ' : 'created ') + 'with ' + pkg.name + '@' + pkg.version;
+ if (link) {
+ msg += ' and has a linked CordovaLib';
+ }
+ return msg;
+}
+
+// Returns a promise.
+exports.update = function (projectPath, options, events) {
+ var errorString =
+ 'An in-place platform update is not supported. \n' +
+ 'The `platforms` folder is always treated as a build artifact in the CLI workflow.\n' +
+ 'To update your platform, you have to remove, then add your android platform again.\n' +
+ 'Make sure you save your plugins beforehand using `cordova plugin save`, and save \n' + 'a copy of the platform first if you had manual changes in it.\n' +
+ '\tcordova plugin save\n' +
+ '\tcordova platform rm android\n' +
+ '\tcordova platform add android\n'
+ ;
+
+ return Promise.reject(errorString);
+};
diff --git a/node_modules/cordova-android/lib/emulator.js b/node_modules/cordova-android/lib/emulator.js
new file mode 100644
index 0000000..c2834f6
--- /dev/null
+++ b/node_modules/cordova-android/lib/emulator.js
@@ -0,0 +1,293 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+const execa = require('execa');
+const fs = require('fs-extra');
+var android_versions = require('android-versions');
+var path = require('path');
+var Adb = require('./Adb');
+var events = require('cordova-common').events;
+var CordovaError = require('cordova-common').CordovaError;
+var android_sdk = require('./android_sdk');
+var which = require('which');
+
+// constants
+const ONE_SECOND = 1000; // in milliseconds
+const CHECK_BOOTED_INTERVAL = 3 * ONE_SECOND; // in milliseconds
+
+function forgivingWhichSync (cmd) {
+ const whichResult = which.sync(cmd, { nothrow: true });
+
+ // On null, returns empty string to maintain backwards compatibility
+ // realpathSync follows symlinks
+ return whichResult === null ? '' : fs.realpathSync(whichResult);
+}
+
+module.exports.list_images_using_avdmanager = function () {
+ return execa('avdmanager', ['list', 'avd']).then(({ stdout: output }) => {
+ var response = output.split('\n');
+ var emulator_list = [];
+ for (var i = 1; i < response.length; i++) {
+ // To return more detailed information use img_obj
+ var img_obj = {};
+ if (response[i].match(/Name:\s/)) {
+ img_obj.name = response[i].split('Name: ')[1].replace('\r', '');
+ if (response[i + 1].match(/Device:\s/)) {
+ i++;
+ img_obj.device = response[i].split('Device: ')[1].replace('\r', '');
+ }
+ if (response[i + 1].match(/Path:\s/)) {
+ i++;
+ img_obj.path = response[i].split('Path: ')[1].replace('\r', '');
+ }
+ if (response[i + 1].match(/Target:\s/)) {
+ i++;
+ if (response[i + 1].match(/ABI:\s/)) {
+ img_obj.abi = response[i + 1].split('ABI: ')[1].replace('\r', '');
+ }
+ // This next conditional just aims to match the old output of `android list avd`
+ // We do so so that we don't have to change the logic when parsing for the
+ // best emulator target to spawn (see below in `best_image`)
+ // This allows us to transitionally support both `android` and `avdmanager` binaries,
+ // depending on what SDK version the user has
+ if (response[i + 1].match(/Based\son:\s/)) {
+ img_obj.target = response[i + 1].split('Based on:')[1];
+ if (img_obj.target.match(/Tag\/ABI:\s/)) {
+ img_obj.target = img_obj.target.split('Tag/ABI:')[0].replace('\r', '').trim();
+ if (img_obj.target.indexOf('(') > -1) {
+ img_obj.target = img_obj.target.substr(0, img_obj.target.indexOf('(') - 1).trim();
+ }
+ }
+ var version_string = img_obj.target.replace(/Android\s+/, '');
+
+ var api_level = android_sdk.version_string_to_api_level[version_string];
+ if (api_level) {
+ img_obj.target += ' (API level ' + api_level + ')';
+ }
+ }
+ }
+ if (response[i + 1].match(/Skin:\s/)) {
+ i++;
+ img_obj.skin = response[i].split('Skin: ')[1].replace('\r', '');
+ }
+
+ emulator_list.push(img_obj);
+ }
+ /* To just return a list of names use this
+ if (response[i].match(/Name:\s/)) {
+ emulator_list.push(response[i].split('Name: ')[1].replace('\r', '');
+ } */
+ }
+ return emulator_list;
+ });
+};
+
+/**
+ * Returns a Promise for a list of emulator images in the form of objects
+ * {
+ name : ,
+ device : ,
+ path : ,
+ target : ,
+ abi : ,
+ skin :
+ }
+ */
+module.exports.list_images = function () {
+ return Promise.resolve().then(function () {
+ if (forgivingWhichSync('avdmanager')) {
+ return module.exports.list_images_using_avdmanager();
+ } else {
+ return Promise.reject(new CordovaError('Could not find `avdmanager` on your $PATH! Are you sure the Android SDK is installed and available?'));
+ }
+ }).then(function (avds) {
+ // In case we're missing the Android OS version string from the target description, add it.
+ return avds.map(function (avd) {
+ if (avd.target && avd.target.indexOf('Android API') > -1 && avd.target.indexOf('API level') < 0) {
+ var api_level = avd.target.match(/\d+/);
+ if (api_level) {
+ var level = android_versions.get(api_level);
+ if (level) {
+ avd.target = 'Android ' + level.semver + ' (API level ' + api_level + ')';
+ }
+ }
+ }
+ return avd;
+ });
+ });
+};
+
+/**
+ * Returns the best image (if any) for given target.
+ *
+ * @param {Number} project_target Android targetSDK API level
+ * @return {{name: string} | undefined} the closest avd to the given target
+ * or undefined if no avds exist.
+ */
+module.exports.best_image = function (project_target) {
+ return this.list_images().then(function (images) {
+ // Just return undefined if there is no images
+ if (images.length === 0) return;
+
+ var closest = 9999;
+ var best = images[0];
+ for (var i in images) {
+ var target = images[i].target;
+ if (target && target.indexOf('API level') > -1) {
+ var num = parseInt(target.split('(API level ')[1].replace(')', ''));
+ if (num === project_target) {
+ return images[i];
+ } else if (project_target - num < closest && project_target > num) {
+ closest = project_target - num;
+ best = images[i];
+ }
+ }
+ }
+ return best;
+ });
+};
+
+exports.list_started = async () => {
+ return (await Adb.devices())
+ .filter(id => id.startsWith('emulator-'));
+};
+
+/*
+ * Gets unused port for android emulator, between 5554 and 5584
+ * Returns a promise.
+ */
+module.exports.get_available_port = function () {
+ var self = this;
+
+ return self.list_started().then(function (emulators) {
+ for (var p = 5584; p >= 5554; p -= 2) {
+ if (emulators.indexOf('emulator-' + p) === -1) {
+ events.emit('verbose', 'Found available port: ' + p);
+ return p;
+ }
+ }
+ throw new CordovaError('Could not find an available avd port');
+ });
+};
+
+/*
+ * Starts an emulator with the given ID,
+ * and returns the started ID of that emulator.
+ * If no boot timeout is given or the value is negative it will wait forever for
+ * the emulator to boot
+ *
+ * Returns a promise.
+ */
+module.exports.start = function (emulatorId, boot_timeout) {
+ var self = this;
+
+ return Promise.resolve().then(function () {
+ if (!emulatorId) {
+ throw new CordovaError('No emulator ID given');
+ }
+
+ return self.get_available_port().then(function (port) {
+ // Figure out the directory the emulator binary runs in, and set the cwd to that directory.
+ // Workaround for https://code.google.com/p/android/issues/detail?id=235461
+ var emulator_dir = path.dirname(which.sync('emulator'));
+ var args = ['-avd', emulatorId, '-port', port];
+ // Don't wait for it to finish, since the emulator will probably keep running for a long time.
+ execa('emulator', args, { stdio: 'inherit', detached: true, cwd: emulator_dir })
+ .unref();
+
+ // wait for emulator to start
+ events.emit('log', 'Waiting for emulator to start...');
+ return self.wait_for_emulator(port);
+ });
+ }).then(function (emulatorId) {
+ if (!emulatorId) { return Promise.reject(new CordovaError('Failed to start emulator')); }
+
+ // wait for emulator to boot up
+ process.stdout.write('Waiting for emulator to boot (this may take a while)...');
+ return self.wait_for_boot(emulatorId, boot_timeout).then(function (success) {
+ if (success) {
+ events.emit('log', 'BOOT COMPLETE');
+ // unlock screen
+ return Adb.shell(emulatorId, 'input keyevent 82').then(function () {
+ // return the new emulator id for the started emulators
+ return emulatorId;
+ });
+ } else {
+ // We timed out waiting for the boot to happen
+ return null;
+ }
+ });
+ });
+};
+
+/*
+ * Waits for an emulator to boot on a given port.
+ * Returns this emulator's ID in a promise.
+ */
+module.exports.wait_for_emulator = function (port) {
+ var self = this;
+ return Promise.resolve().then(function () {
+ var emulator_id = 'emulator-' + port;
+ return Adb.shell(emulator_id, 'getprop dev.bootcomplete').then(function (output) {
+ if (output.indexOf('1') >= 0) {
+ return emulator_id;
+ }
+ return self.wait_for_emulator(port);
+ }, function (error) {
+ if ((error && error.message &&
+ (error.message.indexOf('not found') > -1)) ||
+ (error.message.indexOf('device offline') > -1) ||
+ (error.message.indexOf('device still connecting') > -1) ||
+ (error.message.indexOf('device still authorizing') > -1)) {
+ // emulator not yet started, continue waiting
+ return self.wait_for_emulator(port);
+ } else {
+ // something unexpected has happened
+ throw error;
+ }
+ });
+ });
+};
+
+/*
+ * Waits for the core android process of the emulator to start. Returns a
+ * promise that resolves to a boolean indicating success. Not specifying a
+ * time_remaining or passing a negative value will cause it to wait forever
+ */
+module.exports.wait_for_boot = function (emulator_id, time_remaining) {
+ var self = this;
+ return Adb.shell(emulator_id, 'getprop sys.boot_completed').then(function (output) {
+ if (output.match(/1/)) {
+ return true;
+ } else if (time_remaining === 0) {
+ return false;
+ } else {
+ process.stdout.write('.');
+
+ return new Promise(resolve => {
+ const delay = time_remaining < CHECK_BOOTED_INTERVAL ? time_remaining : CHECK_BOOTED_INTERVAL;
+
+ setTimeout(() => {
+ const updated_time = time_remaining >= 0 ? Math.max(time_remaining - CHECK_BOOTED_INTERVAL, 0) : time_remaining;
+ resolve(self.wait_for_boot(emulator_id, updated_time));
+ }, delay);
+ });
+ }
+ });
+};
diff --git a/node_modules/cordova-android/lib/env/java.js b/node_modules/cordova-android/lib/env/java.js
new file mode 100644
index 0000000..5bd75cb
--- /dev/null
+++ b/node_modules/cordova-android/lib/env/java.js
@@ -0,0 +1,129 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+const execa = require('execa');
+const fs = require('fs-extra');
+const path = require('path');
+const glob = require('fast-glob');
+const { CordovaError, events } = require('cordova-common');
+const utils = require('../utils');
+const semver = require('semver');
+
+/**
+ * Will be set to true on successful ensureness.
+ * If true, skips the expensive java checks.
+ */
+let javaIsEnsured = false;
+
+const java = {
+ /**
+ * Gets the version from the javac executable.
+ *
+ * @returns {semver.SemVer}
+ */
+ getVersion: async () => {
+ await java._ensure(process.env);
+
+ // Java <= 8 writes version info to stderr, Java >= 9 to stdout
+ let javacOutput;
+ try {
+ javacOutput = (await execa('javac', ['-version'], { all: true })).all;
+ } catch (ex) {
+ events.emit('verbose', ex.shortMessage);
+
+ let msg =
+ 'Failed to run "javac -version", make sure that you have a JDK version 8 installed.\n' +
+ 'You can get it from the following location:\n' +
+ 'https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html';
+ if (process.env.JAVA_HOME) {
+ msg += '\n\n';
+ msg += 'Your JAVA_HOME is invalid: ' + process.env.JAVA_HOME;
+ }
+ throw new CordovaError(msg);
+ }
+
+ // We have to filter the output, because javac prints _JAVA_OPTIONS
+ // before printing the version which causes semver.coerce to fail to get
+ // the correct version if those options contain any numbers.
+ const match = /javac\s+([\d.]+)/i.exec(javacOutput);
+ return semver.coerce(match && match[1]);
+ },
+
+ /**
+ * Ensures that Java is installed. Will throw exception if not.
+ * Will set JAVA_HOME and PATH environment variables.
+ *
+ * This function becomes a no-op if already ran previously.
+ */
+ _ensure: async (environment) => {
+ if (javaIsEnsured) {
+ return;
+ }
+
+ const javaHome = environment.CORDOVA_JAVA_HOME || environment.JAVA_HOME;
+ if (javaHome) {
+ // Ensure that CORDOVA_JAVA_HOME overrides
+ environment.JAVA_HOME = javaHome;
+ // Ensure that the JAVA_HOME bin path is before anything else
+ // to cover cases where different Java versions is in the PATH
+ environment.PATH = path.join(environment.JAVA_HOME, 'bin') + path.delimiter + environment.PATH;
+ } else {
+ const javacPath = utils.forgivingWhichSync('javac');
+ if (javacPath) {
+ // OS X has a command for finding JAVA_HOME.
+ const find_java = '/usr/libexec/java_home';
+ const default_java_error_msg = 'Failed to find \'JAVA_HOME\' environment variable. Try setting it manually.';
+ if (fs.existsSync(find_java)) {
+ try {
+ environment.JAVA_HOME = (await execa(find_java)).stdout;
+ } catch (ex) {
+ events.emit('verbose', ex.shortMessage);
+ throw new CordovaError(default_java_error_msg);
+ }
+ } else {
+ // See if we can derive it from javac's location.
+ var maybeJavaHome = path.dirname(path.dirname(javacPath));
+ if (fs.existsSync(path.join(maybeJavaHome, 'bin', 'java')) ||
+ fs.existsSync(path.join(maybeJavaHome, 'bin', 'java.exe'))) {
+ environment.JAVA_HOME = maybeJavaHome;
+ } else {
+ throw new CordovaError(default_java_error_msg);
+ }
+ }
+ } else if (utils.isWindows()) {
+ const baseDirs = [environment.ProgramFiles, environment['ProgramFiles(x86)']];
+ const globOpts = { absolute: true, onlyDirectories: true };
+ const flatMap = (arr, f) => [].concat(...arr.map(f));
+ const jdkDir = flatMap(baseDirs, cwd => {
+ return glob.sync('java/jdk*', { cwd, ...globOpts });
+ }
+ )[0];
+
+ if (jdkDir) {
+ environment.PATH += path.delimiter + path.join(jdkDir, 'bin');
+ environment.JAVA_HOME = path.normalize(jdkDir);
+ }
+ }
+ }
+
+ javaIsEnsured = true;
+ }
+};
+
+module.exports = java;
diff --git a/node_modules/cordova-android/lib/getASPath.bat b/node_modules/cordova-android/lib/getASPath.bat
new file mode 100644
index 0000000..4712b0e
--- /dev/null
+++ b/node_modules/cordova-android/lib/getASPath.bat
@@ -0,0 +1,20 @@
+:: Licensed to the Apache Software Foundation (ASF) under one
+:: or more contributor license agreements. See the NOTICE file
+:: distributed with this work for additional information
+:: regarding copyright ownership. The ASF licenses this file
+:: to you under the Apache License, Version 2.0 (the
+:: "License"); you may not use this file except in compliance
+:: with the License. You may obtain a copy of the License at
+::
+:: http://www.apache.org/licenses/LICENSE-2.0
+::
+:: Unless required by applicable law or agreed to in writing,
+:: software distributed under the License is distributed on an
+:: "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+:: KIND, either express or implied. See the License for the
+:: specific language governing permissions and limitations
+:: under the License.
+
+@ECHO OFF
+for /f "tokens=2*" %%a in ('REG QUERY "HKEY_LOCAL_MACHINE\SOFTWARE\Android Studio" /v Path') do set "ASPath=%%~b"
+ECHO %ASPath%
\ No newline at end of file
diff --git a/node_modules/cordova-android/lib/gradle-config-defaults.js b/node_modules/cordova-android/lib/gradle-config-defaults.js
new file mode 100644
index 0000000..933fe64
--- /dev/null
+++ b/node_modules/cordova-android/lib/gradle-config-defaults.js
@@ -0,0 +1,29 @@
+/*!
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+const ABS_MODULE_PATH = '/framework/cdv-gradle-config-defaults.json';
+
+try {
+ // Try relative require first, …
+ module.exports = require('..' + ABS_MODULE_PATH);
+} catch (error) {
+ // … then fall back to installed-package require
+ if (error.code !== 'MODULE_NOT_FOUND') throw error;
+ module.exports = require('cordova-android' + ABS_MODULE_PATH);
+}
diff --git a/node_modules/cordova-android/lib/pluginHandlers.js b/node_modules/cordova-android/lib/pluginHandlers.js
new file mode 100644
index 0000000..617c30e
--- /dev/null
+++ b/node_modules/cordova-android/lib/pluginHandlers.js
@@ -0,0 +1,324 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+var fs = require('fs-extra');
+var path = require('path');
+var isPathInside = require('is-path-inside');
+var events = require('cordova-common').events;
+var CordovaError = require('cordova-common').CordovaError;
+
+var handlers = {
+ 'source-file': {
+ install: function (obj, plugin, project, options) {
+ if (!obj.src) throw new CordovaError(generateAttributeError('src', 'source-file', plugin.id));
+ if (!obj.targetDir) throw new CordovaError(generateAttributeError('target-dir', 'source-file', plugin.id));
+
+ var dest = getInstallDestination(obj);
+
+ if (options && options.force) {
+ copyFile(plugin.dir, obj.src, project.projectDir, dest, !!(options && options.link));
+ } else {
+ copyNewFile(plugin.dir, obj.src, project.projectDir, dest, !!(options && options.link));
+ }
+ },
+ uninstall: function (obj, plugin, project, options) {
+ var dest = getInstallDestination(obj);
+
+ // TODO: Add Koltin extension to uninstall, since they are handled like Java files
+ if (obj.src.endsWith('java')) {
+ deleteJava(project.projectDir, dest);
+ } else {
+ // Just remove the file, not the whole parent directory
+ removeFile(path.resolve(project.projectDir, dest));
+ }
+ }
+ },
+ 'lib-file': {
+ install: function (obj, plugin, project, options) {
+ var dest = path.join('app/libs', path.basename(obj.src));
+ copyFile(plugin.dir, obj.src, project.projectDir, dest, !!(options && options.link));
+ },
+ uninstall: function (obj, plugin, project, options) {
+ var dest = path.join('app/libs', path.basename(obj.src));
+ removeFile(path.resolve(project.projectDir, dest));
+ }
+ },
+ 'resource-file': {
+ install: function (obj, plugin, project, options) {
+ var dest = path.join('app', 'src', 'main', obj.target);
+ copyFile(plugin.dir, obj.src, project.projectDir, dest, !!(options && options.link));
+ },
+ uninstall: function (obj, plugin, project, options) {
+ var dest = path.join('app', 'src', 'main', obj.target);
+ removeFile(path.resolve(project.projectDir, dest));
+ }
+ },
+ framework: {
+ install: function (obj, plugin, project, options) {
+ var src = obj.src;
+ if (!src) throw new CordovaError(generateAttributeError('src', 'framework', plugin.id));
+
+ events.emit('verbose', 'Installing Android library: ' + src);
+ var parentDir = obj.parent ? path.resolve(project.projectDir, obj.parent) : project.projectDir;
+ var subDir;
+
+ if (obj.custom) {
+ var subRelativeDir = project.getCustomSubprojectRelativeDir(plugin.id, src);
+ copyNewFile(plugin.dir, src, project.projectDir, subRelativeDir, !!(options && options.link));
+ subDir = path.resolve(project.projectDir, subRelativeDir);
+ } else {
+ obj.type = 'sys';
+ subDir = src;
+ }
+
+ if (obj.type === 'gradleReference') {
+ project.addGradleReference(parentDir, subDir);
+ } else if (obj.type === 'sys') {
+ project.addSystemLibrary(parentDir, subDir);
+ } else {
+ project.addSubProject(parentDir, subDir);
+ }
+ },
+ uninstall: function (obj, plugin, project, options) {
+ var src = obj.src;
+ if (!src) throw new CordovaError(generateAttributeError('src', 'framework', plugin.id));
+
+ events.emit('verbose', 'Uninstalling Android library: ' + src);
+ var parentDir = obj.parent ? path.resolve(project.projectDir, obj.parent) : project.projectDir;
+ var subDir;
+
+ if (obj.custom) {
+ var subRelativeDir = project.getCustomSubprojectRelativeDir(plugin.id, src);
+ removeFile(path.resolve(project.projectDir, subRelativeDir));
+ subDir = path.resolve(project.projectDir, subRelativeDir);
+ // If it's the last framework in the plugin, remove the parent directory.
+ var parDir = path.dirname(subDir);
+ if (fs.existsSync(parDir) && fs.readdirSync(parDir).length === 0) {
+ fs.rmdirSync(parDir);
+ }
+ } else {
+ obj.type = 'sys';
+ subDir = src;
+ }
+
+ if (obj.type === 'gradleReference') {
+ project.removeGradleReference(parentDir, subDir);
+ } else if (obj.type === 'sys') {
+ project.removeSystemLibrary(parentDir, subDir);
+ } else {
+ project.removeSubProject(parentDir, subDir);
+ }
+ }
+ },
+ asset: {
+ install: function (obj, plugin, project, options) {
+ if (!obj.src) {
+ throw new CordovaError(generateAttributeError('src', 'asset', plugin.id));
+ }
+ if (!obj.target) {
+ throw new CordovaError(generateAttributeError('target', 'asset', plugin.id));
+ }
+
+ copyFile(plugin.dir, obj.src, project.www, obj.target);
+ if (options && options.usePlatformWww) {
+ // CB-11022 copy file to both directories if usePlatformWww is specified
+ copyFile(plugin.dir, obj.src, project.platformWww, obj.target);
+ }
+ },
+ uninstall: function (obj, plugin, project, options) {
+ var target = obj.target || obj.src;
+
+ if (!target) throw new CordovaError(generateAttributeError('target', 'asset', plugin.id));
+
+ removeFile(path.resolve(project.www, target));
+ removeFile(path.resolve(project.www, 'plugins', plugin.id));
+ if (options && options.usePlatformWww) {
+ // CB-11022 remove file from both directories if usePlatformWww is specified
+ removeFile(path.resolve(project.platformWww, target));
+ removeFile(path.resolve(project.platformWww, 'plugins', plugin.id));
+ }
+ }
+ },
+ 'js-module': {
+ install: function (obj, plugin, project, options) {
+ // Copy the plugin's files into the www directory.
+ var moduleSource = path.resolve(plugin.dir, obj.src);
+ var moduleName = plugin.id + '.' + (obj.name || path.basename(obj.src, path.extname(obj.src)));
+
+ // Read in the file, prepend the cordova.define, and write it back out.
+ var scriptContent = fs.readFileSync(moduleSource, 'utf-8').replace(/^\ufeff/, ''); // Window BOM
+ if (moduleSource.match(/.*\.json$/)) {
+ scriptContent = 'module.exports = ' + scriptContent;
+ }
+ scriptContent = 'cordova.define("' + moduleName + '", function(require, exports, module) {\n' + scriptContent + '\n});\n';
+
+ var wwwDest = path.resolve(project.www, 'plugins', plugin.id, obj.src);
+ fs.ensureDirSync(path.dirname(wwwDest));
+ fs.writeFileSync(wwwDest, scriptContent, 'utf-8');
+
+ if (options && options.usePlatformWww) {
+ // CB-11022 copy file to both directories if usePlatformWww is specified
+ var platformWwwDest = path.resolve(project.platformWww, 'plugins', plugin.id, obj.src);
+ fs.ensureDirSync(path.dirname(platformWwwDest));
+ fs.writeFileSync(platformWwwDest, scriptContent, 'utf-8');
+ }
+ },
+ uninstall: function (obj, plugin, project, options) {
+ var pluginRelativePath = path.join('plugins', plugin.id, obj.src);
+ removeFileAndParents(project.www, pluginRelativePath);
+ if (options && options.usePlatformWww) {
+ // CB-11022 remove file from both directories if usePlatformWww is specified
+ removeFileAndParents(project.platformWww, pluginRelativePath);
+ }
+ }
+ }
+};
+
+module.exports.getInstaller = function (type) {
+ if (handlers[type] && handlers[type].install) {
+ return handlers[type].install;
+ }
+
+ events.emit('verbose', '<' + type + '> is not supported for android plugins');
+};
+
+module.exports.getUninstaller = function (type) {
+ if (handlers[type] && handlers[type].uninstall) {
+ return handlers[type].uninstall;
+ }
+
+ events.emit('verbose', '<' + type + '> is not supported for android plugins');
+};
+
+function copyFile (plugin_dir, src, project_dir, dest, link) {
+ src = path.resolve(plugin_dir, src);
+ if (!fs.existsSync(src)) throw new CordovaError('"' + src + '" not found!');
+
+ // check that src path is inside plugin directory
+ var real_path = fs.realpathSync(src);
+ var real_plugin_path = fs.realpathSync(plugin_dir);
+ if (!isPathInside(real_path, real_plugin_path)) { throw new CordovaError('File "' + src + '" is located outside the plugin directory "' + plugin_dir + '"'); }
+
+ dest = path.resolve(project_dir, dest);
+
+ // check that dest path is located in project directory
+ if (!isPathInside(dest, project_dir)) { throw new CordovaError('Destination "' + dest + '" for source file "' + src + '" is located outside the project'); }
+
+ fs.ensureDirSync(path.dirname(dest));
+ if (link) {
+ symlinkFileOrDirTree(src, dest);
+ } else {
+ fs.copySync(src, dest);
+ }
+}
+
+// Same as copy file but throws error if target exists
+function copyNewFile (plugin_dir, src, project_dir, dest, link) {
+ var target_path = path.resolve(project_dir, dest);
+ if (fs.existsSync(target_path)) { throw new CordovaError('"' + target_path + '" already exists!'); }
+
+ copyFile(plugin_dir, src, project_dir, dest, !!link);
+}
+
+function symlinkFileOrDirTree (src, dest) {
+ if (fs.existsSync(dest)) {
+ fs.removeSync(dest);
+ }
+
+ if (fs.statSync(src).isDirectory()) {
+ fs.ensureDirSync(path.dirname(dest));
+ fs.readdirSync(src).forEach(function (entry) {
+ symlinkFileOrDirTree(path.join(src, entry), path.join(dest, entry));
+ });
+ } else {
+ fs.symlinkSync(path.relative(fs.realpathSync(path.dirname(dest)), src), dest);
+ }
+}
+
+function removeFile (file) {
+ fs.removeSync(file);
+}
+
+// Sometimes we want to remove some java, and prune any unnecessary empty directories
+function deleteJava (project_dir, destFile) {
+ removeFileAndParents(project_dir, destFile, 'src');
+}
+
+function removeFileAndParents (baseDir, destFile, stopper) {
+ stopper = stopper || '.';
+ var file = path.resolve(baseDir, destFile);
+ if (!fs.existsSync(file)) return;
+
+ removeFile(file);
+
+ // check if directory is empty
+ var curDir = path.dirname(file);
+
+ while (curDir !== path.resolve(baseDir, stopper)) {
+ if (fs.existsSync(curDir) && fs.readdirSync(curDir).length === 0) {
+ fs.rmdirSync(curDir);
+ curDir = path.resolve(curDir, '..');
+ } else {
+ // directory not empty...do nothing
+ break;
+ }
+ }
+}
+
+function generateAttributeError (attribute, element, id) {
+ return 'Required attribute "' + attribute + '" not specified in <' + element + '> element from plugin: ' + id;
+}
+
+function getInstallDestination (obj) {
+ var APP_MAIN_PREFIX = 'app/src/main';
+ var PATH_SEPARATOR = '/';
+
+ var PATH_SEP_MATCH = '\\' + PATH_SEPARATOR;
+ var PATH_SEP_OR_EOL_MATCH = '(\\' + PATH_SEPARATOR + '|$)';
+
+ var appReg = new RegExp('^app' + PATH_SEP_OR_EOL_MATCH);
+ var libsReg = new RegExp('^libs' + PATH_SEP_OR_EOL_MATCH);
+ var srcReg = new RegExp('^src' + PATH_SEP_OR_EOL_MATCH);
+ var srcMainReg = new RegExp('^src' + PATH_SEP_MATCH + 'main' + PATH_SEP_OR_EOL_MATCH);
+
+ if (appReg.test(obj.targetDir)) {
+ // If any source file is using the new app directory structure,
+ // don't penalize it
+ return path.join(obj.targetDir, path.basename(obj.src));
+ } else {
+ // Plugin using deprecated target directory structure (GH-580)
+ if (obj.src.endsWith('.java')) {
+ return path.join(APP_MAIN_PREFIX, 'java', obj.targetDir.replace(srcReg, ''),
+ path.basename(obj.src));
+ } else if (obj.src.endsWith('.aidl')) {
+ return path.join(APP_MAIN_PREFIX, 'aidl', obj.targetDir.replace(srcReg, ''),
+ path.basename(obj.src));
+ } else if (libsReg.test(obj.targetDir)) {
+ if (obj.src.endsWith('.so')) {
+ return path.join(APP_MAIN_PREFIX, 'jniLibs', obj.targetDir.replace(libsReg, ''),
+ path.basename(obj.src));
+ } else {
+ return path.join('app', obj.targetDir, path.basename(obj.src));
+ }
+ } else if (srcMainReg.test(obj.targetDir)) {
+ return path.join('app', obj.targetDir, path.basename(obj.src));
+ }
+
+ // For all other source files not using the new app directory structure,
+ // add 'app/src/main' to the targetDir
+ return path.join(APP_MAIN_PREFIX, obj.targetDir, path.basename(obj.src));
+ }
+}
diff --git a/node_modules/cordova-android/lib/prepare.js b/node_modules/cordova-android/lib/prepare.js
new file mode 100644
index 0000000..9e4f50c
--- /dev/null
+++ b/node_modules/cordova-android/lib/prepare.js
@@ -0,0 +1,821 @@
+/**
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+var fs = require('fs-extra');
+var path = require('path');
+const nopt = require('nopt');
+const glob = require('fast-glob');
+var events = require('cordova-common').events;
+var AndroidManifest = require('./AndroidManifest');
+var checkReqs = require('./check_reqs');
+var xmlHelpers = require('cordova-common').xmlHelpers;
+var CordovaError = require('cordova-common').CordovaError;
+var ConfigParser = require('cordova-common').ConfigParser;
+var FileUpdater = require('cordova-common').FileUpdater;
+var PlatformJson = require('cordova-common').PlatformJson;
+var PlatformMunger = require('cordova-common').ConfigChanges.PlatformMunger;
+var PluginInfoProvider = require('cordova-common').PluginInfoProvider;
+const utils = require('./utils');
+const gradleConfigDefaults = require('./gradle-config-defaults');
+
+const GradlePropertiesParser = require('./config/GradlePropertiesParser');
+
+function parseArguments (argv) {
+ return nopt({
+ // `jvmargs` is a valid option however, we don't actually want to parse it because we want the entire string as is.
+ // jvmargs: String
+ }, {}, argv || [], 0);
+}
+
+module.exports.prepare = function (cordovaProject, options) {
+ var self = this;
+
+ let args = {};
+ if (options && options.options) {
+ args = parseArguments(options.options.argv);
+ }
+
+ var platformJson = PlatformJson.load(this.locations.root, this.platform);
+ var munger = new PlatformMunger(this.platform, this.locations.root, platformJson, new PluginInfoProvider());
+
+ this._config = updateConfigFilesFrom(cordovaProject.projectConfig, munger, this.locations);
+
+ // Update Gradle cdv-gradle-config.json
+ updateUserProjectGradleConfig(this);
+
+ // Update Project's Gradle Properties
+ updateUserProjectGradlePropertiesConfig(this, args);
+
+ // Update own www dir with project's www assets and plugins' assets and js-files
+ return Promise.resolve(updateWww(cordovaProject, this.locations)).then(function () {
+ // update project according to config.xml changes.
+ return updateProjectAccordingTo(self._config, self.locations);
+ }).then(function () {
+ updateIcons(cordovaProject, path.relative(cordovaProject.root, self.locations.res));
+ updateSplashes(cordovaProject, path.relative(cordovaProject.root, self.locations.res));
+ updateFileResources(cordovaProject, path.relative(cordovaProject.root, self.locations.root));
+ }).then(function () {
+ events.emit('verbose', 'Prepared android project successfully');
+ });
+};
+
+/** @param {PlatformApi} project */
+function updateUserProjectGradleConfig (project) {
+ // Generate project gradle config
+ const projectGradleConfig = {
+ ...gradleConfigDefaults,
+ ...getUserGradleConfig(project._config)
+ };
+
+ // Write out changes
+ const projectGradleConfigPath = path.join(project.root, 'cdv-gradle-config.json');
+ fs.writeJSONSync(projectGradleConfigPath, projectGradleConfig, { spaces: 2 });
+}
+
+function getUserGradleConfig (configXml) {
+ const configXmlToGradleMapping = [
+ { xmlKey: 'android-minSdkVersion', gradleKey: 'MIN_SDK_VERSION', type: Number },
+ { xmlKey: 'android-maxSdkVersion', gradleKey: 'MAX_SDK_VERSION', type: Number },
+ { xmlKey: 'android-targetSdkVersion', gradleKey: 'SDK_VERSION', type: Number },
+ { xmlKey: 'android-buildToolsVersion', gradleKey: 'BUILD_TOOLS_VERSION', type: String },
+ { xmlKey: 'GradleVersion', gradleKey: 'GRADLE_VERSION', type: String },
+ { xmlKey: 'AndroidGradlePluginVersion', gradleKey: 'AGP_VERSION', type: String },
+ { xmlKey: 'GradlePluginKotlinVersion', gradleKey: 'KOTLIN_VERSION', type: String },
+ { xmlKey: 'AndroidXAppCompatVersion', gradleKey: 'ANDROIDX_APP_COMPAT_VERSION', type: String },
+ { xmlKey: 'AndroidXWebKitVersion', gradleKey: 'ANDROIDX_WEBKIT_VERSION', type: String },
+ { xmlKey: 'GradlePluginGoogleServicesVersion', gradleKey: 'GRADLE_PLUGIN_GOOGLE_SERVICES_VERSION', type: String },
+ { xmlKey: 'GradlePluginGoogleServicesEnabled', gradleKey: 'IS_GRADLE_PLUGIN_GOOGLE_SERVICES_ENABLED', type: Boolean },
+ { xmlKey: 'GradlePluginKotlinEnabled', gradleKey: 'IS_GRADLE_PLUGIN_KOTLIN_ENABLED', type: Boolean }
+ ];
+
+ return configXmlToGradleMapping.reduce((config, mapping) => {
+ const rawValue = configXml.getPreference(mapping.xmlKey, 'android');
+
+ // ignore missing preferences (which occur as '')
+ if (rawValue) {
+ config[mapping.gradleKey] = parseStringAsType(rawValue, mapping.type);
+ }
+
+ return config;
+ }, {});
+}
+
+/** Converts given string to given type */
+function parseStringAsType (value, type) {
+ switch (type) {
+ case String:
+ return String(value);
+ case Number:
+ return parseFloat(value);
+ case Boolean:
+ return value.toLowerCase() === 'true';
+ default:
+ throw new CordovaError('Invalid type: ' + type);
+ }
+}
+
+function updateUserProjectGradlePropertiesConfig (project, args) {
+ const gradlePropertiesUserConfig = {};
+
+ // Get the min SDK version from config.xml
+ if (args.jvmargs) gradlePropertiesUserConfig['org.gradle.jvmargs'] = args.jvmargs;
+
+ const isGradlePluginKotlinEnabled = project._config.getPreference('GradlePluginKotlinEnabled', 'android');
+ if (isGradlePluginKotlinEnabled) {
+ const gradlePluginKotlinCodeStyle = project._config.getPreference('GradlePluginKotlinCodeStyle', 'android');
+ gradlePropertiesUserConfig['kotlin.code.style'] = gradlePluginKotlinCodeStyle || 'official';
+ }
+
+ const gradlePropertiesParser = new GradlePropertiesParser(project.root);
+ gradlePropertiesParser.configure(gradlePropertiesUserConfig);
+}
+
+module.exports.clean = function (options) {
+ // A cordovaProject isn't passed into the clean() function, because it might have
+ // been called from the platform shell script rather than the CLI. Check for the
+ // noPrepare option passed in by the non-CLI clean script. If that's present, or if
+ // there's no config.xml found at the project root, then don't clean prepared files.
+ var projectRoot = path.resolve(this.root, '../..');
+ if ((options && options.noPrepare) || !fs.existsSync(this.locations.configXml) ||
+ !fs.existsSync(this.locations.configXml)) {
+ return Promise.resolve();
+ }
+
+ var projectConfig = new ConfigParser(this.locations.configXml);
+
+ var self = this;
+ return Promise.resolve().then(function () {
+ cleanWww(projectRoot, self.locations);
+ cleanIcons(projectRoot, projectConfig, path.relative(projectRoot, self.locations.res));
+ cleanSplashes(projectRoot, projectConfig, path.relative(projectRoot, self.locations.res));
+ cleanFileResources(projectRoot, projectConfig, path.relative(projectRoot, self.locations.root));
+ });
+};
+
+/**
+ * Updates config files in project based on app's config.xml and config munge,
+ * generated by plugins.
+ *
+ * @param {ConfigParser} sourceConfig A project's configuration that will
+ * be merged into platform's config.xml
+ * @param {ConfigChanges} configMunger An initialized ConfigChanges instance
+ * for this platform.
+ * @param {Object} locations A map of locations for this platform
+ *
+ * @return {ConfigParser} An instance of ConfigParser, that
+ * represents current project's configuration. When returned, the
+ * configuration is already dumped to appropriate config.xml file.
+ */
+function updateConfigFilesFrom (sourceConfig, configMunger, locations) {
+ events.emit('verbose', 'Generating platform-specific config.xml from defaults for android at ' + locations.configXml);
+
+ // First cleanup current config and merge project's one into own
+ // Overwrite platform config.xml with defaults.xml.
+ fs.copySync(locations.defaultConfigXml, locations.configXml);
+
+ // Then apply config changes from global munge to all config files
+ // in project (including project's config)
+ configMunger.reapply_global_munge().save_all();
+
+ events.emit('verbose', 'Merging project\'s config.xml into platform-specific android config.xml');
+ // Merge changes from app's config.xml into platform's one
+ var config = new ConfigParser(locations.configXml);
+ xmlHelpers.mergeXml(sourceConfig.doc.getroot(),
+ config.doc.getroot(), 'android', /* clobber= */true);
+
+ config.write();
+ return config;
+}
+
+/**
+ * Logs all file operations via the verbose event stream, indented.
+ */
+function logFileOp (message) {
+ events.emit('verbose', ' ' + message);
+}
+
+/**
+ * Updates platform 'www' directory by replacing it with contents of
+ * 'platform_www' and app www. Also copies project's overrides' folder into
+ * the platform 'www' folder
+ *
+ * @param {Object} cordovaProject An object which describes cordova project.
+ * @param {Object} destinations An object that contains destination
+ * paths for www files.
+ */
+function updateWww (cordovaProject, destinations) {
+ var sourceDirs = [
+ path.relative(cordovaProject.root, cordovaProject.locations.www),
+ path.relative(cordovaProject.root, destinations.platformWww)
+ ];
+
+ // If project contains 'merges' for our platform, use them as another overrides
+ var merges_path = path.join(cordovaProject.root, 'merges', 'android');
+ if (fs.existsSync(merges_path)) {
+ events.emit('verbose', 'Found "merges/android" folder. Copying its contents into the android project.');
+ sourceDirs.push(path.join('merges', 'android'));
+ }
+
+ var targetDir = path.relative(cordovaProject.root, destinations.www);
+ events.emit(
+ 'verbose', 'Merging and updating files from [' + sourceDirs.join(', ') + '] to ' + targetDir);
+ FileUpdater.mergeAndUpdateDir(
+ sourceDirs, targetDir, { rootDir: cordovaProject.root }, logFileOp);
+}
+
+/**
+ * Cleans all files from the platform 'www' directory.
+ */
+function cleanWww (projectRoot, locations) {
+ var targetDir = path.relative(projectRoot, locations.www);
+ events.emit('verbose', 'Cleaning ' + targetDir);
+
+ // No source paths are specified, so mergeAndUpdateDir() will clear the target directory.
+ FileUpdater.mergeAndUpdateDir(
+ [], targetDir, { rootDir: projectRoot, all: true }, logFileOp);
+}
+
+/**
+ * Updates project structure and AndroidManifest according to project's configuration.
+ *
+ * @param {ConfigParser} platformConfig A project's configuration that will
+ * be used to update project
+ * @param {Object} locations A map of locations for this platform
+ */
+function updateProjectAccordingTo (platformConfig, locations) {
+ // Update app name by editing res/values/strings.xml
+ var strings = xmlHelpers.parseElementtreeSync(locations.strings);
+
+ var name = platformConfig.name();
+ strings.find('string[@name="app_name"]').text = name.replace(/'/g, '\\\'');
+
+ var shortName = platformConfig.shortName && platformConfig.shortName();
+ if (shortName && shortName !== name) {
+ strings.find('string[@name="launcher_name"]').text = shortName.replace(/'/g, '\\\'');
+ }
+
+ fs.writeFileSync(locations.strings, strings.write({ indent: 4 }), 'utf-8');
+ events.emit('verbose', 'Wrote out android application name "' + name + '" to ' + locations.strings);
+
+ // Update app name for gradle project
+ fs.writeFileSync(path.join(locations.root, 'cdv-gradle-name.gradle'),
+ '// GENERATED FILE - DO NOT EDIT\n' +
+ 'rootProject.name = "' + name.replace(/[/\\:<>"?*|]/g, '_') + '"\n');
+
+ // Java packages cannot support dashes
+ var androidPkgName = (platformConfig.android_packageName() || platformConfig.packageName()).replace(/-/g, '_');
+
+ var manifest = new AndroidManifest(locations.manifest);
+ var manifestId = manifest.getPackageId();
+
+ manifest.getActivity()
+ .setOrientation(platformConfig.getPreference('orientation'))
+ .setLaunchMode(findAndroidLaunchModePreference(platformConfig));
+
+ manifest.setVersionName(platformConfig.version())
+ .setVersionCode(platformConfig.android_versionCode() || default_versionCode(platformConfig.version()))
+ .setPackageId(androidPkgName)
+ .write();
+
+ // Java file paths shouldn't be hard coded
+ const javaDirectory = path.join(locations.javaSrc, manifestId.replace(/\./g, '/'));
+ const java_files = glob.sync('**/*.java', { cwd: javaDirectory, absolute: true }).filter(f => {
+ const contents = fs.readFileSync(f, 'utf-8');
+ return /extends\s+CordovaActivity/.test(contents);
+ });
+
+ if (java_files.length === 0) {
+ throw new CordovaError('No Java files found that extend CordovaActivity.');
+ } else if (java_files.length > 1) {
+ events.emit('log', 'Multiple candidate Java files that extend CordovaActivity found. Guessing at the first one, ' + java_files[0]);
+ }
+
+ const destFile = java_files[0];
+
+ // var destFile = path.join(locations.root, 'app', 'src', 'main', 'java', androidPkgName.replace(/\./g, '/'), path.basename(java_files[0]));
+ // fs.ensureDirSync(path.dirname(destFile));
+ // events.emit('verbose', java_files[0]);
+ // events.emit('verbose', destFile);
+ // console.log(locations);
+ // fs.copySync(java_files[0], destFile);
+ utils.replaceFileContents(destFile, /package [\w.]*;/, 'package ' + androidPkgName + ';');
+ events.emit('verbose', 'Wrote out Android package name "' + androidPkgName + '" to ' + destFile);
+
+ var removeOrigPkg = checkReqs.isWindows() || checkReqs.isDarwin()
+ ? manifestId.toUpperCase() !== androidPkgName.toUpperCase()
+ : manifestId !== androidPkgName;
+
+ if (removeOrigPkg) {
+ // If package was name changed we need to remove old java with main activity
+ fs.removeSync(java_files[0]);
+ // remove any empty directories
+ var currentDir = path.dirname(java_files[0]);
+ var sourcesRoot = path.resolve(locations.root, 'src');
+ while (currentDir !== sourcesRoot) {
+ if (fs.existsSync(currentDir) && fs.readdirSync(currentDir).length === 0) {
+ fs.rmdirSync(currentDir);
+ currentDir = path.resolve(currentDir, '..');
+ } else {
+ break;
+ }
+ }
+ }
+}
+
+// Consturct the default value for versionCode as
+// PATCH + MINOR * 100 + MAJOR * 10000
+// see http://developer.android.com/tools/publishing/versioning.html
+function default_versionCode (version) {
+ var nums = version.split('-')[0].split('.');
+ var versionCode = 0;
+ if (+nums[0]) {
+ versionCode += +nums[0] * 10000;
+ }
+ if (+nums[1]) {
+ versionCode += +nums[1] * 100;
+ }
+ if (+nums[2]) {
+ versionCode += +nums[2];
+ }
+
+ events.emit('verbose', 'android-versionCode not found in config.xml. Generating a code based on version in config.xml (' + version + '): ' + versionCode);
+ return versionCode;
+}
+
+function getImageResourcePath (resourcesDir, type, density, name, sourceName) {
+ // Use same extension as source with special case for 9-Patch files
+ const ext = sourceName.endsWith('.9.png')
+ ? '.9.png' : path.extname(sourceName).toLowerCase();
+
+ const subDir = density ? `${type}-${density}` : type;
+ return path.join(resourcesDir, subDir, name + ext);
+}
+
+function getAdaptiveImageResourcePath (resourcesDir, type, density, name, sourceName) {
+ if (/\.9\.png$/.test(sourceName)) {
+ name = name.replace(/\.png$/, '.9.png');
+ }
+ var resourcePath = path.join(resourcesDir, (density ? type + '-' + density + '-v26' : type), name);
+ return resourcePath;
+}
+
+function makeSplashCleanupMap (projectRoot, resourcesDir) {
+ // Build an initial resource map that deletes all existing splash screens
+ const existingSplashPaths = glob.sync(
+ `${resourcesDir.replace(/\\/g, '/')}/drawable-*/screen.{png,9.png,webp,jpg,jpeg}`,
+ { cwd: projectRoot }
+ );
+ return makeCleanResourceMap(existingSplashPaths);
+}
+
+function updateSplashes (cordovaProject, platformResourcesDir) {
+ var resources = cordovaProject.projectConfig.getSplashScreens('android');
+
+ // if there are no "splash" elements in config.xml
+ if (resources.length === 0) {
+ events.emit('verbose', 'This app does not have splash screens defined');
+ // We must not return here!
+ // If the user defines no splash screens, the cleanup map will cause any
+ // existing splash screen images (e.g. the defaults that we copy into a
+ // new app) to be removed from the app folder, which is what we want.
+ }
+
+ // Build an initial resource map that deletes all existing splash screens
+ const resourceMap = makeSplashCleanupMap(cordovaProject.root, platformResourcesDir);
+
+ var hadMdpi = false;
+ resources.forEach(function (resource) {
+ if (!resource.density) {
+ return;
+ }
+ if (resource.density === 'mdpi') {
+ hadMdpi = true;
+ }
+ var targetPath = getImageResourcePath(
+ platformResourcesDir, 'drawable', resource.density, 'screen', path.basename(resource.src));
+ resourceMap[targetPath] = resource.src;
+ });
+
+ // There's no "default" drawable, so assume default == mdpi.
+ if (!hadMdpi && resources.defaultResource) {
+ var targetPath = getImageResourcePath(
+ platformResourcesDir, 'drawable', 'mdpi', 'screen', path.basename(resources.defaultResource.src));
+ resourceMap[targetPath] = resources.defaultResource.src;
+ }
+
+ events.emit('verbose', 'Updating splash screens at ' + platformResourcesDir);
+ FileUpdater.updatePaths(
+ resourceMap, { rootDir: cordovaProject.root }, logFileOp);
+}
+
+function cleanSplashes (projectRoot, projectConfig, platformResourcesDir) {
+ var resources = projectConfig.getSplashScreens('android');
+ if (resources.length > 0) {
+ const resourceMap = makeSplashCleanupMap(projectRoot, platformResourcesDir);
+
+ events.emit('verbose', 'Cleaning splash screens at ' + platformResourcesDir);
+
+ // No source paths are specified in the map, so updatePaths() will delete the target files.
+ FileUpdater.updatePaths(
+ resourceMap, { rootDir: projectRoot, all: true }, logFileOp);
+ }
+}
+
+function updateIcons (cordovaProject, platformResourcesDir) {
+ const icons = cordovaProject.projectConfig.getIcons('android');
+
+ // Skip if there are no app defined icons in config.xml
+ if (icons.length === 0) {
+ events.emit('verbose', 'This app does not have launcher icons defined');
+ return;
+ }
+
+ // 1. loop icons determin if there is an error in the setup.
+ // 2. during initial loop, also setup for legacy support.
+ const errorMissingAttributes = [];
+ const errorLegacyIconNeeded = [];
+ let hasAdaptive = false;
+ icons.forEach((icon, key) => {
+ if (
+ (icon.background && !icon.foreground) ||
+ (!icon.background && icon.foreground) ||
+ (!icon.background && !icon.foreground && !icon.src)
+ ) {
+ errorMissingAttributes.push(icon.density ? icon.density : 'size=' + (icon.height || icon.width));
+ }
+
+ if (icon.foreground) {
+ hasAdaptive = true;
+
+ if (
+ !icon.src &&
+ (
+ icon.foreground.startsWith('@color') ||
+ path.extname(path.basename(icon.foreground)) === '.xml'
+ )
+ ) {
+ errorLegacyIconNeeded.push(icon.density ? icon.density : 'size=' + (icon.height || icon.width));
+ } else if (!icon.src) {
+ icons[key].src = icon.foreground;
+ }
+ }
+ });
+
+ const errorMessage = [];
+ if (errorMissingAttributes.length > 0) {
+ errorMessage.push('One of the following attributes are set but missing the other for the density type: ' + errorMissingAttributes.join(', ') + '. Please ensure that all require attributes are defined.');
+ }
+
+ if (errorLegacyIconNeeded.length > 0) {
+ errorMessage.push('For the following icons with the density of: ' + errorLegacyIconNeeded.join(', ') + ', adaptive foreground with a defined color or vector can not be used as a standard fallback icon for older Android devices. To support older Android environments, please provide a value for the src attribute.');
+ }
+
+ if (errorMessage.length > 0) {
+ throw new CordovaError(errorMessage.join(' '));
+ }
+
+ let resourceMap = Object.assign(
+ {},
+ mapImageResources(cordovaProject.root, platformResourcesDir, 'mipmap', 'ic_launcher.png'),
+ mapImageResources(cordovaProject.root, platformResourcesDir, 'mipmap', 'ic_launcher_foreground.png'),
+ mapImageResources(cordovaProject.root, platformResourcesDir, 'mipmap', 'ic_launcher_background.png'),
+ mapImageResources(cordovaProject.root, platformResourcesDir, 'mipmap', 'ic_launcher_foreground.xml'),
+ mapImageResources(cordovaProject.root, platformResourcesDir, 'mipmap', 'ic_launcher_background.xml'),
+ mapImageResources(cordovaProject.root, platformResourcesDir, 'mipmap', 'ic_launcher.xml')
+ );
+
+ const preparedIcons = prepareIcons(icons);
+
+ if (hasAdaptive) {
+ resourceMap = updateIconResourceForAdaptive(preparedIcons, resourceMap, platformResourcesDir);
+ }
+
+ resourceMap = updateIconResourceForLegacy(preparedIcons, resourceMap, platformResourcesDir);
+
+ events.emit('verbose', 'Updating icons at ' + platformResourcesDir);
+ FileUpdater.updatePaths(resourceMap, { rootDir: cordovaProject.root }, logFileOp);
+}
+
+function updateIconResourceForAdaptive (preparedIcons, resourceMap, platformResourcesDir) {
+ const android_icons = preparedIcons.android_icons;
+ const default_icon = preparedIcons.default_icon;
+
+ // The source paths for icons and splashes are relative to
+ // project's config.xml location, so we use it as base path.
+ let background;
+ let foreground;
+ let targetPathBackground;
+ let targetPathForeground;
+
+ for (const density in android_icons) {
+ let backgroundVal = '@mipmap/ic_launcher_background';
+ let foregroundVal = '@mipmap/ic_launcher_foreground';
+
+ background = android_icons[density].background;
+ foreground = android_icons[density].foreground;
+
+ if (!background || !foreground) {
+ // This icon isn't an adaptive icon, so skip it
+ continue;
+ }
+
+ if (background.startsWith('@color')) {
+ // Colors Use Case
+ backgroundVal = background; // Example: @color/background_foobar_1
+ } else if (path.extname(path.basename(background)) === '.xml') {
+ // Vector Use Case
+ targetPathBackground = getAdaptiveImageResourcePath(platformResourcesDir, 'mipmap', density, 'ic_launcher_background.xml', path.basename(android_icons[density].background));
+ resourceMap[targetPathBackground] = android_icons[density].background;
+ } else if (path.extname(path.basename(background)) === '.png') {
+ // Images Use Case
+ targetPathBackground = getAdaptiveImageResourcePath(platformResourcesDir, 'mipmap', density, 'ic_launcher_background.png', path.basename(android_icons[density].background));
+ resourceMap[targetPathBackground] = android_icons[density].background;
+ }
+
+ if (foreground.startsWith('@color')) {
+ // Colors Use Case
+ foregroundVal = foreground;
+ } else if (path.extname(path.basename(foreground)) === '.xml') {
+ // Vector Use Case
+ targetPathForeground = getAdaptiveImageResourcePath(platformResourcesDir, 'mipmap', density, 'ic_launcher_foreground.xml', path.basename(android_icons[density].foreground));
+ resourceMap[targetPathForeground] = android_icons[density].foreground;
+ } else if (path.extname(path.basename(foreground)) === '.png') {
+ // Images Use Case
+ targetPathForeground = getAdaptiveImageResourcePath(platformResourcesDir, 'mipmap', density, 'ic_launcher_foreground.png', path.basename(android_icons[density].foreground));
+ resourceMap[targetPathForeground] = android_icons[density].foreground;
+ }
+
+ // create an XML for DPI and set color
+ const icLauncherTemplate = `
+
+ `;
+
+ const launcherXmlPath = path.join(platformResourcesDir, 'mipmap-' + density + '-v26', 'ic_launcher.xml');
+
+ // Remove the XML from the resourceMap so the file does not get removed.
+ delete resourceMap[launcherXmlPath];
+
+ fs.writeFileSync(path.resolve(launcherXmlPath), icLauncherTemplate);
+ }
+
+ // There's no "default" drawable, so assume default == mdpi.
+ if (default_icon && !android_icons.mdpi) {
+ let defaultTargetPathBackground;
+ let defaultTargetPathForeground;
+
+ if (background.startsWith('@color')) {
+ // Colors Use Case
+ targetPathBackground = default_icon.background;
+ } else if (path.extname(path.basename(background)) === '.xml') {
+ // Vector Use Case
+ defaultTargetPathBackground = getAdaptiveImageResourcePath(platformResourcesDir, 'mipmap', 'mdpi', 'ic_launcher_background.xml', path.basename(default_icon.background));
+ resourceMap[defaultTargetPathBackground] = default_icon.background;
+ } else if (path.extname(path.basename(background)) === '.png') {
+ // Images Use Case
+ defaultTargetPathBackground = getAdaptiveImageResourcePath(platformResourcesDir, 'mipmap', 'mdpi', 'ic_launcher_background.png', path.basename(default_icon.background));
+ resourceMap[defaultTargetPathBackground] = default_icon.background;
+ }
+
+ if (foreground.startsWith('@color')) {
+ // Colors Use Case
+ targetPathForeground = default_icon.foreground;
+ } else if (path.extname(path.basename(foreground)) === '.xml') {
+ // Vector Use Case
+ defaultTargetPathForeground = getAdaptiveImageResourcePath(platformResourcesDir, 'mipmap', 'mdpi', 'ic_launcher_foreground.xml', path.basename(default_icon.foreground));
+ resourceMap[defaultTargetPathForeground] = default_icon.foreground;
+ } else if (path.extname(path.basename(foreground)) === '.png') {
+ // Images Use Case
+ defaultTargetPathForeground = getAdaptiveImageResourcePath(platformResourcesDir, 'mipmap', 'mdpi', 'ic_launcher_foreground.png', path.basename(default_icon.foreground));
+ resourceMap[defaultTargetPathForeground] = default_icon.foreground;
+ }
+ }
+
+ return resourceMap;
+}
+
+function updateIconResourceForLegacy (preparedIcons, resourceMap, platformResourcesDir) {
+ const android_icons = preparedIcons.android_icons;
+ const default_icon = preparedIcons.default_icon;
+
+ // The source paths for icons and splashes are relative to
+ // project's config.xml location, so we use it as base path.
+ for (var density in android_icons) {
+ var targetPath = getImageResourcePath(platformResourcesDir, 'mipmap', density, 'ic_launcher', path.basename(android_icons[density].src));
+ resourceMap[targetPath] = android_icons[density].src;
+ }
+
+ // There's no "default" drawable, so assume default == mdpi.
+ if (default_icon && !android_icons.mdpi) {
+ var defaultTargetPath = getImageResourcePath(platformResourcesDir, 'mipmap', 'mdpi', 'ic_launcher', path.basename(default_icon.src));
+ resourceMap[defaultTargetPath] = default_icon.src;
+ }
+
+ return resourceMap;
+}
+
+function prepareIcons (icons) {
+ // http://developer.android.com/design/style/iconography.html
+ const SIZE_TO_DENSITY_MAP = {
+ 36: 'ldpi',
+ 48: 'mdpi',
+ 72: 'hdpi',
+ 96: 'xhdpi',
+ 144: 'xxhdpi',
+ 192: 'xxxhdpi'
+ };
+
+ const android_icons = {};
+ let default_icon;
+
+ // find the best matching icon for a given density or size
+ // @output android_icons
+ var parseIcon = function (icon, icon_size) {
+ // do I have a platform icon for that density already
+ var density = icon.density || SIZE_TO_DENSITY_MAP[icon_size];
+ if (!density) {
+ // invalid icon defition ( or unsupported size)
+ return;
+ }
+ var previous = android_icons[density];
+ if (previous && previous.platform) {
+ return;
+ }
+ android_icons[density] = icon;
+ };
+
+ // iterate over all icon elements to find the default icon and call parseIcon
+ for (var i = 0; i < icons.length; i++) {
+ var icon = icons[i];
+ var size = icon.width;
+
+ if (!size) {
+ size = icon.height;
+ }
+
+ if (!size && !icon.density) {
+ if (default_icon) {
+ const found = {};
+ const favor = {};
+
+ // populating found icon.
+ if (icon.background && icon.foreground) {
+ found.background = icon.background;
+ found.foreground = icon.foreground;
+ }
+ if (icon.src) {
+ found.src = icon.src;
+ }
+
+ if (default_icon.background && default_icon.foreground) {
+ favor.background = default_icon.background;
+ favor.foreground = default_icon.foreground;
+ }
+ if (default_icon.src) {
+ favor.src = default_icon.src;
+ }
+
+ events.emit('verbose', 'Found extra default icon: ' + JSON.stringify(found) + ' and ignoring in favor of ' + JSON.stringify(favor) + '.');
+ } else {
+ default_icon = icon;
+ }
+ } else {
+ parseIcon(icon, size);
+ }
+ }
+
+ return {
+ android_icons: android_icons,
+ default_icon: default_icon
+ };
+}
+
+function cleanIcons (projectRoot, projectConfig, platformResourcesDir) {
+ var icons = projectConfig.getIcons('android');
+
+ // Skip if there are no app defined icons in config.xml
+ if (icons.length === 0) {
+ events.emit('verbose', 'This app does not have launcher icons defined');
+ return;
+ }
+
+ const resourceMap = Object.assign(
+ {},
+ mapImageResources(projectRoot, platformResourcesDir, 'mipmap', 'ic_launcher.png'),
+ mapImageResources(projectRoot, platformResourcesDir, 'mipmap', 'ic_launcher_foreground.png'),
+ mapImageResources(projectRoot, platformResourcesDir, 'mipmap', 'ic_launcher_background.png'),
+ mapImageResources(projectRoot, platformResourcesDir, 'mipmap', 'ic_launcher_foreground.xml'),
+ mapImageResources(projectRoot, platformResourcesDir, 'mipmap', 'ic_launcher_background.xml'),
+ mapImageResources(projectRoot, platformResourcesDir, 'mipmap', 'ic_launcher.xml')
+ );
+
+ events.emit('verbose', 'Cleaning icons at ' + platformResourcesDir);
+
+ // No source paths are specified in the map, so updatePaths() will delete the target files.
+ FileUpdater.updatePaths(resourceMap, { rootDir: projectRoot, all: true }, logFileOp);
+}
+
+/**
+ * Gets a map containing resources of a specified name from all drawable folders in a directory.
+ */
+function mapImageResources (rootDir, subDir, type, resourceName) {
+ const pathMap = {};
+ const globOptions = { cwd: path.join(rootDir, subDir), onlyDirectories: true };
+ glob.sync(type + '-*', globOptions).forEach(drawableFolder => {
+ const imagePath = path.join(subDir, drawableFolder, resourceName);
+ pathMap[imagePath] = null;
+ });
+ return pathMap;
+}
+
+/** Returns resource map that deletes all given paths */
+function makeCleanResourceMap (resourcePaths) {
+ const pathMap = {};
+ resourcePaths.map(path.normalize)
+ .forEach(resourcePath => {
+ pathMap[resourcePath] = null;
+ });
+ return pathMap;
+}
+
+function updateFileResources (cordovaProject, platformDir) {
+ var files = cordovaProject.projectConfig.getFileResources('android');
+
+ // if there are resource-file elements in config.xml
+ if (files.length === 0) {
+ events.emit('verbose', 'This app does not have additional resource files defined');
+ return;
+ }
+
+ var resourceMap = {};
+ files.forEach(function (res) {
+ var targetPath = path.join(platformDir, res.target);
+ resourceMap[targetPath] = res.src;
+ });
+
+ events.emit('verbose', 'Updating resource files at ' + platformDir);
+ FileUpdater.updatePaths(
+ resourceMap, { rootDir: cordovaProject.root }, logFileOp);
+}
+
+function cleanFileResources (projectRoot, projectConfig, platformDir) {
+ var files = projectConfig.getFileResources('android', true);
+ if (files.length > 0) {
+ events.emit('verbose', 'Cleaning resource files at ' + platformDir);
+
+ var resourceMap = {};
+ files.forEach(function (res) {
+ var filePath = path.join(platformDir, res.target);
+ resourceMap[filePath] = null;
+ });
+
+ FileUpdater.updatePaths(
+ resourceMap, { rootDir: projectRoot, all: true }, logFileOp);
+ }
+}
+
+/**
+ * Gets and validates 'AndroidLaunchMode' prepference from config.xml. Returns
+ * preference value and warns if it doesn't seems to be valid
+ *
+ * @param {ConfigParser} platformConfig A configParser instance for
+ * platform.
+ *
+ * @return {String} Preference's value from config.xml or
+ * default value, if there is no such preference. The default value is
+ * 'singleTop'
+ */
+function findAndroidLaunchModePreference (platformConfig) {
+ var launchMode = platformConfig.getPreference('AndroidLaunchMode');
+ if (!launchMode) {
+ // Return a default value
+ return 'singleTop';
+ }
+
+ var expectedValues = ['standard', 'singleTop', 'singleTask', 'singleInstance'];
+ var valid = expectedValues.indexOf(launchMode) >= 0;
+ if (!valid) {
+ // Note: warn, but leave the launch mode as developer wanted, in case the list of options changes in the future
+ events.emit('warn', 'Unrecognized value for AndroidLaunchMode preference: ' +
+ launchMode + '. Expected values are: ' + expectedValues.join(', '));
+ }
+
+ return launchMode;
+}
diff --git a/node_modules/cordova-android/lib/retry.js b/node_modules/cordova-android/lib/retry.js
new file mode 100644
index 0000000..6806422
--- /dev/null
+++ b/node_modules/cordova-android/lib/retry.js
@@ -0,0 +1,43 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+'use strict';
+
+var events = require('cordova-common').events;
+
+/**
+ * Retry a promise-returning function a number of times, propagating its
+ * results on success or throwing its error on a failed final attempt.
+ *
+ * @arg {Number} attemptsLeft - The number of times to retry the passed call.
+ * @arg {Function} promiseFunction - A function that returns a promise.
+ * @arg {...} - Arguments to pass to promiseFunction.
+ *
+ * @returns {Promise}
+ */
+module.exports.retryPromise = async function (attemptsLeft, promiseFunction, ...args) {
+ while (true) {
+ try {
+ return await promiseFunction(...args);
+ } catch (error) {
+ if (--attemptsLeft < 1) throw error;
+ events.emit('verbose', 'A retried call failed. Retrying ' + attemptsLeft + ' more time(s).');
+ }
+ }
+};
diff --git a/node_modules/cordova-android/lib/run.js b/node_modules/cordova-android/lib/run.js
new file mode 100644
index 0000000..2a4ff94
--- /dev/null
+++ b/node_modules/cordova-android/lib/run.js
@@ -0,0 +1,83 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+var emulator = require('./emulator');
+const target = require('./target');
+const build = require('./build');
+const PackageType = require('./PackageType');
+const AndroidManifest = require('./AndroidManifest');
+const { CordovaError, events } = require('cordova-common');
+
+/**
+ * Builds a target spec from a runOptions object
+ *
+ * @param {{target?: string, device?: boolean, emulator?: boolean}} runOptions
+ * @return {target.TargetSpec}
+ */
+function buildTargetSpec (runOptions) {
+ const spec = {};
+ if (runOptions.target) {
+ spec.id = runOptions.target;
+ } else if (runOptions.device) {
+ spec.type = 'device';
+ } else if (runOptions.emulator) {
+ spec.type = 'emulator';
+ }
+ return spec;
+}
+
+function formatResolvedTarget ({ id, type }) {
+ return `${type} ${id}`;
+}
+
+/**
+ * Runs the application on a device if available. If no device is found, it will
+ * use a started emulator. If no started emulators are found it will attempt
+ * to start an avd. If no avds are found it will error out.
+ *
+ * @param {Object} runOptions various run/build options. See Api.js build/run
+ * methods for reference.
+ *
+ * @return {Promise}
+ */
+module.exports.run = async function (runOptions = {}) {
+ const { packageType, buildType } = build.parseBuildOptions(runOptions, null, this.root);
+
+ // Android app bundles cannot be deployed directly to the device
+ if (packageType === PackageType.BUNDLE) {
+ throw new CordovaError('Package type "bundle" is not supported during cordova run.');
+ }
+
+ const buildResults = this._builder.fetchBuildResults(buildType);
+ if (buildResults.apkPaths.length === 0) {
+ throw new CordovaError('Could not find any APKs to deploy');
+ }
+
+ const targetSpec = buildTargetSpec(runOptions);
+ const resolvedTarget = await target.resolve(targetSpec, buildResults);
+ events.emit('log', `Deploying to ${formatResolvedTarget(resolvedTarget)}`);
+
+ if (resolvedTarget.type === 'emulator') {
+ await emulator.wait_for_boot(resolvedTarget.id);
+ }
+
+ const manifest = new AndroidManifest(this.locations.manifest);
+
+ return target.install(resolvedTarget, { manifest, buildResults });
+};
diff --git a/node_modules/cordova-android/lib/target.js b/node_modules/cordova-android/lib/target.js
new file mode 100644
index 0000000..8c29788
--- /dev/null
+++ b/node_modules/cordova-android/lib/target.js
@@ -0,0 +1,173 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+const { inspect } = require('util');
+const execa = require('execa');
+const Adb = require('./Adb');
+const build = require('./build');
+const emulator = require('./emulator');
+const { compareBy } = require('./utils');
+const { retryPromise } = require('./retry');
+const { events, CordovaError } = require('cordova-common');
+
+const INSTALL_COMMAND_TIMEOUT = 5 * 60 * 1000;
+const NUM_INSTALL_RETRIES = 3;
+const EXEC_KILL_SIGNAL = 'SIGKILL';
+
+/**
+ * @typedef { 'device' | 'emulator' } TargetType
+ * @typedef { { id: string, type: TargetType } } Target
+ * @typedef { { id?: string, type?: TargetType } } TargetSpec
+ * @typedef { { apkPaths: string[] } } BuildResults
+ */
+
+/**
+ * Returns a list of available targets (connected devices & started emulators)
+ *
+ * @return {Promise}
+ */
+exports.list = async () => {
+ return (await Adb.devices())
+ .map(id => ({
+ id,
+ type: id.startsWith('emulator-') ? 'emulator' : 'device'
+ }));
+};
+
+/**
+ * @param {TargetSpec?} spec
+ * @return {Promise}
+ */
+async function resolveToOnlineTarget (spec = {}) {
+ const targetList = await exports.list();
+ if (targetList.length === 0) return null;
+
+ // Sort by type: devices first, then emulators.
+ targetList.sort(compareBy(t => t.type));
+
+ // Find first matching target for spec. {} matches any target.
+ return targetList.find(target =>
+ Object.keys(spec).every(k => spec[k] === target[k])
+ ) || null;
+}
+
+async function isEmulatorName (name) {
+ const emus = await emulator.list_images();
+ return emus.some(avd => avd.name === name);
+}
+
+/**
+ * @param {TargetSpec} spec
+ * @param {BuildResults} buildResults
+ * @return {Promise}
+ */
+async function resolveToOfflineEmulator ({ id: avdName, type }, { apkPaths }) {
+ if (type === 'device') return null;
+
+ if (avdName) {
+ if (!await isEmulatorName(avdName)) return null;
+ } else {
+ events.emit('verbose', 'Looking for emulator image that best matches the target API');
+
+ const targetSdk = await getTargetSdkFromApk(apkPaths[0]);
+ const bestImage = await emulator.best_image(targetSdk);
+ if (!bestImage) return null;
+
+ avdName = bestImage.name;
+ }
+
+ // try to start an emulator with name avdName
+ const emulatorId = await emulator.start(avdName);
+
+ return { id: emulatorId, type: 'emulator' };
+}
+
+async function getTargetSdkFromApk (apkPath) {
+ const { stdout: targetSdkStr } = await execa('apkanalyzer', [
+ 'manifest', 'target-sdk', apkPath
+ ]);
+ return Number(targetSdkStr);
+}
+
+/**
+ * @param {TargetSpec?} spec
+ * @param {BuildResults} buildResults
+ * @return {Promise}
+ */
+exports.resolve = async (spec, buildResults) => {
+ events.emit('verbose', `Trying to find target matching ${inspect(spec)}`);
+
+ const resolvedTarget =
+ (await resolveToOnlineTarget(spec)) ||
+ (await resolveToOfflineEmulator(spec, buildResults));
+
+ if (!resolvedTarget) {
+ throw new CordovaError(`Could not find target matching ${inspect(spec)}`);
+ }
+
+ return {
+ ...resolvedTarget,
+ arch: await build.detectArchitecture(resolvedTarget.id)
+ };
+};
+
+exports.install = async function ({ id: target, arch, type }, { manifest, buildResults }) {
+ const apk_path = build.findBestApkForArchitecture(buildResults, arch);
+ const pkgName = manifest.getPackageId();
+ const launchName = pkgName + '/.' + manifest.getActivity().getName();
+
+ events.emit('log', 'Using apk: ' + apk_path);
+ events.emit('log', 'Package name: ' + pkgName);
+ events.emit('verbose', `Installing app on target ${target}`);
+
+ async function doInstall (execOptions = {}) {
+ try {
+ await Adb.install(target, apk_path, { replace: true, execOptions });
+ } catch (error) {
+ // CB-9557 CB-10157 only uninstall and reinstall app if the one that
+ // is already installed on device was signed w/different certificate
+ if (!/INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES/.test(error.toString())) throw error;
+
+ events.emit('warn', 'Uninstalling app from device and reinstalling it again because the ' +
+ 'installed app already signed with different key');
+
+ // This promise is always resolved, even if 'adb uninstall' fails to uninstall app
+ // or the app doesn't installed at all, so no error catching needed.
+ await Adb.uninstall(target, pkgName);
+ await Adb.install(target, apk_path, { replace: true });
+ }
+ }
+
+ if (type === 'emulator') {
+ // Work around sporadic emulator hangs: http://issues.apache.org/jira/browse/CB-9119
+ await retryPromise(NUM_INSTALL_RETRIES, () => doInstall({
+ timeout: INSTALL_COMMAND_TIMEOUT,
+ killSignal: EXEC_KILL_SIGNAL
+ }));
+ } else {
+ await doInstall();
+ }
+ events.emit('log', 'INSTALL SUCCESS');
+
+ events.emit('verbose', 'Unlocking screen...');
+ await Adb.shell(target, 'input keyevent 82');
+
+ await Adb.start(target, launchName);
+ events.emit('log', 'LAUNCH SUCCESS');
+};
diff --git a/node_modules/cordova-android/lib/utils.js b/node_modules/cordova-android/lib/utils.js
new file mode 100644
index 0000000..28f17d9
--- /dev/null
+++ b/node_modules/cordova-android/lib/utils.js
@@ -0,0 +1,86 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+/*
+ Provides a set of utility methods, which can also be spied on during unit tests.
+*/
+
+// TODO: Perhaps this should live in cordova-common?
+
+const fs = require('fs-extra');
+const which = require('which');
+const os = require('os');
+
+/**
+ * Reads, searches, and replaces the found occurences with replacementString and then writes the file back out.
+ * A backup is not made.
+ *
+ * @param {string} file A file path to a readable & writable file
+ * @param {RegExp} searchRegex The search regex
+ * @param {string} replacementString The string to replace the found occurences
+ * @returns void
+ */
+exports.replaceFileContents = function (file, searchRegex, replacementString) {
+ let contents = fs.readFileSync(file).toString();
+ contents = contents.replace(searchRegex, replacementString);
+ fs.writeFileSync(file, contents);
+};
+
+// Some helpers for easier sorting
+exports.compare = (a, b) => (a < b && -1) || +(a > b);
+exports.compareBy = f => (a, b) => exports.compare(f(a), f(b));
+exports.compareByAll = fns => {
+ const comparators = fns.map(exports.compareBy);
+ return (a, b) => {
+ for (const cmp of comparators) {
+ const result = cmp(a, b);
+ if (result) return result;
+ }
+ return 0;
+ };
+};
+
+exports.forgivingWhichSync = (cmd) => {
+ const whichResult = which.sync(cmd, { nothrow: true });
+
+ // On null, returns empty string to maintain backwards compatibility
+ // realpathSync follows symlinks
+ return whichResult === null ? '' : fs.realpathSync(whichResult);
+};
+
+exports.isWindows = () => os.platform() === 'win32';
+exports.isDarwin = () => os.platform() === 'darwin';
+
+const UNESCAPED_REGEX = /[&<>"']/g;
+
+const escapes = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": '''
+};
+
+/**
+ * Converts the characters "&", "<", ">", '"' and "'" in the given string to
+ * their corresponding escaped value
+ * @param {string} str the string to be escaped
+ * @returns the escaped string
+ */
+exports.escape = (str) => UNESCAPED_REGEX.test(str) ? str.replace(UNESCAPED_REGEX, (key) => escapes[key]) : str;
diff --git a/node_modules/cordova-android/package.json b/node_modules/cordova-android/package.json
new file mode 100644
index 0000000..384eb98
--- /dev/null
+++ b/node_modules/cordova-android/package.json
@@ -0,0 +1,58 @@
+{
+ "name": "cordova-android",
+ "version": "10.1.2",
+ "description": "cordova-android release",
+ "main": "lib/Api.js",
+ "repository": "github:apache/cordova-android",
+ "bugs": "https://github.com/apache/cordova-android/issues",
+ "keywords": [
+ "android",
+ "cordova",
+ "apache"
+ ],
+ "scripts": {
+ "prepare": "cordova-js build > templates/project/assets/www/cordova.js",
+ "test": "npm run lint && npm run cover && npm run java-unit-tests",
+ "lint": "eslint lib spec test \"templates/cordova/**/!(*.*)\"",
+ "unit-tests": "jasmine --config=spec/unit/jasmine.json",
+ "cover": "nyc jasmine --config=spec/coverage.json",
+ "e2e-tests": "jasmine --config=spec/e2e/jasmine.json",
+ "java-unit-tests": "node test/run_java_unit_tests.js",
+ "clean:java-unit-tests": "node test/clean.js"
+ },
+ "author": "Apache Software Foundation",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "android-versions": "^1.7.0",
+ "cordova-common": "^4.0.2",
+ "execa": "^5.1.1",
+ "fast-glob": "^3.2.7",
+ "fs-extra": "^10.0.0",
+ "is-path-inside": "^3.0.3",
+ "nopt": "^5.0.0",
+ "properties-parser": "^0.3.1",
+ "semver": "^7.3.5",
+ "untildify": "^4.0.0",
+ "which": "^2.0.2"
+ },
+ "devDependencies": {
+ "@cordova/eslint-config": "^3.0.0",
+ "cordova-js": "^6.1.0",
+ "jasmine": "^3.8.0",
+ "jasmine-spec-reporter": "^7.0.0",
+ "nyc": "^15.1.0",
+ "rewire": "^5.0.0"
+ },
+ "engines": {
+ "node": ">=12.0.0"
+ },
+ "nyc": {
+ "include": [
+ "lib"
+ ],
+ "reporter": [
+ "lcov",
+ "text"
+ ]
+ }
+}
diff --git a/node_modules/cordova-android/templates/cordova/Api.js b/node_modules/cordova-android/templates/cordova/Api.js
new file mode 100644
index 0000000..de29478
--- /dev/null
+++ b/node_modules/cordova-android/templates/cordova/Api.js
@@ -0,0 +1,20 @@
+/**
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+module.exports = require('cordova-android');
diff --git a/node_modules/cordova-android/templates/cordova/android_sdk_version b/node_modules/cordova-android/templates/cordova/android_sdk_version
new file mode 100644
index 0000000..5ef0238
--- /dev/null
+++ b/node_modules/cordova-android/templates/cordova/android_sdk_version
@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+var android_sdk = require('cordova-android/lib/android_sdk');
+
+android_sdk.print_newest_available_sdk_target().catch(err => {
+ console.error(err);
+ process.exit(2);
+});
diff --git a/node_modules/cordova-android/templates/cordova/defaults.xml b/node_modules/cordova-android/templates/cordova/defaults.xml
new file mode 100644
index 0000000..5286ab9
--- /dev/null
+++ b/node_modules/cordova-android/templates/cordova/defaults.xml
@@ -0,0 +1,26 @@
+
+
+
+
+
+
diff --git a/node_modules/cordova-android/templates/cordova/lib/list-devices b/node_modules/cordova-android/templates/cordova/lib/list-devices
new file mode 100644
index 0000000..9aa7d99
--- /dev/null
+++ b/node_modules/cordova-android/templates/cordova/lib/list-devices
@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+const { list } = require('cordova-android/lib/target');
+
+// Usage support for when args are given
+require('cordova-android/lib/check_reqs').check_android().then(function () {
+ list().then(targets => {
+ const deviceIds = targets
+ .filter(({ type }) => type === 'device')
+ .map(({ id }) => id);
+
+ console.log(deviceIds.join('\n'));
+ }, function (err) {
+ console.error('ERROR: ' + err);
+ process.exit(2);
+ });
+});
diff --git a/node_modules/cordova-android/templates/cordova/lib/list-emulator-images b/node_modules/cordova-android/templates/cordova/lib/list-emulator-images
new file mode 100644
index 0000000..4351b68
--- /dev/null
+++ b/node_modules/cordova-android/templates/cordova/lib/list-emulator-images
@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+var emulators = require('cordova-android/lib/emulator');
+
+// Usage support for when args are given
+require('cordova-android/lib/check_reqs').check_android().then(function () {
+ emulators.list_images().then(function (emulator_list) {
+ emulator_list && emulator_list.forEach(function (emu) {
+ console.log(emu.name);
+ });
+ }, function (err) {
+ console.error('ERROR: ' + err);
+ process.exit(2);
+ });
+});
diff --git a/node_modules/cordova-android/templates/cordova/version b/node_modules/cordova-android/templates/cordova/version
new file mode 100644
index 0000000..00f44bb
--- /dev/null
+++ b/node_modules/cordova-android/templates/cordova/version
@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+const Api = require('./Api');
+
+console.log(Api.version());
diff --git a/node_modules/cordova-android/templates/project/Activity.java b/node_modules/cordova-android/templates/project/Activity.java
new file mode 100644
index 0000000..567b6c7
--- /dev/null
+++ b/node_modules/cordova-android/templates/project/Activity.java
@@ -0,0 +1,41 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+ */
+
+package __ID__;
+
+import android.os.Bundle;
+import org.apache.cordova.*;
+
+public class __ACTIVITY__ extends CordovaActivity
+{
+ @Override
+ public void onCreate(Bundle savedInstanceState)
+ {
+ super.onCreate(savedInstanceState);
+
+ // enable Cordova apps to be started in the background
+ Bundle extras = getIntent().getExtras();
+ if (extras != null && extras.getBoolean("cdvStartInBackground", false)) {
+ moveTaskToBack(true);
+ }
+
+ // Set by
+
+
+
+
+
+
+
diff --git a/node_modules/cordova-android/templates/project/app/build.gradle b/node_modules/cordova-android/templates/project/app/build.gradle
new file mode 100644
index 0000000..08959e0
--- /dev/null
+++ b/node_modules/cordova-android/templates/project/app/build.gradle
@@ -0,0 +1,343 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+apply plugin: 'com.android.application'
+
+if (cordovaConfig.IS_GRADLE_PLUGIN_KOTLIN_ENABLED) {
+ apply plugin: 'kotlin-android'
+ apply plugin: 'kotlin-android-extensions'
+}
+
+buildscript {
+ apply from: '../CordovaLib/cordova.gradle'
+
+ // Checks if the kotlin version format is valid.
+ if(cordovaConfig.IS_GRADLE_PLUGIN_KOTLIN_ENABLED) {
+ if(!cdvHelpers.isVersionValid(cordovaConfig.KOTLIN_VERSION)) {
+ throw new GradleException("The defined Kotlin version (${cordovaConfig.KOTLIN_VERSION}) does not appear to be a valid version.")
+ }
+ }
+
+ apply from: 'repositories.gradle'
+ repositories repos
+
+ dependencies {
+ classpath "com.android.tools.build:gradle:${cordovaConfig.AGP_VERSION}"
+
+ if (cordovaConfig.IS_GRADLE_PLUGIN_KOTLIN_ENABLED) {
+ classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${cordovaConfig.KOTLIN_VERSION}"
+ }
+
+ if(cordovaConfig.IS_GRADLE_PLUGIN_GOOGLE_SERVICES_ENABLED) {
+ // Checks if the kotlin version format is valid.
+ if(!cdvHelpers.isVersionValid(cordovaConfig.GRADLE_PLUGIN_GOOGLE_SERVICES_VERSION)) {
+ throw new GradleException("The defined Google Services plugin version (${cordovaConfig.GRADLE_PLUGIN_GOOGLE_SERVICES_VERSION}) does not appear to be a valid version.")
+ }
+
+ // Create the Google Services classpath and set it.
+ String gradlePluginGoogleServicesClassPath = "com.google.gms:google-services:${cordovaConfig.GRADLE_PLUGIN_GOOGLE_SERVICES_VERSION}"
+ println "Adding classpath: ${gradlePluginGoogleServicesClassPath}"
+ classpath gradlePluginGoogleServicesClassPath
+ }
+ }
+}
+
+// Allow plugins to declare Maven dependencies via build-extras.gradle.
+allprojects {
+ def hasRepositoriesGradle = file('repositories.gradle').exists()
+ if (hasRepositoriesGradle) {
+ apply from: 'repositories.gradle'
+ } else {
+ apply from: "${project.rootDir}/repositories.gradle"
+ }
+
+ repositories repos
+}
+
+task wrapper(type: Wrapper) {
+ gradleVersion = cordovaConfig.GRADLE_VERSION
+}
+
+// Configuration properties. Set these via environment variables, build-extras.gradle, or gradle.properties.
+// Refer to: http://www.gradle.org/docs/current/userguide/tutorial_this_and_that.html
+ext {
+ apply from: '../CordovaLib/cordova.gradle'
+
+ // Sets the versionCode to the given value.
+ if (!project.hasProperty('cdvVersionCode')) {
+ cdvVersionCode = null
+ }
+ // Whether to build architecture-specific APKs.
+ if (!project.hasProperty('cdvBuildMultipleApks')) {
+ cdvBuildMultipleApks = null
+ }
+ // Whether to append a 0 "abi digit" to versionCode when only a single APK is build
+ if (!project.hasProperty('cdvVersionCodeForceAbiDigit')) {
+ cdvVersionCodeForceAbiDigit = null
+ }
+ // .properties files to use for release signing.
+ if (!project.hasProperty('cdvReleaseSigningPropertiesFile')) {
+ cdvReleaseSigningPropertiesFile = null
+ }
+ // .properties files to use for debug signing.
+ if (!project.hasProperty('cdvDebugSigningPropertiesFile')) {
+ cdvDebugSigningPropertiesFile = null
+ }
+ // Set by build.js script.
+ if (!project.hasProperty('cdvBuildArch')) {
+ cdvBuildArch = null
+ }
+
+ // Plugin gradle extensions can append to this to have code run at the end.
+ cdvPluginPostBuildExtras = []
+}
+
+// PLUGIN GRADLE EXTENSIONS START
+// PLUGIN GRADLE EXTENSIONS END
+
+def hasBuildExtras1 = file('build-extras.gradle').exists()
+if (hasBuildExtras1) {
+ apply from: 'build-extras.gradle'
+}
+
+def hasBuildExtras2 = file('../build-extras.gradle').exists()
+if (hasBuildExtras2) {
+ apply from: '../build-extras.gradle'
+}
+
+// Apply updates that might come from build-extra.
+privateHelpers.applyCordovaConfigCustomization()
+
+// Set property defaults after extension .gradle files.
+if (ext.cdvDebugSigningPropertiesFile == null && file('../debug-signing.properties').exists()) {
+ ext.cdvDebugSigningPropertiesFile = '../debug-signing.properties'
+}
+if (ext.cdvReleaseSigningPropertiesFile == null && file('../release-signing.properties').exists()) {
+ ext.cdvReleaseSigningPropertiesFile = '../release-signing.properties'
+}
+
+// Cast to appropriate types.
+ext.cdvBuildMultipleApks = cdvBuildMultipleApks == null ? false : cdvBuildMultipleApks.toBoolean();
+ext.cdvVersionCodeForceAbiDigit = cdvVersionCodeForceAbiDigit == null ? false : cdvVersionCodeForceAbiDigit.toBoolean();
+ext.cdvVersionCode = cdvVersionCode == null ? null : Integer.parseInt('' + cdvVersionCode)
+
+def computeBuildTargetName(debugBuild) {
+ def ret = 'assemble'
+ if (cdvBuildMultipleApks && cdvBuildArch) {
+ def arch = cdvBuildArch == 'arm' ? 'armv7' : cdvBuildArch
+ ret += '' + arch.toUpperCase().charAt(0) + arch.substring(1);
+ }
+ return ret + (debugBuild ? 'Debug' : 'Release')
+}
+
+// Make cdvBuild a task that depends on the debug/arch-sepecific task.
+task cdvBuildDebug
+cdvBuildDebug.dependsOn {
+ return computeBuildTargetName(true)
+}
+
+task cdvBuildRelease
+cdvBuildRelease.dependsOn {
+ return computeBuildTargetName(false)
+}
+
+task cdvPrintProps {
+ doLast {
+ println('cdvBuildToolsVersion=' + cdvBuildToolsVersion)
+ println('cdvVersionCode=' + cdvVersionCode)
+ println('cdvVersionCodeForceAbiDigit=' + cdvVersionCodeForceAbiDigit)
+ println('cdvSdkVersion=' + cdvSdkVersion)
+ println('cdvMinSdkVersion=' + cdvMinSdkVersion)
+ println('cdvMaxSdkVersion=' + cdvMaxSdkVersion)
+ println('cdvBuildMultipleApks=' + cdvBuildMultipleApks)
+ println('cdvReleaseSigningPropertiesFile=' + cdvReleaseSigningPropertiesFile)
+ println('cdvDebugSigningPropertiesFile=' + cdvDebugSigningPropertiesFile)
+ println('cdvBuildArch=' + cdvBuildArch)
+ println('computedVersionCode=' + android.defaultConfig.versionCode)
+ println('cdvAndroidXAppCompatVersion=' + cdvAndroidXAppCompatVersion)
+ println('cdvAndroidXWebKitVersion=' + cdvAndroidXWebKitVersion)
+ android.productFlavors.each { flavor ->
+ println('computed' + flavor.name.capitalize() + 'VersionCode=' + flavor.versionCode)
+ }
+ }
+}
+
+android {
+ defaultConfig {
+ versionCode cdvVersionCode ?: new BigInteger("" + privateHelpers.extractIntFromManifest("versionCode"))
+ applicationId privateHelpers.extractStringFromManifest("package")
+
+ minSdkVersion cordovaConfig.MIN_SDK_VERSION
+ if (cordovaConfig.MAX_SDK_VERSION != null) {
+ maxSdkVersion cordovaConfig.MAX_SDK_VERSION
+ }
+ targetSdkVersion cordovaConfig.SDK_VERSION
+ compileSdkVersion cordovaConfig.SDK_VERSION
+ }
+
+ lintOptions {
+ abortOnError false
+ }
+
+ buildToolsVersion cordovaConfig.BUILD_TOOLS_VERSION
+
+ // This code exists for Crosswalk and other Native APIs.
+ // By default, we multiply the existing version code in the
+ // Android Manifest by 10 and add a number for each architecture.
+ // If you are not using Crosswalk or SQLite, you can
+ // ignore this chunk of code, and your version codes will be respected.
+
+ if (Boolean.valueOf(cdvBuildMultipleApks)) {
+ flavorDimensions "default"
+
+ productFlavors {
+ armeabi {
+ versionCode defaultConfig.versionCode*10 + 1
+ ndk {
+ abiFilters = ["armeabi"]
+ }
+ }
+ armv7 {
+ versionCode defaultConfig.versionCode*10 + 2
+ ndk {
+ abiFilters = ["armeabi-v7a"]
+ }
+ }
+ arm64 {
+ versionCode defaultConfig.versionCode*10 + 3
+ ndk {
+ abiFilters = ["arm64-v8a"]
+ }
+ }
+ x86 {
+ versionCode defaultConfig.versionCode*10 + 4
+ ndk {
+ abiFilters = ["x86"]
+ }
+ }
+ x86_64 {
+ versionCode defaultConfig.versionCode*10 + 5
+ ndk {
+ abiFilters = ["x86_64"]
+ }
+ }
+ }
+ } else if (Boolean.valueOf(cdvVersionCodeForceAbiDigit)) {
+ // This provides compatibility to the default logic for versionCode before cordova-android 5.2.0
+ defaultConfig {
+ versionCode defaultConfig.versionCode*10
+ }
+ }
+
+ compileOptions {
+ sourceCompatibility JavaVersion.VERSION_1_8
+ targetCompatibility JavaVersion.VERSION_1_8
+ }
+
+ if (cdvReleaseSigningPropertiesFile) {
+ signingConfigs {
+ release {
+ // These must be set or Gradle will complain (even if they are overridden).
+ keyAlias = ""
+ keyPassword = ""
+ storeFile = null
+ storePassword = ""
+ }
+ }
+ buildTypes {
+ release {
+ signingConfig signingConfigs.release
+ }
+ }
+ addSigningProps(cdvReleaseSigningPropertiesFile, signingConfigs.release)
+ }
+
+ if (cdvDebugSigningPropertiesFile) {
+ addSigningProps(cdvDebugSigningPropertiesFile, signingConfigs.debug)
+ }
+
+ sourceSets {
+ main.java.srcDirs += 'src/main/kotlin'
+ }
+}
+
+/*
+ * WARNING: Cordova Lib and platform scripts do management inside of this code here,
+ * if you are adding the dependencies manually, do so outside the comments, otherwise
+ * the Cordova tools will overwrite them
+ */
+
+
+dependencies {
+ implementation fileTree(dir: 'libs', include: '*.jar')
+ implementation "androidx.appcompat:appcompat:${cordovaConfig.ANDROIDX_APP_COMPAT_VERSION}"
+
+ if (cordovaConfig.IS_GRADLE_PLUGIN_KOTLIN_ENABLED) {
+ implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${cordovaConfig.KOTLIN_VERSION}"
+ }
+
+ // SUB-PROJECT DEPENDENCIES START
+ debugCompile(project(path: ":CordovaLib", configuration: "debug"))
+ releaseCompile(project(path: ":CordovaLib", configuration: "release"))
+ // SUB-PROJECT DEPENDENCIES END
+}
+
+def addSigningProps(propsFilePath, signingConfig) {
+ def propsFile = file(propsFilePath)
+ def props = new Properties()
+ propsFile.withReader { reader ->
+ props.load(reader)
+ }
+
+ def storeFile = new File(props.get('key.store') ?: privateHelpers.ensureValueExists(propsFilePath, props, 'storeFile'))
+ if (!storeFile.isAbsolute()) {
+ storeFile = RelativePath.parse(true, storeFile.toString()).getFile(propsFile.getParentFile())
+ }
+ if (!storeFile.exists()) {
+ throw new FileNotFoundException('Keystore file does not exist: ' + storeFile.getAbsolutePath())
+ }
+ signingConfig.keyAlias = props.get('key.alias') ?: privateHelpers.ensureValueExists(propsFilePath, props, 'keyAlias')
+ signingConfig.keyPassword = props.get('keyPassword', props.get('key.alias.password', signingConfig.keyPassword))
+ signingConfig.storeFile = storeFile
+ signingConfig.storePassword = props.get('storePassword', props.get('key.store.password', signingConfig.storePassword))
+ def storeType = props.get('storeType', props.get('key.store.type', ''))
+ if (!storeType) {
+ def filename = storeFile.getName().toLowerCase()
+ if (filename.endsWith('.p12') || filename.endsWith('.pfx')) {
+ storeType = 'pkcs12'
+ } else {
+ storeType = signingConfig.storeType // "jks"
+ }
+ }
+ signingConfig.storeType = storeType
+}
+
+for (def func : cdvPluginPostBuildExtras) {
+ func()
+}
+
+// This can be defined within build-extras.gradle as:
+// ext.postBuildExtras = { ... code here ... }
+if (hasProperty('postBuildExtras')) {
+ postBuildExtras()
+}
+
+if (cordovaConfig.IS_GRADLE_PLUGIN_GOOGLE_SERVICES_ENABLED) {
+ apply plugin: 'com.google.gms.google-services'
+}
diff --git a/node_modules/cordova-android/templates/project/app/repositories.gradle b/node_modules/cordova-android/templates/project/app/repositories.gradle
new file mode 100644
index 0000000..01e73fd
--- /dev/null
+++ b/node_modules/cordova-android/templates/project/app/repositories.gradle
@@ -0,0 +1,22 @@
+/* Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+ext.repos = {
+ google()
+ mavenCentral()
+}
diff --git a/node_modules/cordova-android/templates/project/assets/www/cordova.js b/node_modules/cordova-android/templates/project/assets/www/cordova.js
new file mode 100644
index 0000000..f4c4c9f
--- /dev/null
+++ b/node_modules/cordova-android/templates/project/assets/www/cordova.js
@@ -0,0 +1,1904 @@
+// Platform: cordova-android
+// cordova-js 6.1.0
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+;(function() {
+var PLATFORM_VERSION_BUILD_LABEL = '10.1.2';
+// file: src/scripts/require.js
+var require;
+var define;
+
+(function () {
+ var modules = {};
+ // Stack of moduleIds currently being built.
+ var requireStack = [];
+ // Map of module ID -> index into requireStack of modules currently being built.
+ var inProgressModules = {};
+ var SEPARATOR = '.';
+
+ function build (module) {
+ var factory = module.factory;
+ var localRequire = function (id) {
+ var resultantId = id;
+ // Its a relative path, so lop off the last portion and add the id (minus "./")
+ if (id.charAt(0) === '.') {
+ resultantId = module.id.slice(0, module.id.lastIndexOf(SEPARATOR)) + SEPARATOR + id.slice(2);
+ }
+ return require(resultantId);
+ };
+ module.exports = {};
+ delete module.factory;
+ factory(localRequire, module.exports, module);
+ return module.exports;
+ }
+
+ require = function (id) {
+ if (!modules[id]) {
+ throw new Error('module ' + id + ' not found');
+ } else if (id in inProgressModules) {
+ var cycle = requireStack.slice(inProgressModules[id]).join('->') + '->' + id;
+ throw new Error('Cycle in require graph: ' + cycle);
+ }
+ if (modules[id].factory) {
+ try {
+ inProgressModules[id] = requireStack.length;
+ requireStack.push(id);
+ return build(modules[id]);
+ } finally {
+ delete inProgressModules[id];
+ requireStack.pop();
+ }
+ }
+ return modules[id].exports;
+ };
+
+ define = function (id, factory) {
+ if (Object.prototype.hasOwnProperty.call(modules, id)) {
+ throw new Error('module ' + id + ' already defined');
+ }
+
+ modules[id] = {
+ id: id,
+ factory: factory
+ };
+ };
+
+ define.remove = function (id) {
+ delete modules[id];
+ };
+
+ define.moduleMap = modules;
+})();
+
+// Export for use in node
+if (typeof module === 'object' && typeof require === 'function') {
+ module.exports.require = require;
+ module.exports.define = define;
+}
+
+// file: src/cordova.js
+define("cordova", function(require, exports, module) {
+
+// Workaround for Windows 10 in hosted environment case
+// http://www.w3.org/html/wg/drafts/html/master/browsers.html#named-access-on-the-window-object
+if (window.cordova && !(window.cordova instanceof HTMLElement)) {
+ throw new Error('cordova already defined');
+}
+
+var channel = require('cordova/channel');
+var platform = require('cordova/platform');
+
+/**
+ * Intercept calls to addEventListener + removeEventListener and handle deviceready,
+ * resume, and pause events.
+ */
+var m_document_addEventListener = document.addEventListener;
+var m_document_removeEventListener = document.removeEventListener;
+var m_window_addEventListener = window.addEventListener;
+var m_window_removeEventListener = window.removeEventListener;
+
+/**
+ * Houses custom event handlers to intercept on document + window event listeners.
+ */
+var documentEventHandlers = {};
+var windowEventHandlers = {};
+
+document.addEventListener = function (evt, handler, capture) {
+ var e = evt.toLowerCase();
+ if (typeof documentEventHandlers[e] !== 'undefined') {
+ documentEventHandlers[e].subscribe(handler);
+ } else {
+ m_document_addEventListener.call(document, evt, handler, capture);
+ }
+};
+
+window.addEventListener = function (evt, handler, capture) {
+ var e = evt.toLowerCase();
+ if (typeof windowEventHandlers[e] !== 'undefined') {
+ windowEventHandlers[e].subscribe(handler);
+ } else {
+ m_window_addEventListener.call(window, evt, handler, capture);
+ }
+};
+
+document.removeEventListener = function (evt, handler, capture) {
+ var e = evt.toLowerCase();
+ // If unsubscribing from an event that is handled by a plugin
+ if (typeof documentEventHandlers[e] !== 'undefined') {
+ documentEventHandlers[e].unsubscribe(handler);
+ } else {
+ m_document_removeEventListener.call(document, evt, handler, capture);
+ }
+};
+
+window.removeEventListener = function (evt, handler, capture) {
+ var e = evt.toLowerCase();
+ // If unsubscribing from an event that is handled by a plugin
+ if (typeof windowEventHandlers[e] !== 'undefined') {
+ windowEventHandlers[e].unsubscribe(handler);
+ } else {
+ m_window_removeEventListener.call(window, evt, handler, capture);
+ }
+};
+
+function createEvent (type, data) {
+ var event = document.createEvent('Events');
+ event.initEvent(type, false, false);
+ if (data) {
+ for (var i in data) {
+ if (Object.prototype.hasOwnProperty.call(data, i)) {
+ event[i] = data[i];
+ }
+ }
+ }
+ return event;
+}
+
+var cordova = {
+ define: define,
+ require: require,
+ version: PLATFORM_VERSION_BUILD_LABEL,
+ platformVersion: PLATFORM_VERSION_BUILD_LABEL,
+ platformId: platform.id,
+
+ /**
+ * Methods to add/remove your own addEventListener hijacking on document + window.
+ */
+ addWindowEventHandler: function (event) {
+ return (windowEventHandlers[event] = channel.create(event));
+ },
+ addStickyDocumentEventHandler: function (event) {
+ return (documentEventHandlers[event] = channel.createSticky(event));
+ },
+ addDocumentEventHandler: function (event) {
+ return (documentEventHandlers[event] = channel.create(event));
+ },
+ removeWindowEventHandler: function (event) {
+ delete windowEventHandlers[event];
+ },
+ removeDocumentEventHandler: function (event) {
+ delete documentEventHandlers[event];
+ },
+
+ /**
+ * Retrieve original event handlers that were replaced by Cordova
+ *
+ * @return object
+ */
+ getOriginalHandlers: function () {
+ return {
+ document: {
+ addEventListener: m_document_addEventListener,
+ removeEventListener: m_document_removeEventListener
+ },
+ window: {
+ addEventListener: m_window_addEventListener,
+ removeEventListener: m_window_removeEventListener
+ }
+ };
+ },
+
+ /**
+ * Method to fire event from native code
+ * bNoDetach is required for events which cause an exception which needs to be caught in native code
+ */
+ fireDocumentEvent: function (type, data, bNoDetach) {
+ var evt = createEvent(type, data);
+ if (typeof documentEventHandlers[type] !== 'undefined') {
+ if (bNoDetach) {
+ documentEventHandlers[type].fire(evt);
+ } else {
+ setTimeout(function () {
+ // Fire deviceready on listeners that were registered before cordova.js was loaded.
+ if (type === 'deviceready') {
+ document.dispatchEvent(evt);
+ }
+ documentEventHandlers[type].fire(evt);
+ }, 0);
+ }
+ } else {
+ document.dispatchEvent(evt);
+ }
+ },
+
+ fireWindowEvent: function (type, data) {
+ var evt = createEvent(type, data);
+ if (typeof windowEventHandlers[type] !== 'undefined') {
+ setTimeout(function () {
+ windowEventHandlers[type].fire(evt);
+ }, 0);
+ } else {
+ window.dispatchEvent(evt);
+ }
+ },
+
+ /**
+ * Plugin callback mechanism.
+ */
+ // Randomize the starting callbackId to avoid collisions after refreshing or navigating.
+ // This way, it's very unlikely that any new callback would get the same callbackId as an old callback.
+ callbackId: Math.floor(Math.random() * 2000000000),
+ callbacks: {},
+ callbackStatus: {
+ NO_RESULT: 0,
+ OK: 1,
+ CLASS_NOT_FOUND_EXCEPTION: 2,
+ ILLEGAL_ACCESS_EXCEPTION: 3,
+ INSTANTIATION_EXCEPTION: 4,
+ MALFORMED_URL_EXCEPTION: 5,
+ IO_EXCEPTION: 6,
+ INVALID_ACTION: 7,
+ JSON_EXCEPTION: 8,
+ ERROR: 9
+ },
+
+ /**
+ * Called by native code when returning successful result from an action.
+ */
+ callbackSuccess: function (callbackId, args) {
+ cordova.callbackFromNative(callbackId, true, args.status, [args.message], args.keepCallback);
+ },
+
+ /**
+ * Called by native code when returning error result from an action.
+ */
+ callbackError: function (callbackId, args) {
+ // TODO: Deprecate callbackSuccess and callbackError in favour of callbackFromNative.
+ // Derive success from status.
+ cordova.callbackFromNative(callbackId, false, args.status, [args.message], args.keepCallback);
+ },
+
+ /**
+ * Called by native code when returning the result from an action.
+ */
+ callbackFromNative: function (callbackId, isSuccess, status, args, keepCallback) {
+ try {
+ var callback = cordova.callbacks[callbackId];
+ if (callback) {
+ if (isSuccess && status === cordova.callbackStatus.OK) {
+ callback.success && callback.success.apply(null, args);
+ } else if (!isSuccess) {
+ callback.fail && callback.fail.apply(null, args);
+ }
+ /*
+ else
+ Note, this case is intentionally not caught.
+ this can happen if isSuccess is true, but callbackStatus is NO_RESULT
+ which is used to remove a callback from the list without calling the callbacks
+ typically keepCallback is false in this case
+ */
+ // Clear callback if not expecting any more results
+ if (!keepCallback) {
+ delete cordova.callbacks[callbackId];
+ }
+ }
+ } catch (err) {
+ var msg = 'Error in ' + (isSuccess ? 'Success' : 'Error') + ' callbackId: ' + callbackId + ' : ' + err;
+ cordova.fireWindowEvent('cordovacallbackerror', { message: msg, error: err });
+ throw err;
+ }
+ },
+
+ addConstructor: function (func) {
+ channel.onCordovaReady.subscribe(function () {
+ try {
+ func();
+ } catch (e) {
+ console.log('Failed to run constructor: ' + e);
+ }
+ });
+ }
+};
+
+module.exports = cordova;
+
+});
+
+// file: ../../cordova-js-src/android/nativeapiprovider.js
+define("cordova/android/nativeapiprovider", function(require, exports, module) {
+
+/**
+ * Exports the ExposedJsApi.java object if available, otherwise exports the PromptBasedNativeApi.
+ */
+
+var nativeApi = this._cordovaNative || require('cordova/android/promptbasednativeapi');
+var currentApi = nativeApi;
+
+module.exports = {
+ get: function () { return currentApi; },
+ setPreferPrompt: function (value) {
+ currentApi = value ? require('cordova/android/promptbasednativeapi') : nativeApi;
+ },
+ // Used only by tests.
+ set: function (value) {
+ currentApi = value;
+ }
+};
+
+});
+
+// file: ../../cordova-js-src/android/promptbasednativeapi.js
+define("cordova/android/promptbasednativeapi", function(require, exports, module) {
+
+/**
+ * Implements the API of ExposedJsApi.java, but uses prompt() to communicate.
+ * This is used pre-JellyBean, where addJavascriptInterface() is disabled.
+ */
+
+module.exports = {
+ exec: function (bridgeSecret, service, action, callbackId, argsJson) {
+ return prompt(argsJson, 'gap:' + JSON.stringify([bridgeSecret, service, action, callbackId]));
+ },
+ setNativeToJsBridgeMode: function (bridgeSecret, value) {
+ prompt(value, 'gap_bridge_mode:' + bridgeSecret);
+ },
+ retrieveJsMessages: function (bridgeSecret, fromOnlineEvent) {
+ return prompt(+fromOnlineEvent, 'gap_poll:' + bridgeSecret);
+ }
+};
+
+});
+
+// file: src/common/argscheck.js
+define("cordova/argscheck", function(require, exports, module) {
+
+var utils = require('cordova/utils');
+
+var moduleExports = module.exports;
+
+var typeMap = {
+ A: 'Array',
+ D: 'Date',
+ N: 'Number',
+ S: 'String',
+ F: 'Function',
+ O: 'Object'
+};
+
+function extractParamName (callee, argIndex) {
+ return (/\(\s*([^)]*?)\s*\)/).exec(callee)[1].split(/\s*,\s*/)[argIndex];
+}
+
+/**
+ * Checks the given arguments' types and throws if they are not as expected.
+ *
+ * `spec` is a string where each character stands for the required type of the
+ * argument at the same position. In other words: the character at `spec[i]`
+ * specifies the required type for `args[i]`. The characters in `spec` are the
+ * first letter of the required type's name. The supported types are:
+ *
+ * Array, Date, Number, String, Function, Object
+ *
+ * Lowercase characters specify arguments that must not be `null` or `undefined`
+ * while uppercase characters allow those values to be passed.
+ *
+ * Finally, `*` can be used to allow any type at the corresponding position.
+ *
+ * @example
+ * function foo (arr, opts) {
+ * // require `arr` to be an Array and `opts` an Object, null or undefined
+ * checkArgs('aO', 'my.package.foo', arguments);
+ * // ...
+ * }
+ * @param {String} spec - the type specification for `args` as described above
+ * @param {String} functionName - full name of the callee.
+ * Used in the error message
+ * @param {Array|arguments} args - the arguments to be checked against `spec`
+ * @param {Function} [opt_callee=args.callee] - the recipient of `args`.
+ * Used to extract parameter names for the error message
+ * @throws {TypeError} if args do not satisfy spec
+ */
+function checkArgs (spec, functionName, args, opt_callee) {
+ if (!moduleExports.enableChecks) {
+ return;
+ }
+ var errMsg = null;
+ var typeName;
+ for (var i = 0; i < spec.length; ++i) {
+ var c = spec.charAt(i);
+ var cUpper = c.toUpperCase();
+ var arg = args[i];
+ // Asterix means allow anything.
+ if (c === '*') {
+ continue;
+ }
+ typeName = utils.typeName(arg);
+ if ((arg === null || arg === undefined) && c === cUpper) {
+ continue;
+ }
+ if (typeName !== typeMap[cUpper]) {
+ errMsg = 'Expected ' + typeMap[cUpper];
+ break;
+ }
+ }
+ if (errMsg) {
+ errMsg += ', but got ' + typeName + '.';
+ errMsg = 'Wrong type for parameter "' + extractParamName(opt_callee || args.callee, i) + '" of ' + functionName + ': ' + errMsg;
+ // Don't log when running unit tests.
+ if (typeof jasmine === 'undefined') {
+ console.error(errMsg);
+ }
+ throw TypeError(errMsg);
+ }
+}
+
+function getValue (value, defaultValue) {
+ return value === undefined ? defaultValue : value;
+}
+
+moduleExports.checkArgs = checkArgs;
+moduleExports.getValue = getValue;
+moduleExports.enableChecks = true;
+
+});
+
+// file: src/common/base64.js
+define("cordova/base64", function(require, exports, module) {
+
+var base64 = exports;
+
+base64.fromArrayBuffer = function (arrayBuffer) {
+ var array = new Uint8Array(arrayBuffer);
+ return uint8ToBase64(array);
+};
+
+base64.toArrayBuffer = function (str) {
+ var decodedStr = atob(str);
+ var arrayBuffer = new ArrayBuffer(decodedStr.length);
+ var array = new Uint8Array(arrayBuffer);
+ for (var i = 0, len = decodedStr.length; i < len; i++) {
+ array[i] = decodedStr.charCodeAt(i);
+ }
+ return arrayBuffer;
+};
+
+// ------------------------------------------------------------------------------
+
+/* This code is based on the performance tests at http://jsperf.com/b64tests
+ * This 12-bit-at-a-time algorithm was the best performing version on all
+ * platforms tested.
+ */
+
+var b64_6bit = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+var b64_12bit;
+
+var b64_12bitTable = function () {
+ b64_12bit = [];
+ for (var i = 0; i < 64; i++) {
+ for (var j = 0; j < 64; j++) {
+ b64_12bit[i * 64 + j] = b64_6bit[i] + b64_6bit[j];
+ }
+ }
+ b64_12bitTable = function () { return b64_12bit; };
+ return b64_12bit;
+};
+
+function uint8ToBase64 (rawData) {
+ var numBytes = rawData.byteLength;
+ var output = '';
+ var segment;
+ var table = b64_12bitTable();
+ for (var i = 0; i < numBytes - 2; i += 3) {
+ segment = (rawData[i] << 16) + (rawData[i + 1] << 8) + rawData[i + 2];
+ output += table[segment >> 12];
+ output += table[segment & 0xfff];
+ }
+ if (numBytes - i === 2) {
+ segment = (rawData[i] << 16) + (rawData[i + 1] << 8);
+ output += table[segment >> 12];
+ output += b64_6bit[(segment & 0xfff) >> 6];
+ output += '=';
+ } else if (numBytes - i === 1) {
+ segment = (rawData[i] << 16);
+ output += table[segment >> 12];
+ output += '==';
+ }
+ return output;
+}
+
+});
+
+// file: src/common/builder.js
+define("cordova/builder", function(require, exports, module) {
+
+var utils = require('cordova/utils');
+
+function each (objects, func, context) {
+ for (var prop in objects) {
+ if (Object.prototype.hasOwnProperty.call(objects, prop)) {
+ func.apply(context, [objects[prop], prop]);
+ }
+ }
+}
+
+function clobber (obj, key, value) {
+ var needsProperty = false;
+ try {
+ obj[key] = value;
+ } catch (e) {
+ needsProperty = true;
+ }
+ // Getters can only be overridden by getters.
+ if (needsProperty || obj[key] !== value) {
+ utils.defineGetter(obj, key, function () {
+ return value;
+ });
+ }
+}
+
+function assignOrWrapInDeprecateGetter (obj, key, value, message) {
+ if (message) {
+ utils.defineGetter(obj, key, function () {
+ console.log(message);
+ delete obj[key];
+ clobber(obj, key, value);
+ return value;
+ });
+ } else {
+ clobber(obj, key, value);
+ }
+}
+
+function include (parent, objects, clobber, merge) {
+ each(objects, function (obj, key) {
+ try {
+ var result = obj.path ? require(obj.path) : {};
+
+ if (clobber) {
+ // Clobber if it doesn't exist.
+ if (typeof parent[key] === 'undefined') {
+ assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
+ } else if (typeof obj.path !== 'undefined') {
+ // If merging, merge properties onto parent, otherwise, clobber.
+ if (merge) {
+ recursiveMerge(parent[key], result);
+ } else {
+ assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
+ }
+ }
+ result = parent[key];
+ } else {
+ // Overwrite if not currently defined.
+ if (typeof parent[key] === 'undefined') {
+ assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
+ } else {
+ // Set result to what already exists, so we can build children into it if they exist.
+ result = parent[key];
+ }
+ }
+
+ if (obj.children) {
+ include(result, obj.children, clobber, merge);
+ }
+ } catch (e) {
+ utils.alert('Exception building Cordova JS globals: ' + e + ' for key "' + key + '"');
+ }
+ });
+}
+
+/**
+ * Merge properties from one object onto another recursively. Properties from
+ * the src object will overwrite existing target property.
+ *
+ * @param target Object to merge properties into.
+ * @param src Object to merge properties from.
+ */
+function recursiveMerge (target, src) {
+ for (var prop in src) {
+ if (Object.prototype.hasOwnProperty.call(src, prop)) {
+ if (target.prototype && target.prototype.constructor === target) {
+ // If the target object is a constructor override off prototype.
+ clobber(target.prototype, prop, src[prop]);
+ } else {
+ if (typeof src[prop] === 'object' && typeof target[prop] === 'object') {
+ recursiveMerge(target[prop], src[prop]);
+ } else {
+ clobber(target, prop, src[prop]);
+ }
+ }
+ }
+ }
+}
+
+exports.buildIntoButDoNotClobber = function (objects, target) {
+ include(target, objects, false, false);
+};
+exports.buildIntoAndClobber = function (objects, target) {
+ include(target, objects, true, false);
+};
+exports.buildIntoAndMerge = function (objects, target) {
+ include(target, objects, true, true);
+};
+exports.recursiveMerge = recursiveMerge;
+exports.assignOrWrapInDeprecateGetter = assignOrWrapInDeprecateGetter;
+
+});
+
+// file: src/common/channel.js
+define("cordova/channel", function(require, exports, module) {
+
+var utils = require('cordova/utils');
+var nextGuid = 1;
+
+/**
+ * Custom pub-sub "channel" that can have functions subscribed to it
+ * This object is used to define and control firing of events for
+ * cordova initialization, as well as for custom events thereafter.
+ *
+ * The order of events during page load and Cordova startup is as follows:
+ *
+ * onDOMContentLoaded* Internal event that is received when the web page is loaded and parsed.
+ * onNativeReady* Internal event that indicates the Cordova native side is ready.
+ * onCordovaReady* Internal event fired when all Cordova JavaScript objects have been created.
+ * onDeviceReady* User event fired to indicate that Cordova is ready
+ * onResume User event fired to indicate a start/resume lifecycle event
+ * onPause User event fired to indicate a pause lifecycle event
+ *
+ * The events marked with an * are sticky. Once they have fired, they will stay in the fired state.
+ * All listeners that subscribe after the event is fired will be executed right away.
+ *
+ * The only Cordova events that user code should register for are:
+ * deviceready Cordova native code is initialized and Cordova APIs can be called from JavaScript
+ * pause App has moved to background
+ * resume App has returned to foreground
+ *
+ * Listeners can be registered as:
+ * document.addEventListener("deviceready", myDeviceReadyListener, false);
+ * document.addEventListener("resume", myResumeListener, false);
+ * document.addEventListener("pause", myPauseListener, false);
+ *
+ * The DOM lifecycle events should be used for saving and restoring state
+ * window.onload
+ * window.onunload
+ *
+ */
+
+/**
+ * Channel
+ * @constructor
+ * @param type String the channel name
+ */
+var Channel = function (type, sticky) {
+ this.type = type;
+ // Map of guid -> function.
+ this.handlers = {};
+ // 0 = Non-sticky, 1 = Sticky non-fired, 2 = Sticky fired.
+ this.state = sticky ? 1 : 0;
+ // Used in sticky mode to remember args passed to fire().
+ this.fireArgs = null;
+ // Used by onHasSubscribersChange to know if there are any listeners.
+ this.numHandlers = 0;
+ // Function that is called when the first listener is subscribed, or when
+ // the last listener is unsubscribed.
+ this.onHasSubscribersChange = null;
+};
+var channel = {
+ /**
+ * Calls the provided function only after all of the channels specified
+ * have been fired. All channels must be sticky channels.
+ */
+ join: function (h, c) {
+ var len = c.length;
+ var i = len;
+ var f = function () {
+ if (!(--i)) h();
+ };
+ for (var j = 0; j < len; j++) {
+ if (c[j].state === 0) {
+ throw Error('Can only use join with sticky channels.');
+ }
+ c[j].subscribe(f);
+ }
+ if (!len) h();
+ },
+
+ create: function (type) {
+ return (channel[type] = new Channel(type, false));
+ },
+ createSticky: function (type) {
+ return (channel[type] = new Channel(type, true));
+ },
+
+ /**
+ * cordova Channels that must fire before "deviceready" is fired.
+ */
+ deviceReadyChannelsArray: [],
+ deviceReadyChannelsMap: {},
+
+ /**
+ * Indicate that a feature needs to be initialized before it is ready to be used.
+ * This holds up Cordova's "deviceready" event until the feature has been initialized
+ * and Cordova.initComplete(feature) is called.
+ *
+ * @param feature {String} The unique feature name
+ */
+ waitForInitialization: function (feature) {
+ if (feature) {
+ var c = channel[feature] || this.createSticky(feature);
+ this.deviceReadyChannelsMap[feature] = c;
+ this.deviceReadyChannelsArray.push(c);
+ }
+ },
+
+ /**
+ * Indicate that initialization code has completed and the feature is ready to be used.
+ *
+ * @param feature {String} The unique feature name
+ */
+ initializationComplete: function (feature) {
+ var c = this.deviceReadyChannelsMap[feature];
+ if (c) {
+ c.fire();
+ }
+ }
+};
+
+function checkSubscriptionArgument (argument) {
+ if (typeof argument !== 'function' && typeof argument.handleEvent !== 'function') {
+ throw new Error(
+ 'Must provide a function or an EventListener object ' +
+ 'implementing the handleEvent interface.'
+ );
+ }
+}
+
+/**
+ * Subscribes the given function to the channel. Any time that
+ * Channel.fire is called so too will the function.
+ * Optionally specify an execution context for the function
+ * and a guid that can be used to stop subscribing to the channel.
+ * Returns the guid.
+ */
+Channel.prototype.subscribe = function (eventListenerOrFunction, eventListener) {
+ checkSubscriptionArgument(eventListenerOrFunction);
+ var handleEvent, guid;
+
+ if (eventListenerOrFunction && typeof eventListenerOrFunction === 'object') {
+ // Received an EventListener object implementing the handleEvent interface
+ handleEvent = eventListenerOrFunction.handleEvent;
+ eventListener = eventListenerOrFunction;
+ } else {
+ // Received a function to handle event
+ handleEvent = eventListenerOrFunction;
+ }
+
+ if (this.state === 2) {
+ handleEvent.apply(eventListener || this, this.fireArgs);
+ return;
+ }
+
+ guid = eventListenerOrFunction.observer_guid;
+ if (typeof eventListener === 'object') {
+ handleEvent = utils.close(eventListener, handleEvent);
+ }
+
+ if (!guid) {
+ // First time any channel has seen this subscriber
+ guid = '' + nextGuid++;
+ }
+ handleEvent.observer_guid = guid;
+ eventListenerOrFunction.observer_guid = guid;
+
+ // Don't add the same handler more than once.
+ if (!this.handlers[guid]) {
+ this.handlers[guid] = handleEvent;
+ this.numHandlers++;
+ if (this.numHandlers === 1) {
+ this.onHasSubscribersChange && this.onHasSubscribersChange();
+ }
+ }
+};
+
+/**
+ * Unsubscribes the function with the given guid from the channel.
+ */
+Channel.prototype.unsubscribe = function (eventListenerOrFunction) {
+ checkSubscriptionArgument(eventListenerOrFunction);
+ var handleEvent, guid, handler;
+
+ if (eventListenerOrFunction && typeof eventListenerOrFunction === 'object') {
+ // Received an EventListener object implementing the handleEvent interface
+ handleEvent = eventListenerOrFunction.handleEvent;
+ } else {
+ // Received a function to handle event
+ handleEvent = eventListenerOrFunction;
+ }
+
+ guid = handleEvent.observer_guid;
+ handler = this.handlers[guid];
+ if (handler) {
+ delete this.handlers[guid];
+ this.numHandlers--;
+ if (this.numHandlers === 0) {
+ this.onHasSubscribersChange && this.onHasSubscribersChange();
+ }
+ }
+};
+
+/**
+ * Calls all functions subscribed to this channel.
+ */
+Channel.prototype.fire = function (e) {
+ var fireArgs = Array.prototype.slice.call(arguments);
+ // Apply stickiness.
+ if (this.state === 1) {
+ this.state = 2;
+ this.fireArgs = fireArgs;
+ }
+ if (this.numHandlers) {
+ // Copy the values first so that it is safe to modify it from within
+ // callbacks.
+ var toCall = [];
+ for (var item in this.handlers) {
+ toCall.push(this.handlers[item]);
+ }
+ for (var i = 0; i < toCall.length; ++i) {
+ toCall[i].apply(this, fireArgs);
+ }
+ if (this.state === 2 && this.numHandlers) {
+ this.numHandlers = 0;
+ this.handlers = {};
+ this.onHasSubscribersChange && this.onHasSubscribersChange();
+ }
+ }
+};
+
+// defining them here so they are ready super fast!
+// DOM event that is received when the web page is loaded and parsed.
+channel.createSticky('onDOMContentLoaded');
+
+// Event to indicate the Cordova native side is ready.
+channel.createSticky('onNativeReady');
+
+// Event to indicate that all Cordova JavaScript objects have been created
+// and it's time to run plugin constructors.
+channel.createSticky('onCordovaReady');
+
+// Event to indicate that all automatically loaded JS plugins are loaded and ready.
+// FIXME remove this
+channel.createSticky('onPluginsReady');
+
+// Event to indicate that Cordova is ready
+channel.createSticky('onDeviceReady');
+
+// Event to indicate a resume lifecycle event
+channel.create('onResume');
+
+// Event to indicate a pause lifecycle event
+channel.create('onPause');
+
+// Channels that must fire before "deviceready" is fired.
+channel.waitForInitialization('onCordovaReady');
+channel.waitForInitialization('onDOMContentLoaded');
+
+module.exports = channel;
+
+});
+
+// file: ../../cordova-js-src/exec.js
+define("cordova/exec", function(require, exports, module) {
+
+/**
+ * Execute a cordova command. It is up to the native side whether this action
+ * is synchronous or asynchronous. The native side can return:
+ * Synchronous: PluginResult object as a JSON string
+ * Asynchronous: Empty string ""
+ * If async, the native side will cordova.callbackSuccess or cordova.callbackError,
+ * depending upon the result of the action.
+ *
+ * @param {Function} success The success callback
+ * @param {Function} fail The fail callback
+ * @param {String} service The name of the service to use
+ * @param {String} action Action to be run in cordova
+ * @param {String[]} [args] Zero or more arguments to pass to the method
+ */
+var cordova = require('cordova');
+var nativeApiProvider = require('cordova/android/nativeapiprovider');
+var utils = require('cordova/utils');
+var base64 = require('cordova/base64');
+var channel = require('cordova/channel');
+var jsToNativeModes = {
+ PROMPT: 0,
+ JS_OBJECT: 1
+};
+var nativeToJsModes = {
+ // Polls for messages using the JS->Native bridge.
+ POLLING: 0,
+ // For LOAD_URL to be viable, it would need to have a work-around for
+ // the bug where the soft-keyboard gets dismissed when a message is sent.
+ LOAD_URL: 1,
+ // For the ONLINE_EVENT to be viable, it would need to intercept all event
+ // listeners (both through addEventListener and window.ononline) as well
+ // as set the navigator property itself.
+ ONLINE_EVENT: 2,
+ EVAL_BRIDGE: 3
+};
+var jsToNativeBridgeMode; // Set lazily.
+var nativeToJsBridgeMode = nativeToJsModes.EVAL_BRIDGE;
+var pollEnabled = false;
+var bridgeSecret = -1;
+
+var messagesFromNative = [];
+var isProcessing = false;
+var resolvedPromise = typeof Promise === 'undefined' ? null : Promise.resolve();
+var nextTick = resolvedPromise ? function (fn) { resolvedPromise.then(fn); } : function (fn) { setTimeout(fn); };
+
+function androidExec (success, fail, service, action, args) {
+ if (bridgeSecret < 0) {
+ // If we ever catch this firing, we'll need to queue up exec()s
+ // and fire them once we get a secret. For now, I don't think
+ // it's possible for exec() to be called since plugins are parsed but
+ // not run until until after onNativeReady.
+ throw new Error('exec() called without bridgeSecret');
+ }
+ // Set default bridge modes if they have not already been set.
+ // By default, we use the failsafe, since addJavascriptInterface breaks too often
+ if (jsToNativeBridgeMode === undefined) {
+ androidExec.setJsToNativeBridgeMode(jsToNativeModes.JS_OBJECT);
+ }
+
+ // If args is not provided, default to an empty array
+ args = args || [];
+
+ // Process any ArrayBuffers in the args into a string.
+ for (var i = 0; i < args.length; i++) {
+ if (utils.typeName(args[i]) === 'ArrayBuffer') {
+ args[i] = base64.fromArrayBuffer(args[i]);
+ }
+ }
+
+ var callbackId = service + cordova.callbackId++;
+ var argsJson = JSON.stringify(args);
+ if (success || fail) {
+ cordova.callbacks[callbackId] = { success: success, fail: fail };
+ }
+
+ var msgs = nativeApiProvider.get().exec(bridgeSecret, service, action, callbackId, argsJson);
+ // If argsJson was received by Java as null, try again with the PROMPT bridge mode.
+ // This happens in rare circumstances, such as when certain Unicode characters are passed over the bridge on a Galaxy S2. See CB-2666.
+ if (jsToNativeBridgeMode === jsToNativeModes.JS_OBJECT && msgs === '@Null arguments.') {
+ androidExec.setJsToNativeBridgeMode(jsToNativeModes.PROMPT);
+ androidExec(success, fail, service, action, args);
+ androidExec.setJsToNativeBridgeMode(jsToNativeModes.JS_OBJECT);
+ } else if (msgs) {
+ messagesFromNative.push(msgs);
+ // Always process async to avoid exceptions messing up stack.
+ nextTick(processMessages);
+ }
+}
+
+androidExec.init = function () {
+ bridgeSecret = +prompt('', 'gap_init:' + nativeToJsBridgeMode);
+ channel.onNativeReady.fire();
+};
+
+function pollOnceFromOnlineEvent () {
+ pollOnce(true);
+}
+
+function pollOnce (opt_fromOnlineEvent) {
+ if (bridgeSecret < 0) {
+ // This can happen when the NativeToJsMessageQueue resets the online state on page transitions.
+ // We know there's nothing to retrieve, so no need to poll.
+ return;
+ }
+ var msgs = nativeApiProvider.get().retrieveJsMessages(bridgeSecret, !!opt_fromOnlineEvent);
+ if (msgs) {
+ messagesFromNative.push(msgs);
+ // Process sync since we know we're already top-of-stack.
+ processMessages();
+ }
+}
+
+function pollingTimerFunc () {
+ if (pollEnabled) {
+ pollOnce();
+ setTimeout(pollingTimerFunc, 50);
+ }
+}
+
+function hookOnlineApis () {
+ function proxyEvent (e) {
+ cordova.fireWindowEvent(e.type);
+ }
+ // The network module takes care of firing online and offline events.
+ // It currently fires them only on document though, so we bridge them
+ // to window here (while first listening for exec()-releated online/offline
+ // events).
+ window.addEventListener('online', pollOnceFromOnlineEvent, false);
+ window.addEventListener('offline', pollOnceFromOnlineEvent, false);
+ cordova.addWindowEventHandler('online');
+ cordova.addWindowEventHandler('offline');
+ document.addEventListener('online', proxyEvent, false);
+ document.addEventListener('offline', proxyEvent, false);
+}
+
+hookOnlineApis();
+
+androidExec.jsToNativeModes = jsToNativeModes;
+androidExec.nativeToJsModes = nativeToJsModes;
+
+androidExec.setJsToNativeBridgeMode = function (mode) {
+ if (mode === jsToNativeModes.JS_OBJECT && !window._cordovaNative) {
+ mode = jsToNativeModes.PROMPT;
+ }
+ nativeApiProvider.setPreferPrompt(mode === jsToNativeModes.PROMPT);
+ jsToNativeBridgeMode = mode;
+};
+
+androidExec.setNativeToJsBridgeMode = function (mode) {
+ if (mode === nativeToJsBridgeMode) {
+ return;
+ }
+ if (nativeToJsBridgeMode === nativeToJsModes.POLLING) {
+ pollEnabled = false;
+ }
+
+ nativeToJsBridgeMode = mode;
+ // Tell the native side to switch modes.
+ // Otherwise, it will be set by androidExec.init()
+ if (bridgeSecret >= 0) {
+ nativeApiProvider.get().setNativeToJsBridgeMode(bridgeSecret, mode);
+ }
+
+ if (mode === nativeToJsModes.POLLING) {
+ pollEnabled = true;
+ setTimeout(pollingTimerFunc, 1);
+ }
+};
+
+function buildPayload (payload, message) {
+ var payloadKind = message.charAt(0);
+ if (payloadKind === 's') {
+ payload.push(message.slice(1));
+ } else if (payloadKind === 't') {
+ payload.push(true);
+ } else if (payloadKind === 'f') {
+ payload.push(false);
+ } else if (payloadKind === 'N') {
+ payload.push(null);
+ } else if (payloadKind === 'n') {
+ payload.push(+message.slice(1));
+ } else if (payloadKind === 'A') {
+ var data = message.slice(1);
+ payload.push(base64.toArrayBuffer(data));
+ } else if (payloadKind === 'S') {
+ payload.push(window.atob(message.slice(1)));
+ } else if (payloadKind === 'M') {
+ var multipartMessages = message.slice(1);
+ while (multipartMessages !== '') {
+ var spaceIdx = multipartMessages.indexOf(' ');
+ var msgLen = +multipartMessages.slice(0, spaceIdx);
+ var multipartMessage = multipartMessages.substr(spaceIdx + 1, msgLen);
+ multipartMessages = multipartMessages.slice(spaceIdx + msgLen + 1);
+ buildPayload(payload, multipartMessage);
+ }
+ } else {
+ payload.push(JSON.parse(message));
+ }
+}
+
+// Processes a single message, as encoded by NativeToJsMessageQueue.java.
+function processMessage (message) {
+ var firstChar = message.charAt(0);
+ if (firstChar === 'J') {
+ // This is deprecated on the .java side. It doesn't work with CSP enabled.
+ // eslint-disable-next-line no-eval
+ eval(message.slice(1));
+ } else if (firstChar === 'S' || firstChar === 'F') {
+ var success = firstChar === 'S';
+ var keepCallback = message.charAt(1) === '1';
+ var spaceIdx = message.indexOf(' ', 2);
+ var status = +message.slice(2, spaceIdx);
+ var nextSpaceIdx = message.indexOf(' ', spaceIdx + 1);
+ var callbackId = message.slice(spaceIdx + 1, nextSpaceIdx);
+ var payloadMessage = message.slice(nextSpaceIdx + 1);
+ var payload = [];
+ buildPayload(payload, payloadMessage);
+ cordova.callbackFromNative(callbackId, success, status, payload, keepCallback);
+ } else {
+ console.log('processMessage failed: invalid message: ' + JSON.stringify(message));
+ }
+}
+
+function processMessages () {
+ // Check for the reentrant case.
+ if (isProcessing) {
+ return;
+ }
+ if (messagesFromNative.length === 0) {
+ return;
+ }
+ isProcessing = true;
+ try {
+ var msg = popMessageFromQueue();
+ // The Java side can send a * message to indicate that it
+ // still has messages waiting to be retrieved.
+ if (msg === '*' && messagesFromNative.length === 0) {
+ nextTick(pollOnce);
+ return;
+ }
+ processMessage(msg);
+ } finally {
+ isProcessing = false;
+ if (messagesFromNative.length > 0) {
+ nextTick(processMessages);
+ }
+ }
+}
+
+function popMessageFromQueue () {
+ var messageBatch = messagesFromNative.shift();
+ if (messageBatch === '*') {
+ return '*';
+ }
+
+ var spaceIdx = messageBatch.indexOf(' ');
+ var msgLen = +messageBatch.slice(0, spaceIdx);
+ var message = messageBatch.substr(spaceIdx + 1, msgLen);
+ messageBatch = messageBatch.slice(spaceIdx + msgLen + 1);
+ if (messageBatch) {
+ messagesFromNative.unshift(messageBatch);
+ }
+ return message;
+}
+
+module.exports = androidExec;
+
+});
+
+// file: src/common/exec/proxy.js
+define("cordova/exec/proxy", function(require, exports, module) {
+
+// internal map of proxy function
+var CommandProxyMap = {};
+
+module.exports = {
+
+ // example: cordova.commandProxy.add("Accelerometer",{getCurrentAcceleration: function(successCallback, errorCallback, options) {...},...);
+ add: function (id, proxyObj) {
+ console.log('adding proxy for ' + id);
+ CommandProxyMap[id] = proxyObj;
+ return proxyObj;
+ },
+
+ // cordova.commandProxy.remove("Accelerometer");
+ remove: function (id) {
+ var proxy = CommandProxyMap[id];
+ delete CommandProxyMap[id];
+ CommandProxyMap[id] = null;
+ return proxy;
+ },
+
+ get: function (service, action) {
+ return (CommandProxyMap[service] ? CommandProxyMap[service][action] : null);
+ }
+};
+
+});
+
+// file: src/common/init.js
+define("cordova/init", function(require, exports, module) {
+
+var channel = require('cordova/channel');
+var cordova = require('cordova');
+var modulemapper = require('cordova/modulemapper');
+var platform = require('cordova/platform');
+var pluginloader = require('cordova/pluginloader');
+
+var platformInitChannelsArray = [channel.onNativeReady, channel.onPluginsReady];
+
+function logUnfiredChannels (arr) {
+ for (var i = 0; i < arr.length; ++i) {
+ if (arr[i].state !== 2) {
+ console.log('Channel not fired: ' + arr[i].type);
+ }
+ }
+}
+
+window.setTimeout(function () {
+ if (channel.onDeviceReady.state !== 2) {
+ console.log('deviceready has not fired after 5 seconds.');
+ logUnfiredChannels(platformInitChannelsArray);
+ logUnfiredChannels(channel.deviceReadyChannelsArray);
+ }
+}, 5000);
+
+if (!window.console) {
+ window.console = {
+ log: function () {}
+ };
+}
+if (!window.console.warn) {
+ window.console.warn = function (msg) {
+ this.log('warn: ' + msg);
+ };
+}
+
+// Register pause, resume and deviceready channels as events on document.
+channel.onPause = cordova.addDocumentEventHandler('pause');
+channel.onResume = cordova.addDocumentEventHandler('resume');
+channel.onActivated = cordova.addDocumentEventHandler('activated');
+channel.onDeviceReady = cordova.addStickyDocumentEventHandler('deviceready');
+
+// Listen for DOMContentLoaded and notify our channel subscribers.
+if (document.readyState === 'complete' || document.readyState === 'interactive') {
+ channel.onDOMContentLoaded.fire();
+} else {
+ document.addEventListener('DOMContentLoaded', function () {
+ channel.onDOMContentLoaded.fire();
+ }, false);
+}
+
+// _nativeReady is global variable that the native side can set
+// to signify that the native code is ready. It is a global since
+// it may be called before any cordova JS is ready.
+if (window._nativeReady) {
+ channel.onNativeReady.fire();
+}
+
+modulemapper.clobbers('cordova', 'cordova');
+modulemapper.clobbers('cordova/exec', 'cordova.exec');
+modulemapper.clobbers('cordova/exec', 'Cordova.exec');
+
+// Call the platform-specific initialization.
+platform.bootstrap && platform.bootstrap();
+
+// Wrap in a setTimeout to support the use-case of having plugin JS appended to cordova.js.
+// The delay allows the attached modules to be defined before the plugin loader looks for them.
+setTimeout(function () {
+ pluginloader.load(function () {
+ channel.onPluginsReady.fire();
+ });
+}, 0);
+
+/**
+ * Create all cordova objects once native side is ready.
+ */
+channel.join(function () {
+ modulemapper.mapModules(window);
+
+ platform.initialize && platform.initialize();
+
+ // Fire event to notify that all objects are created
+ channel.onCordovaReady.fire();
+
+ // Fire onDeviceReady event once page has fully loaded, all
+ // constructors have run and cordova info has been received from native
+ // side.
+ channel.join(function () {
+ require('cordova').fireDocumentEvent('deviceready');
+ }, channel.deviceReadyChannelsArray);
+}, platformInitChannelsArray);
+
+});
+
+// file: src/common/modulemapper.js
+define("cordova/modulemapper", function(require, exports, module) {
+
+var builder = require('cordova/builder');
+var moduleMap = define.moduleMap;
+var symbolList;
+var deprecationMap;
+
+exports.reset = function () {
+ symbolList = [];
+ deprecationMap = {};
+};
+
+function addEntry (strategy, moduleName, symbolPath, opt_deprecationMessage) {
+ if (!(moduleName in moduleMap)) {
+ throw new Error('Module ' + moduleName + ' does not exist.');
+ }
+ symbolList.push(strategy, moduleName, symbolPath);
+ if (opt_deprecationMessage) {
+ deprecationMap[symbolPath] = opt_deprecationMessage;
+ }
+}
+
+// Note: Android 2.3 does have Function.bind().
+exports.clobbers = function (moduleName, symbolPath, opt_deprecationMessage) {
+ addEntry('c', moduleName, symbolPath, opt_deprecationMessage);
+};
+
+exports.merges = function (moduleName, symbolPath, opt_deprecationMessage) {
+ addEntry('m', moduleName, symbolPath, opt_deprecationMessage);
+};
+
+exports.defaults = function (moduleName, symbolPath, opt_deprecationMessage) {
+ addEntry('d', moduleName, symbolPath, opt_deprecationMessage);
+};
+
+exports.runs = function (moduleName) {
+ addEntry('r', moduleName, null);
+};
+
+function prepareNamespace (symbolPath, context) {
+ if (!symbolPath) {
+ return context;
+ }
+ return symbolPath.split('.').reduce(function (cur, part) {
+ return (cur[part] = cur[part] || {});
+ }, context);
+}
+
+exports.mapModules = function (context) {
+ var origSymbols = {};
+ context.CDV_origSymbols = origSymbols;
+ for (var i = 0, len = symbolList.length; i < len; i += 3) {
+ var strategy = symbolList[i];
+ var moduleName = symbolList[i + 1];
+ var module = require(moduleName);
+ //