CB-7463: Adding licences. I don't know what the gradle syntax is for comments, that still needs to be done.

Need to show the title in order for the options menu button to be visible.

RELEASENOTES.md

@@ -20,6 +20,17 @@
 -->
 ## Release Notes for Cordova (Android) ##
 
+### 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.6.0

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,165 @@
        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, '..', '..');
 
+var isWindows = process.platform == 'win32';
+
+function forgivingWhichSync(cmd) {
+    try {
+        return which.sync(cmd);
+    } catch (e) {
+        return '';
+    }
+}
+
+function tryCommand(cmd, errMsg) {
+    var d = Q.defer();
+    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() {
     if(fs.existsSync(path.join(ROOT, 'framework', 'project.properties'))) {
-        var target = shell.grep(/target=android-[\d+]/, path.join(ROOT, 'framework', 'project.properties'));
+        var target = shelljs.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'));
+        var target = shelljs.grep(/target=android-[\d+]/, path.join(ROOT, 'project.properties')) ||
+          shelljs.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'));
+          target = shelljs.grep(/target=Google Inc.:Glass Development Kit Preview:[\d+]/, path.join(ROOT, 'project.properties'));
         }
         return target.split('=')[1].replace('\n', '').replace('\r', '');
     }
 }
 
-// Returns a promise.
+// Returns a promise. Called only by build and clean commands.
 module.exports.check_ant = function() {
-    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();
-    });
-    return d.promise;
-}
+    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.
+                    var maybeJavaHome = path.dirname(path.dirname(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 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];
+                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 your java environment is set up\n' +
+            'including JDK and JRE.\n' +
+            'Your JAVA_HOME variable is: ' + process.env['JAVA_HOME'];
+        return tryCommand('java -version', msg)
+    }).then(function() {
+        msg = 'Failed to run "javac -version", make sure you have a Java JDK (not just a JRE) installed.';
+        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']);
+        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) {
+module.exports.check_android_target = function(valid_target) {
+    var msg = 'Failed to run "android". Make sure you have the latest Android SDK installed, and that the "android" command (inside the tools/ folder) is added to your PATH.';
+    return tryCommand('android list targets', msg)
+    .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 ));
+            throw new Error('Please install Android target "' + valid_target + '".\n' +
+                'Hint: Run "android" from your command-line to open the SDK manager.');
         }
     });
-}
+};
 
 // 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, 'settings.gradle'), projectPath);
 }
 
 function copyScripts(projectPath) {
@@ -196,7 +229,7 @@ exports.createProject = function(project_path, package_name, project_name, proje
     })
     // Check that requirements are met and proper targets are installed
     .then(function() {
-        check_reqs.run();
+        return check_reqs.run();
     }).then(function() {
         // Log the given values for the project
         console.log('Creating Cordova project for the Android platform:');
@@ -212,6 +245,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 +277,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 +303,20 @@ function extractProjectNameFromManifest(projectPath) {
 }
 
 // Returns a promise.
-exports.updateProject = function(projectPath) {
-    var version = fs.readFileSync(path.join(ROOT, 'VERSION'), 'utf-8').trim();
+exports.updateProject = function(projectPath, shared) {
+    var newVersion = fs.readFileSync(path.join(ROOT, 'VERSION'), 'utf-8').trim();
     // Check that requirements are met and proper targets are installed
     return check_reqs.run()
     .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,342 @@ var shell   = require('shelljs'),
     path    = require('path'),
     fs      = require('fs'),
     ROOT    = path.join(__dirname, '..', '..');
+var check_reqs = require('./check_reqs');
 
+var LOCAL_PROPERTIES_TEMPLATE =
+    '# This file is automatically generated.\n' +
+    '# Do not modify this file -- YOUR CHANGES WILL BE ERASED!\n';
 
-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');
-    }
-    return args;
-};
-
-/*
- * Builds the project with ant.
- * 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);
-    });
-}
-
-/*
- * 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?)
- */
-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);
+function find_files(directory, predicate) {
+    if (fs.existsSync(directory)) {
+        var candidates = fs.readdirSync(directory).filter(predicate).map(function(p) {
+            p = path.join(directory, 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);
-        }
-        console.log('Using apk: ' + candidates[0].p);
-        return candidates[0].p;
+        }).map(function(p) { return p.p; });
+        return candidates;
     } else {
-        console.error('ERROR : unable to find project ' + binDir + ' directory, could not locate .apk');
+        console.error('ERROR : unable to find project ' + directory + ' directory, could not locate .apk');
         process.exit(2);
     }
 }
 
+function hasCustomRules() {
+    return fs.existsSync(path.join(ROOT, 'custom_rules.xml'));
+}
+
+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 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);
+            }).then(function() {
+                return builder.getOutputFiles();
+            });
+        },
+
+        clean: function() {
+            var args = this.getArgs('clean');
+            return check_reqs.check_ant()
+            .then(function() {
+                return spawn('ant', args);
+            });
+        },
+
+        // Find the recently-generated output APK files
+        // Ant only generates one output file; return it.
+        getOutputFiles: function() {
+            var binDir;
+            if(hasCustomRules()) {
+                binDir = path.join(ROOT, 'ant-build');
+            } else {
+                binDir = path.join(ROOT, 'bin');
+            }
+            var candidates = find_files(binDir, function(candidate) { return path.extname(candidate) == '.apk'; });
+            if (candidates.length === 0) {
+                console.error('ERROR : No .apk found in ' + binDir + ' directory');
+                process.exit(2);
+            }
+            console.log('Using apk: ' + candidates[0]);
+            return [candidates[0]];
+        }
+    },
+    gradle: {
+        getArgs: function(cmd) {
+            var lintSteps;
+            if (process.env['BUILD_MULTIPLE_APKS']) {
+                lintSteps = [
+                    'lint',
+                    'lintVitalX86Release',
+                    'lintVitalArmv7Release',
+                    'compileLint',
+                    'copyReleaseLint',
+                    'copyDebugLint'
+                ];
+            } else {
+                lintSteps = [
+                    'lint',
+                    'lintVitalRelease',
+                    'compileLint',
+                    'copyReleaseLint',
+                    'copyDebugLint'
+                ];
+            }
+            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'));
+            });
+        },
+
+        /*
+         * Builds the project with gradle.
+         * Returns a promise.
+         */
+        build: function(build_type) {
+            var builder = this;
+            var wrapper = path.join(ROOT, 'gradlew');
+            var args = builder.getArgs('build');
+            return Q().then(function() {
+                return spawn(wrapper, args);
+            }).then(function() {
+                return builder.getOutputFiles(build_type);
+            });
+        },
+
+        clean: function() {
+            var builder = this;
+            var wrapper = path.join(ROOT, 'gradlew');
+            var args = builder.getArgs('clean');
+            return Q().then(function() {
+                return spawn(wrapper, args);
+            });
+        },
+
+        // Find the recently-generated output APK files
+        // Gradle can generate multiple output files; return all of them.
+        getOutputFiles: function(build_type) {
+            var binDir = path.join(ROOT, 'build', 'apk');
+            var candidates = find_files(binDir, function(candidate) {
+                // Need to choose between release and debug .apk.
+                if (build_type === 'debug') {
+                    return (path.extname(candidate) == '.apk' && candidate.indexOf('-debug-') >= 0);
+                }
+                if (build_type === 'release') {
+                    return (path.extname(candidate) == '.apk' && candidate.indexOf('-release-') >= 0);
+                }
+                return path.extname(candidate) == '.apk';
+            });
+            return candidates;
+        }
+    },
+
+    none: {
+        prepEnv: function() {
+            return Q();
+        },
+        build: function() {
+            console.log('Skipping build...');
+            return Q();
+        },
+        clean: function() {
+            return Q();
+        },
+    }
+};
+
+function parseOpts(options) {
+    // Backwards-compatibility: Allow a single string argument
+    if (typeof options == "string") options = [options];
+
+    var ret = {
+        buildType: 'debug',
+        buildMethod: process.env['ANDROID_BUILD'] || 'ant'
+    };
+
+    // Iterate through command line options
+    for (var i=0; options && (i < options.length); ++i) {
+        if (options[i].substring && options[i].substring(0,2) == "--") {
+            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.');
+        }
+    }
+    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 the specifed options
+ * Returns a promise.
+ */
+module.exports.run = function(options) {
+    var opts = parseOpts(options);
+
+    var builder = builders[opts.buildMethod];
+    return builder.prepEnv()
+    .then(function() {
+        return builder.build(opts.buildType);
+    }).then(function(apkFiles) {
+        // TODO: Rather than copy apks to out, it might be better to
+        // just write out what the last .apk build was. These files
+        // are used by get_apk().
+        var outputDir = path.join(ROOT, 'out');
+        shell.mkdir('-p', outputDir);
+        for (var i=0; i < apkFiles.length; ++i) {
+            shell.cp('-f', apkFiles[i], path.join(outputDir, path.basename(apkFiles[i])));
+        }
+    });
+};
+
+/*
+ * 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?)
+ * This is called by the run script to install the apk to the device
+ */
+module.exports.get_apk = function(build_type, architecture) {
+    var outputDir = path.join(ROOT, 'out');
+    var candidates = find_files(outputDir, function(filename) { return (!architecture) || filename.indexOf(architecture) >= 0; });
+    if (candidates.length === 0) {
+        console.error('ERROR : No .apk found in ' + outputDir + ' directory');
+        process.exit(2);
+    }
+    // TODO: Use build_type here.
+    console.log('Using apk: ' + candidates[0]);
+    return candidates[0];
+};
+
 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/device.js

@@ -61,7 +61,12 @@ module.exports.install = function(target) {
         if (device_list.indexOf(target) < 0)
             return Q.reject('ERROR: Unable to find target \'' + target + '\'.');
 
-        var apk_path = build.get_apk();
+        var apk_path;
+        if (typeof process.env.DEPLOY_APK_ARCH == 'undefined') {
+            apk_path = build.get_apk();
+        } else {
+            apk_path = build.get_apk(null, process.env.DEPLOY_APK_ARCH);
+        }
         launchName = appinfo.getActivityName();
         console.log('Installing app on device...');
         var cmd = 'adb -s ' + target + ' install -r "' + apk_path + '"';

bin/templates/cordova/version

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

bin/templates/project/build.gradle

@@ -0,0 +1,94 @@
+import java.util.regex.Pattern
+
+apply plugin: 'android'
+
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:0.10.+'
+    }
+}
+
+ext.multiarch=false
+
+dependencies {
+    compile fileTree(dir: 'libs', include: '*.jar')
+    for (subproject in getProjectList()) {
+        compile project(subproject)
+    }
+}
+
+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("" + getVersionCodeFromManifest() + "0")
+    }
+
+    compileSdkVersion 19
+    buildToolsVersion "19.0.0"
+
+    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
+    }
+
+}
+
+task wrapper(type: Wrapper) {
+    gradleVersion = '1.12'
+}
+
+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 getProjectList() {
+    def manifestFile = file("project.properties")
+    def pattern = Pattern.compile("android.library.reference.(\\d+)\\s*=\\s*(.*)")
+    def matcher = pattern.matcher(manifestFile.getText())
+    def projects = []
+    while (matcher.find()) {
+      projects.add(":" + matcher.group(2).replace("/",":"))
+    }
+    return projects
+}

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

bin/templates/project/settings.gradle

@@ -0,0 +1,18 @@
+import java.util.regex.Pattern
+
+def getProjectList() {
+    def manifestFile = file("project.properties")
+    def pattern = Pattern.compile("android.library.reference.(\\d+)\\s*=\\s*(.*)")
+    def matcher = pattern.matcher(manifestFile.getText())
+    def projects = []
+    while (matcher.find()) {
+      projects.add(":" + matcher.group(2).replace("/",":"))
+    }
+    return projects
+}
+
+for (subproject in getProjectList()) {
+    include subproject
+}
+
+include ':'

framework/assets/www/cordova.js

@@ -1,5 +1,5 @@
 // Platform: android
-// 3.6.0-dev-70cdca3
+// 3.6.3
 /*
  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 CORDOVA_JS_BUILD_LABEL = '3.6.3';
 // file: src/scripts/require.js
 
 /*jshint -W079 */
@@ -1497,6 +1497,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 +1585,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 +1693,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

@@ -1,5 +1,3 @@
-#!/usr/bin/env node
-
 /*
        Licensed to the Apache Software Foundation (ASF) under one
        or more contributor license agreements.  See the NOTICE file
@@ -19,21 +17,38 @@
        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);
+
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:0.10.+'
+    }
 }
 
-module.exports.help = function() {
-    console.log('Usage: ' + path.relative(process.cwd(), process.argv[1]));
-    console.log('Cleans the project directory.');
-    process.exit(0);
+apply plugin: 'android-library'
+
+android {
+    compileSdkVersion 19
+    buildToolsVersion "19.0.0"
+
+    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

@@ -248,10 +248,8 @@ public class CordovaActivity extends Activity implements CordovaInterface {
         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);
     }
 
     /**

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.6.0";
 
     private HashSet<Integer> boundKeyCodes = new HashSet<Integer>();
 

package.json

@@ -1,28 +1,28 @@
 {
-  "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.6.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"
+    }
+}

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/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,6 +26,10 @@
         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" />

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,93 @@
+/*
+       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()
+            {
+                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,12 @@ 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 for the options menu to be visible
+        preferences.set("showTitle", true);
         super.init();
         super.registerForContextMenu(super.appView);
         super.loadUrl("file:///android_asset/www/menus/index.html");