am 66f3d7f3: am 446ffe00: am e6299d5a: Merge "Fires geofence if the device is already in the geofence area." into jb-mr1-dev
* commit '66f3d7f3c8247b59516cbc4ad13bea4e0b8c0ef9':
Fires geofence if the device is already in the geofence area.
diff --git a/services/java/com/android/server/location/GeofenceManager.java b/services/java/com/android/server/location/GeofenceManager.java
index d04d2f3..f9be719 100644
--- a/services/java/com/android/server/location/GeofenceManager.java
+++ b/services/java/com/android/server/location/GeofenceManager.java
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 20012 The Android Open Source Project
+ * Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -21,7 +21,6 @@
import java.util.LinkedList;
import java.util.List;
-import android.Manifest.permission;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
@@ -31,10 +30,11 @@
import android.location.LocationManager;
import android.location.LocationRequest;
import android.os.Bundle;
-import android.os.Looper;
+import android.os.Handler;
+import android.os.Message;
import android.os.PowerManager;
import android.os.SystemClock;
-import android.util.Log;
+import android.util.Slog;
import com.android.server.LocationManagerService;
@@ -42,6 +42,8 @@
private static final String TAG = "GeofenceManager";
private static final boolean D = LocationManagerService.D;
+ private static final int MSG_UPDATE_FENCES = 1;
+
/**
* Assume a maximum land speed, as a heuristic to throttle location updates.
* (Air travel should result in an airplane mode toggle which will
@@ -49,37 +51,77 @@
*/
private static final int MAX_SPEED_M_S = 100; // 360 km/hr (high speed train)
+ /**
+ * Maximum age after which a location is no longer considered fresh enough to use.
+ */
+ private static final long MAX_AGE_NANOS = 5 * 60 * 1000000000L; // five minutes
+
+ /**
+ * Most frequent update interval allowed.
+ */
+ private static final long MIN_INTERVAL_MS = 1 * 60 * 1000; // one minute
+
+ /**
+ * Least frequent update interval allowed.
+ */
+ private static final long MAX_INTERVAL_MS = 2 * 60 * 60 * 1000; // two hours
+
private final Context mContext;
private final LocationManager mLocationManager;
private final PowerManager.WakeLock mWakeLock;
- private final Looper mLooper; // looper thread to take location updates on
+ private final GeofenceHandler mHandler;
private final LocationBlacklist mBlacklist;
private Object mLock = new Object();
// access to members below is synchronized on mLock
+ /**
+ * A list containing all registered geofences.
+ */
private List<GeofenceState> mFences = new LinkedList<GeofenceState>();
+ /**
+ * This is set true when we have an active request for {@link Location} updates via
+ * {@link LocationManager#requestLocationUpdates(LocationRequest, LocationListener,
+ * android.os.Looper).
+ */
+ private boolean mReceivingLocationUpdates;
+
+ /**
+ * The update interval component of the current active {@link Location} update request.
+ */
+ private long mLocationUpdateInterval;
+
+ /**
+ * The {@link Location} most recently received via {@link #onLocationChanged(Location)}.
+ */
+ private Location mLastLocationUpdate;
+
+ /**
+ * This is set true when a {@link Location} is received via
+ * {@link #onLocationChanged(Location)} or {@link #scheduleUpdateFencesLocked()}, and cleared
+ * when that Location has been processed via {@link #updateFences()}
+ */
+ private boolean mPendingUpdate;
+
public GeofenceManager(Context context, LocationBlacklist blacklist) {
mContext = context;
mLocationManager = (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);
PowerManager powerManager = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
- mLooper = Looper.myLooper();
+ mHandler = new GeofenceHandler();
mBlacklist = blacklist;
-
- LocationRequest request = new LocationRequest()
- .setQuality(LocationRequest.POWER_NONE)
- .setFastestInterval(0);
- mLocationManager.requestLocationUpdates(request, this, Looper.myLooper());
}
- public void addFence(LocationRequest request, Geofence geofence, PendingIntent intent, int uid,
- String packageName) {
- Location lastLocation = mLocationManager.getLastLocation();
- GeofenceState state = new GeofenceState(geofence, lastLocation,
- request.getExpireAt(), packageName, intent);
+ public void addFence(LocationRequest request, Geofence geofence, PendingIntent intent,
+ int uid, String packageName) {
+ if (D) {
+ Slog.d(TAG, "addFence: request=" + request + ", geofence=" + geofence
+ + ", intent=" + intent + ", uid=" + uid + ", packageName=" + packageName);
+ }
+ GeofenceState state = new GeofenceState(geofence,
+ request.getExpireAt(), packageName, intent);
synchronized (mLock) {
// first make sure it doesn't already exist
for (int i = mFences.size() - 1; i >= 0; i--) {
@@ -91,11 +133,15 @@
}
}
mFences.add(state);
- updateProviderRequirementsLocked();
+ scheduleUpdateFencesLocked();
}
}
public void removeFence(Geofence fence, PendingIntent intent) {
+ if (D) {
+ Slog.d(TAG, "removeFence: fence=" + fence + ", intent=" + intent);
+ }
+
synchronized (mLock) {
Iterator<GeofenceState> iter = mFences.iterator();
while (iter.hasNext()) {
@@ -103,7 +149,7 @@
if (state.mIntent.equals(intent)) {
if (fence == null) {
- // alwaus remove
+ // always remove
iter.remove();
} else {
// just remove matching fences
@@ -113,11 +159,15 @@
}
}
}
- updateProviderRequirementsLocked();
+ scheduleUpdateFencesLocked();
}
}
public void removeFence(String packageName) {
+ if (D) {
+ Slog.d(TAG, "removeFence: packageName=" + packageName);
+ }
+
synchronized (mLock) {
Iterator<GeofenceState> iter = mFences.iterator();
while (iter.hasNext()) {
@@ -126,7 +176,7 @@
iter.remove();
}
}
- updateProviderRequirementsLocked();
+ scheduleUpdateFencesLocked();
}
}
@@ -141,29 +191,133 @@
}
}
- private void processLocation(Location location) {
+ private void scheduleUpdateFencesLocked() {
+ if (!mPendingUpdate) {
+ mPendingUpdate = true;
+ mHandler.sendEmptyMessage(MSG_UPDATE_FENCES);
+ }
+ }
+
+ /**
+ * Returns the location received most recently from {@link #onLocationChanged(Location)},
+ * or consult {@link LocationManager#getLastLocation()} if none has arrived. Does not return
+ * either if the location would be too stale to be useful.
+ *
+ * @return a fresh, valid Location, or null if none is available
+ */
+ private Location getFreshLocationLocked() {
+ // Prefer mLastLocationUpdate to LocationManager.getLastLocation().
+ Location location = mReceivingLocationUpdates ? mLastLocationUpdate : null;
+ if (location == null && !mFences.isEmpty()) {
+ location = mLocationManager.getLastLocation();
+ }
+
+ // Early out for null location.
+ if (location == null) {
+ return null;
+ }
+
+ // Early out for stale location.
+ long now = SystemClock.elapsedRealtimeNanos();
+ if (now - location.getElapsedRealtimeNanos() > MAX_AGE_NANOS) {
+ return null;
+ }
+
+ // Made it this far? Return our fresh, valid location.
+ return location;
+ }
+
+ /**
+ * The geofence update loop. This function removes expired fences, then tests the most
+ * recently-received {@link Location} against each registered {@link GeofenceState}, sending
+ * {@link Intent}s for geofences that have been tripped. It also adjusts the active location
+ * update request with {@link LocationManager} as appropriate for any active geofences.
+ */
+ // Runs on the handler.
+ private void updateFences() {
List<PendingIntent> enterIntents = new LinkedList<PendingIntent>();
List<PendingIntent> exitIntents = new LinkedList<PendingIntent>();
synchronized (mLock) {
+ mPendingUpdate = false;
+
+ // Remove expired fences.
removeExpiredFencesLocked();
+ // Get a location to work with, either received via onLocationChanged() or
+ // via LocationManager.getLastLocation().
+ Location location = getFreshLocationLocked();
+
+ // Update all fences.
+ // Keep track of the distance to the nearest fence.
+ double minFenceDistance = Double.MAX_VALUE;
+ boolean needUpdates = false;
for (GeofenceState state : mFences) {
if (mBlacklist.isBlacklisted(state.mPackageName)) {
- if (D) Log.d(TAG, "skipping geofence processing for blacklisted app: " +
- state.mPackageName);
+ if (D) {
+ Slog.d(TAG, "skipping geofence processing for blacklisted app: "
+ + state.mPackageName);
+ }
continue;
}
- int event = state.processLocation(location);
- if ((event & GeofenceState.FLAG_ENTER) != 0) {
- enterIntents.add(state.mIntent);
- }
- if ((event & GeofenceState.FLAG_EXIT) != 0) {
- exitIntents.add(state.mIntent);
+ needUpdates = true;
+ if (location != null) {
+ int event = state.processLocation(location);
+ if ((event & GeofenceState.FLAG_ENTER) != 0) {
+ enterIntents.add(state.mIntent);
+ }
+ if ((event & GeofenceState.FLAG_EXIT) != 0) {
+ exitIntents.add(state.mIntent);
+ }
+
+ // FIXME: Ideally this code should take into account the accuracy of the
+ // location fix that was used to calculate the distance in the first place.
+ double fenceDistance = state.getDistanceToBoundary(); // MAX_VALUE if unknown
+ if (fenceDistance < minFenceDistance) {
+ minFenceDistance = fenceDistance;
+ }
}
}
- updateProviderRequirementsLocked();
+
+ // Request or cancel location updates if needed.
+ if (needUpdates) {
+ // Request location updates.
+ // Compute a location update interval based on the distance to the nearest fence.
+ long intervalMs;
+ if (location != null && Double.compare(minFenceDistance, Double.MAX_VALUE) != 0) {
+ intervalMs = (long)Math.min(MAX_INTERVAL_MS, Math.max(MIN_INTERVAL_MS,
+ minFenceDistance * 1000 / MAX_SPEED_M_S));
+ } else {
+ intervalMs = MIN_INTERVAL_MS;
+ }
+ if (!mReceivingLocationUpdates || mLocationUpdateInterval != intervalMs) {
+ mReceivingLocationUpdates = true;
+ mLocationUpdateInterval = intervalMs;
+ mLastLocationUpdate = location;
+
+ LocationRequest request = new LocationRequest();
+ request.setInterval(intervalMs).setFastestInterval(0);
+ mLocationManager.requestLocationUpdates(request, this, mHandler.getLooper());
+ }
+ } else {
+ // Cancel location updates.
+ if (mReceivingLocationUpdates) {
+ mReceivingLocationUpdates = false;
+ mLocationUpdateInterval = 0;
+ mLastLocationUpdate = null;
+
+ mLocationManager.removeUpdates(this);
+ }
+ }
+
+ if (D) {
+ Slog.d(TAG, "updateFences: location=" + location
+ + ", mFences.size()=" + mFences.size()
+ + ", mReceivingLocationUpdates=" + mReceivingLocationUpdates
+ + ", mLocationUpdateInterval=" + mLocationUpdateInterval
+ + ", mLastLocationUpdate=" + mLastLocationUpdate);
+ }
}
// release lock before sending intents
@@ -176,55 +330,54 @@
}
private void sendIntentEnter(PendingIntent pendingIntent) {
+ if (D) {
+ Slog.d(TAG, "sendIntentEnter: pendingIntent=" + pendingIntent);
+ }
+
Intent intent = new Intent();
intent.putExtra(LocationManager.KEY_PROXIMITY_ENTERING, true);
sendIntent(pendingIntent, intent);
}
private void sendIntentExit(PendingIntent pendingIntent) {
+ if (D) {
+ Slog.d(TAG, "sendIntentExit: pendingIntent=" + pendingIntent);
+ }
+
Intent intent = new Intent();
intent.putExtra(LocationManager.KEY_PROXIMITY_ENTERING, false);
sendIntent(pendingIntent, intent);
}
private void sendIntent(PendingIntent pendingIntent, Intent intent) {
+ mWakeLock.acquire();
try {
- mWakeLock.acquire();
- pendingIntent.send(mContext, 0, intent, this, null, permission.ACCESS_FINE_LOCATION);
+ pendingIntent.send(mContext, 0, intent, this, null,
+ android.Manifest.permission.ACCESS_FINE_LOCATION);
} catch (PendingIntent.CanceledException e) {
removeFence(null, pendingIntent);
mWakeLock.release();
}
+ // ...otherwise, mWakeLock.release() gets called by onSendFinished()
}
- private void updateProviderRequirementsLocked() {
- double minDistance = Double.MAX_VALUE;
- for (GeofenceState state : mFences) {
- if (state.getDistance() < minDistance) {
- minDistance = state.getDistance();
- }
- }
-
- if (minDistance == Double.MAX_VALUE) {
- disableLocationLocked();
- } else {
- int intervalMs = (int)(minDistance * 1000) / MAX_SPEED_M_S;
- requestLocationLocked(intervalMs);
- }
- }
-
- private void requestLocationLocked(int intervalMs) {
- mLocationManager.requestLocationUpdates(new LocationRequest().setInterval(intervalMs), this,
- mLooper);
- }
-
- private void disableLocationLocked() {
- mLocationManager.removeUpdates(this);
- }
-
+ // Runs on the handler (which was passed into LocationManager.requestLocationUpdates())
@Override
public void onLocationChanged(Location location) {
- processLocation(location);
+ synchronized (mLock) {
+ if (mReceivingLocationUpdates) {
+ mLastLocationUpdate = location;
+ }
+
+ // Update the fences immediately before returning in
+ // case the caller is holding a wakelock.
+ if (mPendingUpdate) {
+ mHandler.removeMessages(MSG_UPDATE_FENCES);
+ } else {
+ mPendingUpdate = true;
+ }
+ }
+ updateFences();
}
@Override
@@ -253,4 +406,20 @@
pw.append("\n");
}
}
+
+ private final class GeofenceHandler extends Handler {
+ public GeofenceHandler() {
+ super(true /*async*/);
+ }
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case MSG_UPDATE_FENCES: {
+ updateFences();
+ break;
+ }
+ }
+ }
+ }
}
diff --git a/services/java/com/android/server/location/GeofenceState.java b/services/java/com/android/server/location/GeofenceState.java
index 1fd737f..11705ff 100644
--- a/services/java/com/android/server/location/GeofenceState.java
+++ b/services/java/com/android/server/location/GeofenceState.java
@@ -39,11 +39,12 @@
public final PendingIntent mIntent;
int mState; // current state
- double mDistance; // current distance to center of fence
+ double mDistanceToCenter; // current distance to center of fence
- public GeofenceState(Geofence fence, Location prevLocation, long expireAt,
+ public GeofenceState(Geofence fence, long expireAt,
String packageName, PendingIntent intent) {
mState = STATE_UNKNOWN;
+ mDistanceToCenter = Double.MAX_VALUE;
mFence = fence;
mExpireAt = expireAt;
@@ -53,10 +54,6 @@
mLocation = new Location("");
mLocation.setLatitude(fence.getLatitude());
mLocation.setLongitude(fence.getLongitude());
-
- if (prevLocation != null) {
- processLocation(prevLocation);
- }
}
/**
@@ -64,26 +61,35 @@
* @return FLAG_ENTER or FLAG_EXIT if the fence was crossed, 0 otherwise
*/
public int processLocation(Location location) {
- mDistance = mLocation.distanceTo(location);
+ mDistanceToCenter = mLocation.distanceTo(location);
int prevState = mState;
//TODO: inside/outside detection could be made more rigorous
- boolean inside = mDistance <= Math.max(mFence.getRadius(), location.getAccuracy());
+ boolean inside = mDistanceToCenter <= Math.max(mFence.getRadius(), location.getAccuracy());
if (inside) {
mState = STATE_INSIDE;
+ if (prevState != STATE_INSIDE) {
+ return FLAG_ENTER; // return enter if previously exited or unknown
+ }
} else {
mState = STATE_OUTSIDE;
- }
-
- if (prevState != 0 && mState != prevState) {
- if (mState == STATE_INSIDE) return FLAG_ENTER;
- if (mState == STATE_OUTSIDE) return FLAG_EXIT;
+ if (prevState == STATE_INSIDE) {
+ return FLAG_EXIT; // return exit only if previously entered
+ }
}
return 0;
}
- public double getDistance() {
- return mDistance;
+ /**
+ * Gets the distance from the current location to the fence's boundary.
+ * @return The distance or {@link Double#MAX_VALUE} if unknown.
+ */
+ public double getDistanceToBoundary() {
+ if (Double.compare(mDistanceToCenter, Double.MAX_VALUE) == 0) {
+ return Double.MAX_VALUE;
+ } else {
+ return Math.abs(mFence.getRadius() - mDistanceToCenter);
+ }
}
@Override
@@ -99,6 +105,6 @@
default:
state = "?";
}
- return String.format("%s d=%.0f %s", mFence.toString(), mDistance, state);
+ return String.format("%s d=%.0f %s", mFence.toString(), mDistanceToCenter, state);
}
}