gps.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2010 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #ifndef ANDROID_INCLUDE_HARDWARE_GPS_H
18 #define ANDROID_INCLUDE_HARDWARE_GPS_H
19 
20 #include <stdint.h>
21 #include <sys/cdefs.h>
22 #include <sys/types.h>
23 #include <pthread.h>
24 #include <sys/socket.h>
25 #include <stdbool.h>
26 
27 #include <hardware/hardware.h>
28 
29 __BEGIN_DECLS
30 
31 /**
32  * The id of this module
33  */
34 #define GPS_HARDWARE_MODULE_ID "gps"
35 
36 
37 /** Milliseconds since January 1, 1970 */
38 typedef int64_t GpsUtcTime;
39 
40 /** Maximum number of SVs for gps_sv_status_callback(). */
41 #define GPS_MAX_SVS 32
42 
43 /** Maximum number of Measurements in gps_measurement_callback(). */
44 #define GPS_MAX_MEASUREMENT 32
45 
46 /** Requested operational mode for GPS operation. */
47 typedef uint32_t GpsPositionMode;
48 // IMPORTANT: Note that the following values must match
49 // constants in GpsLocationProvider.java.
50 /** Mode for running GPS standalone (no assistance). */
51 #define GPS_POSITION_MODE_STANDALONE 0
52 /** AGPS MS-Based mode. */
53 #define GPS_POSITION_MODE_MS_BASED 1
54 /**
55  * AGPS MS-Assisted mode. This mode is not maintained by the platform anymore.
56  * It is strongly recommended to use GPS_POSITION_MODE_MS_BASE instead.
57  */
58 #define GPS_POSITION_MODE_MS_ASSISTED 2
59 
60 /** Requested recurrence mode for GPS operation. */
61 typedef uint32_t GpsPositionRecurrence;
62 // IMPORTANT: Note that the following values must match
63 // constants in GpsLocationProvider.java.
64 /** Receive GPS fixes on a recurring basis at a specified period. */
65 #define GPS_POSITION_RECURRENCE_PERIODIC 0
66 /** Request a single shot GPS fix. */
67 #define GPS_POSITION_RECURRENCE_SINGLE 1
68 
69 /** GPS status event values. */
70 typedef uint16_t GpsStatusValue;
71 // IMPORTANT: Note that the following values must match
72 // constants in GpsLocationProvider.java.
73 /** GPS status unknown. */
74 #define GPS_STATUS_NONE 0
75 /** GPS has begun navigating. */
76 #define GPS_STATUS_SESSION_BEGIN 1
77 /** GPS has stopped navigating. */
78 #define GPS_STATUS_SESSION_END 2
79 /** GPS has powered on but is not navigating. */
80 #define GPS_STATUS_ENGINE_ON 3
81 /** GPS is powered off. */
82 #define GPS_STATUS_ENGINE_OFF 4
83 
84 /** Flags to indicate which values are valid in a GpsLocation. */
85 typedef uint16_t GpsLocationFlags;
86 // IMPORTANT: Note that the following values must match
87 // constants in GpsLocationProvider.java.
88 /** GpsLocation has valid latitude and longitude. */
89 #define GPS_LOCATION_HAS_LAT_LONG 0x0001
90 /** GpsLocation has valid altitude. */
91 #define GPS_LOCATION_HAS_ALTITUDE 0x0002
92 /** GpsLocation has valid speed. */
93 #define GPS_LOCATION_HAS_SPEED 0x0004
94 /** GpsLocation has valid bearing. */
95 #define GPS_LOCATION_HAS_BEARING 0x0008
96 /** GpsLocation has valid accuracy. */
97 #define GPS_LOCATION_HAS_ACCURACY 0x0010
98 
99 /** Flags for the gps_set_capabilities callback. */
100 
101 /** GPS HAL schedules fixes for GPS_POSITION_RECURRENCE_PERIODIC mode.
102  If this is not set, then the framework will use 1000ms for min_interval
103  and will start and call start() and stop() to schedule the GPS.
104  */
105 #define GPS_CAPABILITY_SCHEDULING 0x0000001
106 /** GPS supports MS-Based AGPS mode */
107 #define GPS_CAPABILITY_MSB 0x0000002
108 /** GPS supports MS-Assisted AGPS mode */
109 #define GPS_CAPABILITY_MSA 0x0000004
110 /** GPS supports single-shot fixes */
111 #define GPS_CAPABILITY_SINGLE_SHOT 0x0000008
112 /** GPS supports on demand time injection */
113 #define GPS_CAPABILITY_ON_DEMAND_TIME 0x0000010
114 /** GPS supports Geofencing */
115 #define GPS_CAPABILITY_GEOFENCING 0x0000020
116 /** GPS supports Measurements */
117 #define GPS_CAPABILITY_MEASUREMENTS 0x0000040
118 /** GPS supports Navigation Messages */
119 #define GPS_CAPABILITY_NAV_MESSAGES 0x0000080
120 
121 /** Flags used to specify which aiding data to delete
122  when calling delete_aiding_data(). */
123 typedef uint16_t GpsAidingData;
124 // IMPORTANT: Note that the following values must match
125 // constants in GpsLocationProvider.java.
126 #define GPS_DELETE_EPHEMERIS 0x0001
127 #define GPS_DELETE_ALMANAC 0x0002
128 #define GPS_DELETE_POSITION 0x0004
129 #define GPS_DELETE_TIME 0x0008
130 #define GPS_DELETE_IONO 0x0010
131 #define GPS_DELETE_UTC 0x0020
132 #define GPS_DELETE_HEALTH 0x0040
133 #define GPS_DELETE_SVDIR 0x0080
134 #define GPS_DELETE_SVSTEER 0x0100
135 #define GPS_DELETE_SADATA 0x0200
136 #define GPS_DELETE_RTI 0x0400
137 #define GPS_DELETE_CELLDB_INFO 0x8000
138 #define GPS_DELETE_ALL 0xFFFF
139 
140 /** AGPS type */
141 typedef uint16_t AGpsType;
142 #define AGPS_TYPE_SUPL 1
143 #define AGPS_TYPE_C2K 2
144 
145 typedef uint16_t AGpsSetIDType;
146 #define AGPS_SETID_TYPE_NONE 0
147 #define AGPS_SETID_TYPE_IMSI 1
148 #define AGPS_SETID_TYPE_MSISDN 2
149 
150 typedef uint16_t ApnIpType;
151 #define APN_IP_INVALID 0
152 #define APN_IP_IPV4 1
153 #define APN_IP_IPV6 2
154 #define APN_IP_IPV4V6 3
155 
156 /**
157  * String length constants
158  */
159 #define GPS_NI_SHORT_STRING_MAXLEN 256
160 #define GPS_NI_LONG_STRING_MAXLEN 2048
161 
162 /**
163  * GpsNiType constants
164  */
165 typedef uint32_t GpsNiType;
166 #define GPS_NI_TYPE_VOICE 1
167 #define GPS_NI_TYPE_UMTS_SUPL 2
168 #define GPS_NI_TYPE_UMTS_CTRL_PLANE 3
169 
170 /**
171  * GpsNiNotifyFlags constants
172  */
173 typedef uint32_t GpsNiNotifyFlags;
174 /** NI requires notification */
175 #define GPS_NI_NEED_NOTIFY 0x0001
176 /** NI requires verification */
177 #define GPS_NI_NEED_VERIFY 0x0002
178 /** NI requires privacy override, no notification/minimal trace */
179 #define GPS_NI_PRIVACY_OVERRIDE 0x0004
180 
181 /**
182  * GPS NI responses, used to define the response in
183  * NI structures
184  */
186 #define GPS_NI_RESPONSE_ACCEPT 1
187 #define GPS_NI_RESPONSE_DENY 2
188 #define GPS_NI_RESPONSE_NORESP 3
189 
190 /**
191  * NI data encoding scheme
192  */
193 typedef int GpsNiEncodingType;
194 #define GPS_ENC_NONE 0
195 #define GPS_ENC_SUPL_GSM_DEFAULT 1
196 #define GPS_ENC_SUPL_UTF8 2
197 #define GPS_ENC_SUPL_UCS2 3
198 #define GPS_ENC_UNKNOWN -1
199 
200 /** AGPS status event values. */
201 typedef uint16_t AGpsStatusValue;
202 /** GPS requests data connection for AGPS. */
203 #define GPS_REQUEST_AGPS_DATA_CONN 1
204 /** GPS releases the AGPS data connection. */
205 #define GPS_RELEASE_AGPS_DATA_CONN 2
206 /** AGPS data connection initiated */
207 #define GPS_AGPS_DATA_CONNECTED 3
208 /** AGPS data connection completed */
209 #define GPS_AGPS_DATA_CONN_DONE 4
210 /** AGPS data connection failed */
211 #define GPS_AGPS_DATA_CONN_FAILED 5
212 
213 #define AGPS_REF_LOCATION_TYPE_GSM_CELLID 1
214 #define AGPS_REF_LOCATION_TYPE_UMTS_CELLID 2
215 #define AGPS_REG_LOCATION_TYPE_MAC 3
216 
217 /** Network types for update_network_state "type" parameter */
218 #define AGPS_RIL_NETWORK_TYPE_MOBILE 0
219 #define AGPS_RIL_NETWORK_TYPE_WIFI 1
220 #define AGPS_RIL_NETWORK_TYPE_MOBILE_MMS 2
221 #define AGPS_RIL_NETWORK_TYPE_MOBILE_SUPL 3
222 #define AGPS_RIL_NETWORK_TTYPE_MOBILE_DUN 4
223 #define AGPS_RIL_NETWORK_TTYPE_MOBILE_HIPRI 5
224 #define AGPS_RIL_NETWORK_TTYPE_WIMAX 6
225 
226 /**
227  * Flags to indicate what fields in GpsClock are valid.
228  */
229 typedef uint16_t GpsClockFlags;
230 /** A valid 'leap second' is stored in the data structure. */
231 #define GPS_CLOCK_HAS_LEAP_SECOND (1<<0)
232 /** A valid 'time uncertainty' is stored in the data structure. */
233 #define GPS_CLOCK_HAS_TIME_UNCERTAINTY (1<<1)
234 /** A valid 'full bias' is stored in the data structure. */
235 #define GPS_CLOCK_HAS_FULL_BIAS (1<<2)
236 /** A valid 'bias' is stored in the data structure. */
237 #define GPS_CLOCK_HAS_BIAS (1<<3)
238 /** A valid 'bias uncertainty' is stored in the data structure. */
239 #define GPS_CLOCK_HAS_BIAS_UNCERTAINTY (1<<4)
240 /** A valid 'drift' is stored in the data structure. */
241 #define GPS_CLOCK_HAS_DRIFT (1<<5)
242 /** A valid 'drift uncertainty' is stored in the data structure. */
243 #define GPS_CLOCK_HAS_DRIFT_UNCERTAINTY (1<<6)
244 
245 /**
246  * Enumeration of the available values for the GPS Clock type.
247  */
248 typedef uint8_t GpsClockType;
249 /** The type is not available ot it is unknown. */
250 #define GPS_CLOCK_TYPE_UNKNOWN 0
251 /** The source of the time value reported by GPS clock is the local hardware clock. */
252 #define GPS_CLOCK_TYPE_LOCAL_HW_TIME 1
253 /**
254  * The source of the time value reported by GPS clock is the GPS time derived from satellites
255  * (epoch = Jan 6, 1980)
256  */
257 #define GPS_CLOCK_TYPE_GPS_TIME 2
258 
259 /**
260  * Flags to indicate what fields in GpsMeasurement are valid.
261  */
262 typedef uint32_t GpsMeasurementFlags;
263 /** A valid 'snr' is stored in the data structure. */
264 #define GPS_MEASUREMENT_HAS_SNR (1<<0)
265 /** A valid 'elevation' is stored in the data structure. */
266 #define GPS_MEASUREMENT_HAS_ELEVATION (1<<1)
267 /** A valid 'elevation uncertainty' is stored in the data structure. */
268 #define GPS_MEASUREMENT_HAS_ELEVATION_UNCERTAINTY (1<<2)
269 /** A valid 'azimuth' is stored in the data structure. */
270 #define GPS_MEASUREMENT_HAS_AZIMUTH (1<<3)
271 /** A valid 'azimuth uncertainty' is stored in the data structure. */
272 #define GPS_MEASUREMENT_HAS_AZIMUTH_UNCERTAINTY (1<<4)
273 /** A valid 'pseudorange' is stored in the data structure. */
274 #define GPS_MEASUREMENT_HAS_PSEUDORANGE (1<<5)
275 /** A valid 'pseudorange uncertainty' is stored in the data structure. */
276 #define GPS_MEASUREMENT_HAS_PSEUDORANGE_UNCERTAINTY (1<<6)
277 /** A valid 'code phase' is stored in the data structure. */
278 #define GPS_MEASUREMENT_HAS_CODE_PHASE (1<<7)
279 /** A valid 'code phase uncertainty' is stored in the data structure. */
280 #define GPS_MEASUREMENT_HAS_CODE_PHASE_UNCERTAINTY (1<<8)
281 /** A valid 'carrier frequency' is stored in the data structure. */
282 #define GPS_MEASUREMENT_HAS_CARRIER_FREQUENCY (1<<9)
283 /** A valid 'carrier cycles' is stored in the data structure. */
284 #define GPS_MEASUREMENT_HAS_CARRIER_CYCLES (1<<10)
285 /** A valid 'carrier phase' is stored in the data structure. */
286 #define GPS_MEASUREMENT_HAS_CARRIER_PHASE (1<<11)
287 /** A valid 'carrier phase uncertainty' is stored in the data structure. */
288 #define GPS_MEASUREMENT_HAS_CARRIER_PHASE_UNCERTAINTY (1<<12)
289 /** A valid 'bit number' is stored in the data structure. */
290 #define GPS_MEASUREMENT_HAS_BIT_NUMBER (1<<13)
291 /** A valid 'time from last bit' is stored in the data structure. */
292 #define GPS_MEASUREMENT_HAS_TIME_FROM_LAST_BIT (1<<14)
293 /** A valid 'doppler shift' is stored in the data structure. */
294 #define GPS_MEASUREMENT_HAS_DOPPLER_SHIFT (1<<15)
295 /** A valid 'doppler shift uncertainty' is stored in the data structure. */
296 #define GPS_MEASUREMENT_HAS_DOPPLER_SHIFT_UNCERTAINTY (1<<16)
297 /** A valid 'used in fix' flag is stored in the data structure. */
298 #define GPS_MEASUREMENT_HAS_USED_IN_FIX (1<<17)
299 /** The value of 'pseudorange rate' is uncorrected. */
300 #define GPS_MEASUREMENT_HAS_UNCORRECTED_PSEUDORANGE_RATE (1<<18)
301 
302 /**
303  * Enumeration of the available values for the GPS Measurement's loss of lock.
304  */
305 typedef uint8_t GpsLossOfLock;
306 /** The indicator is not available or it is unknown. */
307 #define GPS_LOSS_OF_LOCK_UNKNOWN 0
308 /** The measurement does not present any indication of loss of lock. */
309 #define GPS_LOSS_OF_LOCK_OK 1
310 /** Loss of lock between previous and current observation: cycle slip possible. */
311 #define GPS_LOSS_OF_LOCK_CYCLE_SLIP 2
312 
313 /**
314  * Enumeration of available values for the GPS Measurement's multipath indicator.
315  */
316 typedef uint8_t GpsMultipathIndicator;
317 /** The indicator is not available or unknown. */
318 #define GPS_MULTIPATH_INDICATOR_UNKNOWN 0
319 /** The measurement has been indicated to use multipath. */
320 #define GPS_MULTIPATH_INDICATOR_DETECTED 1
321 /** The measurement has been indicated Not to use multipath. */
322 #define GPS_MULTIPATH_INDICATOR_NOT_USED 2
323 
324 /**
325  * Flags indicating the GPS measurement state.
326  * The expected behavior here is for GPS HAL to set all the flags that applies. For
327  * example, if the state for a satellite is only C/A code locked and bit synchronized,
328  * and there is still millisecond ambiguity, the state should be set as:
329  * GPS_MEASUREMENT_STATE_CODE_LOCK|GPS_MEASUREMENT_STATE_BIT_SYNC|GPS_MEASUREMENT_STATE_MSEC_AMBIGUOUS
330  * If GPS is still searching for a satellite, the corresponding state should be set to
331  * GPS_MEASUREMENT_STATE_UNKNOWN(0).
332  */
333 typedef uint16_t GpsMeasurementState;
334 #define GPS_MEASUREMENT_STATE_UNKNOWN 0
335 #define GPS_MEASUREMENT_STATE_CODE_LOCK (1<<0)
336 #define GPS_MEASUREMENT_STATE_BIT_SYNC (1<<1)
337 #define GPS_MEASUREMENT_STATE_SUBFRAME_SYNC (1<<2)
338 #define GPS_MEASUREMENT_STATE_TOW_DECODED (1<<3)
339 #define GPS_MEASUREMENT_STATE_MSEC_AMBIGUOUS (1<<4)
340 
341 /**
342  * Flags indicating the Accumulated Delta Range's states.
343  */
345 #define GPS_ADR_STATE_UNKNOWN 0
346 #define GPS_ADR_STATE_VALID (1<<0)
347 #define GPS_ADR_STATE_RESET (1<<1)
348 #define GPS_ADR_STATE_CYCLE_SLIP (1<<2)
349 
350 /**
351  * Enumeration of available values to indicate the available GPS Navigation message types.
352  */
353 typedef uint8_t GpsNavigationMessageType;
354 /** The message type is unknown. */
355 #define GPS_NAVIGATION_MESSAGE_TYPE_UNKNOWN 0
356 /** L1 C/A message contained in the structure. */
357 #define GPS_NAVIGATION_MESSAGE_TYPE_L1CA 1
358 /** L2-CNAV message contained in the structure. */
359 #define GPS_NAVIGATION_MESSAGE_TYPE_L2CNAV 2
360 /** L5-CNAV message contained in the structure. */
361 #define GPS_NAVIGATION_MESSAGE_TYPE_L5CNAV 3
362 /** CNAV-2 message contained in the structure. */
363 #define GPS_NAVIGATION_MESSAGE_TYPE_CNAV2 4
364 
365 /**
366  * Status of Navigation Message
367  * When a message is received properly without any parity error in its navigation words, the
368  * status should be set to NAV_MESSAGE_STATUS_PARITY_PASSED. But if a message is received
369  * with words that failed parity check, but GPS is able to correct those words, the status
370  * should be set to NAV_MESSAGE_STATUS_PARITY_REBUILT.
371  * No need to send any navigation message that contains words with parity error and cannot be
372  * corrected.
373  */
374 typedef uint16_t NavigationMessageStatus;
375 #define NAV_MESSAGE_STATUS_UNKONW 0
376 #define NAV_MESSAGE_STATUS_PARITY_PASSED (1<<0)
377 #define NAV_MESSAGE_STATUS_PARITY_REBUILT (1<<1)
378 
379 /**
380  * Name for the GPS XTRA interface.
381  */
382 #define GPS_XTRA_INTERFACE "gps-xtra"
383 
384 /**
385  * Name for the GPS DEBUG interface.
386  */
387 #define GPS_DEBUG_INTERFACE "gps-debug"
388 
389 /**
390  * Name for the AGPS interface.
391  */
392 #define AGPS_INTERFACE "agps"
393 
394 /**
395  * Name of the Supl Certificate interface.
396  */
397 #define SUPL_CERTIFICATE_INTERFACE "supl-certificate"
398 
399 /**
400  * Name for NI interface
401  */
402 #define GPS_NI_INTERFACE "gps-ni"
403 
404 /**
405  * Name for the AGPS-RIL interface.
406  */
407 #define AGPS_RIL_INTERFACE "agps_ril"
408 
409 /**
410  * Name for the GPS_Geofencing interface.
411  */
412 #define GPS_GEOFENCING_INTERFACE "gps_geofencing"
413 
414 /**
415  * Name of the GPS Measurements interface.
416  */
417 #define GPS_MEASUREMENT_INTERFACE "gps_measurement"
418 
419 /**
420  * Name of the GPS navigation message interface.
421  */
422 #define GPS_NAVIGATION_MESSAGE_INTERFACE "gps_navigation_message"
423 
424 /**
425  * Name of the GNSS/GPS configuration interface.
426  */
427 #define GNSS_CONFIGURATION_INTERFACE "gnss_configuration"
428 
429 
430 /** Represents a location. */
431 typedef struct {
432  /** set to sizeof(GpsLocation) */
433  size_t size;
434  /** Contains GpsLocationFlags bits. */
435  uint16_t flags;
436  /** Represents latitude in degrees. */
437  double latitude;
438  /** Represents longitude in degrees. */
439  double longitude;
440  /** Represents altitude in meters above the WGS 84 reference
441  * ellipsoid. */
442  double altitude;
443  /** Represents speed in meters per second. */
444  float speed;
445  /** Represents heading in degrees. */
446  float bearing;
447  /** Represents expected accuracy in meters. */
448  float accuracy;
449  /** Timestamp for the location fix. */
451 } GpsLocation;
452 
453 /** Represents the status. */
454 typedef struct {
455  /** set to sizeof(GpsStatus) */
456  size_t size;
458 } GpsStatus;
459 
460 /** Represents SV information. */
461 typedef struct {
462  /** set to sizeof(GpsSvInfo) */
463  size_t size;
464  /** Pseudo-random number for the SV. */
465  int prn;
466  /** Signal to noise ratio. */
467  float snr;
468  /** Elevation of SV in degrees. */
469  float elevation;
470  /** Azimuth of SV in degrees. */
471  float azimuth;
472 } GpsSvInfo;
473 
474 /** Represents SV status. */
475 typedef struct {
476  /** set to sizeof(GpsSvStatus) */
477  size_t size;
478 
479  /** Number of SVs currently visible. */
480  int num_svs;
481 
482  /** Contains an array of SV information. */
484 
485  /** Represents a bit mask indicating which SVs
486  * have ephemeris data.
487  */
488  uint32_t ephemeris_mask;
489 
490  /** Represents a bit mask indicating which SVs
491  * have almanac data.
492  */
493  uint32_t almanac_mask;
494 
495  /**
496  * Represents a bit mask indicating which SVs
497  * were used for computing the most recent position fix.
498  */
500 } GpsSvStatus;
501 
502 
503 /* 2G and 3G */
504 /* In 3G lac is discarded */
505 typedef struct {
506  uint16_t type;
507  uint16_t mcc;
508  uint16_t mnc;
509  uint16_t lac;
510  uint32_t cid;
512 
513 typedef struct {
514  uint8_t mac[6];
516 
517 /** Represents ref locations */
518 typedef struct {
519  uint16_t type;
520  union {
523  } u;
525 
526 /** Callback with location information.
527  * Can only be called from a thread created by create_thread_cb.
528  */
529 typedef void (* gps_location_callback)(GpsLocation* location);
530 
531 /** Callback with status information.
532  * Can only be called from a thread created by create_thread_cb.
533  */
534 typedef void (* gps_status_callback)(GpsStatus* status);
535 
536 /**
537  * Callback with SV status information.
538  * Can only be called from a thread created by create_thread_cb.
539  */
540 typedef void (* gps_sv_status_callback)(GpsSvStatus* sv_info);
541 
542 /** Callback for reporting NMEA sentences.
543  * Can only be called from a thread created by create_thread_cb.
544  */
545 typedef void (* gps_nmea_callback)(GpsUtcTime timestamp, const char* nmea, int length);
546 
547 /** Callback to inform framework of the GPS engine's capabilities.
548  * Capability parameter is a bit field of GPS_CAPABILITY_* flags.
549  */
550 typedef void (* gps_set_capabilities)(uint32_t capabilities);
551 
552 /** Callback utility for acquiring the GPS wakelock.
553  * This can be used to prevent the CPU from suspending while handling GPS events.
554  */
555 typedef void (* gps_acquire_wakelock)();
556 
557 /** Callback utility for releasing the GPS wakelock. */
558 typedef void (* gps_release_wakelock)();
559 
560 /** Callback for requesting NTP time */
561 typedef void (* gps_request_utc_time)();
562 
563 /** Callback for creating a thread that can call into the Java framework code.
564  * This must be used to create any threads that report events up to the framework.
565  */
566 typedef pthread_t (* gps_create_thread)(const char* name, void (*start)(void *), void* arg);
567 
568 /** GPS callback structure. */
569 typedef struct {
570  /** set to sizeof(GpsCallbacks) */
571  size_t size;
581 } GpsCallbacks;
582 
583 
584 /** Represents the standard GPS interface. */
585 typedef struct {
586  /** set to sizeof(GpsInterface) */
587  size_t size;
588  /**
589  * Opens the interface and provides the callback routines
590  * to the implementation of this interface.
591  */
592  int (*init)( GpsCallbacks* callbacks );
593 
594  /** Starts navigating. */
595  int (*start)( void );
596 
597  /** Stops navigating. */
598  int (*stop)( void );
599 
600  /** Closes the interface. */
601  void (*cleanup)( void );
602 
603  /** Injects the current time. */
604  int (*inject_time)(GpsUtcTime time, int64_t timeReference,
605  int uncertainty);
606 
607  /** Injects current location from another location provider
608  * (typically cell ID).
609  * latitude and longitude are measured in degrees
610  * expected accuracy is measured in meters
611  */
612  int (*inject_location)(double latitude, double longitude, float accuracy);
613 
614  /**
615  * Specifies that the next call to start will not use the
616  * information defined in the flags. GPS_DELETE_ALL is passed for
617  * a cold start.
618  */
619  void (*delete_aiding_data)(GpsAidingData flags);
620 
621  /**
622  * min_interval represents the time between fixes in milliseconds.
623  * preferred_accuracy represents the requested fix accuracy in meters.
624  * preferred_time represents the requested time to first fix in milliseconds.
625  *
626  * 'mode' parameter should be one of GPS_POSITION_MODE_MS_BASE
627  * or GPS_POSITION_MODE_STANDALONE.
628  * It is allowed by the platform (and it is recommended) to fallback to
629  * GPS_POSITION_MODE_MS_BASE if GPS_POSITION_MODE_MS_ASSISTED is passed in, and
630  * GPS_POSITION_MODE_MS_BASED is supported.
631  */
632  int (*set_position_mode)(GpsPositionMode mode, GpsPositionRecurrence recurrence,
633  uint32_t min_interval, uint32_t preferred_accuracy, uint32_t preferred_time);
634 
635  /** Get a pointer to extension information. */
636  const void* (*get_extension)(const char* name);
637 } GpsInterface;
638 
639 /** Callback to request the client to download XTRA data.
640  * The client should download XTRA data and inject it by calling inject_xtra_data().
641  * Can only be called from a thread created by create_thread_cb.
642  */
643 typedef void (* gps_xtra_download_request)();
644 
645 /** Callback structure for the XTRA interface. */
646 typedef struct {
650 
651 /** Extended interface for XTRA support. */
652 typedef struct {
653  /** set to sizeof(GpsXtraInterface) */
654  size_t size;
655  /**
656  * Opens the XTRA interface and provides the callback routines
657  * to the implementation of this interface.
658  */
659  int (*init)( GpsXtraCallbacks* callbacks );
660  /** Injects XTRA data into the GPS. */
661  int (*inject_xtra_data)( char* data, int length );
663 
664 /** Extended interface for DEBUG support. */
665 typedef struct {
666  /** set to sizeof(GpsDebugInterface) */
667  size_t size;
668 
669  /**
670  * This function should return any information that the native
671  * implementation wishes to include in a bugreport.
672  */
673  size_t (*get_internal_state)(char* buffer, size_t bufferSize);
675 
676 #pragma pack(push,4)
677 // We need to keep the alignment of this data structure to 4-bytes, to ensure that in 64-bit
678 // environments the size of this legacy definition does not collide with _v2. Implementations should
679 // be using _v2 and _v3, so it's OK to pay the 'unaligned' penalty in 64-bit if an old
680 // implementation is still in use.
681 
682 /** Represents the status of AGPS. */
683 typedef struct {
684  /** set to sizeof(AGpsStatus_v1) */
685  size_t size;
686 
689 } AGpsStatus_v1;
690 
691 #pragma pack(pop)
692 
693 /** Represents the status of AGPS augmented with a IPv4 address field. */
694 typedef struct {
695  /** set to sizeof(AGpsStatus_v2) */
696  size_t size;
697 
700  uint32_t ipaddr;
701 } AGpsStatus_v2;
702 
703 /* Represents the status of AGPS augmented to support IPv4 and IPv6. */
704 typedef struct {
705  /** set to sizeof(AGpsStatus_v3) */
706  size_t size;
707 
710 
711  /**
712  * Must be set to a valid IPv4 address if the field 'addr' contains an IPv4
713  * address, or set to INADDR_NONE otherwise.
714  */
715  uint32_t ipaddr;
716 
717  /**
718  * Must contain the IPv4 (AF_INET) or IPv6 (AF_INET6) address to report.
719  * Any other value of addr.ss_family will be rejected.
720  * */
721  struct sockaddr_storage addr;
722 } AGpsStatus_v3;
723 
725 
726 /** Callback with AGPS status information.
727  * Can only be called from a thread created by create_thread_cb.
728  */
729 typedef void (* agps_status_callback)(AGpsStatus* status);
730 
731 /** Callback structure for the AGPS interface. */
732 typedef struct {
735 } AGpsCallbacks;
736 
737 
738 /** Extended interface for AGPS support. */
739 typedef struct {
740  /** set to sizeof(AGpsInterface_v1) */
741  size_t size;
742 
743  /**
744  * Opens the AGPS interface and provides the callback routines
745  * to the implementation of this interface.
746  */
747  void (*init)( AGpsCallbacks* callbacks );
748  /**
749  * Notifies that a data connection is available and sets
750  * the name of the APN to be used for SUPL.
751  */
752  int (*data_conn_open)( const char* apn );
753  /**
754  * Notifies that the AGPS data connection has been closed.
755  */
756  int (*data_conn_closed)();
757  /**
758  * Notifies that a data connection is not available for AGPS.
759  */
760  int (*data_conn_failed)();
761  /**
762  * Sets the hostname and port for the AGPS server.
763  */
764  int (*set_server)( AGpsType type, const char* hostname, int port );
766 
767 /**
768  * Extended interface for AGPS support, it is augmented to enable to pass
769  * extra APN data.
770  */
771 typedef struct {
772  /** set to sizeof(AGpsInterface_v2) */
773  size_t size;
774 
775  /**
776  * Opens the AGPS interface and provides the callback routines to the
777  * implementation of this interface.
778  */
779  void (*init)(AGpsCallbacks* callbacks);
780  /**
781  * Deprecated.
782  * If the HAL supports AGpsInterface_v2 this API will not be used, see
783  * data_conn_open_with_apn_ip_type for more information.
784  */
785  int (*data_conn_open)(const char* apn);
786  /**
787  * Notifies that the AGPS data connection has been closed.
788  */
789  int (*data_conn_closed)();
790  /**
791  * Notifies that a data connection is not available for AGPS.
792  */
793  int (*data_conn_failed)();
794  /**
795  * Sets the hostname and port for the AGPS server.
796  */
797  int (*set_server)(AGpsType type, const char* hostname, int port);
798 
799  /**
800  * Notifies that a data connection is available and sets the name of the
801  * APN, and its IP type, to be used for SUPL connections.
802  */
803  int (*data_conn_open_with_apn_ip_type)(
804  const char* apn,
805  ApnIpType apnIpType);
807 
809 
810 /** Error codes associated with certificate operations */
811 #define AGPS_CERTIFICATE_OPERATION_SUCCESS 0
812 #define AGPS_CERTIFICATE_ERROR_GENERIC -100
813 #define AGPS_CERTIFICATE_ERROR_TOO_MANY_CERTIFICATES -101
814 
815 /** A data structure that represents an X.509 certificate using DER encoding */
816 typedef struct {
817  size_t length;
818  u_char* data;
820 
821 /**
822  * A type definition for SHA1 Fingerprints used to identify X.509 Certificates
823  * The Fingerprint is a digest of the DER Certificate that uniquely identifies it.
824  */
825 typedef struct {
826  u_char data[20];
828 
829 /** AGPS Interface to handle SUPL certificate operations */
830 typedef struct {
831  /** set to sizeof(SuplCertificateInterface) */
832  size_t size;
833 
834  /**
835  * Installs a set of Certificates used for SUPL connections to the AGPS server.
836  * If needed the HAL should find out internally any certificates that need to be removed to
837  * accommodate the certificates to install.
838  * The certificates installed represent a full set of valid certificates needed to connect to
839  * AGPS SUPL servers.
840  * The list of certificates is required, and all must be available at the same time, when trying
841  * to establish a connection with the AGPS Server.
842  *
843  * Parameters:
844  * certificates - A pointer to an array of DER encoded certificates that are need to be
845  * installed in the HAL.
846  * length - The number of certificates to install.
847  * Returns:
848  * AGPS_CERTIFICATE_OPERATION_SUCCESS if the operation is completed successfully
849  * AGPS_CERTIFICATE_ERROR_TOO_MANY_CERTIFICATES if the HAL cannot store the number of
850  * certificates attempted to be installed, the state of the certificates stored should
851  * remain the same as before on this error case.
852  *
853  * IMPORTANT:
854  * If needed the HAL should find out internally the set of certificates that need to be
855  * removed to accommodate the certificates to install.
856  */
857  int (*install_certificates) ( const DerEncodedCertificate* certificates, size_t length );
858 
859  /**
860  * Notifies the HAL that a list of certificates used for SUPL connections are revoked. It is
861  * expected that the given set of certificates is removed from the internal store of the HAL.
862  *
863  * Parameters:
864  * fingerprints - A pointer to an array of SHA1 Fingerprints to identify the set of
865  * certificates to revoke.
866  * length - The number of fingerprints provided.
867  * Returns:
868  * AGPS_CERTIFICATE_OPERATION_SUCCESS if the operation is completed successfully.
869  *
870  * IMPORTANT:
871  * If any of the certificates provided (through its fingerprint) is not known by the HAL,
872  * it should be ignored and continue revoking/deleting the rest of them.
873  */
874  int (*revoke_certificates) ( const Sha1CertificateFingerprint* fingerprints, size_t length );
876 
877 /** Represents an NI request */
878 typedef struct {
879  /** set to sizeof(GpsNiNotification) */
880  size_t size;
881 
882  /**
883  * An ID generated by HAL to associate NI notifications and UI
884  * responses
885  */
887 
888  /**
889  * An NI type used to distinguish different categories of NI
890  * events, such as GPS_NI_TYPE_VOICE, GPS_NI_TYPE_UMTS_SUPL, ...
891  */
893 
894  /**
895  * Notification/verification options, combinations of GpsNiNotifyFlags constants
896  */
898 
899  /**
900  * Timeout period to wait for user response.
901  * Set to 0 for no time out limit.
902  */
903  int timeout;
904 
905  /**
906  * Default response when time out.
907  */
909 
910  /**
911  * Requestor ID
912  */
913  char requestor_id[GPS_NI_SHORT_STRING_MAXLEN];
914 
915  /**
916  * Notification message. It can also be used to store client_id in some cases
917  */
919 
920  /**
921  * Client name decoding scheme
922  */
924 
925  /**
926  * Client name decoding scheme
927  */
929 
930  /**
931  * A pointer to extra data. Format:
932  * key_1 = value_1
933  * key_2 = value_2
934  */
936 
938 
939 /** Callback with NI notification.
940  * Can only be called from a thread created by create_thread_cb.
941  */
942 typedef void (*gps_ni_notify_callback)(GpsNiNotification *notification);
943 
944 /** GPS NI callback structure. */
945 typedef struct
946 {
947  /**
948  * Sends the notification request from HAL to GPSLocationProvider.
949  */
953 
954 /**
955  * Extended interface for Network-initiated (NI) support.
956  */
957 typedef struct
958 {
959  /** set to sizeof(GpsNiInterface) */
960  size_t size;
961 
962  /** Registers the callbacks for HAL to use. */
963  void (*init) (GpsNiCallbacks *callbacks);
964 
965  /** Sends a response to HAL. */
966  void (*respond) (int notif_id, GpsUserResponseType user_response);
968 
969 struct gps_device_t {
971 
972  /**
973  * Set the provided lights to the provided values.
974  *
975  * Returns: 0 on succes, error code on failure.
976  */
977  const GpsInterface* (*get_gps_interface)(struct gps_device_t* dev);
978 };
979 
980 #define AGPS_RIL_REQUEST_SETID_IMSI (1<<0L)
981 #define AGPS_RIL_REQUEST_SETID_MSISDN (1<<1L)
982 
983 #define AGPS_RIL_REQUEST_REFLOC_CELLID (1<<0L)
984 #define AGPS_RIL_REQUEST_REFLOC_MAC (1<<1L)
985 
986 typedef void (*agps_ril_request_set_id)(uint32_t flags);
987 typedef void (*agps_ril_request_ref_loc)(uint32_t flags);
988 
989 typedef struct {
994 
995 /** Extended interface for AGPS_RIL support. */
996 typedef struct {
997  /** set to sizeof(AGpsRilInterface) */
998  size_t size;
999  /**
1000  * Opens the AGPS interface and provides the callback routines
1001  * to the implementation of this interface.
1002  */
1003  void (*init)( AGpsRilCallbacks* callbacks );
1004 
1005  /**
1006  * Sets the reference location.
1007  */
1008  void (*set_ref_location) (const AGpsRefLocation *agps_reflocation, size_t sz_struct);
1009  /**
1010  * Sets the set ID.
1011  */
1012  void (*set_set_id) (AGpsSetIDType type, const char* setid);
1013 
1014  /**
1015  * Send network initiated message.
1016  */
1017  void (*ni_message) (uint8_t *msg, size_t len);
1018 
1019  /**
1020  * Notify GPS of network status changes.
1021  * These parameters match values in the android.net.NetworkInfo class.
1022  */
1023  void (*update_network_state) (int connected, int type, int roaming, const char* extra_info);
1024 
1025  /**
1026  * Notify GPS of network status changes.
1027  * These parameters match values in the android.net.NetworkInfo class.
1028  */
1029  void (*update_network_availability) (int avaiable, const char* apn);
1031 
1032 /**
1033  * GPS Geofence.
1034  * There are 3 states associated with a Geofence: Inside, Outside, Unknown.
1035  * There are 3 transitions: ENTERED, EXITED, UNCERTAIN.
1036  *
1037  * An example state diagram with confidence level: 95% and Unknown time limit
1038  * set as 30 secs is shown below. (confidence level and Unknown time limit are
1039  * explained latter)
1040  * ____________________________
1041  * | Unknown (30 secs) |
1042  * """"""""""""""""""""""""""""
1043  * ^ | | ^
1044  * UNCERTAIN| |ENTERED EXITED| |UNCERTAIN
1045  * | v v |
1046  * ________ EXITED _________
1047  * | Inside | -----------> | Outside |
1048  * | | <----------- | |
1049  * """""""" ENTERED """""""""
1050  *
1051  * Inside state: We are 95% confident that the user is inside the geofence.
1052  * Outside state: We are 95% confident that the user is outside the geofence
1053  * Unknown state: Rest of the time.
1054  *
1055  * The Unknown state is better explained with an example:
1056  *
1057  * __________
1058  * | c|
1059  * | ___ | _______
1060  * | |a| | | b |
1061  * | """ | """""""
1062  * | |
1063  * """"""""""
1064  * In the diagram above, "a" and "b" are 2 geofences and "c" is the accuracy
1065  * circle reported by the GPS subsystem. Now with regard to "b", the system is
1066  * confident that the user is outside. But with regard to "a" is not confident
1067  * whether it is inside or outside the geofence. If the accuracy remains the
1068  * same for a sufficient period of time, the UNCERTAIN transition would be
1069  * triggered with the state set to Unknown. If the accuracy improves later, an
1070  * appropriate transition should be triggered. This "sufficient period of time"
1071  * is defined by the parameter in the add_geofence_area API.
1072  * In other words, Unknown state can be interpreted as a state in which the
1073  * GPS subsystem isn't confident enough that the user is either inside or
1074  * outside the Geofence. It moves to Unknown state only after the expiry of the
1075  * timeout.
1076  *
1077  * The geofence callback needs to be triggered for the ENTERED and EXITED
1078  * transitions, when the GPS system is confident that the user has entered
1079  * (Inside state) or exited (Outside state) the Geofence. An implementation
1080  * which uses a value of 95% as the confidence is recommended. The callback
1081  * should be triggered only for the transitions requested by the
1082  * add_geofence_area call.
1083  *
1084  * Even though the diagram and explanation talks about states and transitions,
1085  * the callee is only interested in the transistions. The states are mentioned
1086  * here for illustrative purposes.
1087  *
1088  * Startup Scenario: When the device boots up, if an application adds geofences,
1089  * and then we get an accurate GPS location fix, it needs to trigger the
1090  * appropriate (ENTERED or EXITED) transition for every Geofence it knows about.
1091  * By default, all the Geofences will be in the Unknown state.
1092  *
1093  * When the GPS system is unavailable, gps_geofence_status_callback should be
1094  * called to inform the upper layers of the same. Similarly, when it becomes
1095  * available the callback should be called. This is a global state while the
1096  * UNKNOWN transition described above is per geofence.
1097  *
1098  * An important aspect to note is that users of this API (framework), will use
1099  * other subsystems like wifi, sensors, cell to handle Unknown case and
1100  * hopefully provide a definitive state transition to the third party
1101  * application. GPS Geofence will just be a signal indicating what the GPS
1102  * subsystem knows about the Geofence.
1103  *
1104  */
1105 #define GPS_GEOFENCE_ENTERED (1<<0L)
1106 #define GPS_GEOFENCE_EXITED (1<<1L)
1107 #define GPS_GEOFENCE_UNCERTAIN (1<<2L)
1108 
1109 #define GPS_GEOFENCE_UNAVAILABLE (1<<0L)
1110 #define GPS_GEOFENCE_AVAILABLE (1<<1L)
1111 
1112 #define GPS_GEOFENCE_OPERATION_SUCCESS 0
1113 #define GPS_GEOFENCE_ERROR_TOO_MANY_GEOFENCES -100
1114 #define GPS_GEOFENCE_ERROR_ID_EXISTS -101
1115 #define GPS_GEOFENCE_ERROR_ID_UNKNOWN -102
1116 #define GPS_GEOFENCE_ERROR_INVALID_TRANSITION -103
1117 #define GPS_GEOFENCE_ERROR_GENERIC -149
1118 
1119 /**
1120  * The callback associated with the geofence.
1121  * Parameters:
1122  * geofence_id - The id associated with the add_geofence_area.
1123  * location - The current GPS location.
1124  * transition - Can be one of GPS_GEOFENCE_ENTERED, GPS_GEOFENCE_EXITED,
1125  * GPS_GEOFENCE_UNCERTAIN.
1126  * timestamp - Timestamp when the transition was detected.
1127  *
1128  * The callback should only be called when the caller is interested in that
1129  * particular transition. For instance, if the caller is interested only in
1130  * ENTERED transition, then the callback should NOT be called with the EXITED
1131  * transition.
1132  *
1133  * IMPORTANT: If a transition is triggered resulting in this callback, the GPS
1134  * subsystem will wake up the application processor, if its in suspend state.
1135  */
1136 typedef void (*gps_geofence_transition_callback) (int32_t geofence_id, GpsLocation* location,
1137  int32_t transition, GpsUtcTime timestamp);
1138 
1139 /**
1140  * The callback associated with the availability of the GPS system for geofencing
1141  * monitoring. If the GPS system determines that it cannot monitor geofences
1142  * because of lack of reliability or unavailability of the GPS signals, it will
1143  * call this callback with GPS_GEOFENCE_UNAVAILABLE parameter.
1144  *
1145  * Parameters:
1146  * status - GPS_GEOFENCE_UNAVAILABLE or GPS_GEOFENCE_AVAILABLE.
1147  * last_location - Last known location.
1148  */
1149 typedef void (*gps_geofence_status_callback) (int32_t status, GpsLocation* last_location);
1150 
1151 /**
1152  * The callback associated with the add_geofence call.
1153  *
1154  * Parameter:
1155  * geofence_id - Id of the geofence.
1156  * status - GPS_GEOFENCE_OPERATION_SUCCESS
1157  * GPS_GEOFENCE_ERROR_TOO_MANY_GEOFENCES - geofence limit has been reached.
1158  * GPS_GEOFENCE_ERROR_ID_EXISTS - geofence with id already exists
1159  * GPS_GEOFENCE_ERROR_INVALID_TRANSITION - the monitorTransition contains an
1160  * invalid transition
1161  * GPS_GEOFENCE_ERROR_GENERIC - for other errors.
1162  */
1163 typedef void (*gps_geofence_add_callback) (int32_t geofence_id, int32_t status);
1164 
1165 /**
1166  * The callback associated with the remove_geofence call.
1167  *
1168  * Parameter:
1169  * geofence_id - Id of the geofence.
1170  * status - GPS_GEOFENCE_OPERATION_SUCCESS
1171  * GPS_GEOFENCE_ERROR_ID_UNKNOWN - for invalid id
1172  * GPS_GEOFENCE_ERROR_GENERIC for others.
1173  */
1174 typedef void (*gps_geofence_remove_callback) (int32_t geofence_id, int32_t status);
1175 
1176 
1177 /**
1178  * The callback associated with the pause_geofence call.
1179  *
1180  * Parameter:
1181  * geofence_id - Id of the geofence.
1182  * status - GPS_GEOFENCE_OPERATION_SUCCESS
1183  * GPS_GEOFENCE_ERROR_ID_UNKNOWN - for invalid id
1184  * GPS_GEOFENCE_ERROR_INVALID_TRANSITION -
1185  * when monitor_transitions is invalid
1186  * GPS_GEOFENCE_ERROR_GENERIC for others.
1187  */
1188 typedef void (*gps_geofence_pause_callback) (int32_t geofence_id, int32_t status);
1189 
1190 /**
1191  * The callback associated with the resume_geofence call.
1192  *
1193  * Parameter:
1194  * geofence_id - Id of the geofence.
1195  * status - GPS_GEOFENCE_OPERATION_SUCCESS
1196  * GPS_GEOFENCE_ERROR_ID_UNKNOWN - for invalid id
1197  * GPS_GEOFENCE_ERROR_GENERIC for others.
1198  */
1199 typedef void (*gps_geofence_resume_callback) (int32_t geofence_id, int32_t status);
1200 
1201 typedef struct {
1210 
1211 /** Extended interface for GPS_Geofencing support */
1212 typedef struct {
1213  /** set to sizeof(GpsGeofencingInterface) */
1214  size_t size;
1215 
1216  /**
1217  * Opens the geofence interface and provides the callback routines
1218  * to the implementation of this interface.
1219  */
1220  void (*init)( GpsGeofenceCallbacks* callbacks );
1221 
1222  /**
1223  * Add a geofence area. This api currently supports circular geofences.
1224  * Parameters:
1225  * geofence_id - The id for the geofence. If a geofence with this id
1226  * already exists, an error value (GPS_GEOFENCE_ERROR_ID_EXISTS)
1227  * should be returned.
1228  * latitude, longtitude, radius_meters - The lat, long and radius
1229  * (in meters) for the geofence
1230  * last_transition - The current state of the geofence. For example, if
1231  * the system already knows that the user is inside the geofence,
1232  * this will be set to GPS_GEOFENCE_ENTERED. In most cases, it
1233  * will be GPS_GEOFENCE_UNCERTAIN.
1234  * monitor_transition - Which transitions to monitor. Bitwise OR of
1235  * GPS_GEOFENCE_ENTERED, GPS_GEOFENCE_EXITED and
1236  * GPS_GEOFENCE_UNCERTAIN.
1237  * notification_responsiveness_ms - Defines the best-effort description
1238  * of how soon should the callback be called when the transition
1239  * associated with the Geofence is triggered. For instance, if set
1240  * to 1000 millseconds with GPS_GEOFENCE_ENTERED, the callback
1241  * should be called 1000 milliseconds within entering the geofence.
1242  * This parameter is defined in milliseconds.
1243  * NOTE: This is not to be confused with the rate that the GPS is
1244  * polled at. It is acceptable to dynamically vary the rate of
1245  * sampling the GPS for power-saving reasons; thus the rate of
1246  * sampling may be faster or slower than this.
1247  * unknown_timer_ms - The time limit after which the UNCERTAIN transition
1248  * should be triggered. This parameter is defined in milliseconds.
1249  * See above for a detailed explanation.
1250  */
1251  void (*add_geofence_area) (int32_t geofence_id, double latitude, double longitude,
1252  double radius_meters, int last_transition, int monitor_transitions,
1253  int notification_responsiveness_ms, int unknown_timer_ms);
1254 
1255  /**
1256  * Pause monitoring a particular geofence.
1257  * Parameters:
1258  * geofence_id - The id for the geofence.
1259  */
1260  void (*pause_geofence) (int32_t geofence_id);
1261 
1262  /**
1263  * Resume monitoring a particular geofence.
1264  * Parameters:
1265  * geofence_id - The id for the geofence.
1266  * monitor_transitions - Which transitions to monitor. Bitwise OR of
1267  * GPS_GEOFENCE_ENTERED, GPS_GEOFENCE_EXITED and
1268  * GPS_GEOFENCE_UNCERTAIN.
1269  * This supersedes the value associated provided in the
1270  * add_geofence_area call.
1271  */
1272  void (*resume_geofence) (int32_t geofence_id, int monitor_transitions);
1273 
1274  /**
1275  * Remove a geofence area. After the function returns, no notifications
1276  * should be sent.
1277  * Parameter:
1278  * geofence_id - The id for the geofence.
1279  */
1280  void (*remove_geofence_area) (int32_t geofence_id);
1282 
1283 
1284 /**
1285  * Represents an estimate of the GPS clock time.
1286  */
1287 typedef struct {
1288  /** set to sizeof(GpsClock) */
1289  size_t size;
1290 
1291  /** A set of flags indicating the validity of the fields in this data structure. */
1293 
1294  /**
1295  * Leap second data.
1296  * The sign of the value is defined by the following equation:
1297  * utc_time_ns = time_ns + (full_bias_ns + bias_ns) - leap_second * 1,000,000,000
1298  *
1299  * If the data is available 'flags' must contain GPS_CLOCK_HAS_LEAP_SECOND.
1300  */
1301  int16_t leap_second;
1302 
1303  /**
1304  * Indicates the type of time reported by the 'time_ns' field.
1305  * This is a Mandatory field.
1306  */
1308 
1309  /**
1310  * The GPS receiver internal clock value. This can be either the local hardware clock value
1311  * (GPS_CLOCK_TYPE_LOCAL_HW_TIME), or the current GPS time derived inside GPS receiver
1312  * (GPS_CLOCK_TYPE_GPS_TIME). The field 'type' defines the time reported.
1313  *
1314  * For local hardware clock, this value is expected to be monotonically increasing during
1315  * the reporting session. The real GPS time can be derived by compensating the 'full bias'
1316  * (when it is available) from this value.
1317  *
1318  * For GPS time, this value is expected to be the best estimation of current GPS time that GPS
1319  * receiver can achieve. Set the 'time uncertainty' appropriately when GPS time is specified.
1320  *
1321  * Sub-nanosecond accuracy can be provided by means of the 'bias' field.
1322  * The value contains the 'time uncertainty' in it.
1323  *
1324  * This is a Mandatory field.
1325  */
1326  int64_t time_ns;
1327 
1328  /**
1329  * 1-Sigma uncertainty associated with the clock's time in nanoseconds.
1330  * The uncertainty is represented as an absolute (single sided) value.
1331  *
1332  * This value should be set if GPS_CLOCK_TYPE_GPS_TIME is set.
1333  * If the data is available 'flags' must contain GPS_CLOCK_HAS_TIME_UNCERTAINTY.
1334  */
1336 
1337  /**
1338  * The difference between hardware clock ('time' field) inside GPS receiver and the true GPS
1339  * time since 0000Z, January 6, 1980, in nanoseconds.
1340  * This value is used if and only if GPS_CLOCK_TYPE_LOCAL_HW_TIME is set, and GPS receiver
1341  * has solved the clock for GPS time.
1342  * The caller is responsible for using the 'bias uncertainty' field for quality check.
1343  *
1344  * The sign of the value is defined by the following equation:
1345  * true time (GPS time) = time_ns + (full_bias_ns + bias_ns)
1346  *
1347  * This value contains the 'bias uncertainty' in it.
1348  * If the data is available 'flags' must contain GPS_CLOCK_HAS_FULL_BIAS.
1349 
1350  */
1351  int64_t full_bias_ns;
1352 
1353  /**
1354  * Sub-nanosecond bias.
1355  * The value contains the 'bias uncertainty' in it.
1356  *
1357  * If the data is available 'flags' must contain GPS_CLOCK_HAS_BIAS.
1358  */
1359  double bias_ns;
1360 
1361  /**
1362  * 1-Sigma uncertainty associated with the clock's bias in nanoseconds.
1363  * The uncertainty is represented as an absolute (single sided) value.
1364  *
1365  * If the data is available 'flags' must contain GPS_CLOCK_HAS_BIAS_UNCERTAINTY.
1366  */
1368 
1369  /**
1370  * The clock's drift in nanoseconds (per second).
1371  * A positive value means that the frequency is higher than the nominal frequency.
1372  *
1373  * The value contains the 'drift uncertainty' in it.
1374  * If the data is available 'flags' must contain GPS_CLOCK_HAS_DRIFT.
1375  *
1376  * If GpsMeasurement's 'flags' field contains GPS_MEASUREMENT_HAS_UNCORRECTED_PSEUDORANGE_RATE,
1377  * it is encouraged that this field is also provided.
1378  */
1379  double drift_nsps;
1380 
1381  /**
1382  * 1-Sigma uncertainty associated with the clock's drift in nanoseconds (per second).
1383  * The uncertainty is represented as an absolute (single sided) value.
1384  *
1385  * If the data is available 'flags' must contain GPS_CLOCK_HAS_DRIFT_UNCERTAINTY.
1386  */
1388 } GpsClock;
1389 
1390 /**
1391  * Represents a GPS Measurement, it contains raw and computed information.
1392  */
1393 typedef struct {
1394  /** set to sizeof(GpsMeasurement) */
1395  size_t size;
1396 
1397  /** A set of flags indicating the validity of the fields in this data structure. */
1399 
1400  /**
1401  * Pseudo-random number in the range of [1, 32]
1402  * This is a Mandatory value.
1403  */
1404  int8_t prn;
1405 
1406  /**
1407  * Time offset at which the measurement was taken in nanoseconds.
1408  * The reference receiver's time is specified by GpsData::clock::time_ns and should be
1409  * interpreted in the same way as indicated by GpsClock::type.
1410  *
1411  * The sign of time_offset_ns is given by the following equation:
1412  * measurement time = GpsClock::time_ns + time_offset_ns
1413  *
1414  * It provides an individual time-stamp for the measurement, and allows sub-nanosecond accuracy.
1415  * This is a Mandatory value.
1416  */
1418 
1419  /**
1420  * Per satellite sync state. It represents the current sync state for the associated satellite.
1421  * Based on the sync state, the 'received GPS tow' field should be interpreted accordingly.
1422  *
1423  * This is a Mandatory value.
1424  */
1426 
1427  /**
1428  * Received GPS Time-of-Week at the measurement time, in nanoseconds.
1429  * The value is relative to the beginning of the current GPS week.
1430  *
1431  * Given the highest sync state that can be achieved, per each satellite, valid range for
1432  * this field can be:
1433  * Searching : [ 0 ] : GPS_MEASUREMENT_STATE_UNKNOWN
1434  * C/A code lock : [ 0 1ms ] : GPS_MEASUREMENT_STATE_CODE_LOCK is set
1435  * Bit sync : [ 0 20ms ] : GPS_MEASUREMENT_STATE_BIT_SYNC is set
1436  * Subframe sync : [ 0 6s ] : GPS_MEASUREMENT_STATE_SUBFRAME_SYNC is set
1437  * TOW decoded : [ 0 1week ] : GPS_MEASUREMENT_STATE_TOW_DECODED is set
1438  *
1439  * However, if there is any ambiguity in integer millisecond,
1440  * GPS_MEASUREMENT_STATE_MSEC_AMBIGUOUS should be set accordingly, in the 'state' field.
1441  *
1442  * This value must be populated if 'state' != GPS_MEASUREMENT_STATE_UNKNOWN.
1443  */
1445 
1446  /**
1447  * 1-Sigma uncertainty of the Received GPS Time-of-Week in nanoseconds.
1448  *
1449  * This value must be populated if 'state' != GPS_MEASUREMENT_STATE_UNKNOWN.
1450  */
1452 
1453  /**
1454  * Carrier-to-noise density in dB-Hz, in the range [0, 63].
1455  * It contains the measured C/N0 value for the signal at the antenna input.
1456  *
1457  * This is a Mandatory value.
1458  */
1459  double c_n0_dbhz;
1460 
1461  /**
1462  * Pseudorange rate at the timestamp in m/s.
1463  * The correction of a given Pseudorange Rate value includes corrections for receiver and
1464  * satellite clock frequency errors.
1465  *
1466  * If GPS_MEASUREMENT_HAS_UNCORRECTED_PSEUDORANGE_RATE is set in 'flags' field, this field must
1467  * be populated with the 'uncorrected' reading.
1468  * If GPS_MEASUREMENT_HAS_UNCORRECTED_PSEUDORANGE_RATE is not set in 'flags' field, this field
1469  * must be populated with the 'corrected' reading. This is the default behavior.
1470  *
1471  * It is encouraged to provide the 'uncorrected' 'pseudorange rate', and provide GpsClock's
1472  * 'drift' field as well.
1473  *
1474  * The value includes the 'pseudorange rate uncertainty' in it.
1475  * A positive 'uncorrected' value indicates that the SV is moving away from the receiver.
1476  *
1477  * The sign of the 'uncorrected' 'pseudorange rate' and its relation to the sign of 'doppler
1478  * shift' is given by the equation:
1479  * pseudorange rate = -k * doppler shift (where k is a constant)
1480  *
1481  * This is a Mandatory value.
1482  */
1484 
1485  /**
1486  * 1-Sigma uncertainty of the pseudurange rate in m/s.
1487  * The uncertainty is represented as an absolute (single sided) value.
1488  *
1489  * This is a Mandatory value.
1490  */
1492 
1493  /**
1494  * Accumulated delta range's state. It indicates whether ADR is reset or there is a cycle slip
1495  * (indicating loss of lock).
1496  *
1497  * This is a Mandatory value.
1498  */
1500 
1501  /**
1502  * Accumulated delta range since the last channel reset in meters.
1503  * A positive value indicates that the SV is moving away from the receiver.
1504  *
1505  * The sign of the 'accumulated delta range' and its relation to the sign of 'carrier phase'
1506  * is given by the equation:
1507  * accumulated delta range = -k * carrier phase (where k is a constant)
1508  *
1509  * This value must be populated if 'accumulated delta range state' != GPS_ADR_STATE_UNKNOWN.
1510  * However, it is expected that the data is only accurate when:
1511  * 'accumulated delta range state' == GPS_ADR_STATE_VALID.
1512  */
1514 
1515  /**
1516  * 1-Sigma uncertainty of the accumulated delta range in meters.
1517  * This value must be populated if 'accumulated delta range state' != GPS_ADR_STATE_UNKNOWN.
1518  */
1520 
1521  /**
1522  * Best derived Pseudorange by the chip-set, in meters.
1523  * The value contains the 'pseudorange uncertainty' in it.
1524  *
1525  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_PSEUDORANGE.
1526  */
1528 
1529  /**
1530  * 1-Sigma uncertainty of the pseudorange in meters.
1531  * The value contains the 'pseudorange' and 'clock' uncertainty in it.
1532  * The uncertainty is represented as an absolute (single sided) value.
1533  *
1534  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_PSEUDORANGE_UNCERTAINTY.
1535  */
1537 
1538  /**
1539  * A fraction of the current C/A code cycle, in the range [0.0, 1023.0]
1540  * This value contains the time (in Chip units) since the last C/A code cycle (GPS Msec epoch).
1541  *
1542  * The reference frequency is given by the field 'carrier_frequency_hz'.
1543  * The value contains the 'code-phase uncertainty' in it.
1544  *
1545  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_CODE_PHASE.
1546  */
1548 
1549  /**
1550  * 1-Sigma uncertainty of the code-phase, in a fraction of chips.
1551  * The uncertainty is represented as an absolute (single sided) value.
1552  *
1553  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_CODE_PHASE_UNCERTAINTY.
1554  */
1556 
1557  /**
1558  * Carrier frequency at which codes and messages are modulated, it can be L1 or L2.
1559  * If the field is not set, the carrier frequency is assumed to be L1.
1560  *
1561  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_CARRIER_FREQUENCY.
1562  */
1564 
1565  /**
1566  * The number of full carrier cycles between the satellite and the receiver.
1567  * The reference frequency is given by the field 'carrier_frequency_hz'.
1568  *
1569  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_CARRIER_CYCLES.
1570  */
1572 
1573  /**
1574  * The RF phase detected by the receiver, in the range [0.0, 1.0].
1575  * This is usually the fractional part of the complete carrier phase measurement.
1576  *
1577  * The reference frequency is given by the field 'carrier_frequency_hz'.
1578  * The value contains the 'carrier-phase uncertainty' in it.
1579  *
1580  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_CARRIER_PHASE.
1581  */
1583 
1584  /**
1585  * 1-Sigma uncertainty of the carrier-phase.
1586  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_CARRIER_PHASE_UNCERTAINTY.
1587  */
1589 
1590  /**
1591  * An enumeration that indicates the 'loss of lock' state of the event.
1592  */
1594 
1595  /**
1596  * The number of GPS bits transmitted since Sat-Sun midnight (GPS week).
1597  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_BIT_NUMBER.
1598  */
1599  int32_t bit_number;
1600 
1601  /**
1602  * The elapsed time since the last received bit in milliseconds, in the range [0, 20]
1603  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_TIME_FROM_LAST_BIT.
1604  */
1606 
1607  /**
1608  * Doppler shift in Hz.
1609  * A positive value indicates that the SV is moving toward the receiver.
1610  *
1611  * The reference frequency is given by the field 'carrier_frequency_hz'.
1612  * The value contains the 'doppler shift uncertainty' in it.
1613  *
1614  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_DOPPLER_SHIFT.
1615  */
1617 
1618  /**
1619  * 1-Sigma uncertainty of the doppler shift in Hz.
1620  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_DOPPLER_SHIFT_UNCERTAINTY.
1621  */
1623 
1624  /**
1625  * An enumeration that indicates the 'multipath' state of the event.
1626  */
1628 
1629  /**
1630  * Signal-to-noise ratio in dB.
1631  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_SNR.
1632  */
1633  double snr_db;
1634 
1635  /**
1636  * Elevation in degrees, the valid range is [-90, 90].
1637  * The value contains the 'elevation uncertainty' in it.
1638  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_ELEVATION.
1639  */
1641 
1642  /**
1643  * 1-Sigma uncertainty of the elevation in degrees, the valid range is [0, 90].
1644  * The uncertainty is represented as the absolute (single sided) value.
1645  *
1646  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_ELEVATION_UNCERTAINTY.
1647  */
1649 
1650  /**
1651  * Azimuth in degrees, in the range [0, 360).
1652  * The value contains the 'azimuth uncertainty' in it.
1653  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_AZIMUTH.
1654  * */
1655  double azimuth_deg;
1656 
1657  /**
1658  * 1-Sigma uncertainty of the azimuth in degrees, the valid range is [0, 180].
1659  * The uncertainty is represented as an absolute (single sided) value.
1660  *
1661  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_AZIMUTH_UNCERTAINTY.
1662  */
1664 
1665  /**
1666  * Whether the GPS represented by the measurement was used for computing the most recent fix.
1667  * If the data is available, 'flags' must contain GPS_MEASUREMENT_HAS_USED_IN_FIX.
1668  */
1670 } GpsMeasurement;
1671 
1672 /** Represents a reading of GPS measurements. */
1673 typedef struct {
1674  /** set to sizeof(GpsData) */
1675  size_t size;
1676 
1677  /** Number of measurements. */
1679 
1680  /** The array of measurements. */
1682 
1683  /** The GPS clock time reading. */
1685 } GpsData;
1686 
1687 /**
1688  * The callback for to report measurements from the HAL.
1689  *
1690  * Parameters:
1691  * data - A data structure containing the measurements.
1692  */
1693 typedef void (*gps_measurement_callback) (GpsData* data);
1694 
1695 typedef struct {
1696  /** set to sizeof(GpsMeasurementCallbacks) */
1697  size_t size;
1700 
1701 #define GPS_MEASUREMENT_OPERATION_SUCCESS 0
1702 #define GPS_MEASUREMENT_ERROR_ALREADY_INIT -100
1703 #define GPS_MEASUREMENT_ERROR_GENERIC -101
1704 
1705 /**
1706  * Extended interface for GPS Measurements support.
1707  */
1708 typedef struct {
1709  /** Set to sizeof(GpsMeasurementInterface) */
1710  size_t size;
1711 
1712  /**
1713  * Initializes the interface and registers the callback routines with the HAL.
1714  * After a successful call to 'init' the HAL must begin to provide updates at its own phase.
1715  *
1716  * Status:
1717  * GPS_MEASUREMENT_OPERATION_SUCCESS
1718  * GPS_MEASUREMENT_ERROR_ALREADY_INIT - if a callback has already been registered without a
1719  * corresponding call to 'close'
1720  * GPS_MEASUREMENT_ERROR_GENERIC - if any other error occurred, it is expected that the HAL
1721  * will not generate any updates upon returning this error code.
1722  */
1723  int (*init) (GpsMeasurementCallbacks* callbacks);
1724 
1725  /**
1726  * Stops updates from the HAL, and unregisters the callback routines.
1727  * After a call to stop, the previously registered callbacks must be considered invalid by the
1728  * HAL.
1729  * If stop is invoked without a previous 'init', this function should perform no work.
1730  */
1731  void (*close) ();
1732 
1734 
1735 
1736 /** Represents a GPS navigation message (or a fragment of it). */
1737 typedef struct {
1738  /** set to sizeof(GpsNavigationMessage) */
1739  size_t size;
1740 
1741  /**
1742  * Pseudo-random number in the range of [1, 32]
1743  * This is a Mandatory value.
1744  */
1745  int8_t prn;
1746 
1747  /**
1748  * The type of message contained in the structure.
1749  * This is a Mandatory value.
1750  */
1752 
1753  /**
1754  * The status of the received navigation message.
1755  * No need to send any navigation message that contains words with parity error and cannot be
1756  * corrected.
1757  */
1759 
1760  /**
1761  * Message identifier.
1762  * It provides an index so the complete Navigation Message can be assembled. i.e. fo L1 C/A
1763  * subframe 4 and 5, this value corresponds to the 'frame id' of the navigation message.
1764  * Subframe 1, 2, 3 does not contain a 'frame id' and this value can be set to -1.
1765  */
1766  int16_t message_id;
1767 
1768  /**
1769  * Sub-message identifier.
1770  * If required by the message 'type', this value contains a sub-index within the current
1771  * message (or frame) that is being transmitted.
1772  * i.e. for L1 C/A the submessage id corresponds to the sub-frame id of the navigation message.
1773  */
1774  int16_t submessage_id;
1775 
1776  /**
1777  * The length of the data (in bytes) contained in the current message.
1778  * If this value is different from zero, 'data' must point to an array of the same size.
1779  * e.g. for L1 C/A the size of the sub-frame will be 40 bytes (10 words, 30 bits/word).
1780  *
1781  * This is a Mandatory value.
1782  */
1783  size_t data_length;
1784 
1785  /**
1786  * The data of the reported GPS message.
1787  * The bytes (or words) specified using big endian format (MSB first).
1788  *
1789  * For L1 C/A, each subframe contains 10 30-bit GPS words. Each GPS word (30 bits) should be
1790  * fitted into the last 30 bits in a 4-byte word (skip B31 and B32), with MSB first.
1791  */
1792  uint8_t* data;
1793 
1795 
1796 /**
1797  * The callback to report an available fragment of a GPS navigation messages from the HAL.
1798  *
1799  * Parameters:
1800  * message - The GPS navigation submessage/subframe representation.
1801  */
1803 
1804 typedef struct {
1805  /** set to sizeof(GpsNavigationMessageCallbacks) */
1806  size_t size;
1809 
1810 #define GPS_NAVIGATION_MESSAGE_OPERATION_SUCCESS 0
1811 #define GPS_NAVIGATION_MESSAGE_ERROR_ALREADY_INIT -100
1812 #define GPS_NAVIGATION_MESSAGE_ERROR_GENERIC -101
1813 
1814 /**
1815  * Extended interface for GPS navigation message reporting support.
1816  */
1817 typedef struct {
1818  /** Set to sizeof(GpsNavigationMessageInterface) */
1819  size_t size;
1820 
1821  /**
1822  * Initializes the interface and registers the callback routines with the HAL.
1823  * After a successful call to 'init' the HAL must begin to provide updates as they become
1824  * available.
1825  *
1826  * Status:
1827  * GPS_NAVIGATION_MESSAGE_OPERATION_SUCCESS
1828  * GPS_NAVIGATION_MESSAGE_ERROR_ALREADY_INIT - if a callback has already been registered
1829  * without a corresponding call to 'close'.
1830  * GPS_NAVIGATION_MESSAGE_ERROR_GENERIC - if any other error occurred, it is expected that
1831  * the HAL will not generate any updates upon returning this error code.
1832  */
1833  int (*init) (GpsNavigationMessageCallbacks* callbacks);
1834 
1835  /**
1836  * Stops updates from the HAL, and unregisters the callback routines.
1837  * After a call to stop, the previously registered callbacks must be considered invalid by the
1838  * HAL.
1839  * If stop is invoked without a previous 'init', this function should perform no work.
1840  */
1841  void (*close) ();
1842 
1844 
1845 /**
1846  * Interface for passing GNSS configuration contents from platform to HAL.
1847  */
1848 typedef struct {
1849  /** Set to sizeof(GnssConfigurationInterface) */
1850  size_t size;
1851 
1852  /**
1853  * Deliver GNSS configuration contents to HAL.
1854  * Parameters:
1855  * config_data - a pointer to a char array which holds what usually is expected from
1856  file(/etc/gps.conf), i.e., a sequence of UTF8 strings separated by '\n'.
1857  * length - total number of UTF8 characters in configuraiton data.
1858  *
1859  * IMPORTANT:
1860  * GPS HAL should expect this function can be called multiple times. And it may be
1861  * called even when GpsLocationProvider is already constructed and enabled. GPS HAL
1862  * should maintain the existing requests for various callback regardless the change
1863  * in configuration data.
1864  */
1865  void (*configuration_update) (const char* config_data, int32_t length);
1867 
1868 __END_DECLS
1869 
1870 #endif /* ANDROID_INCLUDE_HARDWARE_GPS_H */
1871 
void(* gps_geofence_add_callback)(int32_t geofence_id, int32_t status)
Definition: gps.h:1163
#define GPS_NI_SHORT_STRING_MAXLEN
Definition: gps.h:159
uint16_t type
Definition: gps.h:506
double carrier_phase
Definition: gps.h:1582
bool used_in_fix
Definition: gps.h:1669
float snr
Definition: gps.h:467
void(* gps_acquire_wakelock)()
Definition: gps.h:555
agps_status_callback status_cb
Definition: gps.h:733
double accumulated_delta_range_uncertainty_m
Definition: gps.h:1519
void(* gps_ni_notify_callback)(GpsNiNotification *notification)
Definition: gps.h:942
size_t size
Definition: gps.h:773
uint8_t * data
Definition: gps.h:1792
size_t size
Definition: gps.h:1675
int16_t message_id
Definition: gps.h:1766
double pseudorange_uncertainty_m
Definition: gps.h:1536
GpsStatusValue status
Definition: gps.h:457
size_t size
Definition: gps.h:654
double elevation_deg
Definition: gps.h:1640
uint16_t type
Definition: gps.h:519
float elevation
Definition: gps.h:469
double pseudorange_rate_mps
Definition: gps.h:1483
gps_create_thread create_thread_cb
Definition: gps.h:1208
gps_ni_notify_callback notify_cb
Definition: gps.h:950
int32_t bit_number
Definition: gps.h:1599
double accumulated_delta_range_m
Definition: gps.h:1513
uint32_t GpsNiType
Definition: gps.h:165
double time_offset_ns
Definition: gps.h:1417
u_char * data
Definition: gps.h:818
Definition: gps.h:1287
double snr_db
Definition: gps.h:1633
uint32_t GpsPositionMode
Definition: gps.h:47
GpsUserResponseType default_response
Definition: gps.h:908
uint16_t NavigationMessageStatus
Definition: gps.h:374
NavigationMessageStatus status
Definition: gps.h:1758
size_t size
Definition: gps.h:685
int GpsUserResponseType
Definition: gps.h:185
Definition: gps.h:1673
gps_geofence_add_callback geofence_add_callback
Definition: gps.h:1204
int8_t prn
Definition: gps.h:1404
int16_t leap_second
Definition: gps.h:1301
GpsUtcTime timestamp
Definition: gps.h:450
int64_t GpsUtcTime
Definition: gps.h:38
size_t size
Definition: gps.h:463
double latitude
Definition: gps.h:437
double code_phase_uncertainty_chips
Definition: gps.h:1555
void(* agps_status_callback)(AGpsStatus *status)
Definition: gps.h:729
gps_create_thread create_thread_cb
Definition: gps.h:992
uint16_t AGpsStatusValue
Definition: gps.h:201
double c_n0_dbhz
Definition: gps.h:1459
gps_set_capabilities set_capabilities_cb
Definition: gps.h:576
GpsNiNotifyFlags notify_flags
Definition: gps.h:897
int notification_id
Definition: gps.h:886
AGpsStatusValue status
Definition: gps.h:709
size_t size
Definition: gps.h:456
uint16_t lac
Definition: gps.h:509
void(* agps_ril_request_set_id)(uint32_t flags)
Definition: gps.h:986
GpsNiEncodingType text_encoding
Definition: gps.h:928
float accuracy
Definition: gps.h:448
GpsAccumulatedDeltaRangeState accumulated_delta_range_state
Definition: gps.h:1499
size_t size
Definition: gps.h:667
#define GPS_MAX_SVS
Definition: gps.h:41
uint32_t ephemeris_mask
Definition: gps.h:488
AGpsRefLocationMac mac
Definition: gps.h:522
double azimuth_uncertainty_deg
Definition: gps.h:1663
double azimuth_deg
Definition: gps.h:1655
#define GPS_MAX_MEASUREMENT
Definition: gps.h:44
size_t size
Definition: gps.h:706
void(* agps_ril_request_ref_loc)(uint32_t flags)
Definition: gps.h:987
size_t size
Definition: gps.h:477
void(* gps_location_callback)(GpsLocation *location)
Definition: gps.h:529
int16_t submessage_id
Definition: gps.h:1774
uint8_t GpsLossOfLock
Definition: gps.h:305
size_t size
Definition: gps.h:960
void(* gps_sv_status_callback)(GpsSvStatus *sv_info)
Definition: gps.h:540
uint32_t ipaddr
Definition: gps.h:715
double doppler_shift_uncertainty_hz
Definition: gps.h:1622
double pseudorange_m
Definition: gps.h:1527
#define GPS_NI_LONG_STRING_MAXLEN
Definition: gps.h:160
pthread_t(* gps_create_thread)(const char *name, void(*start)(void *), void *arg)
Definition: gps.h:566
int64_t carrier_cycles
Definition: gps.h:1571
double code_phase_chips
Definition: gps.h:1547
uint16_t GpsAidingData
Definition: gps.h:123
size_t size
Definition: gps.h:1395
Definition: gps.h:461
uint16_t ApnIpType
Definition: gps.h:150
void(* gps_status_callback)(GpsStatus *status)
Definition: gps.h:534
size_t size
Definition: gps.h:741
double carrier_phase_uncertainty
Definition: gps.h:1588
size_t size
Definition: gps.h:1289
gps_create_thread create_thread_cb
Definition: gps.h:951
uint16_t mcc
Definition: gps.h:507
int16_t time_from_last_bit_ms
Definition: gps.h:1605
AGpsRefLocationCellID cellID
Definition: gps.h:521
gps_geofence_transition_callback geofence_transition_callback
Definition: gps.h:1202
uint16_t GpsLocationFlags
Definition: gps.h:85
gps_create_thread create_thread_cb
Definition: gps.h:579
gps_measurement_callback measurement_callback
Definition: gps.h:1698
uint16_t mnc
Definition: gps.h:508
uint16_t GpsMeasurementState
Definition: gps.h:333
double bias_uncertainty_ns
Definition: gps.h:1367
double doppler_shift_hz
Definition: gps.h:1616
double longitude
Definition: gps.h:439
AGpsInterface_v2 AGpsInterface
Definition: gps.h:808
agps_ril_request_ref_loc request_refloc
Definition: gps.h:991
float azimuth
Definition: gps.h:471
uint16_t AGpsType
Definition: gps.h:141
AGpsStatusValue status
Definition: gps.h:699
gps_create_thread create_thread_cb
Definition: gps.h:734
gps_sv_status_callback sv_status_cb
Definition: gps.h:574
void(* gps_nmea_callback)(GpsUtcTime timestamp, const char *nmea, int length)
Definition: gps.h:545
gps_geofence_resume_callback geofence_resume_callback
Definition: gps.h:1207
uint32_t almanac_mask
Definition: gps.h:493
gps_status_callback status_cb
Definition: gps.h:573
AGpsType type
Definition: gps.h:698
Definition: gps.h:454
void(* gps_release_wakelock)()
Definition: gps.h:558
gps_geofence_pause_callback geofence_pause_callback
Definition: gps.h:1206
int64_t received_gps_tow_ns
Definition: gps.h:1444
size_t measurement_count
Definition: gps.h:1678
void(* gps_geofence_resume_callback)(int32_t geofence_id, int32_t status)
Definition: gps.h:1199
double elevation_uncertainty_deg
Definition: gps.h:1648
size_t size
Definition: gps.h:433
size_t size
Definition: gps.h:696
uint16_t AGpsSetIDType
Definition: gps.h:145
AGpsType type
Definition: gps.h:708
double time_uncertainty_ns
Definition: gps.h:1335
uint32_t ipaddr
Definition: gps.h:700
int64_t full_bias_ns
Definition: gps.h:1351
uint8_t GpsClockType
Definition: gps.h:248
uint16_t GpsStatusValue
Definition: gps.h:70
GpsNavigationMessageType type
Definition: gps.h:1751
GpsClockType type
Definition: gps.h:1307
struct hw_device_t common
Definition: gps.h:970
gps_nmea_callback nmea_cb
Definition: gps.h:575
float bearing
Definition: gps.h:446
double altitude
Definition: gps.h:442
int64_t received_gps_tow_uncertainty_ns
Definition: gps.h:1451
GpsMeasurementFlags flags
Definition: gps.h:1398
uint16_t GpsClockFlags
Definition: gps.h:229
int prn
Definition: gps.h:465
size_t size
Definition: gps.h:880
void(* gps_set_capabilities)(uint32_t capabilities)
Definition: gps.h:550
gps_create_thread create_thread_cb
Definition: gps.h:648
double drift_uncertainty_nsps
Definition: gps.h:1387
uint16_t GpsAccumulatedDeltaRangeState
Definition: gps.h:344
GpsMeasurementState state
Definition: gps.h:1425
int GpsNiEncodingType
Definition: gps.h:193
gps_request_utc_time request_utc_time_cb
Definition: gps.h:580
GpsNiType ni_type
Definition: gps.h:892
uint32_t cid
Definition: gps.h:510
uint16_t flags
Definition: gps.h:435
double bias_ns
Definition: gps.h:1359
void(* gps_geofence_status_callback)(int32_t status, GpsLocation *last_location)
Definition: gps.h:1149
void(* gps_geofence_transition_callback)(int32_t geofence_id, GpsLocation *location, int32_t transition, GpsUtcTime timestamp)
Definition: gps.h:1136
uint8_t GpsMultipathIndicator
Definition: gps.h:316
void(* gps_xtra_download_request)()
Definition: gps.h:643
gps_navigation_message_callback navigation_message_callback
Definition: gps.h:1807
AGpsStatusValue status
Definition: gps.h:688
uint8_t GpsNavigationMessageType
Definition: gps.h:353
void(* gps_geofence_pause_callback)(int32_t geofence_id, int32_t status)
Definition: gps.h:1188
size_t size
Definition: gps.h:571
uint32_t GpsNiNotifyFlags
Definition: gps.h:173
uint32_t GpsPositionRecurrence
Definition: gps.h:61
AGpsType type
Definition: gps.h:687
gps_xtra_download_request download_request_cb
Definition: gps.h:647
uint32_t used_in_fix_mask
Definition: gps.h:499
GpsNiEncodingType requestor_id_encoding
Definition: gps.h:923
size_t data_length
Definition: gps.h:1783
void(* gps_measurement_callback)(GpsData *data)
Definition: gps.h:1693
void(* gps_request_utc_time)()
Definition: gps.h:561
gps_geofence_remove_callback geofence_remove_callback
Definition: gps.h:1205
GpsMultipathIndicator multipath_indicator
Definition: gps.h:1627
gps_location_callback location_cb
Definition: gps.h:572
float speed
Definition: gps.h:444
int num_svs
Definition: gps.h:480
gps_geofence_status_callback geofence_status_callback
Definition: gps.h:1203
size_t size
Definition: gps.h:587
double drift_nsps
Definition: gps.h:1379
gps_acquire_wakelock acquire_wakelock_cb
Definition: gps.h:577
GpsClock clock
Definition: gps.h:1684
float carrier_frequency_hz
Definition: gps.h:1563
void(* gps_geofence_remove_callback)(int32_t geofence_id, int32_t status)
Definition: gps.h:1174
void(* gps_navigation_message_callback)(GpsNavigationMessage *message)
Definition: gps.h:1802
GpsClockFlags flags
Definition: gps.h:1292
uint32_t GpsMeasurementFlags
Definition: gps.h:262
size_t size
Definition: gps.h:998
GpsLossOfLock loss_of_lock
Definition: gps.h:1593
AGpsStatus_v3 AGpsStatus
Definition: gps.h:724
int64_t time_ns
Definition: gps.h:1326
agps_ril_request_set_id request_setid
Definition: gps.h:990
gps_release_wakelock release_wakelock_cb
Definition: gps.h:578
double pseudorange_rate_uncertainty_mps
Definition: gps.h:1491