/**

* Copyright (C) 2007 The Android Open Source Project

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package com.android.server;

import java.io.FileDescriptor;

import java.io.PrintWriter;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Observable;

import java.util.Observer;

import java.util.Set;

import android.app.Activity;

import android.app.PendingIntent;

import android.content.BroadcastReceiver;

import android.content.ComponentName;

import android.content.ContentQueryMap;

import android.content.ContentResolver;

import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

import android.content.ServiceConnection;

import android.content.pm.PackageManager;

import android.content.res.Resources;

import android.database.Cursor;

import android.location.Address;

import android.location.GeocoderParams;

import android.location.IGpsStatusListener;

import android.location.IGpsStatusProvider;

import android.location.ILocationListener;

import android.location.ILocationManager;

import android.location.INetInitiatedListener;

import android.location.Location;

import android.location.LocationManager;

import android.location.LocationProvider;

import android.location.LocationProviderInterface;

import android.net.ConnectivityManager;

import android.net.NetworkInfo;

import android.net.Uri;

import android.os.Binder;

import android.os.Bundle;

import android.os.Handler;

import android.os.IBinder;

import android.os.Looper;

import android.os.Message;

import android.os.PowerManager;

import android.os.Process;

import android.os.RemoteException;

import android.provider.Settings;

import android.util.Log;

import android.util.Slog;

import android.util.PrintWriterPrinter;

import com.android.internal.location.GeocoderProxy;

import com.android.internal.location.GpsLocationProvider;

import com.android.internal.location.GpsNetInitiatedHandler;

import com.android.internal.location.LocationProviderProxy;

import com.android.internal.location.MockProvider;

import com.android.internal.location.PassiveProvider;

/***

* The service class that manages LocationProviders and issues location

* updates and alerts.

*

* {@hide}

*/

//该类不公开，为系统提供定位服务

public class LocationManagerService extends ILocationManager.Stub implements Runnable {

private static final String TAG = "LocationManagerService";

private static final boolean LOCAL_LOGV = false;

// The last time a location was written, by provider name.

private HashMap<String,Long> mLastWriteTime = new HashMap<String,Long>();

private static final String ACCESS_FINE_LOCATION =

android.Manifest.permission.ACCESS_FINE_LOCATION;

private static final String ACCESS_COARSE_LOCATION =

android.Manifest.permission.ACCESS_COARSE_LOCATION;

private static final String ACCESS_MOCK_LOCATION =

android.Manifest.permission.ACCESS_MOCK_LOCATION;

private static final String ACCESS_LOCATION_EXTRA_COMMANDS =

android.Manifest.permission.ACCESS_LOCATION_EXTRA_COMMANDS;

private static final String INSTALL_LOCATION_PROVIDER =

android.Manifest.permission.INSTALL_LOCATION_PROVIDER;

// Set of providers that are explicitly enabled

private final Set<String> mEnabledProviders = new HashSet<String>();

// Set of providers that are explicitly disabled

private final Set<String> mDisabledProviders = new HashSet<String>();

// Locations, status values, and extras for mock providers

private final HashMap<String,MockProvider> mMockProviders = new HashMap<String,MockProvider>();

private static boolean sProvidersLoaded = false;

private final Context mContext;

private GeocoderProxy mGeocodeProvider;

private IGpsStatusProvider mGpsStatusProvider;

private INetInitiatedListener mNetInitiatedListener;

private LocationWorkerHandler mLocationHandler;

// Cache the real providers for use in addTestProvider() and removeTestProvider()

LocationProviderInterface mNetworkLocationProvider;

LocationProviderInterface mGpsLocationProvider;

// Handler messages

private static final int MESSAGE_LOCATION_CHANGED = 1;

// wakelock variables

private final static String WAKELOCK_KEY = "LocationManagerService";

private PowerManager.WakeLock mWakeLock = null;

private int mPendingBroadcasts;

/***

* List of all receivers.

*/

private final HashMap<Object, Receiver> mReceivers = new HashMap<Object, Receiver>();

/***

* List of location providers.

*/

private final ArrayList<LocationProviderInterface> mProviders =

new ArrayList<LocationProviderInterface>();

private final HashMap<String, LocationProviderInterface> mProvidersByName

= new HashMap<String, LocationProviderInterface>();

/***

* Object used internally for synchronization

*/

private final Object mLock = new Object();

/***

* Mapping from provider name to all its UpdateRecords

*/

private final HashMap<String,ArrayList<UpdateRecord>> mRecordsByProvider =

new HashMap<String,ArrayList<UpdateRecord>>();

// Proximity listeners

private Receiver mProximityReceiver = null;

private ILocationListener mProximityListener = null;

private HashMap<PendingIntent,ProximityAlert> mProximityAlerts =

new HashMap<PendingIntent,ProximityAlert>();

private HashSet<ProximityAlert> mProximitiesEntered =

new HashSet<ProximityAlert>();

// Last known location for each provider

private HashMap<String,Location> mLastKnownLocation =

new HashMap<String,Location>();

private int mNetworkState = LocationProvider.TEMPORARILY_UNAVAILABLE;

// for Settings change notification

private ContentQueryMap mSettings;

/***

* A wrapper class holding either an ILocationListener or a PendingIntent to receive

* location updates.

*/

private final class Receiver implements IBinder.DeathRecipient, PendingIntent.OnFinished {

final ILocationListener mListener;

final PendingIntent mPendingIntent;

final Object mKey;

final HashMap<String,UpdateRecord> mUpdateRecords = new HashMap<String,UpdateRecord>();

int mPendingBroadcasts;

Receiver(ILocationListener listener) {

mListener = listener;

mPendingIntent = null;

mKey = listener.asBinder();

}

Receiver(PendingIntent intent) {

mPendingIntent = intent;

mListener = null;

mKey = intent;

}

@Override

public boolean equals(Object otherObj) {

if (otherObj instanceof Receiver) {

return mKey.equals(

((Receiver)otherObj).mKey);

}

return false;

}

@Override

public int hashCode() {

return mKey.hashCode();

}

@Override

public String toString() {

if (mListener != null) {

return "Receiver{"

+ Integer.toHexString(System.identityHashCode(this))

+ " Listener " + mKey + "}";

} else {

return "Receiver{"

+ Integer.toHexString(System.identityHashCode(this))

+ " Intent " + mKey + "}";

}

}

public boolean isListener() {

return mListener != null;

}

public boolean isPendingIntent() {

return mPendingIntent != null;

}

public ILocationListener getListener() {

if (mListener != null) {

return mListener;

}

throw new IllegalStateException("Request for non-existent listener");

}

public PendingIntent getPendingIntent() {

if (mPendingIntent != null) {

return mPendingIntent;

}

throw new IllegalStateException("Request for non-existent intent");

}

public boolean callStatusChangedLocked(String provider, int status, Bundle extras) {

if (mListener != null) {

try {

synchronized (this) {

// synchronize to ensure incrementPendingBroadcastsLocked()

// is called before decrementPendingBroadcasts()

mListener.onStatusChanged(provider, status, extras);

if (mListener != mProximityListener) {

// call this after broadcasting so we do not increment

// if we throw an exeption.

incrementPendingBroadcastsLocked();

}

}

} catch (RemoteException e) {

return false;

}

} else {

Intent statusChanged = new Intent();

statusChanged.putExtras(extras);

statusChanged.putExtra(LocationManager.KEY_STATUS_CHANGED, status);

try {

synchronized (this) {

// synchronize to ensure incrementPendingBroadcastsLocked()

// is called before decrementPendingBroadcasts()

mPendingIntent.send(mContext, 0, statusChanged, this, mLocationHandler);

// call this after broadcasting so we do not increment

// if we throw an exeption.

incrementPendingBroadcastsLocked();

}

} catch (PendingIntent.CanceledException e) {

return false;

}

}

return true;

}

public boolean callLocationChangedLocked(Location location) {

if (mListener != null) {

try {

synchronized (this) {

// synchronize to ensure incrementPendingBroadcastsLocked()

// is called before decrementPendingBroadcasts()

mListener.onLocationChanged(location);

if (mListener != mProximityListener) {

// call this after broadcasting so we do not increment

// if we throw an exeption.

incrementPendingBroadcastsLocked();

}

}

} catch (RemoteException e) {

return false;

}

} else {

Intent locationChanged = new Intent();

locationChanged.putExtra(LocationManager.KEY_LOCATION_CHANGED, location);

try {

synchronized (this) {

// synchronize to ensure incrementPendingBroadcastsLocked()

// is called before decrementPendingBroadcasts()

mPendingIntent.send(mContext, 0, locationChanged, this, mLocationHandler);

// call this after broadcasting so we do not increment

// if we throw an exeption.

incrementPendingBroadcastsLocked();

}

} catch (PendingIntent.CanceledException e) {

return false;

}

}

return true;

}

public boolean callProviderEnabledLocked(String provider, boolean enabled) {

if (mListener != null) {

try {

synchronized (this) {

// synchronize to ensure incrementPendingBroadcastsLocked()

// is called before decrementPendingBroadcasts()

if (enabled) {

mListener.onProviderEnabled(provider);

} else {

mListener.onProviderDisabled(provider);

}

if (mListener != mProximityListener) {

// call this after broadcasting so we do not increment

// if we throw an exeption.

incrementPendingBroadcastsLocked();

}

}

} catch (RemoteException e) {

return false;

}

} else {

Intent providerIntent = new Intent();

providerIntent.putExtra(LocationManager.KEY_PROVIDER_ENABLED, enabled);

try {

synchronized (this) {

// synchronize to ensure incrementPendingBroadcastsLocked()

// is called before decrementPendingBroadcasts()

mPendingIntent.send(mContext, 0, providerIntent, this, mLocationHandler);

// call this after broadcasting so we do not increment

// if we throw an exeption.

incrementPendingBroadcastsLocked();

}

} catch (PendingIntent.CanceledException e) {

return false;

}

}

return true;

}

public void binderDied() {

if (LOCAL_LOGV) {

Slog.v(TAG, "Location listener died");

}

synchronized (mLock) {

removeUpdatesLocked(this);

}

synchronized (this) {

if (mPendingBroadcasts > 0) {

LocationManagerService.this.decrementPendingBroadcasts();

mPendingBroadcasts = 0;

}

}

}

public void onSendFinished(PendingIntent pendingIntent, Intent intent,

int resultCode, String resultData, Bundle resultExtras) {

synchronized (this) {

decrementPendingBroadcastsLocked();

}

}

// this must be called while synchronized by caller in a synchronized block

// containing the sending of the broadcaset

private void incrementPendingBroadcastsLocked() {

if (mPendingBroadcasts++ == 0) {

LocationManagerService.this.incrementPendingBroadcasts();

}

}

private void decrementPendingBroadcastsLocked() {

if (--mPendingBroadcasts == 0) {

LocationManagerService.this.decrementPendingBroadcasts();

}

}

}

public void locationCallbackFinished(ILocationListener listener) {

//Do not use getReceiver here as that will add the ILocationListener to

//the receiver list if it is not found. If it is not found then the

//LocationListener was removed when it had a pending broadcast and should

//not be added back.

IBinder binder = listener.asBinder();

Receiver receiver = mReceivers.get(binder);

if (receiver != null) {

synchronized (receiver) {

// so wakelock calls will succeed

long identity = Binder.clearCallingIdentity();

receiver.decrementPendingBroadcastsLocked();

Binder.restoreCallingIdentity(identity);

}

}

}

private final class SettingsObserver implements Observer {

public void update(Observable o, Object arg) {

synchronized (mLock) {

updateProvidersLocked();

}

}

}

private void addProvider(LocationProviderInterface provider) {

mProviders.add(provider);

mProvidersByName.put(provider.getName(), provider);

}

private void removeProvider(LocationProviderInterface provider) {

mProviders.remove(provider);

mProvidersByName.remove(provider.getName());

}

private void loadProviders() {

synchronized (mLock) {

if (sProvidersLoaded) {

return;

}

// Load providers

loadProvidersLocked();

sProvidersLoaded = true;

}

}

private void loadProvidersLocked() {

try {

_loadProvidersLocked();

} catch (Exception e) {

Slog.e(TAG, "Exception loading providers:", e);

}

}

private void _loadProvidersLocked() {

// Attempt to load "real" providers first

if (GpsLocationProvider.isSupported()) {

// Create a gps location provider

GpsLocationProvider gpsProvider = new GpsLocationProvider(mContext, this);

mGpsStatusProvider = gpsProvider.getGpsStatusProvider();

mNetInitiatedListener = gpsProvider.getNetInitiatedListener();

addProvider(gpsProvider);

mGpsLocationProvider = gpsProvider;

}

// create a passive location provider, which is always enabled

PassiveProvider passiveProvider = new PassiveProvider(this);

addProvider(passiveProvider);

mEnabledProviders.add(passiveProvider.getName());

// initialize external network location and geocoder services

Resources resources = mContext.getResources();

String serviceName = resources.getString(

com.android.internal.R.string.config_networkLocationProvider);

if (serviceName != null) {

mNetworkLocationProvider =

new LocationProviderProxy(mContext, LocationManager.NETWORK_PROVIDER,

serviceName, mLocationHandler);

addProvider(mNetworkLocationProvider);

}

serviceName = resources.getString(com.android.internal.R.string.config_geocodeProvider);

if (serviceName != null) {

mGeocodeProvider = new GeocoderProxy(mContext, serviceName);

}

updateProvidersLocked();

}

/***

* @param context the context that the LocationManagerService runs in

*/

public LocationManagerService(Context context) {

super();

mContext = context;

if (LOCAL_LOGV) {

Slog.v(TAG, "Constructed LocationManager Service");

}

}

void systemReady() {

// we defer starting up the service until the system is ready

Thread thread = new Thread(null, this, "LocationManagerService");

thread.start();

}

private void initialize() {

// Create a wake lock, needs to be done before calling loadProviders() below

PowerManager powerManager = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);

mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKELOCK_KEY);

// Load providers

loadProviders();

// Register for Network (Wifi or Mobile) updates

IntentFilter intentFilter = new IntentFilter();

intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);

// Register for Package Manager updates

intentFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);

intentFilter.addAction(Intent.ACTION_PACKAGE_RESTARTED);

intentFilter.addAction(Intent.ACTION_QUERY_PACKAGE_RESTART);

mContext.registerReceiver(mBroadcastReceiver, intentFilter);

IntentFilter sdFilter = new IntentFilter(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);

mContext.registerReceiver(mBroadcastReceiver, sdFilter);

// listen for settings changes

ContentResolver resolver = mContext.getContentResolver();

Cursor settingsCursor = resolver.query(Settings.Secure.CONTENT_URI, null,

"(" + Settings.System.NAME + "=?)",

new String[]{Settings.Secure.LOCATION_PROVIDERS_ALLOWED},

null);

mSettings = new ContentQueryMap(settingsCursor, Settings.System.NAME, true, mLocationHandler);

SettingsObserver settingsObserver = new SettingsObserver();

mSettings.addObserver(settingsObserver);

}

public void run()

{

Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

Looper.prepare();

mLocationHandler = new LocationWorkerHandler();

initialize();

Looper.loop();

}

private boolean isAllowedBySettingsLocked(String provider) {

if (mEnabledProviders.contains(provider)) {

return true;

}

if (mDisabledProviders.contains(provider)) {

return false;

}

// Use system settings

ContentResolver resolver = mContext.getContentResolver();

return Settings.Secure.isLocationProviderEnabled(resolver, provider);

}

//权限检查

private void checkPermissionsSafe(String provider) {

if ((LocationManager.GPS_PROVIDER.equals(provider)

|| LocationManager.PASSIVE_PROVIDER.equals(provider))

&& (mContext.checkCallingOrSelfPermission(ACCESS_FINE_LOCATION)

!= PackageManager.PERMISSION_GRANTED)) {

throw new SecurityException("Requires ACCESS_FINE_LOCATION permission");

}

if (LocationManager.NETWORK_PROVIDER.equals(provider)

&& (mContext.checkCallingOrSelfPermission(ACCESS_FINE_LOCATION)

!= PackageManager.PERMISSION_GRANTED)

&& (mContext.checkCallingOrSelfPermission(ACCESS_COARSE_LOCATION)

!= PackageManager.PERMISSION_GRANTED)) {

throw new SecurityException(

"Requires ACCESS_FINE_LOCATION or ACCESS_COARSE_LOCATION permission");

}

}

private boolean isAllowedProviderSafe(String provider) {

if ((LocationManager.GPS_PROVIDER.equals(provider)

|| LocationManager.PASSIVE_PROVIDER.equals(provider))

&& (mContext.checkCallingOrSelfPermission(ACCESS_FINE_LOCATION)

!= PackageManager.PERMISSION_GRANTED)) {

return false;

}

if (LocationManager.NETWORK_PROVIDER.equals(provider)

&& (mContext.checkCallingOrSelfPermission(ACCESS_FINE_LOCATION)

!= PackageManager.PERMISSION_GRANTED)

&& (mContext.checkCallingOrSelfPermission(ACCESS_COARSE_LOCATION)

!= PackageManager.PERMISSION_GRANTED)) {

return false;

}

return true;

}

public List<String> getAllProviders() {

try {

synchronized (mLock) {

return _getAllProvidersLocked();

}

} catch (SecurityException se) {

throw se;

} catch (Exception e) {

Slog.e(TAG, "getAllProviders got exception:", e);

return null;

}

}

private List<String> _getAllProvidersLocked() {

if (LOCAL_LOGV) {

Slog.v(TAG, "getAllProviders");

}

ArrayList<String> out = new ArrayList<String>(mProviders.size());

for (int i = mProviders.size() - 1; i >= 0; i--) {

LocationProviderInterface p = mProviders.get(i);

out.add(p.getName());

}

return out;

}

public List<String> getProviders(boolean enabledOnly) {

try {

synchronized (mLock) {

return _getProvidersLocked(enabledOnly);

}

} catch (SecurityException se) {

throw se;

} catch (Exception e) {

Slog.e(TAG, "getProviders got exception:", e);

return null;

}

}

private List<String> _getProvidersLocked(boolean enabledOnly) {

if (LOCAL_LOGV) {

Slog.v(TAG, "getProviders");

}

ArrayList<String> out = new ArrayList<String>(mProviders.size());

for (int i = mProviders.size() - 1; i >= 0; i--) {

LocationProviderInterface p = mProviders.get(i);

String name = p.getName();

if (isAllowedProviderSafe(name)) {

if (enabledOnly && !isAllowedBySettingsLocked(name)) {

continue;

}

out.add(name);

}

}

return out;

}

private void updateProvidersLocked() {

for (int i = mProviders.size() - 1; i >= 0; i--) {

LocationProviderInterface p = mProviders.get(i);

boolean isEnabled = p.isEnabled();

String name = p.getName();

boolean shouldBeEnabled = isAllowedBySettingsLocked(name);

if (isEnabled && !shouldBeEnabled) {

updateProviderListenersLocked(name, false);

} else if (!isEnabled && shouldBeEnabled) {

updateProviderListenersLocked(name, true);

}

}

}

private void updateProviderListenersLocked(String provider, boolean enabled) {

int listeners = 0;

LocationProviderInterface p = mProvidersByName.get(provider);

if (p == null) {

return;

}

ArrayList<Receiver> deadReceivers = null;

ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider);

if (records != null) {

final int N = records.size();

for (int i=0; i<N; i++) {

UpdateRecord record = records.get(i);

// Sends a notification message to the receiver

if (!record.mReceiver.callProviderEnabledLocked(provider, enabled)) {

if (deadReceivers == null) {

deadReceivers = new ArrayList<Receiver>();

}

deadReceivers.add(record.mReceiver);

}

listeners++;

}

}

if (deadReceivers != null) {

for (int i=deadReceivers.size()-1; i>=0; i--) {

removeUpdatesLocked(deadReceivers.get(i));

}

}

if (enabled) {

p.enable();

if (listeners > 0) {

p.setMinTime(getMinTimeLocked(provider));

p.enableLocationTracking(true);

}

} else {

p.enableLocationTracking(false);

p.disable();

}

}

private long getMinTimeLocked(String provider) {

long minTime = Long.MAX_VALUE;

ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider);

if (records != null) {

for (int i=records.size()-1; i>=0; i--) {

minTime = Math.min(minTime, records.get(i).mMinTime);

}

}

return minTime;

}

private class UpdateRecord {

final String mProvider;

final Receiver mReceiver;

final long mMinTime;

final float mMinDistance;

final int mUid;

Location mLastFixBroadcast;

long mLastStatusBroadcast;

/***

* Note: must be constructed with lock held.

*/

UpdateRecord(String provider, long minTime, float minDistance,

Receiver receiver, int uid) {

mProvider = provider;

mReceiver = receiver;

mMinTime = minTime;

mMinDistance = minDistance;

mUid = uid;

ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider);

if (records == null) {

records = new ArrayList<UpdateRecord>();

mRecordsByProvider.put(provider, records);

}

if (!records.contains(this)) {

records.add(this);

}

}

/***

* Method to be called when a record will no longer be used. Calling this multiple times

* must have the same effect as calling it once.

*/

void disposeLocked() {

ArrayList<UpdateRecord> records = mRecordsByProvider.get(this.mProvider);

if (records != null) {

records.remove(this);

}

}

@Override

public String toString() {

return "UpdateRecord{"

+ Integer.toHexString(System.identityHashCode(this))

+ " " + mProvider + " " + mReceiver + "}";

}

void dump(PrintWriter pw, String prefix) {

pw.println(prefix + this);

pw.println(prefix + "mProvider=" + mProvider + " mReceiver=" + mReceiver);

pw.println(prefix + "mMinTime=" + mMinTime + " mMinDistance=" + mMinDistance);

pw.println(prefix + "mUid=" + mUid);

pw.println(prefix + "mLastFixBroadcast:");

if (mLastFixBroadcast != null) {

mLastFixBroadcast.dump(new PrintWriterPrinter(pw), prefix + " ");

}

pw.println(prefix + "mLastStatusBroadcast=" + mLastStatusBroadcast);

}

}

private Receiver getReceiver(ILocationListener listener) {

IBinder binder = listener.asBinder();

Receiver receiver = mReceivers.get(binder);

if (receiver == null) {

receiver = new Receiver(listener);

mReceivers.put(binder, receiver);

try {

if (receiver.isListener()) {

receiver.getListener().asBinder().linkToDeath(receiver, 0);

}

} catch (RemoteException e) {

Slog.e(TAG, "linkToDeath failed:", e);

return null;

}

}

return receiver;

}

private Receiver getReceiver(PendingIntent intent) {

Receiver receiver = mReceivers.get(intent);

if (receiver == null) {

receiver = new Receiver(intent);

mReceivers.put(intent, receiver);

}

return receiver;

}

private boolean providerHasListener(String provider, int uid, Receiver excludedReceiver) {

ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider);

if (records != null) {

for (int i = records.size() - 1; i >= 0; i--) {

UpdateRecord record = records.get(i);

if (record.mUid == uid && record.mReceiver != excludedReceiver) {

return true;

}

}

}

for (ProximityAlert alert : mProximityAlerts.values()) {

if (alert.mUid == uid) {

return true;

}

}

return false;

}

public void requestLocationUpdates(String provider,

long minTime, float minDistance, ILocationListener listener) {

try {

synchronized (mLock) {

requestLocationUpdatesLocked(provider, minTime, minDistance, getReceiver(listener));

}

} catch (SecurityException se) {

throw se;

} catch (IllegalArgumentException iae) {

throw iae;

} catch (Exception e) {

Slog.e(TAG, "requestUpdates got exception:", e);

}

}

public void requestLocationUpdatesPI(String provider,

long minTime, float minDistance, PendingIntent intent) {

try {

synchronized (mLock) {

requestLocationUpdatesLocked(provider, minTime, minDistance, getReceiver(intent));

}

} catch (SecurityException se) {

throw se;

} catch (IllegalArgumentException iae) {

throw iae;

} catch (Exception e) {

Slog.e(TAG, "requestUpdates got exception:", e);

}

}

private void requestLocationUpdatesLocked(String provider,

long minTime, float minDistance, Receiver receiver) {

if (LOCAL_LOGV) {

Slog.v(TAG, "_requestLocationUpdates: listener = " + receiver);

}

LocationProviderInterface p = mProvidersByName.get(provider);

if (p == null) {

throw new IllegalArgumentException("provider=" + provider);

}

checkPermissionsSafe(provider);

// so wakelock calls will succeed

final int callingUid = Binder.getCallingUid();

boolean newUid = !providerHasListener(provider, callingUid, null);

long identity = Binder.clearCallingIdentity();

try {

UpdateRecord r = new UpdateRecord(provider, minTime, minDistance, receiver, callingUid);

UpdateRecord oldRecord = receiver.mUpdateRecords.put(provider, r);

if (oldRecord != null) {

oldRecord.disposeLocked();

}

if (newUid) {

p.addListener(callingUid);

}

boolean isProviderEnabled = isAllowedBySettingsLocked(provider);

if (isProviderEnabled) {

long minTimeForProvider = getMinTimeLocked(provider);

p.setMinTime(minTimeForProvider);

p.enableLocationTracking(true);

} else {

// Notify the listener that updates are currently disabled

receiver.callProviderEnabledLocked(provider, false);

}

} finally {

Binder.restoreCallingIdentity(identity);

}

}

public void removeUpdates(ILocationListener listener) {

try {

synchronized (mLock) {

removeUpdatesLocked(getReceiver(listener));

}

} catch (SecurityException se) {

throw se;

} catch (IllegalArgumentException iae) {

throw iae;

} catch (Exception e) {

Slog.e(TAG, "removeUpdates got exception:", e);

}

}

public void removeUpdatesPI(PendingIntent intent) {

try {

synchronized (mLock) {

removeUpdatesLocked(getReceiver(intent));

}

} catch (SecurityException se) {

throw se;

} catch (IllegalArgumentException iae) {

throw iae;

} catch (Exception e) {

Slog.e(TAG, "removeUpdates got exception:", e);

}

}

private void removeUpdatesLocked(Receiver receiver) {

if (LOCAL_LOGV) {

Slog.v(TAG, "_removeUpdates: listener = " + receiver);

}

// so wakelock calls will succeed

final int callingUid = Binder.getCallingUid();

long identity = Binder.clearCallingIdentity();

try {

if (mReceivers.remove(receiver.mKey) != null && receiver.isListener()) {

receiver.getListener().asBinder().unlinkToDeath(receiver, 0);

synchronized(receiver) {

if(receiver.mPendingBroadcasts > 0) {

decrementPendingBroadcasts();

receiver.mPendingBroadcasts = 0;

}

}

}

// Record which providers were associated with this listener

HashSet<String> providers = new HashSet<String>();

HashMap<String,UpdateRecord> oldRecords = receiver.mUpdateRecords;

if (oldRecords != null) {

// Call dispose() on the obsolete update records.

for (UpdateRecord record : oldRecords.values()) {

if (!providerHasListener(record.mProvider, callingUid, receiver)) {

LocationProviderInterface p = mProvidersByName.get(record.mProvider);

if (p != null) {

p.removeListener(callingUid);

}

}

record.disposeLocked();

}

// Accumulate providers

providers.addAll(oldRecords.keySet());

}

// See if the providers associated with this listener have any

// other listeners; if one does, inform it of the new smallest minTime

// value; if one does not, disable location tracking for it

for (String provider : providers) {

// If provider is already disabled, don't need to do anything

if (!isAllowedBySettingsLocked(provider)) {

continue;

}

boolean hasOtherListener = false;

ArrayList<UpdateRecord> recordsForProvider = mRecordsByProvider.get(provider);

if (recordsForProvider != null && recordsForProvider.size() > 0) {

hasOtherListener = true;

}

LocationProviderInterface p = mProvidersByName.get(provider);

if (p != null) {

if (hasOtherListener) {

p.setMinTime(getMinTimeLocked(provider));

} else {

p.enableLocationTracking(false);

}

}

}

} finally {

Binder.restoreCallingIdentity(identity);

}

}

public boolean addGpsStatusListener(IGpsStatusListener listener) {

if (mGpsStatusProvider == null) {

return false;

}

if (mContext.checkCallingOrSelfPermission(ACCESS_FINE_LOCATION) !=

PackageManager.PERMISSION_GRANTED) {

throw new SecurityException("Requires ACCESS_FINE_LOCATION permission");

}

try {

mGpsStatusProvider.addGpsStatusListener(listener);

} catch (RemoteException e) {