2 * Copyright (C) 2008 The Android Open Source Project
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 package com.android.server.location;
19 import android.app.AlarmManager;
20 import android.app.AppOpsManager;
21 import android.app.PendingIntent;
22 import android.content.BroadcastReceiver;
23 import android.content.Context;
24 import android.content.Intent;
25 import android.content.IntentFilter;
26 import android.database.Cursor;
27 import android.hardware.location.GeofenceHardware;
28 import android.hardware.location.GeofenceHardwareImpl;
29 import android.location.Criteria;
30 import android.location.FusedBatchOptions;
31 import android.location.GnssStatus;
32 import android.location.IGnssStatusListener;
33 import android.location.IGnssStatusProvider;
34 import android.location.GnssMeasurementsEvent;
35 import android.location.GnssNavigationMessage;
36 import android.location.IGpsGeofenceHardware;
37 import android.location.ILocationManager;
38 import android.location.INetInitiatedListener;
39 import android.location.Location;
40 import android.location.LocationListener;
41 import android.location.LocationManager;
42 import android.location.LocationProvider;
43 import android.location.LocationRequest;
44 import android.net.ConnectivityManager;
45 import android.net.Network;
46 import android.net.NetworkCapabilities;
47 import android.net.NetworkInfo;
48 import android.net.NetworkRequest;
49 import android.net.Uri;
50 import android.os.AsyncTask;
51 import android.os.PowerSaveState;
52 import android.os.BatteryStats;
53 import android.os.Binder;
54 import android.os.Bundle;
55 import android.os.PersistableBundle;
56 import android.os.Handler;
57 import android.os.Looper;
58 import android.os.Message;
59 import android.os.PowerManager;
60 import android.os.RemoteException;
61 import android.os.ServiceManager;
62 import android.os.SystemClock;
63 import android.os.SystemProperties;
64 import android.os.UserHandle;
65 import android.os.WorkSource;
66 import android.provider.Settings;
67 import android.provider.Telephony.Carriers;
68 import android.provider.Telephony.Sms.Intents;
69 import android.telephony.SubscriptionManager;
70 import android.telephony.SubscriptionManager.OnSubscriptionsChangedListener;
71 import android.telephony.TelephonyManager;
72 import android.telephony.CarrierConfigManager;
73 import android.telephony.gsm.GsmCellLocation;
74 import android.text.TextUtils;
75 import android.util.Log;
76 import android.util.NtpTrustedTime;
78 import com.android.internal.app.IAppOpsService;
79 import com.android.internal.app.IBatteryStats;
80 import com.android.internal.location.GpsNetInitiatedHandler;
81 import com.android.internal.location.GpsNetInitiatedHandler.GpsNiNotification;
82 import com.android.internal.location.ProviderProperties;
83 import com.android.internal.location.ProviderRequest;
84 import com.android.server.power.BatterySaverPolicy;
85 import com.android.server.power.BatterySaverPolicy.ServiceType;
87 import libcore.io.IoUtils;
90 import java.io.FileDescriptor;
91 import java.io.FileInputStream;
92 import java.io.IOException;
93 import java.io.PrintWriter;
94 import java.net.InetAddress;
95 import java.net.UnknownHostException;
96 import java.util.ArrayList;
97 import java.util.Arrays;
98 import java.util.Date;
99 import java.util.List;
100 import java.util.Map.Entry;
101 import java.util.Properties;
102 import java.util.Map;
103 import java.util.HashMap;
106 * A GNSS implementation of LocationProvider used by LocationManager.
110 public class GnssLocationProvider implements LocationProviderInterface {
112 private static final String TAG = "GnssLocationProvider";
114 private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
115 private static final boolean VERBOSE = Log.isLoggable(TAG, Log.VERBOSE);
117 private static final ProviderProperties PROPERTIES = new ProviderProperties(
118 true, true, false, false, true, true, true,
119 Criteria.POWER_HIGH, Criteria.ACCURACY_FINE);
121 // these need to match GnssPositionMode enum in IGnss.hal
122 private static final int GPS_POSITION_MODE_STANDALONE = 0;
123 private static final int GPS_POSITION_MODE_MS_BASED = 1;
124 private static final int GPS_POSITION_MODE_MS_ASSISTED = 2;
126 // these need to match GnssPositionRecurrence enum in IGnss.hal
127 private static final int GPS_POSITION_RECURRENCE_PERIODIC = 0;
128 private static final int GPS_POSITION_RECURRENCE_SINGLE = 1;
130 // these need to match GnssStatusValue enum in IGnssCallback.hal
131 private static final int GPS_STATUS_NONE = 0;
132 private static final int GPS_STATUS_SESSION_BEGIN = 1;
133 private static final int GPS_STATUS_SESSION_END = 2;
134 private static final int GPS_STATUS_ENGINE_ON = 3;
135 private static final int GPS_STATUS_ENGINE_OFF = 4;
137 // these need to match AGnssStatusValue enum in IAGnssCallback.hal
138 /** AGPS status event values. */
139 private static final int GPS_REQUEST_AGPS_DATA_CONN = 1;
140 private static final int GPS_RELEASE_AGPS_DATA_CONN = 2;
141 private static final int GPS_AGPS_DATA_CONNECTED = 3;
142 private static final int GPS_AGPS_DATA_CONN_DONE = 4;
143 private static final int GPS_AGPS_DATA_CONN_FAILED = 5;
145 // these need to match GnssLocationFlags enum in types.hal
146 private static final int LOCATION_INVALID = 0;
147 private static final int LOCATION_HAS_LAT_LONG = 1;
148 private static final int LOCATION_HAS_ALTITUDE = 2;
149 private static final int LOCATION_HAS_SPEED = 4;
150 private static final int LOCATION_HAS_BEARING = 8;
151 private static final int LOCATION_HAS_HORIZONTAL_ACCURACY = 16;
152 private static final int LOCATION_HAS_VERTICAL_ACCURACY = 32;
153 private static final int LOCATION_HAS_SPEED_ACCURACY = 64;
154 private static final int LOCATION_HAS_BEARING_ACCURACY = 128;
157 // IMPORTANT - the GPS_DELETE_* symbols here must match GnssAidingData enum in IGnss.hal
158 private static final int GPS_DELETE_EPHEMERIS = 0x0001;
159 private static final int GPS_DELETE_ALMANAC = 0x0002;
160 private static final int GPS_DELETE_POSITION = 0x0004;
161 private static final int GPS_DELETE_TIME = 0x0008;
162 private static final int GPS_DELETE_IONO = 0x0010;
163 private static final int GPS_DELETE_UTC = 0x0020;
164 private static final int GPS_DELETE_HEALTH = 0x0040;
165 private static final int GPS_DELETE_SVDIR = 0x0080;
166 private static final int GPS_DELETE_SVSTEER = 0x0100;
167 private static final int GPS_DELETE_SADATA = 0x0200;
168 private static final int GPS_DELETE_RTI = 0x0400;
169 private static final int GPS_DELETE_CELLDB_INFO = 0x8000;
170 private static final int GPS_DELETE_ALL = 0xFFFF;
172 // The GPS_CAPABILITY_* flags must match Capabilities enum in IGnssCallback.hal
173 private static final int GPS_CAPABILITY_SCHEDULING = 0x0000001;
174 private static final int GPS_CAPABILITY_MSB = 0x0000002;
175 private static final int GPS_CAPABILITY_MSA = 0x0000004;
176 private static final int GPS_CAPABILITY_SINGLE_SHOT = 0x0000008;
177 private static final int GPS_CAPABILITY_ON_DEMAND_TIME = 0x0000010;
178 private static final int GPS_CAPABILITY_GEOFENCING = 0x0000020;
179 private static final int GPS_CAPABILITY_MEASUREMENTS = 0x0000040;
180 private static final int GPS_CAPABILITY_NAV_MESSAGES = 0x0000080;
182 // The AGPS SUPL mode
183 private static final int AGPS_SUPL_MODE_MSA = 0x02;
184 private static final int AGPS_SUPL_MODE_MSB = 0x01;
186 // these need to match AGnssType enum in IAGnssCallback.hal
187 private static final int AGPS_TYPE_SUPL = 1;
188 private static final int AGPS_TYPE_C2K = 2;
190 // these must match the ApnIpType enum in IAGnss.hal
191 private static final int APN_INVALID = 0;
192 private static final int APN_IPV4 = 1;
193 private static final int APN_IPV6 = 2;
194 private static final int APN_IPV4V6 = 3;
196 // for mAGpsDataConnectionState
197 private static final int AGPS_DATA_CONNECTION_CLOSED = 0;
198 private static final int AGPS_DATA_CONNECTION_OPENING = 1;
199 private static final int AGPS_DATA_CONNECTION_OPEN = 2;
202 private static final int CHECK_LOCATION = 1;
203 private static final int ENABLE = 2;
204 private static final int SET_REQUEST = 3;
205 private static final int UPDATE_NETWORK_STATE = 4;
206 private static final int INJECT_NTP_TIME = 5;
207 private static final int DOWNLOAD_XTRA_DATA = 6;
208 private static final int UPDATE_LOCATION = 7;
209 private static final int ADD_LISTENER = 8;
210 private static final int REMOVE_LISTENER = 9;
211 private static final int INJECT_NTP_TIME_FINISHED = 10;
212 private static final int DOWNLOAD_XTRA_DATA_FINISHED = 11;
213 private static final int SUBSCRIPTION_OR_SIM_CHANGED = 12;
214 private static final int INITIALIZE_HANDLER = 13;
215 private static final int REQUEST_SUPL_CONNECTION = 14;
216 private static final int RELEASE_SUPL_CONNECTION = 15;
219 private static final int AGPS_RIL_REQUEST_SETID_IMSI = 1;
220 private static final int AGPS_RIL_REQUEST_SETID_MSISDN = 2;
222 //TODO(b/33112647): Create gps_debug.conf with commented career parameters.
223 private static final String DEBUG_PROPERTIES_FILE = "/etc/gps_debug.conf";
225 // ref. location info
226 private static final int AGPS_REF_LOCATION_TYPE_GSM_CELLID = 1;
227 private static final int AGPS_REF_LOCATION_TYPE_UMTS_CELLID = 2;
230 private static final int AGPS_SETID_TYPE_NONE = 0;
231 private static final int AGPS_SETID_TYPE_IMSI = 1;
232 private static final int AGPS_SETID_TYPE_MSISDN = 2;
234 private static final int GPS_GEOFENCE_UNAVAILABLE = 1<<0L;
235 private static final int GPS_GEOFENCE_AVAILABLE = 1<<1L;
237 // GPS Geofence errors. Should match GeofenceStatus enum in IGnssGeofenceCallback.hal.
238 private static final int GPS_GEOFENCE_OPERATION_SUCCESS = 0;
239 private static final int GPS_GEOFENCE_ERROR_TOO_MANY_GEOFENCES = 100;
240 private static final int GPS_GEOFENCE_ERROR_ID_EXISTS = -101;
241 private static final int GPS_GEOFENCE_ERROR_ID_UNKNOWN = -102;
242 private static final int GPS_GEOFENCE_ERROR_INVALID_TRANSITION = -103;
243 private static final int GPS_GEOFENCE_ERROR_GENERIC = -149;
246 // Valid TCP/UDP port range is (0, 65535].
247 private static final int TCP_MIN_PORT = 0;
248 private static final int TCP_MAX_PORT = 0xffff;
250 /** simpler wrapper for ProviderRequest + Worksource */
251 private static class GpsRequest {
252 public ProviderRequest request;
253 public WorkSource source;
254 public GpsRequest(ProviderRequest request, WorkSource source) {
255 this.request = request;
256 this.source = source;
260 private Object mLock = new Object();
263 private int mStatus = LocationProvider.TEMPORARILY_UNAVAILABLE;
265 // time for last status update
266 private long mStatusUpdateTime = SystemClock.elapsedRealtime();
268 // turn off GPS fix icon if we haven't received a fix in 10 seconds
269 private static final long RECENT_FIX_TIMEOUT = 10 * 1000;
271 // stop trying if we do not receive a fix within 60 seconds
272 private static final int NO_FIX_TIMEOUT = 60 * 1000;
274 // if the fix interval is below this we leave GPS on,
275 // if above then we cycle the GPS driver.
276 // Typical hot TTTF is ~5 seconds, so 10 seconds seems sane.
277 private static final int GPS_POLLING_THRESHOLD_INTERVAL = 10 * 1000;
279 // how often to request NTP time, in milliseconds
280 // current setting 24 hours
281 private static final long NTP_INTERVAL = 24*60*60*1000;
282 // how long to wait if we have a network error in NTP or XTRA downloading
283 // the initial value of the exponential backoff
284 // current setting - 5 minutes
285 private static final long RETRY_INTERVAL = 5*60*1000;
286 // how long to wait if we have a network error in NTP or XTRA downloading
287 // the max value of the exponential backoff
288 // current setting - 4 hours
289 private static final long MAX_RETRY_INTERVAL = 4*60*60*1000;
291 // Timeout when holding wakelocks for downloading XTRA data.
292 private static final long DOWNLOAD_XTRA_DATA_TIMEOUT_MS = 60 * 1000;
294 private BackOff mNtpBackOff = new BackOff(RETRY_INTERVAL, MAX_RETRY_INTERVAL);
295 private BackOff mXtraBackOff = new BackOff(RETRY_INTERVAL, MAX_RETRY_INTERVAL);
297 // true if we are enabled, protected by this
298 private boolean mEnabled;
300 // states for injecting ntp and downloading xtra data
301 private static final int STATE_PENDING_NETWORK = 0;
302 private static final int STATE_DOWNLOADING = 1;
303 private static final int STATE_IDLE = 2;
305 // flags to trigger NTP or XTRA data download when network becomes available
306 // initialized to true so we do NTP and XTRA when the network comes up after booting
307 private int mInjectNtpTimePending = STATE_PENDING_NETWORK;
308 private int mDownloadXtraDataPending = STATE_PENDING_NETWORK;
310 // set to true if the GPS engine requested on-demand NTP time requests
311 private boolean mOnDemandTimeInjection;
313 // true if GPS is navigating
314 private boolean mNavigating;
316 // true if GPS engine is on
317 private boolean mEngineOn;
319 // requested frequency of fixes, in milliseconds
320 private int mFixInterval = 1000;
322 // true if we started navigation
323 private boolean mStarted;
325 // true if single shot request is in progress
326 private boolean mSingleShot;
328 // capabilities of the GPS engine
329 private int mEngineCapabilities;
331 // true if XTRA is supported
332 private boolean mSupportsXtra;
334 // for calculating time to first fix
335 private long mFixRequestTime = 0;
336 // time to first fix for most recent session
337 private int mTimeToFirstFix = 0;
338 // time we received our last fix
339 private long mLastFixTime;
341 private int mPositionMode;
343 // Current request from underlying location clients.
344 private ProviderRequest mProviderRequest = null;
345 // Current list of underlying location clients.
346 private WorkSource mWorkSource = null;
347 // True if gps should be disabled (used to support battery saver mode in settings).
348 private boolean mDisableGps = false;
351 * Properties loaded from PROPERTIES_FILE.
352 * It must be accessed only inside {@link #mHandler}.
354 private Properties mProperties;
356 private String mSuplServerHost;
357 private int mSuplServerPort = TCP_MIN_PORT;
358 private String mC2KServerHost;
359 private int mC2KServerPort;
360 private boolean mSuplEsEnabled = false;
362 private final Context mContext;
363 private final NtpTrustedTime mNtpTime;
364 private final ILocationManager mILocationManager;
365 private Location mLocation = new Location(LocationManager.GPS_PROVIDER);
366 private Bundle mLocationExtras = new Bundle();
367 private final GnssStatusListenerHelper mListenerHelper;
368 private final GnssMeasurementsProvider mGnssMeasurementsProvider;
369 private final GnssNavigationMessageProvider mGnssNavigationMessageProvider;
371 // Handler for processing events
372 private Handler mHandler;
374 /** It must be accessed only inside {@link #mHandler}. */
375 private int mAGpsDataConnectionState;
376 /** It must be accessed only inside {@link #mHandler}. */
377 private InetAddress mAGpsDataConnectionIpAddr;
379 private final ConnectivityManager mConnMgr;
380 private final GpsNetInitiatedHandler mNIHandler;
383 private final static String WAKELOCK_KEY = "GnssLocationProvider";
384 private final PowerManager.WakeLock mWakeLock;
385 private static final String DOWNLOAD_EXTRA_WAKELOCK_KEY = "GnssLocationProviderXtraDownload";
386 private final PowerManager.WakeLock mDownloadXtraWakeLock;
389 private final static String ALARM_WAKEUP = "com.android.internal.location.ALARM_WAKEUP";
390 private final static String ALARM_TIMEOUT = "com.android.internal.location.ALARM_TIMEOUT";
393 private final static String SIM_STATE_CHANGED = "android.intent.action.SIM_STATE_CHANGED";
395 // Persist property for LPP_PROFILE
396 private final static String LPP_PROFILE = "persist.sys.gps.lpp";
400 private final PowerManager mPowerManager;
401 private final AlarmManager mAlarmManager;
402 private final PendingIntent mWakeupIntent;
403 private final PendingIntent mTimeoutIntent;
405 private final IAppOpsService mAppOpsService;
406 private final IBatteryStats mBatteryStats;
408 // only modified on handler thread
409 private WorkSource mClientSource = new WorkSource();
411 private GeofenceHardwareImpl mGeofenceHardwareImpl;
412 private int mYearOfHardware = 0;
414 // Set lower than the current ITAR limit of 600m/s to allow this to trigger even if GPS HAL
415 // stops output right at 600m/s, depriving this of the information of a device that reaches
416 // greater than 600m/s, and higher than the speed of sound to avoid impacting most use cases.
417 private static final float ITAR_SPEED_LIMIT_METERS_PER_SECOND = 400.0F;
418 private boolean mItarSpeedLimitExceeded = false;
420 private final IGnssStatusProvider mGnssStatusProvider = new IGnssStatusProvider.Stub() {
422 public void registerGnssStatusCallback(IGnssStatusListener callback) {
423 mListenerHelper.addListener(callback);
427 public void unregisterGnssStatusCallback(IGnssStatusListener callback) {
428 mListenerHelper.removeListener(callback);
432 public IGnssStatusProvider getGnssStatusProvider() {
433 return mGnssStatusProvider;
436 public IGpsGeofenceHardware getGpsGeofenceProxy() {
437 return mGpsGeofenceBinder;
440 public GnssMeasurementsProvider getGnssMeasurementsProvider() {
441 return mGnssMeasurementsProvider;
444 public GnssNavigationMessageProvider getGnssNavigationMessageProvider() {
445 return mGnssNavigationMessageProvider;
449 * Callback used to listen for data connectivity changes.
451 private final ConnectivityManager.NetworkCallback mNetworkConnectivityCallback =
452 new ConnectivityManager.NetworkCallback() {
454 public void onAvailable(Network network) {
455 if (mInjectNtpTimePending == STATE_PENDING_NETWORK) {
458 if (mDownloadXtraDataPending == STATE_PENDING_NETWORK) {
459 xtraDownloadRequest();
461 // Always on, notify HAL so it can get data it needs
462 sendMessage(UPDATE_NETWORK_STATE, 0 /*arg*/, network);
467 * Callback used to listen for availability of a requested SUPL connection.
468 * It is kept as a separate instance from {@link #mNetworkConnectivityCallback} to be able to
469 * manage the registration/un-registration lifetimes separate.
471 private final ConnectivityManager.NetworkCallback mSuplConnectivityCallback =
472 new ConnectivityManager.NetworkCallback() {
474 public void onAvailable(Network network) {
475 // Specific to a change to a SUPL enabled network becoming ready
476 sendMessage(UPDATE_NETWORK_STATE, 0 /*arg*/, network);
480 public void onLost(Network network) {
481 releaseSuplConnection(GPS_RELEASE_AGPS_DATA_CONN);
485 private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
486 @Override public void onReceive(Context context, Intent intent) {
487 String action = intent.getAction();
488 if (DEBUG) Log.d(TAG, "receive broadcast intent, action: " + action);
489 if (action == null) {
493 if (action.equals(ALARM_WAKEUP)) {
494 startNavigating(false);
495 } else if (action.equals(ALARM_TIMEOUT)) {
497 } else if (PowerManager.ACTION_POWER_SAVE_MODE_CHANGED.equals(action)
498 || PowerManager.ACTION_DEVICE_IDLE_MODE_CHANGED.equals(action)
499 || Intent.ACTION_SCREEN_OFF.equals(action)
500 || Intent.ACTION_SCREEN_ON.equals(action)) {
501 updateLowPowerMode();
502 } else if (action.equals(SIM_STATE_CHANGED)) {
503 subscriptionOrSimChanged(context);
508 private final OnSubscriptionsChangedListener mOnSubscriptionsChangedListener =
509 new OnSubscriptionsChangedListener() {
511 public void onSubscriptionsChanged() {
512 sendMessage(SUBSCRIPTION_OR_SIM_CHANGED, 0, null);
516 private void subscriptionOrSimChanged(Context context) {
517 if (DEBUG) Log.d(TAG, "received SIM related action: ");
518 TelephonyManager phone = (TelephonyManager)
519 mContext.getSystemService(Context.TELEPHONY_SERVICE);
520 CarrierConfigManager configManager = (CarrierConfigManager)
521 mContext.getSystemService(Context.CARRIER_CONFIG_SERVICE);
522 String mccMnc = phone.getSimOperator();
523 boolean isKeepLppProfile = false;
524 if (!TextUtils.isEmpty(mccMnc)) {
525 if (DEBUG) Log.d(TAG, "SIM MCC/MNC is available: " + mccMnc);
526 synchronized (mLock) {
527 if (configManager != null) {
528 PersistableBundle b = configManager.getConfig();
529 isKeepLppProfile = b.getBoolean(CarrierConfigManager.KEY_PERSIST_LPP_MODE_BOOL);
531 if (isKeepLppProfile) {
532 // load current properties for the carrier
533 loadPropertiesFromResource(context, mProperties);
534 String lpp_profile = mProperties.getProperty("LPP_PROFILE");
535 // set the persist property LPP_PROFILE for the value
536 SystemProperties.set(LPP_PROFILE, lpp_profile);
538 // reset the persist property
539 SystemProperties.set(LPP_PROFILE, "");
541 reloadGpsProperties(context, mProperties);
542 mNIHandler.setSuplEsEnabled(mSuplEsEnabled);
545 if (DEBUG) Log.d(TAG, "SIM MCC/MNC is still not available");
549 private void updateLowPowerMode() {
550 // Disable GPS if we are in device idle mode.
551 boolean disableGps = mPowerManager.isDeviceIdleMode();
552 final PowerSaveState result =
553 mPowerManager.getPowerSaveState(ServiceType.GPS);
554 switch (result.gpsMode) {
555 case BatterySaverPolicy.GPS_MODE_DISABLED_WHEN_SCREEN_OFF:
556 // If we are in battery saver mode and the screen is off, disable GPS.
557 disableGps |= result.batterySaverEnabled && !mPowerManager.isInteractive();
560 if (disableGps != mDisableGps) {
561 mDisableGps = disableGps;
562 updateRequirements();
566 public static boolean isSupported() {
567 return native_is_supported();
570 interface SetCarrierProperty {
571 public boolean set(int value);
574 private void reloadGpsProperties(Context context, Properties properties) {
575 if (DEBUG) Log.d(TAG, "Reset GPS properties, previous size = " + properties.size());
576 loadPropertiesFromResource(context, properties);
578 String lpp_prof = SystemProperties.get(LPP_PROFILE);
579 if (!TextUtils.isEmpty(lpp_prof)) {
580 // override default value of this if lpp_prof is not empty
581 properties.setProperty("LPP_PROFILE", lpp_prof);
584 * Overlay carrier properties from a debug configuration file.
586 loadPropertiesFromFile(DEBUG_PROPERTIES_FILE, properties);
587 // TODO: we should get rid of C2K specific setting.
588 setSuplHostPort(properties.getProperty("SUPL_HOST"),
589 properties.getProperty("SUPL_PORT"));
590 mC2KServerHost = properties.getProperty("C2K_HOST");
591 String portString = properties.getProperty("C2K_PORT");
592 if (mC2KServerHost != null && portString != null) {
594 mC2KServerPort = Integer.parseInt(portString);
595 } catch (NumberFormatException e) {
596 Log.e(TAG, "unable to parse C2K_PORT: " + portString);
599 if (native_is_gnss_configuration_supported()) {
600 Map<String, SetCarrierProperty> map = new HashMap<String, SetCarrierProperty>() {
602 put("SUPL_VER", (val) -> native_set_supl_version(val));
603 put("SUPL_MODE", (val) -> native_set_supl_mode(val));
604 put("SUPL_ES", (val) -> native_set_supl_es(val));
605 put("LPP_PROFILE", (val) -> native_set_lpp_profile(val));
606 put("A_GLONASS_POS_PROTOCOL_SELECT", (val) -> native_set_gnss_pos_protocol_select(val));
607 put("USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL", (val) -> native_set_emergency_supl_pdn(val));
608 put("GPS_LOCK", (val) -> native_set_gps_lock(val));
612 for(Entry<String, SetCarrierProperty> entry : map.entrySet()) {
613 String propertyName = entry.getKey();
614 String propertyValueString = properties.getProperty(propertyName);
615 if (propertyValueString != null) {
617 int propertyValueInt = Integer.decode(propertyValueString);
618 boolean result = entry.getValue().set(propertyValueInt);
619 if (result == false) {
620 Log.e(TAG, "Unable to set " + propertyName);
622 } catch (NumberFormatException e) {
623 Log.e(TAG, "unable to parse propertyName: " + propertyValueString);
628 Log.d(TAG, "Skipped configuration update because GNSS configuration in GPS HAL is not"
632 // SUPL_ES configuration.
633 String suplESProperty = mProperties.getProperty("SUPL_ES");
634 if (suplESProperty != null) {
636 mSuplEsEnabled = (Integer.parseInt(suplESProperty) == 1);
637 } catch (NumberFormatException e) {
638 Log.e(TAG, "unable to parse SUPL_ES: " + suplESProperty);
643 private void loadPropertiesFromResource(Context context,
644 Properties properties) {
645 String[] configValues = context.getResources().getStringArray(
646 com.android.internal.R.array.config_gpsParameters);
647 for (String item : configValues) {
648 if (DEBUG) Log.d(TAG, "GpsParamsResource: " + item);
649 // We need to support "KEY =", but not "=VALUE".
650 String[] split = item.split("=");
651 if (split.length == 2) {
652 properties.setProperty(split[0].trim().toUpperCase(), split[1]);
654 Log.w(TAG, "malformed contents: " + item);
659 private boolean loadPropertiesFromFile(String filename,
660 Properties properties) {
662 File file = new File(filename);
663 FileInputStream stream = null;
665 stream = new FileInputStream(file);
666 properties.load(stream);
668 IoUtils.closeQuietly(stream);
671 } catch (IOException e) {
672 if (DEBUG) Log.d(TAG, "Could not open GPS configuration file " + filename);
678 public GnssLocationProvider(Context context, ILocationManager ilocationManager,
681 mNtpTime = NtpTrustedTime.getInstance(context);
682 mILocationManager = ilocationManager;
684 mLocation.setExtras(mLocationExtras);
686 // Create a wake lock
687 mPowerManager = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
688 mWakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKELOCK_KEY);
689 mWakeLock.setReferenceCounted(true);
691 // Create a separate wake lock for xtra downloader as it may be released due to timeout.
692 mDownloadXtraWakeLock = mPowerManager.newWakeLock(
693 PowerManager.PARTIAL_WAKE_LOCK, DOWNLOAD_EXTRA_WAKELOCK_KEY);
694 mDownloadXtraWakeLock.setReferenceCounted(true);
696 mAlarmManager = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE);
697 mWakeupIntent = PendingIntent.getBroadcast(mContext, 0, new Intent(ALARM_WAKEUP), 0);
698 mTimeoutIntent = PendingIntent.getBroadcast(mContext, 0, new Intent(ALARM_TIMEOUT), 0);
700 mConnMgr = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);
702 // App ops service to keep track of who is accessing the GPS
703 mAppOpsService = IAppOpsService.Stub.asInterface(ServiceManager.getService(
704 Context.APP_OPS_SERVICE));
706 // Battery statistics service to be notified when GPS turns on or off
707 mBatteryStats = IBatteryStats.Stub.asInterface(ServiceManager.getService(
708 BatteryStats.SERVICE_NAME));
710 // Construct internal handler
711 mHandler = new ProviderHandler(looper);
713 // Load GPS configuration and register listeners in the background:
714 // some operations, such as opening files and registering broadcast receivers, can take a
715 // relative long time, so the ctor() is kept to create objects needed by this instance,
716 // while IO initialization and registration is delegated to our internal handler
717 // this approach is just fine because events are posted to our handler anyway
718 mProperties = new Properties();
719 sendMessage(INITIALIZE_HANDLER, 0, null);
721 // Create a GPS net-initiated handler.
722 mNIHandler = new GpsNetInitiatedHandler(context,
723 mNetInitiatedListener,
726 mListenerHelper = new GnssStatusListenerHelper(mHandler) {
728 protected boolean isAvailableInPlatform() {
729 return isSupported();
733 protected boolean isGpsEnabled() {
738 mGnssMeasurementsProvider = new GnssMeasurementsProvider(mHandler) {
740 public boolean isAvailableInPlatform() {
741 return native_is_measurement_supported();
745 protected boolean registerWithService() {
746 return native_start_measurement_collection();
750 protected void unregisterFromService() {
751 native_stop_measurement_collection();
755 protected boolean isGpsEnabled() {
760 mGnssNavigationMessageProvider = new GnssNavigationMessageProvider(mHandler) {
762 protected boolean isAvailableInPlatform() {
763 return native_is_navigation_message_supported();
767 protected boolean registerWithService() {
768 return native_start_navigation_message_collection();
772 protected void unregisterFromService() {
773 native_stop_navigation_message_collection();
777 protected boolean isGpsEnabled() {
783 * A cycle of native_init() and native_cleanup() is needed so that callbacks are registered
784 * after bootup even when location is disabled. This will allow Emergency SUPL to work even
785 * when location is disabled before device restart.
787 boolean isInitialized = native_init();
789 Log.d(TAG, "Failed to initialize at bootup");
796 * Returns the name of this provider.
799 public String getName() {
800 return LocationManager.GPS_PROVIDER;
804 public ProviderProperties getProperties() {
808 private void handleUpdateNetworkState(Network network) {
809 // retrieve NetworkInfo for this UID
810 NetworkInfo info = mConnMgr.getNetworkInfo(network);
815 boolean isConnected = info.isConnected();
817 String message = String.format(
818 "UpdateNetworkState, state=%s, connected=%s, info=%s, capabilities=%S",
819 agpsDataConnStateAsString(),
822 mConnMgr.getNetworkCapabilities(network));
826 if (native_is_agps_ril_supported()) {
827 boolean dataEnabled = TelephonyManager.getDefault().getDataEnabled();
828 boolean networkAvailable = info.isAvailable() && dataEnabled;
829 String defaultApn = getSelectedApn();
830 if (defaultApn == null) {
831 defaultApn = "dummy-apn";
834 native_update_network_state(
842 Log.d(TAG, "Skipped network state update because GPS HAL AGPS-RIL is not supported");
845 if (mAGpsDataConnectionState == AGPS_DATA_CONNECTION_OPENING) {
847 String apnName = info.getExtraInfo();
848 if (apnName == null) {
849 // assign a dummy value in the case of C2K as otherwise we will have a runtime
850 // exception in the following call to native_agps_data_conn_open
851 apnName = "dummy-apn";
853 int apnIpType = getApnIpType(apnName);
856 String message = String.format(
857 "native_agps_data_conn_open: mAgpsApn=%s, mApnIpType=%s",
862 native_agps_data_conn_open(apnName, apnIpType);
863 mAGpsDataConnectionState = AGPS_DATA_CONNECTION_OPEN;
865 handleReleaseSuplConnection(GPS_AGPS_DATA_CONN_FAILED);
870 private void handleRequestSuplConnection(InetAddress address) {
872 String message = String.format(
873 "requestSuplConnection, state=%s, address=%s",
874 agpsDataConnStateAsString(),
879 if (mAGpsDataConnectionState != AGPS_DATA_CONNECTION_CLOSED) {
882 mAGpsDataConnectionIpAddr = address;
883 mAGpsDataConnectionState = AGPS_DATA_CONNECTION_OPENING;
885 NetworkRequest.Builder requestBuilder = new NetworkRequest.Builder();
886 requestBuilder.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR);
887 requestBuilder.addCapability(NetworkCapabilities.NET_CAPABILITY_SUPL);
888 NetworkRequest request = requestBuilder.build();
889 mConnMgr.requestNetwork(
891 mSuplConnectivityCallback);
894 private void handleReleaseSuplConnection(int agpsDataConnStatus) {
896 String message = String.format(
897 "releaseSuplConnection, state=%s, status=%s",
898 agpsDataConnStateAsString(),
899 agpsDataConnStatusAsString(agpsDataConnStatus));
903 if (mAGpsDataConnectionState == AGPS_DATA_CONNECTION_CLOSED) {
906 mAGpsDataConnectionState = AGPS_DATA_CONNECTION_CLOSED;
908 mConnMgr.unregisterNetworkCallback(mSuplConnectivityCallback);
909 switch (agpsDataConnStatus) {
910 case GPS_AGPS_DATA_CONN_FAILED:
911 native_agps_data_conn_failed();
913 case GPS_RELEASE_AGPS_DATA_CONN:
914 native_agps_data_conn_closed();
917 Log.e(TAG, "Invalid status to release SUPL connection: " + agpsDataConnStatus);
921 private void handleInjectNtpTime() {
922 if (mInjectNtpTimePending == STATE_DOWNLOADING) {
923 // already downloading data
926 if (!isDataNetworkConnected()) {
927 // try again when network is up
928 mInjectNtpTimePending = STATE_PENDING_NETWORK;
931 mInjectNtpTimePending = STATE_DOWNLOADING;
933 // hold wake lock while task runs
935 Log.i(TAG, "WakeLock acquired by handleInjectNtpTime()");
936 AsyncTask.THREAD_POOL_EXECUTOR.execute(new Runnable() {
941 // force refresh NTP cache when outdated
942 boolean refreshSuccess = true;
943 if (mNtpTime.getCacheAge() >= NTP_INTERVAL) {
944 refreshSuccess = mNtpTime.forceRefresh();
947 // only update when NTP time is fresh
948 if (mNtpTime.getCacheAge() < NTP_INTERVAL) {
949 long time = mNtpTime.getCachedNtpTime();
950 long timeReference = mNtpTime.getCachedNtpTimeReference();
951 long certainty = mNtpTime.getCacheCertainty();
954 long now = System.currentTimeMillis();
955 Log.d(TAG, "NTP server returned: "
956 + time + " (" + new Date(time)
957 + ") reference: " + timeReference
958 + " certainty: " + certainty
959 + " system time offset: " + (time - now));
962 native_inject_time(time, timeReference, (int) certainty);
963 delay = NTP_INTERVAL;
966 Log.e(TAG, "requestTime failed");
967 delay = mNtpBackOff.nextBackoffMillis();
970 sendMessage(INJECT_NTP_TIME_FINISHED, 0, null);
973 String message = String.format(
974 "onDemandTimeInjection=%s, refreshSuccess=%s, delay=%s",
975 mOnDemandTimeInjection,
980 if (mOnDemandTimeInjection || !refreshSuccess) {
981 // send delayed message for next NTP injection
982 // since this is delayed and not urgent we do not hold a wake lock here
983 mHandler.sendEmptyMessageDelayed(INJECT_NTP_TIME, delay);
986 // release wake lock held by task
988 Log.i(TAG, "WakeLock released by handleInjectNtpTime()");
993 private void handleDownloadXtraData() {
994 if (!mSupportsXtra) {
995 // native code reports xtra not supported, don't try
996 Log.d(TAG, "handleDownloadXtraData() called when Xtra not supported");
999 if (mDownloadXtraDataPending == STATE_DOWNLOADING) {
1000 // already downloading data
1003 if (!isDataNetworkConnected()) {
1004 // try again when network is up
1005 mDownloadXtraDataPending = STATE_PENDING_NETWORK;
1008 mDownloadXtraDataPending = STATE_DOWNLOADING;
1010 // hold wake lock while task runs
1011 mDownloadXtraWakeLock.acquire(DOWNLOAD_XTRA_DATA_TIMEOUT_MS);
1012 Log.i(TAG, "WakeLock acquired by handleDownloadXtraData()");
1013 AsyncTask.THREAD_POOL_EXECUTOR.execute(new Runnable() {
1016 GpsXtraDownloader xtraDownloader = new GpsXtraDownloader(mProperties);
1017 byte[] data = xtraDownloader.downloadXtraData();
1019 if (DEBUG) Log.d(TAG, "calling native_inject_xtra_data");
1020 native_inject_xtra_data(data, data.length);
1021 mXtraBackOff.reset();
1024 sendMessage(DOWNLOAD_XTRA_DATA_FINISHED, 0, null);
1028 // since this is delayed and not urgent we do not hold a wake lock here
1029 mHandler.sendEmptyMessageDelayed(DOWNLOAD_XTRA_DATA,
1030 mXtraBackOff.nextBackoffMillis());
1033 // Release wake lock held by task, synchronize on mLock in case multiple
1034 // download tasks overrun.
1035 synchronized (mLock) {
1036 if (mDownloadXtraWakeLock.isHeld()) {
1037 mDownloadXtraWakeLock.release();
1038 if (DEBUG) Log.d(TAG, "WakeLock released by handleDownloadXtraData()");
1040 Log.e(TAG, "WakeLock expired before release in "
1041 + "handleDownloadXtraData()");
1048 private void handleUpdateLocation(Location location) {
1049 if (location.hasAccuracy()) {
1050 native_inject_location(location.getLatitude(), location.getLongitude(),
1051 location.getAccuracy());
1056 * Enables this provider. When enabled, calls to getStatus()
1057 * must be handled. Hardware may be started up
1058 * when the provider is enabled.
1061 public void enable() {
1062 synchronized (mLock) {
1063 if (mEnabled) return;
1067 sendMessage(ENABLE, 1, null);
1070 private void setSuplHostPort(String hostString, String portString) {
1071 if (hostString != null) {
1072 mSuplServerHost = hostString;
1074 if (portString != null) {
1076 mSuplServerPort = Integer.parseInt(portString);
1077 } catch (NumberFormatException e) {
1078 Log.e(TAG, "unable to parse SUPL_PORT: " + portString);
1081 if (mSuplServerHost != null
1082 && mSuplServerPort > TCP_MIN_PORT
1083 && mSuplServerPort <= TCP_MAX_PORT) {
1084 native_set_agps_server(AGPS_TYPE_SUPL, mSuplServerHost, mSuplServerPort);
1089 * Checks what SUPL mode to use, according to the AGPS mode as well as the
1090 * allowed mode from properties.
1092 * @param properties GPS properties
1093 * @param agpsEnabled whether AGPS is enabled by settings value
1094 * @param singleShot whether "singleshot" is needed
1095 * @return SUPL mode (MSA vs MSB vs STANDALONE)
1097 private int getSuplMode(Properties properties, boolean agpsEnabled, boolean singleShot) {
1099 String modeString = properties.getProperty("SUPL_MODE");
1101 if (!TextUtils.isEmpty(modeString)) {
1103 suplMode = Integer.parseInt(modeString);
1104 } catch (NumberFormatException e) {
1105 Log.e(TAG, "unable to parse SUPL_MODE: " + modeString);
1106 return GPS_POSITION_MODE_STANDALONE;
1109 // MS-Based is the preferred mode for Assisted-GPS position computation, so we favor
1110 // such mode when it is available
1111 if (hasCapability(GPS_CAPABILITY_MSB) && (suplMode & AGPS_SUPL_MODE_MSB) != 0) {
1112 return GPS_POSITION_MODE_MS_BASED;
1114 // for now, just as the legacy code did, we fallback to MS-Assisted if it is available,
1115 // do fallback only for single-shot requests, because it is too expensive to do for
1116 // periodic requests as well
1118 && hasCapability(GPS_CAPABILITY_MSA)
1119 && (suplMode & AGPS_SUPL_MODE_MSA) != 0) {
1120 return GPS_POSITION_MODE_MS_ASSISTED;
1123 return GPS_POSITION_MODE_STANDALONE;
1126 private void handleEnable() {
1127 if (DEBUG) Log.d(TAG, "handleEnable");
1129 boolean enabled = native_init();
1132 mSupportsXtra = native_supports_xtra();
1134 // TODO: remove the following native calls if we can make sure they are redundant.
1135 if (mSuplServerHost != null) {
1136 native_set_agps_server(AGPS_TYPE_SUPL, mSuplServerHost, mSuplServerPort);
1138 if (mC2KServerHost != null) {
1139 native_set_agps_server(AGPS_TYPE_C2K, mC2KServerHost, mC2KServerPort);
1142 mGnssMeasurementsProvider.onGpsEnabledChanged();
1143 mGnssNavigationMessageProvider.onGpsEnabledChanged();
1146 synchronized (mLock) {
1149 Log.w(TAG, "Failed to enable location provider");
1154 * Disables this provider. When disabled, calls to getStatus()
1155 * need not be handled. Hardware may be shut
1156 * down while the provider is disabled.
1159 public void disable() {
1160 synchronized (mLock) {
1161 if (!mEnabled) return;
1165 sendMessage(ENABLE, 0, null);
1168 private void handleDisable() {
1169 if (DEBUG) Log.d(TAG, "handleDisable");
1171 updateClientUids(new WorkSource());
1173 mAlarmManager.cancel(mWakeupIntent);
1174 mAlarmManager.cancel(mTimeoutIntent);
1177 // do this before releasing wakelock
1180 mGnssMeasurementsProvider.onGpsEnabledChanged();
1181 mGnssNavigationMessageProvider.onGpsEnabledChanged();
1185 public boolean isEnabled() {
1186 synchronized (mLock) {
1192 public int getStatus(Bundle extras) {
1193 if (extras != null) {
1194 extras.putInt("satellites", mSvCount);
1199 private void updateStatus(int status, int svCount) {
1200 if (status != mStatus || svCount != mSvCount) {
1203 mLocationExtras.putInt("satellites", svCount);
1204 mStatusUpdateTime = SystemClock.elapsedRealtime();
1209 public long getStatusUpdateTime() {
1210 return mStatusUpdateTime;
1214 public void setRequest(ProviderRequest request, WorkSource source) {
1215 sendMessage(SET_REQUEST, 0, new GpsRequest(request, source));
1218 private void handleSetRequest(ProviderRequest request, WorkSource source) {
1219 mProviderRequest = request;
1220 mWorkSource = source;
1221 updateRequirements();
1224 // Called when the requirements for GPS may have changed
1225 private void updateRequirements() {
1226 if (mProviderRequest == null || mWorkSource == null) {
1230 boolean singleShot = false;
1232 // see if the request is for a single update
1233 if (mProviderRequest.locationRequests != null
1234 && mProviderRequest.locationRequests.size() > 0) {
1235 // if any request has zero or more than one updates
1236 // requested, then this is not single-shot mode
1239 for (LocationRequest lr : mProviderRequest.locationRequests) {
1240 if (lr.getNumUpdates() != 1) {
1246 if (DEBUG) Log.d(TAG, "setRequest " + mProviderRequest);
1247 if (mProviderRequest.reportLocation && !mDisableGps && isEnabled()) {
1248 // update client uids
1249 updateClientUids(mWorkSource);
1251 mFixInterval = (int) mProviderRequest.interval;
1253 // check for overflow
1254 if (mFixInterval != mProviderRequest.interval) {
1255 Log.w(TAG, "interval overflow: " + mProviderRequest.interval);
1256 mFixInterval = Integer.MAX_VALUE;
1259 // apply request to GPS engine
1260 if (mStarted && hasCapability(GPS_CAPABILITY_SCHEDULING)) {
1262 if (!native_set_position_mode(mPositionMode, GPS_POSITION_RECURRENCE_PERIODIC,
1263 mFixInterval, 0, 0)) {
1264 Log.e(TAG, "set_position_mode failed in setMinTime()");
1266 } else if (!mStarted) {
1268 startNavigating(singleShot);
1271 updateClientUids(new WorkSource());
1274 mAlarmManager.cancel(mWakeupIntent);
1275 mAlarmManager.cancel(mTimeoutIntent);
1279 private void updateClientUids(WorkSource source) {
1280 // Update work source.
1281 WorkSource[] changes = mClientSource.setReturningDiffs(source);
1282 if (changes == null) {
1285 WorkSource newWork = changes[0];
1286 WorkSource goneWork = changes[1];
1288 // Update sources that were not previously tracked.
1289 if (newWork != null) {
1291 for (int i=0; i<newWork.size(); i++) {
1293 int uid = newWork.get(i);
1294 mAppOpsService.startOperation(AppOpsManager.getToken(mAppOpsService),
1295 AppOpsManager.OP_GPS, uid, newWork.getName(i));
1296 if (uid != lastuid) {
1298 mBatteryStats.noteStartGps(uid);
1300 } catch (RemoteException e) {
1301 Log.w(TAG, "RemoteException", e);
1306 // Update sources that are no longer tracked.
1307 if (goneWork != null) {
1309 for (int i=0; i<goneWork.size(); i++) {
1311 int uid = goneWork.get(i);
1312 mAppOpsService.finishOperation(AppOpsManager.getToken(mAppOpsService),
1313 AppOpsManager.OP_GPS, uid, goneWork.getName(i));
1314 if (uid != lastuid) {
1316 mBatteryStats.noteStopGps(uid);
1318 } catch (RemoteException e) {
1319 Log.w(TAG, "RemoteException", e);
1326 public boolean sendExtraCommand(String command, Bundle extras) {
1328 long identity = Binder.clearCallingIdentity();
1329 boolean result = false;
1331 if ("delete_aiding_data".equals(command)) {
1332 result = deleteAidingData(extras);
1333 } else if ("force_time_injection".equals(command)) {
1336 } else if ("force_xtra_injection".equals(command)) {
1337 if (mSupportsXtra) {
1338 xtraDownloadRequest();
1342 Log.w(TAG, "sendExtraCommand: unknown command " + command);
1345 Binder.restoreCallingIdentity(identity);
1349 private IGpsGeofenceHardware mGpsGeofenceBinder = new IGpsGeofenceHardware.Stub() {
1350 public boolean isHardwareGeofenceSupported() {
1351 return native_is_geofence_supported();
1354 public boolean addCircularHardwareGeofence(int geofenceId, double latitude,
1355 double longitude, double radius, int lastTransition, int monitorTransitions,
1356 int notificationResponsiveness, int unknownTimer) {
1357 return native_add_geofence(geofenceId, latitude, longitude, radius,
1358 lastTransition, monitorTransitions, notificationResponsiveness, unknownTimer);
1361 public boolean removeHardwareGeofence(int geofenceId) {
1362 return native_remove_geofence(geofenceId);
1365 public boolean pauseHardwareGeofence(int geofenceId) {
1366 return native_pause_geofence(geofenceId);
1369 public boolean resumeHardwareGeofence(int geofenceId, int monitorTransition) {
1370 return native_resume_geofence(geofenceId, monitorTransition);
1374 private boolean deleteAidingData(Bundle extras) {
1377 if (extras == null) {
1378 flags = GPS_DELETE_ALL;
1381 if (extras.getBoolean("ephemeris")) flags |= GPS_DELETE_EPHEMERIS;
1382 if (extras.getBoolean("almanac")) flags |= GPS_DELETE_ALMANAC;
1383 if (extras.getBoolean("position")) flags |= GPS_DELETE_POSITION;
1384 if (extras.getBoolean("time")) flags |= GPS_DELETE_TIME;
1385 if (extras.getBoolean("iono")) flags |= GPS_DELETE_IONO;
1386 if (extras.getBoolean("utc")) flags |= GPS_DELETE_UTC;
1387 if (extras.getBoolean("health")) flags |= GPS_DELETE_HEALTH;
1388 if (extras.getBoolean("svdir")) flags |= GPS_DELETE_SVDIR;
1389 if (extras.getBoolean("svsteer")) flags |= GPS_DELETE_SVSTEER;
1390 if (extras.getBoolean("sadata")) flags |= GPS_DELETE_SADATA;
1391 if (extras.getBoolean("rti")) flags |= GPS_DELETE_RTI;
1392 if (extras.getBoolean("celldb-info")) flags |= GPS_DELETE_CELLDB_INFO;
1393 if (extras.getBoolean("all")) flags |= GPS_DELETE_ALL;
1397 native_delete_aiding_data(flags);
1404 private void startNavigating(boolean singleShot) {
1406 if (DEBUG) Log.d(TAG, "startNavigating, singleShot is " + singleShot);
1407 mTimeToFirstFix = 0;
1410 mSingleShot = singleShot;
1411 mPositionMode = GPS_POSITION_MODE_STANDALONE;
1412 // Notify about suppressed output, if speed limit was previously exceeded.
1413 // Elsewhere, we check again with every speed output reported.
1414 if (mItarSpeedLimitExceeded) {
1415 Log.i(TAG, "startNavigating with ITAR limit in place. Output limited " +
1416 "until slow enough speed reported.");
1419 boolean agpsEnabled =
1420 (Settings.Global.getInt(mContext.getContentResolver(),
1421 Settings.Global.ASSISTED_GPS_ENABLED, 1) != 0);
1422 mPositionMode = getSuplMode(mProperties, agpsEnabled, singleShot);
1427 switch(mPositionMode) {
1428 case GPS_POSITION_MODE_STANDALONE:
1429 mode = "standalone";
1431 case GPS_POSITION_MODE_MS_ASSISTED:
1432 mode = "MS_ASSISTED";
1434 case GPS_POSITION_MODE_MS_BASED:
1441 Log.d(TAG, "setting position_mode to " + mode);
1444 int interval = (hasCapability(GPS_CAPABILITY_SCHEDULING) ? mFixInterval : 1000);
1445 if (!native_set_position_mode(mPositionMode, GPS_POSITION_RECURRENCE_PERIODIC,
1448 Log.e(TAG, "set_position_mode failed in startNavigating()");
1451 if (!native_start()) {
1453 Log.e(TAG, "native_start failed in startNavigating()");
1457 // reset SV count to zero
1458 updateStatus(LocationProvider.TEMPORARILY_UNAVAILABLE, 0);
1459 mFixRequestTime = SystemClock.elapsedRealtime();
1461 if (!hasCapability(GPS_CAPABILITY_SCHEDULING)) {
1462 // set timer to give up if we do not receive a fix within NO_FIX_TIMEOUT
1463 // and our fix interval is not short
1464 if (mFixInterval >= NO_FIX_TIMEOUT) {
1465 mAlarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
1466 SystemClock.elapsedRealtime() + NO_FIX_TIMEOUT, mTimeoutIntent);
1472 private void stopNavigating() {
1473 if (DEBUG) Log.d(TAG, "stopNavigating");
1476 mSingleShot = false;
1478 mTimeToFirstFix = 0;
1481 // reset SV count to zero
1482 updateStatus(LocationProvider.TEMPORARILY_UNAVAILABLE, 0);
1486 private void hibernate() {
1487 // stop GPS until our next fix interval arrives
1489 mAlarmManager.cancel(mTimeoutIntent);
1490 mAlarmManager.cancel(mWakeupIntent);
1491 long now = SystemClock.elapsedRealtime();
1492 mAlarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, now + mFixInterval, mWakeupIntent);
1495 private boolean hasCapability(int capability) {
1496 return ((mEngineCapabilities & capability) != 0);
1501 * called from native code to update our position.
1503 private void reportLocation(boolean hasLatLong, Location location) {
1504 if (location.hasSpeed()) {
1505 mItarSpeedLimitExceeded = location.getSpeed() > ITAR_SPEED_LIMIT_METERS_PER_SECOND;
1508 if (mItarSpeedLimitExceeded) {
1509 Log.i(TAG, "Hal reported a speed in excess of ITAR limit." +
1510 " GPS/GNSS Navigation output blocked.");
1511 return; // No output of location allowed
1514 if (VERBOSE) Log.v(TAG, "reportLocation " + location.toString());
1516 synchronized (mLocation) {
1517 mLocation = location;
1518 // It would be nice to push the elapsed real-time timestamp
1519 // further down the stack, but this is still useful
1520 mLocation.setElapsedRealtimeNanos(SystemClock.elapsedRealtimeNanos());
1521 mLocation.setExtras(mLocationExtras);
1524 mILocationManager.reportLocation(mLocation, false);
1525 } catch (RemoteException e) {
1526 Log.e(TAG, "RemoteException calling reportLocation");
1530 mLastFixTime = SystemClock.elapsedRealtime();
1531 // report time to first fix
1532 if (mTimeToFirstFix == 0 && hasLatLong) {
1533 mTimeToFirstFix = (int)(mLastFixTime - mFixRequestTime);
1534 if (DEBUG) Log.d(TAG, "TTFF: " + mTimeToFirstFix);
1536 // notify status listeners
1537 mListenerHelper.onFirstFix(mTimeToFirstFix);
1544 if (mStarted && mStatus != LocationProvider.AVAILABLE) {
1545 // we want to time out if we do not receive a fix
1546 // within the time out and we are requesting infrequent fixes
1547 if (!hasCapability(GPS_CAPABILITY_SCHEDULING) && mFixInterval < NO_FIX_TIMEOUT) {
1548 mAlarmManager.cancel(mTimeoutIntent);
1551 // send an intent to notify that the GPS is receiving fixes.
1552 Intent intent = new Intent(LocationManager.GPS_FIX_CHANGE_ACTION);
1553 intent.putExtra(LocationManager.EXTRA_GPS_ENABLED, true);
1554 mContext.sendBroadcastAsUser(intent, UserHandle.ALL);
1555 updateStatus(LocationProvider.AVAILABLE, mSvCount);
1558 if (!hasCapability(GPS_CAPABILITY_SCHEDULING) && mStarted &&
1559 mFixInterval > GPS_POLLING_THRESHOLD_INTERVAL) {
1560 if (DEBUG) Log.d(TAG, "got fix, hibernating");
1566 * called from native code to update our status
1568 private void reportStatus(int status) {
1569 if (DEBUG) Log.v(TAG, "reportStatus status: " + status);
1571 boolean wasNavigating = mNavigating;
1573 case GPS_STATUS_SESSION_BEGIN:
1577 case GPS_STATUS_SESSION_END:
1578 mNavigating = false;
1580 case GPS_STATUS_ENGINE_ON:
1583 case GPS_STATUS_ENGINE_OFF:
1585 mNavigating = false;
1589 if (wasNavigating != mNavigating) {
1590 mListenerHelper.onStatusChanged(mNavigating);
1592 // send an intent to notify that the GPS has been enabled or disabled
1593 Intent intent = new Intent(LocationManager.GPS_ENABLED_CHANGE_ACTION);
1594 intent.putExtra(LocationManager.EXTRA_GPS_ENABLED, mNavigating);
1595 mContext.sendBroadcastAsUser(intent, UserHandle.ALL);
1600 * called from native code to update SV info
1602 private void reportSvStatus() {
1603 int svCount = native_read_sv_status(mSvidWithFlags,
1608 mListenerHelper.onSvStatusChanged(
1617 Log.v(TAG, "SV count: " + svCount);
1619 // Calculate number of sets used in fix.
1620 int usedInFixCount = 0;
1621 for (int i = 0; i < svCount; i++) {
1622 if ((mSvidWithFlags[i] & GnssStatus.GNSS_SV_FLAGS_USED_IN_FIX) != 0) {
1626 Log.v(TAG, "svid: " + (mSvidWithFlags[i] >> GnssStatus.SVID_SHIFT_WIDTH) +
1627 " cn0: " + mCn0s[i]/10 +
1628 " elev: " + mSvElevations[i] +
1629 " azimuth: " + mSvAzimuths[i] +
1630 " carrier frequency: " + mSvCarrierFreqs[i] +
1631 ((mSvidWithFlags[i] & GnssStatus.GNSS_SV_FLAGS_HAS_EPHEMERIS_DATA) == 0
1633 ((mSvidWithFlags[i] & GnssStatus.GNSS_SV_FLAGS_HAS_ALMANAC_DATA) == 0
1635 ((mSvidWithFlags[i] & GnssStatus.GNSS_SV_FLAGS_USED_IN_FIX) == 0
1637 ((mSvidWithFlags[i] & GnssStatus.GNSS_SV_FLAGS_HAS_CARRIER_FREQUENCY) == 0
1641 // return number of sets used in fix instead of total
1642 updateStatus(mStatus, usedInFixCount);
1644 if (mNavigating && mStatus == LocationProvider.AVAILABLE && mLastFixTime > 0 &&
1645 SystemClock.elapsedRealtime() - mLastFixTime > RECENT_FIX_TIMEOUT) {
1646 // send an intent to notify that the GPS is no longer receiving fixes.
1647 Intent intent = new Intent(LocationManager.GPS_FIX_CHANGE_ACTION);
1648 intent.putExtra(LocationManager.EXTRA_GPS_ENABLED, false);
1649 mContext.sendBroadcastAsUser(intent, UserHandle.ALL);
1650 updateStatus(LocationProvider.TEMPORARILY_UNAVAILABLE, mSvCount);
1655 * called from native code to update AGPS status
1657 private void reportAGpsStatus(int type, int status, byte[] ipaddr) {
1659 case GPS_REQUEST_AGPS_DATA_CONN:
1660 if (DEBUG) Log.d(TAG, "GPS_REQUEST_AGPS_DATA_CONN");
1661 Log.v(TAG, "Received SUPL IP addr[]: " + Arrays.toString(ipaddr));
1662 InetAddress connectionIpAddress = null;
1663 if (ipaddr != null) {
1665 connectionIpAddress = InetAddress.getByAddress(ipaddr);
1666 if (DEBUG) Log.d(TAG, "IP address converted to: " + connectionIpAddress);
1667 } catch (UnknownHostException e) {
1668 Log.e(TAG, "Bad IP Address: " + ipaddr, e);
1671 sendMessage(REQUEST_SUPL_CONNECTION, 0 /*arg*/, connectionIpAddress);
1673 case GPS_RELEASE_AGPS_DATA_CONN:
1674 if (DEBUG) Log.d(TAG, "GPS_RELEASE_AGPS_DATA_CONN");
1675 releaseSuplConnection(GPS_RELEASE_AGPS_DATA_CONN);
1677 case GPS_AGPS_DATA_CONNECTED:
1678 if (DEBUG) Log.d(TAG, "GPS_AGPS_DATA_CONNECTED");
1680 case GPS_AGPS_DATA_CONN_DONE:
1681 if (DEBUG) Log.d(TAG, "GPS_AGPS_DATA_CONN_DONE");
1683 case GPS_AGPS_DATA_CONN_FAILED:
1684 if (DEBUG) Log.d(TAG, "GPS_AGPS_DATA_CONN_FAILED");
1687 if (DEBUG) Log.d(TAG, "Received Unknown AGPS status: " + status);
1691 private void releaseSuplConnection(int connStatus) {
1692 sendMessage(RELEASE_SUPL_CONNECTION, connStatus, null /*obj*/);
1696 * called from native code to report NMEA data received
1698 private void reportNmea(long timestamp) {
1699 if (!mItarSpeedLimitExceeded) {
1700 int length = native_read_nmea(mNmeaBuffer, mNmeaBuffer.length);
1701 String nmea = new String(mNmeaBuffer, 0 /* offset */, length);
1702 mListenerHelper.onNmeaReceived(timestamp, nmea);
1707 * called from native code - Gps measurements callback
1709 private void reportMeasurementData(GnssMeasurementsEvent event) {
1710 if (!mItarSpeedLimitExceeded) {
1711 mGnssMeasurementsProvider.onMeasurementsAvailable(event);
1716 * called from native code - GPS navigation message callback
1718 private void reportNavigationMessage(GnssNavigationMessage event) {
1719 if (!mItarSpeedLimitExceeded) {
1720 mGnssNavigationMessageProvider.onNavigationMessageAvailable(event);
1725 * called from native code to inform us what the GPS engine capabilities are
1727 private void setEngineCapabilities(int capabilities) {
1728 mEngineCapabilities = capabilities;
1730 if (hasCapability(GPS_CAPABILITY_ON_DEMAND_TIME)) {
1731 mOnDemandTimeInjection = true;
1735 mGnssMeasurementsProvider.onCapabilitiesUpdated(
1736 (capabilities & GPS_CAPABILITY_MEASUREMENTS) == GPS_CAPABILITY_MEASUREMENTS);
1737 mGnssNavigationMessageProvider.onCapabilitiesUpdated(
1738 (capabilities & GPS_CAPABILITY_NAV_MESSAGES) == GPS_CAPABILITY_NAV_MESSAGES);
1742 * Called from native code to inform us the hardware information.
1744 private void setGnssYearOfHardware(int yearOfHardware) {
1745 if (DEBUG) Log.d(TAG, "setGnssYearOfHardware called with " + yearOfHardware);
1746 mYearOfHardware = yearOfHardware;
1749 public interface GnssSystemInfoProvider {
1751 * Returns the year of GPS hardware.
1753 int getGnssYearOfHardware();
1759 public GnssSystemInfoProvider getGnssSystemInfoProvider() {
1760 return new GnssSystemInfoProvider() {
1762 public int getGnssYearOfHardware() {
1763 return mYearOfHardware;
1768 public interface GnssBatchingProvider {
1770 * Returns the GNSS batching size
1774 * Starts the hardware batching operation
1776 boolean start(long periodNanos, boolean wakeOnFifoFull);
1778 * Forces a flush of existing locations from the hardware batching
1782 * Stops the batching operation
1790 public GnssBatchingProvider getGnssBatchingProvider() {
1791 return new GnssBatchingProvider() {
1793 public int getSize() {
1794 return native_get_batch_size();
1797 public boolean start(long periodNanos, boolean wakeOnFifoFull) {
1798 if (periodNanos <= 0) {
1799 Log.e(TAG, "Invalid periodNanos " + periodNanos +
1800 "in batching request, not started");
1803 return native_start_batch(periodNanos, wakeOnFifoFull);
1806 public void flush() {
1807 native_flush_batch();
1810 public boolean stop() {
1811 return native_stop_batch();
1817 * Initialize Batching if enabled
1819 private void enableBatching() {
1820 if (!native_init_batching()) {
1821 Log.e(TAG, "Failed to initialize GNSS batching");
1828 private void disableBatching() {
1829 native_stop_batch();
1830 native_cleanup_batching();
1834 * called from native code - GNSS location batch callback
1836 private void reportLocationBatch(Location[] locationArray) {
1837 List<Location> locations = new ArrayList<>(Arrays.asList(locationArray));
1838 if(DEBUG) { Log.d(TAG, "Location batch of size " + locationArray.length + "reported"); }
1840 mILocationManager.reportLocationBatch(locations);
1841 } catch (RemoteException e) {
1842 Log.e(TAG, "RemoteException calling reportLocationBatch");
1847 * called from native code to request XTRA data
1849 private void xtraDownloadRequest() {
1850 if (DEBUG) Log.d(TAG, "xtraDownloadRequest");
1851 sendMessage(DOWNLOAD_XTRA_DATA, 0, null);
1855 * Converts the GPS HAL status to the internal Geofence Hardware status.
1857 private int getGeofenceStatus(int status) {
1859 case GPS_GEOFENCE_OPERATION_SUCCESS:
1860 return GeofenceHardware.GEOFENCE_SUCCESS;
1861 case GPS_GEOFENCE_ERROR_GENERIC:
1862 return GeofenceHardware.GEOFENCE_FAILURE;
1863 case GPS_GEOFENCE_ERROR_ID_EXISTS:
1864 return GeofenceHardware.GEOFENCE_ERROR_ID_EXISTS;
1865 case GPS_GEOFENCE_ERROR_INVALID_TRANSITION:
1866 return GeofenceHardware.GEOFENCE_ERROR_INVALID_TRANSITION;
1867 case GPS_GEOFENCE_ERROR_TOO_MANY_GEOFENCES:
1868 return GeofenceHardware.GEOFENCE_ERROR_TOO_MANY_GEOFENCES;
1869 case GPS_GEOFENCE_ERROR_ID_UNKNOWN:
1870 return GeofenceHardware.GEOFENCE_ERROR_ID_UNKNOWN;
1877 * Called from native to report GPS Geofence transition
1878 * All geofence callbacks are called on the same thread
1880 private void reportGeofenceTransition(int geofenceId, Location location, int transition,
1881 long transitionTimestamp) {
1882 if (mGeofenceHardwareImpl == null) {
1883 mGeofenceHardwareImpl = GeofenceHardwareImpl.getInstance(mContext);
1886 mGeofenceHardwareImpl.reportGeofenceTransition(
1890 transitionTimestamp,
1891 GeofenceHardware.MONITORING_TYPE_GPS_HARDWARE,
1892 FusedBatchOptions.SourceTechnologies.GNSS);
1896 * called from native code to report GPS status change.
1898 private void reportGeofenceStatus(int status, Location location) {
1899 if (mGeofenceHardwareImpl == null) {
1900 mGeofenceHardwareImpl = GeofenceHardwareImpl.getInstance(mContext);
1902 int monitorStatus = GeofenceHardware.MONITOR_CURRENTLY_UNAVAILABLE;
1903 if(status == GPS_GEOFENCE_AVAILABLE) {
1904 monitorStatus = GeofenceHardware.MONITOR_CURRENTLY_AVAILABLE;
1906 mGeofenceHardwareImpl.reportGeofenceMonitorStatus(
1907 GeofenceHardware.MONITORING_TYPE_GPS_HARDWARE,
1910 FusedBatchOptions.SourceTechnologies.GNSS);
1914 * called from native code - Geofence Add callback
1916 private void reportGeofenceAddStatus(int geofenceId, int status) {
1917 if (mGeofenceHardwareImpl == null) {
1918 mGeofenceHardwareImpl = GeofenceHardwareImpl.getInstance(mContext);
1920 mGeofenceHardwareImpl.reportGeofenceAddStatus(geofenceId, getGeofenceStatus(status));
1924 * called from native code - Geofence Remove callback
1926 private void reportGeofenceRemoveStatus(int geofenceId, int status) {
1927 if (mGeofenceHardwareImpl == null) {
1928 mGeofenceHardwareImpl = GeofenceHardwareImpl.getInstance(mContext);
1930 mGeofenceHardwareImpl.reportGeofenceRemoveStatus(geofenceId, getGeofenceStatus(status));
1934 * called from native code - Geofence Pause callback
1936 private void reportGeofencePauseStatus(int geofenceId, int status) {
1937 if (mGeofenceHardwareImpl == null) {
1938 mGeofenceHardwareImpl = GeofenceHardwareImpl.getInstance(mContext);
1940 mGeofenceHardwareImpl.reportGeofencePauseStatus(geofenceId, getGeofenceStatus(status));
1944 * called from native code - Geofence Resume callback
1946 private void reportGeofenceResumeStatus(int geofenceId, int status) {
1947 if (mGeofenceHardwareImpl == null) {
1948 mGeofenceHardwareImpl = GeofenceHardwareImpl.getInstance(mContext);
1950 mGeofenceHardwareImpl.reportGeofenceResumeStatus(geofenceId, getGeofenceStatus(status));
1953 //=============================================================
1954 // NI Client support
1955 //=============================================================
1956 private final INetInitiatedListener mNetInitiatedListener = new INetInitiatedListener.Stub() {
1957 // Sends a response for an NI request to HAL.
1959 public boolean sendNiResponse(int notificationId, int userResponse)
1961 // TODO Add Permission check
1963 if (DEBUG) Log.d(TAG, "sendNiResponse, notifId: " + notificationId +
1964 ", response: " + userResponse);
1965 native_send_ni_response(notificationId, userResponse);
1970 public INetInitiatedListener getNetInitiatedListener() {
1971 return mNetInitiatedListener;
1974 // Called by JNI function to report an NI request.
1975 public void reportNiNotification(
1980 int defaultResponse,
1983 int requestorIdEncoding,
1987 Log.i(TAG, "reportNiNotification: entered");
1988 Log.i(TAG, "notificationId: " + notificationId +
1989 ", niType: " + niType +
1990 ", notifyFlags: " + notifyFlags +
1991 ", timeout: " + timeout +
1992 ", defaultResponse: " + defaultResponse);
1994 Log.i(TAG, "requestorId: " + requestorId +
1996 ", requestorIdEncoding: " + requestorIdEncoding +
1997 ", textEncoding: " + textEncoding);
1999 GpsNiNotification notification = new GpsNiNotification();
2001 notification.notificationId = notificationId;
2002 notification.niType = niType;
2003 notification.needNotify = (notifyFlags & GpsNetInitiatedHandler.GPS_NI_NEED_NOTIFY) != 0;
2004 notification.needVerify = (notifyFlags & GpsNetInitiatedHandler.GPS_NI_NEED_VERIFY) != 0;
2005 notification.privacyOverride = (notifyFlags & GpsNetInitiatedHandler.GPS_NI_PRIVACY_OVERRIDE) != 0;
2006 notification.timeout = timeout;
2007 notification.defaultResponse = defaultResponse;
2008 notification.requestorId = requestorId;
2009 notification.text = text;
2010 notification.requestorIdEncoding = requestorIdEncoding;
2011 notification.textEncoding = textEncoding;
2013 mNIHandler.handleNiNotification(notification);
2017 * Called from native code to request set id info.
2018 * We should be careful about receiving null string from the TelephonyManager,
2019 * because sending null String to JNI function would cause a crash.
2022 private void requestSetID(int flags) {
2023 TelephonyManager phone = (TelephonyManager)
2024 mContext.getSystemService(Context.TELEPHONY_SERVICE);
2025 int type = AGPS_SETID_TYPE_NONE;
2028 if ((flags & AGPS_RIL_REQUEST_SETID_IMSI) == AGPS_RIL_REQUEST_SETID_IMSI) {
2029 String data_temp = phone.getSubscriberId();
2030 if (data_temp == null) {
2031 // This means the framework does not have the SIM card ready.
2033 // This means the framework has the SIM card.
2035 type = AGPS_SETID_TYPE_IMSI;
2038 else if ((flags & AGPS_RIL_REQUEST_SETID_MSISDN) == AGPS_RIL_REQUEST_SETID_MSISDN) {
2039 String data_temp = phone.getLine1Number();
2040 if (data_temp == null) {
2041 // This means the framework does not have the SIM card ready.
2043 // This means the framework has the SIM card.
2045 type = AGPS_SETID_TYPE_MSISDN;
2048 native_agps_set_id(type, data);
2052 * Called from native code to request utc time info
2054 private void requestUtcTime() {
2055 if (DEBUG) Log.d(TAG, "utcTimeRequest");
2056 sendMessage(INJECT_NTP_TIME, 0, null);
2060 * Called from native code to request reference location info
2063 private void requestRefLocation() {
2064 TelephonyManager phone = (TelephonyManager)
2065 mContext.getSystemService(Context.TELEPHONY_SERVICE);
2066 final int phoneType = phone.getPhoneType();
2067 if (phoneType == TelephonyManager.PHONE_TYPE_GSM) {
2068 GsmCellLocation gsm_cell = (GsmCellLocation) phone.getCellLocation();
2069 if ((gsm_cell != null) && (phone.getNetworkOperator() != null)
2070 && (phone.getNetworkOperator().length() > 3)) {
2072 int mcc = Integer.parseInt(phone.getNetworkOperator().substring(0,3));
2073 int mnc = Integer.parseInt(phone.getNetworkOperator().substring(3));
2074 int networkType = phone.getNetworkType();
2075 if (networkType == TelephonyManager.NETWORK_TYPE_UMTS
2076 || networkType == TelephonyManager.NETWORK_TYPE_HSDPA
2077 || networkType == TelephonyManager.NETWORK_TYPE_HSUPA
2078 || networkType == TelephonyManager.NETWORK_TYPE_HSPA
2079 || networkType == TelephonyManager.NETWORK_TYPE_HSPAP) {
2080 type = AGPS_REF_LOCATION_TYPE_UMTS_CELLID;
2082 type = AGPS_REF_LOCATION_TYPE_GSM_CELLID;
2084 native_agps_set_ref_location_cellid(type, mcc, mnc,
2085 gsm_cell.getLac(), gsm_cell.getCid());
2087 Log.e(TAG,"Error getting cell location info.");
2089 } else if (phoneType == TelephonyManager.PHONE_TYPE_CDMA) {
2090 Log.e(TAG, "CDMA not supported.");
2094 private void sendMessage(int message, int arg, Object obj) {
2095 // hold a wake lock until this message is delivered
2096 // note that this assumes the message will not be removed from the queue before
2097 // it is handled (otherwise the wake lock would be leaked).
2098 mWakeLock.acquire();
2099 if (Log.isLoggable(TAG, Log.INFO)) {
2100 Log.i(TAG, "WakeLock acquired by sendMessage(" + messageIdAsString(message) + ", " + arg
2101 + ", " + obj + ")");
2103 mHandler.obtainMessage(message, arg, 1, obj).sendToTarget();
2106 private final class ProviderHandler extends Handler {
2107 public ProviderHandler(Looper looper) {
2108 super(looper, null, true /*async*/);
2112 public void handleMessage(Message msg) {
2113 int message = msg.what;
2116 if (msg.arg1 == 1) {
2123 GpsRequest gpsRequest = (GpsRequest) msg.obj;
2124 handleSetRequest(gpsRequest.request, gpsRequest.source);
2126 case UPDATE_NETWORK_STATE:
2127 handleUpdateNetworkState((Network) msg.obj);
2129 case REQUEST_SUPL_CONNECTION:
2130 handleRequestSuplConnection((InetAddress) msg.obj);
2132 case RELEASE_SUPL_CONNECTION:
2133 handleReleaseSuplConnection(msg.arg1);
2135 case INJECT_NTP_TIME:
2136 handleInjectNtpTime();
2138 case DOWNLOAD_XTRA_DATA:
2139 handleDownloadXtraData();
2141 case INJECT_NTP_TIME_FINISHED:
2142 mInjectNtpTimePending = STATE_IDLE;
2144 case DOWNLOAD_XTRA_DATA_FINISHED:
2145 mDownloadXtraDataPending = STATE_IDLE;
2147 case UPDATE_LOCATION:
2148 handleUpdateLocation((Location) msg.obj);
2150 case SUBSCRIPTION_OR_SIM_CHANGED:
2151 subscriptionOrSimChanged(mContext);
2153 case INITIALIZE_HANDLER:
2157 if (msg.arg2 == 1) {
2158 // wakelock was taken for this message, release it
2159 mWakeLock.release();
2160 if (Log.isLoggable(TAG, Log.INFO)) {
2161 Log.i(TAG, "WakeLock released by handleMessage(" + messageIdAsString(message)
2162 + ", " + msg.arg1 + ", " + msg.obj + ")");
2168 * This method is bound to {@link #GnssLocationProvider(Context, ILocationManager, Looper)}.
2169 * It is in charge of loading properties and registering for events that will be posted to
2172 private void handleInitialize() {
2173 // load default GPS configuration
2174 // (this configuration might change in the future based on SIM changes)
2175 reloadGpsProperties(mContext, mProperties);
2177 // TODO: When this object "finishes" we should unregister by invoking
2178 // SubscriptionManager.getInstance(mContext).unregister(mOnSubscriptionsChangedListener);
2179 // This is not strictly necessary because it will be unregistered if the
2180 // notification fails but it is good form.
2182 // Register for SubscriptionInfo list changes which is guaranteed
2183 // to invoke onSubscriptionsChanged the first time.
2184 SubscriptionManager.from(mContext)
2185 .addOnSubscriptionsChangedListener(mOnSubscriptionsChangedListener);
2187 // listen for events
2188 IntentFilter intentFilter;
2189 if (native_is_agps_ril_supported()) {
2190 intentFilter = new IntentFilter();
2191 intentFilter.addAction(Intents.DATA_SMS_RECEIVED_ACTION);
2192 intentFilter.addDataScheme("sms");
2193 intentFilter.addDataAuthority("localhost", "7275");
2194 mContext.registerReceiver(mBroadcastReceiver, intentFilter, null, this);
2196 intentFilter = new IntentFilter();
2197 intentFilter.addAction(Intents.WAP_PUSH_RECEIVED_ACTION);
2199 intentFilter.addDataType("application/vnd.omaloc-supl-init");
2200 } catch (IntentFilter.MalformedMimeTypeException e) {
2201 Log.w(TAG, "Malformed SUPL init mime type");
2203 mContext.registerReceiver(mBroadcastReceiver, intentFilter, null, this);
2205 Log.d(TAG, "Skipped registration for SMS/WAP-PUSH messages because AGPS Ril in GPS"
2206 + " HAL is not supported");
2209 intentFilter = new IntentFilter();
2210 intentFilter.addAction(ALARM_WAKEUP);
2211 intentFilter.addAction(ALARM_TIMEOUT);
2212 intentFilter.addAction(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED);
2213 intentFilter.addAction(PowerManager.ACTION_DEVICE_IDLE_MODE_CHANGED);
2214 intentFilter.addAction(Intent.ACTION_SCREEN_OFF);
2215 intentFilter.addAction(Intent.ACTION_SCREEN_ON);
2216 intentFilter.addAction(SIM_STATE_CHANGED);
2217 mContext.registerReceiver(mBroadcastReceiver, intentFilter, null, this);
2219 // register for connectivity change events, this is equivalent to the deprecated way of
2220 // registering for CONNECTIVITY_ACTION broadcasts
2221 NetworkRequest.Builder networkRequestBuilder = new NetworkRequest.Builder();
2222 networkRequestBuilder.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR);
2223 networkRequestBuilder.addTransportType(NetworkCapabilities.TRANSPORT_WIFI);
2224 NetworkRequest networkRequest = networkRequestBuilder.build();
2225 mConnMgr.registerNetworkCallback(networkRequest, mNetworkConnectivityCallback);
2227 // listen for PASSIVE_PROVIDER updates
2228 LocationManager locManager =
2229 (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);
2231 float minDistance = 0;
2232 boolean oneShot = false;
2233 LocationRequest request = LocationRequest.createFromDeprecatedProvider(
2234 LocationManager.PASSIVE_PROVIDER,
2238 // Don't keep track of this request since it's done on behalf of other clients
2239 // (which are kept track of separately).
2240 request.setHideFromAppOps(true);
2241 locManager.requestLocationUpdates(
2243 new NetworkLocationListener(),
2248 private final class NetworkLocationListener implements LocationListener {
2250 public void onLocationChanged(Location location) {
2251 // this callback happens on mHandler looper
2252 if (LocationManager.NETWORK_PROVIDER.equals(location.getProvider())) {
2253 handleUpdateLocation(location);
2257 public void onStatusChanged(String provider, int status, Bundle extras) { }
2259 public void onProviderEnabled(String provider) { }
2261 public void onProviderDisabled(String provider) { }
2264 private String getSelectedApn() {
2265 Uri uri = Uri.parse("content://telephony/carriers/preferapn");
2266 Cursor cursor = null;
2268 cursor = mContext.getContentResolver().query(
2270 new String[] { "apn" },
2271 null /* selection */,
2272 null /* selectionArgs */,
2273 Carriers.DEFAULT_SORT_ORDER);
2274 if (cursor != null && cursor.moveToFirst()) {
2275 return cursor.getString(0);
2277 Log.e(TAG, "No APN found to select.");
2279 } catch (Exception e) {
2280 Log.e(TAG, "Error encountered on selecting the APN.", e);
2282 if (cursor != null) {
2290 private int getApnIpType(String apn) {
2291 ensureInHandlerThread();
2296 String selection = String.format("current = 1 and apn = '%s' and carrier_enabled = 1", apn);
2297 Cursor cursor = null;
2299 cursor = mContext.getContentResolver().query(
2300 Carriers.CONTENT_URI,
2301 new String[] { Carriers.PROTOCOL },
2304 Carriers.DEFAULT_SORT_ORDER);
2306 if (null != cursor && cursor.moveToFirst()) {
2307 return translateToApnIpType(cursor.getString(0), apn);
2309 Log.e(TAG, "No entry found in query for APN: " + apn);
2311 } catch (Exception e) {
2312 Log.e(TAG, "Error encountered on APN query for: " + apn, e);
2314 if (cursor != null) {
2322 private int translateToApnIpType(String ipProtocol, String apn) {
2323 if ("IP".equals(ipProtocol)) {
2326 if ("IPV6".equals(ipProtocol)) {
2329 if ("IPV4V6".equals(ipProtocol)) {
2333 // we hit the default case so the ipProtocol is not recognized
2334 String message = String.format("Unknown IP Protocol: %s, for APN: %s", ipProtocol, apn);
2335 Log.e(TAG, message);
2339 private void setRouting() {
2340 if (mAGpsDataConnectionIpAddr == null) {
2344 // TODO: replace the use of this deprecated API
2345 boolean result = mConnMgr.requestRouteToHostAddress(
2346 ConnectivityManager.TYPE_MOBILE_SUPL,
2347 mAGpsDataConnectionIpAddr);
2350 Log.e(TAG, "Error requesting route to host: " + mAGpsDataConnectionIpAddr);
2352 Log.d(TAG, "Successfully requested route to host: " + mAGpsDataConnectionIpAddr);
2357 * @return {@code true} if there is a data network available for outgoing connections,
2358 * {@code false} otherwise.
2360 private boolean isDataNetworkConnected() {
2361 NetworkInfo activeNetworkInfo = mConnMgr.getActiveNetworkInfo();
2362 return activeNetworkInfo != null && activeNetworkInfo.isConnected();
2366 * Ensures the calling function is running in the thread associated with {@link #mHandler}.
2368 private void ensureInHandlerThread() {
2369 if (mHandler != null && Looper.myLooper() == mHandler.getLooper()) {
2372 throw new RuntimeException("This method must run on the Handler thread.");
2376 * @return A string representing the current state stored in {@link #mAGpsDataConnectionState}.
2378 private String agpsDataConnStateAsString() {
2379 switch(mAGpsDataConnectionState) {
2380 case AGPS_DATA_CONNECTION_CLOSED:
2382 case AGPS_DATA_CONNECTION_OPEN:
2384 case AGPS_DATA_CONNECTION_OPENING:
2392 * @return A string representing the given GPS_AGPS_DATA status.
2394 private String agpsDataConnStatusAsString(int agpsDataConnStatus) {
2395 switch (agpsDataConnStatus) {
2396 case GPS_AGPS_DATA_CONNECTED:
2398 case GPS_AGPS_DATA_CONN_DONE:
2400 case GPS_AGPS_DATA_CONN_FAILED:
2402 case GPS_RELEASE_AGPS_DATA_CONN:
2404 case GPS_REQUEST_AGPS_DATA_CONN:
2412 * @return A string representing the given message ID.
2414 private String messageIdAsString(int message) {
2419 return "SET_REQUEST";
2420 case UPDATE_NETWORK_STATE:
2421 return "UPDATE_NETWORK_STATE";
2422 case REQUEST_SUPL_CONNECTION:
2423 return "REQUEST_SUPL_CONNECTION";
2424 case RELEASE_SUPL_CONNECTION:
2425 return "RELEASE_SUPL_CONNECTION";
2426 case INJECT_NTP_TIME:
2427 return "INJECT_NTP_TIME";
2428 case DOWNLOAD_XTRA_DATA:
2429 return "DOWNLOAD_XTRA_DATA";
2430 case INJECT_NTP_TIME_FINISHED:
2431 return "INJECT_NTP_TIME_FINISHED";
2432 case DOWNLOAD_XTRA_DATA_FINISHED:
2433 return "DOWNLOAD_XTRA_DATA_FINISHED";
2434 case UPDATE_LOCATION:
2435 return "UPDATE_LOCATION";
2436 case SUBSCRIPTION_OR_SIM_CHANGED:
2437 return "SUBSCRIPTION_OR_SIM_CHANGED";
2438 case INITIALIZE_HANDLER:
2439 return "INITIALIZE_HANDLER";
2446 public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
2447 StringBuilder s = new StringBuilder();
2448 s.append(" mFixInterval=").append(mFixInterval).append('\n');
2449 s.append(" mDisableGps (battery saver mode)=").append(mDisableGps).append('\n');
2450 s.append(" mEngineCapabilities=0x").append(Integer.toHexString(mEngineCapabilities));
2452 if (hasCapability(GPS_CAPABILITY_SCHEDULING)) s.append("SCHEDULING ");
2453 if (hasCapability(GPS_CAPABILITY_MSB)) s.append("MSB ");
2454 if (hasCapability(GPS_CAPABILITY_MSA)) s.append("MSA ");
2455 if (hasCapability(GPS_CAPABILITY_SINGLE_SHOT)) s.append("SINGLE_SHOT ");
2456 if (hasCapability(GPS_CAPABILITY_ON_DEMAND_TIME)) s.append("ON_DEMAND_TIME ");
2457 if (hasCapability(GPS_CAPABILITY_GEOFENCING)) s.append("GEOFENCING ");
2458 if (hasCapability(GPS_CAPABILITY_MEASUREMENTS)) s.append("MEASUREMENTS ");
2459 if (hasCapability(GPS_CAPABILITY_NAV_MESSAGES)) s.append("NAV_MESSAGES ");
2462 s.append(" internal state: ").append(native_get_internal_state());
2469 * A simple implementation of exponential backoff.
2471 private static final class BackOff {
2472 private static final int MULTIPLIER = 2;
2473 private final long mInitIntervalMillis;
2474 private final long mMaxIntervalMillis;
2475 private long mCurrentIntervalMillis;
2477 public BackOff(long initIntervalMillis, long maxIntervalMillis) {
2478 mInitIntervalMillis = initIntervalMillis;
2479 mMaxIntervalMillis = maxIntervalMillis;
2481 mCurrentIntervalMillis = mInitIntervalMillis / MULTIPLIER;
2484 public long nextBackoffMillis() {
2485 if (mCurrentIntervalMillis > mMaxIntervalMillis) {
2486 return mMaxIntervalMillis;
2489 mCurrentIntervalMillis *= MULTIPLIER;
2490 return mCurrentIntervalMillis;
2493 public void reset() {
2494 mCurrentIntervalMillis = mInitIntervalMillis / MULTIPLIER;
2498 // for GPS SV statistics
2499 private static final int MAX_SVS = 64;
2501 // preallocated arrays, to avoid memory allocation in reportStatus()
2502 private int mSvidWithFlags[] = new int[MAX_SVS];
2503 private float mCn0s[] = new float[MAX_SVS];
2504 private float mSvElevations[] = new float[MAX_SVS];
2505 private float mSvAzimuths[] = new float[MAX_SVS];
2506 private float mSvCarrierFreqs[] = new float[MAX_SVS];
2507 private int mSvCount;
2508 // preallocated to avoid memory allocation in reportNmea()
2509 private byte[] mNmeaBuffer = new byte[120];
2511 static { class_init_native(); }
2512 private static native void class_init_native();
2513 private static native boolean native_is_supported();
2514 private static native boolean native_is_agps_ril_supported();
2515 private static native boolean native_is_gnss_configuration_supported();
2517 private native boolean native_init();
2518 private native void native_cleanup();
2519 private native boolean native_set_position_mode(int mode, int recurrence, int min_interval,
2520 int preferred_accuracy, int preferred_time);
2521 private native boolean native_start();
2522 private native boolean native_stop();
2523 private native void native_delete_aiding_data(int flags);
2524 // returns number of SVs
2525 // mask[0] is ephemeris mask and mask[1] is almanac mask
2526 private native int native_read_sv_status(int[] prnWithFlags, float[] cn0s, float[] elevations,
2527 float[] azimuths, float[] carrierFrequencies);
2528 private native int native_read_nmea(byte[] buffer, int bufferSize);
2529 private native void native_inject_location(double latitude, double longitude, float accuracy);
2532 private native void native_inject_time(long time, long timeReference, int uncertainty);
2533 private native boolean native_supports_xtra();
2534 private native void native_inject_xtra_data(byte[] data, int length);
2537 private native String native_get_internal_state();
2540 private native void native_agps_data_conn_open(String apn, int apnIpType);
2541 private native void native_agps_data_conn_closed();
2542 private native void native_agps_data_conn_failed();
2543 private native void native_agps_ni_message(byte [] msg, int length);
2544 private native void native_set_agps_server(int type, String hostname, int port);
2546 // Network-initiated (NI) Support
2547 private native void native_send_ni_response(int notificationId, int userResponse);
2550 private native void native_agps_set_ref_location_cellid(int type, int mcc, int mnc,
2552 private native void native_agps_set_id(int type, String setid);
2554 private native void native_update_network_state(boolean connected, int type,
2555 boolean roaming, boolean available, String extraInfo, String defaultAPN);
2557 // Hardware Geofence support.
2558 private static native boolean native_is_geofence_supported();
2559 private static native boolean native_add_geofence(int geofenceId, double latitude,
2560 double longitude, double radius, int lastTransition,int monitorTransitions,
2561 int notificationResponsivenes, int unknownTimer);
2562 private static native boolean native_remove_geofence(int geofenceId);
2563 private static native boolean native_resume_geofence(int geofenceId, int transitions);
2564 private static native boolean native_pause_geofence(int geofenceId);
2566 // Gps Hal measurements support.
2567 private static native boolean native_is_measurement_supported();
2568 private native boolean native_start_measurement_collection();
2569 private native boolean native_stop_measurement_collection();
2571 // Gps Navigation message support.
2572 private static native boolean native_is_navigation_message_supported();
2573 private native boolean native_start_navigation_message_collection();
2574 private native boolean native_stop_navigation_message_collection();
2576 // GNSS Configuration
2577 private static native boolean native_set_supl_version(int version);
2578 private static native boolean native_set_supl_mode(int mode);
2579 private static native boolean native_set_supl_es(int es);
2580 private static native boolean native_set_lpp_profile(int lppProfile);
2581 private static native boolean native_set_gnss_pos_protocol_select(int gnssPosProtocolSelect);
2582 private static native boolean native_set_gps_lock(int gpsLock);
2583 private static native boolean native_set_emergency_supl_pdn(int emergencySuplPdn);
2586 private static native int native_get_batch_size();
2587 private static native boolean native_start_batch(long periodNanos, boolean wakeOnFifoFull);
2588 private static native void native_flush_batch();
2589 private static native boolean native_stop_batch();
2590 private static native boolean native_init_batching();
2591 private static native void native_cleanup_batching();