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