phonegap 0.2.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

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

data/README.md

@@ -0,0 +1,25 @@
+PhoneGap Developer 
+===
+Command line utilities for PhoneGap:
+
+- app generation
+- app packaging
+- system reporting
+
+Usage
+---
+	phonegap --generate path/to/MyFreshApp 
+	phonegap --build path/to/MyFreshApp
+	phonegap --report path/to/MyFreshApp
+
+Options
+---
+	-h, --help ......... Displays help message.
+	-v, --version  ..... Display the version and then exit.
+	-g, --generate ..... Generates a PhoneGap application skeleton. 
+	-b, --build ........ Compiles your PhoneGapp application for supported platforms.
+	-r, --report ....... Generates a report for supported SDK's.
+
+
+Copyright (c) 2009 Brian LeRoux. Licensed under the MIT License:
+http://www.opensource.org/licenses/mit-license.php

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "phonegap"
+    gem.summary = %Q{Command line utilities for PhoneGap.}
+    gem.email = "brian@westcoastlogic.com"
+    gem.homepage = "http://github.com/brianleroux/phonegap-dev"
+    gem.authors = ["Brian LeRoux"]
+    gem.rubyforge_project = "phonegap"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+  Jeweler::RubyforgeTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "phonegap #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.2.1

data/bin/phonegap

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+%w(optparse optparse/time ostruct pp phonegap).each { |x| require x }
+#
+# Wraps the command line and passes switches and options back to the PhoneGap class.
+# 
+class PhoneGapConsole
+  def self.parse(args)
+    p = PhoneGap.new
+    
+    opts = OptionParser.new do |opts|
+      b = <<-E
+      
+      PhoneGap #{ p.version }
+      --------------
+      Usage: phonegap [options]
+      
+      E
+      opts.banner = b.gsub("      ","")
+
+      opts.on("-g", "--generate PATH", "Generates a new PhoneGap application skeleton.") do |path|
+        puts p.generate(path)
+        exit
+      end
+      
+      opts.on("-b", "--build PATH", "Compiles your PhoneGapp application for supported platforms.") do |path|
+        puts p.build(path)
+        exit
+      end 
+      
+      opts.on("-r", "--report", "Generates a report for supported SDK's.") do
+        puts p.report
+        exit
+      end
+      
+      opts.on_tail("-h", "--help", "Display this message.") do
+        puts "#{ opts }\n"
+        exit
+      end
+      
+      opts.on_tail("-v", "--version", "Display the version.") do
+        puts p.version
+        exit
+      end
+   end
+   opts.parse!(args)
+ end  
+end 
+
+PhoneGapConsole.parse(ARGV)

data/lib/devices/android.rb

@@ -0,0 +1,11 @@
+module Android
+  # FIXME
+  def android_supported?
+    false
+  end 
+  
+  # FIXME
+  def build_android(path)
+    FileUtils.mkdir_p(File.join(bin,'android')) if android_supported?
+  end
+end 

data/lib/devices/blackberry.rb

@@ -0,0 +1,32 @@
+module Blackberry
+  # FIXME
+  def blackberry_supported?
+    false
+  end
+  
+  # FIXME
+  def build_blackberry(path)
+=begin
+Blackberry uses something rapc.exe to do builds.
+http://www.blackberry.com/developers/javaknowledge/bbJDE/kpa0203190506.shtml
+
+From the command line something like this should work:
+
+>> rapc.exe import=c:\foo\net_rim_api.jar codename=phonegap-bitches -midlet jad=my-app-properties-metadata.jad @file-list.txt
+
+"@file-list.txt" is a newline separated list of .java files to include
+
+It requires (at leaset) rapc.exe from the Blackberry JDE (which I am
+not sure if we can redistribute or not) and JDK.
+
+To sign the app from the command line you do this:
+
+>> java -jar "SignatureTool.jar" -a -c -p <mypass> c:\phonegap-bitches.cod
+
+
+There is also a handy projects that links all this to ANT tasks if we
+want http://bb-ant-tools.sourceforge.net/
+=end     
+    FileUtils.mkdir_p(File.join(bin,'blackberry')) if blackberry_supported?
+  end
+end 

data/lib/devices/iphone.rb

@@ -0,0 +1,22 @@
+module Iphone
+  # TODO need to verify version is 3.0
+  def iphone_supported?
+    return File.exists?("/usr/bin/xcodebuild")
+  end 
+  
+  # builds the iphone using xcode, FIXME should use open toolchain
+  def build_iphone(path_to_build)
+    if iphone_supported?
+      FileUtils.mkdir_p(path_to_build) 
+      www_local = File.join(path_to_build,'www')
+      www_build = File.join(install_path,'iphone')
+      puts '\building for iphone...\n'
+      puts "copying #{www_local} to #{www_build}...#{`cp -r #{www_local} #{www_build}`}\n"
+      # Debug, Release
+      conf = {'Release'=>'iphoneos3.0','Debug'=>'iphonesimulator3.0'}
+      puts `cd #{www_build}; /usr/bin/xcodebuild -alltargets -configuration Debug -sdk #{conf['Debug']}`
+    else
+      puts 'skipping iphone build: iphone sdk not installed'
+    end 
+  end
+end 

data/lib/generate/config/bootstrap.js

@@ -0,0 +1,8 @@
+{
+	title:'Untitled Application',
+	author:'unknown',
+	license:'',
+	description:'',
+	icon:'foo.png',
+	startup:'Default.png'
+}

data/lib/generate/www/assets/css/master.css

@@ -0,0 +1,97 @@
+
+body {
+  background:#222 none repeat scroll 0 0;
+  color:#666;
+  font-family:Helvetica;
+  font-size:72%;
+  line-height:1.5em;
+  margin:0;
+  border-top:1px solid #393939;
+}
+
+#info{
+  background:#ffa;
+  border: 1px solid #ffd324;
+  -webkit-border-radius: 5px;
+  border-radius: 5px;
+  clear:both;
+  margin:15px 6px 0;
+  width:295px;
+  padding:4px 0px 2px 10px;
+}
+
+#info h4{
+  font-size:.95em;
+  margin:0;
+  padding:0;
+}
+
+#stage.theme{
+  padding-top:3px;
+}
+
+/* Definition List */
+#Page1 > dl{
+	padding-top:10px;
+	clear:both;
+	margin:0;
+	list-style-type:none;
+	padding-left:10px;
+	overflow:auto;
+}
+
+#Page1 > dl > dt{
+	font-weight:bold;
+	float:left;
+	margin-left:5px;
+}
+
+#Page1 > dl > dd{
+	width:45px;
+	float:left;
+	color:#a87;
+	font-weight:bold;
+}
+
+/* Content Styling */
+h1, h2, p{
+  margin:1em 0 .5em 13px;
+}
+
+h1{
+  color:#eee;
+  font-size:1.6em;
+  text-align:center;
+  margin:0;
+  margin-top:15px;
+  padding:0;
+}
+
+h2{
+	clear:both;
+  margin:0;
+  padding:3px;
+  font-size:1em;
+  text-align:center;
+}
+
+/* Stage Buttons */
+#stage.theme a.btn{
+	border: 1px solid #555;
+	-webkit-border-radius: 5px;
+	border-radius: 5px;
+	text-align:center;
+	display:block;
+	float:left;
+	background:#444;
+	width:150px;
+	color:#9ab;
+	font-size:1.1em;
+	text-decoration:none;
+	padding:1.2em 0;
+	margin:3px 0px 3px 5px;
+}
+#stage.theme a.btn.large{
+	width:308px;
+	padding:1.2em 0;
+}

data/lib/generate/www/assets/js/phongap.js

@@ -0,0 +1,1122 @@
+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
+ */
+PhoneGap = {
+    queue: {
+        ready: true,
+        commands: [],
+        timer: null
+    },
+    _constructors: []
+};
+
+/**
+ * Boolean flag indicating if the PhoneGap API is available and initialized.
+ */
+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) {
+    var state = document.readyState;
+    if (state != 'loaded' && state != 'complete')
+        PhoneGap._constructors.push(func);
+    else
+        func();
+};
+(function() {
+    var timer = setInterval(function() {
+        var state = document.readyState;
+        if (state != 'loaded' && state != 'complete')
+            return;
+        clearInterval(timer);
+        while (PhoneGap._constructors.length > 0) {
+            var constructor = PhoneGap._constructors.shift();
+            try {
+                constructor();
+            } catch(e) {
+                if (typeof(debug['log']) == 'function')
+                    debug.log("Failed to run constructor: " + debug.processMessage(e));
+                else
+                    alert("Failed to run constructor: " + e.message);
+            }
+        }
+    }, 1);
+})();
+
+
+/**
+ * Execute a PhoneGap command in a queued fashion, to ensure commands do not
+ * execute with any race conditions, and only run when PhoneGap is ready to
+ * recieve them.
+ * @param {String} command Command to be run in PhoneGap, e.g. "ClassName.method"
+ * @param {String[]} [args] Zero or more arguments to pass to the method
+ */
+PhoneGap.exec = function() {
+    PhoneGap.queue.commands.push(arguments);
+    if (PhoneGap.queue.timer == null)
+        PhoneGap.queue.timer = setInterval(PhoneGap.run_command, 10);
+};
+/**
+ * Internal function used to dispatch the request to PhoneGap.  This needs to be implemented per-platform to
+ * ensure that methods are called on the phone in a way appropriate for that device.
+ * @private
+ */
+PhoneGap.run_command = function() {
+};
+
+/**
+ * This class contains acceleration information
+ * @constructor
+ * @param {Number} x The force applied by the device in the x-axis.
+ * @param {Number} y The force applied by the device in the y-axis.
+ * @param {Number} z The force applied by the device in the z-axis.
+ */
+function Acceleration(x, y, z) {
+	/**
+	 * The force applied by the device in the x-axis.
+	 */
+	this.x = x;
+	/**
+	 * The force applied by the device in the y-axis.
+	 */
+	this.y = y;
+	/**
+	 * The force applied by the device in the z-axis.
+	 */
+	this.z = z;
+	/**
+	 * The time that the acceleration was obtained.
+	 */
+	this.timestamp = new Date().getTime();
+}
+
+/**
+ * This class specifies the options for requesting acceleration data.
+ * @constructor
+ */
+function AccelerationOptions() {
+	/**
+	 * The timeout after which if acceleration data cannot be obtained the errorCallback
+	 * is called.
+	 */
+	this.timeout = 10000;
+}
+/**
+ * This class provides access to device accelerometer data.
+ * @constructor
+ */
+function Accelerometer() {
+	/**
+	 * The last known acceleration.
+	 */
+	this.lastAcceleration = null;
+}
+
+/**
+ * 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.
+ * @param {AccelerationOptions} options The options for getting the accelerometer data
+ * such as timeout.
+ */
+Accelerometer.prototype.getCurrentAcceleration = function(successCallback, errorCallback, options) {
+	// If the acceleration is available then call success
+	// If the acceleration is not available then call error
+	
+	// Created for iPhone, Iphone passes back _accel obj litteral
+	if (typeof successCallback == "function") {
+		var accel = new Acceleration(_accel.x,_accel.y,_accel.z);
+		Accelerometer.lastAcceleration = accel;
+		successCallback(accel);
+	}
+}
+
+/**
+ * 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.
+ * @param {AccelerationOptions} options The options for getting the accelerometer data
+ * such as timeout.
+ */
+
+Accelerometer.prototype.watchAcceleration = function(successCallback, errorCallback, options) {
+	this.getCurrentAcceleration(successCallback, errorCallback, options);
+	// TODO: add the interval id to a list so we can clear all watches
+ 	var frequency = (options != undefined)? options.frequency : 10000;
+	return setInterval(function() {
+		navigator.accelerometer.getCurrentAcceleration(successCallback, errorCallback, options);
+	}, frequency);
+}
+
+/**
+ * Clears the specified accelerometer watch.
+ * @param {String} watchId The ID of the watch returned from #watchAcceleration.
+ */
+Accelerometer.prototype.clearWatch = function(watchId) {
+	clearInterval(watchId);
+}
+
+PhoneGap.addConstructor(function() {
+    if (typeof navigator.accelerometer == "undefined") navigator.accelerometer = new Accelerometer();
+});
+/**
+ * This class provides access to the device camera.
+ * @constructor
+ */
+function Camera() {
+	
+}
+
+
+PhoneGap.addConstructor(function() {
+    if (typeof navigator.camera == "undefined") navigator.camera = new Camera();
+});
+
+
+
+/**
+ * 
+ * @param {Function} successCallback
+ * @param {Function} errorCallback
+ * @param {Object} options
+ */
+Camera.prototype.getPicture = function(successCallback, errorCallback, options) {
+	navigator.notification.alert("TEST","Your GeoLocation", "Thanks");	
+	//PhoneGap.exec("Image.imagePickerController");
+}
+
+
+/**
+ * This class provides access to the device contacts.
+ * @constructor
+ */
+
+function Contact(jsonObject) {
+	this.firstName = "";
+	this.lastName = "";
+	this.phoneNumber = "";
+	this.address = "";
+}
+
+Contact.prototype.displayName = function()
+{
+    // TODO: can be tuned according to prefs
+	return this.firstName + " " + this.lastName;
+}
+
+function ContactManager() {
+	// Dummy object to hold array of contacts
+	this.contacts = [];
+	this.timestamp = new Date().getTime();
+}
+
+ContactManager.prototype.getAllContacts = function(successCallback, errorCallback, options) {
+	// Interface
+}
+
+PhoneGap.addConstructor(function() {
+    if (typeof navigator.ContactManager == "undefined") navigator.ContactManager = new ContactManager();
+});
+/**
+ * This class provides access to the debugging console.
+ * @constructor
+ */
+function DebugConsole() {
+}
+
+/**
+ * Utility function for rendering and indenting strings, or serializing
+ * objects to a string capable of being printed to the console.
+ * @param {Object|String} message The string or object to convert to an indented string
+ * @private
+ */
+DebugConsole.prototype.processMessage = function(message) {
+    if (typeof(message) != 'object') {
+        return message;
+    } else {
+        /**
+         * @function
+         * @ignore
+         */
+        function indent(str) {
+            return str.replace(/^/mg, "    ");
+        }
+        /**
+         * @function
+         * @ignore
+         */
+        function makeStructured(obj) {
+            var str = "";
+            for (var i in obj) {
+                try {
+                    if (typeof(obj[i]) == 'object') {
+                        str += i + ":\n" + indent(makeStructured(obj[i])) + "\n";
+                    } else {
+                        str += i + " = " + indent(String(obj[i])).replace(/^    /, "") + "\n";
+                    }
+                } catch(e) {
+                    str += i + " = EXCEPTION: " + e.message + "\n";
+                }
+            }
+            return str;
+        }
+        return "Object:\n" + makeStructured(message);
+    }
+};
+
+/**
+ * Print a normal log message to the console
+ * @param {Object|String} message Message or object to print to the console
+ */
+DebugConsole.prototype.log = function(message) {
+};
+
+/**
+ * Print a warning message to the console
+ * @param {Object|String} message Message or object to print to the console
+ */
+DebugConsole.prototype.warn = function(message) {
+};
+
+/**
+ * Print an error message to the console
+ * @param {Object|String} message Message or object to print to the console
+ */
+DebugConsole.prototype.error = function(message) {
+};
+
+PhoneGap.addConstructor(function() {
+    window.debug = new DebugConsole();
+});
+/**
+ * this represents the mobile device, and provides properties for inspecting the model, version, UUID of the
+ * phone, etc.
+ * @constructor
+ */
+function Device() {
+    this.available = PhoneGap.available;
+    this.platform = null;
+    this.version  = null;
+    this.name     = null;
+    this.gap      = null;
+    this.uuid     = null;
+    try {
+        if (window['DroidGap'] != undefined && window.DroidGap.exists()) {
+            this.available = true;
+            this.isAndroid = true;
+            this.uuid = window.DroidGap.getUuid();
+            this.gapVersion = window.DroidGap.getVersion();
+        } else {          
+            this.platform = DeviceInfo.platform;
+            this.version  = DeviceInfo.version;
+            this.name     = DeviceInfo.name;
+            this.gap      = DeviceInfo.gap;
+            this.uuid     = DeviceInfo.uuid;
+        }
+    } catch(e) {
+        this.available = false;
+    }
+}
+
+PhoneGap.addConstructor(function() {
+    navigator.device = window.device = new Device();
+});
+/**
+ * This class provides generic read and write access to the mobile device file system.
+ */
+function File() {
+	/**
+	 * The data of a file.
+	 */
+	this.data = "";
+	/**
+	 * The name of the file.
+	 */
+	this.name = "";
+}
+
+/**
+ * Reads a file from the mobile device. This function is asyncronous.
+ * @param {String} fileName The name (including the path) to the file on the mobile device. 
+ * The file name will likely be device dependant.
+ * @param {Function} successCallback The function to call when the file is successfully read.
+ * @param {Function} errorCallback The function to call when there is an error reading the file from the device.
+ */
+File.prototype.read = function(fileName, successCallback, errorCallback) {
+	
+}
+
+/**
+ * Writes a file to the mobile device.
+ * @param {File} file The file to write to the device.
+ */
+File.prototype.write = function(file) {
+	
+}
+
+PhoneGap.addConstructor(function() {
+    if (typeof navigator.file == "undefined") navigator.file = new File();
+});
+/**
+ * This class provides access to device GPS data.
+ * @constructor
+ */
+function Geolocation() {
+    /**
+     * The last known GPS position.
+     */
+    this.lastPosition = null;
+    this.lastError = null;
+    this.callbacks = {
+        onLocationChanged: [],
+        onError:           []
+    };
+};
+
+/**
+ * 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 position data.
+ * @param {PositionOptions} options The options for getting the position data
+ * such as timeout.
+ */
+Geolocation.prototype.getCurrentPosition = function(successCallback, errorCallback, options) {
+    var referenceTime = 0;
+    if (this.lastPosition)
+        referenceTime = this.lastPosition.timeout;
+    else
+        this.start(options);
+
+    var timeout = 20000;
+    var interval = 500;
+    if (typeof(options) == 'object' && options.interval)
+        interval = options.interval;
+
+    if (typeof(successCallback) != 'function')
+        successCallback = function() {};
+    if (typeof(errorCallback) != 'function')
+        errorCallback = function() {};
+
+    var dis = this;
+    var delay = 0;
+    var timer = setInterval(function() {
+        delay += interval;
+
+        if (typeof(dis.lastPosition) == 'object' && dis.lastPosition.timestamp > referenceTime) {
+            successCallback(dis.lastPosition);
+            clearInterval(timer);
+        } else if (delay >= timeout) {
+            errorCallback();
+            clearInterval(timer);
+        }
+    }, interval);
+};
+
+/**
+ * Asynchronously aquires the position repeatedly at a given interval.
+ * @param {Function} successCallback The function to call each time the position
+ * data is available
+ * @param {Function} errorCallback The function to call when there is an error 
+ * getting the position data.
+ * @param {PositionOptions} options The options for getting the position data
+ * such as timeout and the frequency of the watch.
+ */
+Geolocation.prototype.watchPosition = function(successCallback, errorCallback, options) {
+	// Invoke the appropriate callback with a new Position object every time the implementation 
+	// determines that the position of the hosting device has changed. 
+	
+	this.getCurrentPosition(successCallback, errorCallback, options);
+	var frequency = 10000;
+        if (typeof(options) == 'object' && options.frequency)
+            frequency = options.frequency;
+	
+	var that = this;
+	return setInterval(function() {
+		that.getCurrentPosition(successCallback, errorCallback, options);
+	}, frequency);
+};
+
+
+/**
+ * Clears the specified position watch.
+ * @param {String} watchId The ID of the watch returned from #watchPosition.
+ */
+Geolocation.prototype.clearWatch = function(watchId) {
+	clearInterval(watchId);
+};
+
+/**
+ * Called by the geolocation framework when the current location is found.
+ * @param {PositionOptions} position The current position.
+ */
+Geolocation.prototype.setLocation = function(position) {
+    this.lastPosition = position;
+    for (var i = 0; i < this.callbacks.onLocationChanged.length; i++) {
+        var f = this.callbacks.onLocationChanged.shift();
+        f(position);
+    }
+};
+
+/**
+ * Called by the geolocation framework when an error occurs while looking up the current position.
+ * @param {String} message The text of the error message.
+ */
+Geolocation.prototype.setError = function(message) {
+    this.lastError = message;
+    for (var i = 0; i < this.callbacks.onError.length; i++) {
+        var f = this.callbacks.onError.shift();
+        f(message);
+    }
+};
+
+PhoneGap.addConstructor(function() {
+    if (typeof navigator.geolocation == "undefined") navigator.geolocation = new Geolocation();
+});
+/**
+ * This class provides access to native mapping applications on the device.
+ */
+function Map() {
+	
+}
+
+/**
+ * Shows a native map on the device with pins at the given positions.
+ * @param {Array} positions
+ */
+Map.prototype.show = function(positions) {
+	
+}
+
+PhoneGap.addConstructor(function() {
+    if (typeof navigator.map == "undefined") navigator.map = new Map();
+});
+
+/**
+ * This class provides access to the device media, interfaces to both sound and video
+ * @constructor
+ */
+function Media(src) {
+	this.src = src;
+}
+
+Media.prototype.play = function() {
+}
+
+Media.prototype.pause = function() {
+}
+
+Media.prototype.stop = function() {
+}
+
+
+/**
+ * This class contains information about any Media errors.
+ * @constructor
+ */
+function MediaError() {
+	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;
+
+
+//if (typeof navigator.audio == "undefined") navigator.audio = new Media(src);
+/**
+ * This class provides access to notifications on the device.
+ */
+function Notification() {
+	
+}
+
+/**
+ * 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 {String} [title="Alert"] Title of the alert dialog (default: Alert)
+ * @param {String} [buttonLabel="OK"] Label of the close button (default: OK)
+ */
+Notification.prototype.alert = function(message, title, buttonLabel) {
+    // Default is to use a browser alert; this will use "index.html" as the title though
+    alert(message);
+};
+
+/**
+ * Start spinning the activity indicator on the statusbar
+ */
+Notification.prototype.activityStart = function() {
+};
+
+/**
+ * Stop spinning the activity indicator on the statusbar, if it's currently spinning
+ */
+Notification.prototype.activityStop = function() {
+};
+
+/**
+ * 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) {
+	
+};
+
+/**
+ * Causes the device to vibrate.
+ * @param {Integer} mills The number of milliseconds to vibrate for.
+ */
+Notification.prototype.vibrate = function(mills) {
+	
+};
+
+/**
+ * Causes the device to beep.
+ * @param {Integer} count The number of beeps.
+ * @param {Integer} volume The volume of the beep.
+ */
+Notification.prototype.beep = function(count, volume) {
+	
+};
+
+// TODO: of course on Blackberry and Android there notifications in the UI as well
+
+PhoneGap.addConstructor(function() {
+    if (typeof navigator.notification == "undefined") navigator.notification = new Notification();
+});
+
+/**
+ * This class provides access to the device orientation.
+ * @constructor
+ */
+function Orientation() {
+	/**
+	 * The current orientation, or null if the orientation hasn't changed yet.
+	 */
+	this.currentOrientation = null;
+}
+
+/**
+ * Set the current orientation of the phone.  This is called from the device automatically.
+ * 
+ * When the orientation is changed, the DOMEvent \c orientationChanged is dispatched against
+ * the document element.  The event has the property \c orientation which can be used to retrieve
+ * the device's current orientation, in addition to the \c Orientation.currentOrientation class property.
+ *
+ * @param {Number} orientation The orientation to be set
+ */
+Orientation.prototype.setOrientation = function(orientation) {
+    Orientation.currentOrientation = orientation;
+    var e = document.createEvent('Events');
+    e.initEvent('orientationChanged', 'false', 'false');
+    e.orientation = orientation;
+    document.dispatchEvent(e);
+};
+
+/**
+ * Asynchronously aquires the current orientation.
+ * @param {Function} successCallback The function to call when the orientation
+ * is known.
+ * @param {Function} errorCallback The function to call when there is an error 
+ * getting the orientation.
+ */
+Orientation.prototype.getCurrentOrientation = function(successCallback, errorCallback) {
+	// If the position is available then call success
+	// If the position is not available then call error
+};
+
+/**
+ * Asynchronously aquires the orientation repeatedly at a given interval.
+ * @param {Function} successCallback The function to call each time the orientation
+ * data is available.
+ * @param {Function} errorCallback The function to call when there is an error 
+ * getting the orientation data.
+ */
+Orientation.prototype.watchOrientation = function(successCallback, errorCallback) {
+	// Invoke the appropriate callback with a new Position object every time the implementation 
+	// determines that the position of the hosting device has changed. 
+	this.getCurrentPosition(successCallback, errorCallback);
+	return setInterval(function() {
+		navigator.orientation.getCurrentOrientation(successCallback, errorCallback);
+	}, 10000);
+};
+
+/**
+ * Clears the specified orientation watch.
+ * @param {String} watchId The ID of the watch returned from #watchOrientation.
+ */
+Orientation.prototype.clearWatch = function(watchId) {
+	clearInterval(watchId);
+};
+
+PhoneGap.addConstructor(function() {
+    if (typeof navigator.orientation == "undefined") navigator.orientation = new Orientation();
+});
+/**
+ * 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
+ */
+function Position(lat, lng, acc, alt, altacc, head, vel) {
+	/**
+	 * 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 altitude accuracy of the position.
+	 */
+	this.altitudeAccuracy = altacc;
+	/**
+	 * The direction the device is moving at the position.
+	 */
+	this.heading = head;
+	/**
+	 * The velocity with which the device is moving at the position.
+	 */
+	this.velocity = vel;
+	/**
+	 * The time that the position was obtained.
+	 */
+	this.timestamp = new Date().getTime();
+}
+
+/**
+ * This class specifies the options for requesting position data.
+ * @constructor
+ */
+function PositionOptions() {
+	/**
+	 * 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
+ */
+function PositionError() {
+	this.code = null;
+	this.message = "";
+}
+
+PositionError.UNKNOWN_ERROR = 0;
+PositionError.PERMISSION_DENIED = 1;
+PositionError.POSITION_UNAVAILABLE = 2;
+PositionError.TIMEOUT = 3;
+/**
+ * This class provides access to the device SMS functionality.
+ * @constructor
+ */
+function Sms() {
+
+}
+
+/**
+ * Sends an SMS message.
+ * @param {Integer} number The phone number to send the message to.
+ * @param {String} message The contents of the SMS message to send.
+ * @param {Function} successCallback The function to call when the SMS message is sent.
+ * @param {Function} errorCallback The function to call when there is an error sending the SMS message.
+ * @param {PositionOptions} options The options for accessing the GPS location such as timeout and accuracy.
+ */
+Sms.prototype.send = function(number, message, successCallback, errorCallback, options) {
+	
+}
+
+PhoneGap.addConstructor(function() {
+    if (typeof navigator.sms == "undefined") navigator.sms = new Sms();
+});
+/**
+ * This class provides access to the telephony features of the device.
+ * @constructor
+ */
+function Telephony() {
+	
+}
+
+/**
+ * Calls the specifed number.
+ * @param {Integer} number The number to be called.
+ */
+Telephony.prototype.call = function(number) {
+	
+}
+
+PhoneGap.addConstructor(function() {
+    if (typeof navigator.telephony == "undefined") navigator.telephony = new Telephony();
+});
+/**
+ * This class exposes mobile phone interface controls to JavaScript, such as
+ * native tab and tool bars, etc.
+ * @constructor
+ */
+function UIControls() {
+    this.tabBarTag = 0;
+    this.tabBarCallbacks = {};
+}
+
+/**
+ * Create a native tab bar that can have tab buttons added to it which can respond to events.
+ */
+UIControls.prototype.createTabBar = function() {};
+
+/**
+ * Show a tab bar.  The tab bar has to be created first.
+ * @param {Object} [options] Options indicating how the tab bar should be shown:
+ * - \c height integer indicating the height of the tab bar (default: \c 49)
+ * - \c position specifies whether the tab bar will be placed at the \c top or \c bottom of the screen (default: \c bottom)
+ */
+UIControls.prototype.showTabBar = function(options) {};
+
+/**
+ * Hide a tab bar.  The tab bar has to be created first.
+ */
+UIControls.prototype.hideTabBar = function(animate) {};
+
+/**
+ * Create a new tab bar item for use on a previously created tab bar.  Use ::showTabBarItems to show the new item on the tab bar.
+ *
+ * If the supplied image name is one of the labels listed below, then this method will construct a tab button
+ * using the standard system buttons.  Note that if you use one of the system images, that the \c title you supply will be ignored.
+ *
+ * <b>Tab Buttons</b>
+ *   - tabButton:More
+ *   - tabButton:Favorites
+ *   - tabButton:Featured
+ *   - tabButton:TopRated
+ *   - tabButton:Recents
+ *   - tabButton:Contacts
+ *   - tabButton:History
+ *   - tabButton:Bookmarks
+ *   - tabButton:Search
+ *   - tabButton:Downloads
+ *   - tabButton:MostRecent
+ *   - tabButton:MostViewed
+ * @param {String} name internal name to refer to this tab by
+ * @param {String} [title] title text to show on the tab, or null if no text should be shown
+ * @param {String} [image] image filename or internal identifier to show, or null if now image should be shown
+ * @param {Object} [options] Options for customizing the individual tab item
+ *  - \c badge value to display in the optional circular badge on the item; if null or unspecified, the badge will be hidden
+ */
+UIControls.prototype.createTabBarItem = function(name, label, image, options) {};
+
+/**
+ * Update an existing tab bar item to change its badge value.
+ * @param {String} name internal name used to represent this item when it was created
+ * @param {Object} options Options for customizing the individual tab item
+ *  - \c badge value to display in the optional circular badge on the item; if null or unspecified, the badge will be hidden
+ */
+UIControls.prototype.updateTabBarItem = function(name, options) {};
+
+/**
+ * Show previously created items on the tab bar
+ * @param {String} arguments... the item names to be shown
+ * @param {Object} [options] dictionary of options, notable options including:
+ *  - \c animate indicates that the items should animate onto the tab bar
+ * @see createTabBarItem
+ * @see createTabBar
+ */
+UIControls.prototype.showTabBarItems = function(tabs, options) {};
+
+/**
+ * Manually select an individual tab bar item, or nil for deselecting a currently selected tab bar item.
+ * @param {String} tabName the name of the tab to select, or null if all tabs should be deselected
+ * @see createTabBarItem
+ * @see showTabBarItems
+ */
+UIControls.prototype.selectTabBarItem = function(tab) {};
+
+/**
+ * Function called when a tab bar item has been selected.
+ * @param {Number} tag the tag number for the item that has been selected
+ */
+UIControls.prototype.tabBarItemSelected = function(tag) {
+    if (typeof(this.tabBarCallbacks[tag]) == 'function')
+        this.tabBarCallbacks[tag]();
+};
+
+/**
+ * Create a toolbar.
+ */
+UIControls.prototype.createToolBar = function() {};
+
+/**
+ * Function called when a tab bar item has been selected.
+ * @param {String} title the title to set within the toolbar
+ */
+UIControls.prototype.setToolBarTitle = function(title) {};
+
+PhoneGap.addConstructor(function() {
+    window.uicontrols = new UIControls();
+});
+Accelerometer.prototype.getCurrentAcceleration = function(successCallback, errorCallback, options) {
+	if (typeof successCallback == "function") {
+		var accel = new Acceleration(_accel.x,_accel.y,_accel.z);
+		Accelerometer.lastAcceleration = accel;
+		successCallback(accel);
+	} 	
+}	
+// --- BjV Additions for 360/iDev
+Bonjour = function() {
+}
+
+Bonjour.prototype.port = 0;
+Bonjour.prototype.start = function(name) {
+	PhoneGap.exec("Bonjour.start");
+}
+Bonjour.prototype.stop = function() {
+	PhoneGap.exec("Bonjour.stop");
+}
+Bonjour.prototype.delegate = null;
+// Gets the function name of a Function object, else uses "alert" if anonymous
+function GetFunctionName(fn)
+{
+  if (fn) {
+      var m = fn.toString().match(/^\s*function\s+([^\s\(]+)/);
+      return m ? m[1] : "alert";
+  } else {
+    return null;
+  }
+}
+
+ContactManager.prototype.getAllContacts = function(successCallback, errorCallback, options) {
+	PhoneGap.exec("Contacts.allContacts", GetFunctionName(successCallback), options);
+}
+
+// THE FUNCTIONS BELOW ARE iPHONE ONLY FOR NOW
+
+ContactManager.prototype.newContact = function(contact, successCallback, options) {
+    if (!options) options = {};
+    options.successCallback = GetFunctionName(successCallback);
+    
+    PhoneGap.exec("Contacts.newContact", contact.firstName, contact.lastName, contact.phoneNumber,
+        options);
+}
+
+ContactManager.prototype.chooseContact = function(successCallback, options) {
+    PhoneGap.exec("Contacts.chooseContact", GetFunctionName(successCallback), options);
+}
+
+ContactManager.prototype.displayContact = function(contactID, errorCallback, options) {
+    PhoneGap.exec("Contacts.displayContact", contactID, GetFunctionName(errorCallback), options);
+}
+
+ContactManager.prototype.removeContact = function(contactID, successCallback, options) {
+    PhoneGap.exec("Contacts.removeContact", contactID, GetFunctionName(successCallback), options);
+}
+
+ContactManager.prototype.contactsCount = function(successCallback, errorCallback) {
+	PhoneGap.exec("Contacts.contactsCount", GetFunctionName(successCallback));
+}
+
+DebugConsole.prototype.log = function(message) {
+    if (PhoneGap.available)
+        PhoneGap.exec('DebugConsole.log',
+            this.processMessage(message),
+            { logLevel: 'INFO' }
+        );
+    else
+        console.log(message);
+};
+DebugConsole.prototype.warn = function(message) {
+    if (PhoneGap.available)
+        PhoneGap.exec('DebugConsole.log',
+            this.processMessage(message),
+            { logLevel: 'WARN' }
+        );
+    else
+        console.error(message);
+};
+DebugConsole.prototype.error = function(message) {
+    if (PhoneGap.available)
+        PhoneGap.exec('DebugConsole.log',
+            this.processMessage(message),
+            { logLevel: 'ERROR' }
+        );
+    else
+        console.error(message);
+};
+Geolocation.prototype.start = function(args) {
+    PhoneGap.exec("Location.start", args);
+};
+
+Geolocation.prototype.stop = function() {
+    PhoneGap.exec("Location.stop");
+};
+/**
+ * Media/Audio override.
+ *
+ */
+
+Media.prototype.play = function() {
+	if (this.src != null) {
+		PhoneGap.exec("Sound.play", this.src);
+	}
+}
+Notification.prototype.vibrate = function(mills) {
+	PhoneGap.exec("Notification.vibrate");
+};
+
+Notification.prototype.beep = function(count, volume) {
+	// No Volume yet for the iphone interface
+	// We can use a canned beep sound and call that
+	new Media('beep.wav').play();
+};
+
+Notification.prototype.alert = function(message, title, buttonLabel) {
+    var options = {};
+    if (title) options.title = title;
+    if (buttonLabel) options.buttonLabel = buttonLabel;
+
+    if (PhoneGap.available)
+        PhoneGap.exec('Notification.alert', message, options);
+    else
+        alert(message);
+};
+
+Notification.prototype.activityStart = function() {
+    PhoneGap.exec("Notification.activityStart");
+};
+Notification.prototype.activityStop = function() {
+    PhoneGap.exec("Notification.activityStop");
+};
+
+Notification.prototype.loadingStart = function(options) {
+    PhoneGap.exec("Notification.loadingStart", options);
+};
+Notification.prototype.loadingStop = function() {
+    PhoneGap.exec("Notification.loadingStop");
+};
+/**
+ * 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
+ */
+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;
+    for (var 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 query_args = [];
+        for (var name in dict) {
+            if (typeof(name) != 'string')
+                continue;
+            query_args.push(encodeURIComponent(name) + "=" + encodeURIComponent(dict[name]));
+        }
+        if (query_args.length > 0)
+            url += "?" + query_args.join("&");
+    }
+    document.location = url;
+
+};
+UIControls.prototype.createTabBar = function() {
+    PhoneGap.exec("UIControls.createTabBar");
+};
+
+UIControls.prototype.showTabBar = function(options) {
+    if (!options) options = {};
+    PhoneGap.exec("UIControls.showTabBar", options);
+};
+
+UIControls.prototype.hideTabBar = function(animate) {
+    if (animate == undefined || animate == null)
+        animate = true;
+    PhoneGap.exec("UIControls.hideTabBar", { animate: animate });
+};
+
+UIControls.prototype.createTabBarItem = function(name, label, image, options) {
+    var tag = this.tabBarTag++;
+    if (options && 'onSelect' in options && typeof(options['onSelect']) == 'function') {
+        this.tabBarCallbacks[tag] = options.onSelect;
+        delete options.onSelect;
+    }
+    PhoneGap.exec("UIControls.createTabBarItem", name, label, image, tag, options);
+};
+
+UIControls.prototype.updateTabBarItem = function(name, options) {
+    if (!options) options = {};
+    PhoneGap.exec("UIControls.updateTabBarItem", name, options);
+};
+
+UIControls.prototype.showTabBarItems = function() {
+    var parameters = [ "UIControls.showTabBarItems" ];
+    for (var i = 0; i < arguments.length; i++) {
+        parameters.push(arguments[i]);
+    }
+    PhoneGap.exec.apply(this, parameters);
+};
+
+UIControls.prototype.selectTabBarItem = function(tab) {
+    PhoneGap.exec("UIControls.selectTabBarItem", tab);
+};
+
+UIControls.prototype.createToolBar = function() {
+    PhoneGap.exec("UIControls.createToolBar");
+};
+
+UIControls.prototype.setToolBarTitle = function(title) {
+    PhoneGap.exec("UIControls.setToolBarTitle", title);
+};