text: /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   * 
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010-2011, IBM Corporation
   */
  
  if (typeof PhoneGap === "undefined") {
  
  /**
   * The order of events during page load and PhoneGap startup is as follows:
   *
   * onDOMContentLoaded         Internal event that is received when the web page is loaded and parsed.
   * window.onload              Body onload event.
   * onNativeReady              Internal event that indicates the PhoneGap native side is ready.
   * onPhoneGapInit             Internal event that kicks off creation of all PhoneGap JavaScript objects (runs constructors).
   * onPhoneGapReady            Internal event fired when all PhoneGap JavaScript objects have been created
   * onPhoneGapInfoReady        Internal event fired when device properties are available
   * onDeviceReady              User event fired to indicate that PhoneGap is ready
   * onResume                   User event fired to indicate a start/resume lifecycle event
   * onPause                    User event fired to indicate a pause lifecycle event
   * onDestroy                  Internal event fired when app is being destroyed (User should use window.onunload event, not this one).
   *
   * The only PhoneGap events that user code should register for are:
   *      onDeviceReady
   *      onResume
   *
   * Listeners can be registered as:
   *      document.addEventListener("deviceready", myDeviceReadyListener, false);
   *      document.addEventListener("resume", myResumeListener, false);
   *      document.addEventListener("pause", myPauseListener, false);
   */
  
  if (typeof(DeviceInfo) !== 'object') {
      DeviceInfo = {};
  }
  
  /**
   * This represents the PhoneGap API itself, and provides a global namespace for accessing
   * information about the state of PhoneGap.
   * @class
   */
  var PhoneGap = {
      queue: {
          ready: true,
          commands: [],
          timer: null
      }
  };
  
  /**
   * List of resource files loaded by PhoneGap.
   * This is used to ensure JS and other files are loaded only once.
   */
  PhoneGap.resources = {base: true};
  
  /**
   * Determine if resource has been loaded by PhoneGap
   *
   * @param name
   * @return
   */
  PhoneGap.hasResource = function(name) {
      return PhoneGap.resources[name];
  };
  
  /**
   * Add a resource to list of loaded resources by PhoneGap
   *
   * @param name
   */
  PhoneGap.addResource = function(name) {
      PhoneGap.resources[name] = true;
  };
  
  /**
   * Custom pub-sub channel that can have functions subscribed to it
   */
  PhoneGap.Channel = function (type)
  {
      this.type = type;
      this.handlers = {};
      this.guid = 0;
      this.fired = false;
      this.enabled = true;
  };
  
  /**
   * Subscribes the given function to the channel. Any time that 
   * Channel.fire is called so too will the function.
   * Optionally specify an execution context for the function
   * and a guid that can be used to stop subscribing to the channel.
   * Returns the guid.
   */
  PhoneGap.Channel.prototype.subscribe = function(f, c, g) {
      // need a function to call
      if (f === null) { return; }
  
      var func = f;
      if (typeof c === "object" && f instanceof Function) { func = PhoneGap.close(c, f); }
  
      g = g || func.observer_guid || f.observer_guid || this.guid++;
      func.observer_guid = g;
      f.observer_guid = g;
      this.handlers[g] = func;
      return g;
  };
  
  /**
   * Like subscribe but the function is only called once and then it
   * auto-unsubscribes itself.
   */
  PhoneGap.Channel.prototype.subscribeOnce = function(f, c) {
      var g = null;
      var _this = this;
      var m = function() {
          f.apply(c || null, arguments);
          _this.unsubscribe(g);
      };
      if (this.fired) {
  	    if (typeof c === "object" && f instanceof Function) { f = PhoneGap.close(c, f); }
          f.apply(this, this.fireArgs);
      } else {
          g = this.subscribe(m);
      }
      return g;
  };
  
  /** 
   * Unsubscribes the function with the given guid from the channel.
   */
  PhoneGap.Channel.prototype.unsubscribe = function(g) {
      if (g instanceof Function) { g = g.observer_guid; }
      this.handlers[g] = null;
      delete this.handlers[g];
  };
  
  /** 
   * Calls all functions subscribed to this channel.
   */
  PhoneGap.Channel.prototype.fire = function(e) {
      if (this.enabled) {
          var fail = false;
          var item, handler, rv;
          for (item in this.handlers) {
              if (this.handlers.hasOwnProperty(item)) {
                  handler = this.handlers[item];
                  if (handler instanceof Function) {
                      rv = (handler.apply(this, arguments) === false);
                      fail = fail || rv;
                  }
              }
          }
          this.fired = true;
          this.fireArgs = arguments;
          return !fail;
      }
      return true;
  };
  
  /**
   * Calls the provided function only after all of the channels specified
   * have been fired.
   */
  PhoneGap.Channel.join = function(h, c) {
      var i = c.length;
      var f = function() {
          if (!(--i)) {
              h();
          }
      };
      var len = i;
      var j;
      for (j=0; j<len; j++) {
          if (!c[j].fired) {
              c[j].subscribeOnce(f);
          }
          else {
              i--;
          }
      }
      if (!i) {
          h();
      }
  };
  
  /**
   * Boolean flag indicating if the PhoneGap API is available and initialized.
   */ // TODO: Remove this, it is unused here ... -jm
  PhoneGap.available = DeviceInfo.uuid !== undefined;
  
  /**
   * Add an initialization function to a queue that ensures it will run and initialize
   * application constructors only once PhoneGap has been initialized.
   * @param {Function} func The function callback you want run once PhoneGap is initialized
   */
  PhoneGap.addConstructor = function(func) {
      PhoneGap.onPhoneGapInit.subscribeOnce(function() {
          try {
              func();
          } catch(e) {
              console.log("Failed to run constructor: " + e);
          }
      });
  };
  
  /**
   * Plugins object
   */
  if (!window.plugins) {
      window.plugins = {};
  }
  
  /**
   * Adds a plugin object to window.plugins.
   * The plugin is accessed using window.plugins.<name>
   *
   * @param name          The plugin name
   * @param obj           The plugin object
   */
  PhoneGap.addPlugin = function(name, obj) {
      if (!window.plugins[name]) {
          window.plugins[name] = obj;
      }
      else {
          console.log("Error: Plugin "+name+" already exists.");
      }
  };
  
  /**
   * onDOMContentLoaded channel is fired when the DOM content 
   * of the page has been parsed.
   */
  PhoneGap.onDOMContentLoaded = new PhoneGap.Channel('onDOMContentLoaded');
  
  /**
   * onNativeReady channel is fired when the PhoneGap native code
   * has been initialized.
   */
  PhoneGap.onNativeReady = new PhoneGap.Channel('onNativeReady');
  
  /**
   * onPhoneGapInit channel is fired when the web page is fully loaded and
   * PhoneGap native code has been initialized.
   */
  PhoneGap.onPhoneGapInit = new PhoneGap.Channel('onPhoneGapInit');
  
  /**
   * onPhoneGapReady channel is fired when the JS PhoneGap objects have been created.
   */
  PhoneGap.onPhoneGapReady = new PhoneGap.Channel('onPhoneGapReady');
  
  /**
   * onPhoneGapInfoReady channel is fired when the PhoneGap device properties
   * has been set.
   */
  PhoneGap.onPhoneGapInfoReady = new PhoneGap.Channel('onPhoneGapInfoReady');
  
  /**
   * onResume channel is fired when the PhoneGap native code
   * resumes.
   */
  PhoneGap.onResume = new PhoneGap.Channel('onResume');
  
  /**
   * onPause channel is fired when the PhoneGap native code
   * pauses.
   */
  PhoneGap.onPause = new PhoneGap.Channel('onPause');
  
  /**
   * onDestroy channel is fired when the PhoneGap native code
   * is destroyed.  It is used internally.  
   * Window.onunload should be used by the user.
   */
  PhoneGap.onDestroy = new PhoneGap.Channel('onDestroy');
  PhoneGap.onDestroy.subscribeOnce(function() {
      PhoneGap.shuttingDown = true;
  });
  PhoneGap.shuttingDown = false;
  
  // _nativeReady is global variable that the native side can set
  // to signify that the native code is ready. It is a global since 
  // it may be called before any PhoneGap JS is ready.
  if (typeof _nativeReady !== 'undefined') { PhoneGap.onNativeReady.fire(); }
  
  /**
   * onDeviceReady is fired only after all PhoneGap objects are created and
   * the device properties are set.
   */
  PhoneGap.onDeviceReady = new PhoneGap.Channel('onDeviceReady');
  
  
  // Array of channels that must fire before "deviceready" is fired
  PhoneGap.deviceReadyChannelsArray = [ PhoneGap.onPhoneGapReady, PhoneGap.onPhoneGapInfoReady];
  
  // Hashtable of user defined channels that must also fire before "deviceready" is fired
  PhoneGap.deviceReadyChannelsMap = {};
  
  /**
   * Indicate that a feature needs to be initialized before it is ready to be used.
   * This holds up PhoneGap's "deviceready" event until the feature has been initialized
   * and PhoneGap.initComplete(feature) is called.
   *
   * @param feature {String}     The unique feature name
   */
  PhoneGap.waitForInitialization = function(feature) {
      if (feature) {
          var channel = new PhoneGap.Channel(feature);
          PhoneGap.deviceReadyChannelsMap[feature] = channel;
          PhoneGap.deviceReadyChannelsArray.push(channel);
      }
  };
  
  /**
   * Indicate that initialization code has completed and the feature is ready to be used.
   *
   * @param feature {String}     The unique feature name
   */ 
  PhoneGap.initializationComplete = function(feature) {
      var channel = PhoneGap.deviceReadyChannelsMap[feature];
      if (channel) {
          channel.fire();
      }
  };
  
  /**
   * Create all PhoneGap objects once page has fully loaded and native side is ready.
   */
  PhoneGap.Channel.join(function() {
  
      // Start listening for XHR callbacks
      setTimeout(function() {
              if (PhoneGap.UsePolling) {
                  PhoneGap.JSCallbackPolling();
              }
              else {
                  var polling = prompt("usePolling", "gap_callbackServer:");
                  if (polling == "true") {
                      PhoneGap.JSCallbackPolling();
                  }
                  else {
                      PhoneGap.JSCallback();
                  }
              }
          }, 1);
  
      // Run PhoneGap constructors
      PhoneGap.onPhoneGapInit.fire();
  
      // Fire event to notify that all objects are created
      PhoneGap.onPhoneGapReady.fire();
  
      // Fire onDeviceReady event once all constructors have run and PhoneGap info has been
      // received from native side, and any user defined initialization channels.
      PhoneGap.Channel.join(function() {
      
          // Turn off app loading dialog
          navigator.notification.activityStop();
  
          PhoneGap.onDeviceReady.fire();
  
          // Fire the onresume event, since first one happens before JavaScript is loaded
          PhoneGap.onResume.fire();
      }, PhoneGap.deviceReadyChannelsArray);
  
  }, [ PhoneGap.onDOMContentLoaded, PhoneGap.onNativeReady ]);
  
  // Listen for DOMContentLoaded and notify our channel subscribers
  document.addEventListener('DOMContentLoaded', function() {
      PhoneGap.onDOMContentLoaded.fire();
  }, false);
  
  // Intercept calls to document.addEventListener and watch for deviceready
  PhoneGap.m_document_addEventListener = document.addEventListener;
  
  document.addEventListener = function(evt, handler, capture) {
      var e = evt.toLowerCase();
      if (e === 'deviceready') {
          PhoneGap.onDeviceReady.subscribeOnce(handler);
      } else if (e === 'resume') {
          PhoneGap.onResume.subscribe(handler);
          if (PhoneGap.onDeviceReady.fired) {
              PhoneGap.onResume.fire();
          }
      } else if (e === 'pause') {
          PhoneGap.onPause.subscribe(handler);
      }     
      else {
          // If subscribing to Android backbutton
          if (e === 'backbutton') {
              PhoneGap.exec(null, null, "App", "overrideBackbutton", [true]);
          } 
          
          PhoneGap.m_document_addEventListener.call(document, evt, handler, capture);
      }
  };
  
  // Intercept calls to document.removeEventListener and watch for events that 
  // are generated by PhoneGap native code
  PhoneGap.m_document_removeEventListener = document.removeEventListener;
  
  document.removeEventListener = function(evt, handler, capture) {
      var e = evt.toLowerCase();
  
      // If unsubscribing to Android backbutton
      if (e === 'backbutton') {
          PhoneGap.exec(null, null, "App", "overrideBackbutton", [false]);
      } 
  
      PhoneGap.m_document_removeEventListener.call(document, evt, handler, capture);
  };
  
  /**
   * Method to fire event from native code
   */
  PhoneGap.fireEvent = function(type) {
      var e = document.createEvent('Events');
      e.initEvent(type);
      document.dispatchEvent(e);
  };
  
  /**
   * If JSON not included, use our own stringify. (Android 1.6)
   * The restriction on ours is that it must be an array of simple types.
   *
   * @param args
   * @return
   */
  PhoneGap.stringify = function(args) {
      if (typeof JSON === "undefined") {
          var s = "[";
          var i, type, start, name, nameType, a;
          for (i = 0; i < args.length; i++) {
              if (args[i] != null) {
                  if (i > 0) {
                      s = s + ",";
                  }
                  type = typeof args[i];
                  if ((type === "number") || (type === "boolean")) {
                      s = s + args[i];
                  } else if (args[i] instanceof Array) {
                      s = s + "[" + args[i] + "]";
                  } else if (args[i] instanceof Object) {
                      start = true;
                      s = s + '{';
                      for (name in args[i]) {
                          if (args[i][name] !== null) {
                              if (!start) {
                                  s = s + ',';
                              }
                              s = s + '"' + name + '":';
                              nameType = typeof args[i][name];
                              if ((nameType === "number") || (nameType === "boolean")) {
                                  s = s + args[i][name];
                              } else if ((typeof args[i][name]) === 'function') {
                                  // don't copy the functions
                                  s = s + '""';
                              } else if (args[i][name] instanceof Object) {
                                  s = s + this.stringify(args[i][name]);
                              } else {
                                  s = s + '"' + args[i][name] + '"';
                              }
                              start = false;
                          }
                      }
                      s = s + '}';
                  } else {
                      a = args[i].replace(/\\/g, '\\\\');
                      a = a.replace(/"/g, '\\"');
                      s = s + '"' + a + '"';
                  }
              }
          }
          s = s + "]";
          return s;
      } else {
          return JSON.stringify(args);
      }
  };
  
  /**
   * Does a deep clone of the object.
   *
   * @param obj
   * @return
   */
  PhoneGap.clone = function(obj) {
      var i, retVal;
  	if(!obj) { 
  		return obj;
  	}
  	
  	if(obj instanceof Array){
  		retVal = [];
  		for(i = 0; i < obj.length; ++i){
  			retVal.push(PhoneGap.clone(obj[i]));
  		}
  		return retVal;
  	}
  	
  	if (obj instanceof Function) {
  		return obj;
  	}
  	
  	if(!(obj instanceof Object)){
  		return obj;
  	}
  	
      if (obj instanceof Date) {
          return obj;
      }
      
  	retVal = {};
  	for(i in obj){
  		if(!(i in retVal) || retVal[i] !== obj[i]) {
  			retVal[i] = PhoneGap.clone(obj[i]);
  		}
  	}
  	return retVal;
  };
  
  PhoneGap.callbackId = 0;
  PhoneGap.callbacks = {};
  PhoneGap.callbackStatus = {
      NO_RESULT: 0,
      OK: 1,
      CLASS_NOT_FOUND_EXCEPTION: 2,
      ILLEGAL_ACCESS_EXCEPTION: 3,
      INSTANTIATION_EXCEPTION: 4,
      MALFORMED_URL_EXCEPTION: 5,
      IO_EXCEPTION: 6,
      INVALID_ACTION: 7,
      JSON_EXCEPTION: 8,
      ERROR: 9
      };
  
  
  /**
   * Execute a PhoneGap command.  It is up to the native side whether this action is synch or async.  
   * The native side can return:
   *      Synchronous: PluginResult object as a JSON string
   *      Asynchrounous: Empty string ""
   * If async, the native side will PhoneGap.callbackSuccess or PhoneGap.callbackError,
   * depending upon the result of the action.
   *
   * @param {Function} success    The success callback
   * @param {Function} fail       The fail callback
   * @param {String} service      The name of the service to use
   * @param {String} action       Action to be run in PhoneGap
   * @param {String[]} [args]     Zero or more arguments to pass to the method
   */
  PhoneGap.exec = function(success, fail, service, action, args) {
      try {
          var callbackId = service + PhoneGap.callbackId++;
          if (success || fail) {
              PhoneGap.callbacks[callbackId] = {success:success, fail:fail};
          }
          
          var r = prompt(this.stringify(args), "gap:"+this.stringify([service, action, callbackId, true]));
          
          // If a result was returned
          if (r.length > 0) {
              eval("var v="+r+";");
          
              // If status is OK, then return value back to caller
              if (v.status === PhoneGap.callbackStatus.OK) {
  
                  // If there is a success callback, then call it now with
                  // returned value
                  if (success) {
                      try {
                          success(v.message);
                      } catch (e) {
                          console.log("Error in success callback: " + callbackId  + " = " + e);
                      }
  
                      // Clear callback if not expecting any more results
                      if (!v.keepCallback) {
                          delete PhoneGap.callbacks[callbackId];
                      }
                  }
                  return v.message;
              }
  
              // If no result
              else if (v.status === PhoneGap.callbackStatus.NO_RESULT) {
                      
                  // Clear callback if not expecting any more results
                  if (!v.keepCallback) {
                      delete PhoneGap.callbacks[callbackId];
                  }
              }
  
              // If error, then display error
              else {
                  console.log("Error: Status="+v.status+" Message="+v.message);
  
                  // If there is a fail callback, then call it now with returned value
                  if (fail) {
                      try {
                          fail(v.message);
                      }
                      catch (e1) {
                          console.log("Error in error callback: "+callbackId+" = "+e1);
                      }
  
                      // Clear callback if not expecting any more results
                      if (!v.keepCallback) {
                          delete PhoneGap.callbacks[callbackId];
                      }
                  }
                  return null;
              }
          }
      } catch (e2) {
          console.log("Error: "+e2);
      }
  };
  
  /**
   * Called by native code when returning successful result from an action.
   *
   * @param callbackId
   * @param args
   */
  PhoneGap.callbackSuccess = function(callbackId, args) {
      if (PhoneGap.callbacks[callbackId]) {
  
          // If result is to be sent to callback
          if (args.status === PhoneGap.callbackStatus.OK) {
              try {
                  if (PhoneGap.callbacks[callbackId].success) {
                      PhoneGap.callbacks[callbackId].success(args.message);
                  }
              }
              catch (e) {
                  console.log("Error in success callback: "+callbackId+" = "+e);
              }
          }
      
          // Clear callback if not expecting any more results
          if (!args.keepCallback) {
              delete PhoneGap.callbacks[callbackId];
          }
      }
  };
  
  /**
   * Called by native code when returning error result from an action.
   *
   * @param callbackId
   * @param args
   */
  PhoneGap.callbackError = function(callbackId, args) {
      if (PhoneGap.callbacks[callbackId]) {
          try {
              if (PhoneGap.callbacks[callbackId].fail) {
                  PhoneGap.callbacks[callbackId].fail(args.message);
              }
          }
          catch (e) {
              console.log("Error in error callback: "+callbackId+" = "+e);
          }
          
          // Clear callback if not expecting any more results
          if (!args.keepCallback) {
              delete PhoneGap.callbacks[callbackId];
          }
      }
  };
  
  
  /**
   * Internal function used to dispatch the request to PhoneGap.  It processes the
   * command queue and executes the next command on the list.  If one of the
   * arguments is a JavaScript object, it will be passed on the QueryString of the
   * url, which will be turned into a dictionary on the other end.
   * @private
   */
  // TODO: Is this used?
  PhoneGap.run_command = function() {
      if (!PhoneGap.available || !PhoneGap.queue.ready) {
          return;
      }
      PhoneGap.queue.ready = false;
  
      var args = PhoneGap.queue.commands.shift();
      if (PhoneGap.queue.commands.length === 0) {
          clearInterval(PhoneGap.queue.timer);
          PhoneGap.queue.timer = null;
      }
  
      var uri = [];
      var dict = null;
      var i;
      for (i = 1; i < args.length; i++) {
          var arg = args[i];
          if (arg === undefined || arg === null) {
              arg = '';
          }
          if (typeof(arg) === 'object') {
              dict = arg;
          } else {
              uri.push(encodeURIComponent(arg));
          }
      }
      var url = "gap://" + args[0] + "/" + uri.join("/");
      if (dict !== null) {
          var name;
          var query_args = [];
          for (name in dict) {
              if (dict.hasOwnProperty(name) && (typeof (name) === 'string')) {
                  query_args.push(encodeURIComponent(name) + "=" + encodeURIComponent(dict[name]));
              }
          }
          if (query_args.length > 0) {
              url += "?" + query_args.join("&");
          }
      }
      document.location = url;
  
  };
  
  PhoneGap.JSCallbackPort = null;
  PhoneGap.JSCallbackToken = null;
  
  /**
   * This is only for Android.
   *
   * Internal function that uses XHR to call into PhoneGap Java code and retrieve 
   * any JavaScript code that needs to be run.  This is used for callbacks from
   * Java to JavaScript.
   */
  PhoneGap.JSCallback = function() {
  
      // Exit if shutting down app
      if (PhoneGap.shuttingDown) {
          return;
      }
  
      // If polling flag was changed, start using polling from now on
      if (PhoneGap.UsePolling) {
          PhoneGap.JSCallbackPolling();
          return;
      }
  
      var xmlhttp = new XMLHttpRequest();
  
      // Callback function when XMLHttpRequest is ready
      xmlhttp.onreadystatechange=function(){
          if(xmlhttp.readyState === 4){
              
              // Exit if shutting down app
              if (PhoneGap.shuttingDown) {
                  return;
              }
  
              // If callback has JavaScript statement to execute
              if (xmlhttp.status === 200) {
  
                  var msg = xmlhttp.responseText;
                  setTimeout(function() {
                      try {
                          var t = eval(msg);
                      }
                      catch (e) {
                          // If we're getting an error here, seeing the message will help in debugging
                          console.log("JSCallback: Message from Server: " + msg);
                          console.log("JSCallback Error: "+e);
                      }
                  }, 1);
                  setTimeout(PhoneGap.JSCallback, 1);
              }
  
              // If callback ping (used to keep XHR request from timing out)
              else if (xmlhttp.status === 404) {
                  setTimeout(PhoneGap.JSCallback, 10);
              }
  
              // If security error
              else if (xmlhttp.status === 403) {
                  console.log("JSCallback Error: Invalid token.  Stopping callbacks.");
              }
  
              // If server is stopping
              else if (xmlhttp.status === 503) {
                  console.log("JSCallback Error: Service unavailable.  Stopping callbacks.");
              }
  
              // If request wasn't GET
              else if (xmlhttp.status === 400) {
                  console.log("JSCallback Error: Bad request.  Stopping callbacks.");
              }
  
              // If error, restart callback server
              else {
                  console.log("JSCallback Error: Request failed.");
                  prompt("restartServer", "gap_callbackServer:");
                  PhoneGap.JSCallbackPort = null;
                  PhoneGap.JSCallbackToken = null;
                  setTimeout(PhoneGap.JSCallback, 100);
              }
          }
      };
  
      if (PhoneGap.JSCallbackPort === null) {
          PhoneGap.JSCallbackPort = prompt("getPort", "gap_callbackServer:");
      }
      if (PhoneGap.JSCallbackToken === null) {
          PhoneGap.JSCallbackToken = prompt("getToken", "gap_callbackServer:");
      }
      xmlhttp.open("GET", "http://127.0.0.1:"+PhoneGap.JSCallbackPort+"/"+PhoneGap.JSCallbackToken , true);
      xmlhttp.send();
  };
  
  /**
   * The polling period to use with JSCallbackPolling.
   * This can be changed by the application.  The default is 50ms.
   */
  PhoneGap.JSCallbackPollingPeriod = 50;
  
  /**
   * Flag that can be set by the user to force polling to be used or force XHR to be used.
   */
  PhoneGap.UsePolling = false;    // T=use polling, F=use XHR
  
  /**
   * This is only for Android.
   *
   * Internal function that uses polling to call into PhoneGap Java code and retrieve 
   * any JavaScript code that needs to be run.  This is used for callbacks from
   * Java to JavaScript.
   */
  PhoneGap.JSCallbackPolling = function() {
  
      // Exit if shutting down app
      if (PhoneGap.shuttingDown) {
          return;
      }
  
      // If polling flag was changed, stop using polling from now on
      if (!PhoneGap.UsePolling) {
          PhoneGap.JSCallback();
          return;
      }
  
      var msg = prompt("", "gap_poll:");
      if (msg) {
          setTimeout(function() {
              try {
                  var t = eval(""+msg);
              }
              catch (e) {
                  console.log("JSCallbackPolling: Message from Server: " + msg);
                  console.log("JSCallbackPolling Error: "+e);
              }
          }, 1);
          setTimeout(PhoneGap.JSCallbackPolling, 1);
      }
      else {
          setTimeout(PhoneGap.JSCallbackPolling, PhoneGap.JSCallbackPollingPeriod);
      }
  };
  
  /**
   * Create a UUID
   *
   * @return
   */
  PhoneGap.createUUID = function() {
      return PhoneGap.UUIDcreatePart(4) + '-' +
          PhoneGap.UUIDcreatePart(2) + '-' +
          PhoneGap.UUIDcreatePart(2) + '-' +
          PhoneGap.UUIDcreatePart(2) + '-' +
          PhoneGap.UUIDcreatePart(6);
  };
  
  PhoneGap.UUIDcreatePart = function(length) {
      var uuidpart = "";
      var i, uuidchar;
      for (i=0; i<length; i++) {
          uuidchar = parseInt((Math.random() * 256),0).toString(16);
          if (uuidchar.length === 1) {
              uuidchar = "0" + uuidchar;
          }
          uuidpart += uuidchar;
      }
      return uuidpart;
  };
  
  PhoneGap.close = function(context, func, params) {
      if (typeof params === 'undefined') {
          return function() {
              return func.apply(context, arguments);
          };
      } else {
          return function() {
              return func.apply(context, params);
          };
      }
  };
  
  /**
   * Load a JavaScript file after page has loaded.
   *
   * @param {String} jsfile               The url of the JavaScript file to load.
   * @param {Function} successCallback    The callback to call when the file has been loaded.
   */
  PhoneGap.includeJavascript = function(jsfile, successCallback) {
      var id = document.getElementsByTagName("head")[0];         
      var el = document.createElement('script');
      el.type = 'text/javascript';
      if (typeof successCallback === 'function') {
          el.onload = successCallback;
      }
      el.src = jsfile;
      id.appendChild(el);
  };
  
  
  /**
   * This class is provided to bridge the gap between the way plugins were setup in 0.9.3 and 0.9.4.  
   * Users should be calling navigator.add.addService() instead of PluginManager.addService().
   * @class
   * @deprecated
   */
  var PluginManager = {
      addService: function(serviceType, className) {
          navigator.app.addService(serviceType, className);   
      }
  };
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010, IBM Corporation
   */
  
  if (!PhoneGap.hasResource("accelerometer")) {
  PhoneGap.addResource("accelerometer");
  
  Acceleration = function(x, y, z) {
    this.x = x;
    this.y = y;
    this.z = z;
    this.timestamp = new Date().getTime();
  }
  
  /**
   * This class provides access to device accelerometer data.
   * @constructor
   */
  Accelerometer = function() {
  
      /**
       * The last known acceleration.  type=Acceleration()
       */
      this.lastAcceleration = null;
  
      /**
       * List of accelerometer watch timers
       */
      this.timers = {};
  }
  
  Accelerometer.ERROR_MSG = ["Not running", "Starting", "", "Failed to start"];
  
  /**
   * Asynchronously aquires the current acceleration.
   *
   * @param {Function} successCallback    The function to call when the acceleration data is available
   * @param {Function} errorCallback      The function to call when there is an error getting the acceleration data. (OPTIONAL)
   * @param {AccelerationOptions} options The options for getting the accelerometer data such as timeout. (OPTIONAL)
   */
  Accelerometer.prototype.getCurrentAcceleration = function(successCallback, errorCallback, options) {
  
      // successCallback required
      if (typeof successCallback !== "function") {
          console.log("Accelerometer Error: successCallback is not a function");
          return;
      }
  
      // errorCallback optional
      if (errorCallback && (typeof errorCallback !== "function")) {
          console.log("Accelerometer Error: errorCallback is not a function");
          return;
      }
  
      // Get acceleration
      PhoneGap.exec(successCallback, errorCallback, "Accelerometer", "getAcceleration", []);
  };
  
  /**
   * Asynchronously aquires the acceleration repeatedly at a given interval.
   *
   * @param {Function} successCallback    The function to call each time the acceleration data is available
   * @param {Function} errorCallback      The function to call when there is an error getting the acceleration data. (OPTIONAL)
   * @param {AccelerationOptions} options The options for getting the accelerometer data such as timeout. (OPTIONAL)
   * @return String                       The watch id that must be passed to #clearWatch to stop watching.
   */
  Accelerometer.prototype.watchAcceleration = function(successCallback, errorCallback, options) {
  
      // Default interval (10 sec)
      var frequency = (options !== undefined)? options.frequency : 10000;
  
      // successCallback required
      if (typeof successCallback !== "function") {
          console.log("Accelerometer Error: successCallback is not a function");
          return;
      }
  
      // errorCallback optional
      if (errorCallback && (typeof errorCallback !== "function")) {
          console.log("Accelerometer Error: errorCallback is not a function");
          return;
      }
  
      // Make sure accelerometer timeout > frequency + 10 sec
      PhoneGap.exec(
          function(timeout) {
              if (timeout < (frequency + 10000)) {
                  PhoneGap.exec(null, null, "Accelerometer", "setTimeout", [frequency + 10000]);
              }
          },
          function(e) { }, "Accelerometer", "getTimeout", []);
  
      // Start watch timer
      var id = PhoneGap.createUUID();
      navigator.accelerometer.timers[id] = setInterval(function() {
          PhoneGap.exec(successCallback, errorCallback, "Accelerometer", "getAcceleration", []);
      }, (frequency ? frequency : 1));
  
      return id;
  };
  
  /**
   * Clears the specified accelerometer watch.
   *
   * @param {String} id       The id of the watch returned from #watchAcceleration.
   */
  Accelerometer.prototype.clearWatch = function(id) {
  
      // Stop javascript timer & remove from timer list
      if (id && navigator.accelerometer.timers[id] !== undefined) {
          clearInterval(navigator.accelerometer.timers[id]);
          delete navigator.accelerometer.timers[id];
      }
  };
  
  PhoneGap.addConstructor(function() {
      if (typeof navigator.accelerometer === "undefined") {
          navigator.accelerometer = new Accelerometer();
      }
  });
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010-2011, IBM Corporation
   */
  
  if (!PhoneGap.hasResource("app")) {
  PhoneGap.addResource("app");
  
  /**
   * Constructor
   */
  App = function() {};
  
  /**
   * Clear the resource cache.
   */
  App.prototype.clearCache = function() {
      PhoneGap.exec(null, null, "App", "clearCache", []);
  };
  
  /**
   * Load the url into the webview.
   * 
   * @param url           The URL to load
   * @param props         Properties that can be passed in to the activity:
   *      wait: int                           => wait msec before loading URL
   *      loadingDialog: "Title,Message"      => display a native loading dialog
   *      hideLoadingDialogOnPage: boolean    => hide loadingDialog when page loaded instead of when deviceready event occurs.
   *      loadInWebView: boolean              => cause all links on web page to be loaded into existing web view, instead of being loaded into new browser.
   *      loadUrlTimeoutValue: int            => time in msec to wait before triggering a timeout error
   *      errorUrl: URL                       => URL to load if there's an error loading specified URL with loadUrl().  Should be a local URL such as file:///android_asset/www/error.html");
   *      keepRunning: boolean                => enable app to keep running in background
   * 
   * Example:
   *      App app = new App();
   *      app.loadUrl("http://server/myapp/index.html", {wait:2000, loadingDialog:"Wait,Loading App", loadUrlTimeoutValue: 60000});
   */
  App.prototype.loadUrl = function(url, props) {
      PhoneGap.exec(null, null, "App", "loadUrl", [url, props]);
  };
  
  /**
   * Cancel loadUrl that is waiting to be loaded.
   */
  App.prototype.cancelLoadUrl = function() {
      PhoneGap.exec(null, null, "App", "cancelLoadUrl", []);
  };
  
  /**
   * Clear web history in this web view.
   * Instead of BACK button loading the previous web page, it will exit the app.
   */
  App.prototype.clearHistory = function() {
      PhoneGap.exec(null, null, "App", "clearHistory", []);
  };
  
  /**
   * Add a class that implements a service.
   * 
   * @param serviceType
   * @param className
   */
  App.prototype.addService = function(serviceType, className) {
  	PhoneGap.exec(null, null, "App", "addService", [serviceType, className]);
  };
  
  /**
   * Override the default behavior of the Android back button.
   * If overridden, when the back button is pressed, the "backKeyDown" JavaScript event will be fired.
   * 
   * Note: The user should not have to call this method.  Instead, when the user
   *       registers for the "backbutton" event, this is automatically done.
   * 
   * @param override		T=override, F=cancel override
   */
  App.prototype.overrideBackbutton = function(override) {
      PhoneGap.exec(null, null, "App", "overrideBackbutton", [override]);
  };
  
  /**
   * Exit and terminate the application.
   */
  App.prototype.exitApp = function() {
  	return PhoneGap.exec(null, null, "App", "exitApp", []);
  };
  
  PhoneGap.addConstructor(function() {
      navigator.app = window.app = new App();
  });
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010, IBM Corporation
   */
  
  if (!PhoneGap.hasResource("camera")) {
  PhoneGap.addResource("camera");
  
  /**
   * This class provides access to the device camera.
   *
   * @constructor
   */
  Camera = function() {
      this.successCallback = null;
      this.errorCallback = null;
      this.options = null;
  };
  
  /**
   * Format of image that returned from getPicture.
   *
   * Example: navigator.camera.getPicture(success, fail,
   *              { quality: 80,
   *                destinationType: Camera.DestinationType.DATA_URL,
   *                sourceType: Camera.PictureSourceType.PHOTOLIBRARY})
   */
  Camera.DestinationType = {
      DATA_URL: 0,                // Return base64 encoded string
      FILE_URI: 1                 // Return file uri (content://media/external/images/media/2 for Android)
  };
  Camera.prototype.DestinationType = Camera.DestinationType;
  
  /**
   * Source to getPicture from.
   *
   * Example: navigator.camera.getPicture(success, fail,
   *              { quality: 80,
   *                destinationType: Camera.DestinationType.DATA_URL,
   *                sourceType: Camera.PictureSourceType.PHOTOLIBRARY})
   */
  Camera.PictureSourceType = {
      PHOTOLIBRARY : 0,           // Choose image from picture library (same as SAVEDPHOTOALBUM for Android)
      CAMERA : 1,                 // Take picture from camera
      SAVEDPHOTOALBUM : 2         // Choose image from picture library (same as PHOTOLIBRARY for Android)
  };
  Camera.prototype.PictureSourceType = Camera.PictureSourceType;
  
  /**
   * 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=DATA_URL.
   *
   * @param {Function} successCallback
   * @param {Function} errorCallback
   * @param {Object} options
   */
  Camera.prototype.getPicture = function(successCallback, errorCallback, options) {
  
      // successCallback required
      if (typeof successCallback !== "function") {
          console.log("Camera Error: successCallback is not a function");
          return;
      }
  
      // errorCallback optional
      if (errorCallback && (typeof errorCallback !== "function")) {
          console.log("Camera Error: errorCallback is not a function");
          return;
      }
  
      this.options = options;
      var quality = 80;
      if (options.quality) {
          quality = this.options.quality;
      }
      var destinationType = Camera.DestinationType.DATA_URL;
      if (this.options.destinationType) {
          destinationType = this.options.destinationType;
      }
      var sourceType = Camera.PictureSourceType.CAMERA;
      if (typeof this.options.sourceType === "number") {
          sourceType = this.options.sourceType;
      }
      PhoneGap.exec(successCallback, errorCallback, "Camera", "takePicture", [quality, destinationType, sourceType]);
  };
  
  PhoneGap.addConstructor(function() {
      if (typeof navigator.camera === "undefined") {
          navigator.camera = new Camera();
      }
  });
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010-2011, IBM Corporation
   */
  
  /**
   * The CaptureError interface encapsulates all errors in the Capture API.
   */
  function CaptureError() {
     this.code = null;
  };
  
  // Capture error codes
  CaptureError.CAPTURE_INTERNAL_ERR = 0;
  CaptureError.CAPTURE_APPLICATION_BUSY = 1;
  CaptureError.CAPTURE_INVALID_ARGUMENT = 2;
  CaptureError.CAPTURE_NO_MEDIA_FILES = 3;
  CaptureError.CAPTURE_NOT_SUPPORTED = 20;
  
  /**
   * The Capture interface exposes an interface to the camera and microphone of the hosting device.
   */
  function Capture() {
  	this.supportedAudioFormats = [];
  	this.supportedImageFormats = [];
  	this.supportedVideoFormats = [];
  };
  
  /**
   * Launch audio recorder application for recording audio clip(s).
   * 
   * @param {Function} successCB
   * @param {Function} errorCB
   * @param {CaptureAudioOptions} options
   */
  Capture.prototype.captureAudio = function(successCallback, errorCallback, options) {
      PhoneGap.exec(successCallback, errorCallback, "Capture", "captureAudio", [options]);
  };
  
  /**
   * Launch camera application for taking image(s).
   * 
   * @param {Function} successCB
   * @param {Function} errorCB
   * @param {CaptureImageOptions} options
   */
  Capture.prototype.captureImage = function(successCallback, errorCallback, options) {
      PhoneGap.exec(successCallback, errorCallback, "Capture", "captureImage", [options]);
  };
  
  /**
   * Launch camera application for taking image(s).
   * 
   * @param {Function} successCB
   * @param {Function} errorCB
   * @param {CaptureImageOptions} options
   */
  Capture.prototype._castMediaFile = function(pluginResult) {
      var mediaFiles = [];
      var i;
      for (i=0; i<pluginResult.message.length; i++) {
          var mediaFile = new MediaFile();
  	    mediaFile.name = pluginResult.message[i].name;
  	    mediaFile.fullPath = pluginResult.message[i].fullPath;
  	    mediaFile.type = pluginResult.message[i].type;
  	    mediaFile.lastModifiedDate = pluginResult.message[i].lastModifiedDate;
  	    mediaFile.size = pluginResult.message[i].size;
          mediaFiles.push(mediaFile);
      }
      pluginResult.message = mediaFiles;
      return pluginResult;
  };
  
  /**
   * Launch device camera application for recording video(s).
   * 
   * @param {Function} successCB
   * @param {Function} errorCB
   * @param {CaptureVideoOptions} options
   */
  Capture.prototype.captureVideo = function(successCallback, errorCallback, options) {
      PhoneGap.exec(successCallback, errorCallback, "Capture", "captureVideo", [options]);
  };
  
  /**
   * Encapsulates a set of parameters that the capture device supports.
   */
  function ConfigurationData() {
      // The ASCII-encoded string in lower case representing the media type. 
      this.type; 
      // The height attribute represents height of the image or video in pixels. 
      // In the case of a sound clip this attribute has value 0. 
      this.height = 0;
      // The width attribute represents width of the image or video in pixels. 
      // In the case of a sound clip this attribute has value 0
      this.width = 0;
  };
  
  /**
   * Encapsulates all image capture operation configuration options.
   */
  function CaptureImageOptions() {
      // Upper limit of images user can take. Value must be equal or greater than 1.
      this.limit = 1; 
      // The selected image mode. Must match with one of the elements in supportedImageModes array.
      this.mode; 
  };
  
  /**
   * Encapsulates all video capture operation configuration options.
   */
  function CaptureVideoOptions() {
      // Upper limit of videos user can record. Value must be equal or greater than 1.
      this.limit;
      // Maximum duration of a single video clip in seconds.
      this.duration;
      // The selected video mode. Must match with one of the elements in supportedVideoModes array.
      this.mode;
  };
  
  /**
   * Encapsulates all audio capture operation configuration options.
   */
  function CaptureAudioOptions() {
      // Upper limit of sound clips user can record. Value must be equal or greater than 1.
      this.limit;
      // Maximum duration of a single sound clip in seconds.
      this.duration;
      // The selected audio mode. Must match with one of the elements in supportedAudioModes array.
      this.mode;
  };
  
  /**
   * Represents a single file.
   * 
   * name {DOMString} name of the file, without path information
   * fullPath {DOMString} the full path of the file, including the name
   * type {DOMString} mime type
   * lastModifiedDate {Date} last modified date
   * size {Number} size of the file in bytes
   */
  function MediaFile(name, fullPath, type, lastModifiedDate, size) {
      this.name = name || null;
      this.fullPath = fullPath || null;
      this.type = type || null;
      this.lastModifiedDate = lastModifiedDate || null;
      this.size = size || 0;
  }
  
  /**
   * Launch device camera application for recording video(s).
   * 
   * @param {Function} successCB
   * @param {Function} errorCB
   */
  MediaFile.prototype.getFormatData = function(successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "Capture", "getFormatData", [this.fullPath, this.type]);	
  };
  
  /**
   * MediaFileData encapsulates format information of a media file.
   * 
   * @param {DOMString} codecs
   * @param {long} bitrate
   * @param {long} height
   * @param {long} width
   * @param {float} duration
   */
  function MediaFileData(codecs, bitrate, height, width, duration) {
      this.codecs = codecs || null;
      this.bitrate = bitrate || 0;
      this.height = height || 0;
      this.width = width || 0;
      this.duration = duration || 0;
  }
  
  PhoneGap.addConstructor(function() {
      if (typeof navigator.device === "undefined") {
          navigator.device = window.device = new Device();
      }
      if (typeof navigator.device.capture === "undefined") {
          navigator.device.capture = window.device.capture = new Capture();
      }
  });
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010, IBM Corporation
   */
  
  if (!PhoneGap.hasResource("compass")) {
  PhoneGap.addResource("compass");
  
  /**
   * This class provides access to device Compass data.
   * @constructor
   */
  Compass = function() {
      /**
       * The last known Compass position.
       */
      this.lastHeading = null;
  
      /**
       * List of compass watch timers
       */
      this.timers = {};
  };
  
  Compass.ERROR_MSG = ["Not running", "Starting", "", "Failed to start"];
  
  /**
   * Asynchronously aquires the current heading.
   *
   * @param {Function} successCallback The function to call when the heading data is available
   * @param {Function} errorCallback The function to call when there is an error getting the heading data. (OPTIONAL)
   * @param {PositionOptions} options The options for getting the heading data such as timeout. (OPTIONAL)
   */
  Compass.prototype.getCurrentHeading = function(successCallback, errorCallback, options) {
  
      // successCallback required
      if (typeof successCallback !== "function") {
          console.log("Compass Error: successCallback is not a function");
          return;
      }
  
      // errorCallback optional
      if (errorCallback && (typeof errorCallback !== "function")) {
          console.log("Compass Error: errorCallback is not a function");
          return;
      }
  
      // Get heading
      PhoneGap.exec(successCallback, errorCallback, "Compass", "getHeading", []);
  };
  
  /**
   * Asynchronously aquires the heading repeatedly at a given interval.
   *
   * @param {Function} successCallback    The function to call each time the heading data is available
   * @param {Function} errorCallback      The function to call when there is an error getting the heading data. (OPTIONAL)
   * @param {HeadingOptions} options      The options for getting the heading data such as timeout and the frequency of the watch. (OPTIONAL)
   * @return String                       The watch id that must be passed to #clearWatch to stop watching.
   */
  Compass.prototype.watchHeading= function(successCallback, errorCallback, options) {
  
      // Default interval (100 msec)
      var frequency = (options !== undefined) ? options.frequency : 100;
  
      // successCallback required
      if (typeof successCallback !== "function") {
          console.log("Compass Error: successCallback is not a function");
          return;
      }
  
      // errorCallback optional
      if (errorCallback && (typeof errorCallback !== "function")) {
          console.log("Compass Error: errorCallback is not a function");
          return;
      }
  
      // Make sure compass timeout > frequency + 10 sec
      PhoneGap.exec(
          function(timeout) {
              if (timeout < (frequency + 10000)) {
                  PhoneGap.exec(null, null, "Compass", "setTimeout", [frequency + 10000]);
              }
          },
          function(e) { }, "Compass", "getTimeout", []);
  
      // Start watch timer to get headings
      var id = PhoneGap.createUUID();
      navigator.compass.timers[id] = setInterval(
          function() {
              PhoneGap.exec(successCallback, errorCallback, "Compass", "getHeading", []);
          }, (frequency ? frequency : 1));
  
      return id;
  };
  
  
  /**
   * Clears the specified heading watch.
   *
   * @param {String} id       The ID of the watch returned from #watchHeading.
   */
  Compass.prototype.clearWatch = function(id) {
  
      // Stop javascript timer & remove from timer list
      if (id && navigator.compass.timers[id]) {
          clearInterval(navigator.compass.timers[id]);
          delete navigator.compass.timers[id];
      }
  };
  
  PhoneGap.addConstructor(function() {
      if (typeof navigator.compass === "undefined") {
          navigator.compass = new Compass();
      }
  });
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010, IBM Corporation
   */
  
  if (!PhoneGap.hasResource("contact")) {
  PhoneGap.addResource("contact");
  
  /**
  * Contains information about a single contact.
  * @param {DOMString} id unique identifier
  * @param {DOMString} displayName
  * @param {ContactName} name
  * @param {DOMString} nickname
  * @param {ContactField[]} phoneNumbers array of phone numbers
  * @param {ContactField[]} emails array of email addresses
  * @param {ContactAddress[]} addresses array of addresses
  * @param {ContactField[]} ims instant messaging user ids
  * @param {ContactOrganization[]} organizations
  * @param {DOMString} revision date contact was last updated
  * @param {DOMString} birthday contact's birthday
  * @param {DOMString} gender contact's gender
  * @param {DOMString} note user notes about contact
  * @param {ContactField[]} photos
  * @param {ContactField[]} categories
  * @param {ContactField[]} urls contact's web sites
  * @param {DOMString} timezone the contacts time zone
  */
  var Contact = function (id, displayName, name, nickname, phoneNumbers, emails, addresses,
      ims, organizations, revision, birthday, gender, note, photos, categories, urls, timezone) {
      this.id = id || null;
      this.rawId = null;
      this.displayName = displayName || null;
      this.name = name || null; // ContactName
      this.nickname = nickname || null;
      this.phoneNumbers = phoneNumbers || null; // ContactField[]
      this.emails = emails || null; // ContactField[]
      this.addresses = addresses || null; // ContactAddress[]
      this.ims = ims || null; // ContactField[]
      this.organizations = organizations || null; // ContactOrganization[]
      this.revision = revision || null;
      this.birthday = birthday || null;
      this.gender = gender || null;
      this.note = note || null;
      this.photos = photos || null; // ContactField[]
      this.categories = categories || null; // ContactField[]
      this.urls = urls || null; // ContactField[]
      this.timezone = timezone || null;
  };
  
  /**
   *  ContactError.
   *  An error code assigned by an implementation when an error has occurred
   */
  var ContactError = function() {
      this.code=null;
  };
  
  /**
   * Error codes
   */
  ContactError.UNKNOWN_ERROR = 0;
  ContactError.INVALID_ARGUMENT_ERROR = 1;
  ContactError.NOT_FOUND_ERROR = 2;
  ContactError.TIMEOUT_ERROR = 3;
  ContactError.PENDING_OPERATION_ERROR = 4;
  ContactError.IO_ERROR = 5;
  ContactError.NOT_SUPPORTED_ERROR = 6;
  ContactError.PERMISSION_DENIED_ERROR = 20;
  
  /**
  * Removes contact from device storage.
  * @param successCB success callback
  * @param errorCB error callback
  */
  Contact.prototype.remove = function(successCB, errorCB) {
      if (this.id === null) {
          var errorObj = new ContactError();
          errorObj.code = ContactError.NOT_FOUND_ERROR;
          errorCB(errorObj);
      }
      else {
          PhoneGap.exec(successCB, errorCB, "Contacts", "remove", [this.id]);
      }
  };
  
  /**
  * Creates a deep copy of this Contact.
  * With the contact ID set to null.
  * @return copy of this Contact
  */
  Contact.prototype.clone = function() {
      var clonedContact = PhoneGap.clone(this);
      var i;
      clonedContact.id = null;
      clonedContact.rawId = null;
      // Loop through and clear out any id's in phones, emails, etc.
      if (clonedContact.phoneNumbers) {
          for (i = 0; i < clonedContact.phoneNumbers.length; i++) {
              clonedContact.phoneNumbers[i].id = null;
          }
      }
      if (clonedContact.emails) {
          for (i = 0; i < clonedContact.emails.length; i++) {
              clonedContact.emails[i].id = null;
          }
      }
      if (clonedContact.addresses) {
          for (i = 0; i < clonedContact.addresses.length; i++) {
              clonedContact.addresses[i].id = null;
          }
      }
      if (clonedContact.ims) {
          for (i = 0; i < clonedContact.ims.length; i++) {
              clonedContact.ims[i].id = null;
          }
      }
      if (clonedContact.organizations) {
          for (i = 0; i < clonedContact.organizations.length; i++) {
              clonedContact.organizations[i].id = null;
          }
      }
      if (clonedContact.tags) {
          for (i = 0; i < clonedContact.tags.length; i++) {
              clonedContact.tags[i].id = null;
          }
      }
      if (clonedContact.photos) {
          for (i = 0; i < clonedContact.photos.length; i++) {
              clonedContact.photos[i].id = null;
          }
      }
      if (clonedContact.urls) {
          for (i = 0; i < clonedContact.urls.length; i++) {
              clonedContact.urls[i].id = null;
          }
      }
      return clonedContact;
  };
  
  /**
  * Persists contact to device storage.
  * @param successCB success callback
  * @param errorCB error callback
  */
  Contact.prototype.save = function(successCB, errorCB) {
      PhoneGap.exec(successCB, errorCB, "Contacts", "save", [this]);
  };
  
  /**
  * Contact name.
  * @param formatted
  * @param familyName
  * @param givenName
  * @param middle
  * @param prefix
  * @param suffix
  */
  var ContactName = function(formatted, familyName, givenName, middle, prefix, suffix) {
      this.formatted = formatted || null;
      this.familyName = familyName || null;
      this.givenName = givenName || null;
      this.middleName = middle || null;
      this.honorificPrefix = prefix || null;
      this.honorificSuffix = suffix || null;
  };
  
  /**
  * Generic contact field.
  * @param {DOMString} id unique identifier, should only be set by native code
  * @param type
  * @param value
  * @param pref
  */
  var ContactField = function(type, value, pref) {
  	this.id = null;
      this.type = type || null;
      this.value = value || null;
      this.pref = pref || null;
  };
  
  /**
  * Contact address.
  * @param {DOMString} id unique identifier, should only be set by native code
  * @param formatted
  * @param streetAddress
  * @param locality
  * @param region
  * @param postalCode
  * @param country
  */
  var ContactAddress = function(formatted, streetAddress, locality, region, postalCode, country) {
  	this.id = null;
      this.formatted = formatted || null;
      this.streetAddress = streetAddress || null;
      this.locality = locality || null;
      this.region = region || null;
      this.postalCode = postalCode || null;
      this.country = country || null;
  };
  
  /**
  * Contact organization.
  * @param {DOMString} id unique identifier, should only be set by native code
  * @param name
  * @param dept
  * @param title
  * @param startDate
  * @param endDate
  * @param location
  * @param desc
  */
  var ContactOrganization = function(name, dept, title) {
  	this.id = null;
      this.name = name || null;
      this.department = dept || null;
      this.title = title || null;
  };
  
  /**
  * Represents a group of Contacts.
  */
  var Contacts = function() {
      this.inProgress = false;
      this.records = [];
  };
  /**
  * Returns an array of Contacts matching the search criteria.
  * @param fields that should be searched
  * @param successCB success callback
  * @param errorCB error callback
  * @param {ContactFindOptions} options that can be applied to contact searching
  * @return array of Contacts matching search criteria
  */
  Contacts.prototype.find = function(fields, successCB, errorCB, options) {
      PhoneGap.exec(successCB, errorCB, "Contacts", "search", [fields, options]);
  };
  
  /**
  * This function creates a new contact, but it does not persist the contact
  * to device storage. To persist the contact to device storage, invoke
  * contact.save().
  * @param properties an object who's properties will be examined to create a new Contact
  * @returns new Contact object
  */
  Contacts.prototype.create = function(properties) {
      var i;
  	var contact = new Contact();
      for (i in properties) {
          if (contact[i] !== 'undefined') {
              contact[i] = properties[i];
          }
      }
      return contact;
  };
  
  /**
  * This function returns and array of contacts.  It is required as we need to convert raw 
  * JSON objects into concrete Contact objects.  Currently this method is called after 
  * navigator.service.contacts.find but before the find methods success call back.
  * 
  * @param jsonArray an array of JSON Objects that need to be converted to Contact objects.
  * @returns an array of Contact objects
  */
  Contacts.prototype.cast = function(pluginResult) {
  	var contacts = [];
  	var i;
  	for (i=0; i<pluginResult.message.length; i++) {
  		contacts.push(navigator.service.contacts.create(pluginResult.message[i]));
  	}
  	pluginResult.message = contacts;
  	return pluginResult;
  };
  
  /**
   * ContactFindOptions.
   * @param filter used to match contacts against
   * @param multiple boolean used to determine if more than one contact should be returned
   * @param updatedSince return only contact records that have been updated on or after the given time
   */
  var ContactFindOptions = function(filter, multiple, updatedSince) {
      this.filter = filter || '';
      this.multiple = multiple || true;
      this.updatedSince = updatedSince || '';
  };
  
  /**
   * Add the contact interface into the browser.
   */
  PhoneGap.addConstructor(function() {
      if(typeof navigator.service === "undefined") {
          navigator.service = {};
      }
      if(typeof navigator.service.contacts === "undefined") {
          navigator.service.contacts = new Contacts();
      }
  });
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010, IBM Corporation
   */
  
  // TODO: Needs to be commented
  
  if (!PhoneGap.hasResource("crypto")) {
  PhoneGap.addResource("crypto");
  
  var Crypto = function() {
  };
  
  Crypto.prototype.encrypt = function(seed, string, callback) {
      this.encryptWin = callback;
      PhoneGap.exec(null, null, "Crypto", "encrypt", [seed, string]);
  };
  
  Crypto.prototype.decrypt = function(seed, string, callback) {
      this.decryptWin = callback;
      PhoneGap.exec(null, null, "Crypto", "decrypt", [seed, string]);
  };
  
  Crypto.prototype.gotCryptedString = function(string) {
      this.encryptWin(string);
  };
  
  Crypto.prototype.getPlainString = function(string) {
      this.decryptWin(string);
  };
  
  PhoneGap.addConstructor(function() {
      if (typeof navigator.Crypto === "undefined") {
          navigator.Crypto = new Crypto();
      }
  });
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010-2011, IBM Corporation
   */
  
  if (!PhoneGap.hasResource("device")) {
  PhoneGap.addResource("device");
  
  /**
   * This represents the mobile device, and provides properties for inspecting the model, version, UUID of the
   * phone, etc.
   * @constructor
   */
  Device = function() {
      this.available = PhoneGap.available;
      this.platform = null;
      this.version = null;
      this.name = null;
      this.uuid = null;
      this.phonegap = null;
  
      var me = this;
      this.getInfo(
          function(info) {
              me.available = true;
              me.platform = info.platform;
              me.version = info.version;
              me.name = info.name;
              me.uuid = info.uuid;
              me.phonegap = info.phonegap;
              PhoneGap.onPhoneGapInfoReady.fire();
          },
          function(e) {
              me.available = false;
              console.log("Error initializing PhoneGap: " + e);
              alert("Error initializing PhoneGap: "+e);
          });
  };
  
  /**
   * Get device info
   *
   * @param {Function} successCallback The function to call when the heading data is available
   * @param {Function} errorCallback The function to call when there is an error getting the heading data. (OPTIONAL)
   */
  Device.prototype.getInfo = function(successCallback, errorCallback) {
  
      // successCallback required
      if (typeof successCallback !== "function") {
          console.log("Device Error: successCallback is not a function");
          return;
      }
  
      // errorCallback optional
      if (errorCallback && (typeof errorCallback !== "function")) {
          console.log("Device Error: errorCallback is not a function");
          return;
      }
  
      // Get info
      PhoneGap.exec(successCallback, errorCallback, "Device", "getDeviceInfo", []);
  };
  
  /*
   * DEPRECATED
   * This is only for Android.
   *
   * You must explicitly override the back button.
   */
  Device.prototype.overrideBackButton = function() {
  	console.log("Device.overrideBackButton() is deprecated.  Use App.overrideBackbutton(true).");
  	app.overrideBackbutton(true);
  };
  
  /*
   * DEPRECATED
   * This is only for Android.
   *
   * This resets the back button to the default behaviour
   */
  Device.prototype.resetBackButton = function() {
  	console.log("Device.resetBackButton() is deprecated.  Use App.overrideBackbutton(false).");
  	app.overrideBackbutton(false);
  };
  
  /*
   * DEPRECATED
   * This is only for Android.
   *
   * This terminates the activity!
   */
  Device.prototype.exitApp = function() {
  	console.log("Device.exitApp() is deprecated.  Use App.exitApp().");
  	app.exitApp();
  };
  
  PhoneGap.addConstructor(function() {
      if (typeof navigator.device === "undefined") {
          navigator.device = window.device = new Device();
      }
  });
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010, IBM Corporation
   */
  
  if (!PhoneGap.hasResource("file")) {
  PhoneGap.addResource("file");
  
  /**
   * This class provides some useful information about a file.
   * This is the fields returned when navigator.fileMgr.getFileProperties() 
   * is called.
   */
  FileProperties = function(filePath) {
      this.filePath = filePath;
      this.size = 0;
      this.lastModifiedDate = null;
  };
  
  /**
   * Represents a single file.
   * 
   * name {DOMString} name of the file, without path information
   * fullPath {DOMString} the full path of the file, including the name
   * type {DOMString} mime type
   * lastModifiedDate {Date} last modified date
   * size {Number} size of the file in bytes
   */
  File = function(name, fullPath, type, lastModifiedDate, size) {
  	this.name = name || null;
      this.fullPath = fullPath || null;
  	this.type = type || null;
      this.lastModifiedDate = lastModifiedDate || null;
      this.size = size || 0;
  };
  
  FileError = function() {
     this.code = null;
  };
  
  // File error codes
  // Found in DOMException
  FileError.NOT_FOUND_ERR = 1;
  FileError.SECURITY_ERR = 2;
  FileError.ABORT_ERR = 3;
  
  // Added by this specification
  FileError.NOT_READABLE_ERR = 4;
  FileError.ENCODING_ERR = 5;
  FileError.NO_MODIFICATION_ALLOWED_ERR = 6;
  FileError.INVALID_STATE_ERR = 7;
  FileError.SYNTAX_ERR = 8;
  FileError.INVALID_MODIFICATION_ERR = 9;
  FileError.QUOTA_EXCEEDED_ERR = 10;
  FileError.TYPE_MISMATCH_ERR = 11;
  FileError.PATH_EXISTS_ERR = 12;
  
  //-----------------------------------------------------------------------------
  // File manager
  //-----------------------------------------------------------------------------
  
  FileMgr = function() {
  };
  
  FileMgr.prototype.getFileProperties = function(filePath) {
      return PhoneGap.exec(null, null, "File", "getFileProperties", [filePath]);
  };
  
  FileMgr.prototype.getFileBasePaths = function() {
  };
  
  FileMgr.prototype.testSaveLocationExists = function(successCallback, errorCallback) {
      return PhoneGap.exec(successCallback, errorCallback, "File", "testSaveLocationExists", []);
  };
  
  FileMgr.prototype.testFileExists = function(fileName, successCallback, errorCallback) {
      return PhoneGap.exec(successCallback, errorCallback, "File", "testFileExists", [fileName]);
  };
  
  FileMgr.prototype.testDirectoryExists = function(dirName, successCallback, errorCallback) {
      return PhoneGap.exec(successCallback, errorCallback, "File", "testDirectoryExists", [dirName]);
  };
  
  FileMgr.prototype.getFreeDiskSpace = function(successCallback, errorCallback) {
      return PhoneGap.exec(successCallback, errorCallback, "File", "getFreeDiskSpace", []);
  };
  
  FileMgr.prototype.writeAsText = function(fileName, data, append, successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "writeAsText", [fileName, data, append]);
  };
  
  FileMgr.prototype.write = function(fileName, data, position, successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "write", [fileName, data, position]);
  };
  
  FileMgr.prototype.truncate = function(fileName, size, successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "truncate", [fileName, size]);
  };
  
  FileMgr.prototype.readAsText = function(fileName, encoding, successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "readAsText", [fileName, encoding]);
  };
  
  FileMgr.prototype.readAsDataURL = function(fileName, successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "readAsDataURL", [fileName]);
  };
  
  PhoneGap.addConstructor(function() {
      if (typeof navigator.fileMgr === "undefined") {
          navigator.fileMgr = new FileMgr();
      }
  });
  
  //-----------------------------------------------------------------------------
  // File Reader
  //-----------------------------------------------------------------------------
  // TODO: All other FileMgr function operate on the SD card as root.  However,
  //       for FileReader & FileWriter the root is not SD card.  Should this be changed?
  
  /**
   * This class reads the mobile device file system.
   *
   * For Android:
   *      The root directory is the root of the file system.
   *      To read from the SD card, the file name is "sdcard/my_file.txt"
   */
  FileReader = function() {
      this.fileName = "";
  
      this.readyState = 0;
  
      // File data
      this.result = null;
  
      // Error
      this.error = null;
  
      // Event handlers
      this.onloadstart = null;    // When the read starts.
      this.onprogress = null;     // While reading (and decoding) file or fileBlob data, and reporting partial file data (progess.loaded/progress.total)
      this.onload = null;         // When the read has successfully completed.
      this.onerror = null;        // When the read has failed (see errors).
      this.onloadend = null;      // When the request has completed (either in success or failure).
      this.onabort = null;        // When the read has been aborted. For instance, by invoking the abort() method.
  };
  
  // States
  FileReader.EMPTY = 0;
  FileReader.LOADING = 1;
  FileReader.DONE = 2;
  
  /**
   * Abort reading file.
   */
  FileReader.prototype.abort = function() {
      var evt;
      this.readyState = FileReader.DONE;
      this.result = null;
  
      // set error
      var error = new FileError();
      error.code = error.ABORT_ERR;
      this.error = error;
     
      // If error callback
      if (typeof this.onerror === "function") {
          this.onerror({"type":"error", "target":this});
      }
      // If abort callback
      if (typeof this.onabort === "function") {
          this.oneabort({"type":"abort", "target":this});
      }
      // If load end callback
      if (typeof this.onloadend === "function") {
          this.onloadend({"type":"loadend", "target":this});
      }
  };
  
  /**
   * Read text file.
   *
   * @param file          {File} File object containing file properties
   * @param encoding      [Optional] (see http://www.iana.org/assignments/character-sets)
   */
  FileReader.prototype.readAsText = function(file, encoding) {
      this.fileName = "";
  	if (typeof file.fullPath === "undefined") {
  		this.fileName = file;
  	} else {
  		this.fileName = file.fullPath;
  	}
  
      // LOADING state
      this.readyState = FileReader.LOADING;
  
      // If loadstart callback
      if (typeof this.onloadstart === "function") {
          this.onloadstart({"type":"loadstart", "target":this});
      }
  
      // Default encoding is UTF-8
      var enc = encoding ? encoding : "UTF-8";
  
      var me = this;
  
      // Read file
      navigator.fileMgr.readAsText(this.fileName, enc,
  
          // Success callback
          function(r) {
              var evt;
  
              // If DONE (cancelled), then don't do anything
              if (me.readyState === FileReader.DONE) {
                  return;
              }
  
              // Save result
              me.result = r;
  
              // If onload callback
              if (typeof me.onload === "function") {
                  me.onload({"type":"load", "target":me});
              }
  
              // DONE state
              me.readyState = FileReader.DONE;
  
              // If onloadend callback
              if (typeof me.onloadend === "function") {
                  me.onloadend({"type":"loadend", "target":me});
              }
          },
  
          // Error callback
          function(e) {
              var evt;
              // If DONE (cancelled), then don't do anything
              if (me.readyState === FileReader.DONE) {
                  return;
              }
  
              // Save error
  		    var fileError = new FileError();
  		    fileError.code = e;
  		    me.error = fileError;
  
              // If onerror callback
              if (typeof me.onerror === "function") {
                  me.onerror({"type":"error", "target":me});
              }
  
              // DONE state
              me.readyState = FileReader.DONE;
  
              // If onloadend callback
              if (typeof me.onloadend === "function") {
                  me.onloadend({"type":"loadend", "target":me});
              }
          }
          );
  };
  
  
  /**
   * Read file and return data as a base64 encoded data url.
   * A data url is of the form:
   *      data:[<mediatype>][;base64],<data>
   *
   * @param file          {File} File object containing file properties
   */
  FileReader.prototype.readAsDataURL = function(file) {
  	this.fileName = "";
      if (typeof file.fullPath === "undefined") {
          this.fileName = file;
      } else {
          this.fileName = file.fullPath;
      }
  
      // LOADING state
      this.readyState = FileReader.LOADING;
  
      // If loadstart callback
      if (typeof this.onloadstart === "function") {
          this.onloadstart({"type":"loadstart", "target":this});
      }
  
      var me = this;
  
      // Read file
      navigator.fileMgr.readAsDataURL(this.fileName,
  
          // Success callback
          function(r) {
              var evt;
  
              // If DONE (cancelled), then don't do anything
              if (me.readyState === FileReader.DONE) {
                  return;
              }
  
              // Save result
              me.result = r;
  
              // If onload callback
              if (typeof me.onload === "function") {
                  me.onload({"type":"load", "target":me});
              }
  
              // DONE state
              me.readyState = FileReader.DONE;
  
              // If onloadend callback
              if (typeof me.onloadend === "function") {
                  me.onloadend({"type":"loadend", "target":me});
              }
          },
  
          // Error callback
          function(e) {
              var evt;
              // If DONE (cancelled), then don't do anything
              if (me.readyState === FileReader.DONE) {
                  return;
              }
  
              // Save error
              var fileError = new FileError();
              fileError.code = e;
              me.error = fileError;
  
              // If onerror callback
              if (typeof me.onerror === "function") {
                  me.onerror({"type":"error", "target":me});
              }
  
              // DONE state
              me.readyState = FileReader.DONE;
  
              // If onloadend callback
              if (typeof me.onloadend === "function") {
                  me.onloadend({"type":"loadend", "target":me});
              }
          }
          );
  };
  
  /**
   * Read file and return data as a binary data.
   *
   * @param file          {File} File object containing file properties
   */
  FileReader.prototype.readAsBinaryString = function(file) {
      // TODO - Can't return binary data to browser.
      this.fileName = file;
  };
  
  /**
   * Read file and return data as a binary data.
   *
   * @param file          {File} File object containing file properties
   */
  FileReader.prototype.readAsArrayBuffer = function(file) {
      // TODO - Can't return binary data to browser.
      this.fileName = file;
  };
  
  //-----------------------------------------------------------------------------
  // File Writer
  //-----------------------------------------------------------------------------
  
  /**
   * This class writes to the mobile device file system.
   *
   * For Android:
   *      The root directory is the root of the file system.
   *      To write to the SD card, the file name is "sdcard/my_file.txt"
   *      
   * @param file {File} File object containing file properties
   * @param append if true write to the end of the file, otherwise overwrite the file
   */
  FileWriter = function(file) {
      this.fileName = "";
      this.length = 0;
  	if (file) {
  	    this.fileName = file.fullPath || file;
  	    this.length = file.size || 0;
  	}
      // default is to write at the beginning of the file
      this.position = 0;
  
      this.readyState = 0; // EMPTY
  
      this.result = null;
  
      // Error
      this.error = null;
  
      // Event handlers
      this.onwritestart = null;	// When writing starts
      this.onprogress = null;		// While writing the file, and reporting partial file data
      this.onwrite = null;		// When the write has successfully completed.
      this.onwriteend = null;		// When the request has completed (either in success or failure).
      this.onabort = null;		// When the write has been aborted. For instance, by invoking the abort() method.
      this.onerror = null;		// When the write has failed (see errors).
  };
  
  // States
  FileWriter.INIT = 0;
  FileWriter.WRITING = 1;
  FileWriter.DONE = 2;
  
  /**
   * Abort writing file.
   */
  FileWriter.prototype.abort = function() {
      // check for invalid state
  	if (this.readyState === FileWriter.DONE || this.readyState === FileWriter.INIT) {
  		throw FileError.INVALID_STATE_ERR;
  	} 
  
      // set error
      var error = new FileError(), evt;
      error.code = error.ABORT_ERR;
      this.error = error;
      
      // If error callback
      if (typeof this.onerror === "function") {
          this.onerror({"type":"error", "target":this});
      }
      // If abort callback
      if (typeof this.onabort === "function") {
          this.oneabort({"type":"abort", "target":this});
      }
      
      this.readyState = FileWriter.DONE;
  
      // If write end callback
      if (typeof this.onwriteend == "function") {
          this.onwriteend({"type":"writeend", "target":this});
      }
  };
  
  /**
   * Writes data to the file
   *  
   * @param text to be written
   */
  FileWriter.prototype.write = function(text) {
  	// Throw an exception if we are already writing a file
  	if (this.readyState === FileWriter.WRITING) {
  		throw FileError.INVALID_STATE_ERR;
  	}
  
      // WRITING state
      this.readyState = FileWriter.WRITING;
  
      var me = this;
  
      // If onwritestart callback
      if (typeof me.onwritestart === "function") {
          me.onwritestart({"type":"writestart", "target":me});
      }
  
      // Write file
      navigator.fileMgr.write(this.fileName, text, this.position,
  
          // Success callback
          function(r) {
              var evt;
              // If DONE (cancelled), then don't do anything
              if (me.readyState === FileWriter.DONE) {
                  return;
              }
  
              // So if the user wants to keep appending to the file
              me.length = Math.max(me.length, me.position + r);
              // position always increases by bytes written because file would be extended
              me.position += r;
  
              // If onwrite callback
              if (typeof me.onwrite === "function") {
                  me.onwrite({"type":"write", "target":me});
              }
  
              // DONE state
              me.readyState = FileWriter.DONE;
  
              // If onwriteend callback
              if (typeof me.onwriteend === "function") {
                  me.onwriteend({"type":"writeend", "target":me});
              }
          },
  
          // Error callback
          function(e) {
              var evt;
  
              // If DONE (cancelled), then don't do anything
              if (me.readyState === FileWriter.DONE) {
                  return;
              }
  
              // Save error
              var fileError = new FileError();
              fileError.code = e;
              me.error = fileError;
  
              // If onerror callback
              if (typeof me.onerror === "function") {
                  me.onerror({"type":"error", "target":me});
              }
  
              // DONE state
              me.readyState = FileWriter.DONE;
  
              // If onwriteend callback
              if (typeof me.onwriteend === "function") {
                  me.onwriteend({"type":"writeend", "target":me});
              }
          }
          );
  
  };
  
  /** 
   * Moves the file pointer to the location specified.
   * 
   * If the offset is a negative number the position of the file 
   * pointer is rewound.  If the offset is greater than the file 
   * size the position is set to the end of the file.  
   * 
   * @param offset is the location to move the file pointer to.
   */
  FileWriter.prototype.seek = function(offset) {
      // Throw an exception if we are already writing a file
      if (this.readyState === FileWriter.WRITING) {
          throw FileError.INVALID_STATE_ERR;
      }
  
      if (!offset) {
          return;
      }
      
      // See back from end of file.
      if (offset < 0) {
  		this.position = Math.max(offset + this.length, 0);
  	}
      // Offset is bigger then file size so set position 
      // to the end of the file.
  	else if (offset > this.length) {
  		this.position = this.length;
  	}
      // Offset is between 0 and file size so set the position
      // to start writing.
  	else {
  		this.position = offset;
  	}	
  };
  
  /** 
   * Truncates the file to the size specified.
   * 
   * @param size to chop the file at.
   */
  FileWriter.prototype.truncate = function(size) {
  	// Throw an exception if we are already writing a file
  	if (this.readyState === FileWriter.WRITING) {
  		throw FileError.INVALID_STATE_ERR;
  	}
  
      // WRITING state
      this.readyState = FileWriter.WRITING;
  
      var me = this;
  
      // If onwritestart callback
      if (typeof me.onwritestart === "function") {
          me.onwritestart({"type":"writestart", "target":this});
      }
  
      // Write file
      navigator.fileMgr.truncate(this.fileName, size,
  
          // Success callback
          function(r) {
              var evt;
              // If DONE (cancelled), then don't do anything
              if (me.readyState === FileWriter.DONE) {
                  return;
              }
  
              // Update the length of the file
              me.length = r;
              me.position = Math.min(me.position, r);
  
              // If onwrite callback
              if (typeof me.onwrite === "function") {
                  me.onwrite({"type":"write", "target":me});
              }
  
              // DONE state
              me.readyState = FileWriter.DONE;
  
              // If onwriteend callback
              if (typeof me.onwriteend === "function") {
                  me.onwriteend({"type":"writeend", "target":me});
              }
          },
  
          // Error callback
          function(e) {
              var evt;
              // If DONE (cancelled), then don't do anything
              if (me.readyState === FileWriter.DONE) {
                  return;
              }
  
              // Save error
              var fileError = new FileError();
              fileError.code = e;
              me.error = fileError;
  
              // If onerror callback
              if (typeof me.onerror === "function") {
                  me.onerror({"type":"error", "target":me});
              }
  
              // DONE state
              me.readyState = FileWriter.DONE;
  
              // If onwriteend callback
              if (typeof me.onwriteend === "function") {
                  me.onwriteend({"type":"writeend", "target":me});
              }
          }
      );
  };
  
  LocalFileSystem = function() {
  };
  
  // File error codes
  LocalFileSystem.TEMPORARY = 0;
  LocalFileSystem.PERSISTENT = 1;
  LocalFileSystem.RESOURCE = 2;
  LocalFileSystem.APPLICATION = 3;
  
  /**
   * Requests a filesystem in which to store application data.
   * 
   * @param {int} type of file system being requested
   * @param {Function} successCallback is called with the new FileSystem
   * @param {Function} errorCallback is called with a FileError
   */
  LocalFileSystem.prototype.requestFileSystem = function(type, size, successCallback, errorCallback) {
  	if (type < 0 || type > 3) {
  		if (typeof errorCallback == "function") {
  			errorCallback({
  				"code": FileError.SYNTAX_ERR
  			});
  		}
  	}
  	else {
  		PhoneGap.exec(successCallback, errorCallback, "File", "requestFileSystem", [type, size]);
  	}
  };
  
  /**
   * 
   * @param {DOMString} uri referring to a local file in a filesystem
   * @param {Function} successCallback is called with the new entry
   * @param {Function} errorCallback is called with a FileError
   */
  LocalFileSystem.prototype.resolveLocalFileSystemURI = function(uri, successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "resolveLocalFileSystemURI", [uri]);
  };
  
  /**
  * This function returns and array of contacts.  It is required as we need to convert raw 
  * JSON objects into concrete Contact objects.  Currently this method is called after 
  * navigator.service.contacts.find but before the find methods success call back.
  * 
  * @param a JSON Objects that need to be converted to DirectoryEntry or FileEntry objects.
  * @returns an entry 
  */
  LocalFileSystem.prototype._castFS = function(pluginResult) {
      var entry = null;
      entry = new DirectoryEntry();
      entry.isDirectory = pluginResult.message.root.isDirectory;
      entry.isFile = pluginResult.message.root.isFile;
      entry.name = pluginResult.message.root.name;
      entry.fullPath = pluginResult.message.root.fullPath;
      pluginResult.message.root = entry;
      return pluginResult;    
  }
  
  LocalFileSystem.prototype._castEntry = function(pluginResult) {
      var entry = null;
      if (pluginResult.message.isDirectory) {
          console.log("This is a dir");
          entry = new DirectoryEntry();
      }
      else if (pluginResult.message.isFile) {
          console.log("This is a file");
          entry = new FileEntry();
      }
      entry.isDirectory = pluginResult.message.isDirectory;
      entry.isFile = pluginResult.message.isFile;
      entry.name = pluginResult.message.name;
      entry.fullPath = pluginResult.message.fullPath;
      pluginResult.message = entry;
      return pluginResult;    
  }
  
  LocalFileSystem.prototype._castEntries = function(pluginResult) {
      var entries = pluginResult.message;
  	var retVal = []; 
  	for (i=0; i<entries.length; i++) {
  		retVal.push(window.localFileSystem._createEntry(entries[i]));
  	}
      pluginResult.message = retVal;
      return pluginResult;    
  }
  
  LocalFileSystem.prototype._createEntry = function(castMe) {
  	var entry = null;
      if (castMe.isDirectory) {
          console.log("This is a dir");
          entry = new DirectoryEntry();
      }
      else if (castMe.isFile) {
          console.log("This is a file");
          entry = new FileEntry();
      }
      entry.isDirectory = castMe.isDirectory;
      entry.isFile = castMe.isFile;
      entry.name = castMe.name;
      entry.fullPath = castMe.fullPath;
      return entry;    
  	
  }
  
  LocalFileSystem.prototype._castDate = function(pluginResult) {
  	if (pluginResult.message.modificationTime) {
  	    var modTime = new Date(pluginResult.message.modificationTime);
  	    pluginResult.message.modificationTime = modTime;
  	}
  	else if (pluginResult.message.lastModifiedDate) {
  		var file = new File();
          file.size = pluginResult.message.size;
          file.type = pluginResult.message.type;
          file.name = pluginResult.message.name;
          file.fullPath = pluginResult.message.fullPath;
  		file.lastModifedDate = new Date(pluginResult.message.lastModifiedDate);
  	    pluginResult.message = file;		
  	}
  	
      return pluginResult;	
  }
  
  /**
   * Information about the state of the file or directory
   * 
   * {Date} modificationTime (readonly)
   */
  Metadata = function() {
      this.modificationTime=null;
  };
  
  /**
   * Supplies arguments to methods that lookup or create files and directories
   * 
   * @param {boolean} create file or directory if it doesn't exist 
   * @param {boolean} exclusive if true the command will fail if the file or directory exists
   */
  Flags = function(create, exclusive) {
      this.create = create || false;
      this.exclusive = exclusive || false;
  };
  
  /**
   * An interface representing a file system
   * 
   * {DOMString} name the unique name of the file system (readonly)
   * {DirectoryEntry} root directory of the file system (readonly)
   */
  FileSystem = function() {
      this.name = null;
      this.root = null;
  };
  
  /**
   * An interface representing a directory on the file system.
   * 
   * {boolean} isFile always false (readonly)
   * {boolean} isDirectory always true (readonly)
   * {DOMString} name of the directory, excluding the path leading to it (readonly)
   * {DOMString} fullPath the absolute full path to the directory (readonly)
   * {FileSystem} filesystem on which the directory resides (readonly)
   */
  DirectoryEntry = function() {
      this.isFile = false;
      this.isDirectory = true;
      this.name = null;
      this.fullPath = null;
      this.filesystem = null;
  };
  
  /**
   * Copies a directory to a new location
   * 
   * @param {DirectoryEntry} parent the directory to which to copy the entry
   * @param {DOMString} newName the new name of the entry, defaults to the current name
   * @param {Function} successCallback is called with the new entry
   * @param {Function} errorCallback is called with a FileError
   */
  DirectoryEntry.prototype.copyTo = function(parent, newName, successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "copyTo", [this.fullPath, parent, newName]);
  };
  
  /**
   * Looks up the metadata of the entry
   * 
   * @param {Function} successCallback is called with a Metadata object
   * @param {Function} errorCallback is called with a FileError
   */
  DirectoryEntry.prototype.getMetadata = function(successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "getMetadata", [this.fullPath]);
  };
  
  /**
   * Gets the parent of the entry
   * 
   * @param {Function} successCallback is called with a parent entry
   * @param {Function} errorCallback is called with a FileError
   */
  DirectoryEntry.prototype.getParent = function(successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "getParent", [this.fullPath]);
  };
  
  /**
   * Moves a directory to a new location
   * 
   * @param {DirectoryEntry} parent the directory to which to move the entry
   * @param {DOMString} newName the new name of the entry, defaults to the current name
   * @param {Function} successCallback is called with the new entry
   * @param {Function} errorCallback is called with a FileError
   */
  DirectoryEntry.prototype.moveTo = function(parent, newName, successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "moveTo", [this.fullPath, parent, newName]);
  };
  
  /**
   * Removes the entry
   * 
   * @param {Function} successCallback is called with no parameters
   * @param {Function} errorCallback is called with a FileError
   */
  DirectoryEntry.prototype.remove = function(successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "remove", [this.fullPath]);
  };
  
  /**
   * Returns a URI that can be used to identify this entry.
   * 
   * @param {DOMString} mimeType for a FileEntry, the mime type to be used to interpret the file, when loaded through this URI.
   * @return uri
   */
  DirectoryEntry.prototype.toURI = function(mimeType) {
      return "file://" + this.fullPath;
  };
  
  /**
   * Creates a new DirectoryReader to read entries from this directory
   */
  DirectoryEntry.prototype.createReader = function(successCallback, errorCallback) {
      return new DirectoryReader(this.fullPath);
  };
  
  /**
   * Creates or looks up a directory
   * 
   * @param {DOMString} path either a relative or absolute path from this directory in which to look up or create a directory
   * @param {Flags} options to create or excluively create the directory
   * @param {Function} successCallback is called with the new entry
   * @param {Function} errorCallback is called with a FileError
   */
  DirectoryEntry.prototype.getDirectory = function(path, options, successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "getDirectory", [this.fullPath, path, options]);
  };
  
  /**
   * Creates or looks up a file
   * 
   * @param {DOMString} path either a relative or absolute path from this directory in which to look up or create a file
   * @param {Flags} options to create or excluively create the file
   * @param {Function} successCallback is called with the new entry
   * @param {Function} errorCallback is called with a FileError
   */
  DirectoryEntry.prototype.getFile = function(path, options, successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "getFile", [this.fullPath, path, options]);
  };
  
  /**
   * Deletes a directory and all of it's contents
   * 
   * @param {Function} successCallback is called with no parameters
   * @param {Function} errorCallback is called with a FileError
   */
  DirectoryEntry.prototype.removeRecursively = function(successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "removeRecursively", [this.fullPath]);
  };
  
  /**
   * An interface that lists the files and directories in a directory.
   */
  DirectoryReader = function(fullPath){
  	this.fullPath = fullPath || null;    
  };
  
  /**
   * Returns a list of entries from a directory.
   * 
   * @param {Function} successCallback is called with a list of entries
   * @param {Function} errorCallback is called with a FileError
   */
  DirectoryReader.prototype.readEntries = function(successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "readEntries", [this.fullPath]);
  }
   
  /**
   * An interface representing a directory on the file system.
   * 
   * {boolean} isFile always true (readonly)
   * {boolean} isDirectory always false (readonly)
   * {DOMString} name of the file, excluding the path leading to it (readonly)
   * {DOMString} fullPath the absolute full path to the file (readonly)
   * {FileSystem} filesystem on which the directory resides (readonly)
   */
  FileEntry = function() {
      this.isFile = true;
      this.isDirectory = false;
      this.name = null;
      this.fullPath = null;
      this.filesystem = null;
  };
  
  /**
   * Copies a file to a new location
   * 
   * @param {DirectoryEntry} parent the directory to which to copy the entry
   * @param {DOMString} newName the new name of the entry, defaults to the current name
   * @param {Function} successCallback is called with the new entry
   * @param {Function} errorCallback is called with a FileError
   */
  FileEntry.prototype.copyTo = function(parent, newName, successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "copyTo", [this.fullPath, parent, newName]);
  };
  
  /**
   * Looks up the metadata of the entry
   * 
   * @param {Function} successCallback is called with a Metadata object
   * @param {Function} errorCallback is called with a FileError
   */
  FileEntry.prototype.getMetadata = function(successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "getMetadata", [this.fullPath]);
  };
  
  /**
   * Gets the parent of the entry
   * 
   * @param {Function} successCallback is called with a parent entry
   * @param {Function} errorCallback is called with a FileError
   */
  FileEntry.prototype.getParent = function(successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "getParent", [this.fullPath]);
  };
  
  /**
   * Moves a directory to a new location
   * 
   * @param {DirectoryEntry} parent the directory to which to move the entry
   * @param {DOMString} newName the new name of the entry, defaults to the current name
   * @param {Function} successCallback is called with the new entry
   * @param {Function} errorCallback is called with a FileError
   */
  FileEntry.prototype.moveTo = function(parent, newName, successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "moveTo", [this.fullPath, parent, newName]);
  };
  
  /**
   * Removes the entry
   * 
   * @param {Function} successCallback is called with no parameters
   * @param {Function} errorCallback is called with a FileError
   */
  FileEntry.prototype.remove = function(successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "remove", [this.fullPath]);
  };
  
  /**
   * Returns a URI that can be used to identify this entry.
   * 
   * @param {DOMString} mimeType for a FileEntry, the mime type to be used to interpret the file, when loaded through this URI.
   * @return uri
   */
  FileEntry.prototype.toURI = function(mimeType) {
      return "file://" + this.fullPath;
  };
  
  /**
   * Creates a new FileWriter associated with the file that this FileEntry represents.
   * 
   * @param {Function} successCallback is called with the new FileWriter
   * @param {Function} errorCallback is called with a FileError
   */
  FileEntry.prototype.createWriter = function(successCallback, errorCallback) {
  	var writer = new FileWriter(this.fullPath);
  
      if (writer.fileName == null || writer.fileName == "") {
  		if (typeof errorCallback == "function") {
  			errorCallback({
  				"code": FileError.INVALID_STATE_ERR
  			});
  		}
  	}
  	
      if (typeof successCallback == "function") {
          successCallback(writer);
      }
  };
  
  /**
   * Returns a File that represents the current state of the file that this FileEntry represents.
   * 
   * @param {Function} successCallback is called with the new File object
   * @param {Function} errorCallback is called with a FileError
   */
  FileEntry.prototype.file = function(successCallback, errorCallback) {
      PhoneGap.exec(successCallback, errorCallback, "File", "getFileMetadata", [this.fullPath]);
  };
  
  /**
   * Add the FileSystem interface into the browser.
   */
  PhoneGap.addConstructor(function() {
  	var pgLocalFileSystem = new LocalFileSystem();
  	// Needed for cast methods
      if(typeof window.localFileSystem == "undefined") window.localFileSystem  = pgLocalFileSystem;
      if(typeof window.requestFileSystem == "undefined") window.requestFileSystem  = pgLocalFileSystem.requestFileSystem;
      if(typeof window.resolveLocalFileSystemURI == "undefined") window.resolveLocalFileSystemURI = pgLocalFileSystem.resolveLocalFileSystemURI;
  });
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *  
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010, IBM Corporation
   */
  
  if (!PhoneGap.hasResource("filetransfer")) {
  PhoneGap.addResource("filetransfer");
  
  /**
   * FileTransfer uploads a file to a remote server.
   */
  FileTransfer = function() {};
  
  /**
   * FileUploadResult
   */
  FileUploadResult = function() {
      this.bytesSent = 0;
      this.responseCode = null;
      this.response = null;
  };
  
  /**
   * FileTransferError
   */
  FileTransferError = function() {
      this.code = null;
  };
  
  FileTransferError.FILE_NOT_FOUND_ERR = 1;
  FileTransferError.INVALID_URL_ERR = 2;
  FileTransferError.CONNECTION_ERR = 3;
  
  /**
  * Given an absolute file path, uploads a file on the device to a remote server 
  * using a multipart HTTP request.
  * @param filePath {String}           Full path of the file on the device
  * @param server {String}             URL of the server to receive the file
  * @param successCallback (Function}  Callback to be invoked when upload has completed
  * @param errorCallback {Function}    Callback to be invoked upon error
  * @param options {FileUploadOptions} Optional parameters such as file name and mimetype           
  */
  FileTransfer.prototype.upload = function(filePath, server, successCallback, errorCallback, options, debug) {
  
      // check for options
      var fileKey = null;
      var fileName = null;
      var mimeType = null;
      var params = null;
      if (options) {
          fileKey = options.fileKey;
          fileName = options.fileName;
          mimeType = options.mimeType;
          if (options.params) {
              params = options.params;
          }
          else {
              params = {};
          }
      }
      
      PhoneGap.exec(successCallback, errorCallback, 'FileTransfer', 'upload', [filePath, server, fileKey, fileName, mimeType, params, debug]);
  };
  
  /**
   * Options to customize the HTTP request used to upload files.
   * @param fileKey {String}   Name of file request parameter.
   * @param fileName {String}  Filename to be used by the server. Defaults to image.jpg.
   * @param mimeType {String}  Mimetype of the uploaded file. Defaults to image/jpeg.
   * @param params {Object}    Object with key: value params to send to the server.
   */
  FileUploadOptions = function(fileKey, fileName, mimeType, params) {
      this.fileKey = fileKey || null;
      this.fileName = fileName || null;
      this.mimeType = mimeType || null;
      this.params = params || null;
  };
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010, IBM Corporation
   */
  
  if (!PhoneGap.hasResource("geolocation")) {
  PhoneGap.addResource("geolocation");
  
  /**
   * This class provides access to device GPS data.
   * @constructor
   */
  Geolocation = function() {
  
      // The last known GPS position.
      this.lastPosition = null;
  
      // Geolocation listeners
      this.listeners = {};
  };
  
  /**
   * Position error object
   *
   * @param code
   * @param message
   */
  PositionError = function(code, message) {
      this.code = code;
      this.message = message;
  };
  
  PositionError.PERMISSION_DENIED = 1;
  PositionError.POSITION_UNAVAILABLE = 2;
  PositionError.TIMEOUT = 3;
  
  /**
   * Asynchronously aquires the current position.
   *
   * @param {Function} successCallback    The function to call when the position data is available
   * @param {Function} errorCallback      The function to call when there is an error getting the heading position. (OPTIONAL)
   * @param {PositionOptions} options     The options for getting the position data. (OPTIONAL)
   */
  Geolocation.prototype.getCurrentPosition = function(successCallback, errorCallback, options) {
      if (navigator._geo.listeners.global) {
          console.log("Geolocation Error: Still waiting for previous getCurrentPosition() request.");
          try {
              errorCallback(new PositionError(PositionError.TIMEOUT, "Geolocation Error: Still waiting for previous getCurrentPosition() request."));
          } catch (e) {
          }
          return;
      }
      var maximumAge = 10000;
      var enableHighAccuracy = false;
      var timeout = 10000;
      if (typeof options !== "undefined") {
          if (typeof options.maximumAge !== "undefined") {
              maximumAge = options.maximumAge;
          }
          if (typeof options.enableHighAccuracy !== "undefined") {
              enableHighAccuracy = options.enableHighAccuracy;
          }
          if (typeof options.timeout !== "undefined") {
              timeout = options.timeout;
          }
      }
      navigator._geo.listeners.global = {"success" : successCallback, "fail" : errorCallback };
      PhoneGap.exec(null, null, "Geolocation", "getCurrentLocation", [enableHighAccuracy, timeout, maximumAge]);
  };
  
  /**
   * Asynchronously watches the geolocation for changes to geolocation.  When a change occurs,
   * the successCallback is called with the new location.
   *
   * @param {Function} successCallback    The function to call each time the location data is available
   * @param {Function} errorCallback      The function to call when there is an error getting the location data. (OPTIONAL)
   * @param {PositionOptions} options     The options for getting the location data such as frequency. (OPTIONAL)
   * @return String                       The watch id that must be passed to #clearWatch to stop watching.
   */
  Geolocation.prototype.watchPosition = function(successCallback, errorCallback, options) {
      var maximumAge = 10000;
      var enableHighAccuracy = false;
      var timeout = 10000;
      if (typeof options !== "undefined") {
          if (typeof options.frequency  !== "undefined") {
              maximumAge = options.frequency;
          }
          if (typeof options.maximumAge !== "undefined") {
              maximumAge = options.maximumAge;
          }
          if (typeof options.enableHighAccuracy !== "undefined") {
              enableHighAccuracy = options.enableHighAccuracy;
          }
          if (typeof options.timeout !== "undefined") {
              timeout = options.timeout;
          }
      }
      var id = PhoneGap.createUUID();
      navigator._geo.listeners[id] = {"success" : successCallback, "fail" : errorCallback };
      PhoneGap.exec(null, null, "Geolocation", "start", [id, enableHighAccuracy, timeout, maximumAge]);
      return id;
  };
  
  /*
   * Native callback when watch position has a new position.
   * PRIVATE METHOD
   *
   * @param {String} id
   * @param {Number} lat
   * @param {Number} lng
   * @param {Number} alt
   * @param {Number} altacc
   * @param {Number} head
   * @param {Number} vel
   * @param {Number} stamp
   */
  Geolocation.prototype.success = function(id, lat, lng, alt, altacc, head, vel, stamp) {
      var coords = new Coordinates(lat, lng, alt, altacc, head, vel);
      var loc = new Position(coords, stamp);
      try {
          if (lat === "undefined" || lng === "undefined") {
              navigator._geo.listeners[id].fail(new PositionError(PositionError.POSITION_UNAVAILABLE, "Lat/Lng are undefined."));
          }
          else {
              navigator._geo.lastPosition = loc;
              navigator._geo.listeners[id].success(loc);
          }
      }
      catch (e) {
          console.log("Geolocation Error: Error calling success callback function.");
      }
  
      if (id === "global") {
          delete navigator._geo.listeners.global;
      }
  };
  
  /**
   * Native callback when watch position has an error.
   * PRIVATE METHOD
   *
   * @param {String} id       The ID of the watch
   * @param {Number} code     The error code
   * @param {String} msg      The error message
   */
  Geolocation.prototype.fail = function(id, code, msg) {
      try {
          navigator._geo.listeners[id].fail(new PositionError(code, msg));
      }
      catch (e) {
          console.log("Geolocation Error: Error calling error callback function.");
      }
  };
  
  /**
   * Clears the specified heading watch.
   *
   * @param {String} id       The ID of the watch returned from #watchPosition
   */
  Geolocation.prototype.clearWatch = function(id) {
      PhoneGap.exec(null, null, "Geolocation", "stop", [id]);
      delete navigator._geo.listeners[id];
  };
  
  /**
   * Force the PhoneGap geolocation to be used instead of built-in.
   */
  Geolocation.usingPhoneGap = false;
  Geolocation.usePhoneGap = function() {
      if (Geolocation.usingPhoneGap) {
          return;
      }
      Geolocation.usingPhoneGap = true;
  
      // Set built-in geolocation methods to our own implementations
      // (Cannot replace entire geolocation, but can replace individual methods)
      navigator.geolocation.setLocation = navigator._geo.setLocation;
      navigator.geolocation.getCurrentPosition = navigator._geo.getCurrentPosition;
      navigator.geolocation.watchPosition = navigator._geo.watchPosition;
      navigator.geolocation.clearWatch = navigator._geo.clearWatch;
      navigator.geolocation.start = navigator._geo.start;
      navigator.geolocation.stop = navigator._geo.stop;
  };
  
  PhoneGap.addConstructor(function() {
      navigator._geo = new Geolocation();
  
      // No native geolocation object for Android 1.x, so use PhoneGap geolocation
      if (typeof navigator.geolocation === 'undefined') {
          navigator.geolocation = navigator._geo;
          Geolocation.usingPhoneGap = true;
      }
  });
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010, IBM Corporation
   */
  
  if (!PhoneGap.hasResource("media")) {
  PhoneGap.addResource("media");
  
  /**
   * List of media objects.
   * PRIVATE
   */
  PhoneGap.mediaObjects = {};
  
  /**
   * Object that receives native callbacks.
   * PRIVATE
   */
  PhoneGap.Media = function() {};
  
  /**
   * Get the media object.
   * PRIVATE
   *
   * @param id            The media object id (string)
   */
  PhoneGap.Media.getMediaObject = function(id) {
      return PhoneGap.mediaObjects[id];
  };
  
  /**
   * Audio has status update.
   * PRIVATE
   *
   * @param id            The media object id (string)
   * @param status        The status code (int)
   * @param msg           The status message (string)
   */
  PhoneGap.Media.onStatus = function(id, msg, value) {
      var media = PhoneGap.mediaObjects[id];
  
      // If state update
      if (msg === Media.MEDIA_STATE) {
          if (value === Media.MEDIA_STOPPED) {
              if (media.successCallback) {
                  media.successCallback();
              }
          }
          if (media.statusCallback) {
              media.statusCallback(value);
          }
      }
      else if (msg === Media.MEDIA_DURATION) {
          media._duration = value;
      }
      else if (msg === Media.MEDIA_ERROR) {
          if (media.errorCallback) {
              media.errorCallback(value);
          }
      }
  };
  
  /**
   * This class provides access to the device media, interfaces to both sound and video
   *
   * @param src                   The file name or url to play
   * @param successCallback       The callback to be called when the file is done playing or recording.
   *                                  successCallback() - OPTIONAL
   * @param errorCallback         The callback to be called if there is an error.
   *                                  errorCallback(int errorCode) - OPTIONAL
   * @param statusCallback        The callback to be called when media status has changed.
   *                                  statusCallback(int statusCode) - OPTIONAL
   * @param positionCallback      The callback to be called when media position has changed.
   *                                  positionCallback(long position) - OPTIONAL
   */
  Media = function(src, successCallback, errorCallback, statusCallback, positionCallback) {
  
      // successCallback optional
      if (successCallback && (typeof successCallback !== "function")) {
          console.log("Media Error: successCallback is not a function");
          return;
      }
  
      // errorCallback optional
      if (errorCallback && (typeof errorCallback !== "function")) {
          console.log("Media Error: errorCallback is not a function");
          return;
      }
  
      // statusCallback optional
      if (statusCallback && (typeof statusCallback !== "function")) {
          console.log("Media Error: statusCallback is not a function");
          return;
      }
  
      // statusCallback optional
      if (positionCallback && (typeof positionCallback !== "function")) {
          console.log("Media Error: positionCallback is not a function");
          return;
      }
  
      this.id = PhoneGap.createUUID();
      PhoneGap.mediaObjects[this.id] = this;
      this.src = src;
      this.successCallback = successCallback;
      this.errorCallback = errorCallback;
      this.statusCallback = statusCallback;
      this.positionCallback = positionCallback;
      this._duration = -1;
      this._position = -1;
  };
  
  // Media messages
  Media.MEDIA_STATE = 1;
  Media.MEDIA_DURATION = 2;
  Media.MEDIA_ERROR = 9;
  
  // Media states
  Media.MEDIA_NONE = 0;
  Media.MEDIA_STARTING = 1;
  Media.MEDIA_RUNNING = 2;
  Media.MEDIA_PAUSED = 3;
  Media.MEDIA_STOPPED = 4;
  Media.MEDIA_MSG = ["None", "Starting", "Running", "Paused", "Stopped"];
  
  // TODO: Will MediaError be used?
  /**
   * This class contains information about any Media errors.
   * @constructor
   */
  MediaError = function() {
      this.code = null;
      this.message = "";
  };
  
  MediaError.MEDIA_ERR_ABORTED        = 1;
  MediaError.MEDIA_ERR_NETWORK        = 2;
  MediaError.MEDIA_ERR_DECODE         = 3;
  MediaError.MEDIA_ERR_NONE_SUPPORTED = 4;
  
  /**
   * Start or resume playing audio file.
   */
  Media.prototype.play = function() {
      PhoneGap.exec(null, null, "Media", "startPlayingAudio", [this.id, this.src]);
  };
  
  /**
   * Stop playing audio file.
   */
  Media.prototype.stop = function() {
      return PhoneGap.exec(null, null, "Media", "stopPlayingAudio", [this.id]);
  };
  
  /**
   * Pause playing audio file.
   */
  Media.prototype.pause = function() {
      PhoneGap.exec(null, null, "Media", "pausePlayingAudio", [this.id]);
  };
  
  /**
   * Get duration of an audio file.
   * The duration is only set for audio that is playing, paused or stopped.
   *
   * @return      duration or -1 if not known.
   */
  Media.prototype.getDuration = function() {
      return this._duration;
  };
  
  /**
   * Get position of audio.
   *
   * @return
   */
  Media.prototype.getCurrentPosition = function(success, fail) {
      PhoneGap.exec(success, fail, "Media", "getCurrentPositionAudio", [this.id]);
  };
  
  /**
   * Start recording audio file.
   */
  Media.prototype.startRecord = function() {
      PhoneGap.exec(null, null, "Media", "startRecordingAudio", [this.id, this.src]);
  };
  
  /**
   * Stop recording audio file.
   */
  Media.prototype.stopRecord = function() {
      PhoneGap.exec(null, null, "Media", "stopRecordingAudio", [this.id]);
  };
  
  /**
   * Release the resources.
   */
  Media.prototype.release = function() {
      PhoneGap.exec(null, null, "Media", "release", [this.id]);
  };
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010, IBM Corporation
   */
  
  if (!PhoneGap.hasResource("network")) {
  PhoneGap.addResource("network");
  
  /**
   * This class contains information about any NetworkStatus.
   * @constructor
   */
  NetworkStatus = function() {
      //this.code = null;
      //this.message = "";
  };
  
  NetworkStatus.NOT_REACHABLE = 0;
  NetworkStatus.REACHABLE_VIA_CARRIER_DATA_NETWORK = 1;
  NetworkStatus.REACHABLE_VIA_WIFI_NETWORK = 2;
  
  /**
   * This class provides access to device Network data (reachability).
   * @constructor
   */
  Network = function() {
      /**
       * The last known Network status.
       * { hostName: string, ipAddress: string,
          remoteHostStatus: int(0/1/2), internetConnectionStatus: int(0/1/2), localWiFiConnectionStatus: int (0/2) }
       */
      this.lastReachability = null;
  };
  
  /**
   * Called by the geolocation framework when the reachability status has changed.
   * @param {Reachibility} reachability The current reachability status.
   */
  // TODO: Callback from native code not implemented for Android
  Network.prototype.updateReachability = function(reachability) {
      this.lastReachability = reachability;
  };
  
  /**
   * Determine if a URI is reachable over the network.
  
   * @param {Object} uri
   * @param {Function} callback
   * @param {Object} options  (isIpAddress:boolean)
   */
  Network.prototype.isReachable = function(uri, callback, options) {
      var isIpAddress = false;
      if (options && options.isIpAddress) {
          isIpAddress = options.isIpAddress;
      }
      PhoneGap.exec(callback, null, "Network Status", "isReachable", [uri, isIpAddress]);
  };
  
  PhoneGap.addConstructor(function() {
      if (typeof navigator.network === "undefined") {
          navigator.network = new Network();
      }
  });
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010, IBM Corporation
   */
  
  if (!PhoneGap.hasResource("notification")) {
  PhoneGap.addResource("notification");
  
  /**
   * This class provides access to notifications on the device.
   */
  Notification = function() {
  };
  
  /**
   * Open a native alert dialog, with a customizable title and button text.
   *
   * @param {String} message              Message to print in the body of the alert
   * @param {Function} completeCallback   The callback that is called when user clicks on a button.
   * @param {String} title                Title of the alert dialog (default: Alert)
   * @param {String} buttonLabel          Label of the close button (default: OK)
   */
  Notification.prototype.alert = function(message, completeCallback, title, buttonLabel) {
      var _title = (title || "Alert");
      var _buttonLabel = (buttonLabel || "OK");
      PhoneGap.exec(completeCallback, null, "Notification", "alert", [message,_title,_buttonLabel]);
  };
  
  /**
   * Open a native confirm dialog, with a customizable title and button text.
   * The result that the user selects is returned to the result callback.
   *
   * @param {String} message              Message to print in the body of the alert
   * @param {Function} resultCallback     The callback that is called when user clicks on a button.
   * @param {String} title                Title of the alert dialog (default: Confirm)
   * @param {String} buttonLabels         Comma separated list of the labels of the buttons (default: 'OK,Cancel')
   */
  Notification.prototype.confirm = function(message, resultCallback, title, buttonLabels) {
      var _title = (title || "Confirm");
      var _buttonLabels = (buttonLabels || "OK,Cancel");
      PhoneGap.exec(resultCallback, null, "Notification", "confirm", [message,_title,_buttonLabels]);
  };
  
  /**
   * Start spinning the activity indicator on the statusbar
   */
  Notification.prototype.activityStart = function() {
      PhoneGap.exec(null, null, "Notification", "activityStart", ["Busy","Please wait..."]);
  };
  
  /**
   * Stop spinning the activity indicator on the statusbar, if it's currently spinning
   */
  Notification.prototype.activityStop = function() {
      PhoneGap.exec(null, null, "Notification", "activityStop", []);
  };
  
  /**
   * Display a progress dialog with progress bar that goes from 0 to 100.
   *
   * @param {String} title        Title of the progress dialog.
   * @param {String} message      Message to display in the dialog.
   */
  Notification.prototype.progressStart = function(title, message) {
      PhoneGap.exec(null, null, "Notification", "progressStart", [title, message]);
  };
  
  /**
   * Set the progress dialog value.
   *
   * @param {Number} value         0-100
   */
  Notification.prototype.progressValue = function(value) {
      PhoneGap.exec(null, null, "Notification", "progressValue", [value]);
  };
  
  /**
   * Close the progress dialog.
   */
  Notification.prototype.progressStop = function() {
      PhoneGap.exec(null, null, "Notification", "progressStop", []);
  };
  
  /**
   * Causes the device to blink a status LED.
   *
   * @param {Integer} count       The number of blinks.
   * @param {String} colour       The colour of the light.
   */
  Notification.prototype.blink = function(count, colour) {
      // NOT IMPLEMENTED
  };
  
  /**
   * Causes the device to vibrate.
   *
   * @param {Integer} mills       The number of milliseconds to vibrate for.
   */
  Notification.prototype.vibrate = function(mills) {
      PhoneGap.exec(null, null, "Notification", "vibrate", [mills]);
  };
  
  /**
   * Causes the device to beep.
   * On Android, the default notification ringtone is played "count" times.
   *
   * @param {Integer} count       The number of beeps.
   */
  Notification.prototype.beep = function(count) {
      PhoneGap.exec(null, null, "Notification", "beep", [count]);
  };
  
  PhoneGap.addConstructor(function() {
      if (typeof navigator.notification === "undefined") {
          navigator.notification = new Notification();
      }
  });
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010, IBM Corporation
   */
  
  if (!PhoneGap.hasResource("position")) {
  PhoneGap.addResource("position");
  
  /**
   * This class contains position information.
   * @param {Object} lat
   * @param {Object} lng
   * @param {Object} acc
   * @param {Object} alt
   * @param {Object} altacc
   * @param {Object} head
   * @param {Object} vel
   * @constructor
   */
  Position = function(coords, timestamp) {
  	this.coords = coords;
  	this.timestamp = (timestamp !== 'undefined') ? timestamp : new Date().getTime();
  };
  
  Coordinates = function(lat, lng, alt, acc, head, vel, altacc) {
  	/**
  	 * The latitude of the position.
  	 */
  	this.latitude = lat;
  	/**
  	 * The longitude of the position,
  	 */
  	this.longitude = lng;
  	/**
  	 * The accuracy of the position.
  	 */
  	this.accuracy = acc;
  	/**
  	 * The altitude of the position.
  	 */
  	this.altitude = alt;
  	/**
  	 * The direction the device is moving at the position.
  	 */
  	this.heading = head;
  	/**
  	 * The velocity with which the device is moving at the position.
  	 */
  	this.speed = vel;
  	/**
  	 * The altitude accuracy of the position.
  	 */
  	this.altitudeAccuracy = (altacc !== 'undefined') ? altacc : null; 
  };
  
  /**
   * This class specifies the options for requesting position data.
   * @constructor
   */
  PositionOptions = function() {
  	/**
  	 * Specifies the desired position accuracy.
  	 */
  	this.enableHighAccuracy = true;
  	/**
  	 * The timeout after which if position data cannot be obtained the errorCallback
  	 * is called.
  	 */
  	this.timeout = 10000;
  };
  
  /**
   * This class contains information about any GSP errors.
   * @constructor
   */
  PositionError = function() {
  	this.code = null;
  	this.message = "";
  };
  
  PositionError.UNKNOWN_ERROR = 0;
  PositionError.PERMISSION_DENIED = 1;
  PositionError.POSITION_UNAVAILABLE = 2;
  PositionError.TIMEOUT = 3;
  };
  /*
   * PhoneGap is available under *either* the terms of the modified BSD license *or* the
   * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
   *
   * Copyright (c) 2005-2010, Nitobi Software Inc.
   * Copyright (c) 2010, IBM Corporation
   */
  
  /*
   * This is purely for the Android 1.5/1.6 HTML 5 Storage
   * I was hoping that Android 2.0 would deprecate this, but given the fact that
   * most manufacturers ship with Android 1.5 and do not do OTA Updates, this is required
   */
  
  if (!PhoneGap.hasResource("storage")) {
  PhoneGap.addResource("storage");
  
  /**
   * Storage object that is called by native code when performing queries.
   * PRIVATE METHOD
   */
  var DroidDB = function() {
      this.queryQueue = {};
  };
  
  /**
   * Callback from native code when query is complete.
   * PRIVATE METHOD
   *
   * @param id                Query id
   */
  DroidDB.prototype.completeQuery = function(id, data) {
      var query = this.queryQueue[id];
      if (query) {
          try {
              delete this.queryQueue[id];
  
              // Get transaction
              var tx = query.tx;
  
              // If transaction hasn't failed
              // Note: We ignore all query results if previous query
              //       in the same transaction failed.
              if (tx && tx.queryList[id]) {
  
                  // Save query results
                  var r = new DroidDB_Result();
                  r.rows.resultSet = data;
                  r.rows.length = data.length;
                  try {
                      if (typeof query.successCallback === 'function') {
                          query.successCallback(query.tx, r);
                      }
                  } catch (ex) {
                      console.log("executeSql error calling user success callback: "+ex);
                  }
  
                  tx.queryComplete(id);
              }
          } catch (e) {
              console.log("executeSql error: "+e);
          }
      }
  };
  
  /**
   * Callback from native code when query fails
   * PRIVATE METHOD
   *
   * @param reason            Error message
   * @param id                Query id
   */
  DroidDB.prototype.fail = function(reason, id) {
      var query = this.queryQueue[id];
      if (query) {
          try {
              delete this.queryQueue[id];
  
              // Get transaction
              var tx = query.tx;
  
              // If transaction hasn't failed
              // Note: We ignore all query results if previous query
              //       in the same transaction failed.
              if (tx && tx.queryList[id]) {
                  tx.queryList = {};
  
                  try {
                      if (typeof query.errorCallback === 'function') {
                          query.errorCallback(query.tx, reason);
                      }
                  } catch (ex) {
                      console.log("executeSql error calling user error callback: "+ex);
                  }
  
                  tx.queryFailed(id, reason);
              }
  
          } catch (e) {
              console.log("executeSql error: "+e);
          }
      }
  };
  
  /**
   * Transaction object
   * PRIVATE METHOD
   */
  var DroidDB_Tx = function() {
  
      // Set the id of the transaction
      this.id = PhoneGap.createUUID();
  
      // Callbacks
      this.successCallback = null;
      this.errorCallback = null;
  
      // Query list
      this.queryList = {};
  };
  
  
  var DatabaseShell = function() {
  };
  
  /**
   * Start a transaction.
   * Does not support rollback in event of failure.
   *
   * @param process {Function}            The transaction function
   * @param successCallback {Function}
   * @param errorCallback {Function}
   */
  DatabaseShell.prototype.transaction = function(process, errorCallback, successCallback) {
      var tx = new DroidDB_Tx();
      tx.successCallback = successCallback;
      tx.errorCallback = errorCallback;
      try {
          process(tx);
      } catch (e) {
          console.log("Transaction error: "+e);
          if (tx.errorCallback) {
              try {
                  tx.errorCallback(e);
              } catch (ex) {
                  console.log("Transaction error calling user error callback: "+e);
              }
          }
      }
  };
  
  
  /**
   * Mark query in transaction as complete.
   * If all queries are complete, call the user's transaction success callback.
   *
   * @param id                Query id
   */
  DroidDB_Tx.prototype.queryComplete = function(id) {
      delete this.queryList[id];
  
      // If no more outstanding queries, then fire transaction success
      if (this.successCallback) {
          var count = 0;
          var i;
          for (i in this.queryList) {
              if (this.queryList.hasOwnProperty(i)) {
                  count++;   
              }
          }
          if (count === 0) {
              try {
                  this.successCallback();
              } catch(e) {
                  console.log("Transaction error calling user success callback: " + e);
              }
          }
      }
  };
  
  /**
   * Mark query in transaction as failed.
   *
   * @param id                Query id
   * @param reason            Error message
   */
  DroidDB_Tx.prototype.queryFailed = function(id, reason) {
  
      // The sql queries in this transaction have already been run, since
      // we really don't have a real transaction implemented in native code.
      // However, the user callbacks for the remaining sql queries in transaction
      // will not be called.
      this.queryList = {};
  
      if (this.errorCallback) {
          try {
              this.errorCallback(reason);
          } catch(e) {
              console.log("Transaction error calling user error callback: " + e);
          }
      }
  };
  
  /**
   * SQL query object
   * PRIVATE METHOD
   *
   * @param tx                The transaction object that this query belongs to
   */
  var DroidDB_Query = function(tx) {
  
      // Set the id of the query
      this.id = PhoneGap.createUUID();
  
      // Add this query to the queue
      droiddb.queryQueue[this.id] = this;
  
      // Init result
      this.resultSet = [];
  
      // Set transaction that this query belongs to
      this.tx = tx;
  
      // Add this query to transaction list
      this.tx.queryList[this.id] = this;
  
      // Callbacks
      this.successCallback = null;
      this.errorCallback = null;
  
  };
  
  /**
   * Execute SQL statement
   *
   * @param sql                   SQL statement to execute
   * @param params                Statement parameters
   * @param successCallback       Success callback
   * @param errorCallback         Error callback
   */
  DroidDB_Tx.prototype.executeSql = function(sql, params, successCallback, errorCallback) {
  
      // Init params array
      if (typeof params === 'undefined') {
          params = [];
      }
  
      // Create query and add to queue
      var query = new DroidDB_Query(this);
      droiddb.queryQueue[query.id] = query;
  
      // Save callbacks
      query.successCallback = successCallback;
      query.errorCallback = errorCallback;
  
      // Call native code
      PhoneGap.exec(null, null, "Storage", "executeSql", [sql, params, query.id]);
  };
  
  /**
   * SQL result set that is returned to user.
   * PRIVATE METHOD
   */
  DroidDB_Result = function() {
      this.rows = new DroidDB_Rows();
  };
  
  /**
   * SQL result set object
   * PRIVATE METHOD
   */
  DroidDB_Rows = function() {
      this.resultSet = [];    // results array
      this.length = 0;        // number of rows
  };
  
  /**
   * Get item from SQL result set
   *
   * @param row           The row number to return
   * @return              The row object
   */
  DroidDB_Rows.prototype.item = function(row) {
      return this.resultSet[row];
  };
  
  /**
   * Open database
   *
   * @param name              Database name
   * @param version           Database version
   * @param display_name      Database display name
   * @param size              Database size in bytes
   * @return                  Database object
   */
  DroidDB_openDatabase = function(name, version, display_name, size) {
      PhoneGap.exec(null, null, "Storage", "openDatabase", [name, version, display_name, size]);
      var db = new DatabaseShell();
      return db;
  };
  
  
  /**
   * For browsers with no localStorage we emulate it with SQLite. Follows the w3c api. 
   * TODO: Do similar for sessionStorage. 
   */
  
  var CupcakeLocalStorage = function() {
  		try {
  
  			this.db = openDatabase('localStorage', '1.0', 'localStorage', 2621440);	
  			var storage = {};
  			this.length = 0;
  			function setLength (length) {
  				this.length = length;
  				localStorage.length = length;
  			}
  			this.db.transaction(
  				function (transaction) {
  				    var i;
  					transaction.executeSql('CREATE TABLE IF NOT EXISTS storage (id NVARCHAR(40) PRIMARY KEY, body NVARCHAR(255))');
  					transaction.executeSql('SELECT * FROM storage', [], function(tx, result) {
  						for(var i = 0; i < result.rows.length; i++) {
  							storage[result.rows.item(i)['id']] =  result.rows.item(i)['body'];
  						}
  						setLength(result.rows.length);
  						PhoneGap.initializationComplete("cupcakeStorage");
  					});
  					
  				}, 
  				function (err) {
  					alert(err.message);
  				}
  			);
  			this.setItem = function(key, val) {
  				if (typeof(storage[key])=='undefined') {
  					this.length++;
  				}
  				storage[key] = val;
  				this.db.transaction(
  					function (transaction) {
  						transaction.executeSql('CREATE TABLE IF NOT EXISTS storage (id NVARCHAR(40) PRIMARY KEY, body NVARCHAR(255))');
  						transaction.executeSql('REPLACE INTO storage (id, body) values(?,?)', [key,val]);
  					}
  				);
  			};
  			this.getItem = function(key) {			
  				return storage[key];
  			};
  			this.removeItem = function(key) {
  				delete storage[key];
  				this.length--;
  				this.db.transaction(
  					function (transaction) {
  						transaction.executeSql('CREATE TABLE IF NOT EXISTS storage (id NVARCHAR(40) PRIMARY KEY, body NVARCHAR(255))');
  						transaction.executeSql('DELETE FROM storage where id=?', [key]);
  					}
  				);
  			};
  			this.clear = function() {
  				storage = {};
  				this.length = 0;
  				this.db.transaction(
  					function (transaction) {
  						transaction.executeSql('CREATE TABLE IF NOT EXISTS storage (id NVARCHAR(40) PRIMARY KEY, body NVARCHAR(255))');
  						transaction.executeSql('DELETE FROM storage', []);
  					}
  				);
  			};
  			this.key = function(index) {
  				var i = 0;
  				for (var j in storage) {
  					if (i==index) {
  						return j;
  					} else {
  						i++;
  					}
  				}
  				return null;
  			}
  
  		} catch(e) {
  			alert("Database error "+e+".");
  		    return;
  		}
  };
  PhoneGap.addConstructor(function() {
      var setupDroidDB = function() {
          navigator.openDatabase = window.openDatabase = DroidDB_openDatabase;
          window.droiddb = new DroidDB();
      }
  	  if (typeof window.openDatabase === "undefined") {
          setupDroidDB();
      } else {
          window.openDatabase_orig = window.openDatabase;
          window.openDatabase = function(name, version, desc, size) {
              var db = window.openDatabase_orig(name, version, desc, size);
              if (db == null) {
                  setupDroidDB();
                  return DroidDB_openDatabase(name, version, desc, size);
              } else return db;
          }
      }
      
      if (typeof window.localStorage === "undefined") {
          navigator.localStorage = window.localStorage = new CupcakeLocalStorage();
          PhoneGap.waitForInitialization("cupcakeStorage");
      }
  });
  };
  