/*
|
* 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.
|
* 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 com.android.server.location;
|
|
import java.io.PrintWriter;
|
import java.util.Iterator;
|
import java.util.LinkedList;
|
import java.util.List;
|
|
import android.app.AppOpsManager;
|
import android.app.PendingIntent;
|
import android.content.ContentResolver;
|
import android.content.Context;
|
import android.content.Intent;
|
import android.database.ContentObserver;
|
import android.location.Geofence;
|
import android.location.Location;
|
import android.location.LocationListener;
|
import android.location.LocationManager;
|
import android.location.LocationRequest;
|
import android.os.Bundle;
|
import android.os.Handler;
|
import android.os.Message;
|
import android.os.PowerManager;
|
import android.os.SystemClock;
|
import android.os.UserHandle;
|
import android.provider.Settings;
|
import android.util.Slog;
|
|
import com.android.server.LocationManagerService;
|
import com.android.server.PendingIntentUtils;
|
|
public class GeofenceManager implements LocationListener, PendingIntent.OnFinished {
|
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
|
* force a new location update anyway).
|
*/
|
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
|
|
/**
|
* The default value of most frequent update interval allowed.
|
*/
|
private static final long DEFAULT_MIN_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
|
|
/**
|
* 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 AppOpsManager mAppOps;
|
private final PowerManager.WakeLock mWakeLock;
|
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;
|
|
/**
|
* The actual value of most frequent update interval allowed.
|
*/
|
private long mEffectiveMinIntervalMs;
|
private ContentResolver mResolver;
|
|
public GeofenceManager(Context context, LocationBlacklist blacklist) {
|
mContext = context;
|
mLocationManager = (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);
|
mAppOps = (AppOpsManager)mContext.getSystemService(Context.APP_OPS_SERVICE);
|
PowerManager powerManager = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
|
mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
|
mHandler = new GeofenceHandler();
|
mBlacklist = blacklist;
|
mResolver = mContext.getContentResolver();
|
updateMinInterval();
|
mResolver.registerContentObserver(
|
Settings.Global.getUriFor(
|
Settings.Global.LOCATION_BACKGROUND_THROTTLE_PROXIMITY_ALERT_INTERVAL_MS),
|
true,
|
new ContentObserver(mHandler) {
|
@Override
|
public void onChange(boolean selfChange) {
|
synchronized (mLock) {
|
updateMinInterval();
|
}
|
}
|
}, UserHandle.USER_ALL);
|
}
|
|
/**
|
* Updates the minimal location request frequency.
|
*/
|
private void updateMinInterval() {
|
mEffectiveMinIntervalMs = Settings.Global.getLong(mResolver,
|
Settings.Global.LOCATION_BACKGROUND_THROTTLE_PROXIMITY_ALERT_INTERVAL_MS,
|
DEFAULT_MIN_INTERVAL_MS);
|
}
|
|
public void addFence(LocationRequest request, Geofence geofence, PendingIntent intent,
|
int allowedResolutionLevel, 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(), allowedResolutionLevel, uid, packageName, intent);
|
synchronized (mLock) {
|
// first make sure it doesn't already exist
|
for (int i = mFences.size() - 1; i >= 0; i--) {
|
GeofenceState w = mFences.get(i);
|
if (geofence.equals(w.mFence) && intent.equals(w.mIntent)) {
|
// already exists, remove the old one
|
mFences.remove(i);
|
break;
|
}
|
}
|
mFences.add(state);
|
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()) {
|
GeofenceState state = iter.next();
|
if (state.mIntent.equals(intent)) {
|
|
if (fence == null) {
|
// always remove
|
iter.remove();
|
} else {
|
// just remove matching fences
|
if (fence.equals(state.mFence)) {
|
iter.remove();
|
}
|
}
|
}
|
}
|
scheduleUpdateFencesLocked();
|
}
|
}
|
|
public void removeFence(String packageName) {
|
if (D) {
|
Slog.d(TAG, "removeFence: packageName=" + packageName);
|
}
|
|
synchronized (mLock) {
|
Iterator<GeofenceState> iter = mFences.iterator();
|
while (iter.hasNext()) {
|
GeofenceState state = iter.next();
|
if (state.mPackageName.equals(packageName)) {
|
iter.remove();
|
}
|
}
|
scheduleUpdateFencesLocked();
|
}
|
}
|
|
private void removeExpiredFencesLocked() {
|
long time = SystemClock.elapsedRealtime();
|
Iterator<GeofenceState> iter = mFences.iterator();
|
while (iter.hasNext()) {
|
GeofenceState state = iter.next();
|
if (state.mExpireAt < time) {
|
iter.remove();
|
}
|
}
|
}
|
|
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) {
|
Slog.d(TAG, "skipping geofence processing for blacklisted app: "
|
+ state.mPackageName);
|
}
|
continue;
|
}
|
|
int op = LocationManagerService.resolutionLevelToOp(state.mAllowedResolutionLevel);
|
if (op >= 0) {
|
if (mAppOps.noteOpNoThrow(AppOpsManager.OP_FINE_LOCATION, state.mUid,
|
state.mPackageName) != AppOpsManager.MODE_ALLOWED) {
|
if (D) {
|
Slog.d(TAG, "skipping geofence processing for no op app: "
|
+ state.mPackageName);
|
}
|
continue;
|
}
|
}
|
|
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(mEffectiveMinIntervalMs,
|
minFenceDistance * 1000 / MAX_SPEED_M_S));
|
} else {
|
intervalMs = mEffectiveMinIntervalMs;
|
}
|
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
|
for (PendingIntent intent : exitIntents) {
|
sendIntentExit(intent);
|
}
|
for (PendingIntent intent : enterIntents) {
|
sendIntentEnter(intent);
|
}
|
}
|
|
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 {
|
pendingIntent.send(mContext, 0, intent, this, null,
|
android.Manifest.permission.ACCESS_FINE_LOCATION,
|
PendingIntentUtils.createDontSendToRestrictedAppsBundle(null));
|
} catch (PendingIntent.CanceledException e) {
|
removeFence(null, pendingIntent);
|
mWakeLock.release();
|
}
|
// ...otherwise, mWakeLock.release() gets called by onSendFinished()
|
}
|
|
// Runs on the handler (which was passed into LocationManager.requestLocationUpdates())
|
@Override
|
public void onLocationChanged(Location 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
|
public void onStatusChanged(String provider, int status, Bundle extras) { }
|
|
@Override
|
public void onProviderEnabled(String provider) { }
|
|
@Override
|
public void onProviderDisabled(String provider) { }
|
|
@Override
|
public void onSendFinished(PendingIntent pendingIntent, Intent intent, int resultCode,
|
String resultData, Bundle resultExtras) {
|
mWakeLock.release();
|
}
|
|
public void dump(PrintWriter pw) {
|
pw.println(" Geofences:");
|
|
for (GeofenceState state : mFences) {
|
pw.append(" ");
|
pw.append(state.mPackageName);
|
pw.append(" ");
|
pw.append(state.mFence.toString());
|
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;
|
}
|
}
|
}
|
}
|
}
|
