LocationManagerService.java revision a4903f254b4711c8fc0ac5f7e3d605f4dce34f35
1/* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package com.android.server; 18 19import java.io.FileDescriptor; 20import java.io.PrintWriter; 21import java.util.ArrayList; 22import java.util.HashMap; 23import java.util.HashSet; 24import java.util.List; 25import java.util.Map; 26import java.util.Observable; 27import java.util.Observer; 28import java.util.Set; 29 30import android.app.PendingIntent; 31import android.content.BroadcastReceiver; 32import android.content.ComponentName; 33import android.content.ContentQueryMap; 34import android.content.ContentResolver; 35import android.content.Context; 36import android.content.Intent; 37import android.content.IntentFilter; 38import android.content.ServiceConnection; 39import android.content.pm.PackageManager; 40import android.content.res.Resources; 41import android.database.Cursor; 42import android.location.Address; 43import android.location.GeocoderParams; 44import android.location.IGpsStatusListener; 45import android.location.IGpsStatusProvider; 46import android.location.ILocationListener; 47import android.location.ILocationManager; 48import android.location.INetInitiatedListener; 49import android.location.Location; 50import android.location.LocationManager; 51import android.location.LocationProvider; 52import android.location.LocationProviderInterface; 53import android.net.ConnectivityManager; 54import android.net.NetworkInfo; 55import android.net.Uri; 56import android.os.Binder; 57import android.os.Bundle; 58import android.os.Handler; 59import android.os.IBinder; 60import android.os.Looper; 61import android.os.Message; 62import android.os.PowerManager; 63import android.os.Process; 64import android.os.RemoteException; 65import android.provider.Settings; 66import android.util.Log; 67import android.util.PrintWriterPrinter; 68 69import com.android.internal.location.GeocoderProxy; 70import com.android.internal.location.GpsLocationProvider; 71import com.android.internal.location.GpsNetInitiatedHandler; 72import com.android.internal.location.LocationProviderProxy; 73import com.android.internal.location.MockProvider; 74import com.android.internal.location.PassiveProvider; 75 76/** 77 * The service class that manages LocationProviders and issues location 78 * updates and alerts. 79 * 80 * {@hide} 81 */ 82public class LocationManagerService extends ILocationManager.Stub implements Runnable { 83 private static final String TAG = "LocationManagerService"; 84 private static final boolean LOCAL_LOGV = false; 85 86 // The last time a location was written, by provider name. 87 private HashMap<String,Long> mLastWriteTime = new HashMap<String,Long>(); 88 89 private static final String ACCESS_FINE_LOCATION = 90 android.Manifest.permission.ACCESS_FINE_LOCATION; 91 private static final String ACCESS_COARSE_LOCATION = 92 android.Manifest.permission.ACCESS_COARSE_LOCATION; 93 private static final String ACCESS_MOCK_LOCATION = 94 android.Manifest.permission.ACCESS_MOCK_LOCATION; 95 private static final String ACCESS_LOCATION_EXTRA_COMMANDS = 96 android.Manifest.permission.ACCESS_LOCATION_EXTRA_COMMANDS; 97 private static final String INSTALL_LOCATION_PROVIDER = 98 android.Manifest.permission.INSTALL_LOCATION_PROVIDER; 99 100 // Set of providers that are explicitly enabled 101 private final Set<String> mEnabledProviders = new HashSet<String>(); 102 103 // Set of providers that are explicitly disabled 104 private final Set<String> mDisabledProviders = new HashSet<String>(); 105 106 // Locations, status values, and extras for mock providers 107 private final HashMap<String,MockProvider> mMockProviders = new HashMap<String,MockProvider>(); 108 109 private static boolean sProvidersLoaded = false; 110 111 private final Context mContext; 112 private GeocoderProxy mGeocodeProvider; 113 private IGpsStatusProvider mGpsStatusProvider; 114 private INetInitiatedListener mNetInitiatedListener; 115 private LocationWorkerHandler mLocationHandler; 116 117 // Cache the real providers for use in addTestProvider() and removeTestProvider() 118 LocationProviderInterface mNetworkLocationProvider; 119 LocationProviderInterface mGpsLocationProvider; 120 121 // Handler messages 122 private static final int MESSAGE_LOCATION_CHANGED = 1; 123 124 // wakelock variables 125 private final static String WAKELOCK_KEY = "LocationManagerService"; 126 private PowerManager.WakeLock mWakeLock = null; 127 private int mPendingBroadcasts; 128 129 /** 130 * List of all receivers. 131 */ 132 private final HashMap<Object, Receiver> mReceivers = new HashMap<Object, Receiver>(); 133 134 135 /** 136 * List of location providers. 137 */ 138 private final ArrayList<LocationProviderInterface> mProviders = 139 new ArrayList<LocationProviderInterface>(); 140 private final HashMap<String, LocationProviderInterface> mProvidersByName 141 = new HashMap<String, LocationProviderInterface>(); 142 143 /** 144 * Object used internally for synchronization 145 */ 146 private final Object mLock = new Object(); 147 148 /** 149 * Mapping from provider name to all its UpdateRecords 150 */ 151 private final HashMap<String,ArrayList<UpdateRecord>> mRecordsByProvider = 152 new HashMap<String,ArrayList<UpdateRecord>>(); 153 154 // Proximity listeners 155 private Receiver mProximityReceiver = null; 156 private ILocationListener mProximityListener = null; 157 private HashMap<PendingIntent,ProximityAlert> mProximityAlerts = 158 new HashMap<PendingIntent,ProximityAlert>(); 159 private HashSet<ProximityAlert> mProximitiesEntered = 160 new HashSet<ProximityAlert>(); 161 162 // Last known location for each provider 163 private HashMap<String,Location> mLastKnownLocation = 164 new HashMap<String,Location>(); 165 166 private int mNetworkState = LocationProvider.TEMPORARILY_UNAVAILABLE; 167 168 // for Settings change notification 169 private ContentQueryMap mSettings; 170 171 /** 172 * A wrapper class holding either an ILocationListener or a PendingIntent to receive 173 * location updates. 174 */ 175 private final class Receiver implements IBinder.DeathRecipient, PendingIntent.OnFinished { 176 final ILocationListener mListener; 177 final PendingIntent mPendingIntent; 178 final Object mKey; 179 final HashMap<String,UpdateRecord> mUpdateRecords = new HashMap<String,UpdateRecord>(); 180 int mPendingBroadcasts; 181 182 Receiver(ILocationListener listener) { 183 mListener = listener; 184 mPendingIntent = null; 185 mKey = listener.asBinder(); 186 } 187 188 Receiver(PendingIntent intent) { 189 mPendingIntent = intent; 190 mListener = null; 191 mKey = intent; 192 } 193 194 @Override 195 public boolean equals(Object otherObj) { 196 if (otherObj instanceof Receiver) { 197 return mKey.equals( 198 ((Receiver)otherObj).mKey); 199 } 200 return false; 201 } 202 203 @Override 204 public int hashCode() { 205 return mKey.hashCode(); 206 } 207 208 @Override 209 public String toString() { 210 if (mListener != null) { 211 return "Receiver{" 212 + Integer.toHexString(System.identityHashCode(this)) 213 + " Listener " + mKey + "}"; 214 } else { 215 return "Receiver{" 216 + Integer.toHexString(System.identityHashCode(this)) 217 + " Intent " + mKey + "}"; 218 } 219 } 220 221 public boolean isListener() { 222 return mListener != null; 223 } 224 225 public boolean isPendingIntent() { 226 return mPendingIntent != null; 227 } 228 229 public ILocationListener getListener() { 230 if (mListener != null) { 231 return mListener; 232 } 233 throw new IllegalStateException("Request for non-existent listener"); 234 } 235 236 public PendingIntent getPendingIntent() { 237 if (mPendingIntent != null) { 238 return mPendingIntent; 239 } 240 throw new IllegalStateException("Request for non-existent intent"); 241 } 242 243 public boolean callStatusChangedLocked(String provider, int status, Bundle extras) { 244 if (mListener != null) { 245 try { 246 synchronized (this) { 247 // synchronize to ensure incrementPendingBroadcastsLocked() 248 // is called before decrementPendingBroadcasts() 249 mListener.onStatusChanged(provider, status, extras); 250 if (mListener != mProximityListener) { 251 // call this after broadcasting so we do not increment 252 // if we throw an exeption. 253 incrementPendingBroadcastsLocked(); 254 } 255 } 256 } catch (RemoteException e) { 257 return false; 258 } 259 } else { 260 Intent statusChanged = new Intent(); 261 statusChanged.putExtras(extras); 262 statusChanged.putExtra(LocationManager.KEY_STATUS_CHANGED, status); 263 try { 264 synchronized (this) { 265 // synchronize to ensure incrementPendingBroadcastsLocked() 266 // is called before decrementPendingBroadcasts() 267 mPendingIntent.send(mContext, 0, statusChanged, this, mLocationHandler); 268 // call this after broadcasting so we do not increment 269 // if we throw an exeption. 270 incrementPendingBroadcastsLocked(); 271 } 272 } catch (PendingIntent.CanceledException e) { 273 return false; 274 } 275 } 276 return true; 277 } 278 279 public boolean callLocationChangedLocked(Location location) { 280 if (mListener != null) { 281 try { 282 synchronized (this) { 283 // synchronize to ensure incrementPendingBroadcastsLocked() 284 // is called before decrementPendingBroadcasts() 285 mListener.onLocationChanged(location); 286 if (mListener != mProximityListener) { 287 // call this after broadcasting so we do not increment 288 // if we throw an exeption. 289 incrementPendingBroadcastsLocked(); 290 } 291 } 292 } catch (RemoteException e) { 293 return false; 294 } 295 } else { 296 Intent locationChanged = new Intent(); 297 locationChanged.putExtra(LocationManager.KEY_LOCATION_CHANGED, location); 298 try { 299 synchronized (this) { 300 // synchronize to ensure incrementPendingBroadcastsLocked() 301 // is called before decrementPendingBroadcasts() 302 mPendingIntent.send(mContext, 0, locationChanged, this, mLocationHandler); 303 // call this after broadcasting so we do not increment 304 // if we throw an exeption. 305 incrementPendingBroadcastsLocked(); 306 } 307 } catch (PendingIntent.CanceledException e) { 308 return false; 309 } 310 } 311 return true; 312 } 313 314 public boolean callProviderEnabledLocked(String provider, boolean enabled) { 315 if (mListener != null) { 316 try { 317 synchronized (this) { 318 // synchronize to ensure incrementPendingBroadcastsLocked() 319 // is called before decrementPendingBroadcasts() 320 if (enabled) { 321 mListener.onProviderEnabled(provider); 322 } else { 323 mListener.onProviderDisabled(provider); 324 } 325 if (mListener != mProximityListener) { 326 // call this after broadcasting so we do not increment 327 // if we throw an exeption. 328 incrementPendingBroadcastsLocked(); 329 } 330 } 331 } catch (RemoteException e) { 332 return false; 333 } 334 } else { 335 Intent providerIntent = new Intent(); 336 providerIntent.putExtra(LocationManager.KEY_PROVIDER_ENABLED, enabled); 337 try { 338 synchronized (this) { 339 // synchronize to ensure incrementPendingBroadcastsLocked() 340 // is called before decrementPendingBroadcasts() 341 mPendingIntent.send(mContext, 0, providerIntent, this, mLocationHandler); 342 // call this after broadcasting so we do not increment 343 // if we throw an exeption. 344 incrementPendingBroadcastsLocked(); 345 } 346 } catch (PendingIntent.CanceledException e) { 347 return false; 348 } 349 } 350 return true; 351 } 352 353 public void binderDied() { 354 if (LOCAL_LOGV) { 355 Log.v(TAG, "Location listener died"); 356 } 357 synchronized (mLock) { 358 removeUpdatesLocked(this); 359 } 360 synchronized (this) { 361 if (mPendingBroadcasts > 0) { 362 LocationManagerService.this.decrementPendingBroadcasts(); 363 mPendingBroadcasts = 0; 364 } 365 } 366 } 367 368 public void onSendFinished(PendingIntent pendingIntent, Intent intent, 369 int resultCode, String resultData, Bundle resultExtras) { 370 synchronized (this) { 371 decrementPendingBroadcastsLocked(); 372 } 373 } 374 375 // this must be called while synchronized by caller in a synchronized block 376 // containing the sending of the broadcaset 377 private void incrementPendingBroadcastsLocked() { 378 if (mPendingBroadcasts++ == 0) { 379 LocationManagerService.this.incrementPendingBroadcasts(); 380 } 381 } 382 383 private void decrementPendingBroadcastsLocked() { 384 if (--mPendingBroadcasts == 0) { 385 LocationManagerService.this.decrementPendingBroadcasts(); 386 } 387 } 388 } 389 390 public void locationCallbackFinished(ILocationListener listener) { 391 //Do not use getReceiver here as that will add the ILocationListener to 392 //the receiver list if it is not found. If it is not found then the 393 //LocationListener was removed when it had a pending broadcast and should 394 //not be added back. 395 IBinder binder = listener.asBinder(); 396 Receiver receiver = mReceivers.get(binder); 397 if (receiver != null) { 398 synchronized (receiver) { 399 // so wakelock calls will succeed 400 long identity = Binder.clearCallingIdentity(); 401 receiver.decrementPendingBroadcastsLocked(); 402 Binder.restoreCallingIdentity(identity); 403 } 404 } 405 } 406 407 private final class SettingsObserver implements Observer { 408 public void update(Observable o, Object arg) { 409 synchronized (mLock) { 410 updateProvidersLocked(); 411 } 412 } 413 } 414 415 private void addProvider(LocationProviderInterface provider) { 416 mProviders.add(provider); 417 mProvidersByName.put(provider.getName(), provider); 418 } 419 420 private void removeProvider(LocationProviderInterface provider) { 421 mProviders.remove(provider); 422 mProvidersByName.remove(provider.getName()); 423 } 424 425 private void loadProviders() { 426 synchronized (mLock) { 427 if (sProvidersLoaded) { 428 return; 429 } 430 431 // Load providers 432 loadProvidersLocked(); 433 sProvidersLoaded = true; 434 } 435 } 436 437 private void loadProvidersLocked() { 438 try { 439 _loadProvidersLocked(); 440 } catch (Exception e) { 441 Log.e(TAG, "Exception loading providers:", e); 442 } 443 } 444 445 private void _loadProvidersLocked() { 446 // Attempt to load "real" providers first 447 if (GpsLocationProvider.isSupported()) { 448 // Create a gps location provider 449 GpsLocationProvider gpsProvider = new GpsLocationProvider(mContext, this); 450 mGpsStatusProvider = gpsProvider.getGpsStatusProvider(); 451 mNetInitiatedListener = gpsProvider.getNetInitiatedListener(); 452 addProvider(gpsProvider); 453 mGpsLocationProvider = gpsProvider; 454 } 455 456 // create a passive location provider, which is always enabled 457 PassiveProvider passiveProvider = new PassiveProvider(this); 458 addProvider(passiveProvider); 459 mEnabledProviders.add(passiveProvider.getName()); 460 461 // initialize external network location and geocoder services 462 Resources resources = mContext.getResources(); 463 String serviceName = resources.getString( 464 com.android.internal.R.string.config_networkLocationProvider); 465 if (serviceName != null) { 466 mNetworkLocationProvider = 467 new LocationProviderProxy(mContext, LocationManager.NETWORK_PROVIDER, 468 serviceName, mLocationHandler); 469 addProvider(mNetworkLocationProvider); 470 } 471 472 serviceName = resources.getString(com.android.internal.R.string.config_geocodeProvider); 473 if (serviceName != null) { 474 mGeocodeProvider = new GeocoderProxy(mContext, serviceName); 475 } 476 477 updateProvidersLocked(); 478 } 479 480 /** 481 * @param context the context that the LocationManagerService runs in 482 */ 483 public LocationManagerService(Context context) { 484 super(); 485 mContext = context; 486 487 Thread thread = new Thread(null, this, "LocationManagerService"); 488 thread.start(); 489 490 if (LOCAL_LOGV) { 491 Log.v(TAG, "Constructed LocationManager Service"); 492 } 493 } 494 495 private void initialize() { 496 // Create a wake lock, needs to be done before calling loadProviders() below 497 PowerManager powerManager = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE); 498 mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKELOCK_KEY); 499 500 // Load providers 501 loadProviders(); 502 503 // Register for Network (Wifi or Mobile) updates 504 IntentFilter intentFilter = new IntentFilter(); 505 intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION); 506 // Register for Package Manager updates 507 intentFilter.addAction(Intent.ACTION_PACKAGE_REMOVED); 508 intentFilter.addAction(Intent.ACTION_PACKAGE_RESTARTED); 509 mContext.registerReceiver(mBroadcastReceiver, intentFilter); 510 IntentFilter sdFilter = new IntentFilter(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE); 511 mContext.registerReceiver(mBroadcastReceiver, sdFilter); 512 513 // listen for settings changes 514 ContentResolver resolver = mContext.getContentResolver(); 515 Cursor settingsCursor = resolver.query(Settings.Secure.CONTENT_URI, null, 516 "(" + Settings.System.NAME + "=?)", 517 new String[]{Settings.Secure.LOCATION_PROVIDERS_ALLOWED}, 518 null); 519 mSettings = new ContentQueryMap(settingsCursor, Settings.System.NAME, true, mLocationHandler); 520 SettingsObserver settingsObserver = new SettingsObserver(); 521 mSettings.addObserver(settingsObserver); 522 } 523 524 public void run() 525 { 526 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); 527 Looper.prepare(); 528 mLocationHandler = new LocationWorkerHandler(); 529 initialize(); 530 Looper.loop(); 531 } 532 533 private boolean isAllowedBySettingsLocked(String provider) { 534 if (mEnabledProviders.contains(provider)) { 535 return true; 536 } 537 if (mDisabledProviders.contains(provider)) { 538 return false; 539 } 540 // Use system settings 541 ContentResolver resolver = mContext.getContentResolver(); 542 543 return Settings.Secure.isLocationProviderEnabled(resolver, provider); 544 } 545 546 private void checkPermissionsSafe(String provider) { 547 if ((LocationManager.GPS_PROVIDER.equals(provider) 548 || LocationManager.PASSIVE_PROVIDER.equals(provider)) 549 && (mContext.checkCallingOrSelfPermission(ACCESS_FINE_LOCATION) 550 != PackageManager.PERMISSION_GRANTED)) { 551 throw new SecurityException("Requires ACCESS_FINE_LOCATION permission"); 552 } 553 if (LocationManager.NETWORK_PROVIDER.equals(provider) 554 && (mContext.checkCallingOrSelfPermission(ACCESS_FINE_LOCATION) 555 != PackageManager.PERMISSION_GRANTED) 556 && (mContext.checkCallingOrSelfPermission(ACCESS_COARSE_LOCATION) 557 != PackageManager.PERMISSION_GRANTED)) { 558 throw new SecurityException( 559 "Requires ACCESS_FINE_LOCATION or ACCESS_COARSE_LOCATION permission"); 560 } 561 } 562 563 private boolean isAllowedProviderSafe(String provider) { 564 if (LocationManager.GPS_PROVIDER.equals(provider) 565 && (mContext.checkCallingOrSelfPermission(ACCESS_FINE_LOCATION) 566 != PackageManager.PERMISSION_GRANTED)) { 567 return false; 568 } 569 if (LocationManager.NETWORK_PROVIDER.equals(provider) 570 && (mContext.checkCallingOrSelfPermission(ACCESS_FINE_LOCATION) 571 != PackageManager.PERMISSION_GRANTED) 572 && (mContext.checkCallingOrSelfPermission(ACCESS_COARSE_LOCATION) 573 != PackageManager.PERMISSION_GRANTED)) { 574 return false; 575 } 576 577 return true; 578 } 579 580 public List<String> getAllProviders() { 581 try { 582 synchronized (mLock) { 583 return _getAllProvidersLocked(); 584 } 585 } catch (SecurityException se) { 586 throw se; 587 } catch (Exception e) { 588 Log.e(TAG, "getAllProviders got exception:", e); 589 return null; 590 } 591 } 592 593 private List<String> _getAllProvidersLocked() { 594 if (LOCAL_LOGV) { 595 Log.v(TAG, "getAllProviders"); 596 } 597 ArrayList<String> out = new ArrayList<String>(mProviders.size()); 598 for (int i = mProviders.size() - 1; i >= 0; i--) { 599 LocationProviderInterface p = mProviders.get(i); 600 out.add(p.getName()); 601 } 602 return out; 603 } 604 605 public List<String> getProviders(boolean enabledOnly) { 606 try { 607 synchronized (mLock) { 608 return _getProvidersLocked(enabledOnly); 609 } 610 } catch (SecurityException se) { 611 throw se; 612 } catch (Exception e) { 613 Log.e(TAG, "getProviders got exception:", e); 614 return null; 615 } 616 } 617 618 private List<String> _getProvidersLocked(boolean enabledOnly) { 619 if (LOCAL_LOGV) { 620 Log.v(TAG, "getProviders"); 621 } 622 ArrayList<String> out = new ArrayList<String>(mProviders.size()); 623 for (int i = mProviders.size() - 1; i >= 0; i--) { 624 LocationProviderInterface p = mProviders.get(i); 625 String name = p.getName(); 626 if (isAllowedProviderSafe(name)) { 627 if (enabledOnly && !isAllowedBySettingsLocked(name)) { 628 continue; 629 } 630 out.add(name); 631 } 632 } 633 return out; 634 } 635 636 private void updateProvidersLocked() { 637 for (int i = mProviders.size() - 1; i >= 0; i--) { 638 LocationProviderInterface p = mProviders.get(i); 639 boolean isEnabled = p.isEnabled(); 640 String name = p.getName(); 641 boolean shouldBeEnabled = isAllowedBySettingsLocked(name); 642 643 if (isEnabled && !shouldBeEnabled) { 644 updateProviderListenersLocked(name, false); 645 } else if (!isEnabled && shouldBeEnabled) { 646 updateProviderListenersLocked(name, true); 647 } 648 649 } 650 } 651 652 private void updateProviderListenersLocked(String provider, boolean enabled) { 653 int listeners = 0; 654 655 LocationProviderInterface p = mProvidersByName.get(provider); 656 if (p == null) { 657 return; 658 } 659 660 ArrayList<Receiver> deadReceivers = null; 661 662 ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider); 663 if (records != null) { 664 final int N = records.size(); 665 for (int i=0; i<N; i++) { 666 UpdateRecord record = records.get(i); 667 // Sends a notification message to the receiver 668 if (!record.mReceiver.callProviderEnabledLocked(provider, enabled)) { 669 if (deadReceivers == null) { 670 deadReceivers = new ArrayList<Receiver>(); 671 } 672 deadReceivers.add(record.mReceiver); 673 } 674 listeners++; 675 } 676 } 677 678 if (deadReceivers != null) { 679 for (int i=deadReceivers.size()-1; i>=0; i--) { 680 removeUpdatesLocked(deadReceivers.get(i)); 681 } 682 } 683 684 if (enabled) { 685 p.enable(); 686 if (listeners > 0) { 687 p.setMinTime(getMinTimeLocked(provider)); 688 p.enableLocationTracking(true); 689 } 690 } else { 691 p.enableLocationTracking(false); 692 p.disable(); 693 } 694 } 695 696 private long getMinTimeLocked(String provider) { 697 long minTime = Long.MAX_VALUE; 698 ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider); 699 if (records != null) { 700 for (int i=records.size()-1; i>=0; i--) { 701 minTime = Math.min(minTime, records.get(i).mMinTime); 702 } 703 } 704 return minTime; 705 } 706 707 private class UpdateRecord { 708 final String mProvider; 709 final Receiver mReceiver; 710 final long mMinTime; 711 final float mMinDistance; 712 final int mUid; 713 Location mLastFixBroadcast; 714 long mLastStatusBroadcast; 715 716 /** 717 * Note: must be constructed with lock held. 718 */ 719 UpdateRecord(String provider, long minTime, float minDistance, 720 Receiver receiver, int uid) { 721 mProvider = provider; 722 mReceiver = receiver; 723 mMinTime = minTime; 724 mMinDistance = minDistance; 725 mUid = uid; 726 727 ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider); 728 if (records == null) { 729 records = new ArrayList<UpdateRecord>(); 730 mRecordsByProvider.put(provider, records); 731 } 732 if (!records.contains(this)) { 733 records.add(this); 734 } 735 } 736 737 /** 738 * Method to be called when a record will no longer be used. Calling this multiple times 739 * must have the same effect as calling it once. 740 */ 741 void disposeLocked() { 742 ArrayList<UpdateRecord> records = mRecordsByProvider.get(this.mProvider); 743 if (records != null) { 744 records.remove(this); 745 } 746 } 747 748 @Override 749 public String toString() { 750 return "UpdateRecord{" 751 + Integer.toHexString(System.identityHashCode(this)) 752 + " " + mProvider + " " + mReceiver + "}"; 753 } 754 755 void dump(PrintWriter pw, String prefix) { 756 pw.println(prefix + this); 757 pw.println(prefix + "mProvider=" + mProvider + " mReceiver=" + mReceiver); 758 pw.println(prefix + "mMinTime=" + mMinTime + " mMinDistance=" + mMinDistance); 759 pw.println(prefix + "mUid=" + mUid); 760 pw.println(prefix + "mLastFixBroadcast:"); 761 mLastFixBroadcast.dump(new PrintWriterPrinter(pw), prefix + " "); 762 pw.println(prefix + "mLastStatusBroadcast=" + mLastStatusBroadcast); 763 } 764 } 765 766 private Receiver getReceiver(ILocationListener listener) { 767 IBinder binder = listener.asBinder(); 768 Receiver receiver = mReceivers.get(binder); 769 if (receiver == null) { 770 receiver = new Receiver(listener); 771 mReceivers.put(binder, receiver); 772 773 try { 774 if (receiver.isListener()) { 775 receiver.getListener().asBinder().linkToDeath(receiver, 0); 776 } 777 } catch (RemoteException e) { 778 Log.e(TAG, "linkToDeath failed:", e); 779 return null; 780 } 781 } 782 return receiver; 783 } 784 785 private Receiver getReceiver(PendingIntent intent) { 786 Receiver receiver = mReceivers.get(intent); 787 if (receiver == null) { 788 receiver = new Receiver(intent); 789 mReceivers.put(intent, receiver); 790 } 791 return receiver; 792 } 793 794 private boolean providerHasListener(String provider, int uid, Receiver excludedReceiver) { 795 ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider); 796 if (records != null) { 797 for (int i = records.size() - 1; i >= 0; i--) { 798 UpdateRecord record = records.get(i); 799 if (record.mUid == uid && record.mReceiver != excludedReceiver) { 800 return true; 801 } 802 } 803 } 804 for (ProximityAlert alert : mProximityAlerts.values()) { 805 if (alert.mUid == uid) { 806 return true; 807 } 808 } 809 return false; 810 } 811 812 public void requestLocationUpdates(String provider, 813 long minTime, float minDistance, ILocationListener listener) { 814 815 try { 816 synchronized (mLock) { 817 requestLocationUpdatesLocked(provider, minTime, minDistance, getReceiver(listener)); 818 } 819 } catch (SecurityException se) { 820 throw se; 821 } catch (Exception e) { 822 Log.e(TAG, "requestUpdates got exception:", e); 823 } 824 } 825 826 public void requestLocationUpdatesPI(String provider, 827 long minTime, float minDistance, PendingIntent intent) { 828 try { 829 synchronized (mLock) { 830 requestLocationUpdatesLocked(provider, minTime, minDistance, getReceiver(intent)); 831 } 832 } catch (SecurityException se) { 833 throw se; 834 } catch (Exception e) { 835 Log.e(TAG, "requestUpdates got exception:", e); 836 } 837 } 838 839 private void requestLocationUpdatesLocked(String provider, 840 long minTime, float minDistance, Receiver receiver) { 841 if (LOCAL_LOGV) { 842 Log.v(TAG, "_requestLocationUpdates: listener = " + receiver); 843 } 844 845 LocationProviderInterface p = mProvidersByName.get(provider); 846 if (p == null) { 847 throw new IllegalArgumentException("provider=" + provider); 848 } 849 850 checkPermissionsSafe(provider); 851 852 // so wakelock calls will succeed 853 final int callingUid = Binder.getCallingUid(); 854 boolean newUid = !providerHasListener(provider, callingUid, null); 855 long identity = Binder.clearCallingIdentity(); 856 try { 857 UpdateRecord r = new UpdateRecord(provider, minTime, minDistance, receiver, callingUid); 858 UpdateRecord oldRecord = receiver.mUpdateRecords.put(provider, r); 859 if (oldRecord != null) { 860 oldRecord.disposeLocked(); 861 } 862 863 if (newUid) { 864 p.addListener(callingUid); 865 } 866 867 boolean isProviderEnabled = isAllowedBySettingsLocked(provider); 868 if (isProviderEnabled) { 869 long minTimeForProvider = getMinTimeLocked(provider); 870 p.setMinTime(minTimeForProvider); 871 p.enableLocationTracking(true); 872 } else { 873 // Notify the listener that updates are currently disabled 874 receiver.callProviderEnabledLocked(provider, false); 875 } 876 } finally { 877 Binder.restoreCallingIdentity(identity); 878 } 879 } 880 881 public void removeUpdates(ILocationListener listener) { 882 try { 883 synchronized (mLock) { 884 removeUpdatesLocked(getReceiver(listener)); 885 } 886 } catch (SecurityException se) { 887 throw se; 888 } catch (Exception e) { 889 Log.e(TAG, "removeUpdates got exception:", e); 890 } 891 } 892 893 public void removeUpdatesPI(PendingIntent intent) { 894 try { 895 synchronized (mLock) { 896 removeUpdatesLocked(getReceiver(intent)); 897 } 898 } catch (SecurityException se) { 899 throw se; 900 } catch (Exception e) { 901 Log.e(TAG, "removeUpdates got exception:", e); 902 } 903 } 904 905 private void removeUpdatesLocked(Receiver receiver) { 906 if (LOCAL_LOGV) { 907 Log.v(TAG, "_removeUpdates: listener = " + receiver); 908 } 909 910 // so wakelock calls will succeed 911 final int callingUid = Binder.getCallingUid(); 912 long identity = Binder.clearCallingIdentity(); 913 try { 914 if (mReceivers.remove(receiver.mKey) != null && receiver.isListener()) { 915 receiver.getListener().asBinder().unlinkToDeath(receiver, 0); 916 synchronized(receiver) { 917 if(receiver.mPendingBroadcasts > 0) { 918 decrementPendingBroadcasts(); 919 receiver.mPendingBroadcasts = 0; 920 } 921 } 922 } 923 924 // Record which providers were associated with this listener 925 HashSet<String> providers = new HashSet<String>(); 926 HashMap<String,UpdateRecord> oldRecords = receiver.mUpdateRecords; 927 if (oldRecords != null) { 928 // Call dispose() on the obsolete update records. 929 for (UpdateRecord record : oldRecords.values()) { 930 if (!providerHasListener(record.mProvider, callingUid, receiver)) { 931 LocationProviderInterface p = mProvidersByName.get(record.mProvider); 932 if (p != null) { 933 p.removeListener(callingUid); 934 } 935 } 936 record.disposeLocked(); 937 } 938 // Accumulate providers 939 providers.addAll(oldRecords.keySet()); 940 } 941 942 // See if the providers associated with this listener have any 943 // other listeners; if one does, inform it of the new smallest minTime 944 // value; if one does not, disable location tracking for it 945 for (String provider : providers) { 946 // If provider is already disabled, don't need to do anything 947 if (!isAllowedBySettingsLocked(provider)) { 948 continue; 949 } 950 951 boolean hasOtherListener = false; 952 ArrayList<UpdateRecord> recordsForProvider = mRecordsByProvider.get(provider); 953 if (recordsForProvider != null && recordsForProvider.size() > 0) { 954 hasOtherListener = true; 955 } 956 957 LocationProviderInterface p = mProvidersByName.get(provider); 958 if (p != null) { 959 if (hasOtherListener) { 960 p.setMinTime(getMinTimeLocked(provider)); 961 } else { 962 p.enableLocationTracking(false); 963 } 964 } 965 } 966 } finally { 967 Binder.restoreCallingIdentity(identity); 968 } 969 } 970 971 public boolean addGpsStatusListener(IGpsStatusListener listener) { 972 if (mGpsStatusProvider == null) { 973 return false; 974 } 975 if (mContext.checkCallingOrSelfPermission(ACCESS_FINE_LOCATION) != 976 PackageManager.PERMISSION_GRANTED) { 977 throw new SecurityException("Requires ACCESS_FINE_LOCATION permission"); 978 } 979 980 try { 981 mGpsStatusProvider.addGpsStatusListener(listener); 982 } catch (RemoteException e) { 983 Log.e(TAG, "mGpsStatusProvider.addGpsStatusListener failed", e); 984 return false; 985 } 986 return true; 987 } 988 989 public void removeGpsStatusListener(IGpsStatusListener listener) { 990 synchronized (mLock) { 991 try { 992 mGpsStatusProvider.removeGpsStatusListener(listener); 993 } catch (Exception e) { 994 Log.e(TAG, "mGpsStatusProvider.removeGpsStatusListener failed", e); 995 } 996 } 997 } 998 999 public boolean sendExtraCommand(String provider, String command, Bundle extras) { 1000 if (provider == null) { 1001 // throw NullPointerException to remain compatible with previous implementation 1002 throw new NullPointerException(); 1003 } 1004 1005 // first check for permission to the provider 1006 checkPermissionsSafe(provider); 1007 // and check for ACCESS_LOCATION_EXTRA_COMMANDS 1008 if ((mContext.checkCallingOrSelfPermission(ACCESS_LOCATION_EXTRA_COMMANDS) 1009 != PackageManager.PERMISSION_GRANTED)) { 1010 throw new SecurityException("Requires ACCESS_LOCATION_EXTRA_COMMANDS permission"); 1011 } 1012 1013 synchronized (mLock) { 1014 LocationProviderInterface p = mProvidersByName.get(provider); 1015 if (p == null) { 1016 return false; 1017 } 1018 1019 return p.sendExtraCommand(command, extras); 1020 } 1021 } 1022 1023 public boolean sendNiResponse(int notifId, int userResponse) 1024 { 1025 if (Binder.getCallingUid() != Process.myUid()) { 1026 throw new SecurityException( 1027 "calling sendNiResponse from outside of the system is not allowed"); 1028 } 1029 try { 1030 return mNetInitiatedListener.sendNiResponse(notifId, userResponse); 1031 } 1032 catch (RemoteException e) 1033 { 1034 Log.e(TAG, "RemoteException in LocationManagerService.sendNiResponse"); 1035 return false; 1036 } 1037 } 1038 1039 class ProximityAlert { 1040 final int mUid; 1041 final double mLatitude; 1042 final double mLongitude; 1043 final float mRadius; 1044 final long mExpiration; 1045 final PendingIntent mIntent; 1046 final Location mLocation; 1047 1048 public ProximityAlert(int uid, double latitude, double longitude, 1049 float radius, long expiration, PendingIntent intent) { 1050 mUid = uid; 1051 mLatitude = latitude; 1052 mLongitude = longitude; 1053 mRadius = radius; 1054 mExpiration = expiration; 1055 mIntent = intent; 1056 1057 mLocation = new Location(""); 1058 mLocation.setLatitude(latitude); 1059 mLocation.setLongitude(longitude); 1060 } 1061 1062 long getExpiration() { 1063 return mExpiration; 1064 } 1065 1066 PendingIntent getIntent() { 1067 return mIntent; 1068 } 1069 1070 boolean isInProximity(double latitude, double longitude, float accuracy) { 1071 Location loc = new Location(""); 1072 loc.setLatitude(latitude); 1073 loc.setLongitude(longitude); 1074 1075 double radius = loc.distanceTo(mLocation); 1076 return radius <= Math.max(mRadius,accuracy); 1077 } 1078 1079 @Override 1080 public String toString() { 1081 return "ProximityAlert{" 1082 + Integer.toHexString(System.identityHashCode(this)) 1083 + " uid " + mUid + mIntent + "}"; 1084 } 1085 1086 void dump(PrintWriter pw, String prefix) { 1087 pw.println(prefix + this); 1088 pw.println(prefix + "mLatitude=" + mLatitude + " mLongitude=" + mLongitude); 1089 pw.println(prefix + "mRadius=" + mRadius + " mExpiration=" + mExpiration); 1090 pw.println(prefix + "mIntent=" + mIntent); 1091 pw.println(prefix + "mLocation:"); 1092 mLocation.dump(new PrintWriterPrinter(pw), prefix + " "); 1093 } 1094 } 1095 1096 // Listener for receiving locations to trigger proximity alerts 1097 class ProximityListener extends ILocationListener.Stub implements PendingIntent.OnFinished { 1098 1099 boolean isGpsAvailable = false; 1100 1101 // Note: this is called with the lock held. 1102 public void onLocationChanged(Location loc) { 1103 1104 // If Gps is available, then ignore updates from NetworkLocationProvider 1105 if (loc.getProvider().equals(LocationManager.GPS_PROVIDER)) { 1106 isGpsAvailable = true; 1107 } 1108 if (isGpsAvailable && loc.getProvider().equals(LocationManager.NETWORK_PROVIDER)) { 1109 return; 1110 } 1111 1112 // Process proximity alerts 1113 long now = System.currentTimeMillis(); 1114 double latitude = loc.getLatitude(); 1115 double longitude = loc.getLongitude(); 1116 float accuracy = loc.getAccuracy(); 1117 ArrayList<PendingIntent> intentsToRemove = null; 1118 1119 for (ProximityAlert alert : mProximityAlerts.values()) { 1120 PendingIntent intent = alert.getIntent(); 1121 long expiration = alert.getExpiration(); 1122 1123 if ((expiration == -1) || (now <= expiration)) { 1124 boolean entered = mProximitiesEntered.contains(alert); 1125 boolean inProximity = 1126 alert.isInProximity(latitude, longitude, accuracy); 1127 if (!entered && inProximity) { 1128 if (LOCAL_LOGV) { 1129 Log.v(TAG, "Entered alert"); 1130 } 1131 mProximitiesEntered.add(alert); 1132 Intent enteredIntent = new Intent(); 1133 enteredIntent.putExtra(LocationManager.KEY_PROXIMITY_ENTERING, true); 1134 try { 1135 synchronized (this) { 1136 // synchronize to ensure incrementPendingBroadcasts() 1137 // is called before decrementPendingBroadcasts() 1138 intent.send(mContext, 0, enteredIntent, this, mLocationHandler); 1139 // call this after broadcasting so we do not increment 1140 // if we throw an exeption. 1141 incrementPendingBroadcasts(); 1142 } 1143 } catch (PendingIntent.CanceledException e) { 1144 if (LOCAL_LOGV) { 1145 Log.v(TAG, "Canceled proximity alert: " + alert, e); 1146 } 1147 if (intentsToRemove == null) { 1148 intentsToRemove = new ArrayList<PendingIntent>(); 1149 } 1150 intentsToRemove.add(intent); 1151 } 1152 } else if (entered && !inProximity) { 1153 if (LOCAL_LOGV) { 1154 Log.v(TAG, "Exited alert"); 1155 } 1156 mProximitiesEntered.remove(alert); 1157 Intent exitedIntent = new Intent(); 1158 exitedIntent.putExtra(LocationManager.KEY_PROXIMITY_ENTERING, false); 1159 try { 1160 synchronized (this) { 1161 // synchronize to ensure incrementPendingBroadcasts() 1162 // is called before decrementPendingBroadcasts() 1163 intent.send(mContext, 0, exitedIntent, this, mLocationHandler); 1164 // call this after broadcasting so we do not increment 1165 // if we throw an exeption. 1166 incrementPendingBroadcasts(); 1167 } 1168 } catch (PendingIntent.CanceledException e) { 1169 if (LOCAL_LOGV) { 1170 Log.v(TAG, "Canceled proximity alert: " + alert, e); 1171 } 1172 if (intentsToRemove == null) { 1173 intentsToRemove = new ArrayList<PendingIntent>(); 1174 } 1175 intentsToRemove.add(intent); 1176 } 1177 } 1178 } else { 1179 // Mark alert for expiration 1180 if (LOCAL_LOGV) { 1181 Log.v(TAG, "Expiring proximity alert: " + alert); 1182 } 1183 if (intentsToRemove == null) { 1184 intentsToRemove = new ArrayList<PendingIntent>(); 1185 } 1186 intentsToRemove.add(alert.getIntent()); 1187 } 1188 } 1189 1190 // Remove expired alerts 1191 if (intentsToRemove != null) { 1192 for (PendingIntent i : intentsToRemove) { 1193 ProximityAlert alert = mProximityAlerts.remove(i); 1194 mProximitiesEntered.remove(alert); 1195 } 1196 } 1197 } 1198 1199 // Note: this is called with the lock held. 1200 public void onProviderDisabled(String provider) { 1201 if (provider.equals(LocationManager.GPS_PROVIDER)) { 1202 isGpsAvailable = false; 1203 } 1204 } 1205 1206 // Note: this is called with the lock held. 1207 public void onProviderEnabled(String provider) { 1208 // ignore 1209 } 1210 1211 // Note: this is called with the lock held. 1212 public void onStatusChanged(String provider, int status, Bundle extras) { 1213 if ((provider.equals(LocationManager.GPS_PROVIDER)) && 1214 (status != LocationProvider.AVAILABLE)) { 1215 isGpsAvailable = false; 1216 } 1217 } 1218 1219 public void onSendFinished(PendingIntent pendingIntent, Intent intent, 1220 int resultCode, String resultData, Bundle resultExtras) { 1221 // synchronize to ensure incrementPendingBroadcasts() 1222 // is called before decrementPendingBroadcasts() 1223 synchronized (this) { 1224 decrementPendingBroadcasts(); 1225 } 1226 } 1227 } 1228 1229 public void addProximityAlert(double latitude, double longitude, 1230 float radius, long expiration, PendingIntent intent) { 1231 try { 1232 synchronized (mLock) { 1233 addProximityAlertLocked(latitude, longitude, radius, expiration, intent); 1234 } 1235 } catch (SecurityException se) { 1236 throw se; 1237 } catch (Exception e) { 1238 Log.e(TAG, "addProximityAlert got exception:", e); 1239 } 1240 } 1241 1242 private void addProximityAlertLocked(double latitude, double longitude, 1243 float radius, long expiration, PendingIntent intent) { 1244 if (LOCAL_LOGV) { 1245 Log.v(TAG, "addProximityAlert: latitude = " + latitude + 1246 ", longitude = " + longitude + 1247 ", expiration = " + expiration + 1248 ", intent = " + intent); 1249 } 1250 1251 // Require ability to access all providers for now 1252 if (!isAllowedProviderSafe(LocationManager.GPS_PROVIDER) || 1253 !isAllowedProviderSafe(LocationManager.NETWORK_PROVIDER)) { 1254 throw new SecurityException("Requires ACCESS_FINE_LOCATION permission"); 1255 } 1256 1257 if (expiration != -1) { 1258 expiration += System.currentTimeMillis(); 1259 } 1260 ProximityAlert alert = new ProximityAlert(Binder.getCallingUid(), 1261 latitude, longitude, radius, expiration, intent); 1262 mProximityAlerts.put(intent, alert); 1263 1264 if (mProximityReceiver == null) { 1265 mProximityListener = new ProximityListener(); 1266 mProximityReceiver = new Receiver(mProximityListener); 1267 1268 for (int i = mProviders.size() - 1; i >= 0; i--) { 1269 LocationProviderInterface provider = mProviders.get(i); 1270 requestLocationUpdatesLocked(provider.getName(), 1000L, 1.0f, mProximityReceiver); 1271 } 1272 } 1273 } 1274 1275 public void removeProximityAlert(PendingIntent intent) { 1276 try { 1277 synchronized (mLock) { 1278 removeProximityAlertLocked(intent); 1279 } 1280 } catch (SecurityException se) { 1281 throw se; 1282 } catch (Exception e) { 1283 Log.e(TAG, "removeProximityAlert got exception:", e); 1284 } 1285 } 1286 1287 private void removeProximityAlertLocked(PendingIntent intent) { 1288 if (LOCAL_LOGV) { 1289 Log.v(TAG, "removeProximityAlert: intent = " + intent); 1290 } 1291 1292 mProximityAlerts.remove(intent); 1293 if (mProximityAlerts.size() == 0) { 1294 removeUpdatesLocked(mProximityReceiver); 1295 mProximityReceiver = null; 1296 mProximityListener = null; 1297 } 1298 } 1299 1300 /** 1301 * @return null if the provider does not exist 1302 * @throws SecurityException if the provider is not allowed to be 1303 * accessed by the caller 1304 */ 1305 public Bundle getProviderInfo(String provider) { 1306 try { 1307 synchronized (mLock) { 1308 return _getProviderInfoLocked(provider); 1309 } 1310 } catch (SecurityException se) { 1311 throw se; 1312 } catch (Exception e) { 1313 Log.e(TAG, "_getProviderInfo got exception:", e); 1314 return null; 1315 } 1316 } 1317 1318 private Bundle _getProviderInfoLocked(String provider) { 1319 LocationProviderInterface p = mProvidersByName.get(provider); 1320 if (p == null || !p.isEnabled()) { 1321 return null; 1322 } 1323 1324 checkPermissionsSafe(provider); 1325 1326 Bundle b = new Bundle(); 1327 b.putBoolean("network", p.requiresNetwork()); 1328 b.putBoolean("satellite", p.requiresSatellite()); 1329 b.putBoolean("cell", p.requiresCell()); 1330 b.putBoolean("cost", p.hasMonetaryCost()); 1331 b.putBoolean("altitude", p.supportsAltitude()); 1332 b.putBoolean("speed", p.supportsSpeed()); 1333 b.putBoolean("bearing", p.supportsBearing()); 1334 b.putInt("power", p.getPowerRequirement()); 1335 b.putInt("accuracy", p.getAccuracy()); 1336 1337 return b; 1338 } 1339 1340 public boolean isProviderEnabled(String provider) { 1341 try { 1342 synchronized (mLock) { 1343 return _isProviderEnabledLocked(provider); 1344 } 1345 } catch (SecurityException se) { 1346 throw se; 1347 } catch (Exception e) { 1348 Log.e(TAG, "isProviderEnabled got exception:", e); 1349 return false; 1350 } 1351 } 1352 1353 public void reportLocation(Location location, boolean passive) { 1354 if (mContext.checkCallingOrSelfPermission(INSTALL_LOCATION_PROVIDER) 1355 != PackageManager.PERMISSION_GRANTED) { 1356 throw new SecurityException("Requires INSTALL_LOCATION_PROVIDER permission"); 1357 } 1358 1359 mLocationHandler.removeMessages(MESSAGE_LOCATION_CHANGED, location); 1360 Message m = Message.obtain(mLocationHandler, MESSAGE_LOCATION_CHANGED, location); 1361 m.arg1 = (passive ? 1 : 0); 1362 mLocationHandler.sendMessageAtFrontOfQueue(m); 1363 } 1364 1365 private boolean _isProviderEnabledLocked(String provider) { 1366 checkPermissionsSafe(provider); 1367 1368 LocationProviderInterface p = mProvidersByName.get(provider); 1369 if (p == null) { 1370 throw new IllegalArgumentException("provider=" + provider); 1371 } 1372 return isAllowedBySettingsLocked(provider); 1373 } 1374 1375 public Location getLastKnownLocation(String provider) { 1376 try { 1377 synchronized (mLock) { 1378 return _getLastKnownLocationLocked(provider); 1379 } 1380 } catch (SecurityException se) { 1381 throw se; 1382 } catch (Exception e) { 1383 Log.e(TAG, "getLastKnownLocation got exception:", e); 1384 return null; 1385 } 1386 } 1387 1388 private Location _getLastKnownLocationLocked(String provider) { 1389 checkPermissionsSafe(provider); 1390 1391 LocationProviderInterface p = mProvidersByName.get(provider); 1392 if (p == null) { 1393 throw new IllegalArgumentException("provider=" + provider); 1394 } 1395 1396 if (!isAllowedBySettingsLocked(provider)) { 1397 return null; 1398 } 1399 1400 return mLastKnownLocation.get(provider); 1401 } 1402 1403 private static boolean shouldBroadcastSafe(Location loc, Location lastLoc, UpdateRecord record) { 1404 // Always broadcast the first update 1405 if (lastLoc == null) { 1406 return true; 1407 } 1408 1409 // Don't broadcast same location again regardless of condition 1410 // TODO - we should probably still rebroadcast if user explicitly sets a minTime > 0 1411 if (loc.getTime() == lastLoc.getTime()) { 1412 return false; 1413 } 1414 1415 // Check whether sufficient distance has been traveled 1416 double minDistance = record.mMinDistance; 1417 if (minDistance > 0.0) { 1418 if (loc.distanceTo(lastLoc) <= minDistance) { 1419 return false; 1420 } 1421 } 1422 1423 return true; 1424 } 1425 1426 private void handleLocationChangedLocked(Location location, boolean passive) { 1427 String provider = (passive ? LocationManager.PASSIVE_PROVIDER : location.getProvider()); 1428 ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider); 1429 if (records == null || records.size() == 0) { 1430 return; 1431 } 1432 1433 LocationProviderInterface p = mProvidersByName.get(provider); 1434 if (p == null) { 1435 return; 1436 } 1437 1438 // Update last known location for provider 1439 Location lastLocation = mLastKnownLocation.get(provider); 1440 if (lastLocation == null) { 1441 mLastKnownLocation.put(provider, new Location(location)); 1442 } else { 1443 lastLocation.set(location); 1444 } 1445 1446 // Fetch latest status update time 1447 long newStatusUpdateTime = p.getStatusUpdateTime(); 1448 1449 // Get latest status 1450 Bundle extras = new Bundle(); 1451 int status = p.getStatus(extras); 1452 1453 ArrayList<Receiver> deadReceivers = null; 1454 1455 // Broadcast location or status to all listeners 1456 final int N = records.size(); 1457 for (int i=0; i<N; i++) { 1458 UpdateRecord r = records.get(i); 1459 Receiver receiver = r.mReceiver; 1460 1461 Location lastLoc = r.mLastFixBroadcast; 1462 if ((lastLoc == null) || shouldBroadcastSafe(location, lastLoc, r)) { 1463 if (lastLoc == null) { 1464 lastLoc = new Location(location); 1465 r.mLastFixBroadcast = lastLoc; 1466 } else { 1467 lastLoc.set(location); 1468 } 1469 if (!receiver.callLocationChangedLocked(location)) { 1470 Log.w(TAG, "RemoteException calling onLocationChanged on " + receiver); 1471 if (deadReceivers == null) { 1472 deadReceivers = new ArrayList<Receiver>(); 1473 } 1474 deadReceivers.add(receiver); 1475 } 1476 } 1477 1478 long prevStatusUpdateTime = r.mLastStatusBroadcast; 1479 if ((newStatusUpdateTime > prevStatusUpdateTime) && 1480 (prevStatusUpdateTime != 0 || status != LocationProvider.AVAILABLE)) { 1481 1482 r.mLastStatusBroadcast = newStatusUpdateTime; 1483 if (!receiver.callStatusChangedLocked(provider, status, extras)) { 1484 Log.w(TAG, "RemoteException calling onStatusChanged on " + receiver); 1485 if (deadReceivers == null) { 1486 deadReceivers = new ArrayList<Receiver>(); 1487 } 1488 if (!deadReceivers.contains(receiver)) { 1489 deadReceivers.add(receiver); 1490 } 1491 } 1492 } 1493 } 1494 1495 if (deadReceivers != null) { 1496 for (int i=deadReceivers.size()-1; i>=0; i--) { 1497 removeUpdatesLocked(deadReceivers.get(i)); 1498 } 1499 } 1500 } 1501 1502 private class LocationWorkerHandler extends Handler { 1503 1504 @Override 1505 public void handleMessage(Message msg) { 1506 try { 1507 if (msg.what == MESSAGE_LOCATION_CHANGED) { 1508 // log("LocationWorkerHandler: MESSAGE_LOCATION_CHANGED!"); 1509 1510 synchronized (mLock) { 1511 Location location = (Location) msg.obj; 1512 String provider = location.getProvider(); 1513 boolean passive = (msg.arg1 == 1); 1514 1515 if (!passive) { 1516 // notify other providers of the new location 1517 for (int i = mProviders.size() - 1; i >= 0; i--) { 1518 LocationProviderInterface p = mProviders.get(i); 1519 if (!provider.equals(p.getName())) { 1520 p.updateLocation(location); 1521 } 1522 } 1523 } 1524 1525 if (isAllowedBySettingsLocked(provider)) { 1526 handleLocationChangedLocked(location, passive); 1527 } 1528 } 1529 } 1530 } catch (Exception e) { 1531 // Log, don't crash! 1532 Log.e(TAG, "Exception in LocationWorkerHandler.handleMessage:", e); 1533 } 1534 } 1535 } 1536 1537 private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { 1538 @Override 1539 public void onReceive(Context context, Intent intent) { 1540 String action = intent.getAction(); 1541 1542 if (action.equals(Intent.ACTION_PACKAGE_REMOVED) 1543 || action.equals(Intent.ACTION_PACKAGE_RESTARTED) 1544 || action.equals(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE)) { 1545 synchronized (mLock) { 1546 int uidList[] = null; 1547 if (action.equals(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE)) { 1548 uidList = intent.getIntArrayExtra(Intent.EXTRA_CHANGED_UID_LIST); 1549 } else { 1550 uidList = new int[]{intent.getIntExtra(Intent.EXTRA_UID, -1)}; 1551 } 1552 if (uidList == null || uidList.length == 0) { 1553 return; 1554 } 1555 for (int uid : uidList) { 1556 if (uid >= 0) { 1557 ArrayList<Receiver> removedRecs = null; 1558 for (ArrayList<UpdateRecord> i : mRecordsByProvider.values()) { 1559 for (int j=i.size()-1; j>=0; j--) { 1560 UpdateRecord ur = i.get(j); 1561 if (ur.mReceiver.isPendingIntent() && ur.mUid == uid) { 1562 if (removedRecs == null) { 1563 removedRecs = new ArrayList<Receiver>(); 1564 } 1565 if (!removedRecs.contains(ur.mReceiver)) { 1566 removedRecs.add(ur.mReceiver); 1567 } 1568 } 1569 } 1570 } 1571 ArrayList<ProximityAlert> removedAlerts = null; 1572 for (ProximityAlert i : mProximityAlerts.values()) { 1573 if (i.mUid == uid) { 1574 if (removedAlerts == null) { 1575 removedAlerts = new ArrayList<ProximityAlert>(); 1576 } 1577 if (!removedAlerts.contains(i)) { 1578 removedAlerts.add(i); 1579 } 1580 } 1581 } 1582 if (removedRecs != null) { 1583 for (int i=removedRecs.size()-1; i>=0; i--) { 1584 removeUpdatesLocked(removedRecs.get(i)); 1585 } 1586 } 1587 if (removedAlerts != null) { 1588 for (int i=removedAlerts.size()-1; i>=0; i--) { 1589 removeProximityAlertLocked(removedAlerts.get(i).mIntent); 1590 } 1591 } 1592 } 1593 } 1594 } 1595 } else if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) { 1596 boolean noConnectivity = 1597 intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, false); 1598 if (!noConnectivity) { 1599 mNetworkState = LocationProvider.AVAILABLE; 1600 } else { 1601 mNetworkState = LocationProvider.TEMPORARILY_UNAVAILABLE; 1602 } 1603 NetworkInfo info = 1604 (NetworkInfo)intent.getExtra(ConnectivityManager.EXTRA_NETWORK_INFO); 1605 1606 // Notify location providers of current network state 1607 synchronized (mLock) { 1608 for (int i = mProviders.size() - 1; i >= 0; i--) { 1609 LocationProviderInterface provider = mProviders.get(i); 1610 if (provider.isEnabled() && provider.requiresNetwork()) { 1611 provider.updateNetworkState(mNetworkState, info); 1612 } 1613 } 1614 } 1615 } 1616 } 1617 }; 1618 1619 // Wake locks 1620 1621 private void incrementPendingBroadcasts() { 1622 synchronized (mWakeLock) { 1623 if (mPendingBroadcasts++ == 0) { 1624 try { 1625 mWakeLock.acquire(); 1626 log("Acquired wakelock"); 1627 } catch (Exception e) { 1628 // This is to catch a runtime exception thrown when we try to release an 1629 // already released lock. 1630 Log.e(TAG, "exception in acquireWakeLock()", e); 1631 } 1632 } 1633 } 1634 } 1635 1636 private void decrementPendingBroadcasts() { 1637 synchronized (mWakeLock) { 1638 if (--mPendingBroadcasts == 0) { 1639 try { 1640 // Release wake lock 1641 if (mWakeLock.isHeld()) { 1642 mWakeLock.release(); 1643 log("Released wakelock"); 1644 } else { 1645 log("Can't release wakelock again!"); 1646 } 1647 } catch (Exception e) { 1648 // This is to catch a runtime exception thrown when we try to release an 1649 // already released lock. 1650 Log.e(TAG, "exception in releaseWakeLock()", e); 1651 } 1652 } 1653 } 1654 } 1655 1656 // Geocoder 1657 1658 public String getFromLocation(double latitude, double longitude, int maxResults, 1659 GeocoderParams params, List<Address> addrs) { 1660 if (mGeocodeProvider != null) { 1661 return mGeocodeProvider.getFromLocation(latitude, longitude, maxResults, 1662 params, addrs); 1663 } 1664 return null; 1665 } 1666 1667 1668 public String getFromLocationName(String locationName, 1669 double lowerLeftLatitude, double lowerLeftLongitude, 1670 double upperRightLatitude, double upperRightLongitude, int maxResults, 1671 GeocoderParams params, List<Address> addrs) { 1672 1673 if (mGeocodeProvider != null) { 1674 return mGeocodeProvider.getFromLocationName(locationName, lowerLeftLatitude, 1675 lowerLeftLongitude, upperRightLatitude, upperRightLongitude, 1676 maxResults, params, addrs); 1677 } 1678 return null; 1679 } 1680 1681 // Mock Providers 1682 1683 private void checkMockPermissionsSafe() { 1684 boolean allowMocks = Settings.Secure.getInt(mContext.getContentResolver(), 1685 Settings.Secure.ALLOW_MOCK_LOCATION, 0) == 1; 1686 if (!allowMocks) { 1687 throw new SecurityException("Requires ACCESS_MOCK_LOCATION secure setting"); 1688 } 1689 1690 if (mContext.checkCallingPermission(ACCESS_MOCK_LOCATION) != 1691 PackageManager.PERMISSION_GRANTED) { 1692 throw new SecurityException("Requires ACCESS_MOCK_LOCATION permission"); 1693 } 1694 } 1695 1696 public void addTestProvider(String name, boolean requiresNetwork, boolean requiresSatellite, 1697 boolean requiresCell, boolean hasMonetaryCost, boolean supportsAltitude, 1698 boolean supportsSpeed, boolean supportsBearing, int powerRequirement, int accuracy) { 1699 checkMockPermissionsSafe(); 1700 1701 if (LocationManager.PASSIVE_PROVIDER.equals(name)) { 1702 throw new IllegalArgumentException("Cannot mock the passive location provider"); 1703 } 1704 1705 long identity = Binder.clearCallingIdentity(); 1706 synchronized (mLock) { 1707 MockProvider provider = new MockProvider(name, this, 1708 requiresNetwork, requiresSatellite, 1709 requiresCell, hasMonetaryCost, supportsAltitude, 1710 supportsSpeed, supportsBearing, powerRequirement, accuracy); 1711 // remove the real provider if we are replacing GPS or network provider 1712 if (LocationManager.GPS_PROVIDER.equals(name) 1713 || LocationManager.NETWORK_PROVIDER.equals(name)) { 1714 LocationProviderInterface p = mProvidersByName.get(name); 1715 if (p != null) { 1716 p.enableLocationTracking(false); 1717 removeProvider(p); 1718 } 1719 } 1720 if (mProvidersByName.get(name) != null) { 1721 throw new IllegalArgumentException("Provider \"" + name + "\" already exists"); 1722 } 1723 addProvider(provider); 1724 mMockProviders.put(name, provider); 1725 mLastKnownLocation.put(name, null); 1726 updateProvidersLocked(); 1727 } 1728 Binder.restoreCallingIdentity(identity); 1729 } 1730 1731 public void removeTestProvider(String provider) { 1732 checkMockPermissionsSafe(); 1733 synchronized (mLock) { 1734 MockProvider mockProvider = mMockProviders.get(provider); 1735 if (mockProvider == null) { 1736 throw new IllegalArgumentException("Provider \"" + provider + "\" unknown"); 1737 } 1738 long identity = Binder.clearCallingIdentity(); 1739 removeProvider(mProvidersByName.get(provider)); 1740 mMockProviders.remove(mockProvider); 1741 // reinstall real provider if we were mocking GPS or network provider 1742 if (LocationManager.GPS_PROVIDER.equals(provider) && 1743 mGpsLocationProvider != null) { 1744 addProvider(mGpsLocationProvider); 1745 } else if (LocationManager.NETWORK_PROVIDER.equals(provider) && 1746 mNetworkLocationProvider != null) { 1747 addProvider(mNetworkLocationProvider); 1748 } 1749 mLastKnownLocation.put(provider, null); 1750 updateProvidersLocked(); 1751 Binder.restoreCallingIdentity(identity); 1752 } 1753 } 1754 1755 public void setTestProviderLocation(String provider, Location loc) { 1756 checkMockPermissionsSafe(); 1757 synchronized (mLock) { 1758 MockProvider mockProvider = mMockProviders.get(provider); 1759 if (mockProvider == null) { 1760 throw new IllegalArgumentException("Provider \"" + provider + "\" unknown"); 1761 } 1762 // clear calling identity so INSTALL_LOCATION_PROVIDER permission is not required 1763 long identity = Binder.clearCallingIdentity(); 1764 mockProvider.setLocation(loc); 1765 Binder.restoreCallingIdentity(identity); 1766 } 1767 } 1768 1769 public void clearTestProviderLocation(String provider) { 1770 checkMockPermissionsSafe(); 1771 synchronized (mLock) { 1772 MockProvider mockProvider = mMockProviders.get(provider); 1773 if (mockProvider == null) { 1774 throw new IllegalArgumentException("Provider \"" + provider + "\" unknown"); 1775 } 1776 mockProvider.clearLocation(); 1777 } 1778 } 1779 1780 public void setTestProviderEnabled(String provider, boolean enabled) { 1781 checkMockPermissionsSafe(); 1782 synchronized (mLock) { 1783 MockProvider mockProvider = mMockProviders.get(provider); 1784 if (mockProvider == null) { 1785 throw new IllegalArgumentException("Provider \"" + provider + "\" unknown"); 1786 } 1787 long identity = Binder.clearCallingIdentity(); 1788 if (enabled) { 1789 mockProvider.enable(); 1790 mEnabledProviders.add(provider); 1791 mDisabledProviders.remove(provider); 1792 } else { 1793 mockProvider.disable(); 1794 mEnabledProviders.remove(provider); 1795 mDisabledProviders.add(provider); 1796 } 1797 updateProvidersLocked(); 1798 Binder.restoreCallingIdentity(identity); 1799 } 1800 } 1801 1802 public void clearTestProviderEnabled(String provider) { 1803 checkMockPermissionsSafe(); 1804 synchronized (mLock) { 1805 MockProvider mockProvider = mMockProviders.get(provider); 1806 if (mockProvider == null) { 1807 throw new IllegalArgumentException("Provider \"" + provider + "\" unknown"); 1808 } 1809 long identity = Binder.clearCallingIdentity(); 1810 mEnabledProviders.remove(provider); 1811 mDisabledProviders.remove(provider); 1812 updateProvidersLocked(); 1813 Binder.restoreCallingIdentity(identity); 1814 } 1815 } 1816 1817 public void setTestProviderStatus(String provider, int status, Bundle extras, long updateTime) { 1818 checkMockPermissionsSafe(); 1819 synchronized (mLock) { 1820 MockProvider mockProvider = mMockProviders.get(provider); 1821 if (mockProvider == null) { 1822 throw new IllegalArgumentException("Provider \"" + provider + "\" unknown"); 1823 } 1824 mockProvider.setStatus(status, extras, updateTime); 1825 } 1826 } 1827 1828 public void clearTestProviderStatus(String provider) { 1829 checkMockPermissionsSafe(); 1830 synchronized (mLock) { 1831 MockProvider mockProvider = mMockProviders.get(provider); 1832 if (mockProvider == null) { 1833 throw new IllegalArgumentException("Provider \"" + provider + "\" unknown"); 1834 } 1835 mockProvider.clearStatus(); 1836 } 1837 } 1838 1839 private void log(String log) { 1840 if (Log.isLoggable(TAG, Log.VERBOSE)) { 1841 Log.d(TAG, log); 1842 } 1843 } 1844 1845 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 1846 if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) 1847 != PackageManager.PERMISSION_GRANTED) { 1848 pw.println("Permission Denial: can't dump LocationManagerService from from pid=" 1849 + Binder.getCallingPid() 1850 + ", uid=" + Binder.getCallingUid()); 1851 return; 1852 } 1853 1854 synchronized (mLock) { 1855 pw.println("Current Location Manager state:"); 1856 pw.println(" sProvidersLoaded=" + sProvidersLoaded); 1857 pw.println(" Listeners:"); 1858 int N = mReceivers.size(); 1859 for (int i=0; i<N; i++) { 1860 pw.println(" " + mReceivers.get(i)); 1861 } 1862 pw.println(" Location Listeners:"); 1863 for (Receiver i : mReceivers.values()) { 1864 pw.println(" " + i + ":"); 1865 for (Map.Entry<String,UpdateRecord> j : i.mUpdateRecords.entrySet()) { 1866 pw.println(" " + j.getKey() + ":"); 1867 j.getValue().dump(pw, " "); 1868 } 1869 } 1870 pw.println(" Records by Provider:"); 1871 for (Map.Entry<String, ArrayList<UpdateRecord>> i 1872 : mRecordsByProvider.entrySet()) { 1873 pw.println(" " + i.getKey() + ":"); 1874 for (UpdateRecord j : i.getValue()) { 1875 pw.println(" " + j + ":"); 1876 j.dump(pw, " "); 1877 } 1878 } 1879 pw.println(" Last Known Locations:"); 1880 for (Map.Entry<String, Location> i 1881 : mLastKnownLocation.entrySet()) { 1882 pw.println(" " + i.getKey() + ":"); 1883 i.getValue().dump(new PrintWriterPrinter(pw), " "); 1884 } 1885 if (mProximityAlerts.size() > 0) { 1886 pw.println(" Proximity Alerts:"); 1887 for (Map.Entry<PendingIntent, ProximityAlert> i 1888 : mProximityAlerts.entrySet()) { 1889 pw.println(" " + i.getKey() + ":"); 1890 i.getValue().dump(pw, " "); 1891 } 1892 } 1893 if (mProximitiesEntered.size() > 0) { 1894 pw.println(" Proximities Entered:"); 1895 for (ProximityAlert i : mProximitiesEntered) { 1896 pw.println(" " + i + ":"); 1897 i.dump(pw, " "); 1898 } 1899 } 1900 pw.println(" mProximityReceiver=" + mProximityReceiver); 1901 pw.println(" mProximityListener=" + mProximityListener); 1902 if (mEnabledProviders.size() > 0) { 1903 pw.println(" Enabled Providers:"); 1904 for (String i : mEnabledProviders) { 1905 pw.println(" " + i); 1906 } 1907 1908 } 1909 if (mDisabledProviders.size() > 0) { 1910 pw.println(" Disabled Providers:"); 1911 for (String i : mDisabledProviders) { 1912 pw.println(" " + i); 1913 } 1914 1915 } 1916 if (mMockProviders.size() > 0) { 1917 pw.println(" Mock Providers:"); 1918 for (Map.Entry<String, MockProvider> i : mMockProviders.entrySet()) { 1919 i.getValue().dump(pw, " "); 1920 } 1921 } 1922 } 1923 } 1924} 1925