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