mobile_template 0.0.1

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

@@ -0,0 +1,153 @@
+/*
+       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;
+
+public class NetworkListener 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 NetworkListener(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.NETWORK_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) {
+		System.out.println("NetworkListener: The provider " + provider + " is disabled");
+	}
+
+	/**
+	 * Called when the provider is enabled by the user.
+	 * 
+	 * @param provider
+	 */
+	public void onProviderEnabled(String provider) {
+		System.out.println("NetworkListener: 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("NetworkListener: The status of the provider " + provider + " has changed");
+		if (status == 0) {
+			System.out.println("NetworkListener: " + provider + " is OUT OF SERVICE");
+		}
+		else if (status == 1) {
+			System.out.println("NetworkListener: " + provider + " is TEMPORARILY_UNAVAILABLE");
+		}
+		else {
+			System.out.println("NetworkListener: " + provider + " is Available");
+		}
+	}
+
+	/**
+	 * Called when the location has changed.
+	 * 
+	 * @param location
+	 */
+	public void onLocationChanged(Location location) {
+		System.out.println("NetworkListener: The location has been updated!");
+		this.hasData = true;
+		this.cLoc = location;
+		
+		// The GPS is the primary form of Geolocation in Cordova.  
+		// Only fire the success variables if the GPS is down for some reason.
+		if (!this.owner.mGps.hasLocation()) {
+			this.owner.success(location);
+		}
+	}
+	
+	/**
+	 * Start requesting location updates.
+	 * 
+	 * @param interval
+	 */
+	public void start(int interval)	{
+		if (!this.running) {
+			this.running = true;
+			this.mLocMan.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, interval, 0, this);
+			this.getLocation();
+			
+			// If Network provider has data but GPS provider doesn't, then send ours
+			if (this.hasData && !this.owner.mGps.hasLocation()) {
+				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/NetworkManager.java

@@ -0,0 +1,248 @@
+/*
+       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 org.apache.cordova.api.Plugin;
+import org.apache.cordova.api.PluginResult;
+import org.json.JSONArray;
+
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.util.Log;
+
+public class NetworkManager extends Plugin {
+    
+    public static int NOT_REACHABLE = 0;
+    public static int REACHABLE_VIA_CARRIER_DATA_NETWORK = 1;
+    public static int REACHABLE_VIA_WIFI_NETWORK = 2;
+
+    public static final String WIFI = "wifi";
+    public static final String WIMAX = "wimax";
+    // mobile
+    public static final String MOBILE = "mobile";
+    // 2G network types
+    public static final String GSM = "gsm";
+    public static final String GPRS = "gprs";
+    public static final String EDGE = "edge";
+    // 3G network types
+    public static final String CDMA = "cdma";
+    public static final String UMTS = "umts";
+    public static final String HSPA = "hspa";
+    public static final String HSUPA = "hsupa";
+    public static final String HSDPA = "hsdpa";
+    public static final String ONEXRTT = "1xrtt";
+    public static final String EHRPD = "ehrpd";
+    // 4G network types
+    public static final String LTE = "lte";
+    public static final String UMB = "umb";
+    public static final String HSPA_PLUS = "hspa+";
+    // return types
+    public static final String TYPE_UNKNOWN = "unknown";
+    public static final String TYPE_ETHERNET = "ethernet";
+    public static final String TYPE_WIFI = "wifi";
+    public static final String TYPE_2G = "2g";
+    public static final String TYPE_3G = "3g";
+    public static final String TYPE_4G = "4g";
+    public static final String TYPE_NONE = "none";
+    
+    private static final String LOG_TAG = "NetworkManager";
+
+    private String connectionCallbackId;
+
+    ConnectivityManager sockMan;
+    BroadcastReceiver receiver;
+    
+    /**
+     * Constructor.
+     */
+    public NetworkManager()    {
+        this.receiver = null;
+    }
+
+    /**
+     * Sets the context of the Command. This can then be used to do things like
+     * get file paths associated with the Activity.
+     * 
+     * @param ctx The context of the main Activity.
+     */
+    public void setContext(CordovaInterface ctx) {
+        super.setContext(ctx);
+        this.sockMan = (ConnectivityManager) ctx.getSystemService(Context.CONNECTIVITY_SERVICE);        
+        this.connectionCallbackId = null;
+        
+        // We need to listen to connectivity events to update navigator.connection
+        IntentFilter intentFilter = new IntentFilter() ;
+        intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
+        if (this.receiver == null) {
+            this.receiver = new BroadcastReceiver() {
+                @Override
+                public void onReceive(Context context, Intent intent) {                
+                    updateConnectionInfo((NetworkInfo) intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO));                
+                }
+            };
+            ctx.registerReceiver(this.receiver, intentFilter);
+        }
+
+    }
+    
+    /**
+     * 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.INVALID_ACTION;
+        String result = "Unsupported Operation: " + action;    
+        
+        if (action.equals("getConnectionInfo")) {
+            this.connectionCallbackId = callbackId;
+            NetworkInfo info = sockMan.getActiveNetworkInfo();
+            PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, this.getConnectionInfo(info));
+            pluginResult.setKeepCallback(true);
+            return pluginResult;
+        }
+        
+        return new PluginResult(status, result);
+    }
+
+    /**
+     * 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) {
+        // All methods take a while, so always use async
+        return false;
+    }
+    
+    /**
+     * Stop network receiver.
+     */
+    public void onDestroy() {
+        if (this.receiver != null) {
+            try {
+                this.ctx.unregisterReceiver(this.receiver);
+            } catch (Exception e) {
+                Log.e(LOG_TAG, "Error unregistering network receiver: " + e.getMessage(), e);
+            }
+        }
+    }
+
+    //--------------------------------------------------------------------------
+    // LOCAL METHODS
+    //--------------------------------------------------------------------------
+
+
+    /**
+     * Updates the JavaScript side whenever the connection changes
+     * 
+     * @param info the current active network info
+     * @return
+     */
+    private void updateConnectionInfo(NetworkInfo info) {     
+        // send update to javascript "navigator.network.connection"
+        sendUpdate(this.getConnectionInfo(info));
+    }
+
+    /** 
+     * Get the latest network connection information
+     * 
+     * @param info the current active network info
+     * @return a JSONObject that represents the network info
+     */
+    private String getConnectionInfo(NetworkInfo info) {
+        String type = TYPE_NONE;
+        if (info != null) {
+            // If we are not connected to any network set type to none
+            if (!info.isConnected()) {
+                type = TYPE_NONE;
+            }            
+            else {
+                type = getType(info);
+            }
+        }
+        return type;
+    }
+    
+    /**
+     * Create a new plugin result and send it back to JavaScript
+     * 
+     * @param connection the network info to set as navigator.connection
+     */
+    private void sendUpdate(String type) {
+        PluginResult result = new PluginResult(PluginResult.Status.OK, type);
+        result.setKeepCallback(true);
+        this.success(result, this.connectionCallbackId);
+        
+        // Send to all plugins
+        this.ctx.postMessage("networkconnection", type);
+    }
+    
+    /**
+     * Determine the type of connection
+     * 
+     * @param info the network info so we can determine connection type.
+     * @return the type of mobile network we are on
+     */
+    private String getType(NetworkInfo info) {
+        if (info != null) {
+            String type = info.getTypeName(); 
+
+            if (type.toLowerCase().equals(WIFI)) {
+                return TYPE_WIFI;
+            }
+            else if (type.toLowerCase().equals(MOBILE)) {
+                type = info.getSubtypeName();
+                if (type.toLowerCase().equals(GSM) || 
+                        type.toLowerCase().equals(GPRS) ||
+                        type.toLowerCase().equals(EDGE)) {
+                    return TYPE_2G;
+                }
+                else if (type.toLowerCase().startsWith(CDMA) || 
+                        type.toLowerCase().equals(UMTS)  ||
+                        type.toLowerCase().equals(ONEXRTT) ||
+                        type.toLowerCase().equals(EHRPD) ||
+                        type.toLowerCase().equals(HSUPA) ||
+                        type.toLowerCase().equals(HSDPA) ||
+                        type.toLowerCase().equals(HSPA)) {
+                    return TYPE_3G;
+                }
+                else if (type.toLowerCase().equals(LTE) || 
+                        type.toLowerCase().equals(UMB) ||
+                        type.toLowerCase().equals(HSPA_PLUS)) {
+                    return TYPE_4G;
+                }
+            }
+        } 
+        else {
+            return TYPE_NONE;
+        }
+        return TYPE_UNKNOWN;
+    }
+}