Merge pull request #18 from christocracy/edge

Edge

LICENSE

@@ -16,7 +16,7 @@ Cordova Background Geolocation - Terms and conditions
 		- Allowing 3rd Parties to run Software on Licensee's Website[s] and Server[s];
 		- Publishing Software’s output to Licensee and 3rd Parties;
 		- Distribute verbatim copies of Software's output (including compiled binaries);
-		- Modify Software to suit Licensee’s needs and specifications.
+		- Modify Software to suit Licensee's needs and specifications.
 
 	2.2 Binary Restricted: Licensee may sublicense Software as a part of a larger work containing more than Software, distributed solely in Object or Binary form under a personal, non-sublicensable, limited license. Such redistribution shall be limited to unlimited codebases.</li><li>
 

example/SampleApp/www/js/index.js

+/**
+* cordova-background-geolocation
+* Copyright (c) 2015, Transistor Software (9224-2932 Quebec Inc)
+* All rights reserved.
+* sales@transistorsoft.com
+* http://transistorsoft.com
+* @see LICENSE
+*/
 var ENV = (function() {
     
     var localStorage = window.localStorage;
@@ -124,8 +132,6 @@ var app = {
         * This would be your own callback for Ajax-requests after POSTing background geolocation to your server.
         */
         var yourAjaxCallback = function(response) {
-            // NB:  It's important to inform BackgroundGeolocation when your callback is complete so it can terminate the native background-process which is currently running your callback.
-            // If you fail to execute #finish, the OS might kill your app for leaving a background-process running.
             bgGeo.finish();
         };
 
@@ -133,7 +139,7 @@ var app = {
         * This callback will be executed every time a geolocation is recorded in the background.
         */
         var callbackFn = function(location) {
-            console.log('[js] BackgroundGeoLocation callback:  ' + location.latitude + ',' + location.longitude);
+            console.log('[js] BackgroundGeoLocation callback:  ' + JSON.stringify(location));
             
             // Update our current-position marker.
             app.setCurrentLocation(location);
@@ -148,6 +154,7 @@ var app = {
 
         // Only ios emits this stationary event
         bgGeo.onStationary(function(location) {
+            console.log('[js] BackgroundGeoLocation onStationary ' + JSON.stringify(location));
             if (!app.stationaryRadius) {
                 app.stationaryRadius = new google.maps.Circle({
                     fillColor: '#cc0000',
@@ -165,14 +172,28 @@ var app = {
 
         // BackgroundGeoLocation is highly configurable.
         bgGeo.configure(callbackFn, failureFn, {
-            desiredAccuracy: 0,                         // <-- 0:  highest power, highest accuracy; 1000:  lowest power, lowest accuracy.
+            debug: true, // <-- enable this hear sounds for background-geolocation life-cycle.
+            desiredAccuracy: 0,
             stationaryRadius: 50,
-            distanceFilter: 50,                         // <-- minimum distance between location events
-            activityType: 'AutomotiveNavigation',       // <-- [ios]
-            locationUpdateInterval: 30000,              // <-- [android] minimum time between location updates, used in conjunction with #distanceFilter
-            activityRecognitionInterval: 10000,         // <-- [android] sampling-rate activity-recognition system for movement/stationary detection
-            debug: true,                                // <-- enable this hear sounds, see notifications during life-cycle events.
-            stopOnTerminate: false                      // <-- enable this to clear background location settings when the app terminates
+            distanceFilter: 50,
+            locationUpdateInterval: 5000,
+            activityRecognitionInterval: 10000,
+            stopTimeout: 0,
+            forceReload: true,      // <-- If the user closes the app **while location-tracking is started** , reboot app (WARNING: possibly distruptive to user) 
+            stopOnTerminate: false, // <-- Allow the background-service to run headless when user closes the app.
+            activityType: 'AutomotiveNavigation'
+            /**
+            * HTTP Feature:  set an url to allow the native background service to POST locations to your server
+            *
+            ,url: 'http://posttestserver.com/post.php?dir=cordova-background-geolocation',
+            headers: {
+                "X-FOO": "bar"
+            },
+            params: {
+                "auth_token": "maybe_your_server_authenticates_via_token_YES?"
+            }
+            *
+            */
         });
         
         // Turn ON the background-geolocation system.  The user will be tracked whenever they suspend the app.
@@ -347,4 +368,4 @@ var app = {
     }
 };
 
-app.initialize();
\ No newline at end of file
+app.initialize();

plugin.xml

@@ -27,9 +27,27 @@
         <source-file src="src/android/libs/eventbus-2.4.0.jar" target-dir="libs" />
         <source-file src="src/android/BackgroundGeolocationPlugin.java" target-dir="src/com/transistorsoft/cordova/bggeo" />
         <source-file src="src/android/BackgroundGeolocationService.java" target-dir="src/com/transistorsoft/cordova/bggeo" />
+        <source-file src="src/android/ActivityRecognitionService.java" target-dir="src/com/transistorsoft/cordova/bggeo" />
+        <source-file src="src/android/LocationService.java" target-dir="src/com/transistorsoft/cordova/bggeo" />
+        <source-file src="src/android/BootReceiver.java" target-dir="src/com/transistorsoft/cordova/bggeo" />
         
+        <!-- For SQLite persistence NOT YET IMPLEMENTED
+        <source-file src="src/android/data/LocationDAO.java" target-dir="src/com/tenforwardconsulting/cordova/bgloc/data" />
+        <source-file src="src/android/data/sqlite/LocationOpenHelper.java" target-dir="src/com/tenforwardconsulting/cordova/bgloc/data/sqlite" />
+        <source-file src="src/android/data/sqlite/SQLiteLocationDAO.java" target-dir="src/com/tenforwardconsulting/cordova/bgloc/data/sqlite" />
+        -->
+
         <config-file target="AndroidManifest.xml" parent="/manifest/application">
             <service android:name="com.transistorsoft.cordova.bggeo.BackgroundGeolocationService" />
+            <service android:name="com.transistorsoft.cordova.bggeo.LocationService" />
+            <service android:name="com.transistorsoft.cordova.bggeo.ActivityRecognitionService" />
+            
+            <!-- autorun on boot receiver -->
+            <receiver android:name="com.transistorsoft.cordova.bggeo.BootReceiver" android:enabled="true" android:exported="false">
+                <intent-filter>
+                    <action android:name="android.intent.action.BOOT_COMPLETED"/>
+                </intent-filter>
+            </receiver>
         </config-file>
 
         <config-file target="AndroidManifest.xml" parent="/manifest">
@@ -40,6 +58,10 @@
             <uses-permission android:name="android.permission.INTERNET" />
             <uses-permission android:name="android.permission.WAKE_LOCK" />
             <uses-permission android:name="com.google.android.gms.permission.ACTIVITY_RECOGNITION" />
+
+            <!-- Autorun your app on device BOOT.  UNCOMMENT TO ENABLE AUTO-BOOT -->
+            <!-- <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" /> -->
+
         </config-file>   
         <config-file target="res/xml/config.xml" parent="/*">
             <feature name="BackgroundGeoLocation">

src/android/ActivityRecognitionService.java

+package com.transistorsoft.cordova.bggeo;
+
+import de.greenrobot.event.EventBus;
+
+import com.google.android.gms.location.DetectedActivity;
+import com.google.android.gms.location.ActivityRecognitionResult;
+import android.app.IntentService;
+import android.content.Intent;
+import android.util.Log;
+
+public class ActivityRecognitionService extends IntentService {
+
+    private static final String TAG = "BackgroundGeolocation";
+    
+    public ActivityRecognitionService() {
+        super("com.transistorsoft.cordova.bggeo.ActivityRecognitionService");
+    }
+
+    @Override
+    protected void onHandleIntent(Intent intent) {
+        // Determine whether the fore-ground Activity is running.  If it's not, we'll reboot it.
+        
+        if (ActivityRecognitionResult.hasResult(intent)) {
+            ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
+            DetectedActivity probableActivity = result.getMostProbableActivity();
+            
+            Log.w(TAG, "Activity detected:" + getActivityName(probableActivity.getType()) + ", confidence:" + probableActivity.getConfidence());
+            if (probableActivity.getConfidence() < 80) {
+                return;
+            }
+
+            switch (probableActivity.getType()) {
+                case DetectedActivity.IN_VEHICLE:
+                case DetectedActivity.ON_BICYCLE:
+                case DetectedActivity.ON_FOOT:
+                case DetectedActivity.WALKING:
+                case DetectedActivity.RUNNING:
+                case DetectedActivity.STILL:
+                    EventBus.getDefault().post(result);
+                    break;
+                case DetectedActivity.UNKNOWN:
+                    return;
+                case DetectedActivity.TILTING:
+                    return;
+            }
+        }
+    }
+    
+    /**
+     * This method has no other purpose than formatting the Activity for log-messages 
+     */
+    private String getActivityName(int activityType) {
+        switch (activityType) {
+            case DetectedActivity.IN_VEHICLE:
+                return "in_vehicle";
+            case DetectedActivity.ON_BICYCLE:
+                return "on_bicycle";
+            case DetectedActivity.ON_FOOT:
+                return "on_foot";
+            case DetectedActivity.RUNNING:
+                return "running";
+            case DetectedActivity.WALKING:
+                return "walking";
+            case DetectedActivity.STILL:
+                return "still";
+            case DetectedActivity.UNKNOWN:
+                return "unknown";
+            case DetectedActivity.TILTING:
+                return "tilting";
+        }
+        return "unknown";
+    }
+}
\ No newline at end of file

src/android/BootReceiver.java

+package com.transistorsoft.cordova.bggeo;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+/**
+ * This boot receiver is meant to handle the case where device is first booted after power up.  
+ * This boot the headless BackgroundGeolocationService as configured by this class.
+ * @author chris scott
+ *
+ */
+public class BootReceiver extends BroadcastReceiver {   
+	private static final String TAG = "BackgroundGeolocation";
+	
+	/**
+	 * Background Geolocation Configuration params.
+	 * If you're auto-running the service on BOOT, you need to manually configure the params here since the foreground app will not have been booted.
+	 */
+	private float 	distanceFilter 					= 50;
+	private Integer desiredAccuracy 				= 0;
+	private Integer locationUpdateInterval 				= 5000;
+	private Integer activityRecognitionInterval 			= 10000;
+	private long 	stopTimeout 					= 0;
+	private boolean debug 						= true;
+	private boolean stopOnTerminate 				= false;
+	private boolean forceReload 					= false;
+	private String 	url 						= "http://posttestserver.com/post.php?dir=cordova-background-geolocation";
+	private String 	params 						= "{'foo':'bar'}";
+	private String 	headers 					= "{'X-FOO':'BAR'}";
+	
+    @Override
+    public void onReceive(Context context, Intent intent) {
+    	Log.i(TAG, "- BootReceiver booting service");
+    	
+    	Intent backgroundServiceIntent = new Intent(context, BackgroundGeolocationService.class);
+    	
+    	// Configure background geolocation service params.
+        backgroundServiceIntent.putExtra("distanceFilter", distanceFilter);
+        backgroundServiceIntent.putExtra("desiredAccuracy", desiredAccuracy);
+        backgroundServiceIntent.putExtra("locationUpdateInterval", locationUpdateInterval);
+        backgroundServiceIntent.putExtra("activityRecognitionInterval", activityRecognitionInterval);
+        backgroundServiceIntent.putExtra("stopTimeout", stopTimeout);
+        backgroundServiceIntent.putExtra("debug", debug);
+        backgroundServiceIntent.putExtra("stopOnTerminate", stopOnTerminate);
+        backgroundServiceIntent.putExtra("forceReload", forceReload);
+        backgroundServiceIntent.putExtra("url", url);
+        backgroundServiceIntent.putExtra("params", params);        
+        backgroundServiceIntent.putExtra("headers", headers);
+        
+        // Start the service.
+        context.startService(backgroundServiceIntent);
+    	
+    }
+}

src/android/LocationService.java

+package com.transistorsoft.cordova.bggeo;
+
+import de.greenrobot.event.EventBus;
+
+import com.google.android.gms.location.FusedLocationProviderApi;
+import android.app.IntentService;
+import android.content.Intent;
+import android.location.Location;
+import android.util.Log;
+
+public class LocationService extends IntentService {
+
+	private static final String TAG = "BackgroundGeolocation";
+	
+	public LocationService() {
+		super("com.transistorsoft.cordova.bggeo.LocationUpdateService");
+	}
+
+	@Override
+	protected void onHandleIntent(Intent intent) {
+		final Location location = intent.getParcelableExtra(FusedLocationProviderApi.KEY_LOCATION_CHANGED);
+		
+		if (location != null) {
+			Log.i(TAG, "Location received: " + location.toString());
+			EventBus.getDefault().post(location);	
+		}
+	}
+	
+}
\ No newline at end of file

src/android/data/LocationDAO.java

+package com.transistorsoft.cordova.bggeo.data;
+
+import org.json.JSONObject;
+import org.json.JSONException;
+
+public interface LocationDAO {
+    public JSONObject[] getAllLocations();
+    public boolean persistLocation(JSONObject l);
+    public void deleteLocation(JSONObject l);
+}
\ No newline at end of file

src/android/data/sqlite/LocationOpenHelper.java

+package com.transistorsoft.cordova.bggeo.data.sqlite;
+
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.util.Log;
+
+public class LocationOpenHelper extends SQLiteOpenHelper {
+    private static final String SQLITE_DATABASE_NAME = "cordova_background_geolocation";
+    private static final int DATABASE_VERSION = 1;
+    public static final String LOCATION_TABLE_NAME = "locations";
+    private static final String LOCATION_TABLE_COLUMNS = "timestamp INTEGER PRIMARY KEY, json TEXT";
+    private static final String LOCATION_TABLE_CREATE = "CREATE TABLE " + LOCATION_TABLE_NAME + " (" + LOCATION_TABLE_COLUMNS + ");";
+
+    LocationOpenHelper(Context context) {
+        super(context, SQLITE_DATABASE_NAME, null, DATABASE_VERSION);
+    }    
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+        db.execSQL(LOCATION_TABLE_CREATE);
+        Log.d(this.getClass().getName(), LOCATION_TABLE_CREATE);
+    }
+
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        // TODO Auto-generated method stub
+        
+    }
+}

src/android/data/sqlite/SQLiteLocationDAO.java

+package com.transistorsoft.cordova.bggeo.data.sqlite;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.TimeZone;
+import java.util.List;
+
+import org.json.JSONObject;
+import org.json.JSONException;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.util.Log;
+
+import com.transistorsoft.cordova.bggeo.data.LocationDAO;
+
+public class SQLiteLocationDAO implements LocationDAO {
+	private static final String TAG = "SQLiteLocationDAO";
+	private Context context;
+	
+	public SQLiteLocationDAO(Context context) {
+		this.context = context;
+	}
+	
+	/*
+	public JSONObject[] getAllLocations() {
+		SQLiteDatabase db = null;
+		Cursor c = null;
+		List<JSONObject> all = new ArrayList<JSONObject>();
+		try {
+			db = new LocationOpenHelper(context).getReadableDatabase();
+			c = db.query(LocationOpenHelper.LOCATION_TABLE_NAME, null);
+			while (c.moveToNext()) {
+				all.add(hydrate(c));
+			}
+		} finally {
+			if (c != null) {
+				c.close();
+			}
+			if (db != null) {
+				db.close();
+			}
+		}
+		return all.toArray(new JSONObject[all.size()]);
+	}
+
+	public boolean persistLocation(JSONObject location) {
+		SQLiteDatabase db = new LocationOpenHelper(context).getWritableDatabase();
+		db.beginTransaction();
+		ContentValues values = getContentValues(location);
+		long rowId = db.insert(LocationOpenHelper.LOCATION_TABLE_NAME, null, values);
+		Log.d(TAG, "After insert, rowId = " + rowId);
+		db.setTransactionSuccessful();
+		db.endTransaction();
+		db.close();
+		if (rowId > -1) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	
+	public void deleteLocation(JSONObject location) {
+		SQLiteDatabase db = new LocationOpenHelper(context).getWritableDatabase();
+		db.beginTransaction();
+		db.delete(LocationOpenHelper.LOCATION_TABLE_NAME, "timestamp = ?", location.getString("timestamp"));
+		db.setTransactionSuccessful();
+		db.endTransaction();
+		db.close();
+	}
+	
+	private JSONObject hydrate(Cursor c) {
+		JSONObject l = new JSONObject(c);
+		return l;
+	}
+	
+	private ContentValues getContentValues(JSONObject location) {
+		ContentValues values = new ContentValues();
+		values.put("latitude", location.get("latitude"));
+		values.put("longitude", location.get("longitude"));
+		values.put("timestamp", location.get("timestamp"));
+		values.put("accuracy",  location.get("accuracy"));
+		values.put("altitude", location.get("altitude"));
+		values.put("bearing", location.get("bearing"));
+		values.put("speed", location.get("speed"));
+		return values;
+	}
+	*/
+}
\ No newline at end of file

www/BackgroundGeoLocation.js

+/**
+* cordova-background-geolocation
+* Copyright (c) 2015, Transistor Software (9224-2932 Quebec Inc)
+* All rights reserved.
+* sales@transistorsoft.com
+* http://transistorsoft.com
+* @see LICENSE
+*/
 var exec = require("cordova/exec");
 module.exports = {
     /**