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