/**@class android.location.LocationManager
@extends java.lang.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.

 <p class="note">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.
*/
var LocationManager = {

/** Name of the network location provider.
 <p>This provider determines location based on
 availability of cell tower and WiFi access points. Results are retrieved
 by means of a network lookup.
*/
NETWORK_PROVIDER : "network",
/** Name of the GPS location provider.

 <p>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}.

 <p> The extras Bundle for the GPS location provider can contain the
 following key/value pairs:
 <ul>
 <li> satellites - the number of satellites used to derive the fix
 </ul>
*/
GPS_PROVIDER : "gps",
/** A special location provider for receiving locations without actually initiating
 a location fix.

 <p>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 android.location.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.
*/
PASSIVE_PROVIDER : "passive",
/** Name of the Fused location provider.

 <p>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 android.location.LocationRequest}
 object.

 @hide
*/
FUSED_PROVIDER : "fused",
/** Key used for the Bundle extra holding a boolean indicating whether
 a proximity alert is entering (true) or exiting (false)..
*/
KEY_PROXIMITY_ENTERING : "entering",
/** This key is no longer in use.

 Key used for a Bundle extra holding an Integer status value
 when a status change is broadcast using a PendingIntent.

 @deprecated Status changes are deprecated and no longer broadcast.
*/
KEY_STATUS_CHANGED : "status",
/** Key used for a Bundle extra holding an Boolean status value
 when a provider enabled/disabled event is broadcast using a PendingIntent.
*/
KEY_PROVIDER_ENABLED : "providerEnabled",
/** Key used for a Bundle extra holding a Location value
 when a location change is broadcast using a PendingIntent.
*/
KEY_LOCATION_CHANGED : "location",
/** Broadcast intent action when the set of enabled location providers changes. To check the
 status of a provider, use {@link #isProviderEnabled}(String). From Android Q and above, will
 include a string intent extra, {@link #EXTRA_PROVIDER_NAME}, with the name of the provider
 whose state has changed.

 @see #EXTRA_PROVIDER_NAME
*/
PROVIDERS_CHANGED_ACTION : "android.location.PROVIDERS_CHANGED",
/** Intent extra included with {@link #PROVIDERS_CHANGED_ACTION} broadcasts, containing the name
 of the location provider that has changed, to be used with location provider APIs.
*/
EXTRA_PROVIDER_NAME : "android.location.extra.PROVIDER_NAME",
/** Broadcast intent action when the device location mode changes. To check the location mode,
 use {@link #isLocationEnabled}().
*/
MODE_CHANGED_ACTION : "android.location.MODE_CHANGED",
/** Broadcast intent action when {@link android.provider.Settings.Secure#LOCATION_MODE} is
 about to be changed through Settings app or Quick Settings.
 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.

 @deprecated Do not use.
 @hide
*/
MODE_CHANGING_ACTION : "com.android.settings.location.MODE_CHANGING",
/** Broadcast 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}.

 @hide
*/
HIGH_POWER_REQUEST_CHANGE_ACTION : "android.location.HIGH_POWER_REQUEST_CHANGE",
/** Broadcast intent action for Settings app to inject a footer at the bottom of location
 settings.

 <p>This broadcast is used for two things:
 <ol>
     <li>For receivers to inject a footer with provided text. This is for use only by apps
         that are included in the system image. </li>
     <li>For receivers to know their footer is injected under location settings.</li>
 </ol>

 <p>To inject a footer to location settings, you must declare a broadcast receiver of
 {@link android.location.LocationManager#SETTINGS_FOOTER_DISPLAYED_ACTION} in the manifest as so:
 <pre>
     &lt;receiver android:name="com.example.android.footer.MyFooterInjector"&gt;
         &lt;intent-filter&gt;
             &lt;action android:name="com.android.settings.location.INJECT_FOOTER" /&gt;
         &lt;/intent-filter&gt;
         &lt;meta-data
             android:name="com.android.settings.location.FOOTER_STRING"
             android:resource="@string/my_injected_footer_string" /&gt;
     &lt;/receiver&gt;
 </pre>

 <p>On entering location settings, Settings app will send a
 {@link #SETTINGS_FOOTER_DISPLAYED_ACTION} broadcast to receivers whose footer is successfully
 injected. On leaving location settings, the footer becomes not visible to users. Settings app
 will send a {@link #SETTINGS_FOOTER_REMOVED_ACTION} broadcast to those receivers.

 @hide
*/
SETTINGS_FOOTER_DISPLAYED_ACTION : "com.android.settings.location.DISPLAYED_FOOTER",
/** Broadcast intent action when location settings footer is not visible to users.

 <p>See {@link #SETTINGS_FOOTER_DISPLAYED_ACTION} for more detail on how to use.

 @hide
*/
SETTINGS_FOOTER_REMOVED_ACTION : "com.android.settings.location.REMOVED_FOOTER",
/** Metadata name for {@link android.location.LocationManager#SETTINGS_FOOTER_DISPLAYED_ACTION} broadcast
 receivers to specify a string resource id as location settings footer text. This is for use
 only by apps that are included in the system image.

 <p>See {@link #SETTINGS_FOOTER_DISPLAYED_ACTION} for more detail on how to use.

 @hide
*/
METADATA_SETTINGS_FOOTER_STRING : "com.android.settings.location.FOOTER_STRING",
/**
@hide 
*/
getBackgroundThrottlingWhitelist : function(  ) {},

/**
@hide 
*/
getIgnoreSettingsWhitelist : function(  ) {},

/**Returns a list of the names of all known location providers.
 <p>All providers are returned, including ones that are not permitted to
 be accessed by the calling activity or are currently disabled.
@return {Object {java.util.List}} list of Strings containing names of the provider
*/
getAllProviders : function(  ) {},

/**Returns a list of the names of location providers.
@param {Boolean} enabledOnly if true then only the providers which are currently
 enabled are returned.
@return {Object {java.util.List}} list of Strings containing names of the providers
*/
getProviders : function(  ) {},

/**Returns the information associated with the location provider of the
 given name, or null if no provider exists by that name.
@param {String} name the provider name
@return {Object {android.location.LocationProvider}} a LocationProvider, or null
@throws IllegalArgumentException if name is null or does not exist
@throws SecurityException if the caller is not permitted to access the
 given provider.
*/
getProvider : function(  ) {},

/**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.
@param {Object {Criteria}} criteria the criteria that the returned providers must match
@param {Boolean} enabledOnly if true then only the providers which are currently
 enabled are returned.
@return {Object {java.util.List}} list of Strings containing names of the providers
*/
getProviders : function(  ) {},

/**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:

 <ul>
 <li> power requirement
 <li> accuracy
 <li> bearing
 <li> speed
 <li> altitude
 </ul>

 <p> Note that the requirement on monetary cost is not removed
 in this process.
@param {Object {Criteria}} criteria the criteria that need to be matched
@param {Boolean} enabledOnly if true then only a provider that is currently enabled is returned
@return {String} name of the provider that best matches the requirements
*/
getBestProvider : function(  ) {},

/**Register for location updates using the named provider, and a
 pending intent.

 <p>See {@link #requestLocationUpdates(long, float, android.location.Criteria, PendingIntent)}
 for more detail on how to use this method.
@param {String} provider the name of the provider with which to register
@param {Number} minTime minimum time interval between location updates, in milliseconds
@param {Number} minDistance minimum distance between location updates, in meters
@param {Object {LocationListener}} listener a {@link LocationListener} whose
 {@link LocationListener#onLocationChanged} method will be called for
 each location update
@throws IllegalArgumentException if provider is null or doesn't exist
 on this device
@throws IllegalArgumentException if listener is null
@throws RuntimeException if the calling thread has no Looper
@throws SecurityException if no suitable permission is present
*/
requestLocationUpdates : function(  ) {},

/**Register for location updates using the named provider, and a callback on
 the specified looper thread.

 <p>See {@link #requestLocationUpdates(long, float, android.location.Criteria, PendingIntent)}
 for more detail on how to use this method.
@param {String} provider the name of the provider with which to register
@param {Number} minTime minimum time interval between location updates, in milliseconds
@param {Number} minDistance minimum distance between location updates, in meters
@param {Object {LocationListener}} listener a {@link LocationListener} whose
 {@link LocationListener#onLocationChanged} method will be called for
 each location update
@param {Object {Looper}} looper a Looper object whose message queue will be used to
 implement the callback mechanism, or null to make callbacks on the calling
 thread
@throws IllegalArgumentException if provider is null or doesn't exist
@throws IllegalArgumentException if listener is null
@throws SecurityException if no suitable permission is present
*/
requestLocationUpdates : function(  ) {},

/**Register for location updates using a Criteria, and a callback
 on the specified looper thread.

 <p>See {@link #requestLocationUpdates(long, float, android.location.Criteria, PendingIntent)}
 for more detail on how to use this method.
@param {Number} minTime minimum time interval between location updates, in milliseconds
@param {Number} minDistance minimum distance between location updates, in meters
@param {Object {Criteria}} criteria contains parameters for the location manager to choose the
 appropriate provider and parameters to compute the location
@param {Object {LocationListener}} listener a {@link LocationListener} whose
 {@link LocationListener#onLocationChanged} method will be called for
 each location update
@param {Object {Looper}} looper a Looper object whose message queue will be used to
 implement the callback mechanism, or null to make callbacks on the calling
 thread
@throws IllegalArgumentException if criteria is null
@throws IllegalArgumentException if listener is null
@throws SecurityException if no suitable permission is present
*/
requestLocationUpdates : function(  ) {},

/**Register for location updates using the named provider, and a
 pending intent.

 <p>See {@link #requestLocationUpdates(long, float, android.location.Criteria, PendingIntent)}
 for more detail on how to use this method.
@param {String} provider the name of the provider with which to register
@param {Number} minTime minimum time interval between location updates, in milliseconds
@param {Number} minDistance minimum distance between location updates, in meters
@param {Object {PendingIntent}} intent a {@link PendingIntent} to be sent for each location update
@throws IllegalArgumentException if provider is null or doesn't exist
 on this device
@throws IllegalArgumentException if intent is null
@throws SecurityException if no suitable permission is present
*/
requestLocationUpdates : function(  ) {},

/**Register for location updates using a Criteria and pending intent.

 <p>The <code>requestLocationUpdates()</code> and
 <code>requestSingleUpdate()</code> register the current activity to be
 updated periodically by the named provider, or by the provider matching
 the specified {@link android.location.Criteria}, with location and status updates.

 <p> 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.

 <p> Location updates are received either by {@link android.location.LocationListener}
 callbacks, or by broadcast intents to a supplied {@link PendingIntent}.

 <p> 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.

 <p> 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.

 <p> 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.

 <p> 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.

 <p> 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.

 <p>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 android.location.LocationListener#onProviderDisabled},
 {@link android.location.LocationListener#onProviderEnabled} or
 {@link android.location.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}.

 <p> If a {@link android.location.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 android.location.LocationListener}
 then callbacks are made on the supplied Looper thread.

 <p> When location callbacks are invoked, the system will hold a wakelock
 on your application's behalf for some period of time, but not
 indefinitely. If your application requires a long running wakelock
 within the location callback, you should acquire it yourself.

 <p class="note"> 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.
@param {Number} minTime minimum time interval between location updates, in milliseconds
@param {Number} minDistance minimum distance between location updates, in meters
@param {Object {Criteria}} criteria contains parameters for the location manager to choose the
 appropriate provider and parameters to compute the location
@param {Object {PendingIntent}} intent a {@link PendingIntent} to be sent for each location update
@throws IllegalArgumentException if criteria is null
@throws IllegalArgumentException if intent is null
@throws SecurityException if no suitable permission is present
*/
requestLocationUpdates : function(  ) {},

/**Register for a single location update using the named provider and
 a callback.

 <p>See {@link #requestLocationUpdates(long, float, android.location.Criteria, PendingIntent)}
 for more detail on how to use this method.
@param {String} provider the name of the provider with which to register
@param {Object {LocationListener}} listener a {@link LocationListener} whose
 {@link LocationListener#onLocationChanged} method will be called when
 the location update is available
@param {Object {Looper}} looper a Looper object whose message queue will be used to
 implement the callback mechanism, or null to make callbacks on the calling
 thread
@throws IllegalArgumentException if provider is null or doesn't exist
@throws IllegalArgumentException if listener is null
@throws SecurityException if no suitable permission is present
*/
requestSingleUpdate : function(  ) {},

/**Register for a single location update using a Criteria and
 a callback.

 <p>See {@link #requestLocationUpdates(long, float, android.location.Criteria, PendingIntent)}
 for more detail on how to use this method.
@param {Object {Criteria}} criteria contains parameters for the location manager to choose the
 appropriate provider and parameters to compute the location
@param {Object {LocationListener}} listener a {@link LocationListener} whose
 {@link LocationListener#onLocationChanged} method will be called when
 the location update is available
@param {Object {Looper}} looper a Looper object whose message queue will be used to
 implement the callback mechanism, or null to make callbacks on the calling
 thread
@throws IllegalArgumentException if criteria is null
@throws IllegalArgumentException if listener is null
@throws SecurityException if no suitable permission is present
*/
requestSingleUpdate : function(  ) {},

/**Register for a single location update using a named provider and pending intent.

 <p>See {@link #requestLocationUpdates(long, float, android.location.Criteria, PendingIntent)}
 for more detail on how to use this method.
@param {String} provider the name of the provider with which to register
@param {Object {PendingIntent}} intent a {@link PendingIntent} to be sent for the location update
@throws IllegalArgumentException if provider is null or doesn't exist
@throws IllegalArgumentException if intent is null
@throws SecurityException if no suitable permission is present
*/
requestSingleUpdate : function(  ) {},

/**Register for a single location update using a Criteria and pending intent.

 <p>See {@link #requestLocationUpdates(long, float, android.location.Criteria, PendingIntent)}
 for more detail on how to use this method.
@param {Object {Criteria}} criteria contains parameters for the location manager to choose the
 appropriate provider and parameters to compute the location
@param {Object {PendingIntent}} intent a {@link PendingIntent} to be sent for the location update
@throws IllegalArgumentException if provider is null or doesn't exist
@throws IllegalArgumentException if intent is null
@throws SecurityException if no suitable permission is present
*/
requestSingleUpdate : function(  ) {},

/**Register for fused location updates using a LocationRequest and callback.

 <p>Upon a location update, the system delivers the new {@link android.location.Location} to the
 provided {@link android.location.LocationListener}, by calling its {@link android.location.LocationListener#onLocationChanged} method.</p>

 <p>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 android.location.LocationRequest}.

 <p>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.

 <p>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.

 <p> 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 android.location.LocationListener#onLocationChanged} callback, on the specified
 Looper thread. If a {@link android.location.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.

 <p> Provider status updates and availability updates are deprecated
 because the system is performing provider fusion on the applications
 behalf. So {@link android.location.LocationListener#onProviderDisabled},
 {@link android.location.LocationListener#onProviderEnabled}, {@link android.location.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.

 <p> To unregister for Location updates, use: {@link #removeUpdates}(LocationListener).
@param {Object {LocationRequest}} request quality of service required, null for default low power
@param {Object {LocationListener}} listener a {@link LocationListener} whose
 {@link LocationListener#onLocationChanged} method will be called when
 the location update is available
@param {Object {Looper}} looper a Looper object whose message queue will be used to
 implement the callback mechanism, or null to make callbacks on the calling
 thread
@throws IllegalArgumentException if listener is null
@throws SecurityException if no suitable permission is present
@hide 
*/
requestLocationUpdates : function(  ) {},

/**Register for fused location updates using a LocationRequest and a pending intent.

 <p>Upon a location update, the system delivers the new {@link android.location.Location} with your provided
 {@link PendingIntent}, as the value for {@link android.location.LocationManager#KEY_LOCATION_CHANGED}
 in the intent's extras.</p>

 <p> To unregister for Location updates, use: {@link #removeUpdates}(PendingIntent).

 <p> See {@link #requestLocationUpdates(LocationRequest, android.location.LocationListener, Looper)}
 for more detail.
@param {Object {LocationRequest}} request quality of service required, null for default low power
@param {Object {PendingIntent}} intent a {@link PendingIntent} to be sent for the location update
@throws IllegalArgumentException if intent is null
@throws SecurityException if no suitable permission is present
@hide 
*/
requestLocationUpdates : function(  ) {},

/**Set the last known location with a new location.

 <p>A privileged client can inject a {@link android.location.Location} if it has a better estimate of what
 the recent location is.  This is especially useful when the device boots up and the GPS
 chipset is in the process of getting the first fix.  If the client has cached the location,
 it can inject the {@link android.location.Location}, so if an app requests for a {@link android.location.Location} from {@link #getLastKnownLocation}(String), the location information is still useful before getting
 the first fix.</p>

 <p> Useful in products like Auto.
@param {Object {Location}} newLocation newly available {@link Location} object
@return {Boolean} true if update was successful, false if not
@throws SecurityException if no suitable permission is present
@hide 
*/
injectLocation : function(  ) {},

/**Removes all location updates for the specified LocationListener.

 <p>Following this call, updates will no longer
 occur for this listener.
@param {Object {LocationListener}} listener listener object that no longer needs location updates
@throws IllegalArgumentException if listener is null
*/
removeUpdates : function(  ) {},

/**Removes all location updates for the specified pending intent.

 <p>Following this call, updates will no longer for this pending intent.
@param {Object {PendingIntent}} intent pending intent object that no longer needs location updates
@throws IllegalArgumentException if intent is null
*/
removeUpdates : function(  ) {},

/**Set a proximity alert for the location given by the position
 (latitude, longitude) and the given radius.

 <p> 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.

 <p> 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.

 <p> 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.

 <p> 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.

 <p> Internally, this method uses both {@link #NETWORK_PROVIDER}
 and {@link #GPS_PROVIDER}.

 <p>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.
@param {Number} latitude the latitude of the central point of the
 alert region
@param {Number} longitude the longitude of the central point of the
 alert region
@param {Number} radius the radius of the central point of the
 alert region, in meters
@param {Number} expiration time for this proximity alert, in milliseconds,
 or -1 to indicate no expiration
@param {Object {PendingIntent}} intent a PendingIntent that will be used to generate an Intent to
 fire when entry to or exit from the alert region is detected
@throws SecurityException if {@link android.Manifest.permission#ACCESS_FINE_LOCATION}
 permission is not present
*/
addProximityAlert : function(  ) {},

/**Add a geofence with the specified LocationRequest quality of service.

 <p> 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.

 <p> 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.

 <p> 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 android.location.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 android.location.LocationRequest} as a hint to trade-off
 accuracy and power.

 <p> The power required by the geofence engine can depend on many factors,
 such as quality and interval requested in {@link android.location.LocationRequest},
 distance to nearest geofence and current device velocity.
@param {Object {LocationRequest}} request quality of service required, null for default low power
@param {Object {Geofence}} fence a geographical description of the geofence area
@param {Object {PendingIntent}} intent pending intent to receive geofence updates
@throws IllegalArgumentException if fence is null
@throws IllegalArgumentException if intent is null
@throws SecurityException if {@link android.Manifest.permission#ACCESS_FINE_LOCATION}
 permission is not present
@hide 
*/
addGeofence : function(  ) {},

/**Removes the proximity alert with the given PendingIntent.

 <p>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.
@param {Object {PendingIntent}} intent the PendingIntent that no longer needs to be notified of
 proximity alerts
@throws IllegalArgumentException if intent is null
@throws SecurityException if {@link android.Manifest.permission#ACCESS_FINE_LOCATION}
 permission is not present
*/
removeProximityAlert : function(  ) {},

/**Remove a single geofence.

 <p>This removes only the specified geofence associated with the
 specified pending intent. All other geofences remain unchanged.
@param {Object {Geofence}} fence a geofence previously passed to {@link #addGeofence}
@param {Object {PendingIntent}} intent a pending intent previously passed to {@link #addGeofence}
@throws IllegalArgumentException if fence is null
@throws IllegalArgumentException if intent is null
@throws SecurityException if {@link android.Manifest.permission#ACCESS_FINE_LOCATION}
 permission is not present
@hide 
*/
removeGeofence : function(  ) {},

/**Remove all geofences registered to the specified pending intent.
@param {Object {PendingIntent}} intent a pending intent previously passed to {@link #addGeofence}
@throws IllegalArgumentException if intent is null
@throws SecurityException if {@link android.Manifest.permission#ACCESS_FINE_LOCATION}
 permission is not present
@hide 
*/
removeAllGeofences : function(  ) {},

/**Returns the current enabled/disabled state of location. To listen for changes, see
 {@link #MODE_CHANGED_ACTION}.
@return {Boolean} true if location is enabled and false if location is disabled.
*/
isLocationEnabled : function(  ) {},

/**Returns the current enabled/disabled state of location.
@param {Object {UserHandle}} userHandle the user to query
@return {Boolean} true if location is enabled and false if location is disabled.
@hide 
*/
isLocationEnabledForUser : function(  ) {},

/**Enables or disables the location setting.
@param {Boolean} enabled true to enable location and false to disable location.
@param {Object {UserHandle}} userHandle the user to set
@hide 
*/
setLocationEnabledForUser : function(  ) {},

/**Returns the current enabled/disabled status of the given provider. To listen for changes, see
 {@link #PROVIDERS_CHANGED_ACTION}.

 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.
@param {String} provider the name of the provider
@return {Boolean} true if the provider exists and is enabled
@throws IllegalArgumentException if provider is null
*/
isProviderEnabled : function(  ) {},

/**Returns the current enabled/disabled status of the given provider and user. Callers should
 prefer {@link #isLocationEnabledForUser}(UserHandle) unless they depend on provider-specific
 APIs.

 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.
@param {String} provider the name of the provider
@param {Object {UserHandle}} userHandle the user to query
@return {Boolean} true if the provider exists and is enabled
@throws IllegalArgumentException if provider is null
@hide 
*/
isProviderEnabledForUser : function(  ) {},

/**Method for enabling or disabling a single location provider. This method is deprecated and
 functions as a best effort. It should not be relied on in any meaningful sense as providers
 may no longer be enabled or disabled by clients.
@param {String} provider the name of the provider
@param {Boolean} enabled true to enable the provider. false to disable the provider
@param {Object {UserHandle}} userHandle the user to set
@return {Boolean} true if the value was set, false otherwise
@throws IllegalArgumentException if provider is null
@deprecated Do not manipulate providers individually, use
 {@link #setLocationEnabledForUser(boolean, UserHandle)} instead.
@hide 
*/
setProviderEnabledForUser : function(  ) {},

/**Get the last known location.

 <p>This location could be very old so use
 {@link android.location.Location#getElapsedRealtimeNanos} to calculate its age. It can
 also return null if no previous location is available.

 <p>Always returns immediately.
@return {Object {android.location.Location}} The last known location, or null if not available
@throws SecurityException if no suitable permission is present
@hide 
*/
getLastLocation : function(  ) {},

/**Returns a Location indicating the data from the last known
 location fix obtained from the given provider.

 <p> 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.

 <p> If the provider is currently disabled, null is returned.
@param {String} provider the name of the provider
@return {Object {android.location.Location}} the last known location for the provider, or null
@throws SecurityException if no suitable permission is present
@throws IllegalArgumentException if provider is null or doesn't exist
*/
getLastKnownLocation : function(  ) {},

/**Creates a mock location provider and adds it to the set of active providers.
@param {String} name the provider name
@throws SecurityException if {@link android.app.AppOpsManager#OPSTR_MOCK_LOCATION
 mock location app op} is not set to {@link android.app.AppOpsManager#MODE_ALLOWED
 allowed} for your app.
@throws IllegalArgumentException if a provider with the given name already exists
*/
addTestProvider : function(  ) {},

/**Removes the mock location provider with the given name.
@param {String} provider the provider name
@throws SecurityException if {@link android.app.AppOpsManager#OPSTR_MOCK_LOCATION
 mock location app op} is not set to {@link android.app.AppOpsManager#MODE_ALLOWED
 allowed} for your app.
@throws IllegalArgumentException if no provider with the given name exists
*/
removeTestProvider : function(  ) {},

/**Sets a mock location for the given provider.
 <p>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 android.location.Location} class.
@param {String} provider the provider name
@param {Object {Location}} loc the mock location
@throws SecurityException if {@link android.app.AppOpsManager#OPSTR_MOCK_LOCATION
 mock location app op} is not set to {@link android.app.AppOpsManager#MODE_ALLOWED
 allowed} for your app.
@throws IllegalArgumentException if no provider with the given name exists
@throws IllegalArgumentException if the location is incomplete
*/
setTestProviderLocation : function(  ) {},

/**Removes any mock location associated with the given provider.
@param {String} provider the provider name
@throws SecurityException if {@link android.app.AppOpsManager#OPSTR_MOCK_LOCATION
 mock location app op} is not set to {@link android.app.AppOpsManager#MODE_ALLOWED
 allowed} for your app.
@throws IllegalArgumentException if no provider with the given name exists
@deprecated This function has always been a no-op, and may be removed in the future.
*/
clearTestProviderLocation : function(  ) {},

/**Sets a mock enabled value for the given provider.  This value will be used in place
 of any actual value from the provider.
@param {String} provider the provider name
@param {Boolean} enabled the mock enabled value
@throws SecurityException if {@link android.app.AppOpsManager#OPSTR_MOCK_LOCATION
 mock location app op} is not set to {@link android.app.AppOpsManager#MODE_ALLOWED
 allowed} for your app.
@throws IllegalArgumentException if no provider with the given name exists
*/
setTestProviderEnabled : function(  ) {},

/**Removes any mock enabled value associated with the given provider.
@param {String} provider the provider name
@throws SecurityException if {@link android.app.AppOpsManager#OPSTR_MOCK_LOCATION
 mock location app op} is not set to {@link android.app.AppOpsManager#MODE_ALLOWED
 allowed} for your app.
@throws IllegalArgumentException if no provider with the given name exists
@deprecated Use {@link #setTestProviderEnabled(String, boolean)} instead.
*/
clearTestProviderEnabled : function(  ) {},

/**This method has no effect as provider status has been deprecated and is no longer supported.
@param {String} provider the provider name
@param {Number} status the mock status
@param {Object {Bundle}} extras a Bundle containing mock extras
@param {Number} updateTime the mock update time
@throws SecurityException if {@link android.app.AppOpsManager#OPSTR_MOCK_LOCATION
 mock location app op} is not set to {@link android.app.AppOpsManager#MODE_ALLOWED
 allowed} for your app.
@throws IllegalArgumentException if no provider with the given name exists
@deprecated This method has no effect.
*/
setTestProviderStatus : function(  ) {},

/**This method has no effect as provider status has been deprecated and is no longer supported.
@param {String} provider the provider name
@throws SecurityException if {@link android.app.AppOpsManager#OPSTR_MOCK_LOCATION
 mock location app op} is not set to {@link android.app.AppOpsManager#MODE_ALLOWED
 allowed} for your app.
@throws IllegalArgumentException if no provider with the given name exists
@deprecated This method has no effect.
*/
clearTestProviderStatus : function(  ) {},

/**Get the last list of {@link android.location.LocationRequest}s sent to the provider.
@hide 
*/
getTestProviderCurrentRequests : function(  ) {},

/**Adds a GPS status listener.
@param {Object {GpsStatus.Listener}} listener GPS status listener object to register
@return {Boolean} true if the listener was successfully added
@throws SecurityException if the ACCESS_FINE_LOCATION permission is not present
@deprecated use {@link #registerGnssStatusCallback(GnssStatus.Callback)} instead.
*/
addGpsStatusListener : function(  ) {},

/**Removes a GPS status listener.
@param {Object {GpsStatus.Listener}} listener GPS status listener object to remove
@deprecated use {@link #unregisterGnssStatusCallback(GnssStatus.Callback)} instead.
*/
removeGpsStatusListener : function(  ) {},

/**Registers a GNSS status callback.
@param {Object {GnssStatus.Callback}} callback GNSS status callback object to register
@return {Boolean} true if the listener was successfully added
@throws SecurityException if the ACCESS_FINE_LOCATION permission is not present
*/
registerGnssStatusCallback : function(  ) {},

/**Registers a GNSS status callback.
@param {Object {GnssStatus.Callback}} callback GNSS status callback object to register
@param {Object {Handler}} handler the handler that the callback runs on.
@return {Boolean} true if the listener was successfully added
@throws SecurityException if the ACCESS_FINE_LOCATION permission is not present
*/
registerGnssStatusCallback : function(  ) {},

/**Removes a GNSS status callback.
@param {Object {GnssStatus.Callback}} callback GNSS status callback object to remove
*/
unregisterGnssStatusCallback : function(  ) {},

/**Adds an NMEA listener.
@param {Object {GpsStatus.NmeaListener}} listener a {@link GpsStatus.NmeaListener} object to register
@return {Boolean} true if the listener was successfully added
@throws SecurityException if the ACCESS_FINE_LOCATION permission is not present
@deprecated use {@link #addNmeaListener(OnNmeaMessageListener)} instead.
@removed 
*/
addNmeaListener : function(  ) {},

/**Removes an NMEA listener.
@param {Object {GpsStatus.NmeaListener}} listener a {@link GpsStatus.NmeaListener} object to remove
@deprecated use {@link #removeNmeaListener(OnNmeaMessageListener)} instead.
@removed 
*/
removeNmeaListener : function(  ) {},

/**Adds an NMEA listener.
@param {Object {OnNmeaMessageListener}} listener a {@link OnNmeaMessageListener} object to register
@return {Boolean} true if the listener was successfully added
@throws SecurityException if the ACCESS_FINE_LOCATION permission is not present
*/
addNmeaListener : function(  ) {},

/**Adds an NMEA listener.
@param {Object {OnNmeaMessageListener}} listener a {@link OnNmeaMessageListener} object to register
@param {Object {Handler}} handler the handler that the listener runs on.
@return {Boolean} true if the listener was successfully added
@throws SecurityException if the ACCESS_FINE_LOCATION permission is not present
*/
addNmeaListener : function(  ) {},

/**Removes an NMEA listener.
@param {Object {OnNmeaMessageListener}} listener a {@link OnNmeaMessageListener} object to remove
*/
removeNmeaListener : function(  ) {},

/**No-op method to keep backward-compatibility.
 Don't use it. Use {@link #registerGnssMeasurementsCallback} instead.
@hide 
@deprecated Not supported anymore.
@removed 
*/
addGpsMeasurementListener : function(  ) {},

/**Registers a GPS Measurement callback.
@param {Object {GnssMeasurementsEvent.Callback}} callback a {@link GnssMeasurementsEvent.Callback} object to register.
@return {Boolean} {@code true} if the callback was added successfully, {@code false} otherwise.
*/
registerGnssMeasurementsCallback : function(  ) {},

/**Registers a GPS Measurement callback.
@param {Object {GnssMeasurementsEvent.Callback}} callback a {@link GnssMeasurementsEvent.Callback} object to register.
@param {Object {Handler}} handler the handler that the callback runs on.
@return {Boolean} {@code true} if the callback was added successfully, {@code false} otherwise.
*/
registerGnssMeasurementsCallback : function(  ) {},

/**Injects GNSS measurement corrections into the GNSS chipset.
@param {Object {GnssMeasurementCorrections}} measurementCorrections a {@link GnssMeasurementCorrections} object with the GNSS
     measurement corrections to be injected into the GNSS chipset.
@hide 
*/
injectGnssMeasurementCorrections : function(  ) {},

/**Returns the supported capabilities of the GNSS chipset.
@throws SecurityException if the ACCESS_FINE_LOCATION permission is not present.
@hide 
*/
getGnssCapabilities : function(  ) {},

/**No-op method to keep backward-compatibility. Don't use it. Use {@link #unregisterGnssMeasurementsCallback} instead.
@hide 
@deprecated use {@link #unregisterGnssMeasurementsCallback(GnssMeasurementsEvent.Callback)}
     instead.
@removed 
*/
removeGpsMeasurementListener : function(  ) {},

/**Unregisters a GPS Measurement callback.
@param {Object {GnssMeasurementsEvent.Callback}} callback a {@link GnssMeasurementsEvent.Callback} object to remove.
*/
unregisterGnssMeasurementsCallback : function(  ) {},

/**No-op method to keep backward-compatibility.
 Don't use it. Use {@link #registerGnssNavigationMessageCallback} instead.
@hide 
@deprecated Not supported anymore.
@removed 
*/
addGpsNavigationMessageListener : function(  ) {},

/**No-op method to keep backward-compatibility.
 Don't use it. Use {@link #unregisterGnssNavigationMessageCallback} instead.
@hide 
@deprecated use
 {@link #unregisterGnssNavigationMessageCallback(GnssNavigationMessage.Callback)}
 instead
@removed 
*/
removeGpsNavigationMessageListener : function(  ) {},

/**Registers a GNSS Navigation Message callback.
@param {Object {GnssNavigationMessage.Callback}} callback a {@link GnssNavigationMessage.Callback} object to register.
@return {Boolean} {@code true} if the callback was added successfully, {@code false} otherwise.
*/
registerGnssNavigationMessageCallback : function(  ) {},

/**Registers a GNSS Navigation Message callback.
@param {Object {GnssNavigationMessage.Callback}} callback a {@link GnssNavigationMessage.Callback} object to register.
@param {Object {Handler}} handler the handler that the callback runs on.
@return {Boolean} {@code true} if the callback was added successfully, {@code false} otherwise.
*/
registerGnssNavigationMessageCallback : function(  ) {},

/**Unregisters a GNSS Navigation Message callback.
@param {Object {GnssNavigationMessage.Callback}} callback a {@link GnssNavigationMessage.Callback} object to remove.
*/
unregisterGnssNavigationMessageCallback : function(  ) {},

/**Retrieves information about the current status of the GPS engine.
 This should only be called from the {@link android.location.GpsStatus.Listener#onandroid.location.GpsStatusChanged}
 callback to ensure that the data is copied atomically.

 The caller may either pass in a {@link android.location.GpsStatus} object to set with the latest
 status information, or pass null to create a new {@link android.location.GpsStatus} object.
@param {Object {GpsStatus}} status object containing GPS status details, or null.
@return {Object {android.location.GpsStatus}} status object containing updated GPS status.
*/
getGpsStatus : function(  ) {},

/**Returns the model year of the GNSS hardware and software build.

 <p> More details, such as build date, may be available in {@link #getGnssHardwareModelName}().

 <p> May return 0 if the model year is less than 2016.
*/
getGnssYearOfHardware : function(  ) {},

/**Returns the Model Name (including Vendor and Hardware/Software Version) of the GNSS hardware
 driver.

 <p> No device-specific serial number or ID is returned from this API.

 <p> Will return null when the GNSS hardware abstraction layer does not support providing
 this value.
*/
getGnssHardwareModelName : function(  ) {},

/**Returns the batch size (in number of Location objects) that are supported by the batching
 interface.
@return {Number} Maximum number of location objects that can be returned
@hide 
*/
getGnssBatchSize : function(  ) {},

/**Start hardware-batching of GNSS locations. This API is primarily used when the AP is
 asleep and the device can batch GNSS locations in the hardware.

 Note this is designed (as was the fused location interface before it) for a single user
 SystemApi - requests are not consolidated.  Care should be taken when the System switches
 users that may have different batching requests, to stop hardware batching for one user, and
 restart it for the next.
@param {Number} periodNanos Time interval, in nanoseconds, that the GNSS locations are requested
                    within the batch
@param {Boolean} wakeOnFifoFull True if the hardware batching should flush the locations in a
                       a callback to the listener, when it's internal buffer is full.  If
                       set to false, the oldest location information is, instead,
                       dropped when the buffer is full.
@param {Object {BatchedLocationCallback}} callback The listener on which to return the batched locations
@param {Object {Handler}} handler The handler on which to process the callback
@return {Boolean} True if batching was successfully started
@hide 
*/
registerGnssBatchedLocationCallback : function(  ) {},

/**Flush the batched GNSS locations.
 All GNSS locations currently ready in the batch are returned via the callback sent in
 startGnssBatch(), and the buffer containing the batched locations is cleared.
@hide 
*/
flushGnssBatch : function(  ) {},

/**Stop batching locations. This API is primarily used when the AP is
 asleep and the device can batch locations in the hardware.
@param {Object {BatchedLocationCallback}} callback the specific callback class to remove from the transport layer
@return {Boolean} True if batching was successfully started
@hide 
*/
unregisterGnssBatchedLocationCallback : function(  ) {},

/**Sends additional commands to a location provider.
 Can be used to support provider specific extensions to the Location Manager API
@param {String} provider name of the location provider.
@param {String} command name of the command to send to the provider.
@param {Object {Bundle}} extras optional arguments for the command (or null).
 The provider may optionally fill the extras Bundle with results from the command.
@return {Boolean} true if the command succeeds.
*/
sendExtraCommand : function(  ) {},

/**Used by NetInitiatedActivity to report user response
 for network initiated GPS fix requests.
@hide 
*/
sendNiResponse : function(  ) {},

/**Returns true if the given package name matches a location provider package, and false
 otherwise.
@hide 
*/
isProviderPackage : function(  ) {},

/**Set the extra location controller package for location services on the device.
@hide 
*/
setExtraLocationControllerPackage : function(  ) {},

/**Set the extra location controller package for location services on the device.
@removed 
@deprecated Use {@link #setExtraLocationControllerPackage} instead.
@hide 
*/
setLocationControllerExtraPackage : function(  ) {},

/**Returns the extra location controller package on the device.
@hide 
*/
getExtraLocationControllerPackage : function(  ) {},

/**Set whether the extra location controller package is currently enabled on the device.
@removed 
@deprecated Use {@link #setExtraLocationControllerPackageEnabled} instead.
@hide 
*/
setLocationControllerExtraPackageEnabled : function(  ) {},

/**Set whether the extra location controller package is currently enabled on the device.
@hide 
*/
setExtraLocationControllerPackageEnabled : function(  ) {},

/**Returns whether extra location controller package is currently enabled on the device.
@hide 
*/
isExtraLocationControllerPackageEnabled : function(  ) {},


};