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