Set VERSION to 9.1.0 (via coho)

.eslintignore

@@ -1,3 +1,3 @@
-templates/project/assets/www/cordova.js
+bin/templates/project/assets/www/cordova.js
 test/android/app
 test/androidx/app

.github/workflows/ci.yml

@@ -27,7 +27,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [12.x, 14.x, 16.x]
+        node-version: [10.x, 12.x, 14.x]
         os: [ubuntu-latest, windows-latest, macos-latest]
 
     steps:

.gitignore

@@ -25,15 +25,14 @@ example
 /framework/libs
 /framework/javadoc-public
 /framework/javadoc-private
-
-**/assets/www/cordova.js
-
 /test/.externalNativeBuild
 
+/test/android/gradle
+/test/android/gradlew
+/test/android/gradlew.bat
 /test/androidx/gradle
 /test/androidx/gradlew
 /test/androidx/gradlew.bat
-/test/androidx/cdv-gradle-config.json
 
 /test/assets/www/.tmp*
 /test/assets/www/cordova.js

.npmignore

@@ -3,4 +3,3 @@ coverage
 test
 spec
 framework/build
-cordova-js-src

.ratignore

@@ -1,5 +1,5 @@
 *.properties
-templates
+bin
 gen
 proguard-project.txt
 spec

README.md

@@ -30,14 +30,28 @@ Cordova Android is an Android application library that allows for Cordova-based
 
 [Apache Cordova](https://cordova.apache.org) is a project of The Apache Software Foundation (ASF).
 
-## Requirements
+## Requires
 
-- Java Development Kit (JDK) 11
-- [Android SDK](https://developer.android.com/)
+- Java JDK 1.8
+- Android SDK [http://developer.android.com](https://developer.android.com/)
 
 ## Cordova Android Developer Tools
 
-Use the [Cordova command-line tool](https://www.npmjs.com/package/cordova) to create projects and install plugins.
+We recommend using the [Cordova command-line tool](https://www.npmjs.com/package/cordova) to create projects and be able to easily install plugins.
+
+However, the following scripts can be used instead:
+
+    ./bin/create [path package activity] ... creates the ./example app or a cordova android project
+    ./bin/check_reqs ....................... checks that your environment is set up for cordova-android development
+    ./bin/update [path] .................... updates an existing cordova-android project to the version of the framework
+
+These commands live in a generated Cordova Android project. Any interactions with the emulator require you to have an AVD defined.
+
+    ./cordova/clean ........................ cleans the project
+    ./cordova/build ........................ calls `clean` then compiles the project
+    ./cordova/log   ........................ streams device or emulator logs to STDOUT
+    ./cordova/run   ........................ calls `build` then deploys to a connected Android device. If no Android device is detected, will launch an emulator and deploy to it.
+    ./cordova/version ...................... returns the cordova-android version of the current project
 
 ## Using Android Studio
 

RELEASENOTES.md

@@ -20,99 +20,6 @@
 -->
 ## Release Notes for Cordova (Android)
 
-### 10.0.1 (Jul 27, 2021)
-
-**Fixes:**
-
-* [GH-1295](https://github.com/apache/cordova-android/pull/1295) fix: `maven-publish` setup
-* [GH-1293](https://github.com/apache/cordova-android/pull/1293) fix: `gradle` build tools config
-* [GH-1294](https://github.com/apache/cordova-android/pull/1294) fix: automatic latest build tools finding
-* [GH-1287](https://github.com/apache/cordova-android/pull/1287) fix: Google Services Gradle Plugin version check failure
-
-**Chores:**
-
-* [GH-1291](https://github.com/apache/cordova-android/pull/1291) chore: add missing release notes
-* [GH-1286](https://github.com/apache/cordova-android/pull/1286) chore: update `README` requirements
-
-### 10.0.0 (Jul 17, 2021)
-
-**Breaking:**
-
-* [GH-1052](https://github.com/apache/cordova-android/pull/1052) feat!: only support `AndroidX`
-* [GH-1137](https://github.com/apache/cordova-android/pull/1137) feat!: implement `WebViewAssetLoader`
-* [GH-1268](https://github.com/apache/cordova-android/pull/1268) feat!: release build defaults to `aab` package type
-* [GH-1182](https://github.com/apache/cordova-android/pull/1182) feat!: bump `target sdk@30` w/ `build-tool@30.0.3`
-* [GH-1257](https://github.com/apache/cordova-android/pull/1257) feat!: upgrade `gradle@7.1.1`
-* [GH-1197](https://github.com/apache/cordova-android/pull/1197) feat!: upgrade `gradle@6.8.3`
-* [GH-1256](https://github.com/apache/cordova-android/pull/1256) feat!: upgrade `kotlin@1.5.20`
-* [GH-1204](https://github.com/apache/cordova-android/pull/1204) feat!: upgrade `kotlin@1.4.32`
-* [GH-1200](https://github.com/apache/cordova-android/pull/1200) feat!: upgrade `kotlin@1.4.31`
-* [GH-1255](https://github.com/apache/cordova-android/pull/1255) feat!: upgrade `android-gradle-plugin@4.2.2`
-* [GH-1232](https://github.com/apache/cordova-android/pull/1232) feat!: upgrade `android-gradle-plugin@4.2.1`
-* [GH-1198](https://github.com/apache/cordova-android/pull/1198) feat!: upgrade `android-gradle-plugin@4.1.3`
-* [GH-1199](https://github.com/apache/cordova-android/pull/1199) feat!: upgrade `Google Services Gradle Plugin@4.3.5`
-* [GH-1262](https://github.com/apache/cordova-android/pull/1262) feat!: bump `appcompat@1.3.0`
-* [GH-1258](https://github.com/apache/cordova-android/pull/1258) feat!: bump `android.webkit@1.4.0`
-* [GH-1252](https://github.com/apache/cordova-android/pull/1252) feat!: drop abandoned `com.github.dcendents:android-maven-gradle-plugin`
-* [GH-1212](https://github.com/apache/cordova-android/pull/1212) feat!: unify & fix gradle library/tooling overrides
-* [GH-1138](https://github.com/apache/cordova-android/pull/1138) feat(allow-list)!: integrate and refactor core plugin
-* [GH-1201](https://github.com/apache/cordova-android/pull/1201) feat!: upgrade jfrog `gradle-bintray-plugin@1.8.5`
-* [GH-1279](https://github.com/apache/cordova-android/pull/1279) chore!: bump all dependencies
-* [GH-1278](https://github.com/apache/cordova-android/pull/1278) chore!: drop `node` 10 support
-* [GH-1205](https://github.com/apache/cordova-android/pull/1205) chore! (`npm`): update all dependencies
-* [GH-1274](https://github.com/apache/cordova-android/pull/1274) cleanup!: remove deprecated settings & add todo comments
-* [GH-1048](https://github.com/apache/cordova-android/pull/1048) cleanup!: remove `keystore` password prompt
-* [GH-1251](https://github.com/apache/cordova-android/pull/1251) cleanup!: drop `jcenter` & update dependencies
-* [GH-1269](https://github.com/apache/cordova-android/pull/1269) refactor!: do not copy JS lib to platform project
-* [GH-1270](https://github.com/apache/cordova-android/pull/1270) refactor(Api)!: use version from `package.json`
-* [GH-1266](https://github.com/apache/cordova-android/pull/1266) refactor(run)!: `run` method
-* [GH-1083](https://github.com/apache/cordova-android/pull/1083) refactor!: drop support for `android` SDK tool
-* [GH-1100](https://github.com/apache/cordova-android/pull/1100) refactor!: remove most platform binaries
-
-**Features:**
-
-* [GH-1241](https://github.com/apache/cordova-android/pull/1241) feat: remove `java` 1.8 version check
-* [GH-1254](https://github.com/apache/cordova-android/pull/1254) feat: support `webkit` version override
-* [GH-1229](https://github.com/apache/cordova-android/pull/1229) feat: `CORDOVA_JAVA_HOME` env variable
-* [GH-1222](https://github.com/apache/cordova-android/pull/1222) feat: add backwards compatibility mode for `WebViewAssetLoader`
-* [GH-1166](https://github.com/apache/cordova-android/pull/1166) feat: overload `PluginEntry` constructor to set onload property
-* [GH-1208](https://github.com/apache/cordova-android/pull/1208) feat: allow `appcompat` version to be configurable
-* [GH-1047](https://github.com/apache/cordova-android/pull/1047) feat: Deprecated `onRequestPermissionResult` in favour for `onRequestPermissionsResult` for consistency
-
-**Fixes:**
-
-* [GH-1283](https://github.com/apache/cordova-android/pull/1283) fix: add missing apache-license header to `getASPath.bat`
-* [GH-1275](https://github.com/apache/cordova-android/pull/1275) fix: add `WebViewAssetloader` to default allow list
-* [GH-1216](https://github.com/apache/cordova-android/pull/1216) fix: request focus after custom view hided
-* [GH-1264](https://github.com/apache/cordova-android/pull/1264) fix: missing `super.onRequestPermissionsResult` error (`MissingSuperCall`)
-* [GH-563](https://github.com/apache/cordova-android/pull/563) fix(build): support tilde expansion on Windows
-* [GH-1220](https://github.com/apache/cordova-android/pull/1220) fix(`requirements` check): use regex to get java version from javac output
-* [GH-1227](https://github.com/apache/cordova-android/pull/1227) fix(prepare): delete splash screens if none are used
-* [GH-1228](https://github.com/apache/cordova-android/pull/1228) fix: java checks
-* [GH-1276](https://github.com/apache/cordova-android/pull/1276) fix: remove forced default `gradle.daemon` setting
-
-**Refactors:**
-
-* [GH-1265](https://github.com/apache/cordova-android/pull/1265) refactor: do not infer project root from script location
-* [GH-1267](https://github.com/apache/cordova-android/pull/1267) refactor: use target SDK of built APK to determine best emulator
-* [GH-1253](https://github.com/apache/cordova-android/pull/1253) refactor: `gradle` cleanup
-* [GH-1260](https://github.com/apache/cordova-android/pull/1260) refactor(`check_reqs`): drop `originalError` param from `check_android_target`
-* [GH-1246](https://github.com/apache/cordova-android/pull/1246) refactor(`env/java`): improve tests and implementation
-
-**Chores & Cleanup:**
-
-* [GH-1273](https://github.com/apache/cordova-android/pull/1273) chore: remove old `VERSION` file
-* [GH-1272](https://github.com/apache/cordova-android/pull/1272) cleanup: delete old ANT & Eclipse files
-* [GH-1141](https://github.com/apache/cordova-android/pull/1141) cleanup: remove app cache settings
-
-**CI, Build & Testing:**
-
-* [GH-1218](https://github.com/apache/cordova-android/pull/1218) ci: Add `Node16` to CI matrix
-* [GH-1271](https://github.com/apache/cordova-android/pull/1271) build: build `cordova.js` during npm prepare
-* [GH-1207](https://github.com/apache/cordova-android/pull/1207) test(`AndroidManifest`): update theme to `Theme.AppCompat.NoActionBar`
-* [GH-1263](https://github.com/apache/cordova-android/pull/1263) test(`check_reqs`): do not hardcode `DEFAULT_TARGET_API`
-* [GH-1259](https://github.com/apache/cordova-android/pull/1259) test(`prepare`): factor out common vars
-
 ### 9.1.0 (Apr 09, 2021)
 
 **Features:**
@@ -326,38 +233,6 @@
 * [CB-13830](https://issues.apache.org/jira/browse/CB-13830) Add handlers for plugins that use non-Java source files, such as Camera
 * [CB-13923](https://issues.apache.org/jira/browse/CB-13923) Fix -1 length for compressed files
 
-### 7.1.4 (Nov 22, 2018)
-
-* Update android-versions to `1.4.0`, with added support for Android Pie ([#573](https://github.com/apache/cordova-android/pull/573))
-* Output current package name if package name can't be validated ([#567](https://github.com/apache/cordova-android/pull/567))
-* Resolve issue with plugin `target-dir="*app*"` subdirs ([#572](https://github.com/apache/cordova-android/pull/572))
-
-### 7.1.3 (Nov 19, 2018)
-
-* [GH-495](https://github.com/apache/cordova-android/pull/495) Incorrect default sdk version issue fix
-* [GH-496](https://github.com/apache/cordova-android/pull/496) update comments in `build.gradle`
-* [GH-539](https://github.com/apache/cordova-android/pull/539) Fix dest overwrite, in case of of plugin `source-file` element with `target-dir` that does not need remapping
-* [GH-540](https://github.com/apache/cordova-android/issues/540) support plugin `source-file` element with any app `target-dir` value
-* [GH-547](https://github.com/apache/cordova-android/issues/547) Compatibility of old plugins with non-Java `source-file` entries (individual files)
-* [GH-551](https://github.com/apache/cordova-android/pull/551) add missing cast for cdvMinSdkVersion to `build.gradle`
-* [GH-552](https://github.com/apache/cordova-android/issues/552) check for `build-extras.gradle` in the parent app directory
-
-### 7.1.2 (Nov 08, 2018)
-* [CB-14127](https://issues.apache.org/jira/browse/CB-14127): Always put the Google repo above jcenter
-* [CB-14165](https://issues.apache.org/jira/browse/CB-14165): Emulator: handle "device still connecting" error (#457)
-* [CB-14125](https://issues.apache.org/jira/browse/CB-14125): Increase old plugin compatibility
-* [CB-13830](https://issues.apache.org/jira/browse/CB-13830): Add handlers for plugins that use non-Java source files, such as Camera
-* [CB-14038](https://issues.apache.org/jira/browse/CB-14038): fix false positive detecting project type
-
-### 7.1.1 (Jul 11, 2018)
-* Fix unsafe property access in run.js (#445)
-* Emit log event instead of logging directly (#452)
-* [CB-14101](https://issues.apache.org/jira/browse/CB-14101) Fix Java version check for Java >= 9 (#446)
-* [CB-14127](https://issues.apache.org/jira/browse/CB-14127) (android) Move google maven repo ahead of jcenter
-* [CB-13923](https://issues.apache.org/jira/browse/CB-13923) (android) fix -1 length for compressed files
-* [CB-14145](https://issues.apache.org/jira/browse/CB-14145) use cordova-common@2.2.5 and update other dependencies to resolve `npm audit` warnings
-* [CB-9366](https://issues.apache.org/jira/browse/CB-9366) log error.stack in cordova.js
-
 ### 7.1.0 (Feb 20, 2018)
 * [CB-13879](https://issues.apache.org/jira/browse/CB-13879) updated gradle tools dependency to 3.0.1 for project template
 * [CB-13831](https://issues.apache.org/jira/browse/CB-13831) Update `android-versions` to 1.3.0 to support SDK 27.

VERSION

@@ -0,0 +1 @@
+9.1.0

bin/android_sdk_version

@@ -19,7 +19,7 @@
        under the License.
 */
 
-var android_sdk = require('cordova-android/lib/android_sdk');
+var android_sdk = require('./templates/cordova/lib/android_sdk');
 
 android_sdk.print_newest_available_sdk_target().catch(err => {
     console.error(err);

bin/android_sdk_version.bat

@@ -0,0 +1,26 @@
+:: 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
+SET script_path="%~dp0android_sdk_version"
+IF EXIST %script_path% (
+        node %script_path% %*
+) ELSE (
+    ECHO.
+    ECHO ERROR: Could not find 'android_sdk_version' script in 'bin' folder, aborting...>&2
+    EXIT /B 1
+)

bin/check_reqs

@@ -1,3 +1,5 @@
+#!/usr/bin/env node
+
 /*
        Licensed to the Apache Software Foundation (ASF) under one
        or more contributor license agreements.  See the NOTICE file
@@ -17,22 +19,14 @@
        under the License.
 */
 
-package org.apache.cordova;
+var check_reqs = require('./templates/cordova/lib/check_reqs');
 
-import androidx.webkit.WebViewAssetLoader;
-
-/**
- * Wrapper class for path and handler
- */
-public class CordovaPluginPathHandler {
-
-    private final WebViewAssetLoader.PathHandler handler;
-
-    public  CordovaPluginPathHandler(WebViewAssetLoader.PathHandler handler) {
-        this.handler = handler;
+check_reqs.run().then(
+    function success () {
+        console.log('Looks like your environment fully supports cordova-android development!');
+    },
+    function fail (err) {
+        console.log(err);
+        process.exit(2);
     }
-
-    public WebViewAssetLoader.PathHandler getPathHandler() {
-        return handler;
-    }
-}
+);

bin/check_reqs.bat

@@ -0,0 +1,26 @@
+:: 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
+SET script_path="%~dp0check_reqs"
+IF EXIST %script_path% (
+        node %script_path% %*
+) ELSE (
+    ECHO.
+    ECHO ERROR: Could not find 'check_reqs' script in 'bin' folder, aborting...>&2
+    EXIT /B 1
+)

bin/create

@@ -0,0 +1,61 @@
+#!/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 path = require('path');
+var ConfigParser = require('cordova-common').ConfigParser;
+var Api = require('./templates/cordova/Api');
+
+var argv = require('nopt')({
+    help: Boolean,
+    cli: Boolean,
+    shared: Boolean,
+    link: Boolean,
+    'activity-name': [String, undefined]
+}, { d: '--verbose' });
+
+if (argv.help || argv.argv.remain.length === 0) {
+    console.log('Usage: ' + path.relative(process.cwd(), path.join(__dirname, 'create')) + ' <path_to_new_project> <package_name> <project_name> [<template_path>] [--activity-name <activity_name>] [--link]');
+    console.log('    <path_to_new_project>: Path to your new Cordova Android project');
+    console.log('    <package_name>: Package name, following reverse-domain style convention');
+    console.log('    <project_name>: Project name');
+    console.log('    <template_path>: Path to a custom application template to use');
+    console.log('    --activity-name <activity_name>: Activity name');
+    console.log('    --link will use the CordovaLib project directly instead of making a copy.');
+    process.exit(1);
+}
+
+var config = new ConfigParser(path.resolve(__dirname, 'templates/project/res/xml/config.xml'));
+
+if (argv.argv.remain[1]) config.setPackageName(argv.argv.remain[1]);
+if (argv.argv.remain[2]) config.setName(argv.argv.remain[2]);
+if (argv['activity-name']) config.setName(argv['activity-name']);
+
+var options = {
+    link: argv.link || argv.shared,
+    customTemplate: argv.argv.remain[3],
+    activityName: argv['activity-name']
+};
+
+require('./templates/cordova/loggingHelper').adjustLoggerLevel(argv);
+
+Api.createPlatform(argv.argv.remain[0], config, options).catch(err => {
+    console.error(err);
+    process.exitCode = 1;
+});

bin/create.bat

@@ -16,5 +16,11 @@
 :: 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%
+SET script_path="%~dp0create"
+IF EXIST %script_path% (
+    node %script_path% %*
+) ELSE (
+    ECHO.
+    ECHO ERROR: Could not find 'create' script in 'bin' folder, aborting...>&2
+    EXIT /B 1
+)

bin/lib/create.js

@@ -19,13 +19,12 @@
 
 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 utils = require('../templates/cordova/lib/utils');
+var check_reqs = require('./../templates/cordova/lib/check_reqs');
+var ROOT = path.join(__dirname, '..', '..');
 
 var CordovaError = require('cordova-common').CordovaError;
-var AndroidManifest = require('./AndroidManifest');
+var AndroidManifest = require('../templates/cordova/lib/AndroidManifest');
 
 // Export all helper functions, and make sure internally within this module, we
 // reference these methods via the `exports` object - this helps with testing
@@ -43,12 +42,16 @@ function getFrameworkDir (projectPath, shared) {
     return shared ? path.join(ROOT, 'framework') : path.join(projectPath, 'CordovaLib');
 }
 
-function copyJsAndLibrary (projectPath, shared, projectName, targetAPI) {
+function copyJsAndLibrary (projectPath, shared, projectName, isLegacy) {
     var nestedCordovaLibPath = getFrameworkDir(projectPath, false);
-    var srcCordovaJsPath = path.join(ROOT, 'templates', 'project', 'assets', 'www', 'cordova.js');
+    var srcCordovaJsPath = path.join(ROOT, 'bin', 'templates', 'project', 'assets', 'www', 'cordova.js');
     var app_path = path.join(projectPath, 'app', 'src', 'main');
     const platform_www = path.join(projectPath, 'platform_www');
 
+    if (isLegacy) {
+        app_path = projectPath;
+    }
+
     fs.copySync(srcCordovaJsPath, path.join(app_path, 'assets', 'www', 'cordova.js'));
 
     // Copy the cordova.js file to platforms/<platform>/platform_www/
@@ -56,20 +59,21 @@ function copyJsAndLibrary (projectPath, shared, projectName, targetAPI) {
     fs.ensureDirSync(platform_www);
     fs.copySync(srcCordovaJsPath, path.join(platform_www, 'cordova.js'));
 
+    // Copy cordova-js-src directory into platform_www directory.
+    // We need these files to build cordova.js if using browserify method.
+    fs.copySync(path.join(ROOT, 'cordova-js-src'), path.join(platform_www, 'cordova-js-src'));
+
     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', 'project.properties'), 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'));
     }
 }
 
@@ -85,7 +89,7 @@ function extractSubProjectPaths (data) {
 
 function writeProjectProperties (projectPath, target_api) {
     var dstPath = path.join(projectPath, 'project.properties');
-    var templatePath = path.join(ROOT, 'templates', 'project', 'project.properties');
+    var templatePath = path.join(ROOT, 'bin', 'templates', 'project', 'project.properties');
     var srcPath = fs.existsSync(dstPath) ? dstPath : templatePath;
 
     var data = fs.readFileSync(srcPath, 'utf8');
@@ -109,12 +113,12 @@ function writeProjectProperties (projectPath, target_api) {
 
 // This makes no sense, what if you're building with a different build system?
 function prepBuildFiles (projectPath) {
-    var buildModule = require('./builders/builders');
+    var buildModule = require('../templates/cordova/lib/builders/builders');
     buildModule.getBuilder(projectPath).prepBuildFiles();
 }
 
 function copyBuildRules (projectPath, isLegacy) {
-    var srcDir = path.join(ROOT, 'templates', 'project');
+    var srcDir = path.join(ROOT, 'bin', 'templates', 'project');
 
     if (isLegacy) {
         // The project's build.gradle is identical to the earlier build.gradle, so it should still work
@@ -130,12 +134,33 @@ function copyBuildRules (projectPath, isLegacy) {
 }
 
 function copyScripts (projectPath) {
-    var srcScriptsDir = path.join(ROOT, 'templates', 'cordova');
+    var bin = path.join(ROOT, 'bin');
+    var srcScriptsDir = path.join(bin, '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);
+
+    const nodeModulesDir = path.join(ROOT, 'node_modules');
+    if (fs.existsSync(nodeModulesDir)) fs.copySync(nodeModulesDir, path.join(destScriptsDir, 'node_modules'));
+
+    fs.copySync(path.join(bin, 'check_reqs'), path.join(destScriptsDir, 'check_reqs'));
+    fs.copySync(path.join(bin, 'check_reqs.bat'), path.join(destScriptsDir, 'check_reqs.bat'));
+    fs.copySync(path.join(bin, 'android_sdk_version'), path.join(destScriptsDir, 'android_sdk_version'));
+    fs.copySync(path.join(bin, 'android_sdk_version.bat'), path.join(destScriptsDir, 'android_sdk_version.bat'));
+
+    var check_reqs = path.join(destScriptsDir, 'check_reqs');
+    var android_sdk_version = path.join(destScriptsDir, 'android_sdk_version');
+
+    // TODO: the two files being edited on-the-fly here are shared between
+    // platform and project-level commands. the below is updating the
+    // `require` path for the two libraries. if there's a better way to share
+    // modules across both the repo and generated projects, we should make sure
+    // to remove/update this.
+    const templatesCordovaRegex = /templates\/cordova\//;
+    utils.replaceFileContents(android_sdk_version, templatesCordovaRegex, '');
+    utils.replaceFileContents(check_reqs, templatesCordovaRegex, '');
 }
 
 /**
@@ -222,7 +247,7 @@ exports.create = function (project_path, config, options, events) {
         ? config.name().replace(/[^\w.]/g, '_') : 'CordovaExample';
 
     var safe_activity_name = config.android_activityName() || options.activityName || 'MainActivity';
-    var target_api = check_reqs.get_target(project_path);
+    var target_api = check_reqs.get_target();
 
     // Make the package conform to Java package types
     return exports.validatePackageName(package_name)
@@ -239,7 +264,7 @@ exports.create = function (project_path, config, options, events) {
 
             events.emit('verbose', 'Copying android template project to ' + project_path);
 
-            var project_template_dir = options.customTemplate || path.join(ROOT, 'templates', 'project');
+            var project_template_dir = options.customTemplate || path.join(ROOT, 'bin', 'templates', 'project');
             var app_path = path.join(project_path, 'app', 'src', 'main');
 
             // copy project template
@@ -252,7 +277,7 @@ exports.create = function (project_path, config, options, events) {
             fs.ensureDirSync(path.join(app_path, 'libs'));
 
             // copy cordova.js, cordova.jar
-            exports.copyJsAndLibrary(project_path, options.link, safe_activity_name, target_api);
+            exports.copyJsAndLibrary(project_path, options.link, safe_activity_name);
 
             // Set up ther Android Studio paths
             var java_path = path.join(app_path, 'java');
@@ -292,7 +317,7 @@ exports.create = function (project_path, config, options, events) {
 };
 
 function generateDoneMessage (type, link) {
-    var pkg = require('../package');
+    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';

bin/templates/cordova/Api.js

@@ -17,18 +17,26 @@
     under the License.
 */
 
+/**
+ * @todo update coho to update this line.
+ * @todo use `package.json` instead but first
+ *  figure out how this fit in with the platform-centered workflow structure.
+ *  This workflow would not have the `package.json` file.
+ */
+// Coho updates this line
+const VERSION = '9.1.0';
+
 var path = require('path');
 
-var AndroidProject = require('./AndroidProject');
+var AndroidProject = require('./lib/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;
+const prepare = require('./lib/prepare').prepare;
 
 var PLATFORM = 'android';
-const VERSION = require('../package').version;
 
 function setupEvents (externalEventEmitter) {
     if (externalEventEmitter) {
@@ -58,7 +66,7 @@ function setupEvents (externalEventEmitter) {
 class Api {
     constructor (platform, platformRootDir, events) {
         this.platform = PLATFORM;
-        this.root = platformRootDir;
+        this.root = path.resolve(__dirname, '..');
 
         setupEvents(events);
 
@@ -78,7 +86,7 @@ class Api {
             javaSrc: path.join(appMain, 'java')
         };
 
-        this._builder = require('./builders/builders').getBuilder(this.root);
+        this._builder = require('./lib/builders/builders').getBuilder(this.root);
     }
 
     /**
@@ -241,8 +249,8 @@ class Api {
     build (buildOptions) {
         var self = this;
 
-        return require('./check_reqs').run().then(function () {
-            return require('./build').run.call(self, buildOptions);
+        return require('./lib/check_reqs').run().then(function () {
+            return require('./lib/build').run.call(self, buildOptions);
         }).then(function (buildResults) {
             // Cast build result to array of build artifacts
             return buildResults.paths.map(function (apkPath) {
@@ -270,8 +278,8 @@ class Api {
      */
     run (runOptions) {
         var self = this;
-        return require('./check_reqs').run().then(function () {
-            return require('./run').run.call(self, runOptions);
+        return require('./lib/check_reqs').run().then(function () {
+            return require('./lib/run').run.call(self, runOptions);
         });
     }
 
@@ -289,10 +297,10 @@ class Api {
             cleanOptions = {};
         }
 
-        return require('./check_reqs').run().then(function () {
-            return require('./build').runClean.call(self, cleanOptions);
+        return require('./lib/check_reqs').run().then(function () {
+            return require('./lib/build').runClean.call(self, cleanOptions);
         }).then(function () {
-            return require('./prepare').clean.call(self, cleanOptions);
+            return require('./lib/prepare').clean.call(self, cleanOptions);
         });
     }
 
@@ -305,7 +313,7 @@ class Api {
      *   objects for current platform.
      */
     requirements () {
-        return require('./check_reqs').check_all(this.root);
+        return require('./lib/check_reqs').check_all();
     }
 
     /**
@@ -330,7 +338,7 @@ class Api {
         events = setupEvents(events);
         var result;
         try {
-            result = require('./create').create(destination, config, options, events).then(function (destination) {
+            result = require('../../lib/create').create(destination, config, options, events).then(function (destination) {
                 return new Api(PLATFORM, destination, events);
             });
         } catch (e) {

bin/templates/cordova/build

@@ -0,0 +1,51 @@
+#!/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 args = process.argv;
+var Api = require('./Api');
+var nopt = require('nopt');
+var path = require('path');
+
+// Support basic help commands
+if (['--help', '/?', '-h', 'help', '-help', '/help'].indexOf(args[2]) >= 0) {
+    require('./lib/build').help();
+}
+
+// Do some basic argument parsing
+var buildOpts = nopt({
+    verbose: Boolean,
+    silent: Boolean,
+    debug: Boolean,
+    release: Boolean,
+    nobuild: Boolean,
+    buildConfig: path
+}, { d: '--verbose' });
+
+// Make buildOptions compatible with PlatformApi build method spec
+buildOpts.argv = buildOpts.argv.original;
+
+require('./loggingHelper').adjustLoggerLevel(buildOpts);
+
+new Api().build(buildOpts)
+    .catch(function (err) {
+        console.error(err.stack);
+        process.exit(2);
+    });

bin/templates/cordova/build.bat

@@ -0,0 +1,26 @@
+:: 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
+SET script_path="%~dp0build"
+IF EXIST %script_path% (
+        node %script_path% %*
+) ELSE (
+    ECHO.
+    ECHO ERROR: Could not find 'build' script in 'cordova' folder, aborting...>&2
+    EXIT /B 1
+)

bin/templates/cordova/clean

@@ -0,0 +1,51 @@
+#!/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 Api = require('./Api');
+var path = require('path');
+var nopt = require('nopt');
+
+// Support basic help commands
+if (['--help', '/?', '-h', 'help', '-help', '/help'].indexOf(process.argv[2]) >= 0) {
+    console.log('Usage: ' + path.relative(process.cwd(), process.argv[1]));
+    console.log('Cleans the project directory.');
+    process.exit(0);
+}
+
+// Do some basic argument parsing
+var opts = nopt({
+    verbose: Boolean,
+    silent: Boolean
+}, { d: '--verbose' });
+
+// Make buildOptions compatible with PlatformApi clean method spec
+opts.argv = opts.argv.original;
+
+// Skip cleaning prepared files when not invoking via cordova CLI.
+opts.noPrepare = true;
+
+require('./loggingHelper').adjustLoggerLevel(opts);
+
+new Api().clean(opts)
+    .catch(function (err) {
+        console.error(err.stack);
+        process.exit(2);
+    });

bin/templates/cordova/clean.bat

@@ -0,0 +1,26 @@
+:: 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
+SET script_path="%~dp0clean"
+IF EXIST %script_path% (
+        node %script_path% %*
+) ELSE (
+    ECHO.
+    ECHO ERROR: Could not find 'clean' script in 'cordova' folder, aborting...>&2
+    EXIT /B 1
+)

bin/templates/cordova/lib/android_sdk.js

@@ -76,12 +76,23 @@ function parse_targets (output) {
     return targets;
 }
 
+module.exports.list_targets_with_android = function () {
+    return execa('android', ['list', 'target']).then(result => parse_targets(result.stdout));
+};
+
 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) {
+    return module.exports.list_targets_with_avdmanager().catch(function (err) {
+        // If there's an error, like avdmanager could not be found, we can try
+        // as a last resort, to run `android`, in case this is a super old
+        // SDK installation.
+        if (err && (err.code === 'ENOENT' || (err.stderr && err.stderr.match(/not recognized/)))) {
+            return module.exports.list_targets_with_android();
+        } else throw err;
+    }).then(function (targets) {
         if (targets.length === 0) {
             return Promise.reject(new Error('No android targets (SDKs) installed!'));
         }

bin/templates/cordova/lib/build.js

@@ -20,7 +20,6 @@
 var path = require('path');
 var fs = require('fs');
 var nopt = require('nopt');
-const untildify = require('untildify');
 
 var Adb = require('./Adb');
 
@@ -83,7 +82,9 @@ function parseOpts (options, resolvedTarget, projectRoot) {
         if (config.android && config.android[ret.buildType]) {
             var androidInfo = config.android[ret.buildType];
             if (androidInfo.keystore && !packageArgs.keystore) {
-                androidInfo.keystore = untildify(androidInfo.keystore);
+                if (androidInfo.keystore.substr(0, 1) === '~') {
+                    androidInfo.keystore = process.env.HOME + androidInfo.keystore.substr(1);
+                }
                 packageArgs.keystore = path.resolve(path.dirname(buildConfig), androidInfo.keystore);
                 events.emit('log', 'Reading the keystore from: ' + packageArgs.keystore);
             }
@@ -129,11 +130,7 @@ function parseOpts (options, resolvedTarget, projectRoot) {
             ret.packageType = packageArgs.packageType;
         }
     } else {
-        if (ret.buildType === 'release') {
-            ret.packageType = PackageType.BUNDLE;
-        } else {
-            ret.packageType = PackageType.APK;
-        }
+        ret.packageType = PackageType.APK;
     }
 
     return ret;
@@ -244,3 +241,26 @@ PackageInfo.prototype = {
         propertiesParser.save();
     }
 };
+
+module.exports.help = function () {
+    console.log('Usage: ' + path.relative(process.cwd(), path.join('../build')) + ' [flags] [Signed APK flags]');
+    console.log('Flags:');
+    console.log('    \'--debug\': will build project in debug mode (default)');
+    console.log('    \'--release\': will build project for release');
+    console.log('    \'--nobuild\': will skip build process (useful when using run command)');
+    console.log('    \'--prepenv\': don\'t build, but copy in build scripts where necessary');
+    console.log('    \'--versionCode=#\': Override versionCode for this build. Useful for uploading multiple APKs.');
+    console.log('    \'--minSdkVersion=#\': Override minSdkVersion for this build.');
+    console.log('    \'--maxSdkVersion=#\': Override maxSdkVersion for this build. (Not Recommended)');
+    console.log('    \'--targetSdkVersion=#\': Override targetSdkVersion for this build.');
+    console.log('    \'--gradleArg=<gradle command line arg>\': Extra args to pass to the gradle command. Use one flag per arg. Ex. --gradleArg=-PcdvBuildMultipleApks=true');
+    console.log('    \'--packageType=<apk|bundle>\': Builds an APK or a bundle');
+    console.log('');
+    console.log('Signed APK flags (overwrites debug/release-signing.proprties) :');
+    console.log('    \'--keystore=<path to keystore>\': Key store used to build a signed archive. (Required)');
+    console.log('    \'--alias=\': Alias for the key store. (Required)');
+    console.log('    \'--storePassword=\': Password for the key store. (Optional - prompted)');
+    console.log('    \'--password=\': Password for the key. (Optional - prompted)');
+    console.log('    \'--keystoreType\': Type of the keystore. (Optional)');
+    process.exit(0);
+};

bin/templates/cordova/lib/builders/ProjectBuilder.js

@@ -78,7 +78,7 @@ function findOutputFiles (bundleType, buildType, { arch } = {}) {
 
 class ProjectBuilder {
     constructor (rootDirectory) {
-        this.root = rootDirectory;
+        this.root = rootDirectory || path.resolve(__dirname, '../../..');
         this.apkDir = path.join(this.root, 'app', 'build', 'outputs', 'apk');
         this.aabDir = path.join(this.root, 'app', 'build', 'outputs', 'bundle');
     }
@@ -160,7 +160,7 @@ class ProjectBuilder {
     // Makes the project buildable, minus the gradle wrapper.
     prepBuildFiles () {
         // Update the version of build.gradle in each dependent library.
-        var pluginBuildGradle = path.join(__dirname, 'plugin-build.gradle');
+        var pluginBuildGradle = path.join(this.root, 'cordova', 'lib', 'plugin-build.gradle');
         var propertiesObj = this.readProjectProperties();
         var subProjects = propertiesObj.libs;
 
@@ -265,11 +265,10 @@ class ProjectBuilder {
             }).then(function () {
                 return self.prepBuildFiles();
             }).then(() => {
-                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`;
+                const distributionUrl = process.env.CORDOVA_ANDROID_GRADLE_DISTRIBUTION_URL || 'https://services.gradle.org/distributions/gradle-6.5-all.zip';
                 gradleWrapperProperties.set('distributionUrl', distributionUrl);
                 gradleWrapperProperties.save();
 
@@ -288,35 +287,25 @@ class ProjectBuilder {
             });
     }
 
-    /**
-     * @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) {
+    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;
+        return execa(wrapper, args, { stdio: 'inherit', cwd: path.resolve(this.root) })
+            .catch(function (error) {
+                if (error.toString().indexOf('failed to find target with hash string') >= 0) {
+                    return check_reqs.check_android_target(error).then(function () {
+                        // If due to some odd reason - check_android_target succeeds
+                        // we should still fail here.
+                        throw error;
+                    });
                 }
-            }
-            throw error;
-        }
+                throw error;
+            });
     }
 
     clean (opts) {

bin/templates/cordova/lib/check_reqs.js

@@ -22,44 +22,58 @@ var path = require('path');
 var fs = require('fs-extra');
 const { forgivingWhichSync, isWindows, isDarwin } = require('./utils');
 const java = require('./env/java');
+var REPO_ROOT = path.join(__dirname, '..', '..', '..', '..');
+var PROJECT_ROOT = path.join(__dirname, '..', '..');
 const { CordovaError, ConfigParser, events } = require('cordova-common');
 var android_sdk = require('./android_sdk');
-const { SDK_VERSION } = require('./gradle-config-defaults');
+const { createEditor } = require('properties-parser');
+const semver = require('semver');
+
+const EXPECTED_JAVA_VERSION = '1.8.x';
 
 // 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
+ * @description Get valid target from framework/project.properties if run from this repo
+ *              Otherwise get target from project.properties file within a generated cordova-android project
  * @returns {string} The android target in format "android-${target}"
  */
-module.exports.get_target = function (projectRoot) {
-    const userTargetSdkVersion = getUserTargetSdkVersion(projectRoot);
+module.exports.get_target = function () {
+    const projectPropertiesPaths = [
+        path.join(REPO_ROOT, 'framework', 'project.properties'),
+        path.join(PROJECT_ROOT, 'project.properties')
+    ];
 
-    if (userTargetSdkVersion && userTargetSdkVersion < SDK_VERSION) {
-        events.emit('warn', `android-targetSdkVersion should be greater than or equal to ${SDK_VERSION}.`);
+    // Get the minimum required target API from the framework.
+    let target = projectPropertiesPaths.filter(filePath => fs.existsSync(filePath))
+        .map(filePath => createEditor(filePath).get('target'))
+        .pop();
+
+    if (!target) {
+        throw new Error(`We could not locate the target from the "project.properties" at either "${projectPropertiesPaths.join('", "')}".`);
     }
 
-    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 configFile = path.join(REPO_ROOT, 'config.xml');
+    if (!fs.existsSync(configFile)) return target;
 
     const configParser = new ConfigParser(configFile);
-    const targetSdkVersion = parseInt(configParser.getPreference('android-targetSdkVersion', 'android'), 10);
-    return isNaN(targetSdkVersion) ? 0 : targetSdkVersion;
-}
+    const desiredAPI = parseInt(configParser.getPreference('android-targetSdkVersion', 'android'), 10);
+
+    if (!isNaN(desiredAPI)) {
+        const minimumAPI = parseInt(target.split('-').pop(), 10);
+
+        if (desiredAPI >= minimumAPI) {
+            target = `android-${desiredAPI}`;
+        } else {
+            events.emit('warn', `android-targetSdkVersion should be greater than or equal to ${minimumAPI}.`);
+        }
+    }
+
+    return target;
+};
 
 module.exports.get_gradle_wrapper = function () {
     var androidStudioPath;
@@ -126,6 +140,14 @@ module.exports.check_gradle = function () {
  */
 module.exports.check_java = async function () {
     const javaVersion = await java.getVersion();
+
+    if (!semver.satisfies(javaVersion.version, EXPECTED_JAVA_VERSION)) {
+        throw new CordovaError(
+            `Requirements check failed for JDK ${EXPECTED_JAVA_VERSION}! Detected version: ${javaVersion.version}\n` +
+            'Check your ANDROID_SDK_ROOT / JAVA_HOME / PATH environment variables.'
+        );
+    }
+
     return javaVersion;
 };
 
@@ -139,6 +161,7 @@ module.exports.check_android = function () {
             }
         }
 
+        var androidCmdPath = forgivingWhichSync('android');
         var adbInPath = forgivingWhichSync('adb');
         var avdmanagerInPath = forgivingWhichSync('avdmanager');
         var hasAndroidHome = false;
@@ -149,7 +172,7 @@ module.exports.check_android = function () {
 
         // First ensure ANDROID_HOME is set
         // If we have no hints (nothing in PATH), try a few default locations
-        if (!hasAndroidHome && !adbInPath && !avdmanagerInPath) {
+        if (!hasAndroidHome && !androidCmdPath && !adbInPath && !avdmanagerInPath) {
             if (process.env.ANDROID_HOME) {
                 // Fallback to deprecated `ANDROID_HOME` variable
                 maybeSetAndroidHome(path.join(process.env.ANDROID_HOME));
@@ -199,6 +222,17 @@ module.exports.check_android = function () {
         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 (androidCmdPath) {
+                parentDir = path.dirname(androidCmdPath);
+                grandParentDir = path.dirname(parentDir);
+                if (path.basename(parentDir) === 'tools' || fs.existsSync(path.join(grandParentDir, 'tools', 'android'))) {
+                    maybeSetAndroidHome(grandParentDir);
+                } else {
+                    throw new CordovaError('Failed to find \'ANDROID_SDK_ROOT\' environment variable. Try setting it manually.\n' +
+                        'Detected \'android\' command at ' + parentDir + ' but no \'tools\' directory found near.\n' +
+                        'Try reinstall Android SDK or update your PATH to include valid path to SDK' + path.sep + 'tools directory.');
+                }
+            }
             if (adbInPath) {
                 parentDir = path.dirname(adbInPath);
                 grandParentDir = path.dirname(parentDir);
@@ -231,6 +265,9 @@ module.exports.check_android = function () {
                 '\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 && !androidCmdPath) {
+            process.env.PATH += path.delimiter + path.join(process.env.ANDROID_SDK_ROOT, 'tools');
+        }
         if (hasAndroidHome && !adbInPath) {
             process.env.PATH += path.delimiter + path.join(process.env.ANDROID_SDK_ROOT, 'platform-tools');
         }
@@ -241,18 +278,40 @@ module.exports.check_android = function () {
     });
 };
 
-module.exports.check_android_target = function (projectRoot) {
+// TODO: is this actually needed?
+module.exports.getAbsoluteAndroidCmd = function () {
+    var cmd = forgivingWhichSync('android');
+    if (cmd.length === 0) {
+        cmd = forgivingWhichSync('sdkmanager');
+    }
+    if (module.exports.isWindows()) {
+        return '"' + cmd + '"';
+    }
+    return cmd.replace(/(\s)/g, '\\$1');
+};
+
+module.exports.check_android_target = function (originalError) {
     // 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);
+    var desired_api_level = module.exports.get_target();
     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}"`);
+        var androidCmd = module.exports.getAbsoluteAndroidCmd();
+        var msg = 'Please install Android target / API level: "' + desired_api_level + '".\n\n' +
+            'Hint: Open the SDK manager by running: ' + androidCmd + '\n' +
+            'You will require:\n' +
+            '1. "SDK Platform" for API level ' + desired_api_level + '\n' +
+            '2. "Android SDK Platform-tools (latest)\n' +
+            '3. "Android SDK Build-tools" (latest)';
+        if (originalError) {
+            msg = originalError + '\n' + msg;
+        }
+        throw new CordovaError(msg);
     });
 };
 
@@ -292,10 +351,9 @@ var Requirement = function (id, name, version, installed) {
  * 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<Requirement[]> Array of requirements. Due to implementation, promise is always fulfilled.
  */
-module.exports.check_all = function (projectRoot) {
+module.exports.check_all = function () {
     var requirements = [
         new Requirement('java', 'Java JDK'),
         new Requirement('androidSdk', 'Android SDK'),
@@ -306,7 +364,7 @@ module.exports.check_all = function (projectRoot) {
     var checkFns = [
         this.check_java,
         this.check_android,
-        this.check_android_target.bind(this, projectRoot),
+        this.check_android_target,
         this.check_gradle
     ];
 

bin/templates/cordova/lib/config/GradlePropertiesParser.js

@@ -30,12 +30,15 @@ class GradlePropertiesParser {
     */
     constructor (platformDir) {
         this._defaults = {
+            // 10 seconds -> 6 seconds
+            'org.gradle.daemon': 'true',
+
             // to allow dex in process
             'org.gradle.jvmargs': '-Xmx2048m',
 
             // Android X
-            'android.useAndroidX': 'true',
-            'android.enableJetifier': 'true'
+            'android.useAndroidX': 'false',
+            'android.enableJetifier': 'false'
 
             // Shaves another 100ms, but produces a "try at own risk" warning. Not worth it (yet):
             // 'org.gradle.parallel': 'true'

bin/templates/cordova/lib/emulator.js

@@ -25,6 +25,7 @@ var Adb = require('./Adb');
 var events = require('cordova-common').events;
 var CordovaError = require('cordova-common').CordovaError;
 var android_sdk = require('./android_sdk');
+var check_reqs = require('./check_reqs');
 var which = require('which');
 
 // constants
@@ -98,6 +99,48 @@ module.exports.list_images_using_avdmanager = function () {
     });
 };
 
+module.exports.list_images_using_android = function () {
+    return execa('android', ['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(/\(API\slevel\s/) || (response[i + 2] && response[i + 2].match(/\(API\slevel\s/))) {
+                    i++;
+                    var secondLine = response[i + 1].match(/\(API\slevel\s/) ? response[i + 1] : '';
+                    img_obj.target = (response[i] + secondLine).split('Target: ')[1].replace('\r', '');
+                }
+                if (response[i + 1].match(/ABI:\s/)) {
+                    i++;
+                    img_obj.abi = response[i].split('ABI: ')[1].replace('\r', '');
+                }
+                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
  * {
@@ -113,8 +156,10 @@ module.exports.list_images = function () {
     return Promise.resolve().then(function () {
         if (forgivingWhichSync('avdmanager')) {
             return module.exports.list_images_using_avdmanager();
+        } else if (forgivingWhichSync('android')) {
+            return module.exports.list_images_using_android();
         } else {
-            return Promise.reject(new CordovaError('Could not find `avdmanager` on your $PATH! Are you sure the Android SDK is installed and available?'));
+            return Promise.reject(new CordovaError('Could not find either `android` or `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.
@@ -134,19 +179,18 @@ module.exports.list_images = function () {
 };
 
 /**
- * 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
+ * Will return the closest avd to the projects target
  * or undefined if no avds exist.
+ * Returns a promise.
  */
-module.exports.best_image = function (project_target) {
+module.exports.best_image = function () {
     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];
+        var project_target = parseInt(check_reqs.get_target().replace('android-', ''));
         for (var i in images) {
             var target = images[i].target;
             if (target && target.indexOf('API level') > -1) {
@@ -189,19 +233,32 @@ module.exports.get_available_port = function () {
 /*
  * Starts an emulator with the given ID,
  * and returns the started ID of that emulator.
+ * If no ID is given it will use the first image available,
+ * if no image is available it will error out (maybe create one?).
  * 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) {
+module.exports.start = function (emulator_ID, boot_timeout) {
     var self = this;
 
     return Promise.resolve().then(function () {
-        if (!emulatorId) {
-            throw new CordovaError('No emulator ID given');
-        }
+        if (emulator_ID) return Promise.resolve(emulator_ID);
 
+        return self.best_image().then(function (best) {
+            if (best && best.name) {
+                events.emit('warn', 'No emulator specified, defaulting to ' + best.name);
+                return best.name;
+            }
+
+            var androidCmd = check_reqs.getAbsoluteAndroidCmd();
+            return Promise.reject(new CordovaError('No emulator images (avds) found.\n' +
+                '1. Download desired System Image by running: ' + androidCmd + ' sdk\n' +
+                '2. Create an AVD by running: ' + androidCmd + ' avd\n' +
+                'HINT: For a faster emulator, use an Intel System Image and install the HAXM device driver\n'));
+        });
+    }).then(function (emulatorId) {
         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

bin/templates/cordova/lib/env/java.js

@@ -41,9 +41,9 @@ const java = {
         await java._ensure(process.env);
 
         // Java <= 8 writes version info to stderr, Java >= 9 to stdout
-        let javacOutput;
+        let version = null;
         try {
-            javacOutput = (await execa('javac', ['-version'], { all: true })).all;
+            version = (await execa('javac', ['-version'], { all: true })).all;
         } catch (ex) {
             events.emit('verbose', ex.shortMessage);
 
@@ -58,11 +58,7 @@ const java = {
             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]);
+        return semver.coerce(version);
     },
 
     /**
@@ -76,15 +72,14 @@ const java = {
             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;
+        const javacPath = utils.forgivingWhichSync('javac');
+        const hasJavaHome = !!environment.JAVA_HOME;
+        if (hasJavaHome) {
+            // Windows java installer doesn't add javac to PATH, nor set JAVA_HOME (ugh).
+            if (!javacPath) {
+                environment.PATH += path.delimiter + path.join(environment.JAVA_HOME, 'bin');
+            }
         } else {
-            const javacPath = utils.forgivingWhichSync('javac');
             if (javacPath) {
                 // OS X has a command for finding JAVA_HOME.
                 const find_java = '/usr/libexec/java_home';

bin/templates/cordova/lib/getASPath.bat

@@ -0,0 +1,3 @@
+@ECHO OFF
+for /f "tokens=2*" %%a in ('REG QUERY "HKEY_LOCAL_MACHINE\SOFTWARE\Android Studio" /v Path') do set "ASPath=%%~b"
+ECHO %ASPath%

bin/templates/cordova/lib/install-device

@@ -0,0 +1,39 @@
+#!/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 { resolve, install } = require('./target');
+
+var args = process.argv;
+const targetSpec = { type: 'device' };
+
+if (args.length > 2) {
+    if (args[2].substring(0, 9) === '--target=') {
+        targetSpec.id = args[2].substring(9, args[2].length);
+    } else {
+        console.error('ERROR : argument \'' + args[2] + '\' not recognized.');
+        process.exit(2);
+    }
+}
+
+resolve(targetSpec).then(install).catch(err => {
+    console.error('ERROR: ' + err);
+    process.exit(2);
+});

bin/templates/cordova/lib/install-device.bat

@@ -0,0 +1,26 @@
+:: 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
+SET script_path="%~dp0install-device"
+IF EXIST %script_path% (
+        node %script_path% %*
+) ELSE (
+    ECHO.
+    ECHO ERROR: Could not find 'install-device' script in 'cordova\lib' folder, aborting...>&2
+    EXIT /B 1
+)

bin/templates/cordova/lib/install-emulator

@@ -0,0 +1,39 @@
+#!/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 { resolve, install } = require('./target');
+
+var args = process.argv;
+const targetSpec = { type: 'emulator' };
+
+if (args.length > 2) {
+    if (args[2].substring(0, 9) === '--target=') {
+        targetSpec.id = args[2].substring(9, args[2].length);
+    } else {
+        console.error('ERROR : argument \'' + args[2] + '\' not recognized.');
+        process.exit(2);
+    }
+}
+
+resolve(targetSpec).then(install).catch(err => {
+    console.error('ERROR: ' + err);
+    process.exit(2);
+});

bin/templates/cordova/lib/install-emulator.bat

@@ -0,0 +1,26 @@
+:: 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
+SET script_path="%~dp0install-emulator"
+IF EXIST %script_path% (
+        node %script_path% %*
+) ELSE (
+    ECHO.
+    ECHO ERROR: Could not find 'install-emulator' script in 'cordova\lib' folder, aborting...>&2
+    EXIT /B 1
+)

bin/templates/cordova/lib/list-devices

@@ -19,10 +19,10 @@
        under the License.
 */
 
-const { list } = require('cordova-android/lib/target');
+const { list } = require('./target');
 
 // Usage support for when args are given
-require('cordova-android/lib/check_reqs').check_android().then(function () {
+require('./check_reqs').check_android().then(function () {
     list().then(targets => {
         const deviceIds = targets
             .filter(({ type }) => type === 'device')

bin/templates/cordova/lib/list-devices.bat

@@ -0,0 +1,26 @@
+:: 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
+SET script_path="%~dp0list-devices"
+IF EXIST %script_path% (
+        node %script_path% %*
+) ELSE (
+    ECHO.
+    ECHO ERROR: Could not find 'list-devices' script in 'cordova\lib' folder, aborting...>&2
+    EXIT /B 1
+)

bin/templates/cordova/lib/list-emulator-images

@@ -19,10 +19,10 @@
        under the License.
 */
 
-var emulators = require('cordova-android/lib/emulator');
+var emulators = require('./emulator');
 
 // Usage support for when args are given
-require('cordova-android/lib/check_reqs').check_android().then(function () {
+require('./check_reqs').check_android().then(function () {
     emulators.list_images().then(function (emulator_list) {
         emulator_list && emulator_list.forEach(function (emu) {
             console.log(emu.name);

bin/templates/cordova/lib/list-emulator-images.bat

@@ -0,0 +1,26 @@
+:: 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
+SET script_path="%~dp0list-emulator-images"
+IF EXIST %script_path% (
+        node %script_path% %*
+) ELSE (
+    ECHO.
+    ECHO ERROR: Could not find 'list-emulator-images' script in 'cordova\lib' folder, aborting...>&2
+    EXIT /B 1
+)

bin/templates/cordova/lib/list-started-emulators

@@ -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('./emulator');
+
+// Usage support for when args are given
+require('./check_reqs').check_android().then(function () {
+    emulators.list_started().then(function (emulator_list) {
+        emulator_list && emulator_list.forEach(function (emu) {
+            console.log(emu);
+        });
+    }, function (err) {
+        console.error('ERROR: ' + err);
+        process.exit(2);
+    });
+});

bin/templates/cordova/lib/list-started-emulators.bat

@@ -0,0 +1,26 @@
+:: 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
+SET script_path="%~dp0list-started-emulators"
+IF EXIST %script_path% (
+        node %script_path% %*
+) ELSE (
+    ECHO.
+    ECHO ERROR: Could not find 'list-started-emulators' script in 'cordova\lib' folder, aborting...>&2
+    EXIT /B 1
+)

bin/templates/cordova/lib/log.js

@@ -0,0 +1,45 @@
+/*
+       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 os = require('os');
+var execa = require('execa');
+var ROOT = path.join(__dirname, '..', '..');
+
+/*
+ * Starts running logcat in the shell.
+ * Returns a promise.
+ */
+module.exports.run = function () {
+    var adb = execa('adb', ['logcat'], { cwd: os.tmpdir(), stderr: 'inherit' });
+
+    adb.stdout.on('data', function (data) {
+        var lines = data ? data.toString().split('\n') : [];
+        var out = lines.filter(function (x) { return x.indexOf('nativeGetEnabledTags') < 0; });
+        console.log(out.join('\n'));
+    });
+
+    return adb;
+};
+
+module.exports.help = function () {
+    console.log('Usage: ' + path.relative(process.cwd(), path.join(ROOT, 'cordova', 'log')));
+    console.log('Gives the logcat output on the command line.');
+    process.exit(0);
+};

bin/templates/cordova/lib/plugin-build.gradle

@@ -21,7 +21,7 @@
 buildscript {
     repositories {
         google()
-        mavenCentral()
+        jcenter()
     }
 
     // Switch the Android Gradle plugin version requirement depending on the
@@ -42,8 +42,8 @@ dependencies {
 }
 
 android {
-    compileSdkVersion cordovaConfig.SDK_VERSION
-    buildToolsVersion cordovaConfig.BUILD_TOOLS_VERSION
+    compileSdkVersion cdvCompileSdkVersion
+    buildToolsVersion cdvBuildToolsVersion
 
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_1_6

bin/templates/cordova/lib/prepare.js

@@ -32,7 +32,6 @@ 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');
 
@@ -56,11 +55,31 @@ module.exports.prepare = function (cordovaProject, options) {
 
     this._config = updateConfigFilesFrom(cordovaProject.projectConfig, munger, this.locations);
 
-    // Update Gradle cdv-gradle-config.json
-    updateUserProjectGradleConfig(this);
+    // Get the min SDK version from config.xml
+    const minSdkVersion = this._config.getPreference('android-minSdkVersion', 'android');
+    const maxSdkVersion = this._config.getPreference('android-maxSdkVersion', 'android');
+    const targetSdkVersion = this._config.getPreference('android-targetSdkVersion', 'android');
+    const androidXEnabled = this._config.getPreference('AndroidXEnabled', 'android');
+    const isGradlePluginKotlinEnabled = this._config.getPreference('GradlePluginKotlinEnabled', 'android');
+    const gradlePluginKotlinCodeStyle = this._config.getPreference('GradlePluginKotlinCodeStyle', 'android');
 
-    // Update Project's Gradle Properties
-    updateUserProjectGradlePropertiesConfig(this, args);
+    const gradlePropertiesUserConfig = {};
+    if (minSdkVersion) gradlePropertiesUserConfig.cdvMinSdkVersion = minSdkVersion;
+    if (maxSdkVersion) gradlePropertiesUserConfig.cdvMaxSdkVersion = maxSdkVersion;
+    if (targetSdkVersion) gradlePropertiesUserConfig.cdvTargetSdkVersion = targetSdkVersion;
+    if (args.jvmargs) gradlePropertiesUserConfig['org.gradle.jvmargs'] = args.jvmargs;
+    if (isGradlePluginKotlinEnabled) {
+        gradlePropertiesUserConfig['kotlin.code.style'] = gradlePluginKotlinCodeStyle || 'official';
+    }
+
+    // Both 'useAndroidX' and 'enableJetifier' are linked together.
+    if (androidXEnabled) {
+        gradlePropertiesUserConfig['android.useAndroidX'] = androidXEnabled;
+        gradlePropertiesUserConfig['android.enableJetifier'] = androidXEnabled;
+    }
+
+    const gradlePropertiesParser = new GradlePropertiesParser(this.locations.root);
+    gradlePropertiesParser.configure(gradlePropertiesUserConfig);
 
     // Update own www dir with project's www assets and plugins' assets and js-files
     return Promise.resolve(updateWww(cordovaProject, this.locations)).then(function () {
@@ -75,77 +94,6 @@ module.exports.prepare = function (cordovaProject, options) {
     });
 };
 
-/** @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
@@ -382,13 +330,10 @@ function makeSplashCleanupMap (projectRoot, resourcesDir) {
 function updateSplashes (cordovaProject, platformResourcesDir) {
     var resources = cordovaProject.projectConfig.getSplashScreens('android');
 
-    // if there are no "splash" elements in config.xml
+    // if there are "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.
+        return;
     }
 
     // Build an initial resource map that deletes all existing splash screens

bin/templates/cordova/lib/run.js

@@ -0,0 +1,99 @@
+/*
+       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 emulator = require('./emulator');
+const target = require('./target');
+var PackageType = require('./PackageType');
+const { 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 = function (runOptions) {
+    runOptions = runOptions || {};
+
+    var self = this;
+    const spec = buildTargetSpec(runOptions);
+
+    return target.resolve(spec).then(function (resolvedTarget) {
+        events.emit('log', `Deploying to ${formatResolvedTarget(resolvedTarget)}`);
+
+        return new Promise((resolve) => {
+            const buildOptions = require('./build').parseBuildOptions(runOptions, null, self.root);
+
+            // Android app bundles cannot be deployed directly to the device
+            if (buildOptions.packageType === PackageType.BUNDLE) {
+                const packageTypeErrorMessage = 'Package type "bundle" is not supported during cordova run.';
+                events.emit('error', packageTypeErrorMessage);
+                throw packageTypeErrorMessage;
+            }
+
+            resolve(self._builder.fetchBuildResults(buildOptions.buildType, buildOptions.arch));
+        }).then(async function (buildResults) {
+            if (resolvedTarget.type === 'emulator') {
+                await emulator.wait_for_boot(resolvedTarget.id);
+            }
+
+            return target.install(resolvedTarget, buildResults);
+        });
+    });
+};
+
+module.exports.help = function () {
+    console.log('Usage: ' + path.relative(process.cwd(), process.argv[1]) + ' [options]');
+    console.log('Build options :');
+    console.log('    --debug : Builds project in debug mode');
+    console.log('    --release : Builds project in release mode');
+    console.log('    --nobuild : Runs the currently built project without recompiling');
+    console.log('Deploy options :');
+    console.log('    --device : Will deploy the built project to a device');
+    console.log('    --emulator : Will deploy the built project to an emulator if one exists');
+    console.log('    --target=<target_id> : Installs to the target with the specified id.');
+    process.exit(0);
+};

bin/templates/cordova/lib/start-emulator

@@ -0,0 +1,38 @@
+#!/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 emulator = require('./emulator');
+var args = process.argv;
+
+var install_target;
+if (args.length > 2) {
+    if (args[2].substring(0, 9) === '--target=') {
+        install_target = args[2].substring(9, args[2].length);
+    } else {
+        console.error('ERROR : argument \'' + args[2] + '\' not recognized.');
+        process.exit(2);
+    }
+}
+
+emulator.start(install_target).catch(function (err) {
+    console.error('ERROR: ' + err);
+    process.exit(2);
+});

bin/templates/cordova/lib/start-emulator.bat

@@ -0,0 +1,26 @@
+:: 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
+SET script_path="%~dp0start-emulator"
+IF EXIST %script_path% (
+        node %script_path% %*
+) ELSE (
+    ECHO.
+    ECHO ERROR: Could not find 'start-emulator' script in 'cordova\lib' folder, aborting...>&2
+    EXIT /B 1
+)

bin/templates/cordova/lib/target.js

@@ -17,11 +17,12 @@
        under the License.
 */
 
+const path = require('path');
 const { inspect } = require('util');
-const execa = require('execa');
 const Adb = require('./Adb');
 const build = require('./build');
 const emulator = require('./emulator');
+const AndroidManifest = require('./AndroidManifest');
 const { compareBy } = require('./utils');
 const { retryPromise } = require('./retry');
 const { events, CordovaError } = require('cordova-common');
@@ -34,7 +35,6 @@ 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
  */
 
 /**
@@ -73,49 +73,30 @@ async function isEmulatorName (name) {
 }
 
 /**
- * @param {TargetSpec} spec
- * @param {BuildResults} buildResults
+ * @param {TargetSpec?} spec
  * @return {Promise<Target>}
  */
-async function resolveToOfflineEmulator ({ id: avdName, type }, { apkPaths }) {
-    if (type === 'device') return null;
+async function resolveToOfflineEmulator (spec = {}) {
+    if (spec.type === 'device') return null;
+    if (spec.id && !(await isEmulatorName(spec.id))) 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);
+    // try to start an emulator with name spec.id
+    // if spec.id is undefined, picks best match regarding target API
+    const emulatorId = await emulator.start(spec.id);
 
     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<Target & {arch: string}>}
  */
-exports.resolve = async (spec, buildResults) => {
+exports.resolve = async (spec = {}) => {
     events.emit('verbose', `Trying to find target matching ${inspect(spec)}`);
 
     const resolvedTarget =
         (await resolveToOnlineTarget(spec)) ||
-        (await resolveToOfflineEmulator(spec, buildResults));
+        (await resolveToOfflineEmulator(spec));
 
     if (!resolvedTarget) {
         throw new CordovaError(`Could not find target matching ${inspect(spec)}`);
@@ -127,8 +108,9 @@ exports.resolve = async (spec, buildResults) => {
     };
 };
 
-exports.install = async function ({ id: target, arch, type }, { manifest, buildResults }) {
+exports.install = async function ({ id: target, arch, type }, buildResults) {
     const apk_path = build.findBestApkForArchitecture(buildResults, arch);
+    const manifest = new AndroidManifest(path.join(__dirname, '../../app/src/main/AndroidManifest.xml'));
     const pkgName = manifest.getPackageId();
     const launchName = pkgName + '/.' + manifest.getActivity().getName();
 

bin/templates/cordova/log

@@ -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.
+*/
+
+var log = require('./lib/log');
+var reqs = require('./lib/check_reqs');
+var args = process.argv;
+
+// Usage support for when args are given
+if (args.length > 2) {
+    log.help();
+} else {
+    reqs.run().then(function () {
+        return log.run();
+    }, function (err) {
+        console.error('ERROR: ' + err);
+        process.exit(2);
+    });
+}

bin/templates/cordova/log.bat

@@ -0,0 +1,26 @@
+:: 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
+SET script_path="%~dp0log"
+IF EXIST %script_path% (
+        node %script_path% %*
+) ELSE (
+    ECHO.
+    ECHO ERROR: Could not find 'log' script in 'cordova' folder, aborting...>&2
+    EXIT /B 1
+)

bin/templates/cordova/loggingHelper.js

@@ -0,0 +1,18 @@
+var CordovaLogger = require('cordova-common').CordovaLogger;
+
+module.exports = {
+    adjustLoggerLevel: function (opts) {
+        if (opts instanceof Array) {
+            opts.silent = opts.indexOf('--silent') !== -1;
+            opts.verbose = opts.indexOf('--verbose') !== -1;
+        }
+
+        if (opts.silent) {
+            CordovaLogger.get().setLevel('error');
+        }
+
+        if (opts.verbose) {
+            CordovaLogger.get().setLevel('verbose');
+        }
+    }
+};

bin/templates/cordova/run

@@ -0,0 +1,54 @@
+#!/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 Api = require('./Api');
+var nopt = require('nopt');
+var path = require('path');
+
+// Support basic help commands
+if (['--help', '/?', '-h', 'help', '-help', '/help'].indexOf(process.argv[2]) >= 0) {
+    require('./lib/run').help();
+}
+
+// Do some basic argument parsing
+var runOpts = nopt({
+    verbose: Boolean,
+    silent: Boolean,
+    debug: Boolean,
+    release: Boolean,
+    nobuild: Boolean,
+    buildConfig: path,
+    archs: String,
+    device: Boolean,
+    emulator: Boolean,
+    target: String
+}, { d: '--verbose' });
+
+// Make runOptions compatible with PlatformApi run method spec
+runOpts.argv = runOpts.argv.remain;
+
+require('./loggingHelper').adjustLoggerLevel(runOpts);
+
+new Api().run(runOpts)
+    .catch(function (err) {
+        console.error(err, err.stack);
+        process.exit(2);
+    });

bin/templates/cordova/run.bat

@@ -0,0 +1,26 @@
+:: 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
+SET script_path="%~dp0run"
+IF EXIST %script_path% (
+        node %script_path% %*
+) ELSE (
+    ECHO.
+    ECHO ERROR: Could not find 'run' script in 'cordova' folder, aborting...>&2
+    EXIT /B 1
+)

bin/templates/cordova/version.bat

@@ -0,0 +1,26 @@
+:: 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
+SET script_path="%~dp0version"
+IF EXIST %script_path% (
+        node %script_path% %*
+) ELSE (
+    ECHO.
+    ECHO ERROR: Could not find 'version' script in 'cordova' folder, aborting...>&2
+    EXIT /B 1
+)

bin/templates/project/AndroidManifest.xml

@@ -35,7 +35,7 @@
         <activity android:name="__ACTIVITY__"
                 android:label="@string/activity_name"
                 android:launchMode="singleTop"
-                android:theme="@style/Theme.AppCompat.NoActionBar"
+                android:theme="@android:style/Theme.DeviceDefault.NoActionBar"
                 android:windowSoftInputMode="adjustResize"
                 android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|smallestScreenSize|screenLayout|uiMode">
             <intent-filter android:label="@string/launcher_name">

bin/templates/project/app/build.gradle

@@ -19,7 +19,7 @@
 
 apply plugin: 'com.android.application'
 
-if (cordovaConfig.IS_GRADLE_PLUGIN_KOTLIN_ENABLED) {
+if (cdvHelpers.getConfigPreference('GradlePluginKotlinEnabled', 'false').toBoolean()) {
     apply plugin: 'kotlin-android'
     apply plugin: 'kotlin-android-extensions'
 }
@@ -27,31 +27,50 @@ if (cordovaConfig.IS_GRADLE_PLUGIN_KOTLIN_ENABLED) {
 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.")
+    if(cdvHelpers.getConfigPreference('GradlePluginKotlinEnabled', 'false').toBoolean()) {
+        String defaultGradlePluginKotlinVersion = kotlin_version
+
+        /**
+         * Fetches the user's defined Kotlin Version from config.xml.
+         * If the version is not set or invalid, it will default to the ${defaultGradlePluginKotlinVersion}
+         */
+        String gradlePluginKotlinVersion = cdvHelpers.getConfigPreference('GradlePluginKotlinVersion', defaultGradlePluginKotlinVersion)
+        if(!cdvHelpers.isVersionValid(gradlePluginKotlinVersion)) {
+            println("The defined Kotlin version (${gradlePluginKotlinVersion}) does not appear to be a valid version. Falling back to version: ${defaultGradlePluginKotlinVersion}.")
+            gradlePluginKotlinVersion = defaultGradlePluginKotlinVersion
         }
+
+        // Change the version to be used.
+        ext.kotlin_version = gradlePluginKotlinVersion
     }
 
     apply from: 'repositories.gradle'
     repositories repos
 
     dependencies {
-        classpath "com.android.tools.build:gradle:${cordovaConfig.AGP_VERSION}"
+        apply from: '../CordovaLib/cordova.gradle'
 
-        if (cordovaConfig.IS_GRADLE_PLUGIN_KOTLIN_ENABLED) {
-            classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${cordovaConfig.KOTLIN_VERSION}"
+        classpath 'com.android.tools.build:gradle:4.0.0'
+
+        if (cdvHelpers.getConfigPreference('GradlePluginKotlinEnabled', 'false').toBoolean()) {
+            classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$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.")
+        if(cdvHelpers.getConfigPreference('GradlePluginGoogleServicesEnabled', 'false').toBoolean()) {
+            String defaultGradlePluginGoogleServicesVersion = '4.2.0'
+
+            /**
+             * Fetches the user's defined Google Services Plugin Version from config.xml.
+             * If the version is not set or invalid, it will default to the ${defaultGradlePluginGoogleServicesVersion}
+             */
+            String gradlePluginGoogleServicesVersion = cdvHelpers.getConfigPreference('GradlePluginGoogleServicesVersion', defaultGradlePluginGoogleServicesVersion)
+            if(!cdvHelpers.isVersionValid(gradlePluginGoogleServicesVersion)) {
+                println("The defined Google Services plugin version (${gradlePluginGoogleServicesVersion}) does not appear to be a valid version. Falling back to version: ${defaultGradlePluginGoogleServicesVersion}.")
+                gradlePluginGoogleServicesVersion = defaultGradlePluginGoogleServicesVersion
             }
 
             // Create the Google Services classpath and set it.
-            String gradlePluginGoogleServicesClassPath = "com.google.gms:google-services:${cordovaConfig.GRADLE_PLUGIN_GOOGLE_SERVICES_VERSION}"
+            String gradlePluginGoogleServicesClassPath = "com.google.gms:google-services:${gradlePluginGoogleServicesVersion}"
             println "Adding classpath: ${gradlePluginGoogleServicesClassPath}"
             classpath gradlePluginGoogleServicesClassPath
         }
@@ -60,18 +79,12 @@ buildscript {
 
 // 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"
-    }
-
+    apply from: 'repositories.gradle'
     repositories repos
 }
 
 task wrapper(type: Wrapper) {
-    gradleVersion = cordovaConfig.GRADLE_VERSION
+    gradleVersion = '6.5'
 }
 
 // Configuration properties. Set these via environment variables, build-extras.gradle, or gradle.properties.
@@ -79,10 +92,30 @@ task wrapper(type: Wrapper) {
 ext {
     apply from: '../CordovaLib/cordova.gradle'
 
+    // The value for android.compileSdkVersion.
+    if (!project.hasProperty('cdvCompileSdkVersion')) {
+        cdvCompileSdkVersion = null;
+    }
+    // The value for android.buildToolsVersion.
+    if (!project.hasProperty('cdvBuildToolsVersion')) {
+        cdvBuildToolsVersion = null;
+    }
     // Sets the versionCode to the given value.
     if (!project.hasProperty('cdvVersionCode')) {
         cdvVersionCode = null
     }
+    // Sets the minSdkVersion to the given value.
+    if (!project.hasProperty('cdvMinSdkVersion')) {
+        cdvMinSdkVersion = null
+    }
+    // Sets the maxSdkVersion to the given value.
+    if (!project.hasProperty('cdvMaxSdkVersion')) {
+        cdvMaxSdkVersion = null
+    }
+    // The value for android.targetSdkVersion.
+    if (!project.hasProperty('cdvTargetSdkVersion')) {
+        cdvTargetSdkVersion = null;
+    }
     // Whether to build architecture-specific APKs.
     if (!project.hasProperty('cdvBuildMultipleApks')) {
         cdvBuildMultipleApks = null
@@ -121,10 +154,17 @@ if (hasBuildExtras2) {
     apply from: '../build-extras.gradle'
 }
 
-// Apply updates that might come from build-extra.
-privateHelpers.applyCordovaConfigCustomization()
-
 // Set property defaults after extension .gradle files.
+ext.cdvCompileSdkVersion = cdvCompileSdkVersion == null ? (
+    defaultCompileSdkVersion == null
+        ? privateHelpers.getProjectTarget()
+        : defaultCompileSdkVersion
+) : Integer.parseInt('' + cdvCompileSdkVersion);
+
+if (ext.cdvBuildToolsVersion == null) {
+    ext.cdvBuildToolsVersion = privateHelpers.findLatestInstalledBuildTools()
+    //ext.cdvBuildToolsVersion = project.ext.defaultBuildToolsVersion
+}
 if (ext.cdvDebugSigningPropertiesFile == null && file('../debug-signing.properties').exists()) {
     ext.cdvDebugSigningPropertiesFile = '../debug-signing.properties'
 }
@@ -135,6 +175,14 @@ if (ext.cdvReleaseSigningPropertiesFile == null && file('../release-signing.prop
 // Cast to appropriate types.
 ext.cdvBuildMultipleApks = cdvBuildMultipleApks == null ? false : cdvBuildMultipleApks.toBoolean();
 ext.cdvVersionCodeForceAbiDigit = cdvVersionCodeForceAbiDigit == null ? false : cdvVersionCodeForceAbiDigit.toBoolean();
+
+// minSdkVersion, maxSdkVersion and targetSdkVersion
+ext.cdvMinSdkVersion = cdvMinSdkVersion == null ? defaultMinSdkVersion : Integer.parseInt('' + cdvMinSdkVersion)
+if (cdvMaxSdkVersion != null) {
+    ext.cdvMaxSdkVersion = Integer.parseInt('' + cdvMaxSdkVersion)
+}
+ext.cdvTargetSdkVersion = cdvTargetSdkVersion == null ? defaultTargetSdkVersion  : Integer.parseInt('' + cdvTargetSdkVersion)
+
 ext.cdvVersionCode = cdvVersionCode == null ? null : Integer.parseInt('' + cdvVersionCode)
 
 def computeBuildTargetName(debugBuild) {
@@ -159,19 +207,18 @@ cdvBuildRelease.dependsOn {
 
 task cdvPrintProps {
     doLast {
+        println('cdvCompileSdkVersion=' + cdvCompileSdkVersion)
         println('cdvBuildToolsVersion=' + cdvBuildToolsVersion)
         println('cdvVersionCode=' + cdvVersionCode)
         println('cdvVersionCodeForceAbiDigit=' + cdvVersionCodeForceAbiDigit)
-        println('cdvSdkVersion=' + cdvSdkVersion)
         println('cdvMinSdkVersion=' + cdvMinSdkVersion)
         println('cdvMaxSdkVersion=' + cdvMaxSdkVersion)
+        println('cdvTargetSdkVersion=' + cdvTargetSdkVersion)
         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)
         }
@@ -183,19 +230,25 @@ android {
         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
+        if (cdvMinSdkVersion != null) {
+            minSdkVersion cdvMinSdkVersion
+        }
+
+        if (cdvMaxSdkVersion != null) {
+            maxSdkVersion cdvMaxSdkVersion
+        }
+
+        if(cdvTargetSdkVersion != null) {
+            targetSdkVersion cdvTargetSdkVersion
         }
-        targetSdkVersion cordovaConfig.SDK_VERSION
-        compileSdkVersion cordovaConfig.SDK_VERSION
     }
 
     lintOptions {
-      abortOnError false
+      abortOnError false;
     }
 
-    buildToolsVersion cordovaConfig.BUILD_TOOLS_VERSION
+    compileSdkVersion cdvCompileSdkVersion
+    buildToolsVersion cdvBuildToolsVersion
 
     // This code exists for Crosswalk and other Native APIs.
     // By default, we multiply the existing version code in the
@@ -255,9 +308,9 @@ android {
             release {
                 // These must be set or Gradle will complain (even if they are overridden).
                 keyAlias = ""
-                keyPassword = ""
+                keyPassword = "__unset" // And these must be set to non-empty in order to have the signing step added to the task graph.
                 storeFile = null
-                storePassword = ""
+                storePassword = "__unset"
             }
         }
         buildTypes {
@@ -286,10 +339,9 @@ android {
 
 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}"
+    if (cdvHelpers.getConfigPreference('GradlePluginKotlinEnabled', 'false').toBoolean()) {
+        implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     }
 
     // SUB-PROJECT DEPENDENCIES START
@@ -298,6 +350,26 @@ dependencies {
     // SUB-PROJECT DEPENDENCIES END
 }
 
+def promptForReleaseKeyPassword() {
+    if (!cdvReleaseSigningPropertiesFile) {
+        return;
+    }
+    if ('__unset'.equals(android.signingConfigs.release.storePassword)) {
+        android.signingConfigs.release.storePassword = privateHelpers.promptForPassword('Enter key store password: ')
+    }
+    if ('__unset'.equals(android.signingConfigs.release.keyPassword)) {
+        android.signingConfigs.release.keyPassword = privateHelpers.promptForPassword('Enter key password: ');
+    }
+}
+
+gradle.taskGraph.whenReady { taskGraph ->
+    taskGraph.getAllTasks().each() { task ->
+      if(['validateReleaseSigning', 'validateSigningRelease', 'validateSigningArmv7Release', 'validateSigningX76Release'].contains(task.name)) {
+         promptForReleaseKeyPassword()
+      }
+    }
+}
+
 def addSigningProps(propsFilePath, signingConfig) {
     def propsFile = file(propsFilePath)
     def props = new Properties()
@@ -318,7 +390,7 @@ def addSigningProps(propsFilePath, signingConfig) {
     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()
+        def filename = storeFile.getName().toLowerCase();
         if (filename.endsWith('.p12') || filename.endsWith('.pfx')) {
             storeType = 'pkcs12'
         } else {
@@ -338,6 +410,6 @@ if (hasProperty('postBuildExtras')) {
     postBuildExtras()
 }
 
-if (cordovaConfig.IS_GRADLE_PLUGIN_GOOGLE_SERVICES_ENABLED) {
+if (cdvHelpers.getConfigPreference('GradlePluginGoogleServicesEnabled', 'false').toBoolean()) {
     apply plugin: 'com.google.gms.google-services'
 }

bin/templates/project/app/repositories.gradle

@@ -17,6 +17,7 @@
 */
 
 ext.repos = {
-    google()
     mavenCentral()
+    google()
+    jcenter()
 }

bin/templates/project/assets/www/index.html

@@ -21,7 +21,7 @@
     <head>
         <!--
         Customize this policy to fit your own app's needs. For more guidance, see:
-            https://cordova.apache.org/docs/en/latest/
+            https://github.com/apache/cordova-plugin-whitelist/blob/master/README.md#content-security-policy
         Some notes:
             * gap: is required only on iOS (when using UIWebView) and is needed for JS->native communication
             * https://ssl.gstatic.com is required only on Android and is needed for TalkBack to function properly

bin/templates/project/build.gradle

@@ -0,0 +1,49 @@
+/* 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.
+*/
+
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    ext.kotlin_version = '1.3.50'
+    apply from: 'repositories.gradle'
+    repositories repos
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:4.0.0'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    apply from: 'repositories.gradle'
+    repositories repos
+
+    //This replaces project.properties w.r.t. build settings
+    project.ext {
+      defaultBuildToolsVersion="29.0.2" //String
+      defaultMinSdkVersion=22 //Integer - Minimum requirement is Android 5.1
+      defaultTargetSdkVersion=29 //Integer - We ALWAYS target the latest by default
+      defaultCompileSdkVersion=29 //Integer - We ALWAYS compile with the latest by default
+    }
+}
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}

bin/templates/project/repositories.gradle

@@ -18,5 +18,5 @@
 
 ext.repos = {
     google()
-    mavenCentral()
+    jcenter()
 }