Fires geofence if the device is already in the geofence area.

Process the location of the fence as soon as it is added.

Clarified how the distance to the fence was being used.

Added more debug logs (disabled by default).

Fixed a numerical overflow in the location request if the
distance to the border of the nearest fence was greater
than about 2000Km.

Removed a useless call to request location updates passively
when the geofence manager is initialized.  We have no need
of location updates unless there are active geofences.
The effect of this call was undone the next time the location
request was updated anyhow.

Changed the location request to always request a fastest update
interval of 0 which accomplishes the goal of passively
monitoring all updates.  This does not increase the power
consumption because we are conservative about choosing
a minimum location update interval.  We're simply stating
that the geofence manager is willing to handle a higher
report rate which is very important.

Subject location to a "freshness test" - only use relatively
recent locations for geofence testing.

Run all geofence updates on the handler and avoid making
multiple redundant calls into the location manager when
updating the provider requirements.

Ensure that we update geofences correctly even if we don't
know the initial location of the device at the time the
geofence is created.

Pin update interval value to the range [1m..2hr].

Distance to fence is now distance to fence's border, not
distance to fence's centre.

Bug: 7466334
Change-Id: I28e571ecfc508d5ceb9bb2afcabaaf05abb26369

2 files changed, 247 insertions, 72 deletions

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.Iterator;
 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.LocationListener;
 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 @@ public class GeofenceManager implements LocationListener, PendingIntent.OnFinish
     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 @@ public class GeofenceManager implements LocationListener, PendingIntent.OnFinish
      */
     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 @@ public class GeofenceManager implements LocationListener, PendingIntent.OnFinish
                 }
             }
             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 @@ public class GeofenceManager implements LocationListener, PendingIntent.OnFinish
                 if (state.mIntent.equals(intent)) {
 
                     if (fence == null) {
-                        // alwaus remove
+                        // always remove
                         iter.remove();
                     } else {
                         // just remove matching fences
@@ -113,11 +159,15 @@ public class GeofenceManager implements LocationListener, PendingIntent.OnFinish
                     }
                 }
             }
-            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 @@ public class GeofenceManager implements LocationListener, PendingIntent.OnFinish
                     iter.remove();
                 }
             }
-            updateProviderRequirementsLocked();
+            scheduleUpdateFencesLocked();
         }
     }
 
@@ -141,29 +191,133 @@ public class GeofenceManager implements LocationListener, PendingIntent.OnFinish
         }
     }
 
-    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);
+                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;
+                    }
+                }
+            }
+
+            // 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 ((event & GeofenceState.FLAG_EXIT) != 0) {
-                    exitIntents.add(state.mIntent);
+                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);
             }
-            updateProviderRequirementsLocked();
         }
 
         // release lock before sending intents
@@ -176,55 +330,54 @@ public class GeofenceManager implements LocationListener, PendingIntent.OnFinish
     }
 
     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();
+    // Runs on the handler (which was passed into LocationManager.requestLocationUpdates())
+    @Override
+    public void onLocationChanged(Location location) {
+        synchronized (mLock) {
+            if (mReceivingLocationUpdates) {
+                mLastLocationUpdate = location;
             }
-        }
 
-        if (minDistance == Double.MAX_VALUE) {
-            disableLocationLocked();
-        } else {
-            int intervalMs = (int)(minDistance * 1000) / MAX_SPEED_M_S;
-            requestLocationLocked(intervalMs);
+            // Update the fences immediately before returning in
+            // case the caller is holding a wakelock.
+            if (mPendingUpdate) {
+                mHandler.removeMessages(MSG_UPDATE_FENCES);
+            } else {
+                mPendingUpdate = true;
+            }
         }
-    }
-
-    private void requestLocationLocked(int intervalMs) {
-        mLocationManager.requestLocationUpdates(new LocationRequest().setInterval(intervalMs), this,
-                mLooper);
-    }
-
-    private void disableLocationLocked() {
-        mLocationManager.removeUpdates(this);
-    }
-
-    @Override
-    public void onLocationChanged(Location location) {
-        processLocation(location);
+        updateFences();
     }
 
     @Override
@@ -253,4 +406,20 @@ public class GeofenceManager implements LocationListener, PendingIntent.OnFinish
             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 class GeofenceState {
     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 @@ public class GeofenceState {
         mLocation = new Location("");
         mLocation.setLatitude(fence.getLatitude());
         mLocation.setLongitude(fence.getLongitude());
-
-        if (prevLocation != null) {
-            processLocation(prevLocation);
-        }
     }
 
     /**
@@ -64,26 +61,35 @@ public class GeofenceState {
      * @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 @@ public class GeofenceState {
             default:
                 state = "?";
         }
-        return String.format("%s d=%.0f %s", mFence.toString(), mDistance, state);
+        return String.format("%s d=%.0f %s", mFence.toString(), mDistanceToCenter, state);
     }
 }