incubator-callback-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bows...@apache.org
Subject [20/50] [abbrv] android commit: Merge commit and fix.
Date Thu, 07 Jun 2012 20:20:54 GMT
Merge commit and fix.


Project: http://git-wip-us.apache.org/repos/asf/incubator-cordova-android/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-cordova-android/commit/c37b2d23
Tree: http://git-wip-us.apache.org/repos/asf/incubator-cordova-android/tree/c37b2d23
Diff: http://git-wip-us.apache.org/repos/asf/incubator-cordova-android/diff/c37b2d23

Branch: refs/heads/master
Commit: c37b2d236bc51f5fddd558fab4179e63ece84b1b
Parents: c8a521c 2d77bcf
Author: Joe Bowser <bowserj@apache.org>
Authored: Thu May 24 09:31:11 2012 -0700
Committer: Joe Bowser <bowserj@apache.org>
Committed: Thu May 24 09:31:11 2012 -0700

----------------------------------------------------------------------
 bin/create.bat                                     |    2 +-
 bin/create.js                                      |  111 +++-
 bin/templates/project/cordova/create.bat           |    2 +
 bin/templates/project/cordova/create.js            |   69 ++
 .../cordova/templates/project/assets/www/main.js   |    2 +-
 .../templates/project/res/drawable-hdpi/icon.png   |  Bin 0 -> 6080 bytes
 .../templates/project/res/drawable-ldpi/icon.png   |  Bin 0 -> 3096 bytes
 .../templates/project/res/drawable-mdpi/icon.png   |  Bin 0 -> 4090 bytes
 .../templates/project/res/drawable-xhdpi/icon.png  |  Bin 0 -> 7685 bytes
 .../templates/project/res/drawable/icon.png        |  Bin 5800 -> 7685 bytes
 framework/assets/js/cordova.android.js             |  561 +++++++++++++--
 .../src/org/apache/cordova/AccelListener.java      |  273 +++----
 framework/src/org/apache/cordova/FileTransfer.java |  579 ++++++++-------
 13 files changed, 1114 insertions(+), 485 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-cordova-android/blob/c37b2d23/framework/assets/js/cordova.android.js
----------------------------------------------------------------------
diff --cc framework/assets/js/cordova.android.js
index 3b5c7d9,cdf619d..dc716fd
--- a/framework/assets/js/cordova.android.js
+++ b/framework/assets/js/cordova.android.js
@@@ -1,6 -1,6 +1,6 @@@
- // commit 55e46cecd73e06a4866f084ffa8513219ef68421
 -// commit 4a4ba9985c920850fe3f229abc60de984e196ab5
++// commit 68eebbca4a3691fed773d7599dd77c0030beabe6
  
- // File generated at :: Fri May 11 2012 10:34:50 GMT-0700 (PDT)
 -// File generated at :: Fri May 18 2012 13:43:11 GMT-0700 (PDT)
++// File generated at :: Thu May 24 2012 09:30:21 GMT-0700 (PDT)
  
  /*
   Licensed to the Apache Software Foundation (ASF) under one
@@@ -711,6 -711,6 +711,9 @@@ module.exports = 
              children: {
                  exec: {
                      path: 'cordova/exec'
++                },
++                logger: {
++                    path: 'cordova/plugin/logger'
                  }
              }
          },
@@@ -1169,7 -1170,7 +1173,7 @@@ for (var key in Camera) 
   * Gets a picture from source defined by "options.sourceType", and returns the
   * image as defined by the "options.destinationType" option.
  
-- * The defaults are sourceType=CAMERA and destinationType=FILE_URL.
++ * The defaults are sourceType=CAMERA and destinationType=FILE_URI.
   *
   * @param {Function} successCallback
   * @param {Function} errorCallback
@@@ -2115,7 -2116,7 +2119,7 @@@ Entry.prototype.toURL = function() 
  Entry.prototype.toURI = function(mimeType) {
      console.log("DEPRECATED: Update your code to use 'toURL'");
      // fullPath attribute contains the full URI
--    return this.fullPath;
++    return this.toURL();
  };
  
  /**
@@@ -4471,6 -4530,6 +4533,177 @@@ var exec = require('cordova/exec')
  module.exports = compass;
  });
  
++// file: lib/common/plugin/console-via-logger.js
++define("cordova/plugin/console-via-logger", function(require, exports, module) {
++//------------------------------------------------------------------------------
++
++var logger = require("cordova/plugin/logger");
++var utils  = require("cordova/utils");
++
++//------------------------------------------------------------------------------
++// object that we're exporting
++//------------------------------------------------------------------------------
++var console = module.exports;
++
++//------------------------------------------------------------------------------
++// copy of the original console object
++//------------------------------------------------------------------------------
++var WinConsole = window.console;
++
++//------------------------------------------------------------------------------
++// whether to use the logger
++//------------------------------------------------------------------------------
++var UseLogger = false;
++
++//------------------------------------------------------------------------------
++// Timers
++//------------------------------------------------------------------------------
++var Timers = {};
++
++//------------------------------------------------------------------------------
++// used for unimplemented methods
++//------------------------------------------------------------------------------
++function noop() {}
++
++//------------------------------------------------------------------------------
++// used for unimplemented methods
++//------------------------------------------------------------------------------
++console.useLogger = function (value) {
++    if (arguments.length) UseLogger = !!value;
++
++    if (UseLogger) {
++        if (logger.useConsole()) {
++            throw new Error("console and logger are too intertwingly");
++        }
++    }
++
++    return UseLogger;
++};
++
++//------------------------------------------------------------------------------
++console.log = function() {
++    if (logger.useConsole()) return;
++    logger.log.apply(logger, [].slice.call(arguments));
++};
++
++//------------------------------------------------------------------------------
++console.error = function() {
++    if (logger.useConsole()) return;
++    logger.error.apply(logger, [].slice.call(arguments));
++};
++
++//------------------------------------------------------------------------------
++console.warn = function() {
++    if (logger.useConsole()) return;
++    logger.warn.apply(logger, [].slice.call(arguments));
++};
++
++//------------------------------------------------------------------------------
++console.info = function() {
++    if (logger.useConsole()) return;
++    logger.info.apply(logger, [].slice.call(arguments));
++};
++
++//------------------------------------------------------------------------------
++console.debug = function() {
++    if (logger.useConsole()) return;
++    logger.debug.apply(logger, [].slice.call(arguments));
++};
++
++//------------------------------------------------------------------------------
++console.assert = function(expression) {
++    if (expression) return;
++
++    var message = utils.vformat(arguments[1], [].slice.call(arguments, 2));
++    console.log("ASSERT: " + message);
++};
++
++//------------------------------------------------------------------------------
++console.clear = function() {};
++
++//------------------------------------------------------------------------------
++console.dir = function(object) {
++    console.log("%o", object);
++};
++
++//------------------------------------------------------------------------------
++console.dirxml = function(node) {
++    console.log(node.innerHTML);
++};
++
++//------------------------------------------------------------------------------
++console.trace = noop;
++
++//------------------------------------------------------------------------------
++console.group = console.log;
++
++//------------------------------------------------------------------------------
++console.groupCollapsed = console.log;
++
++//------------------------------------------------------------------------------
++console.groupEnd = noop;
++
++//------------------------------------------------------------------------------
++console.time = function(name) {
++    Timers[name] = new Date().valueOf();
++};
++
++//------------------------------------------------------------------------------
++console.timeEnd = function(name) {
++    var timeStart = Timers[name];
++    if (!timeStart) {
++        console.warn("unknown timer: " + name);
++        return;
++    }
++
++    var timeElapsed = new Date().valueOf() - timeStart;
++    console.log(name + ": " + timeElapsed + "ms");
++};
++
++//------------------------------------------------------------------------------
++console.timeStamp = noop;
++
++//------------------------------------------------------------------------------
++console.profile = noop;
++
++//------------------------------------------------------------------------------
++console.profileEnd = noop;
++
++//------------------------------------------------------------------------------
++console.count = noop;
++
++//------------------------------------------------------------------------------
++console.exception = console.log;
++
++//------------------------------------------------------------------------------
++console.table = function(data, columns) {
++    console.log("%o", data);
++};
++
++//------------------------------------------------------------------------------
++// return a new function that calls both functions passed as args
++//------------------------------------------------------------------------------
++function wrapperedOrigCall(orgFunc, newFunc) {
++    return function() {
++        var args = [].slice.call(arguments);
++        try { orgFunc.apply(WinConsole, args); } catch (e) {}
++        try { newFunc.apply(console,    args); } catch (e) {}
++    };
++}
++
++//------------------------------------------------------------------------------
++// For every function that exists in the original console object, that
++// also exists in the new console object, wrap the new console method
++// with one that calls both
++//------------------------------------------------------------------------------
++for (var key in console) {
++    if (typeof WinConsole[key] == "function") {
++        console[key] = wrapperedOrigCall(WinConsole[key], console[key]);
++    }
++}
++
++});
++
  // file: lib/common/plugin/contacts.js
  define("cordova/plugin/contacts", function(require, exports, module) {
  var exec = require('cordova/exec'),
@@@ -4732,6 -4791,6 +4965,233 @@@ module.exports = geolocation
  
  });
  
++// file: lib/common/plugin/logger.js
++define("cordova/plugin/logger", function(require, exports, module) {
++//------------------------------------------------------------------------------
++// The logger module exports the following properties/functions:
++//
++// LOG                          - constant for the level LOG
++// ERROR                        - constant for the level ERROR
++// WARN                         - constant for the level WARN
++// INFO                         - constant for the level INFO
++// DEBUG                        - constant for the level DEBUG
++// logLevel()                   - returns current log level
++// logLevel(value)              - sets and returns a new log level
++// useConsole()                 - returns whether logger is using console
++// useConsole(value)            - sets and returns whether logger is using console
++// log(message,...)             - logs a message at level LOG
++// error(message,...)           - logs a message at level ERROR
++// warn(message,...)            - logs a message at level WARN
++// info(message,...)            - logs a message at level INFO
++// debug(message,...)           - logs a message at level DEBUG
++// logLevel(level,message,...)  - logs a message specified level
++//
++//------------------------------------------------------------------------------
++
++var logger = exports;
++
++var exec    = require('cordova/exec');
++var utils   = require('cordova/utils');
++
++var UseConsole   = true;
++var Queued       = [];
++var DeviceReady  = false;
++var CurrentLevel;
++
++/**
++ * Logging levels
++ */
++
++var Levels = [
++    "LOG",
++    "ERROR",
++    "WARN",
++    "INFO",
++    "DEBUG"
++];
++
++/*
++ * add the logging levels to the logger object and
++ * to a separate levelsMap object for testing
++ */
++
++var LevelsMap = {};
++for (var i=0; i<Levels.length; i++) {
++    var level = Levels[i];
++    LevelsMap[level] = i;
++    logger[level]    = level;
++}
++
++CurrentLevel = LevelsMap.WARN;
++
++/**
++ * Getter/Setter for the logging level
++ *
++ * Returns the current logging level.
++ *
++ * When a value is passed, sets the logging level to that value.
++ * The values should be one of the following constants:
++ *    logger.LOG
++ *    logger.ERROR
++ *    logger.WARN
++ *    logger.INFO
++ *    logger.DEBUG
++ *
++ * The value used determines which messages get printed.  The logging
++ * values above are in order, and only messages logged at the logging
++ * level or above will actually be displayed to the user.  Eg, the
++ * default level is WARN, so only messages logged with LOG, ERROR, or
++ * WARN will be displayed; INFO and DEBUG messages will be ignored.
++ */
++logger.level = function (value) {
++    if (arguments.length) {
++        if (LevelsMap[value] === null) {
++            throw new Error("invalid logging level: " + value);
++        }
++        CurrentLevel = LevelsMap[value];
++    }
++
++    return Levels[CurrentLevel];
++};
++
++/**
++ * Getter/Setter for the useConsole functionality
++ *
++ * When useConsole is true, the logger will log via the
++ * browser 'console' object.  Otherwise, it will use the
++ * native Logger plugin.
++ */
++logger.useConsole = function (value) {
++    if (arguments.length) UseConsole = !!value;
++
++    if (UseConsole) {
++        if (typeof console == "undefined") {
++            throw new Error("global console object is not defined");
++        }
++
++        if (typeof console.log != "function") {
++            throw new Error("global console object does not have a log function");
++        }
++
++        if (typeof console.useLogger == "function") {
++            if (console.useLogger()) {
++                throw new Error("console and logger are too intertwingly");
++            }
++        }
++    }
++
++    return UseConsole;
++};
++
++/**
++ * Logs a message at the LOG level.
++ *
++ * Parameters passed after message are used applied to
++ * the message with utils.format()
++ */
++logger.log   = function(message) { logWithArgs("LOG",   arguments); };
++
++/**
++ * Logs a message at the ERROR level.
++ *
++ * Parameters passed after message are used applied to
++ * the message with utils.format()
++ */
++logger.error = function(message) { logWithArgs("ERROR", arguments); };
++
++/**
++ * Logs a message at the WARN level.
++ *
++ * Parameters passed after message are used applied to
++ * the message with utils.format()
++ */
++logger.warn  = function(message) { logWithArgs("WARN",  arguments); };
++
++/**
++ * Logs a message at the INFO level.
++ *
++ * Parameters passed after message are used applied to
++ * the message with utils.format()
++ */
++logger.info  = function(message) { logWithArgs("INFO",  arguments); };
++
++/**
++ * Logs a message at the DEBUG level.
++ *
++ * Parameters passed after message are used applied to
++ * the message with utils.format()
++ */
++logger.debug = function(message) { logWithArgs("DEBUG", arguments); };
++
++// log at the specified level with args
++function logWithArgs(level, args) {
++    args = [level].concat([].slice.call(args));
++    logger.logLevel.apply(logger, args);
++}
++
++/**
++ * Logs a message at the specified level.
++ *
++ * Parameters passed after message are used applied to
++ * the message with utils.format()
++ */
++logger.logLevel = function(level, message /* , ... */) {
++    // format the message with the parameters
++    var formatArgs = [].slice.call(arguments, 2);
++    message    = utils.vformat(message, formatArgs);
++
++    if (LevelsMap[level] === null) {
++        throw new Error("invalid logging level: " + level);
++    }
++
++    if (LevelsMap[level] > CurrentLevel) return;
++
++    // queue the message if not yet at deviceready
++    if (!DeviceReady && !UseConsole) {
++        Queued.push([level, message]);
++        return;
++    }
++
++    // if not using the console, use the native logger
++    if (!UseConsole) {
++        exec(null, null, "Logger", "logLevel", [level, message]);
++        return;
++    }
++
++    // make sure console is not using logger
++    if (console.__usingCordovaLogger) {
++        throw new Error("console and logger are too intertwingly");
++    }
++
++    // log to the console
++    switch (level) {
++        case logger.LOG:   console.log(message); break;
++        case logger.ERROR: console.log("ERROR: " + message); break;
++        case logger.WARN:  console.log("WARN: "  + message); break;
++        case logger.INFO:  console.log("INFO: "  + message); break;
++        case logger.DEBUG: console.log("DEBUG: " + message); break;
++    }
++};
++
++// when deviceready fires, log queued messages
++logger.__onDeviceReady = function() {
++    if (DeviceReady) return;
++
++    DeviceReady = true;
++
++    for (var i=0; i<Queued.length; i++) {
++        var messageArgs = Queued[i];
++        logger.logLevel(messageArgs[0], messageArgs[1]);
++    }
++
++    Queued = null;
++};
++
++// add a deviceready event to log queued messages
++document.addEventListener("deviceready", logger.__onDeviceReady, false);
++
++});
++
  // file: lib/common/plugin/network.js
  define("cordova/plugin/network", function(require, exports, module) {
  var exec = require('cordova/exec'),
@@@ -5061,6 -5120,6 +5521,16 @@@ utils.alert = function(msg) 
  /**
   * Formats a string and arguments following it ala sprintf()
   *
++ * see utils.vformat() for more information
++ */
++utils.format = function(formatString /* ,... */) {
++    var args = [].slice.call(arguments, 1);
++    return utils.vformat(formatString, args);
++};
++
++/**
++ * Formats a string and arguments following it ala vsprintf()
++ *
   * format chars:
   *   %j - format arg as JSON
   *   %o - format arg as JSON
@@@ -5072,14 -5131,14 +5542,13 @@@
   * for rationale, see FireBug's Console API:
   *    http://getfirebug.com/wiki/index.php/Console_API
   */
--utils.format = function(formatString /* ,... */) {
++utils.vformat = function(formatString, args) {
      if (formatString === null || formatString === undefined) return "";
      if (arguments.length == 1) return formatString.toString();
  
      var pattern = /(.*?)%(.)(.*)/;
      var rest    = formatString.toString();
      var result  = [];
--    var args    = [].slice.call(arguments,1);
  
      while (args.length) {
          var arg   = args.shift();

http://git-wip-us.apache.org/repos/asf/incubator-cordova-android/blob/c37b2d23/framework/src/org/apache/cordova/AccelListener.java
----------------------------------------------------------------------
diff --cc framework/src/org/apache/cordova/AccelListener.java
index dbda3fe,9e19d75..1574f08
--- a/framework/src/org/apache/cordova/AccelListener.java
+++ b/framework/src/org/apache/cordova/AccelListener.java
@@@ -43,16 -50,16 +49,16 @@@ public class AccelListener extends Plug
      public static int STARTING = 1;
      public static int RUNNING = 2;
      public static int ERROR_FAILED_TO_START = 3;
+     
 -    private float x,y,z;						        // most recent acceleration values
 -    private long timestamp;					        // time of most recent value
 -    private int status;							        // status of listener
++    private float x,y,z;                                // most recent acceleration values
++    private long timestamp;                         // time of most recent value
++    private int status;                                 // status of listener
+     private int accuracy = SensorManager.SENSOR_STATUS_UNRELIABLE;
  
-     public float TIMEOUT = 30000;		// Timeout in msec to shut off listener
+     private SensorManager sensorManager;    // Sensor manager
 -    private Sensor mSensor;						      // Acceleration sensor returned by sensor manager
++    private Sensor mSensor;                           // Acceleration sensor returned by
sensor manager
  
-     float x, y, z;						// most recent acceleration values
-     long timestamp;						// time of most recent value
-     int status;							// status of listener
-     long lastAccessTime;				// time the value was last retrieved
- 
-     private SensorManager sensorManager;// Sensor manager
-     Sensor mSensor;						// Acceleration sensor returned by sensor manager
+     private String callbackId;              // Keeps track of the single "start" callback
ID passed in from JS
  
      /**
       * Create an accelerometer listener.
@@@ -80,106 -86,36 +86,36 @@@
      /**
       * Executes the request and returns PluginResult.
       * 
--     * @param action 		The action to execute.
--     * @param args 			JSONArry of arguments for the plugin.
--     * @param callbackId	The callback id used when calling back into JavaScript.
--     * @return 				A PluginResult object with a status and message.
++     * @param action        The action to execute.
++     * @param args          JSONArry of arguments for the plugin.
++     * @param callbackId    The callback id used when calling back into JavaScript.
++     * @return              A PluginResult object with a status and message.
       */
      public PluginResult execute(String action, JSONArray args, String callbackId) {
-         PluginResult.Status status = PluginResult.Status.OK;
-         String result = "";
- 
-         try {
-             if (action.equals("getStatus")) {
-                 int i = this.getStatus();
-                 return new PluginResult(status, i);
-             }
-             else if (action.equals("start")) {
-                 int i = this.start();
-                 return new PluginResult(status, i);
-             }
-             else if (action.equals("stop")) {
-                 this.stop();
-                 return new PluginResult(status, 0);
-             }
-             else if (action.equals("getAcceleration")) {
+         PluginResult.Status status = PluginResult.Status.NO_RESULT;
+         String message = "";
+         PluginResult result = new PluginResult(status, message);
 -        result.setKeepCallback(true);	
++        result.setKeepCallback(true);   
+ 
+         if (action.equals("start")) {
+             this.callbackId = callbackId;
+             if (this.status != AccelListener.RUNNING) {
                  // If not running, then this is an async call, so don't worry about waiting
-                 if (this.status != AccelListener.RUNNING) {
-                     int r = this.start();
-                     if (r == AccelListener.ERROR_FAILED_TO_START) {
-                         return new PluginResult(PluginResult.Status.IO_EXCEPTION, AccelListener.ERROR_FAILED_TO_START);
-                     }
-                     // Wait until running
-                     long timeout = 2000;
-                     while ((this.status == STARTING) && (timeout > 0)) {
-                         timeout = timeout - 100;
-                         try {
-                             Thread.sleep(100);
-                         } catch (InterruptedException e) {
-                             e.printStackTrace();
-                         }
-                     }
-                     if (timeout == 0) {
-                         return new PluginResult(PluginResult.Status.IO_EXCEPTION, AccelListener.ERROR_FAILED_TO_START);
-                     }
-                 }
-                 this.lastAccessTime = System.currentTimeMillis();
-                 JSONObject r = new JSONObject();
-                 r.put("x", this.x);
-                 r.put("y", this.y);
-                 r.put("z", this.z);
-                 // TODO: Should timestamp be sent?
-                 r.put("timestamp", this.timestamp);
-                 return new PluginResult(status, r);
-             }
-             else if (action.equals("setTimeout")) {
-                 try {
-                     float timeout = Float.parseFloat(args.getString(0));
-                     this.setTimeout(timeout);
-                     return new PluginResult(status, 0);
-                 } catch (NumberFormatException e) {
-                     status = PluginResult.Status.INVALID_ACTION;
-                     e.printStackTrace();
-                 } catch (JSONException e) {
-                     status = PluginResult.Status.JSON_EXCEPTION;
-                     e.printStackTrace();
-                 }
+                 // We drop the callback onto our stack, call start, and let start and the
sensor callback fire off the callback down the road
+                 this.start();
              }
-             else if (action.equals("getTimeout")) {
-                 float f = this.getTimeout();
-                 return new PluginResult(status, f);
-             } else {
-                 // Unsupported action
-                 return new PluginResult(PluginResult.Status.INVALID_ACTION);
-             }
-             return new PluginResult(status, result);
-         } catch (JSONException e) {
-             return new PluginResult(PluginResult.Status.JSON_EXCEPTION);
-         }
-     }
- 
-     /**
-      * Identifies if action to be executed returns a value and should be run synchronously.
-      * 
-      * @param action	The action to execute
-      * @return			T=returns value
-      */
-     public boolean isSynch(String action) {
-         if (action.equals("getStatus")) {
-             return true;
          }
-         else if (action.equals("getAcceleration")) {
-             // Can only return value if RUNNING
+         else if (action.equals("stop")) {
              if (this.status == AccelListener.RUNNING) {
-                 return true;
+                 this.stop();
              }
+         } else {
+           // Unsupported action
+             return new PluginResult(PluginResult.Status.INVALID_ACTION);
          }
-         else if (action.equals("getTimeout")) {
-             return true;
-         }
-         return false;
+         return result;
      }
- 
+     
      /**
       * Called by AccelBroker when listener is to be shut down.
       * Stop listener.
@@@ -195,32 -131,45 +131,45 @@@
      /**
       * Start listening for acceleration sensor.
       * 
--     * @return 			status of listener
++     * @return          status of listener
       */
-     public int start() {
- 
+     private int start() {
 -    	// If already starting or running, then just return
 -    	if ((this.status == AccelListener.RUNNING) || (this.status == AccelListener.STARTING))
{
 +        // If already starting or running, then just return
 +        if ((this.status == AccelListener.RUNNING) || (this.status == AccelListener.STARTING))
{
-             return this.status;
+           return this.status;
 -    	}
 -    	
 -    	this.setStatus(AccelListener.STARTING);
 -    	
 -    	// Get accelerometer from sensor manager
 -    	List<Sensor> list = this.sensorManager.getSensorList(Sensor.TYPE_ACCELEROMETER);
 +        }
- 
++        
++        this.setStatus(AccelListener.STARTING);
++        
 +        // Get accelerometer from sensor manager
 +        List<Sensor> list = this.sensorManager.getSensorList(Sensor.TYPE_ACCELEROMETER);
  
 -    	// If found, then register as listener
 -    	if ((list != null) && (list.size() > 0)) {
 +        // If found, then register as listener
 +        if ((list != null) && (list.size() > 0)) {
-             this.mSensor = list.get(0);
-             this.sensorManager.registerListener(this, this.mSensor, SensorManager.SENSOR_DELAY_FASTEST);
-             this.setStatus(AccelListener.STARTING);
-             this.lastAccessTime = System.currentTimeMillis();
+           this.mSensor = list.get(0);
+           this.sensorManager.registerListener(this, this.mSensor, SensorManager.SENSOR_DELAY_UI);
+           this.setStatus(AccelListener.STARTING);
 -    	} else {
++        } else {
+           this.setStatus(AccelListener.ERROR_FAILED_TO_START);
+           this.fail(AccelListener.ERROR_FAILED_TO_START, "No sensors found to register accelerometer
listening to.");
+           return this.status;
 -    	}
 -    	
 -    	// Wait until running
 -    	long timeout = 2000;
 -    	while ((this.status == STARTING) && (timeout > 0)) {
 +        }
- 
-         // If error, then set status to error
-         else {
-             this.setStatus(AccelListener.ERROR_FAILED_TO_START);
++        
++        // Wait until running
++        long timeout = 2000;
++        while ((this.status == STARTING) && (timeout > 0)) {
+           timeout = timeout - 100;
+           try {
+               Thread.sleep(100);
+           } catch (InterruptedException e) {
+               e.printStackTrace();
+           }
 -    	}
 -    	if (timeout == 0) {
++        }
++        if (timeout == 0) {
+           this.setStatus(AccelListener.ERROR_FAILED_TO_START);
+           this.fail(AccelListener.ERROR_FAILED_TO_START, "Accelerometer could not be started.");
 -    	}
 -    	return this.status;
 +        }
- 
 +        return this.status;
      }
  
      /**
@@@ -240,6 -190,16 +190,16 @@@
       * @param accuracy
       */
      public void onAccuracyChanged(Sensor sensor, int accuracy) {
 -    	// Only look at accelerometer events
++        // Only look at accelerometer events
+         if (sensor.getType() != Sensor.TYPE_ACCELEROMETER) {
+             return;
+         }
+         
+         // If not running, then just return
+         if (this.status == AccelListener.STOPPED) {
+             return;
+         }
+         this.accuracy = accuracy;
      }
  
      /**
@@@ -258,18 -217,18 +217,17 @@@
          if (this.status == AccelListener.STOPPED) {
              return;
          }
- 
-         // Save time that event was received
-         this.timestamp = System.currentTimeMillis();
-         this.x = event.values[0];
-         this.y = event.values[1];
-         this.z = event.values[2];
- 
 -        
          this.setStatus(AccelListener.RUNNING);
+         
+         if (this.accuracy >= SensorManager.SENSOR_STATUS_ACCURACY_MEDIUM) {
+ 
+             // Save time that event was received
+             this.timestamp = System.currentTimeMillis();
+             this.x = event.values[0];
+             this.y = event.values[1];
+             this.z = event.values[2];
  
-         // If values haven't been read for TIMEOUT time, then turn off accelerometer sensor
to save power
-         if ((this.timestamp - this.lastAccessTime) > this.TIMEOUT) {
-             this.stop();
+             this.win();
          }
      }
  
@@@ -303,9 -259,17 +258,17 @@@
      private void setStatus(int status) {
          this.status = status;
      }
- 
 -	
++    
+     private JSONObject getAccelerationJSON() {
+         JSONObject r = new JSONObject();
+         try {
+             r.put("x", this.x);
+             r.put("y", this.y);
+             r.put("z", this.z);
+             r.put("timestamp", this.timestamp);
+         } catch (JSONException e) {
+             e.printStackTrace();
+         }
+         return r;
+     }
  }

http://git-wip-us.apache.org/repos/asf/incubator-cordova-android/blob/c37b2d23/framework/src/org/apache/cordova/FileTransfer.java
----------------------------------------------------------------------
diff --cc framework/src/org/apache/cordova/FileTransfer.java
index e006230,368d97a..a040f47
--- a/framework/src/org/apache/cordova/FileTransfer.java
+++ b/framework/src/org/apache/cordova/FileTransfer.java
@@@ -206,201 -428,8 +426,7 @@@ public class FileTransfer extends Plugi
          return arg;
      }
  
 -
      /**
-      * Uploads the specified file to the server URL provided using an HTTP
-      * multipart request.
-      * @param file      Full path of the file on the file system
-      * @param server        URL of the server to receive the file
-      * @param fileKey       Name of file request parameter
-      * @param fileName      File name to be used on server
-      * @param mimeType      Describes file content type
-      * @param params        key:value pairs of user-defined parameters
-      * @return FileUploadResult containing result of upload request
-      */
-     @SuppressWarnings("deprecation")
-     public FileUploadResult upload(String file, String server, final String fileKey, final
String fileName,
-             final String mimeType, JSONObject params, boolean trustEveryone, boolean chunkedMode)
throws IOException, SSLException {
-         // Create return object
-         FileUploadResult result = new FileUploadResult();
- 
-         // Get a input stream of the file on the phone
-         FileInputStream fileInputStream = (FileInputStream) getPathFromUri(file);
- 
-         HttpURLConnection conn = null;
-         DataOutputStream dos = null;
- 
-         int bytesRead, bytesAvailable, bufferSize;
-         long totalBytes;
-         byte[] buffer;
-         int maxBufferSize = 8096;
- 
-         //------------------ CLIENT REQUEST
-         // open a URL connection to the server
-         URL url = new URL(server);
- 
-         // Open a HTTP connection to the URL based on protocol
-         if (url.getProtocol().toLowerCase().equals("https")) {
-             // Using standard HTTPS connection. Will not allow self signed certificate
-             if (!trustEveryone) {
-                 conn = (HttpsURLConnection) url.openConnection();
-             }
-             // Use our HTTPS connection that blindly trusts everyone.
-             // This should only be used in debug environments
-             else {
-                 // Setup the HTTPS connection class to trust everyone
-                 trustAllHosts();
-                 HttpsURLConnection https = (HttpsURLConnection) url.openConnection();
-                 // Save the current hostnameVerifier
-                 defaultHostnameVerifier = https.getHostnameVerifier();
-                 // Setup the connection not to verify hostnames
-                 https.setHostnameVerifier(DO_NOT_VERIFY);
-                 conn = https;
-             }
-         }
-         // Return a standard HTTP connection
-         else {
-             conn = (HttpURLConnection) url.openConnection();
-         }
- 
-         // Allow Inputs
-         conn.setDoInput(true);
- 
-         // Allow Outputs
-         conn.setDoOutput(true);
- 
-         // Don't use a cached copy.
-         conn.setUseCaches(false);
- 
-         // Use a post method.
-         conn.setRequestMethod("POST");
-         conn.setRequestProperty("Connection", "Keep-Alive");
-         conn.setRequestProperty("Content-Type", "multipart/form-data;boundary=" + BOUNDRY);
- 
-         // Handle the other headers
-         try {
-             JSONObject headers = params.getJSONObject("headers");
-             for (@SuppressWarnings("rawtypes")
-             Iterator iter = headers.keys(); iter.hasNext();)
-             {
-                 String headerKey = iter.next().toString();
-                 conn.setRequestProperty(headerKey, headers.getString(headerKey));
-             }
-         } catch (JSONException e1) {
-             // No headers to be manipulated!
-         }
- 
-         // Set the cookies on the response
-         String cookie = CookieManager.getInstance().getCookie(server);
-         if (cookie != null) {
-             conn.setRequestProperty("Cookie", cookie);
-         }
- 
-         /*
-          * Store the non-file portions of the multipart data as a string, so that we can
add it 
-          * to the contentSize, since it is part of the body of the HTTP request.
-          */
-         String extraParams = "";
-         try {
-             for (@SuppressWarnings("rawtypes")
-             Iterator iter = params.keys(); iter.hasNext();) {
-                 Object key = iter.next();
-                 if (key.toString() != "headers")
-                 {
-                     extraParams += LINE_START + BOUNDRY + LINE_END;
-                     extraParams += "Content-Disposition: form-data; name=\"" + key.toString()
+ "\";";
-                     extraParams += LINE_END + LINE_END;
-                     extraParams += params.getString(key.toString());
-                     extraParams += LINE_END;
-                 }
-             }
-         } catch (JSONException e) {
-             Log.e(LOG_TAG, e.getMessage(), e);
-         }
- 
-         extraParams += LINE_START + BOUNDRY + LINE_END;
-         extraParams += "Content-Disposition: form-data; name=\"" + fileKey + "\";" + " filename=\"";
- 
-         String midParams = "\"" + LINE_END + "Content-Type: " + mimeType + LINE_END + LINE_END;
-         String tailParams = LINE_END + LINE_START + BOUNDRY + LINE_START + LINE_END;
- 
-         // Should set this up as an option
-         if (chunkedMode) {
-             conn.setChunkedStreamingMode(maxBufferSize);
-         }
-         else
-         {
-             int stringLength = extraParams.length() + midParams.length() + tailParams.length()
+ fileName.getBytes("UTF-8").length;
-             Log.d(LOG_TAG, "String Length: " + stringLength);
-             int fixedLength = (int) fileInputStream.getChannel().size() + stringLength;
-             Log.d(LOG_TAG, "Content Length: " + fixedLength);
-             conn.setFixedLengthStreamingMode(fixedLength);
-         }
- 
-         dos = new DataOutputStream(conn.getOutputStream());
-         dos.writeBytes(extraParams);
-         //We don't want to chagne encoding, we just want this to write for all Unicode.
-         dos.write(fileName.getBytes("UTF-8"));
-         dos.writeBytes(midParams);
- 
-         // create a buffer of maximum size
-         bytesAvailable = fileInputStream.available();
-         bufferSize = Math.min(bytesAvailable, maxBufferSize);
-         buffer = new byte[bufferSize];
- 
-         // read file and write it into form...
-         bytesRead = fileInputStream.read(buffer, 0, bufferSize);
-         totalBytes = 0;
- 
-         while (bytesRead > 0) {
-             totalBytes += bytesRead;
-             result.setBytesSent(totalBytes);
-             dos.write(buffer, 0, bufferSize);
-             bytesAvailable = fileInputStream.available();
-             bufferSize = Math.min(bytesAvailable, maxBufferSize);
-             bytesRead = fileInputStream.read(buffer, 0, bufferSize);
-         }
- 
-         // send multipart form data necesssary after file data...
-         dos.writeBytes(tailParams);
- 
-         // close streams
-         fileInputStream.close();
-         dos.flush();
-         dos.close();
- 
-         //------------------ read the SERVER RESPONSE
-         StringBuffer responseString = new StringBuffer("");
-         DataInputStream inStream;
-         try {
-             inStream = new DataInputStream(conn.getInputStream());
-         } catch (FileNotFoundException e) {
-             throw new IOException("Received error from server");
-         }
- 
-         String line;
-         while ((line = inStream.readLine()) != null) {
-             responseString.append(line);
-         }
-         Log.d(LOG_TAG, "got response from server");
-         Log.d(LOG_TAG, responseString.toString());
- 
-         // send request and retrieve response
-         result.setResponseCode(conn.getResponseCode());
-         result.setResponse(responseString.toString());
- 
-         inStream.close();
-         conn.disconnect();
- 
-         // Revert back to the proper verifier and socket factories
-         if (trustEveryone && url.getProtocol().toLowerCase().equals("https")) {
-             ((HttpsURLConnection) conn).setHostnameVerifier(defaultHostnameVerifier);
-             HttpsURLConnection.setDefaultSSLSocketFactory(defaultSSLSocketFactory);
-         }
- 
-         return result;
-     }
- 
-     /**
       * Downloads a file form a given URL and saves it to the specified directory.
       *
       * @param source        URL of the server to receive the file
@@@ -415,42 -447,43 +444,47 @@@
              file.getParentFile().mkdirs();
  
              // connect to server
 -            if(this.ctx.isUrlWhiteListed(source))
 +            if (webView.isUrlWhiteListed(source))
              {
-                 URL url = new URL(source);
-                 HttpURLConnection connection = (HttpURLConnection) url.openConnection();
-                 connection.setRequestMethod("GET");
- 
-                 //Add cookie support
-                 String cookie = CookieManager.getInstance().getCookie(source);
-                 if (cookie != null)
-                 {
-                     connection.setRequestProperty("cookie", cookie);
-                 }
+               URL url = new URL(source);
+               connection = (HttpURLConnection) url.openConnection();
+               connection.setRequestMethod("GET");
+               
+               //Add cookie support
+               String cookie = CookieManager.getInstance().getCookie(source);
+               if(cookie != null)
+               {
+                 connection.setRequestProperty("cookie", cookie);
+               }
+               
+               connection.connect();
+ 
+               Log.d(LOG_TAG, "Download file: " + url);
  
 -              InputStream inputStream = connection.getInputStream();
 -              byte[] buffer = new byte[1024];
 -              int bytesRead = 0;
 +                connection.connect();
  
 -              FileOutputStream outputStream = new FileOutputStream(file);
 +                Log.d(LOG_TAG, "Download file:" + url);
  
 -              // write bytes to file
 -              while ( (bytesRead = inputStream.read(buffer)) > 0 ) {
 -                outputStream.write(buffer,0, bytesRead);
 -              }
 +                InputStream inputStream = connection.getInputStream();
 +                byte[] buffer = new byte[1024];
 +                int bytesRead = 0;
 +
 +                FileOutputStream outputStream = new FileOutputStream(file);
 +
 +                // write bytes to file
 +                while ((bytesRead = inputStream.read(buffer)) > 0) {
 +                    outputStream.write(buffer, 0, bytesRead);
 +                }
  
 -              outputStream.close();
 +                outputStream.close();
  
 -              Log.d(LOG_TAG, "Saved file: " + target);
 +                Log.d(LOG_TAG, "Saved file: " + target);
  
-                 // create FileEntry object
-                 FileUtils fileUtil = new FileUtils();
+               // create FileEntry object
+               FileUtils fileUtil = new FileUtils();
+               JSONObject fileEntry = fileUtil.getEntry(file);
  
-                 return fileUtil.getEntry(file);
+               return new PluginResult(PluginResult.Status.OK, fileEntry);
              }
              else
              {


Mime
View raw message