Update .gitignore to ignore /framework/build and /node_modules

Keep track of the last AlertDialog showed.
The last dialog showed that is rendered while hitting back button it
causes a leaked window.
Instead of perform a full track of all dialogs created, only destroy the
last one showed, this fixes the problem.

close #122

.gitignore

@@ -37,3 +37,6 @@ Desktop.ini
 # IntelliJ IDEA files
 *.iml
 .idea
+npm-debug.log
+/node_modules
+/framework/build

.travis.yml

@@ -0,0 +1,5 @@
+language: android
+install: npm install
+script:
+    - npm test
+    - npm run test-build

RELEASENOTES.md

@@ -20,6 +20,146 @@
 -->
 ## Release Notes for Cordova (Android) ##
 
+### 3.6.4 (Sept 30, 2014) ###
+
+* Set VERSION to 3.6.4 (via coho)
+* Update JS snapshot to version 3.6.4 (via coho)
+* CB-7634 Detect JAVA_HOME properly on Ubuntu
+* CB-7579 Fix run script's ability to use non-arch-specific APKs
+* CB-6511 Fixes build for android when app name contains unicode characters.
+* CB-7463: Adding licences.  I don't know what the gradle syntax is for comments, that still needs to be done.
+* CB-7463: Looked at the Apache BigTop git, gradle uses C-style comments
+* CB-7460: Fixing bug with KitKat where the background colour would override the CSS colours on the application
+
+### 3.6.0 (Sept 2014) ###
+
+* Set VERSION to 3.6.0 (via coho)
+* CB-7410 fix the menu test
+* CB-7410 Fix the errorUrl test
+* CB-7410 Fix Basic Authentication test
+* CB-3445: Allow build and run scripts to select APK by architecture
+* CB-3445: Add environment variable 'BUILD_MULTIPLE_APKS' for splitting APKs based on architecture
+* CB-3445: Ensure that JAR files in libs directory are included
+* CB-7267 update RELEASENOTES for 3.5.1
+* CB-7410 clarify the title
+* CB-7385 update cordova.js for testing prior to branch/tag
+* CB-7410 add whitelist entries to get iframe/GoogleMaps working
+* CB-7291 propogate change in method signature to the native tests
+* CB-7291: Restrict meaning of "\*" in internal whitelist to just http and https
+* CB-7291: Only add file, content and data URLs to internal whitelist
+* CB-7291: Add defaults to external whitelist
+* CB-7291: Add external-launch-whitelist and use it for filtering intent launches
+* CB-3445: Read project.properties to configure gradle libraries
+* CB-7325 Fix error message in android_sdk_version.js when missing SDK on windows
+* CB-7335 Add a .gitignore to android project template
+* CB-7330 Fix dangling function call in last commit (broke gradle builds)
+* CB-7330 Don't run "android update" during creation
+* CB-3445 Add gradle support clean command (plus some code cleanup)
+* CB-7044 Fix typo in prev commit causing check_reqs to always fail.
+* CB-3445 Copy gradle wrapper in build instead of create
+* CB-3445 Add .gradle template files for "update" as well as "create"
+* CB-7044 Add JAVA_HOME when not set. Be stricter about ANDROID_HOME
+* CB-3445 Speed up gradle building (incremental builds go from 10s -> 1.5s for me)
+* CB-3445: android: Copy Gradle wrapper from Android SDK rather than bundling a JAR
+* CB-3445: Add which to checked-in node_modules
+* CB-3445: Add option to build and install with gradle
+* CB-3445: Add an initial set of Gradle build scripts
+* CB-7321 Don't require ant for create script
+* CB-7044, CB-7299 Fix up PATH problems when possible.
+* Change in test's AndroidManifest.xml needed for the test to run properly. Forgot the manifest.
+* Change in test's AndroidManifest.xml needed for the test to run properly
+* Adding tests related to 3.5.1
+* CB-7261 Fix setNativeToJsBridgeMode sometimes crashing when switching to ONLINE_EVENT
+* CB-7265 Fix crash when navigating to custom protocol (introduced in 3.5.1)
+* Filter out non-launchable intents
+* Handle unsupported protocol errors in webview better
+* CB-7238: I should have collapsed this, but Config.init() must go before the creation of CordovaWebView
+* CB-7238: Minor band-aid to get tests running again, this has to go away before 3.6.0 is released, since this is an API change.
+* Extend whitelist to handle URLs without // chars
+* CB-7172 Force window to have focus after resume
+* CB-7159 Set background color of webView as well as its parent
+* CB-7018 Fix setButtonPlumbedToJs never un-listening
+* Undeprecate some just-deprecated symbols in PluginManager.
+* @Deprecate methods of PluginManager that were never meant to be public
+* Move plugin instantiation and instance storing logic PluginEntry->PluginManager
+* Fix broken unit test due to missing Config.init() call
+* Update to check for Google Glass APIs
+* Fix for `android` not being in PATH check on Windows
+* Displaying error when regex does not match.
+* Fix broken compile due to previous commit :(
+* Tweak CordovaPlugin.initialize method to be less deprecated.
+* Un-deprecate CordovaActivity.init() - it's needed to tweak prefs in onCreate
+* Tweak log messages in CordovaBridge with bridgeSecret is wrong
+* Backport CordovaBridge from 4.0.x -> master
+* Update unit tests to not use most deprecated things (e.g. DroidGap)
+* Add non-String overloades for CordovaPreferences.set()
+* Make CordovaWebview resilient to init() not being called (for backwards-compatibility)
+* Add node_module licenses to LICENSE
+* Update cordova.js snapshot to work with bridge changes
+* Provide CordovaPlugin with CordovaPreferences. Add new Plugin.initialize()
+* Convert usages of Config.\* to use the non-static versions
+* Change getProperty -> prefs.get\* within CordovaActivity
+* Make CordovaUriHelper class package-private
+* Fix PluginManager.setPluginEntries not removing old entries
+* Move registration of App plugin from config.xml -> code
+* Make setWebViewClient an override instead of an overload. Delete Location-change JS->Native bridge mode (missed some of it).
+* CB-4404 Revert setting android:windowSoftInputMode to "adjustPan"
+* Refactor: Use ConfigXmlParser in activity. Adds CordovaWebView.init()
+* Deprecate some convenience methods on CordovaActivity
+* Fix CordovaPreferences not correctly parsing hex values (valueOf->decode)
+* Refactor: Move url-filter information into PluginEntry.
+* Don't re-parse config.xml in onResume.
+* Move handling of Fullscreen preference to CordovaActivity
+* Delete dead code from CordovaActivity
+* Update .classpath to make Eclipse happy (just re-orders one line)
+* Delete "CB-3064: The errorUrl is..." Log message left over from debugging presumably
+* Refactor Config into ConfigXmlParser, CordovaPreferences
+* Delete Location-change JS->Native bridge mode
+* CB-5988 Allow exec() only from file: or start-up URL's domain
+* CB-6761 Fix native->JS bridge ceasing to fire when page changes and online is set to false and the JS loads quickly
+* Update the errorurl to no longer use intents
+* This breaks running the JUnit tests, we'll bring it back soon
+* Refactoring the URI handling on Cordova, removing dead code
+* CB-7018 Clean up and deprecation of some button-related functions
+* CB-7017 Fix onload=true being set on all subsequent plugins
+* CB-5971: Fix package / project validation
+* CB-5971: Add unit tests to cordova-android
+* CB-5971: Factor out package/project name validation logic
+* Delete explicit activity.finish() in back button handling. No change in behaviour.
+* CB-5971: This would have been a good first bug, too bad
+* CB-4404: Changing where android:windowSoftInputMode is in the manifest so it works
+* Add documentation referencing other implementation.
+* CB-6851 Deprecate WebView.sendJavascript()
+* CB-6876 Show the correct executable name
+* CB-6876 Fix the "print usage"
+* Trivial spelling fix in comments when reading CordovaResourceApi
+* CB-6818: I want to remove this code, because Square didn't do their headers properly
+* CB-6860 Add activity_name and launcher_name to AndroidManifest.xml & strings.xml
+* Add a comment to custom_rules.xml saying why we move AndroidManifest.xml
+* Remove +x from README.md
+* CB-6784 Add missing licenses
+* CB-6784 Add license to CONTRIBUTING.md
+* Revert "defaults.xml: Add AndroidLaunchMode preference"
+* updated RELEASENOTES
+* CB-6315: Wrapping this so it runs on the UI thread
+* CB-6723 Update package name for Robotium
+* CB-6707 Update minSdkVersion to 10 consistently
+* CB-5652 make visible cordova version
+* Update JS snapshot to version 3.6.0-dev (via coho)
+* Update JS snapshot to version 3.6.0-dev (via coho)
+* Set VERSION to 3.6.0-dev (via coho)
+
+### 3.5.1 (August 2014) ###
+
+This was a security update to address CVE-2014-3500, CVE-2014-3501,
+and CVE-2014-3502. For more information, see
+http://cordova.apache.org/announcements/2014/08/04/android-351.html
+
+* Filter out non-launchable intents
+* Handle unsupported protocol errors in webview better
+* Update the errorurl to no longer use intents
+* Refactoring the URI handling on Cordova, removing dead code
+
 ### 3.5.0 (May 2014) ###
 
 * OkHttp has broken headers. Updating for ASF compliance.

VERSION

@@ -1 +1 @@
-3.6.0-dev
+3.7.0-dev

bin/lib/android_sdk_version.js

@@ -51,7 +51,7 @@ get_sdks = function() {
 
         return Q();
     }, function(stderr) {
-        if (stderr.match(/command\snot\sfound/)) {
+        if (stderr.match(/command\snot\sfound/) || stderr.match(/'android' is not recognized/)) {
             return Q.reject(new Error('The command \"android\" failed. Make sure you have the latest Android SDK installed, and the \"android\" command (inside the tools/ folder) is added to your path.'));
         } else {
             return Q.reject(new Error('An error occurred while listing Android targets'));

bin/lib/check_reqs.js

@@ -19,82 +19,212 @@
        under the License.
 */
 
-var shell = require('shelljs'),
+var shelljs = require('shelljs'),
     child_process = require('child_process'),
     Q     = require('q'),
     path  = require('path'),
     fs    = require('fs'),
+    which = require('which'),
     ROOT  = path.join(__dirname, '..', '..');
 
-// Get valid target from framework/project.properties
-module.exports.get_target = function() {
-    if(fs.existsSync(path.join(ROOT, 'framework', 'project.properties'))) {
-        var target = shell.grep(/target=android-[\d+]/, path.join(ROOT, 'framework', 'project.properties'));
-        return target.split('=')[1].replace('\n', '').replace('\r', '').replace(' ', '');
-    } else if (fs.existsSync(path.join(ROOT, 'project.properties'))) {
-        // if no target found, we're probably in a project and project.properties is in ROOT.
-        // this is called on the project itself, and can support Google APIs AND Vanilla Android
-        var target = shell.grep(/target=android-[\d+]/, path.join(ROOT, 'project.properties')) ||
-          shell.grep(/target=Google Inc.:Google APIs:[\d+]/, path.join(ROOT, 'project.properties'));
-        if(target == "" || !target) {
-          // Try Google Glass APIs
-          target = shell.grep(/target=Google Inc.:Glass Development Kit Preview:[\d+]/, path.join(ROOT, 'project.properties'));
-        }
-        return target.split('=')[1].replace('\n', '').replace('\r', '');
+var isWindows = process.platform == 'win32';
+
+function forgivingWhichSync(cmd) {
+    try {
+        return which.sync(cmd);
+    } catch (e) {
+        return '';
     }
 }
 
-// Returns a promise.
-module.exports.check_ant = function() {
+function tryCommand(cmd, errMsg) {
     var d = Q.defer();
-    child_process.exec('ant -version', function(err, stdout, stderr) {
-        if (err) d.reject(new Error('ERROR : executing command \'ant\', make sure you have ant installed and added to your path.'));
-        else d.resolve();
+    child_process.exec(cmd, function(err, stdout, stderr) {
+        if (err) d.reject(new Error(errMsg));
+        else d.resolve(stdout);
     });
     return d.promise;
 }
 
+// Get valid target from framework/project.properties
+module.exports.get_target = function() {
+    function extractFromFile(filePath) {
+        var target = shelljs.grep(/\btarget=/, filePath);
+        if (!target) {
+            throw new Error('Could not find android target within: ' + filePath);
+        }
+        return target.split('=')[1].trim();
+    }
+    if (fs.existsSync(path.join(ROOT, 'framework', 'project.properties'))) {
+        return extractFromFile(path.join(ROOT, 'framework', 'project.properties'));
+    }
+    if (fs.existsSync(path.join(ROOT, 'project.properties'))) {
+        // if no target found, we're probably in a project and project.properties is in ROOT.
+        return extractFromFile(path.join(ROOT, 'project.properties'));
+    }
+    throw new Error('Could not find android target. File missing: ' + path.join(ROOT, 'project.properties'));
+}
+
+// Returns a promise. Called only by build and clean commands.
+module.exports.check_ant = function() {
+    return tryCommand('ant -version', 'Failed to run "ant -version", make sure you have ant installed and added to your PATH.');
+};
+
+// Returns a promise. Called only by build and clean commands.
+module.exports.check_gradle = function() {
+    var sdkDir = process.env['ANDROID_HOME'];
+    var wrapperDir = path.join(sdkDir, 'tools', 'templates', 'gradle', 'wrapper');
+    if (!fs.existsSync(wrapperDir)) {
+        return Q.reject(new Error('Could not find gradle wrapper within android sdk. Might need to update your Android SDK.\n' +
+            'Looked here: ' + wrapperDir));
+    }
+    return Q.when();
+};
+
 // Returns a promise.
 module.exports.check_java = function() {
-    var d = Q.defer();
-    child_process.exec('java -version', function(err, stdout, stderr) {
-        if(err) {
-            var msg =
-                'Failed to run \'java -version\', make sure your java environment is set up\n' +
-                'including JDK and JRE.\n' +
-                'Your JAVA_HOME variable is ' + process.env.JAVA_HOME + '\n';
-            d.reject(new Error(msg + err));
+    var javacPath = forgivingWhichSync('javac');
+    var hasJavaHome = !!process.env['JAVA_HOME'];
+    return Q().then(function() {
+        if (hasJavaHome) {
+            // Windows java installer doesn't add javac to PATH, nor set JAVA_HOME (ugh).
+            if (!javacPath) {
+                process.env['PATH'] += path.delimiter + path.join(process.env['JAVA_HOME'], 'bin');
+            }
+        } else {
+            if (javacPath) {
+                // OS X has a command for finding JAVA_HOME.
+                if (fs.existsSync('/usr/libexec/java_home')) {
+                    return tryCommand('/usr/libexec/java_home', 'Failed to run: /usr/libexec/java_home')
+                    .then(function(stdout) {
+                        process.env['JAVA_HOME'] = stdout.trim();
+                    });
+                } else {
+                    // See if we can derive it from javac's location.
+                    // fs.realpathSync is require on Ubuntu, which symplinks from /usr/bin -> JDK
+                    var maybeJavaHome = path.dirname(path.dirname(fs.realpathSync(javacPath)));
+                    if (fs.existsSync(path.join(maybeJavaHome, 'lib', 'tools.jar'))) {
+                        process.env['JAVA_HOME'] = maybeJavaHome;
+                    } else {
+                        throw new Error('Could not find JAVA_HOME. Try setting the environment variable manually');
+                    }
+                }
+            } else if (isWindows) {
+                // Try to auto-detect java in the default install paths.
+                var oldSilent = shelljs.config.silent;
+                shelljs.config.silent = true;
+                var firstJdkDir =
+                    shelljs.ls(process.env['ProgramFiles'] + '\\java\\jdk*')[0] ||
+                    shelljs.ls('C:\\Program Files\\java\\jdk*')[0] ||
+                    shelljs.ls('C:\\Program Files (x86)\\java\\jdk*')[0];
+                shelljs.config.silent = oldSilent;
+                if (firstJdkDir) {
+                    // shelljs always uses / in paths.
+                    firstJdkDir = firstJdkDir.replace(/\//g, path.sep);
+                    if (!javacPath) {
+                        process.env['PATH'] += path.delimiter + path.join(firstJdkDir, 'bin');
+                    }
+                    process.env['JAVA_HOME'] = firstJdkDir;
+                }
+            }
         }
-        else d.resolve();
+    }).then(function() {
+        var msg =
+            'Failed to run "java -version", make sure that you have a JDK installed.\n' +
+            'You can get it from: http://www.oracle.com/technetwork/java/javase/downloads.\n';
+        if (process.env['JAVA_HOME']) {
+            msg += 'Your JAVA_HOME is invalid: ' + process.env['JAVA_HOME'] + '\n';
+        }
+        return tryCommand('java -version', msg)
+        .then(function() {
+            return tryCommand('javac -version', msg);
+        });
     });
-    return d.promise;
 }
 
 // Returns a promise.
 module.exports.check_android = function() {
-    var valid_target = this.get_target();
-    var d = Q.defer();
-    child_process.exec('android list targets', function(err, stdout, stderr) {
-        if (err) d.reject(stderr);
-        else d.resolve(stdout);
+    return Q().then(function() {
+        var androidCmdPath = forgivingWhichSync('android');
+        var adbInPath = !!forgivingWhichSync('adb');
+        var hasAndroidHome = !!process.env['ANDROID_HOME'] && fs.existsSync(process.env['ANDROID_HOME']);
+        function maybeSetAndroidHome(value) {
+            if (!hasAndroidHome && fs.existsSync(value)) {
+                hasAndroidHome = true;
+                process.env['ANDROID_HOME'] = value;
+            }
+        }
+        if (!hasAndroidHome && !androidCmdPath) {
+            if (isWindows) {
+                // Android Studio installer.
+                maybeSetAndroidHome(path.join(process.env['LOCALAPPDATA'], 'Android', 'android-studio', 'sdk'));
+                maybeSetAndroidHome(path.join(process.env['ProgramFiles'], 'Android', 'android-studio', 'sdk'));
+                // Stand-alone installer.
+                maybeSetAndroidHome(path.join(process.env['LOCALAPPDATA'], 'Android', 'android-sdk'));
+                maybeSetAndroidHome(path.join(process.env['ProgramFiles'], 'Android', 'android-sdk'));
+            } else if (process.platform == 'darwin') {
+                maybeSetAndroidHome('/Applications/Android Studio.app/sdk');
+                // Stand-alone zip file that user might think to put under /Applications
+                maybeSetAndroidHome('/Applications/android-sdk-macosx');
+                maybeSetAndroidHome('/Applications/android-sdk');
+            }
+            if (process.env['HOME']) {
+                // or their HOME directory.
+                maybeSetAndroidHome(path.join(process.env['HOME'], 'android-sdk-macosx'));
+                maybeSetAndroidHome(path.join(process.env['HOME'], 'android-sdk'));
+            }
+        }
+        if (hasAndroidHome && !androidCmdPath) {
+            process.env['PATH'] += path.delimiter + path.join(process.env['ANDROID_HOME'], 'tools');
+        }
+        if (androidCmdPath && !hasAndroidHome) {
+            var parentDir = path.dirname(androidCmdPath);
+            if (path.basename(parentDir) == 'tools') {
+                process.env['ANDROID_HOME'] = path.dirname(parentDir);
+                hasAndroidHome = true;
+            }
+        }
+        if (hasAndroidHome && !adbInPath) {
+            process.env['PATH'] += path.delimiter + path.join(process.env['ANDROID_HOME'], 'platform-tools');
+        }
+        if (!process.env['ANDROID_HOME']) {
+            throw new Error('ANDROID_HOME is not set and "android" command not in your PATH. You must fulfill at least one of these conditions.');
+        }
+        if (!fs.existsSync(process.env['ANDROID_HOME'])) {
+            throw new Error('ANDROID_HOME is set to a non-existant path: ' + process.env['ANDROID_HOME']);
+        }
+        // Check that the target sdk level is installed.
+        return module.exports.check_android_target(module.exports.get_target());
     });
+};
 
-    return d.promise.then(function(output) {
-        if (!output.match(valid_target)) {
-            return Q.reject(new Error('Please install Android target ' + valid_target.split('-')[1] + ' (the Android newest SDK). Make sure you have the latest Android tools installed as well. Run \"android\" from your command-line to install/update any missing SDKs or tools.'));
-        }
-        return Q();
-    }, function(stderr) {
-        if (stderr.match(/command\snot\sfound/) || stderr.match(/is not recognized as an internal or external command/)) {
-            return Q.reject(new Error('The command \"android\" failed. Make sure you have the latest Android SDK installed, and the \"android\" command (inside the tools/ folder) is added to your path.'));
-        } else {
-            return Q.reject(new Error('An error occurred while listing Android targets. Error: ' + stderr ));
+module.exports.getAbsoluteAndroidCmd = function() {
+    return forgivingWhichSync('android').replace(/(\s)/g, '\\$1');
+};
+
+module.exports.check_android_target = function(valid_target) {
+    // valid_target can look like:
+    //   android-19
+    //   android-L
+    //   Google Inc.:Google APIs:20
+    //   Google Inc.:Glass Development Kit Preview:20
+    var msg = 'Android SDK not found. Make sure that it is installed. If it is not at the default location, set the ANDROID_HOME environment variable.';
+    return tryCommand('android list targets --compact', msg)
+    .then(function(output) {
+        if (output.split('\n').indexOf(valid_target) == -1) {
+            var androidCmd = module.exports.getAbsoluteAndroidCmd();
+            throw new Error('Please install Android target: "' + valid_target + '".\n\n' +
+                'Hint: Open the SDK manager by running: ' + androidCmd + '\n' +
+                'You will require:\n' +
+                '1. "SDK Platform" for ' + valid_target + '\n' +
+                '2. "Android SDK Platform-tools (latest)\n' +
+                '3. "Android SDK Build-tools" (latest)');
         }
     });
-}
+};
 
 // Returns a promise.
 module.exports.run = function() {
-    return Q.all([this.check_ant(), this.check_java(), this.check_android()]);
+    return Q.all([this.check_java(), this.check_android()]);
 }
 

bin/lib/create.js

@@ -71,6 +71,7 @@ function copyJsAndLibrary(projectPath, shared, projectName) {
         shell.mkdir('-p', nestedCordovaLibPath);
         shell.cp('-f', path.join(ROOT, 'framework', 'AndroidManifest.xml'), nestedCordovaLibPath);
         shell.cp('-f', path.join(ROOT, 'framework', 'project.properties'), nestedCordovaLibPath);
+        shell.cp('-f', path.join(ROOT, 'framework', 'build.gradle'), nestedCordovaLibPath);
         shell.cp('-r', path.join(ROOT, 'framework', 'src'), nestedCordovaLibPath);
         // Create an eclipse project file and set the name of it to something unique.
         // Without this, you can't import multiple CordovaLib projects into the same workspace.
@@ -82,14 +83,46 @@ function copyJsAndLibrary(projectPath, shared, projectName) {
     }
 }
 
-function runAndroidUpdate(projectPath, target_api, shared) {
-    var targetFrameworkDir = getFrameworkDir(projectPath, shared);
-    return exec('android update project --subprojects --path "' + projectPath + '" --target ' + target_api + ' --library "' + path.relative(projectPath, targetFrameworkDir) + '"');
+function extractSubProjectPaths(data) {
+    var ret = {};
+    var r = /^\s*android\.library\.reference\.\d+=(.*)(?:\s|$)/mg
+    var m;
+    while (m = r.exec(data)) {
+        ret[m[1]] = 1;
+    }
+    return Object.keys(ret);
 }
 
-function copyAntRules(projectPath) {
+function writeProjectProperties(projectPath, target_api, shared) {
+    var dstPath = path.join(projectPath, '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');
+    data = data.replace(/^target=.*/m, 'target=' + target_api);
+    var subProjects = extractSubProjectPaths(data);
+    subProjects = subProjects.filter(function(p) {
+        return !(/^CordovaLib$/m.exec(p) ||
+                 /[\\\/]cordova-android[\\\/]framework$/m.exec(p) ||
+                 /^(\.\.[\\\/])+framework$/m.exec(p)
+                 );
+    });
+    subProjects.unshift(shared ? path.relative(projectPath, path.join(ROOT, 'framework')) : 'CordovaLib');
+    data = data.replace(/^\s*android\.library\.reference\.\d+=.*\n/mg, '');
+    if (!/\n$/.exec(data)) {
+        data += '\n';
+    }
+    for (var i = 0; i < subProjects.length; ++i) {
+        data += 'android.library.reference.' + (i+1) + '=' + subProjects[i] + '\n';
+    }
+    fs.writeFileSync(dstPath, data);
+}
+
+function copyBuildRules(projectPath) {
     var srcDir = path.join(ROOT, 'bin', 'templates', 'project');
     shell.cp('-f', path.join(srcDir, 'custom_rules.xml'), projectPath);
+
+    shell.cp('-f', path.join(srcDir, 'build.gradle'), projectPath);
+    shell.cp('-f', path.join(srcDir, 'cordova.gradle'), projectPath);
 }
 
 function copyScripts(projectPath) {
@@ -193,10 +226,6 @@ exports.createProject = function(project_path, package_name, project_name, proje
     return validatePackageName(package_name)
     .then(function() {
         validateProjectName(project_name);
-    })
-    // Check that requirements are met and proper targets are installed
-    .then(function() {
-        check_reqs.run();
     }).then(function() {
         // Log the given values for the project
         console.log('Creating Cordova project for the Android platform:');
@@ -212,6 +241,7 @@ exports.createProject = function(project_path, package_name, project_name, proje
             shell.cp('-r', path.join(project_template_dir, 'assets'), project_path);
             shell.cp('-r', path.join(project_template_dir, 'res'), project_path);
             shell.cp('-r', path.join(ROOT, 'framework', 'res', 'xml'), path.join(project_path, 'res'));
+            shell.cp(path.join(project_template_dir, 'gitignore'), path.join(project_path, '.gitignore'));
 
             // Manually create directories that would be empty within the template (since git doesn't track directories).
             shell.mkdir(path.join(project_path, 'libs'));
@@ -243,10 +273,10 @@ exports.createProject = function(project_path, package_name, project_name, proje
             shell.sed('-i', /__PACKAGE__/, package_name, manifest_path);
             shell.sed('-i', /__APILEVEL__/, target_api.split('-')[1], manifest_path);
             copyScripts(project_path);
-            copyAntRules(project_path);
+            copyBuildRules(project_path);
         });
         // Link it to local android install.
-        return runAndroidUpdate(project_path, target_api, use_shared_project);
+        writeProjectProperties(project_path, target_api);
     }).then(function() {
         console.log('Project successfully created.');
     });
@@ -269,22 +299,19 @@ function extractProjectNameFromManifest(projectPath) {
 }
 
 // Returns a promise.
-exports.updateProject = function(projectPath) {
-    var version = fs.readFileSync(path.join(ROOT, 'VERSION'), 'utf-8').trim();
-    // Check that requirements are met and proper targets are installed
-    return check_reqs.run()
+exports.updateProject = function(projectPath, shared) {
+    var newVersion = fs.readFileSync(path.join(ROOT, 'VERSION'), 'utf-8').trim();
+    return Q()
     .then(function() {
         var projectName = extractProjectNameFromManifest(projectPath);
         var target_api = check_reqs.get_target();
-        copyJsAndLibrary(projectPath, false, projectName);
+        copyJsAndLibrary(projectPath, shared, projectName);
         copyScripts(projectPath);
-        copyAntRules(projectPath);
+        copyBuildRules(projectPath);
         removeDebuggableFromManifest(projectPath);
-        return runAndroidUpdate(projectPath, target_api, false)
-        .then(function() {
-            console.log('Android project is now at version ' + version);
-            console.log('If you updated from a pre-3.2.0 version and use an IDE, we now require that you import the "CordovaLib" library project.');
-        });
+        writeProjectProperties(projectPath, target_api, shared);
+        console.log('Android project is now at version ' + newVersion);
+        console.log('If you updated from a pre-3.2.0 version and use an IDE, we now require that you import the "CordovaLib" library project.');
     });
 };
 

bin/node_modules/which/LICENSE

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

bin/node_modules/which/README.md

@@ -0,0 +1,5 @@
+The "which" util from npm's guts.
+
+Finds the first instance of a specified executable in the PATH
+environment variable.  Does not cache the results, so `hash -r` is not
+needed when the PATH changes.

bin/node_modules/which/bin/which

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+var which = require("../")
+if (process.argv.length < 3) {
+  console.error("Usage: which <thing>")
+  process.exit(1)
+}
+
+which(process.argv[2], function (er, thing) {
+  if (er) {
+    console.error(er.message)
+    process.exit(er.errno || 127)
+  }
+  console.log(thing)
+})

bin/node_modules/which/package.json

@@ -0,0 +1,31 @@
+{
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me"
+  },
+  "name": "which",
+  "description": "Like which(1) unix command. Find the first instance of an executable in the PATH.",
+  "version": "1.0.5",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/node-which.git"
+  },
+  "main": "which.js",
+  "bin": {
+    "which": "./bin/which"
+  },
+  "engines": {
+    "node": "*"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "readme": "The \"which\" util from npm's guts.\n\nFinds the first instance of a specified executable in the PATH\nenvironment variable.  Does not cache the results, so `hash -r` is not\nneeded when the PATH changes.\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/isaacs/node-which/issues"
+  },
+  "homepage": "https://github.com/isaacs/node-which",
+  "_id": "which@1.0.5",
+  "_from": "which@"
+}

bin/node_modules/which/which.js

@@ -0,0 +1,104 @@
+module.exports = which
+which.sync = whichSync
+
+var path = require("path")
+  , fs
+  , COLON = process.platform === "win32" ? ";" : ":"
+  , isExe
+
+try {
+  fs = require("graceful-fs")
+} catch (ex) {
+  fs = require("fs")
+}
+
+if (process.platform == "win32") {
+  // On windows, there is no good way to check that a file is executable
+  isExe = function isExe () { return true }
+} else {
+  isExe = function isExe (mod, uid, gid) {
+    //console.error(mod, uid, gid);
+    //console.error("isExe?", (mod & 0111).toString(8))
+    var ret = (mod & 0001)
+        || (mod & 0010) && process.getgid && gid === process.getgid()
+        || (mod & 0100) && process.getuid && uid === process.getuid()
+    //console.error("isExe?", ret)
+    return ret
+  }
+}
+
+
+
+function which (cmd, cb) {
+  if (isAbsolute(cmd)) return cb(null, cmd)
+  var pathEnv = (process.env.PATH || "").split(COLON)
+    , pathExt = [""]
+  if (process.platform === "win32") {
+    pathEnv.push(process.cwd())
+    pathExt = (process.env.PATHEXT || ".EXE").split(COLON)
+    if (cmd.indexOf(".") !== -1) pathExt.unshift("")
+  }
+  //console.error("pathEnv", pathEnv)
+  ;(function F (i, l) {
+    if (i === l) return cb(new Error("not found: "+cmd))
+    var p = path.resolve(pathEnv[i], cmd)
+    ;(function E (ii, ll) {
+      if (ii === ll) return F(i + 1, l)
+      var ext = pathExt[ii]
+      //console.error(p + ext)
+      fs.stat(p + ext, function (er, stat) {
+        if (!er &&
+            stat &&
+            stat.isFile() &&
+            isExe(stat.mode, stat.uid, stat.gid)) {
+          //console.error("yes, exe!", p + ext)
+          return cb(null, p + ext)
+        }
+        return E(ii + 1, ll)
+      })
+    })(0, pathExt.length)
+  })(0, pathEnv.length)
+}
+
+function whichSync (cmd) {
+  if (isAbsolute(cmd)) return cmd
+  var pathEnv = (process.env.PATH || "").split(COLON)
+    , pathExt = [""]
+  if (process.platform === "win32") {
+    pathEnv.push(process.cwd())
+    pathExt = (process.env.PATHEXT || ".EXE").split(COLON)
+    if (cmd.indexOf(".") !== -1) pathExt.unshift("")
+  }
+  for (var i = 0, l = pathEnv.length; i < l; i ++) {
+    var p = path.join(pathEnv[i], cmd)
+    for (var j = 0, ll = pathExt.length; j < ll; j ++) {
+      var cur = p + pathExt[j]
+      var stat
+      try { stat = fs.statSync(cur) } catch (ex) {}
+      if (stat &&
+          stat.isFile() &&
+          isExe(stat.mode, stat.uid, stat.gid)) return cur
+    }
+  }
+  throw new Error("not found: "+cmd)
+}
+
+var isAbsolute = process.platform === "win32" ? absWin : absUnix
+
+function absWin (p) {
+  if (absUnix(p)) return true
+  // pull off the device/UNC bit from a windows path.
+  // from node's lib/path.js
+  var splitDeviceRe =
+        /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?([\\\/])?/
+    , result = splitDeviceRe.exec(p)
+    , device = result[1] || ''
+    , isUnc = device && device.charAt(1) !== ':'
+    , isAbsolute = !!result[2] || isUnc // UNC paths are always absolute
+
+  return isAbsolute
+}
+
+function absUnix (p) {
+  return p.charAt(0) === "/" || p === ""
+}

bin/templates/cordova/build

@@ -24,13 +24,17 @@ var build = require('./lib/build'),
     args  = process.argv;
 
 // Support basic help commands
-if(args[2] == '--help' || args[2] == '/?' || args[2] == '-h' ||
-                    args[2] == 'help' || args[2] == '-help' || args[2] == '/help') {
+if(args[2] == '--help' ||
+   args[2] == '/?' ||
+   args[2] == '-h' ||
+   args[2] == 'help' ||
+   args[2] == '-help' ||
+   args[2] == '/help') {
     build.help();
 } else {
-    reqs.run().then(function() {
-        return build.run(args[2]);
-    }).done(null, function(err) {
+    reqs.run().done(function() {
+        return build.run(args.slice(2));
+    }, function(err) {
         console.error(err);
         process.exit(2);
     });

bin/templates/cordova/clean

@@ -19,18 +19,26 @@
        under the License.
 */
 
-var clean = require('./lib/clean'),
+var build = require('./lib/build'),
     reqs  = require('./lib/check_reqs'),
     args  = process.argv;
+var path  = require('path');
 
-// Usage support for when args are given
-if(args.length > 2) {
-    clean.help();
+// Support basic help commands
+if(args[2] == '--help' ||
+   args[2] == '/?' ||
+   args[2] == '-h' ||
+   args[2] == 'help' ||
+   args[2] == '-help' ||
+   args[2] == '/help') {
+    console.log('Usage: ' + path.relative(process.cwd(), process.argv[1]));
+    console.log('Cleans the project directory.');
+    process.exit(0);
 } else {
     reqs.run().done(function() {
-        return clean.run();
+        return build.runClean(args.slice(2));
     }, function(err) {
-        console.error('ERROR: ' + err);
+        console.error(err);
         process.exit(2);
     });
 }

bin/templates/cordova/lib/build.js

@@ -25,89 +25,416 @@ var shell   = require('shelljs'),
     path    = require('path'),
     fs      = require('fs'),
     ROOT    = path.join(__dirname, '..', '..');
+var check_reqs = require('./check_reqs');
+var exec  = require('./exec');
 
+var LOCAL_PROPERTIES_TEMPLATE =
+    '# This file is automatically generated.\n' +
+    '# Do not modify this file -- YOUR CHANGES WILL BE ERASED!\n';
+
+function findApks(directory) {
+    var ret = [];
+    if (fs.existsSync(directory)) {
+        fs.readdirSync(directory).forEach(function(p) {
+            if (path.extname(p) == '.apk') {
+                ret.push(path.join(directory, p));
+            }
+        });
+    }
+    return ret;
+}
+
+function sortFilesByDate(files) {
+    return files.map(function(p) {
+        return { p: p, t: fs.statSync(p).mtime };
+    }).sort(function(a, b) {
+        var timeDiff = b.t - a.t;
+        return timeDiff === 0 ? a.p.length - b.p.length : timeDiff;
+    }).map(function(p) { return p.p; });
+}
+
+function findOutputApksHelper(dir, build_type, arch) {
+    var ret = findApks(dir).filter(function(candidate) {
+        // Need to choose between release and debug .apk.
+        if (build_type === 'debug') {
+            return /-debug/.exec(candidate) && !/-unaligned|-unsigned/.exec(candidate);
+        }
+        if (build_type === 'release') {
+            return /-release/.exec(candidate) && !/-unaligned/.exec(candidate);
+        }
+        return true;
+    });
+    ret = sortFilesByDate(ret);
+    if (ret.length === 0) {
+        return ret;
+    }
+    var archSpecific = !!/-x86|-arm/.exec(ret[0]);
+    ret = ret.filter(function(p) {
+        return !!/-x86|-arm/.exec(p) == archSpecific;
+    });
+    if (arch) {
+        ret = ret.filter(function(p) {
+            return p.indexOf('-' + arch) != -1;
+        });
+    }
+    return ret;
+}
 
 function hasCustomRules() {
     return fs.existsSync(path.join(ROOT, 'custom_rules.xml'));
 }
-module.exports.getAntArgs = function(cmd) {
-    var args = [cmd, '-f', path.join(ROOT, 'build.xml')];
-    // custom_rules.xml is required for incremental builds.
-    if (hasCustomRules()) {
-        args.push('-Dout.dir=ant-build', '-Dgen.absolute.dir=ant-gen');
+
+function extractProjectNameFromManifest(projectPath) {
+    var manifestPath = path.join(projectPath, 'AndroidManifest.xml');
+    var manifestData = fs.readFileSync(manifestPath, 'utf8');
+    var m = /<activity[\s\S]*?android:name\s*=\s*"(.*?)"/i.exec(manifestData);
+    if (!m) {
+        throw new Error('Could not find activity name in ' + manifestPath);
     }
-    return args;
+    return m[1];
+}
+
+function extractSubProjectPaths() {
+    var data = fs.readFileSync(path.join(ROOT, 'project.properties'), 'utf8');
+    var ret = {};
+    var r = /^\s*android\.library\.reference\.\d+=(.*)(?:\s|$)/mg
+    var m;
+    while (m = r.exec(data)) {
+        ret[m[1]] = 1;
+    }
+    return Object.keys(ret);
+}
+
+var builders = {
+    ant: {
+        getArgs: function(cmd) {
+            var args = [cmd, '-f', path.join(ROOT, 'build.xml')];
+            // custom_rules.xml is required for incremental builds.
+            if (hasCustomRules()) {
+                args.push('-Dout.dir=ant-build', '-Dgen.absolute.dir=ant-gen');
+            }
+            return args;
+        },
+
+        prepEnv: function() {
+            return check_reqs.check_ant()
+            .then(function() {
+                // Copy in build.xml on each build so that:
+                // A) we don't require the Android SDK at project creation time, and
+                // B) we always use the SDK's latest version of it.
+                var sdkDir = process.env['ANDROID_HOME'];
+                var buildTemplate = fs.readFileSync(path.join(sdkDir, 'tools', 'lib', 'build.template'), 'utf8');
+                function writeBuildXml(projectPath) {
+                    var newData = buildTemplate.replace('PROJECT_NAME', extractProjectNameFromManifest(ROOT));
+                    fs.writeFileSync(path.join(projectPath, 'build.xml'), newData);
+                    if (!fs.existsSync(path.join(projectPath, 'local.properties'))) {
+                        fs.writeFileSync(path.join(projectPath, 'local.properties'), LOCAL_PROPERTIES_TEMPLATE);
+                    }
+                }
+                var subProjects = extractSubProjectPaths();
+                writeBuildXml(ROOT);
+                for (var i = 0; i < subProjects.length; ++i) {
+                    writeBuildXml(path.join(ROOT, subProjects[i]));
+                }
+            });
+        },
+
+        /*
+         * Builds the project with ant.
+         * Returns a promise.
+         */
+        build: function(build_type) {
+            // Without our custom_rules.xml, we need to clean before building.
+            var ret = Q();
+            if (!hasCustomRules()) {
+                // clean will call check_ant() for us.
+                ret = this.clean();
+            }
+
+            var builder = this;
+            var args = this.getArgs(build_type == 'debug' ? 'debug' : 'release');
+            return check_reqs.check_ant()
+            .then(function() {
+                return spawn('ant', args);
+            });
+        },
+
+        clean: function() {
+            var args = this.getArgs('clean');
+            return check_reqs.check_ant()
+            .then(function() {
+                return spawn('ant', args);
+            });
+        },
+
+        findOutputApks: function(build_type) {
+            var binDir = path.join(ROOT, hasCustomRules() ? 'ant-build' : 'bin');
+            return findOutputApksHelper(binDir, build_type, null);
+        }
+    },
+    gradle: {
+        getArgs: function(cmd, arch) {
+            var lintSteps;
+            if (process.env['BUILD_MULTIPLE_APKS']) {
+                lintSteps = [
+                    'lint',
+                    'lintVitalX86Release',
+                    'lintVitalArmv7Release',
+                    'compileLint',
+                    'copyReleaseLint',
+                    'copyDebugLint'
+                ];
+            } else {
+                lintSteps = [
+                    'lint',
+                    'lintVitalRelease',
+                    'compileLint',
+                    'copyReleaseLint',
+                    'copyDebugLint'
+                ];
+            }
+            if (arch == 'arm' && cmd == 'debug') {
+                cmd = 'assembleArmv7Debug';
+            } else if (arch == 'arm' && cmd == 'release') {
+                cmd = 'assembleArmv7Release';
+            } else if (arch == 'x86' && cmd == 'debug') {
+                cmd = 'assembleX86Debug';
+            } else if (arch == 'x86' && cmd == 'release') {
+                cmd = 'assembleX86Release';
+            } else if (cmd == 'debug') {
+                cmd = 'assembleDebug';
+            } else if (cmd == 'release') {
+                cmd = 'assembleRelease';
+            }
+            var args = [cmd, '-b', path.join(ROOT, 'build.gradle')];
+            // 10 seconds -> 6 seconds
+            args.push('-Dorg.gradle.daemon=true');
+            // Excluding lint: 6s-> 1.6s
+            for (var i = 0; i < lintSteps.length; ++i) {
+                args.push('-x', lintSteps[i]);
+            }
+            // Shaves another 100ms, but produces a "try at own risk" warning. Not worth it (yet):
+            // args.push('-Dorg.gradle.parallel=true');
+            return args;
+        },
+
+        prepEnv: function() {
+            return check_reqs.check_gradle()
+            .then(function() {
+                // Copy the gradle wrapper on each build so that:
+                // A) we don't require the Android SDK at project creation time, and
+                // B) we always use the SDK's latest version of it.
+                var projectPath = ROOT;
+                // check_reqs ensures that this is set.
+                var sdkDir = process.env['ANDROID_HOME'];
+                var wrapperDir = path.join(sdkDir, 'tools', 'templates', 'gradle', 'wrapper');
+                if (process.platform == 'win32') {
+                    shell.cp('-f', path.join(wrapperDir, 'gradlew.bat'), projectPath);
+                } else {
+                    shell.cp('-f', path.join(wrapperDir, 'gradlew'), projectPath);
+                }
+                shell.rm('-rf', path.join(projectPath, 'gradle', 'wrapper'));
+                shell.mkdir('-p', path.join(projectPath, 'gradle'));
+                shell.cp('-r', path.join(wrapperDir, 'gradle', 'wrapper'), path.join(projectPath, 'gradle'));
+
+                // If the gradle distribution URL is set, make sure it points to version 1.12.
+                // If it's not set, do nothing, assuming that we're using a future version of gradle that we don't want to mess with.
+                var distributionUrlRegex = '/^distributionUrl=.*$/';
+                var distributionUrl = 'distributionUrl=http\\://services.gradle.org/distributions/gradle-1.12-all.zip';
+                var gradleWrapperPropertiesPath = path.join(projectPath, 'gradle', 'wrapper', 'gradle-wrapper.properties');
+                shell.sed('-i', distributionUrlRegex, distributionUrl, gradleWrapperPropertiesPath);
+
+                // Update the version of build.gradle in each dependent library.
+                var pluginBuildGradle = path.join(projectPath, 'cordova', 'lib', 'plugin-build.gradle');
+                var subProjects = extractSubProjectPaths();
+                for (var i = 0; i < subProjects.length; ++i) {
+                    shell.cp('-f', pluginBuildGradle, path.join(ROOT, subProjects[i], 'build.gradle'));
+                }
+
+                var subProjectsAsGradlePaths = subProjects.map(function(p) { return ':' + p.replace(/[/\\]/g, ':') });
+                // Write the settings.gradle file.
+                fs.writeFileSync(path.join(projectPath, 'settings.gradle'),
+                    '// GENERATED FILE - DO NOT EDIT\n' +
+                    'include ":"\n' +
+                    'include "' + subProjectsAsGradlePaths.join('"\ninclude "') + '"\n');
+                // Update dependencies within build.gradle.
+                var buildGradle = fs.readFileSync(path.join(projectPath, 'build.gradle'), 'utf8');
+                var depsList = '';
+                subProjectsAsGradlePaths.forEach(function(p) {
+                    depsList += '    debugCompile project(path: "' + p + '", configuration: "debug")\n';
+                    depsList += '    releaseCompile project(path: "' + p + '", configuration: "release")\n';
+                });
+                buildGradle = buildGradle.replace(/(SUB-PROJECT DEPENDENCIES START)[\s\S]*(\/\/ SUB-PROJECT DEPENDENCIES END)/, '$1\n' + depsList + '    $2');
+                fs.writeFileSync(path.join(projectPath, 'build.gradle'), buildGradle);
+            });
+        },
+
+        /*
+         * Builds the project with gradle.
+         * Returns a promise.
+         */
+        build: function(build_type, arch) {
+            var builder = this;
+            var wrapper = path.join(ROOT, 'gradlew');
+            var args = this.getArgs(build_type == 'debug' ? 'debug' : 'release', arch);
+            return Q().then(function() {
+                return spawn(wrapper, args);
+            });
+        },
+
+        clean: function() {
+            var builder = this;
+            var wrapper = path.join(ROOT, 'gradlew');
+            var args = builder.getArgs('clean');
+            return Q().then(function() {
+                return spawn(wrapper, args);
+            });
+        },
+
+        findOutputApks: function(build_type, arch) {
+            var binDir = path.join(ROOT, 'build', 'outputs', 'apk');
+            return findOutputApksHelper(binDir, build_type, arch);
+        }
+    },
+
+    none: {
+        prepEnv: function() {
+            return Q();
+        },
+        build: function() {
+            console.log('Skipping build...');
+            return Q(null);
+        },
+        clean: function() {
+            return Q();
+        },
+        findOutputApks: function(build_type, arch) {
+            return sortFilesByDate(builders.ant.findOutputApks(build_type, arch).concat(builders.gradle.findOutputApks(build_type, arch)));
+        }
+    }
+};
+
+function parseOpts(options, resolvedTarget) {
+    // Backwards-compatibility: Allow a single string argument
+    if (typeof options == "string") options = [options];
+
+    var ret = {
+        buildType: 'debug',
+        buildMethod: process.env['ANDROID_BUILD'] || 'ant',
+        arch: null
+    };
+
+    // Iterate through command line options
+    for (var i=0; options && (i < options.length); ++i) {
+        if (/^--/.exec(options[i])) {
+            var option = options[i].substring(2);
+            switch(option) {
+                case 'debug':
+                case 'release':
+                    ret.buildType = option;
+                    break;
+                case 'ant':
+                case 'gradle':
+                    ret.buildMethod = option;
+                    break;
+                case 'nobuild' :
+                    ret.buildMethod = 'none';
+                    break;
+                default :
+                    return Q.reject('Build option \'' + options[i] + '\' not recognized.');
+            }
+        } else {
+            return Q.reject('Build option \'' + options[i] + '\' not recognized.');
+        }
+    }
+
+    var multiApk = ret.buildMethod == 'gradle' && process.env['BUILD_MULTIPLE_APKS'];
+    if (multiApk && !/0|false|no/i.exec(multiApk)) {
+        ret.arch = resolvedTarget && resolvedTarget.arch;
+    }
+
+    return ret;
+}
+
+/*
+ * Builds the project with the specifed options
+ * Returns a promise.
+ */
+module.exports.runClean = function(options) {
+    var opts = parseOpts(options);
+    var builder = builders[opts.buildMethod];
+    return builder.prepEnv()
+    .then(function() {
+        return builder.clean();
+    }).then(function() {
+        shell.rm('-rf', path.join(ROOT, 'out'));
+    });
 };
 
 /*
- * Builds the project with ant.
+ * Builds the project with the specifed options
  * Returns a promise.
  */
-module.exports.run = function(build_type) {
-    //default build type
-    build_type = typeof build_type !== 'undefined' ? build_type : "--debug";
-    var args = module.exports.getAntArgs('debug');
-    switch(build_type) {
-        case '--debug' :
-            break;
-        case '--release' :
-            args[0] = 'release';
-            break;
-        case '--nobuild' :
-            console.log('Skipping build...');
-            return Q();
-        default :
-            return Q.reject('Build option \'' + build_type + '\' not recognized.');
-    }
-    // Without our custom_rules.xml, we need to clean before building.
-    var ret = Q();
-    if (!hasCustomRules()) {
-        ret = require('./clean').run();
-    }
-    return ret.then(function() {
-        return spawn('ant', args);
+module.exports.run = function(options, optResolvedTarget) {
+    var opts = parseOpts(options, optResolvedTarget);
+    var builder = builders[opts.buildMethod];
+    return builder.prepEnv()
+    .then(function() {
+        return builder.build(opts.buildType, opts.arch);
+    }).then(function() {
+        var apkPaths = builder.findOutputApks(opts.buildType, opts.arch);
+        console.log('Built the following apk(s):');
+        console.log('    ' + apkPaths.join('\n    '));
+        return {
+            apkPaths: apkPaths,
+            buildType: opts.buildType,
+            buildMethod: opts.buildMethod
+        };
     });
-}
+};
 
 /*
- * Gets the path to the apk file, if not such file exists then
- * the script will error out. (should we error or just return undefined?)
+ * Detects the architecture of a device/emulator
+ * Returns "arm" or "x86".
  */
-module.exports.get_apk = function() {
-    var binDir = '';
-    if(!hasCustomRules()) {
-        binDir = path.join(ROOT, 'bin');
-    } else {
-        binDir = path.join(ROOT, 'ant-build');
-    }
-    if (fs.existsSync(binDir)) {
-        var candidates = fs.readdirSync(binDir).filter(function(p) {
-            // Need to choose between release and debug .apk.
-            return path.extname(p) == '.apk';
-        }).map(function(p) {
-            p = path.join(binDir, p);
-            return { p: p, t: fs.statSync(p).mtime };
-        }).sort(function(a,b) {
-            return a.t > b.t ? -1 :
-                   a.t < b.t ? 1 : 0;
-        });
-        if (candidates.length === 0) {
-            console.error('ERROR : No .apk found in ' + binDir + ' directory');
-            process.exit(2);
+module.exports.detectArchitecture = function(target) {
+    return exec('adb -s ' + target + ' shell cat /proc/cpuinfo')
+    .then(function(output) {
+        if (/intel/i.exec(output)) {
+            return 'x86';
+        }
+        return 'arm';
+    });
+};
+
+module.exports.findBestApkForArchitecture = function(buildResults, arch) {
+    var paths = buildResults.apkPaths.filter(function(p) {
+        if (buildResults.buildType == 'debug') {
+            return /-debug/.exec(p);
+        }
+        return !/-debug/.exec(p);
+    });
+    var archPattern = new RegExp('-' + arch);
+    var hasArchPattern = /-x86|-arm/;
+    for (var i = 0; i < paths.length; ++i) {
+        if (hasArchPattern.exec(paths[i])) {
+            if (archPattern.exec(paths[i])) {
+                return paths[i];
+            }
+        } else {
+            return paths[i];
         }
-        console.log('Using apk: ' + candidates[0].p);
-        return candidates[0].p;
-    } else {
-        console.error('ERROR : unable to find project ' + binDir + ' directory, could not locate .apk');
-        process.exit(2);
     }
-}
+    throw new Error('Could not find apk architecture: ' + arch + ' build-type: ' + buildResults.buildType);
+};
 
 module.exports.help = function() {
     console.log('Usage: ' + path.relative(process.cwd(), path.join(ROOT, 'cordova', 'build')) + ' [build_type]');
     console.log('Build Types : ');
-    console.log('    \'--debug\': Default build, will build project in using ant debug');
-    console.log('    \'--release\': will build project using ant release');
+    console.log('    \'--debug\': Default build, will build project in debug mode');
+    console.log('    \'--release\': will build project for release');
+    console.log('    \'--ant\': Default build, will build project with ant');
+    console.log('    \'--gradle\': will build project with gradle');
     console.log('    \'--nobuild\': will skip build process (can be used with run command)');
     process.exit(0);
-}
+};

bin/templates/cordova/lib/clean.js

@@ -1,39 +0,0 @@
-#!/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 build = require('./build'),
-    spawn = require('./spawn'),
-    path  = require('path');
-
-/*
- * Cleans the project using ant
- * Returns a promise.
- */
-module.exports.run = function() {
-    var args = build.getAntArgs('clean');
-    return spawn('ant', args);
-}
-
-module.exports.help = function() {
-    console.log('Usage: ' + path.relative(process.cwd(), process.argv[1]));
-    console.log('Cleans the project directory.');
-    process.exit(0);
-}

bin/templates/cordova/lib/device.js

@@ -43,44 +43,60 @@ module.exports.list = function() {
     });
 }
 
+module.exports.resolveTarget = function(target) {
+    return this.list()
+    .then(function(device_list) {
+        if (!device_list || !device_list.length) {
+            return Q.reject('ERROR: Failed to deploy to device, no devices found.');
+        }
+        // default device
+        target = target || device_list[0];
+
+        if (device_list.indexOf(target) < 0) {
+            return Q.reject('ERROR: Unable to find target \'' + target + '\'.');
+        }
+
+        return build.detectArchitecture(target)
+        .then(function(arch) {
+            return { target: target, arch: arch, isEmulator: false };
+        });
+    });
+};
+
 /*
  * Installs a previously built application on the device
  * and launches it.
  * Returns a promise.
  */
-module.exports.install = function(target) {
-    var launchName;
-    return this.list()
-    .then(function(device_list) {
-        if (!device_list || !device_list.length)
-            return Q.reject('ERROR: Failed to deploy to device, no devices found.');
-
-        // default device
-        target = typeof target !== 'undefined' ? target : device_list[0];
-
-        if (device_list.indexOf(target) < 0)
-            return Q.reject('ERROR: Unable to find target \'' + target + '\'.');
-
-        var apk_path = build.get_apk();
-        launchName = appinfo.getActivityName();
+module.exports.install = function(target, buildResults) {
+    return Q().then(function() {
+        if (target && typeof target == 'object') {
+            return target;
+        }
+        return module.exports.resolveTarget(target);
+    }).then(function(resolvedTarget) {
+        var apk_path = build.findBestApkForArchitecture(buildResults, resolvedTarget.arch);
+        var launchName = appinfo.getActivityName();
+        console.log('Using apk: ' + apk_path);
         console.log('Installing app on device...');
-        var cmd = 'adb -s ' + target + ' install -r "' + apk_path + '"';
-        return exec(cmd);
-    }).then(function(output) {
-        if (output.match(/Failure/)) return Q.reject('ERROR: Failed to install apk to device: ' + output);
+        var cmd = 'adb -s ' + resolvedTarget.target + ' install -r "' + apk_path + '"';
+        return exec(cmd)
+        .then(function(output) {
+            if (output.match(/Failure/)) return Q.reject('ERROR: Failed to install apk to device: ' + output);
 
-        //unlock screen
-        var cmd = 'adb -s ' + target + ' shell input keyevent 82';
-        return exec(cmd);
-    }, function(err) { return Q.reject('ERROR: Failed to install apk to device: ' + err); })
-    .then(function() {
-        // launch the application
-        console.log('Launching application...');
-        var cmd = 'adb -s ' + target + ' shell am start -W -a android.intent.action.MAIN -n ' + launchName;
-        return exec(cmd);
-    }).then(function() {
-        console.log('LAUNCH SUCCESS');
-    }, function(err) {
-        return Q.reject('ERROR: Failed to launch application on device: ' + err);
+            //unlock screen
+            var cmd = 'adb -s ' + resolvedTarget.target + ' shell input keyevent 82';
+            return exec(cmd);
+        }, function(err) { return Q.reject('ERROR: Failed to install apk to device: ' + err); })
+        .then(function() {
+            // launch the application
+            console.log('Launching application...');
+            var cmd = 'adb -s ' + resolvedTarget.target + ' shell am start -W -a android.intent.action.MAIN -n ' + launchName;
+            return exec(cmd);
+        }).then(function() {
+            console.log('LAUNCH SUCCESS');
+        }, function(err) {
+            return Q.reject('ERROR: Failed to launch application on device: ' + err);
+        });
     });
 }

bin/templates/cordova/lib/emulator.js

@@ -28,6 +28,7 @@ var shell = require('shelljs'),
     ROOT  = path.join(__dirname, '..', '..'),
     child_process = require('child_process'),
     new_emulator = 'cordova_emulator';
+var check_reqs = require('./check_reqs');
 
 /**
  * Returns a Promise for a list of emulator images in the form of objects
@@ -84,7 +85,7 @@ module.exports.list_images = function() {
  * Returns a promise.
  */
 module.exports.best_image = function() {
-    var project_target = this.get_target().replace('android-', '');
+    var project_target = check_reqs.get_target().replace('android-', '');
     return this.list_images()
     .then(function(images) {
         var closest = 9999;
@@ -120,11 +121,6 @@ module.exports.list_started = function() {
     });
 }
 
-module.exports.get_target = function() {
-    var target = shell.grep(/target=android-[\d+]/, path.join(ROOT, 'project.properties'));
-    return target.split('=')[1].replace('\n', '').replace('\r', '').replace(' ', '');
-}
-
 // Returns a promise.
 module.exports.list_targets = function() {
     return exec('android list targets')
@@ -156,7 +152,7 @@ module.exports.start = function(emulator_ID) {
     .then(function(list) {
         started_emulators = list;
         num_started = started_emulators.length;
-        if (typeof emulator_ID === 'undefined') {
+        if (!emulator_ID) {
             return self.list_images()
             .then(function(emulator_list) {
                 if (emulator_list.length > 0) {
@@ -167,11 +163,11 @@ module.exports.start = function(emulator_ID) {
                         return emulator_ID;
                     });
                 } else {
-                    return Q.reject('ERROR : No emulator images (avds) found, if you would like to create an\n' +
-                        ' avd follow the instructions provided here:\n' +
-                        ' http://developer.android.com/tools/devices/index.html\n' +
-                        ' Or run \'android create avd --name <name> --target <targetID>\'\n' +
-                        ' in on the command line.');
+                    var androidCmd = check_reqs.getAbsoluteAndroidCmd();
+                    return Q.reject('ERROR : 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');
                 }
             });
         } else {
@@ -277,14 +273,7 @@ module.exports.create_image = function(name, target) {
     }
 }
 
-/*
- * Installs a previously built application on the emulator and launches it.
- * If no target is specified, then it picks one.
- * If no started emulators are found, error out.
- * Returns a promise.
- */
-module.exports.install = function(target) {
-    var self = this;
+module.exports.resolveTarget = function(target) {
     return this.list_started()
     .then(function(emulator_list) {
         if (emulator_list.length < 1) {
@@ -292,33 +281,55 @@ module.exports.install = function(target) {
         }
 
         // default emulator
-        target = typeof target !== 'undefined' ? target : emulator_list[0];
+        target = target || emulator_list[0];
         if (emulator_list.indexOf(target) < 0) {
             return Q.reject('Unable to find target \'' + target + '\'. Failed to deploy to emulator.');
         }
 
-        console.log('Installing app on emulator...');
-        var apk_path = build.get_apk();
-        return exec('adb -s ' + target + ' install -r "' + apk_path + '"');
-    }).then(function(output) {
-        if (output.match(/Failure/)) {
-            return Q.reject('Failed to install apk to emulator: ' + output);
+        return build.detectArchitecture(target)
+        .then(function(arch) {
+            return {target:target, arch:arch, isEmulator:true};
+        });
+    });
+};
+
+/*
+ * Installs a previously built application on the emulator and launches it.
+ * If no target is specified, then it picks one.
+ * If no started emulators are found, error out.
+ * Returns a promise.
+ */
+module.exports.install = function(target, buildResults) {
+    return Q().then(function() {
+        if (target && typeof target == 'object') {
+            return target;
         }
-        return Q();
-    }, function(err) {
-        return Q.reject('Failed to install apk to emulator: ' + err);
-    }).then(function() {
-        //unlock screen
-        return exec('adb -s ' + target + ' shell input keyevent 82');
-    }).then(function() {
-        // launch the application
-        console.log('Launching application...');
-        var launchName = appinfo.getActivityName();
-        cmd = 'adb -s ' + target + ' shell am start -W -a android.intent.action.MAIN -n ' + launchName;
-        return exec(cmd);
-    }).then(function(output) {
-        console.log('LAUNCH SUCCESS');
-    }, function(err) {
-        return Q.reject('Failed to launch app on emulator: ' + err);
+        return module.exports.resolveTarget(target);
+    }).then(function(resolvedTarget) {
+        var apk_path = build.findBestApkForArchitecture(buildResults, resolvedTarget.arch);
+        console.log('Installing app on emulator...');
+        console.log('Using apk: ' + apk_path);
+        return exec('adb -s ' + resolvedTarget.target + ' install -r "' + apk_path + '"')
+        .then(function(output) {
+            if (output.match(/Failure/)) {
+                return Q.reject('Failed to install apk to emulator: ' + output);
+            }
+            return Q();
+        }, function(err) {
+            return Q.reject('Failed to install apk to emulator: ' + err);
+        }).then(function() {
+            //unlock screen
+            return exec('adb -s ' + resolvedTarget.target + ' shell input keyevent 82');
+        }).then(function() {
+            // launch the application
+            console.log('Launching application...');
+            var launchName = appinfo.getActivityName();
+            cmd = 'adb -s ' + resolvedTarget.target + ' shell am start -W -a android.intent.action.MAIN -n ' + launchName;
+            return exec(cmd);
+        }).then(function(output) {
+            console.log('LAUNCH SUCCESS');
+        }, function(err) {
+            return Q.reject('Failed to launch app on emulator: ' + err);
+        });
     });
 }

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

@@ -0,0 +1,63 @@
+/* Licensed to the Apache Software Foundation (ASF) under one
+   or more contributor license agreements.  See the NOTICE file
+   distributed with this work for additional information
+   regarding copyright ownership.  The ASF licenses this file
+   to you under the Apache License, Version 2.0 (the
+   "License"); you may not use this file except in compliance
+   with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing,
+   software distributed under the License is distributed on an
+   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+   KIND, either express or implied.  See the License for the
+   specific language governing permissions and limitations
+   under the License.
+*/
+
+// GENERATED FILE! DO NOT EDIT!
+
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:0.12.+'
+    }
+}
+
+apply plugin: 'android-library'
+
+dependencies {
+    compile fileTree(dir: 'libs', include: '*.jar')
+}
+
+android {
+    compileSdkVersion cordova.cordovaSdkVersion
+    buildToolsVersion cordova.cordovaBuildToolsVersion
+    publishNonDefault true
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_7
+        targetCompatibility JavaVersion.VERSION_1_7
+    }
+
+    sourceSets {
+        main {
+            manifest.srcFile 'AndroidManifest.xml'
+            java.srcDirs = ['src']
+            resources.srcDirs = ['src']
+            aidl.srcDirs = ['src']
+            renderscript.srcDirs = ['src']
+            res.srcDirs = ['res']
+            assets.srcDirs = ['assets']
+            jniLibs.srcDirs = ['libs']
+        }
+    }
+}
+
+if (file('build-extras.gradle').exists()) {
+    apply from: 'build-extras.gradle'
+}

bin/templates/cordova/lib/run.js

@@ -33,16 +33,16 @@ var path  = require('path'),
  * Returns a promise.
  */
  module.exports.run = function(args) {
-    var build_type;
+    var buildFlags = [];
     var install_target;
 
     for (var i=2; i<args.length; i++) {
         if (args[i] == '--debug') {
-            build_type = '--debug';
+            buildFlags.push('--debug');
         } else if (args[i] == '--release') {
-            build_type = '--release';
+            buildFlags.push('--release');
         } else if (args[i] == '--nobuild') {
-            build_type = '--nobuild';
+            buildFlags.push('--nobuild');
         } else if (args[i] == '--device') {
             install_target = '--device';
         } else if (args[i] == '--emulator') {
@@ -55,73 +55,66 @@ var path  = require('path'),
         }
     }
 
-    return build.run(build_type).then(function() {
-        if (install_target == '--device') {
-            return device.install();
-        } else if (install_target == '--emulator') {
-            return emulator.list_started().then(function(started) {
-                var p = started && started.length > 0 ? Q() : emulator.start();
-                return p.then(function() { emulator.install(); });
-            });
-        } else if (install_target) {
-            var devices, started_emulators, avds;
-            return device.list()
-            .then(function(res) {
-                devices = res;
-                return emulator.list_started();
-            }).then(function(res) {
-                started_emulators = res;
-                return emulator.list_images();
-            }).then(function(res) {
-                avds = res;
-                if (devices.indexOf(install_target) > -1) {
-                    return device.install(install_target);
-                } else if (started_emulators.indexOf(install_target) > -1) {
-                    return emulator.install(install_target);
-                } else {
-                    // if target emulator isn't started, then start it.
-                    var emulator_ID;
-                    for(avd in avds) {
-                        if(avds[avd].name == install_target) {
-                            return emulator.start(install_target)
-                            .then(function() { emulator.install(emulator_ID); });
-                        }
-                    }
-                    return Q.reject('Target \'' + install_target + '\' not found, unable to run project');
-                }
-            });
-        } else {
+    return Q()
+    .then(function() {
+        if (!install_target) {
             // no target given, deploy to device if available, otherwise use the emulator.
             return device.list()
             .then(function(device_list) {
                 if (device_list.length > 0) {
                     console.log('WARNING : No target specified, deploying to device \'' + device_list[0] + '\'.');
-                    return device.install(device_list[0]);
+                    install_target = device_list[0];
                 } else {
-                    return emulator.list_started()
-                    .then(function(emulator_list) {
-                        if (emulator_list.length > 0) {
-                            console.log('WARNING : No target specified, deploying to emulator \'' + emulator_list[0] + '\'.');
-                            return emulator.install(emulator_list[0]);
-                        } else {
-                            console.log('WARNING : No started emulators found, starting an emulator.');
-                            return emulator.best_image()
-                            .then(function(best_avd) {
-                                if(best_avd) {
-                                    return emulator.start(best_avd.name)
-                                    .then(function(emulator_ID) {
-                                        console.log('WARNING : No target specified, deploying to emulator \'' + emulator_ID + '\'.');
-                                        return emulator.install(emulator_ID);
-                                    });
-                                } else {
-                                    return emulator.start();
-                                }
-                            });
-                        }
-                    });
+                    console.log('WARNING : No target specified, deploying to emulator');
+                    install_target = '--emulator';
                 }
             });
         }
+    }).then(function() {
+        if (install_target == '--device') {
+            return device.resolveTarget(null);
+        } else if (install_target == '--emulator') {
+            // Give preference to any already started emulators. Else, start one.
+            return emulator.list_started()
+            .then(function(started) {
+                return started && started.length > 0 ? started[0] : emulator.start();
+            }).then(function(emulatorId) {
+                return emulator.resolveTarget(emulatorId);
+            });
+        }
+        // They specified a specific device/emulator ID.
+        return device.list()
+        .then(function(devices) {
+            if (devices.indexOf(install_target) > -1) {
+                return device.resolveTarget(install_target);
+            }
+            return emulator.list_started()
+            .then(function(started_emulators) {
+                if (started_emulators.indexOf(install_target) > -1) {
+                    return emulator.resolveTarget(install_target);
+                }
+                return emulator.list_images()
+                .then(function(avds) {
+                    // if target emulator isn't started, then start it.
+                    for (avd in avds) {
+                        if (avds[avd].name == install_target) {
+                            return emulator.start(install_target)
+                            .then(function(emulatorId) {
+                                return emulator.resolveTarget(emulatorId);
+                            });
+                        }
+                    }
+                    return Q.reject('Target \'' + install_target + '\' not found, unable to run project');
+                });
+            });
+        });
+    }).then(function(resolvedTarget) {
+        return build.run(buildFlags, resolvedTarget).then(function(buildResults) {
+            if (resolvedTarget.isEmulator) {
+                return emulator.install(resolvedTarget, buildResults);
+            }
+            return device.install(resolvedTarget, buildResults);
+        });
     });
 }
 

bin/templates/cordova/version

@@ -20,6 +20,6 @@
 */
 
 // Coho updates this line:
-var VERSION = "3.6.0-dev";
+var VERSION = "3.7.0-dev";
 
 console.log(VERSION);

bin/templates/project/Activity.java

@@ -28,6 +28,7 @@ public class __ACTIVITY__ extends CordovaActivity
     public void onCreate(Bundle savedInstanceState)
     {
         super.onCreate(savedInstanceState);
+        super.init();
         // Set by <content src="index.html" /> in config.xml
         loadUrl(launchUrl);
     }

bin/templates/project/AndroidManifest.xml

@@ -31,7 +31,7 @@
     <uses-permission android:name="android.permission.INTERNET" />
 
     <application android:icon="@drawable/icon" android:label="@string/app_name"
-        android:hardwareAccelerated="true">
+        android:hardwareAccelerated="true" android:supportsRtl="true">
         <activity android:name="__ACTIVITY__"
                 android:label="@string/activity_name"
                 android:launchMode="singleTop"

bin/templates/project/build.gradle

@@ -0,0 +1,195 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+
+// GENERATED FILE! DO NOT EDIT!
+
+import java.util.regex.Pattern
+import groovy.swing.SwingBuilder
+
+ext.cordova = {}
+apply from: 'cordova.gradle', to: ext.cordova
+apply plugin: 'android'
+
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:0.12.0+'
+    }
+}
+
+task wrapper(type: Wrapper) {
+    gradleVersion = '1.12'
+}
+
+ext.multiarch=false
+
+android {
+    sourceSets {
+        main {
+            manifest.srcFile 'AndroidManifest.xml'
+            java.srcDirs = ['src']
+            resources.srcDirs = ['src']
+            aidl.srcDirs = ['src']
+            renderscript.srcDirs = ['src']
+            res.srcDirs = ['res']
+            assets.srcDirs = ['assets']
+        }
+    }
+
+    defaultConfig {
+        versionCode Integer.parseInt(System.env.ANDROID_VERSION_CODE ?: ("" + getVersionCodeFromManifest() + "0"))
+    }
+
+    compileSdkVersion cordova.cordovaSdkVersion
+    buildToolsVersion cordova.cordovaBuildToolsVersion
+
+    if (multiarch || System.env.BUILD_MULTIPLE_APKS) {
+        productFlavors {
+            armv7 {
+                versionCode defaultConfig.versionCode + 2
+                ndk {
+                    abiFilters "armeabi-v7a", ""
+                }
+            }
+            x86 {
+                versionCode defaultConfig.versionCode + 4
+                ndk {
+                    abiFilters "x86", ""
+                }
+            }
+            all {
+                ndk {
+                    abiFilters "all", ""
+                }
+            }
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_7
+        targetCompatibility JavaVersion.VERSION_1_7
+    }
+
+    if (System.env.RELEASE_SIGNING_PROPERTIES_FILE) {
+        signingConfigs {
+            release {
+                // These must be set or Gradle will complain (even if they are overridden).
+                keyAlias = ""
+                keyPassword = ""
+                storeFile = null
+                storePassword = ""
+            }
+        }
+        buildTypes {
+            release {
+                signingConfig signingConfigs.release
+            }
+        }
+        addSigningProps(System.env.RELEASE_SIGNING_PROPERTIES_FILE, signingConfigs.release)
+    }
+    if (System.env.DEBUG_SIGNING_PROPERTIES_FILE) {
+        addSigningProps(System.env.DEBUG_SIGNING_PROPERTIES_FILE, signingConfigs.debug)
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: '*.jar')
+    // SUB-PROJECT DEPENDENCIES START
+    // SUB-PROJECT DEPENDENCIES END
+}
+
+
+def promptForPassword(msg) {
+    if (System.console() == null) {
+        def ret = null
+        new SwingBuilder().edt {
+            dialog(modal: true, title: 'Enter password', alwaysOnTop: true, resizable: false, locationRelativeTo: null, pack: true, show: true) {
+                vbox {
+                    label(text: msg)
+                    def input = passwordField()
+                    button(defaultButton: true, text: 'OK', actionPerformed: {
+                        ret = input.password;
+                        dispose();
+                    })
+                }
+            }
+        }
+        if (!ret) {
+            throw new GradleException('User canceled build')
+        }
+        return new String(ret)
+    } else {
+        return System.console().readPassword('\n' + msg);
+    }
+}
+
+def promptForReleaseKeyPassword() {
+    if (!System.env.RELEASE_SIGNING_PROPERTIES_FILE) {
+        return;
+    }
+    if (!android.signingConfigs.release.storePassword) {
+        android.signingConfigs.release.storePassword = promptForPassword('Enter key store password: ')
+        println('set to:' + android.signingConfigs.release.storePassword)
+    }
+    if (!android.signingConfigs.release.keyPassword) {
+        android.signingConfigs.release.keyPassword = promptForPassword('Enter key password: ');
+    }
+}
+
+gradle.taskGraph.whenReady { taskGraph ->
+    taskGraph.getAllTasks().each() { task ->
+        if (task.name == 'validateReleaseSigning') {
+            promptForReleaseKeyPassword()
+        }
+    }
+}
+
+def getVersionCodeFromManifest() {
+    def manifestFile = file(android.sourceSets.main.manifest.srcFile)
+    def pattern = Pattern.compile("versionCode=\"(\\d+)\"")
+    def matcher = pattern.matcher(manifestFile.getText())
+    matcher.find()
+    return Integer.parseInt(matcher.group(1))
+}
+
+def ensureValueExists(filePath, props, key) {
+    if (props.get(key) == null) {
+        throw new GradleException(filePath + ': Missing key required "' + key + '"')
+    }
+    return props.get(key)
+}
+
+def addSigningProps(propsFilePath, signingConfig) {
+    def propsFile = file(propsFilePath)
+    propsFile.withReader { reader ->
+        def props = new Properties()
+        props.load(reader)
+        signingConfig.keyAlias = ensureValueExists(propsFilePath, props, 'keyAlias')
+        signingConfig.keyPassword = props.get('keyPassword')
+        signingConfig.storeFile = RelativePath.parse(true, ensureValueExists(propsFilePath, props, 'storeFile')).getFile(propsFile.getParentFile())
+        signingConfig.storePassword = props.get('storePassword')
+    }
+}
+
+if (file('build-extras.gradle').exists()) {
+    apply from: 'build-extras.gradle'
+}

bin/templates/project/cordova.gradle

@@ -0,0 +1,120 @@
+/*
+       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.
+*/
+
+import java.util.regex.Pattern
+
+String getProjectTarget(String defaultTarget) {
+    def manifestFile = file("project.properties")
+    def pattern = Pattern.compile("target\\s*=\\s*(.*)")
+    def matcher = pattern.matcher(manifestFile.getText())
+    if (matcher.find()) {
+        matcher.group(1)
+    } else {
+        defaultTarget
+    }
+}
+
+String[] getAvailableBuildTools() {
+    def buildToolsDir = new File(getAndroidSdkDir(), "build-tools")
+    buildToolsDir.list()
+        .findAll { it ==~ /[0-9.]+/ }
+        .sort { a, b -> compareVersions(b, a) }
+}
+
+String latestBuildToolsAvailable(String minBuildToolsVersion) {
+    def availableBuildToolsVersions
+    try {
+        availableBuildToolsVersions = getAvailableBuildTools()
+    } catch (e) {
+        println "An exception occurred while trying to find the Android build tools."
+        throw e
+    }
+    if (availableBuildToolsVersions.length > 0) {
+        def highestBuildToolsVersion = availableBuildToolsVersions[0]
+        if (compareVersions(highestBuildToolsVersion, minBuildToolsVersion) < 0) {
+            throw new RuntimeException(
+                "No usable Android build tools found. Highest installed version is " +
+                highestBuildToolsVersion + "; minimum version required is " +
+                minBuildToolsVersion + ".")
+        }
+        highestBuildToolsVersion
+    } else {
+        throw new RuntimeException(
+            "No installed build tools found. Please install the Android build tools version " +
+            minBuildToolsVersion + " or higher.")
+    }
+}
+
+// Return the first non-zero result of subtracting version list elements
+// pairwise. If they are all identical, return the difference in length of
+// the two lists.
+int compareVersionList(Collection aParts, Collection bParts) {
+    def pairs = ([aParts, bParts]).transpose()
+    pairs.findResult(aParts.size()-bParts.size()) {it[0] - it[1] != 0 ? it[0] - it[1] : null}
+}
+
+// Compare two version strings, such as "19.0.0" and "18.1.1.0". If all matched
+// elements are identical, the longer version is the largest by this method.
+// Examples:
+//   "19.0.0" > "19"
+//   "19.0.1" > "19.0.0"
+//   "19.1.0" > "19.0.1"
+//   "19" > "18.999.999"
+int compareVersions(String a, String b) {
+    def aParts = a.tokenize('.').collect {it.toInteger()}
+    def bParts = b.tokenize('.').collect {it.toInteger()}
+    compareVersionList(aParts, bParts)
+}
+
+String getAndroidSdkDir() {
+    def rootDir = project.rootDir
+    def androidSdkDir = null
+    String envVar = System.getenv("ANDROID_HOME")
+    def localProperties = new File(rootDir, 'local.properties')
+    String systemProperty = System.getProperty("android.home")
+    if (envVar != null) {
+        androidSdkDir = envVar
+    } else if (localProperties.exists()) {
+        Properties properties = new Properties()
+        localProperties.withInputStream { instr ->
+            properties.load(instr)
+        }
+        def sdkDirProp = properties.getProperty('sdk.dir')
+        if (sdkDirProp != null) {
+            androidSdkDir = sdkDirProp
+        } else {
+            sdkDirProp = properties.getProperty('android.dir')
+            if (sdkDirProp != null) {
+                androidSdkDir = (new File(rootDir, sdkDirProp)).getAbsolutePath()
+            }
+        }
+    }
+    if (androidSdkDir == null && systemProperty != null) {
+        androidSdkDir = systemProperty
+    }
+    if (androidSdkDir == null) {
+        throw new RuntimeException(
+            "Unable to determine Android SDK directory.")
+    }
+    androidSdkDir
+}
+
+ext.cordovaSdkVersion =  System.env.MIN_SDK_VERSION ?: getProjectTarget("android-19")
+ext.cordovaBuildToolsVersion = latestBuildToolsAvailable("19.1.0")
+

bin/templates/project/gitignore

@@ -0,0 +1,14 @@
+# Non-project-specific build files:
+build.xml
+local.properties
+/gradlew
+/gradlew.bat
+/gradle
+# Ant builds
+ant-built
+ant-gen
+# Eclipse builds
+gen
+out
+# Gradle builds
+/build

bin/templates/project/project.properties

@@ -0,0 +1,15 @@
+# This file is automatically generated by Android Tools.
+# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
+#
+# This file must be checked in Version Control Systems.
+#
+# To customize properties used by the Ant build system edit
+# "ant.properties", and override values to adapt the script to your
+# project structure.
+#
+# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
+#proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
+
+android.library.reference.1=CordovaLib
+# Project target.
+target=This_gets_replaced

framework/assets/www/cordova.js

@@ -1,5 +1,5 @@
 // Platform: android
-// 3.6.0-dev-70cdca3
+// 8ca0f3b2b87e0759c5236b91c80f18438544409c
 /*
  Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
@@ -19,7 +19,7 @@
  under the License.
 */
 ;(function() {
-var CORDOVA_JS_BUILD_LABEL = '3.6.0-dev-70cdca3';
+var PLATFORM_VERSION_BUILD_LABEL = '3.7.0-dev';
 // file: src/scripts/require.js
 
 /*jshint -W079 */
@@ -175,7 +175,8 @@ function createEvent(type, data) {
 var cordova = {
     define:define,
     require:require,
-    version:CORDOVA_JS_BUILD_LABEL,
+    version:PLATFORM_VERSION_BUILD_LABEL,
+    platformVersion:PLATFORM_VERSION_BUILD_LABEL,
     platformId:platform.id,
     /**
      * Methods to add/remove your own addEventListener hijacking on document + window.
@@ -1183,6 +1184,16 @@ function replaceNavigator(origNavigator) {
         for (var key in origNavigator) {
             if (typeof origNavigator[key] == 'function') {
                 newNavigator[key] = origNavigator[key].bind(origNavigator);
+            } else {
+                (function(k) {
+                        Object.defineProperty(newNavigator, k, {
+                            get: function() {
+                                return origNavigator[k];
+                            },
+                            configurable: true,
+                            enumerable: true
+                        });
+                    })(key);
             }
         }
     }
@@ -1302,6 +1313,16 @@ function replaceNavigator(origNavigator) {
         for (var key in origNavigator) {
             if (typeof origNavigator[key] == 'function') {
                 newNavigator[key] = origNavigator[key].bind(origNavigator);
+            } else {
+                (function(k) {
+                        Object.defineProperty(newNavigator, k, {
+                            get: function() {
+                                return origNavigator[k];
+                            },
+                            configurable: true,
+                            enumerable: true
+                        });
+                    })(key);
             }
         }
     }
@@ -1497,6 +1518,17 @@ module.exports = {
         cordova.addDocumentEventHandler('menubutton');
         cordova.addDocumentEventHandler('searchbutton');
 
+        function bindButtonChannel(buttonName) {
+            // generic button bind used for volumeup/volumedown buttons
+            var volumeButtonChannel = cordova.addDocumentEventHandler(buttonName + 'button');
+            volumeButtonChannel.onHasSubscribersChange = function() {
+                exec(null, null, "App", "overrideButton", [buttonName, this.numHandlers == 1]);
+            };
+        }
+        // Inject a listener for the volume buttons on the document.
+        bindButtonChannel('volumeup');
+        bindButtonChannel('volumedown');
+
         // Let native code know we are all done on the JS side.
         // Native code will then un-hide the WebView.
         channel.onCordovaReady.subscribe(function() {
@@ -1574,6 +1606,21 @@ module.exports = {
         exec(null, null, "App", "overrideBackbutton", [override]);
     },
 
+    /**
+    * Override the default behavior of the Android volume button.
+    * If overridden, when the volume button is pressed, the "volume[up|down]button"
+    * JavaScript event will be fired.
+    *
+    * Note: The user should not have to call this method.  Instead, when the user
+    *       registers for the "volume[up|down]button" event, this is automatically done.
+    *
+    * @param button          volumeup, volumedown
+    * @param override        T=override, F=cancel override
+    */
+    overrideButton:function(button, override) {
+        exec(null, null, "App", "overrideButton", [button, override]);
+    },
+
     /**
     * Exit and terminate the application.
     */
@@ -1667,11 +1714,11 @@ function handlePluginsObject(path, moduleList, finishPluginLoading) {
 function findCordovaPath() {
     var path = null;
     var scripts = document.getElementsByTagName('script');
-    var term = 'cordova.js';
+    var term = '/cordova.js';
     for (var n = scripts.length-1; n>-1; n--) {
         var src = scripts[n].src.replace(/\?.*$/, ''); // Strip any query param (CB-6007).
         if (src.indexOf(term) == (src.length - term.length)) {
-            path = src.substring(0, src.length - term.length);
+            path = src.substring(0, src.length - term.length) + '/';
             break;
         }
     }

framework/build.gradle

@@ -0,0 +1,63 @@
+/* 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.
+*/
+
+
+
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        // This should be updated with each cordova-android release.
+        // It can affect things like where the .apk is generated.
+        // It also dictates what the minimum android build-tools version
+        // that you need (Set in bin/templates/project/cordova.gradle).
+        // Make sure the value is the same in all locations:
+        // * framework/build.gradle
+        // * bin/templates/project/cordova.gradle
+        // * bin/templates/cordova/lib/plugin-build.gradle
+        // * distributionUrl within bin/templates/cordova/lib/build.js.
+        classpath 'com.android.tools.build:gradle:0.12.+'
+    }
+}
+
+apply plugin: 'android-library'
+
+android {
+    compileSdkVersion cordova.cordovaSdkVersion
+    buildToolsVersion cordova.cordovaBuildToolsVersion
+    publishNonDefault true
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_7
+        targetCompatibility JavaVersion.VERSION_1_7
+    }
+
+    sourceSets {
+        main {
+            manifest.srcFile 'AndroidManifest.xml'
+            java.srcDirs = ['src']
+            resources.srcDirs = ['src']
+            aidl.srcDirs = ['src']
+            renderscript.srcDirs = ['src']
+            res.srcDirs = ['res']
+            assets.srcDirs = ['assets']
+        }
+    }
+}

framework/src/org/apache/cordova/CordovaActivity.java

@@ -49,6 +49,7 @@ import android.view.Menu;
 import android.view.MenuItem;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.ViewParent;
 import android.view.Window;
 import android.view.WindowManager;
 import android.webkit.ValueCallback;
@@ -72,6 +73,7 @@ import android.widget.LinearLayout;
  *       @Override
  *       public void onCreate(Bundle savedInstanceState) {
  *         super.onCreate(savedInstanceState);
+ *         super.init();
  *         // Load your application
  *         loadUrl(launchUrl);
  *       }
@@ -200,14 +202,33 @@ public class CordovaActivity extends Activity implements CordovaInterface {
     public void onCreate(Bundle savedInstanceState) {
         LOG.i(TAG, "Apache Cordova native platform version " + CordovaWebView.CORDOVA_VERSION + " is starting");
         LOG.d(TAG, "CordovaActivity.onCreate()");
+
+        // need to activate preferences before super.onCreate to avoid "requestFeature() must be called before adding content" exception
+        loadConfig();
+        if(!preferences.getBoolean("ShowTitle", false))
+        {
+            getWindow().requestFeature(Window.FEATURE_NO_TITLE);
+        }
+        
+        if(preferences.getBoolean("SetFullscreen", false))
+        {
+            Log.d(TAG, "The SetFullscreen configuration is deprecated in favor of Fullscreen, and will be removed in a future version.");
+            getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
+                    WindowManager.LayoutParams.FLAG_FULLSCREEN);
+        } else if (preferences.getBoolean("Fullscreen", false)) {
+            getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
+                    WindowManager.LayoutParams.FLAG_FULLSCREEN);
+        } else {
+            getWindow().setFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN,
+                    WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
+        }
+
         super.onCreate(savedInstanceState);
 
         if(savedInstanceState != null)
         {
             initCallbackClass = savedInstanceState.getString("callbackClass");
         }
-        
-        loadConfig();
     }
 
     @SuppressWarnings("deprecation")
@@ -227,7 +248,9 @@ public class CordovaActivity extends Activity implements CordovaInterface {
     @SuppressWarnings("deprecation")
     protected void createViews() {
         // This builds the view.  We could probably get away with NOT having a LinearLayout, but I like having a bucket!
-        // This builds the view.  We could probably get away with NOT having a LinearLayout, but I like having a bucket!
+
+        LOG.d(TAG, "CordovaActivity.createViews()");
+
         Display display = getWindowManager().getDefaultDisplay();
         int width = display.getWidth();
         int height = display.getHeight();
@@ -245,13 +268,19 @@ public class CordovaActivity extends Activity implements CordovaInterface {
 
         // Add web view but make it invisible while loading URL
         appView.setVisibility(View.INVISIBLE);
+        
+        // need to remove appView from any existing parent before invoking root.addView(appView)
+        ViewParent parent = appView.getParent();
+        if ((parent != null) && (parent != root)) {
+            LOG.d(TAG, "removing appView from existing parent");
+            ViewGroup parentGroup = (ViewGroup) parent;
+            parentGroup.removeView(appView);
+        }
         root.addView((View) appView);
         setContentView(root);
 
-        // TODO: Setting this on the appView causes it to show when <html style="opacity:0">.
         int backgroundColor = preferences.getInteger("BackgroundColor", Color.BLACK);
         root.setBackgroundColor(backgroundColor);
-        appView.setBackgroundColor(backgroundColor);
     }
 
     /**
@@ -304,24 +333,6 @@ public class CordovaActivity extends Activity implements CordovaInterface {
     public void init(CordovaWebView webView, CordovaWebViewClient webViewClient, CordovaChromeClient webChromeClient) {
         LOG.d(TAG, "CordovaActivity.init()");
 
-        if(!preferences.getBoolean("ShowTitle", false))
-        {
-            getWindow().requestFeature(Window.FEATURE_NO_TITLE);
-        }
-
-        if(preferences.getBoolean("SetFullscreen", false))
-        {
-            Log.d(TAG, "The SetFullscreen configuration is deprecated in favor of Fullscreen, and will be removed in a future version.");
-            getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
-                    WindowManager.LayoutParams.FLAG_FULLSCREEN);
-        } else if (preferences.getBoolean("Fullscreen", false)) {
-            getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
-                    WindowManager.LayoutParams.FLAG_FULLSCREEN);
-        } else {
-            getWindow().setFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN,
-                    WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
-        }
-
         appView = webView != null ? webView : makeWebView();
         if (appView.pluginManager == null) {
             appView.init(this, webViewClient != null ? webViewClient : makeWebViewClient(appView),

framework/src/org/apache/cordova/CordovaChromeClient.java

@@ -65,6 +65,9 @@ public class CordovaChromeClient extends WebChromeClient {
     // the video progress view
     private View mVideoProgressView;
     
+    //Keep track of last AlertDialog showed
+    private AlertDialog lastHandledDialog;
+    
     // File Chooser
     public ValueCallback<Uri> mUploadMessage;
     
@@ -123,7 +126,7 @@ public class CordovaChromeClient extends WebChromeClient {
                     return true;
             }
         });
-        dlg.show();
+        lastHandledDialog = dlg.show();
         return true;
     }
 
@@ -172,7 +175,7 @@ public class CordovaChromeClient extends WebChromeClient {
                     return true;
             }
         });
-        dlg.show();
+        lastHandledDialog = dlg.show();
         return true;
     }
 
@@ -216,7 +219,7 @@ public class CordovaChromeClient extends WebChromeClient {
                             res.cancel();
                         }
                     });
-            dlg.show();
+            lastHandledDialog = dlg.show();
         }
         return true;
     }
@@ -328,4 +331,11 @@ public class CordovaChromeClient extends WebChromeClient {
     public ValueCallback<Uri> getValueCallback() {
         return this.mUploadMessage;
     }
+    
+    public void destroyLastDialog(){
+        if(lastHandledDialog != null){
+                lastHandledDialog.cancel();
+        }
+    }
+
 }

framework/src/org/apache/cordova/CordovaWebView.java

@@ -61,7 +61,7 @@ import android.widget.FrameLayout;
 public class CordovaWebView extends WebView {
 
     public static final String TAG = "CordovaWebView";
-    public static final String CORDOVA_VERSION = "3.6.0-dev";
+    public static final String CORDOVA_VERSION = "3.7.0-dev";
 
     private HashSet<Integer> boundKeyCodes = new HashSet<Integer>();
 
@@ -788,6 +788,9 @@ public class CordovaWebView extends WebView {
 
         // Load blank page so that JavaScript onunload is called
         this.loadUrl("about:blank");
+        
+        //Remove last AlertDialog
+        this.chromeClient.destroyLastDialog();
 
         // Forward to plugins
         if (this.pluginManager != null) {

package.json

@@ -1,28 +1,29 @@
 {
-  "name": "cordova-android",
-  "version": "3.4.0",
-  "description": "cordova-android release",
-  "main": "bin/create",
-  "repository": {
-    "type": "git",
-    "url": "https://git-wip-us.apache.org/repos/asf/cordova-android.git"
-  },
-  "keywords": [
-    "android",
-    "cordova",
-    "apache"
-  ],
-  "scripts": {
-    "test": "jasmine-node --color spec"
-  },
-  "author": "Apache Software Foundation",
-  "license": "Apache version 2.0",
-  "dependencies": {
-    "q": "^0.9.0",
-    "shelljs": "^0.2.6"
-  },
-  "devDependencies": {
-    "jasmine-node": "~1",
-    "promise-matchers": "~0"
-  }
-}
+    "name": "cordova-android",
+    "version": "3.7.0-dev",
+    "description": "cordova-android release",
+    "main": "bin/create",
+    "repository": {
+        "type": "git",
+        "url": "https://git-wip-us.apache.org/repos/asf/cordova-android.git"
+    },
+    "keywords": [
+        "android",
+        "cordova",
+        "apache"
+    ],
+    "scripts": {
+        "test": "jasmine-node --color spec",
+        "test-build": "rm -rf \"test create\"; ./bin/create \"test create\" com.test.app Test && \"./test create/cordova/build\" && rm -rf \"test create\""
+    },
+    "author": "Apache Software Foundation",
+    "license": "Apache version 2.0",
+    "dependencies": {
+        "q": "^0.9.0",
+        "shelljs": "^0.2.6"
+    },
+    "devDependencies": {
+        "jasmine-node": "~1",
+        "promise-matchers": "~0"
+    }
+}

test/AndroidManifest.xml

@@ -255,5 +255,15 @@
                 <category android:name="android.intent.category.SAMPLE_CODE" />
             </intent-filter>
         </activity>
+           <activity
+            android:windowSoftInputMode="adjustPan"
+            android:label="@string/app_name" 
+            android:configChanges="orientation|keyboardHidden"
+            android:name="org.apache.cordova.test.SabotagedActivity" >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.SAMPLE_CODE" />
+            </intent-filter>
+        </activity>
     </application>
 </manifest> 

test/README.md

@@ -34,7 +34,7 @@ found at https://code.google.com/p/robotium/ and the jar should be put in the
 To run manually from command line:
 
 0. Build by entering `ant debug install`
-0. Run tests by clicking on "CordovaTest" icon on device
+0. Run tests by clicking on "CordovaNativeTests" app icon on the device
 
 To run from Eclipse:
 

test/assets/www/htmlnotfound/error.html

@@ -14,6 +14,25 @@
          "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.$
+         under the License.
 -->
-This is an error page.
+<!DOCTYPE HTML>
+<html>
+  <head>
+    <meta name="viewport" content="width=320, user-scalable=no" />
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+    <title>Expected Error</title>
+      <link rel="stylesheet" href="../master.css" type="text/css" media="screen" title="no title">
+      <script type="text/javascript" charset="utf-8" src="../cordova.js"></script>
+      <script type="text/javascript" charset="utf-8" src="../main.js"></script>
+  </head>
+  <body onload="init();" id="stage" class="theme">
+    <h1>Expected Error</h1>
+    <div id="info">
+        <h4>Cordova: <span id="cordova"> &nbsp;</span></h4>
+        <h4>Deviceready: <span id="deviceready"> &nbsp;</span></h4>
+     </div>
+     <div id="info">
+     This is an expected error page because the initial href doesn't exist.
+  </body>
+</html>

test/assets/www/index.html

@@ -36,7 +36,7 @@
 
   </head>
   <body onload="init();" id="stage" class="theme">
-    <h1>Cordova Android Tests</h1>
+    <h1>Cordova Android Native Tests</h1>
     <div id="info">
         <h4>Cordova: <span id="cordova"> &nbsp;</span></h4>
         <h4>Deviceready: <span id="deviceready"> &nbsp;</span></h4>

test/assets/www/menus/index.html

@@ -33,7 +33,7 @@
         <h4>Deviceready: <span id="deviceready"> &nbsp;</span></h4>
      </div>
      <div id="info">
-     <h4>The menu items should be:</h4>
+     <h4>The options menu items should be:</h4>
      <li>Item1<br>
      <li>Item2<br>
      <li>Item3<br>

test/res/values/strings.xml

@@ -18,5 +18,5 @@
  under the License.
 -->
 <resources>
-   <string name="app_name">CordovaTests</string>
+   <string name="app_name">CordovaNativeTests</string>
 </resources>

test/res/xml/config.xml

@@ -26,10 +26,15 @@
         Apache Cordova Team
     </author>
     <access origin="*.apache.org" />
+    <access origin="http://*.google.com/*" />
+    <access origin="https://*.google.com/*" />
+    <access origin="https://*.googleapis.com/*" />
+    <access origin="https://*.gstatic.com/*" />
     <content src="index.html" />
     <preference name="loglevel" value="DEBUG" />
     <preference name="useBrowserHistory" value="true" />
     <preference name="exit-on-suspend" value="false" />
+    <preference name="showTitle" value="true" />
     <feature name="Activity">
         <param name="android-package" value="org.apache.cordova.test.ActivityPlugin" />
     </feature>

test/src/org/apache/cordova/test/CordovaWebViewTestActivity.java

@@ -52,7 +52,7 @@ public class CordovaWebViewTestActivity extends Activity implements CordovaInter
         
         cordovaWebView = (CordovaWebView) findViewById(R.id.cordovaWebView);
         cordovaWebView.init(this, new CordovaWebViewClient(this, cordovaWebView), new CordovaChromeClient(this, cordovaWebView),
-                Config.getPluginEntries(), Config.getWhitelist(), Config.getPreferences());
+                Config.getPluginEntries(), Config.getWhitelist(), Config.getExternalWhitelist(), Config.getPreferences());
 
         cordovaWebView.loadUrl("file:///android_asset/www/index.html");
 
@@ -105,4 +105,4 @@ public class CordovaWebViewTestActivity extends Activity implements CordovaInter
             cordovaWebView.handleDestroy();
         }
     }
-}
+}

test/src/org/apache/cordova/test/SabotagedActivity.java

@@ -0,0 +1,92 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+
+package org.apache.cordova.test;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.FileOutputStream;
+
+import org.apache.cordova.Config;
+import org.apache.cordova.CordovaActivity;
+
+import android.content.res.AssetManager;
+import android.os.Bundle;
+import android.os.Environment;
+import android.util.Log;
+
+public class SabotagedActivity extends CordovaActivity {
+
+    private String BAD_ASSET = "www/error.html";
+    private String LOG_TAG = "SabotagedActivity";
+    
+    
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);        
+        
+//        copyErrorAsset();
+        super.init();
+        super.loadUrl(Config.getStartUrl());
+    }
+
+    /* 
+     * Sometimes we need to move code around before we can do anything.  This will
+     * copy the bad code out of the assets before we initalize Cordova so that when Cordova actually
+     * initializes, we have something for it to navigate to.
+     */ 
+    
+    private void copyErrorAsset () {
+        AssetManager assetManager = getAssets();
+        String[] files = null;
+        try {
+            files = assetManager.list(BAD_ASSET);
+        } catch (IOException e) {
+            Log.e(LOG_TAG, e.getMessage());
+        }
+
+        for(String filename : files) {
+            InputStream in = null;
+            OutputStream out = null;
+            try {
+              in = assetManager.open(BAD_ASSET);
+              out = new FileOutputStream(Environment.getExternalStorageDirectory().toString() +"/" + filename);
+              copy(in, out);
+              in.close();
+              in = null;
+              out.flush();
+              out.close();
+              out = null;
+            } catch(Exception e) {
+                Log.e("tag", e.getMessage());
+            }
+        }
+    }
+    
+    
+    //Quick and Dirty Copy! 
+    private void copy(InputStream in, OutputStream out) throws IOException {
+        byte[] buffer = new byte[1024];
+        int read;
+        while((read = in.read(buffer)) != -1){
+          out.write(buffer, 0, read);
+        }
+    }
+}

test/src/org/apache/cordova/test/basicauth.java

@@ -21,7 +21,7 @@ package org.apache.cordova.test;
 import android.os.Bundle;
 import org.apache.cordova.*;
 
-public class basicauth extends DroidGap {
+public class basicauth extends CordovaActivity {
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
@@ -31,11 +31,13 @@ public class basicauth extends DroidGap {
         AuthenticationToken token = new AuthenticationToken();
         token.setUserName("test");
         token.setPassword("test");
-        super.setAuthenticationToken(token, "browserspy.dk:80", "BrowserSpy.dk - HTTP Password Test");
+        // classic webview includes port in hostname, Chromium webview does not. Handle both here.
+        // BTW, the realm is optional.
+        setAuthenticationToken(token, "browserspy.dk:80", "BrowserSpy.dk - HTTP Password Test");
+        setAuthenticationToken(token, "browserspy.dk", "BrowserSpy.dk - HTTP Password Test");
 
         // Add web site to whitelist
-        Config.init();
-        Config.addWhiteListEntry("http://browserspy.dk*", true);
+        Config.getWhitelist().addWhiteListEntry("http://browserspy.dk/*", true);
 
         // Load test
         super.loadUrl("file:///android_asset/www/basicauth/index.html");

test/src/org/apache/cordova/test/junit/IntentUriOverrideTest.java

@@ -0,0 +1,94 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+
+package org.apache.cordova.test.junit;
+
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.test.SabotagedActivity;
+import org.apache.cordova.test.splashscreen;
+
+import android.app.Instrumentation;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.AssetManager;
+import android.test.ActivityInstrumentationTestCase2;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+
+
+public class IntentUriOverrideTest extends ActivityInstrumentationTestCase2<SabotagedActivity> {
+    
+    private int TIMEOUT = 1000;
+    
+    private SabotagedActivity testActivity;
+    private FrameLayout containerView;
+    private LinearLayout innerContainer;
+    private CordovaWebView testView;
+    private Instrumentation mInstr;
+    private String BAD_URL = "file:///sdcard/download/wl-exploit.htm";
+
+
+    @SuppressWarnings("deprecation")
+    public IntentUriOverrideTest()
+    {
+        super("org.apache.cordova.test",SabotagedActivity.class);
+    }
+    
+    
+    protected void setUp() throws Exception {
+        super.setUp();
+        mInstr = this.getInstrumentation();
+        Intent badIntent = new Intent();
+        badIntent.setClassName("org.apache.cordova.test", "org.apache.cordova.test.SabotagedActivity");
+        badIntent.putExtra("url", BAD_URL);
+        setActivityIntent(badIntent);
+        testActivity = getActivity();
+        containerView = (FrameLayout) testActivity.findViewById(android.R.id.content);
+        innerContainer = (LinearLayout) containerView.getChildAt(0);
+        testView = (CordovaWebView) innerContainer.getChildAt(0);
+    }
+    
+    
+    public void testPreconditions(){
+        assertNotNull(innerContainer);
+        assertNotNull(testView);
+    }
+    
+    public void testChangeStartUrl() throws Throwable
+    {
+        runTestOnUiThread(new Runnable() {
+            public void run()
+            {
+                sleep();
+                boolean isBadUrl = testView.getUrl().equals(BAD_URL);
+                assertFalse(isBadUrl);
+            }
+        });
+    }
+
+    private void sleep() {
+        try {
+          Thread.sleep(TIMEOUT);
+        } catch (InterruptedException e) {
+          fail("Unexpected Timeout");
+        }
+    }
+    
+
+}

test/src/org/apache/cordova/test/menus.java

@@ -28,10 +28,11 @@ import android.view.ContextMenu.ContextMenuInfo;
 import org.apache.cordova.*;
 import org.apache.cordova.LOG;
 
-public class menus extends DroidGap {
+public class menus extends CordovaActivity {
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
+        // need the title to be shown (config.xml) for the options menu to be visible
         super.init();
         super.registerForContextMenu(super.appView);
         super.loadUrl("file:///android_asset/www/menus/index.html");