mobile_template 0.0.1

data/templates/cordova_android/framework/src/org/apache/cordova/GeoBroker.java

@@ -0,0 +1,165 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+package org.apache.cordova;
+
+import java.util.HashMap;
+import java.util.Map.Entry;
+
+import org.apache.cordova.api.Plugin;
+import org.apache.cordova.api.PluginResult;
+import org.json.JSONArray;
+import org.json.JSONException;
+
+
+/*
+ * This class is the interface to the Geolocation.  It's bound to the geo object.
+ * 
+ * This class only starts and stops various GeoListeners, which consist of a GPS and a Network Listener
+ */
+
+public class GeoBroker extends Plugin {
+    
+    // List of gGeolocation listeners
+    private HashMap<String, GeoListener> geoListeners;
+	private GeoListener global;
+	
+	/**
+	 * Constructor.
+	 */
+	public GeoBroker() {
+		this.geoListeners = new HashMap<String, GeoListener>();
+	}
+
+	/**
+	 * Executes the request and returns PluginResult.
+	 * 
+	 * @param action 		The action to execute.
+	 * @param args 			JSONArry of arguments for the plugin.
+	 * @param callbackId	The callback id used when calling back into JavaScript.
+	 * @return 				A PluginResult object with a status and message.
+	 */
+	public PluginResult execute(String action, JSONArray args, String callbackId) {
+		PluginResult.Status status = PluginResult.Status.OK;
+		String result = "";		
+		
+		try {
+			if (action.equals("getCurrentLocation")) {
+				this.getCurrentLocation(args.getBoolean(0), args.getInt(1), args.getInt(2));
+			}
+			else if (action.equals("start")) {
+				String s = this.start(args.getString(0), args.getBoolean(1), args.getInt(2), args.getInt(3));
+				return new PluginResult(status, s);
+			}
+			else if (action.equals("stop")) {
+				this.stop(args.getString(0));
+			}
+			return new PluginResult(status, result);
+		} catch (JSONException e) {
+			return new PluginResult(PluginResult.Status.JSON_EXCEPTION);
+		}
+	}
+
+	/**
+	 * Identifies if action to be executed returns a value and should be run synchronously.
+	 * 
+	 * @param action	The action to execute
+	 * @return			T=returns value
+	 */
+	public boolean isSynch(String action) {
+		// Starting listeners is easier to run on main thread, so don't run async.
+		return true;
+	}
+    
+    /**
+     * Called when the activity is to be shut down.
+     * Stop listener.
+     */
+    public void onDestroy() {
+		java.util.Set<Entry<String,GeoListener>> s = this.geoListeners.entrySet();
+        java.util.Iterator<Entry<String,GeoListener>> it = s.iterator();
+        while (it.hasNext()) {
+            Entry<String,GeoListener> entry = it.next();
+            GeoListener listener = entry.getValue();
+            listener.destroy();
+		}
+        this.geoListeners.clear();
+        if (this.global != null) {
+        	this.global.destroy();
+        }
+        this.global = null;
+    }
+
+    //--------------------------------------------------------------------------
+    // LOCAL METHODS
+    //--------------------------------------------------------------------------
+
+    /**
+     * Get current location.
+     * The result is returned to JavaScript via a callback.
+     * 
+	 * @param enableHighAccuracy
+	 * @param timeout
+	 * @param maximumAge
+     */
+	public void getCurrentLocation(boolean enableHighAccuracy, int timeout, int maximumAge) {
+		
+		// Create a geolocation listener just for getCurrentLocation and call it "global"
+		if (this.global == null) {
+			this.global = new GeoListener(this, "global", maximumAge);
+		}
+		else {
+			this.global.start(maximumAge);
+		}
+	}
+	
+	/**
+	 * Start geolocation listener and add to listener list.
+	 * 
+	 * @param key					The listener id
+	 * @param enableHighAccuracy
+	 * @param timeout
+	 * @param maximumAge
+	 * @return
+	 */
+	public String start(String key, boolean enableHighAccuracy, int timeout, int maximumAge) {
+		
+		// Make sure this listener doesn't already exist
+		GeoListener listener = geoListeners.get(key);
+		if (listener == null) {
+			listener = new GeoListener(this, key, maximumAge);
+			geoListeners.put(key, listener);
+		}
+		
+		// Start it
+		listener.start(maximumAge);
+		return key;
+	}
+	
+	/**
+	 * Stop geolocation listener and remove from listener list.
+	 * 
+	 * @param key			The listener id
+	 */
+	public void stop(String key) {
+		GeoListener listener = geoListeners.remove(key);
+		if (listener != null) {
+			listener.stop();
+		}
+	}
+}

data/templates/cordova_android/framework/src/org/apache/cordova/GeoListener.java

@@ -0,0 +1,133 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+package org.apache.cordova;
+
+import android.content.Context;
+import android.location.Location;
+import android.location.LocationManager;
+import android.webkit.WebView;
+
+public class GeoListener {
+	public static int PERMISSION_DENIED = 1;
+	public static int POSITION_UNAVAILABLE = 2;
+	public static int TIMEOUT = 3;
+
+	String id;							// Listener ID
+	String successCallback;				// 
+	String failCallback;
+    GpsListener mGps;					// GPS listener
+    NetworkListener mNetwork;			// Network listener
+    LocationManager mLocMan;			// Location manager
+    
+    private GeoBroker broker;			// GeoBroker object
+	
+	int interval;
+	
+	/**
+	 * Constructor.
+	 * 
+	 * @param id			Listener id
+	 * @param ctx
+	 * @param time			Sampling period in msec
+	 * @param appView
+	 */
+	GeoListener(GeoBroker broker, String id, int time) {
+		this.id = id;
+		this.interval = time;
+		this.broker = broker;
+		this.mGps = null;
+		this.mNetwork = null;
+		this.mLocMan = (LocationManager) broker.ctx.getSystemService(Context.LOCATION_SERVICE);
+
+		// If GPS provider, then create and start GPS listener
+		if (this.mLocMan.getProvider(LocationManager.GPS_PROVIDER) != null) {
+			this.mGps = new GpsListener(broker.ctx, time, this);
+		}
+		
+		// If network provider, then create and start network listener
+		if (this.mLocMan.getProvider(LocationManager.NETWORK_PROVIDER) != null) {
+			this.mNetwork = new NetworkListener(broker.ctx, time, this);
+		}
+	}
+	
+	/**
+	 * Destroy listener.
+	 */
+	public void destroy() {
+		this.stop();
+	}
+	
+	/**
+	 * Location found.  Send location back to JavaScript.
+	 * 
+	 * @param loc
+	 */
+	void success(Location loc) {
+		
+		String params = loc.getLatitude() + "," + loc.getLongitude() + ", " + loc.getAltitude() + 
+				"," + loc.getAccuracy() + "," + loc.getBearing() +
+		 		"," + loc.getSpeed() + "," + loc.getTime();
+		
+		if (id == "global") {
+			this.stop();
+		}
+		this.broker.sendJavascript("navigator._geo.success('" + id + "'," +  params + ");");
+	}
+	
+	/**
+	 * Location failed.  Send error back to JavaScript.
+	 * 
+	 * @param code			The error code
+	 * @param msg			The error message
+	 */
+	void fail(int code, String msg) {
+		this.broker.sendJavascript("navigator._geo.fail('" + this.id + "', '" + code + "', '" + msg + "');");
+		this.stop();
+	}
+	
+	/**
+	 * Start retrieving location.
+	 * 
+	 * @param interval
+	 */
+	void start(int interval) {
+		if (this.mGps != null) {
+			this.mGps.start(interval);
+		}
+		if (this.mNetwork != null) {
+			this.mNetwork.start(interval);
+		}
+		if (this.mNetwork == null && this.mGps == null) {
+			this.fail(POSITION_UNAVAILABLE, "No location providers available.");
+		}
+	}
+	
+	/**
+	 * Stop listening for location.
+	 */
+	void stop() {
+		if (this.mGps != null) {
+			this.mGps.stop();
+		}
+		if (this.mNetwork != null) {
+			this.mNetwork.stop();
+		}
+	}
+
+}

data/templates/cordova_android/framework/src/org/apache/cordova/GpsListener.java

@@ -0,0 +1,163 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+
+package org.apache.cordova;
+
+import org.apache.cordova.api.CordovaInterface;
+
+import android.content.Context;
+import android.location.Location;
+import android.location.LocationManager;
+import android.location.LocationListener;
+import android.os.Bundle;
+
+/**
+ * This class handles requests for GPS location services.
+ *
+ */
+public class GpsListener implements LocationListener {
+	
+	private CordovaInterface mCtx;				// CordovaActivity object
+	
+	private LocationManager mLocMan;			// Location manager object
+	private GeoListener owner;					// Geolistener object (parent)
+	private boolean hasData = false;			// Flag indicates if location data is available in cLoc
+	private Location cLoc;						// Last recieved location
+	private boolean running = false;			// Flag indicates if listener is running
+	
+	/**
+	 * Constructor.  
+	 * Automatically starts listening.
+	 * 
+	 * @param ctx
+	 * @param interval
+	 * @param m
+	 */
+	public GpsListener(CordovaInterface ctx, int interval, GeoListener m) {
+		this.owner = m;
+		this.mCtx = ctx;
+		this.mLocMan = (LocationManager) this.mCtx.getSystemService(Context.LOCATION_SERVICE);
+		this.running = false;
+		this.start(interval);
+	}
+	
+	/**
+	 * Get last location.
+	 * 
+	 * @return 				Location object
+	 */
+	public Location getLocation() {
+		this.cLoc = this.mLocMan.getLastKnownLocation(LocationManager.GPS_PROVIDER);
+		if (this.cLoc != null) {
+			this.hasData = true;
+		}
+		return this.cLoc;
+	}
+	
+	/**
+	 * Called when the provider is disabled by the user.
+	 * 
+	 * @param provider
+	 */
+	public void onProviderDisabled(String provider) {
+		this.owner.fail(GeoListener.POSITION_UNAVAILABLE, "GPS provider disabled.");
+	}
+
+	/**
+	 * Called when the provider is enabled by the user.
+	 * 
+	 * @param provider
+	 */
+	public void onProviderEnabled(String provider) {
+		System.out.println("GpsListener: The provider "+ provider + " is enabled");
+	}
+
+	/**
+	 * Called when the provider status changes. This method is called when a 
+	 * provider is unable to fetch a location or if the provider has recently 
+	 * become available after a period of unavailability.
+	 * 
+	 * @param provider
+	 * @param status
+	 * @param extras
+	 */
+	public void onStatusChanged(String provider, int status, Bundle extras) {
+		System.out.println("GpsListener: The status of the provider " + provider + " has changed");
+		if (status == 0) {
+			System.out.println("GpsListener: " + provider + " is OUT OF SERVICE");
+			this.owner.fail(GeoListener.POSITION_UNAVAILABLE, "GPS out of service.");
+		}
+		else if (status == 1) {
+			System.out.println("GpsListener: " + provider + " is TEMPORARILY_UNAVAILABLE");
+		}
+		else {
+			System.out.println("GpsListener: " + provider + " is Available");
+		}
+	}
+
+	/**
+	 * Called when the location has changed.
+	 * 
+	 * @param location
+	 */
+	public void onLocationChanged(Location location) {
+		System.out.println("GpsListener: The location has been updated!");
+		this.hasData = true;
+		this.cLoc = location;
+		this.owner.success(location);
+	}
+
+	/**
+	 * Determine if location data is available.
+	 * 
+	 * @return
+	 */
+	public boolean hasLocation() {
+		return this.hasData;
+	}
+	
+	/**
+	 * Start requesting location updates.
+	 * 
+	 * @param interval
+	 */
+	public void start(int interval) {
+		if (!this.running) {
+			this.running = true;
+			this.mLocMan.requestLocationUpdates(LocationManager.GPS_PROVIDER, interval, 0, this);
+			this.getLocation();
+
+			// If GPS provider has data, then send now
+			if (this.hasData) {
+				this.owner.success(this.cLoc);
+			}
+		}
+	}
+
+	/**
+	 * Stop receiving location updates.
+	 */
+	public void stop() {
+		if (this.running) {
+			this.mLocMan.removeUpdates(this);
+		}
+		this.running = false;
+	}
+	
+}

data/templates/cordova_android/framework/src/org/apache/cordova/HttpHandler.java

@@ -0,0 +1,80 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+package org.apache.cordova;
+
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.DefaultHttpClient;
+
+public class HttpHandler {
+
+	protected Boolean get(String url, String file)
+	{
+		HttpEntity entity = getHttpEntity(url);
+		try {
+			writeToDisk(entity, file);
+		} catch (Exception e) { e.printStackTrace(); return false; }
+		try {
+			entity.consumeContent();
+		} catch (Exception e) { e.printStackTrace(); return false; }
+		return true;
+	}
+	
+	private HttpEntity getHttpEntity(String url)
+	/**
+	 * get the http entity at a given url
+	 */
+	{
+		HttpEntity entity=null;
+		try {
+			DefaultHttpClient httpclient = new DefaultHttpClient();
+			HttpGet httpget = new HttpGet(url);
+			HttpResponse response = httpclient.execute(httpget);
+			entity = response.getEntity();
+		} catch (Exception e) { e.printStackTrace(); return null; }
+		return entity;
+	}
+	
+	private void writeToDisk(HttpEntity entity, String file) throws IllegalStateException, IOException
+	/**
+	 * writes a HTTP entity to the specified filename and location on disk
+	 */
+	{  
+		int i=0;
+		String FilePath="/sdcard/" + file;
+		InputStream in = entity.getContent();
+		byte buff[] = new byte[1024];    
+		FileOutputStream out=
+			new FileOutputStream(FilePath);
+		do {
+			int numread = in.read(buff);
+			if (numread <= 0)
+				break;
+			out.write(buff, 0, numread);
+			i++;
+		} while (true);
+		out.flush();
+		out.close();	
+	}
+}

data/templates/cordova_android/framework/src/org/apache/cordova/LinearLayoutSoftKeyboardDetect.java

@@ -0,0 +1,104 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+package org.apache.cordova;
+import org.apache.cordova.api.LOG;
+
+import android.content.Context;
+import android.view.View.MeasureSpec;
+import android.widget.LinearLayout;
+
+/**
+ * This class is used to detect when the soft keyboard is shown and hidden in the web view.
+ */
+public class LinearLayoutSoftKeyboardDetect extends LinearLayout {
+
+    private static final String TAG = "SoftKeyboardDetect";
+    
+    private int oldHeight = 0;  // Need to save the old height as not to send redundant events
+    private int oldWidth = 0; // Need to save old width for orientation change          
+    private int screenWidth = 0;
+    private int screenHeight = 0;
+    private DroidGap app = null;
+                
+    public LinearLayoutSoftKeyboardDetect(Context context, int width, int height) {
+        super(context);     
+        screenWidth = width;
+        screenHeight = height;
+        app = (DroidGap) context;
+    }
+
+    @Override
+    /**
+     * Start listening to new measurement events.  Fire events when the height 
+     * gets smaller fire a show keyboard event and when height gets bigger fire 
+     * a hide keyboard event.
+     * 
+     * Note: We are using app.postMessage so that this is more compatible with the API
+     * 
+     * @param widthMeasureSpec
+     * @param heightMeasureSpec
+     */
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);       
+        
+        LOG.v(TAG, "We are in our onMeasure method");
+
+        // Get the current height of the visible part of the screen.
+        // This height will not included the status bar.\
+        int width, height;
+
+        height = MeasureSpec.getSize(heightMeasureSpec);
+        width = MeasureSpec.getSize(widthMeasureSpec);
+        LOG.v(TAG, "Old Height = %d", oldHeight);
+        LOG.v(TAG, "Height = %d", height);             
+        LOG.v(TAG, "Old Width = %d", oldWidth);
+        LOG.v(TAG, "Width = %d", width);
+
+        // If the oldHeight = 0 then this is the first measure event as the app starts up.
+        // If oldHeight == height then we got a measurement change that doesn't affect us.
+        if (oldHeight == 0 || oldHeight == height) {
+            LOG.d(TAG, "Ignore this event");
+        }
+        // Account for orientation change and ignore this event/Fire orientation change
+        else if(screenHeight == width)
+        {
+            int tmp_var = screenHeight;
+            screenHeight = screenWidth;
+            screenWidth = tmp_var;
+            LOG.v(TAG, "Orientation Change");
+        }
+        // If the height as gotten bigger then we will assume the soft keyboard has 
+        // gone away.
+        else if (height > oldHeight) {
+            if(app != null)
+                app.sendJavascript("require('cordova').fireDocumentEvent('hidekeyboard');");
+        } 
+        // If the height as gotten smaller then we will assume the soft keyboard has 
+        // been displayed.
+        else if (height < oldHeight) {
+            if(app != null)
+                app.sendJavascript("require('cordova').fireDocumentEvent('showkeyboard');");
+        }
+
+        // Update the old height for the next event
+        oldHeight = height;
+        oldWidth = width;
+    }
+
+}