LocationManagerpublic class LocationManager extends Object | This class provides access to the system location services. These
services allow applications to obtain periodic updates of the
device's geographical location, or to fire an application-specified
{@link Intent} when the device enters the proximity of a given
geographical location.
You do not
instantiate this class directly; instead, retrieve it through
{@link android.content.Context#getSystemService
Context.getSystemService(Context.LOCATION_SERVICE)}.
Unless noted, all Location API methods require
the {@link android.Manifest.permission#ACCESS_COARSE_LOCATION} or
{@link android.Manifest.permission#ACCESS_FINE_LOCATION} permissions.
If your application only has the coarse permission then it will not have
access to the GPS or passive location providers. Other providers will still
return location results, but the update rate will be throttled and the exact
location will be obfuscated to a coarse level of accuracy. |
| Fields Summary |
|---|
| private static final String | TAG | | private final android.content.Context | mContext | | private final ILocationManager | mService | | private final GpsMeasurementListenerTransport | mGpsMeasurementListenerTransport | | private final GpsNavigationMessageListenerTransport | mGpsNavigationMessageListenerTransport | | private final HashMap | mGpsStatusListeners | | private final HashMap | mNmeaListeners | | private final GpsStatus | mGpsStatus | | public static final String | NETWORK_PROVIDERName of the network location provider.
This provider determines location based on
availability of cell tower and WiFi access points. Results are retrieved
by means of a network lookup. | | public static final String | GPS_PROVIDERName of the GPS location provider.
This provider determines location using
satellites. Depending on conditions, this provider may take a while to return
a location fix. Requires the permission
{@link android.Manifest.permission#ACCESS_FINE_LOCATION}.
The extras Bundle for the GPS location provider can contain the
following key/value pairs:
- satellites - the number of satellites used to derive the fix
| | public static final String | PASSIVE_PROVIDERA special location provider for receiving locations without actually initiating
a location fix.
This provider can be used to passively receive location updates
when other applications or services request them without actually requesting
the locations yourself. This provider will return locations generated by other
providers. You can query the {@link Location#getProvider()} method to determine
the origin of the location update. Requires the permission
{@link android.Manifest.permission#ACCESS_FINE_LOCATION}, although if the GPS is
not enabled this provider might only return coarse fixes. | | public static final String | FUSED_PROVIDERName of the Fused location provider.
This provider combines inputs for all possible location sources
to provide the best possible Location fix. It is implicitly
used for all API's that involve the {@link LocationRequest}
object. | | public static final String | KEY_PROXIMITY_ENTERINGKey used for the Bundle extra holding a boolean indicating whether
a proximity alert is entering (true) or exiting (false).. | | public static final String | KEY_STATUS_CHANGEDKey used for a Bundle extra holding an Integer status value
when a status change is broadcast using a PendingIntent. | | public static final String | KEY_PROVIDER_ENABLEDKey used for a Bundle extra holding an Boolean status value
when a provider enabled/disabled event is broadcast using a PendingIntent. | | public static final String | KEY_LOCATION_CHANGEDKey used for a Bundle extra holding a Location value
when a location change is broadcast using a PendingIntent. | | public static final String | GPS_ENABLED_CHANGE_ACTIONBroadcast intent action indicating that the GPS has either been
enabled or disabled. An intent extra provides this state as a boolean,
where {@code true} means enabled. | | public static final String | PROVIDERS_CHANGED_ACTIONBroadcast intent action when the configured location providers
change. For use with {@link #isProviderEnabled(String)}. If you're interacting with the
{@link android.provider.Settings.Secure#LOCATION_MODE} API, use {@link #MODE_CHANGED_ACTION}
instead. | | public static final String | MODE_CHANGED_ACTIONBroadcast intent action when {@link android.provider.Settings.Secure#LOCATION_MODE} changes.
For use with the {@link android.provider.Settings.Secure#LOCATION_MODE} API.
If you're interacting with {@link #isProviderEnabled(String)}, use
{@link #PROVIDERS_CHANGED_ACTION} instead.
In the future, there may be mode changes that do not result in
{@link #PROVIDERS_CHANGED_ACTION} broadcasts. | | public static final String | GPS_FIX_CHANGE_ACTIONBroadcast intent action indicating that the GPS has either started or
stopped receiving GPS fixes. An intent extra provides this state as a
boolean, where {@code true} means that the GPS is actively receiving fixes. | | public static final String | EXTRA_GPS_ENABLEDThe lookup key for a boolean that indicates whether GPS is enabled or
disabled. {@code true} means GPS is enabled. Retrieve it with
{@link android.content.Intent#getBooleanExtra(String,boolean)}. | | public static final String | HIGH_POWER_REQUEST_CHANGE_ACTIONBroadcast intent action indicating that a high power location requests
has either started or stopped being active. The current state of
active location requests should be read from AppOpsManager using
{@code OP_MONITOR_HIGH_POWER_LOCATION}. | | private HashMap | mListeners |
| Constructors Summary |
|---|
public LocationManager(android.content.Context context, ILocationManager service)
mService = service;
mContext = context;
mGpsMeasurementListenerTransport = new GpsMeasurementListenerTransport(mContext, mService);
mGpsNavigationMessageListenerTransport =
new GpsNavigationMessageListenerTransport(mContext, mService);
|
| Methods Summary |
|---|
| public void | addGeofence(LocationRequest request, Geofence fence, android.app.PendingIntent intent)Add a geofence with the specified LocationRequest quality of service.
When the device
detects that it has entered or exited the area surrounding the
location, the given PendingIntent will be used to create an Intent
to be fired.
The fired Intent will have a boolean extra added with key
{@link #KEY_PROXIMITY_ENTERING}. If the value is true, the device is
entering the proximity region; if false, it is exiting.
The geofence engine fuses results from all location providers to
provide the best balance between accuracy and power. Applications
can choose the quality of service required using the
{@link LocationRequest} object. If it is null then a default,
low power geo-fencing implementation is used. It is possible to cross
a geo-fence without notification, but the system will do its best
to detect, using {@link LocationRequest} as a hint to trade-off
accuracy and power.
The power required by the geofence engine can depend on many factors,
such as quality and interval requested in {@link LocationRequest},
distance to nearest geofence and current device velocity.
checkPendingIntent(intent);
checkGeofence(fence);
try {
mService.requestGeofence(request, fence, intent, mContext.getPackageName());
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | public boolean | addGpsMeasurementListener(GpsMeasurementsEvent.Listener listener)Adds a GPS Measurement listener.
return mGpsMeasurementListenerTransport.add(listener);
| | public boolean | addGpsNavigationMessageListener(GpsNavigationMessageEvent.Listener listener)Adds a GPS Navigation Message listener.
return mGpsNavigationMessageListenerTransport.add(listener);
| | public boolean | addGpsStatusListener(GpsStatus.Listener listener)Adds a GPS status listener.
boolean result;
if (mGpsStatusListeners.get(listener) != null) {
// listener is already registered
return true;
}
try {
GpsStatusListenerTransport transport = new GpsStatusListenerTransport(listener);
result = mService.addGpsStatusListener(transport, mContext.getPackageName());
if (result) {
mGpsStatusListeners.put(listener, transport);
}
} catch (RemoteException e) {
Log.e(TAG, "RemoteException in registerGpsStatusListener: ", e);
result = false;
}
return result;
| | public boolean | addNmeaListener(GpsStatus.NmeaListener listener)Adds an NMEA listener.
boolean result;
if (mNmeaListeners.get(listener) != null) {
// listener is already registered
return true;
}
try {
GpsStatusListenerTransport transport = new GpsStatusListenerTransport(listener);
result = mService.addGpsStatusListener(transport, mContext.getPackageName());
if (result) {
mNmeaListeners.put(listener, transport);
}
} catch (RemoteException e) {
Log.e(TAG, "RemoteException in registerGpsStatusListener: ", e);
result = false;
}
return result;
| | public void | addProximityAlert(double latitude, double longitude, float radius, long expiration, android.app.PendingIntent intent)Set a proximity alert for the location given by the position
(latitude, longitude) and the given radius.
When the device
detects that it has entered or exited the area surrounding the
location, the given PendingIntent will be used to create an Intent
to be fired.
The fired Intent will have a boolean extra added with key
{@link #KEY_PROXIMITY_ENTERING}. If the value is true, the device is
entering the proximity region; if false, it is exiting.
Due to the approximate nature of position estimation, if the
device passes through the given area briefly, it is possible
that no Intent will be fired. Similarly, an Intent could be
fired if the device passes very close to the given area but
does not actually enter it.
After the number of milliseconds given by the expiration
parameter, the location manager will delete this proximity
alert and no longer monitor it. A value of -1 indicates that
there should be no expiration time.
Internally, this method uses both {@link #NETWORK_PROVIDER}
and {@link #GPS_PROVIDER}.
Before API version 17, this method could be used with
{@link android.Manifest.permission#ACCESS_FINE_LOCATION} or
{@link android.Manifest.permission#ACCESS_COARSE_LOCATION}.
From API version 17 and onwards, this method requires
{@link android.Manifest.permission#ACCESS_FINE_LOCATION} permission.
checkPendingIntent(intent);
if (expiration < 0) expiration = Long.MAX_VALUE;
Geofence fence = Geofence.createCircle(latitude, longitude, radius);
LocationRequest request = new LocationRequest().setExpireIn(expiration);
try {
mService.requestGeofence(request, fence, intent, mContext.getPackageName());
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | public void | addTestProvider(java.lang.String name, boolean requiresNetwork, boolean requiresSatellite, boolean requiresCell, boolean hasMonetaryCost, boolean supportsAltitude, boolean supportsSpeed, boolean supportsBearing, int powerRequirement, int accuracy)Creates a mock location provider and adds it to the set of active providers.
ProviderProperties properties = new ProviderProperties(requiresNetwork,
requiresSatellite, requiresCell, hasMonetaryCost, supportsAltitude, supportsSpeed,
supportsBearing, powerRequirement, accuracy);
if (name.matches(LocationProvider.BAD_CHARS_REGEX)) {
throw new IllegalArgumentException("provider name contains illegal character: " + name);
}
try {
mService.addTestProvider(name, properties);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | private static void | checkCriteria(Criteria criteria)
if (criteria == null) {
throw new IllegalArgumentException("invalid criteria: " + criteria);
}
| | private static void | checkGeofence(Geofence fence)
if (fence == null) {
throw new IllegalArgumentException("invalid geofence: " + fence);
}
| | private static void | checkListener(LocationListener listener)
if (listener == null) {
throw new IllegalArgumentException("invalid listener: " + listener);
}
| | private void | checkPendingIntent(android.app.PendingIntent intent)
if (intent == null) {
throw new IllegalArgumentException("invalid pending intent: " + intent);
}
if (!intent.isTargetedToPackage()) {
IllegalArgumentException e = new IllegalArgumentException(
"pending intent must be targeted to package");
if (mContext.getApplicationInfo().targetSdkVersion > Build.VERSION_CODES.JELLY_BEAN) {
throw e;
} else {
Log.w(TAG, e);
}
}
| | private static void | checkProvider(java.lang.String provider)
if (provider == null) {
throw new IllegalArgumentException("invalid provider: " + provider);
}
| | public void | clearTestProviderEnabled(java.lang.String provider)Removes any mock enabled value associated with the given provider.
try {
mService.clearTestProviderEnabled(provider);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | public void | clearTestProviderLocation(java.lang.String provider)Removes any mock location associated with the given provider.
try {
mService.clearTestProviderLocation(provider);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | public void | clearTestProviderStatus(java.lang.String provider)Removes any mock status values associated with the given provider.
try {
mService.clearTestProviderStatus(provider);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | private LocationProvider | createProvider(java.lang.String name, com.android.internal.location.ProviderProperties properties)
return new LocationProvider(name, properties);
| | public java.util.List | getAllProviders()Returns a list of the names of all known location providers.
All providers are returned, including ones that are not permitted to
be accessed by the calling activity or are currently disabled.
try {
return mService.getAllProviders();
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
return null;
| | public java.lang.String | getBestProvider(Criteria criteria, boolean enabledOnly)Returns the name of the provider that best meets the given criteria. Only providers
that are permitted to be accessed by the calling activity will be
returned. If several providers meet the criteria, the one with the best
accuracy is returned. If no provider meets the criteria,
the criteria are loosened in the following sequence:
- power requirement
- accuracy
- bearing
- speed
- altitude
Note that the requirement on monetary cost is not removed
in this process.
checkCriteria(criteria);
try {
return mService.getBestProvider(criteria, enabledOnly);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
return null;
| | public GpsStatus | getGpsStatus(GpsStatus status)Retrieves information about the current status of the GPS engine.
This should only be called from the {@link GpsStatus.Listener#onGpsStatusChanged}
callback to ensure that the data is copied atomically.
The caller may either pass in a {@link GpsStatus} object to set with the latest
status information, or pass null to create a new {@link GpsStatus} object.
if (status == null) {
status = new GpsStatus();
}
status.setStatus(mGpsStatus);
return status;
| | public Location | getLastKnownLocation(java.lang.String provider)Returns a Location indicating the data from the last known
location fix obtained from the given provider.
This can be done
without starting the provider. Note that this location could
be out-of-date, for example if the device was turned off and
moved to another location.
If the provider is currently disabled, null is returned.
checkProvider(provider);
String packageName = mContext.getPackageName();
LocationRequest request = LocationRequest.createFromDeprecatedProvider(
provider, 0, 0, true);
try {
return mService.getLastLocation(request, packageName);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
return null;
}
| | public Location | getLastLocation()Get the last known location.
This location could be very old so use
{@link Location#getElapsedRealtimeNanos} to calculate its age. It can
also return null if no previous location is available.
Always returns immediately.
String packageName = mContext.getPackageName();
try {
return mService.getLastLocation(null, packageName);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
return null;
}
| | public LocationProvider | getProvider(java.lang.String name)Returns the information associated with the location provider of the
given name, or null if no provider exists by that name.
checkProvider(name);
try {
ProviderProperties properties = mService.getProviderProperties(name);
if (properties == null) {
return null;
}
return createProvider(name, properties);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
return null;
| | public java.util.List | getProviders(boolean enabledOnly)Returns a list of the names of location providers.
try {
return mService.getProviders(null, enabledOnly);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
return null;
| | public java.util.List | getProviders(Criteria criteria, boolean enabledOnly)Returns a list of the names of LocationProviders that satisfy the given
criteria, or null if none do. Only providers that are permitted to be
accessed by the calling activity will be returned.
checkCriteria(criteria);
try {
return mService.getProviders(criteria, enabledOnly);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
return null;
| | public boolean | isProviderEnabled(java.lang.String provider)Returns the current enabled/disabled status of the given provider.
If the user has enabled this provider in the Settings menu, true
is returned otherwise false is returned
Callers should instead use
{@link android.provider.Settings.Secure#LOCATION_MODE}
unless they depend on provider-specific APIs such as
{@link #requestLocationUpdates(String, long, float, LocationListener)}.
Before API version {@link android.os.Build.VERSION_CODES#LOLLIPOP}, this
method would throw {@link SecurityException} if the location permissions
were not sufficient to use the specified provider.
checkProvider(provider);
try {
return mService.isProviderEnabled(provider);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
return false;
}
| | public void | removeAllGeofences(android.app.PendingIntent intent)Remove all geofences registered to the specified pending intent.
checkPendingIntent(intent);
String packageName = mContext.getPackageName();
try {
mService.removeGeofence(null, intent, packageName);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | public void | removeGeofence(Geofence fence, android.app.PendingIntent intent)Remove a single geofence.
This removes only the specified geofence associated with the
specified pending intent. All other geofences remain unchanged.
checkPendingIntent(intent);
checkGeofence(fence);
String packageName = mContext.getPackageName();
try {
mService.removeGeofence(fence, intent, packageName);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | public void | removeGpsMeasurementListener(GpsMeasurementsEvent.Listener listener)Removes a GPS Measurement listener.
mGpsMeasurementListenerTransport.remove(listener);
| | public void | removeGpsNavigationMessageListener(GpsNavigationMessageEvent.Listener listener)Removes a GPS Navigation Message listener.
mGpsNavigationMessageListenerTransport.remove(listener);
| | public void | removeGpsStatusListener(GpsStatus.Listener listener)Removes a GPS status listener.
try {
GpsStatusListenerTransport transport = mGpsStatusListeners.remove(listener);
if (transport != null) {
mService.removeGpsStatusListener(transport);
}
} catch (RemoteException e) {
Log.e(TAG, "RemoteException in unregisterGpsStatusListener: ", e);
}
| | public void | removeNmeaListener(GpsStatus.NmeaListener listener)Removes an NMEA listener.
try {
GpsStatusListenerTransport transport = mNmeaListeners.remove(listener);
if (transport != null) {
mService.removeGpsStatusListener(transport);
}
} catch (RemoteException e) {
Log.e(TAG, "RemoteException in unregisterGpsStatusListener: ", e);
}
| | public void | removeProximityAlert(android.app.PendingIntent intent)Removes the proximity alert with the given PendingIntent.
Before API version 17, this method could be used with
{@link android.Manifest.permission#ACCESS_FINE_LOCATION} or
{@link android.Manifest.permission#ACCESS_COARSE_LOCATION}.
From API version 17 and onwards, this method requires
{@link android.Manifest.permission#ACCESS_FINE_LOCATION} permission.
checkPendingIntent(intent);
String packageName = mContext.getPackageName();
try {
mService.removeGeofence(null, intent, packageName);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | public void | removeTestProvider(java.lang.String provider)Removes the mock location provider with the given name.
try {
mService.removeTestProvider(provider);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | public void | removeUpdates(LocationListener listener)Removes all location updates for the specified LocationListener.
Following this call, updates will no longer
occur for this listener.
checkListener(listener);
String packageName = mContext.getPackageName();
ListenerTransport transport;
synchronized (mListeners) {
transport = mListeners.remove(listener);
}
if (transport == null) return;
try {
mService.removeUpdates(transport, null, packageName);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | public void | removeUpdates(android.app.PendingIntent intent)Removes all location updates for the specified pending intent.
Following this call, updates will no longer for this pending intent.
checkPendingIntent(intent);
String packageName = mContext.getPackageName();
try {
mService.removeUpdates(null, intent, packageName);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | public void | requestLocationUpdates(long minTime, float minDistance, Criteria criteria, LocationListener listener, android.os.Looper looper)Register for location updates using a Criteria, and a callback
on the specified looper thread.
See {@link #requestLocationUpdates(long, float, Criteria, PendingIntent)}
for more detail on how to use this method.
checkCriteria(criteria);
checkListener(listener);
LocationRequest request = LocationRequest.createFromDeprecatedCriteria(
criteria, minTime, minDistance, false);
requestLocationUpdates(request, listener, looper, null);
| | public void | requestLocationUpdates(java.lang.String provider, long minTime, float minDistance, android.app.PendingIntent intent)Register for location updates using the named provider, and a
pending intent.
See {@link #requestLocationUpdates(long, float, Criteria, PendingIntent)}
for more detail on how to use this method.
checkProvider(provider);
checkPendingIntent(intent);
LocationRequest request = LocationRequest.createFromDeprecatedProvider(
provider, minTime, minDistance, false);
requestLocationUpdates(request, null, null, intent);
| | public void | requestLocationUpdates(long minTime, float minDistance, Criteria criteria, android.app.PendingIntent intent)Register for location updates using a Criteria and pending intent.
The requestLocationUpdates() and
requestSingleUpdate() register the current activity to be
updated periodically by the named provider, or by the provider matching
the specified {@link Criteria}, with location and status updates.
It may take a while to receive the first location update. If
an immediate location is required, applications may use the
{@link #getLastKnownLocation(String)} method.
Location updates are received either by {@link LocationListener}
callbacks, or by broadcast intents to a supplied {@link PendingIntent}.
If the caller supplied a pending intent, then location updates
are sent with a key of {@link #KEY_LOCATION_CHANGED} and a
{@link android.location.Location} value.
The location update interval can be controlled using the minTime parameter.
The elapsed time between location updates will never be less than
minTime, although it can be more depending on the Location Provider
implementation and the update interval requested by other applications.
Choosing a sensible value for minTime is important to conserve
battery life. Each location update requires power from
GPS, WIFI, Cell and other radios. Select a minTime value as high as
possible while still providing a reasonable user experience.
If your application is not in the foreground and showing
location to the user then your application should avoid using an active
provider (such as {@link #NETWORK_PROVIDER} or {@link #GPS_PROVIDER}),
but if you insist then select a minTime of 5 * 60 * 1000 (5 minutes)
or greater. If your application is in the foreground and showing
location to the user then it is appropriate to select a faster
update interval.
The minDistance parameter can also be used to control the
frequency of location updates. If it is greater than 0 then the
location provider will only send your application an update when
the location has changed by at least minDistance meters, AND
at least minTime milliseconds have passed. However it is more
difficult for location providers to save power using the minDistance
parameter, so minTime should be the primary tool to conserving battery
life.
If your application wants to passively observe location
updates triggered by other applications, but not consume
any additional power otherwise, then use the {@link #PASSIVE_PROVIDER}
This provider does not actively turn on or modify active location
providers, so you do not need to be as careful about minTime and
minDistance. However if your application performs heavy work
on a location update (such as network activity) then you should
select non-zero values for minTime and/or minDistance to rate-limit
your update frequency in the case another application enables a
location provider with extremely fast updates.
In case the provider is disabled by the user, updates will stop,
and a provider availability update will be sent.
As soon as the provider is enabled again,
location updates will immediately resume and a provider availability
update sent. Providers can also send status updates, at any time,
with extra's specific to the provider. If a callback was supplied
then status and availability updates are via
{@link LocationListener#onProviderDisabled},
{@link LocationListener#onProviderEnabled} or
{@link LocationListener#onStatusChanged}. Alternately, if a
pending intent was supplied then status and availability updates
are broadcast intents with extra keys of
{@link #KEY_PROVIDER_ENABLED} or {@link #KEY_STATUS_CHANGED}.
If a {@link LocationListener} is used but with no Looper specified
then the calling thread must already
be a {@link android.os.Looper} thread such as the main thread of the
calling Activity. If a Looper is specified with a {@link LocationListener}
then callbacks are made on the supplied Looper thread.
Prior to Jellybean, the minTime parameter was
only a hint, and some location provider implementations ignored it.
From Jellybean and onwards it is mandatory for Android compatible
devices to observe both the minTime and minDistance parameters.
checkCriteria(criteria);
checkPendingIntent(intent);
LocationRequest request = LocationRequest.createFromDeprecatedCriteria(
criteria, minTime, minDistance, false);
requestLocationUpdates(request, null, null, intent);
| | public void | requestLocationUpdates(LocationRequest request, LocationListener listener, android.os.Looper looper)Register for fused location updates using a LocationRequest and callback.
Upon a location update, the system delivers the new {@link Location} to the
provided {@link LocationListener}, by calling its {@link
LocationListener#onLocationChanged} method.
The system will automatically select and enable the best providers
to compute a location for your application. It may use only passive
locations, or just a single location source, or it may fuse together
multiple location sources in order to produce the best possible
result, depending on the quality of service requested in the
{@link LocationRequest}.
LocationRequest can be null, in which case the system will choose
default, low power parameters for location updates. You will occasionally
receive location updates as available, without a major power impact on the
system. If your application just needs an occasional location update
without any strict demands, then pass a null LocationRequest.
Only one LocationRequest can be registered for each unique callback
or pending intent. So a subsequent request with the same callback or
pending intent will over-write the previous LocationRequest.
If a pending intent is supplied then location updates
are sent with a key of {@link #KEY_LOCATION_CHANGED} and a
{@link android.location.Location} value. If a callback is supplied
then location updates are made using the
{@link LocationListener#onLocationChanged} callback, on the specified
Looper thread. If a {@link LocationListener} is used
but with a null Looper then the calling thread must already
be a {@link android.os.Looper} thread (such as the main thread) and
callbacks will occur on this thread.
Provider status updates and availability updates are deprecated
because the system is performing provider fusion on the applications
behalf. So {@link LocationListener#onProviderDisabled},
{@link LocationListener#onProviderEnabled}, {@link LocationListener#onStatusChanged}
will not be called, and intents with extra keys of
{@link #KEY_PROVIDER_ENABLED} or {@link #KEY_STATUS_CHANGED} will not
be received.
To unregister for Location updates, use: {@link #removeUpdates(LocationListener)}.
checkListener(listener);
requestLocationUpdates(request, listener, looper, null);
| | public void | requestLocationUpdates(LocationRequest request, android.app.PendingIntent intent)Register for fused location updates using a LocationRequest and a pending intent.
Upon a location update, the system delivers the new {@link Location} with your provided
{@link PendingIntent}, as the value for {@link LocationManager#KEY_LOCATION_CHANGED}
in the intent's extras.
To unregister for Location updates, use: {@link #removeUpdates(PendingIntent)}.
See {@link #requestLocationUpdates(LocationRequest, LocationListener, Looper)}
for more detail.
checkPendingIntent(intent);
requestLocationUpdates(request, null, null, intent);
| | private void | requestLocationUpdates(LocationRequest request, LocationListener listener, android.os.Looper looper, android.app.PendingIntent intent)
String packageName = mContext.getPackageName();
// wrap the listener class
ListenerTransport transport = wrapListener(listener, looper);
try {
mService.requestLocationUpdates(request, transport, intent, packageName);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | public void | requestLocationUpdates(java.lang.String provider, long minTime, float minDistance, LocationListener listener)Register for location updates using the named provider, and a
pending intent.
See {@link #requestLocationUpdates(long, float, Criteria, PendingIntent)}
for more detail on how to use this method.
checkProvider(provider);
checkListener(listener);
LocationRequest request = LocationRequest.createFromDeprecatedProvider(
provider, minTime, minDistance, false);
requestLocationUpdates(request, listener, null, null);
| | public void | requestLocationUpdates(java.lang.String provider, long minTime, float minDistance, LocationListener listener, android.os.Looper looper)Register for location updates using the named provider, and a callback on
the specified looper thread.
See {@link #requestLocationUpdates(long, float, Criteria, PendingIntent)}
for more detail on how to use this method.
checkProvider(provider);
checkListener(listener);
LocationRequest request = LocationRequest.createFromDeprecatedProvider(
provider, minTime, minDistance, false);
requestLocationUpdates(request, listener, looper, null);
| | public void | requestSingleUpdate(java.lang.String provider, LocationListener listener, android.os.Looper looper)Register for a single location update using the named provider and
a callback.
See {@link #requestLocationUpdates(long, float, Criteria, PendingIntent)}
for more detail on how to use this method.
checkProvider(provider);
checkListener(listener);
LocationRequest request = LocationRequest.createFromDeprecatedProvider(
provider, 0, 0, true);
requestLocationUpdates(request, listener, looper, null);
| | public void | requestSingleUpdate(Criteria criteria, LocationListener listener, android.os.Looper looper)Register for a single location update using a Criteria and
a callback.
See {@link #requestLocationUpdates(long, float, Criteria, PendingIntent)}
for more detail on how to use this method.
checkCriteria(criteria);
checkListener(listener);
LocationRequest request = LocationRequest.createFromDeprecatedCriteria(
criteria, 0, 0, true);
requestLocationUpdates(request, listener, looper, null);
| | public void | requestSingleUpdate(java.lang.String provider, android.app.PendingIntent intent)Register for a single location update using a named provider and pending intent.
See {@link #requestLocationUpdates(long, float, Criteria, PendingIntent)}
for more detail on how to use this method.
checkProvider(provider);
checkPendingIntent(intent);
LocationRequest request = LocationRequest.createFromDeprecatedProvider(
provider, 0, 0, true);
requestLocationUpdates(request, null, null, intent);
| | public void | requestSingleUpdate(Criteria criteria, android.app.PendingIntent intent)Register for a single location update using a Criteria and pending intent.
See {@link #requestLocationUpdates(long, float, Criteria, PendingIntent)}
for more detail on how to use this method.
checkCriteria(criteria);
checkPendingIntent(intent);
LocationRequest request = LocationRequest.createFromDeprecatedCriteria(
criteria, 0, 0, true);
requestLocationUpdates(request, null, null, intent);
| | public boolean | sendExtraCommand(java.lang.String provider, java.lang.String command, android.os.Bundle extras)Sends additional commands to a location provider.
Can be used to support provider specific extensions to the Location Manager API
try {
return mService.sendExtraCommand(provider, command, extras);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException in sendExtraCommand: ", e);
return false;
}
| | public boolean | sendNiResponse(int notifId, int userResponse)Used by NetInitiatedActivity to report user response
for network initiated GPS fix requests.
try {
return mService.sendNiResponse(notifId, userResponse);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException in sendNiResponse: ", e);
return false;
}
| | public void | setTestProviderEnabled(java.lang.String provider, boolean enabled)Sets a mock enabled value for the given provider. This value will be used in place
of any actual value from the provider.
try {
mService.setTestProviderEnabled(provider, enabled);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | public void | setTestProviderLocation(java.lang.String provider, Location loc)Sets a mock location for the given provider.
This location will be used in place of any actual location from the provider.
The location object must have a minimum number of fields set to be
considered a valid LocationProvider Location, as per documentation
on {@link Location} class.
if (!loc.isComplete()) {
IllegalArgumentException e = new IllegalArgumentException(
"Incomplete location object, missing timestamp or accuracy? " + loc);
if (mContext.getApplicationInfo().targetSdkVersion <= Build.VERSION_CODES.JELLY_BEAN) {
// just log on old platform (for backwards compatibility)
Log.w(TAG, e);
loc.makeComplete();
} else {
// really throw it!
throw e;
}
}
try {
mService.setTestProviderLocation(provider, loc);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | public void | setTestProviderStatus(java.lang.String provider, int status, android.os.Bundle extras, long updateTime)Sets mock status values for the given provider. These values will be used in place
of any actual values from the provider.
try {
mService.setTestProviderStatus(provider, status, extras, updateTime);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException", e);
}
| | private android.location.LocationManager$ListenerTransport | wrapListener(LocationListener listener, android.os.Looper looper)
if (listener == null) return null;
synchronized (mListeners) {
ListenerTransport transport = mListeners.get(listener);
if (transport == null) {
transport = new ListenerTransport(listener, looper);
}
mListeners.put(listener, transport);
return transport;
}
|
|
