1/*
2 * Copyright (C) 2008 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#define LOG_TAG "GnssLocationProvider"
18
19#define LOG_NDEBUG 0
20
21#include "JNIHelp.h"
22#include "jni.h"
23#include "hardware/hardware.h"
24#include "hardware/gps_internal.h"
25#include "hardware_legacy/power.h"
26#include "utils/Log.h"
27#include "utils/misc.h"
28#include "android_runtime/AndroidRuntime.h"
29#include "android_runtime/Log.h"
30
31#include <arpa/inet.h>
32#include <limits>
33#include <linux/in.h>
34#include <linux/in6.h>
35#include <pthread.h>
36#include <string.h>
37
38static jobject mCallbacksObj = NULL;
39
40static jmethodID method_reportLocation;
41static jmethodID method_reportStatus;
42static jmethodID method_reportSvStatus;
43static jmethodID method_reportAGpsStatus;
44static jmethodID method_reportNmea;
45static jmethodID method_setEngineCapabilities;
46static jmethodID method_setGnssYearOfHardware;
47static jmethodID method_xtraDownloadRequest;
48static jmethodID method_reportNiNotification;
49static jmethodID method_requestRefLocation;
50static jmethodID method_requestSetID;
51static jmethodID method_requestUtcTime;
52static jmethodID method_reportGeofenceTransition;
53static jmethodID method_reportGeofenceStatus;
54static jmethodID method_reportGeofenceAddStatus;
55static jmethodID method_reportGeofenceRemoveStatus;
56static jmethodID method_reportGeofencePauseStatus;
57static jmethodID method_reportGeofenceResumeStatus;
58static jmethodID method_reportMeasurementData;
59static jmethodID method_reportNavigationMessages;
60
61static const GpsInterface* sGpsInterface = NULL;
62static const GpsXtraInterface* sGpsXtraInterface = NULL;
63static const AGpsInterface* sAGpsInterface = NULL;
64static const GpsNiInterface* sGpsNiInterface = NULL;
65static const GpsDebugInterface* sGpsDebugInterface = NULL;
66static const AGpsRilInterface* sAGpsRilInterface = NULL;
67static const GpsGeofencingInterface* sGpsGeofencingInterface = NULL;
68static const GpsMeasurementInterface* sGpsMeasurementInterface = NULL;
69static const GpsNavigationMessageInterface* sGpsNavigationMessageInterface = NULL;
70static const GnssConfigurationInterface* sGnssConfigurationInterface = NULL;
71
72#define GPS_MAX_SATELLITE_COUNT 32
73#define GNSS_MAX_SATELLITE_COUNT 64
74
75// Let these through, with ID remapped down to 1, 2... by offset
76#define GLONASS_SVID_OFFSET 64
77#define GLONASS_SVID_COUNT 24
78#define BEIDOU_SVID_OFFSET 200
79#define BEIDOU_SVID_COUNT 35
80
81// Let these through, with ID remapped up (33->120 ... 64->151, etc.)
82#define SBAS_SVID_MIN 33
83#define SBAS_SVID_MAX 64
84#define SBAS_SVID_ADD 87
85
86// Let these through, with no ID remapping
87#define QZSS_SVID_MIN 193
88#define QZSS_SVID_MAX 200
89
90#define SVID_SHIFT_WIDTH 7
91#define CONSTELLATION_TYPE_SHIFT_WIDTH 3
92
93// temporary storage for GPS callbacks
94static GnssSvInfo sGnssSvList[GNSS_MAX_SATELLITE_COUNT];
95static size_t sGnssSvListSize;
96static const char* sNmeaString;
97static int sNmeaStringLength;
98
99#define WAKE_LOCK_NAME  "GPS"
100
101namespace android {
102
103static void checkAndClearExceptionFromCallback(JNIEnv* env, const char* methodName) {
104    if (env->ExceptionCheck()) {
105        ALOGE("An exception was thrown by callback '%s'.", methodName);
106        LOGE_EX(env);
107        env->ExceptionClear();
108    }
109}
110
111static void location_callback(GpsLocation* location)
112{
113    JNIEnv* env = AndroidRuntime::getJNIEnv();
114    env->CallVoidMethod(mCallbacksObj, method_reportLocation, location->flags,
115            (jdouble)location->latitude, (jdouble)location->longitude,
116            (jdouble)location->altitude,
117            (jfloat)location->speed, (jfloat)location->bearing,
118            (jfloat)location->accuracy, (jlong)location->timestamp);
119    checkAndClearExceptionFromCallback(env, __FUNCTION__);
120}
121
122static void status_callback(GpsStatus* status)
123{
124    JNIEnv* env = AndroidRuntime::getJNIEnv();
125    env->CallVoidMethod(mCallbacksObj, method_reportStatus, status->status);
126    checkAndClearExceptionFromCallback(env, __FUNCTION__);
127}
128
129static void sv_status_callback(GpsSvStatus* sv_status)
130{
131    JNIEnv* env = AndroidRuntime::getJNIEnv();
132    size_t status_size = sv_status->size;
133    // Some drives doesn't set the size field correctly. Assume GpsSvStatus_v1
134    // if it doesn't provide a valid size.
135    if (status_size == 0) {
136        ALOGW("Invalid size of GpsSvStatus found: %zd.", status_size);
137    }
138    sGnssSvListSize = sv_status->num_svs;
139    // Clamp the list size. Legacy GpsSvStatus has only 32 elements in sv_list.
140    if (sGnssSvListSize > GPS_MAX_SATELLITE_COUNT) {
141        ALOGW("Too many satellites %zd. Clamps to %d.",
142              sGnssSvListSize,
143              GPS_MAX_SATELLITE_COUNT);
144        sGnssSvListSize = GPS_MAX_SATELLITE_COUNT;
145    }
146    uint32_t ephemeris_mask = sv_status->ephemeris_mask;
147    uint32_t almanac_mask = sv_status->almanac_mask;
148    uint32_t used_in_fix_mask = sv_status->used_in_fix_mask;
149    for (size_t i = 0; i < sGnssSvListSize; i++) {
150        GnssSvInfo& info = sGnssSvList[i];
151        info.svid = sv_status->sv_list[i].prn;
152        // Defacto mapping from the overused API that was designed for GPS-only
153        if (info.svid >=1 && info.svid <= 32) {
154            info.constellation = GNSS_CONSTELLATION_GPS;
155        } else if (info.svid > GLONASS_SVID_OFFSET &&
156                   info.svid <= GLONASS_SVID_OFFSET + GLONASS_SVID_COUNT) {
157            info.constellation = GNSS_CONSTELLATION_GLONASS;
158            info.svid -= GLONASS_SVID_OFFSET;
159        } else if (info.svid > BEIDOU_SVID_OFFSET &&
160                   info.svid <= BEIDOU_SVID_OFFSET + BEIDOU_SVID_COUNT) {
161            info.constellation = GNSS_CONSTELLATION_BEIDOU;
162            info.svid -= BEIDOU_SVID_OFFSET;
163        } else if (info.svid >= SBAS_SVID_MIN && info.svid <= SBAS_SVID_MAX) {
164            info.constellation = GNSS_CONSTELLATION_SBAS;
165            info.svid += SBAS_SVID_ADD;
166        } else if (info.svid >= QZSS_SVID_MIN && info.svid <= QZSS_SVID_MAX) {
167            info.constellation = GNSS_CONSTELLATION_QZSS;
168        } else {
169            ALOGD("Unknown constellation type with Svid = %d.", info.svid);
170            info.constellation = GNSS_CONSTELLATION_UNKNOWN;
171        }
172        info.c_n0_dbhz = sv_status->sv_list[i].snr;
173        info.elevation = sv_status->sv_list[i].elevation;
174        info.azimuth = sv_status->sv_list[i].azimuth;
175        info.flags = GNSS_SV_FLAGS_NONE;
176        // Only GPS info is valid for these fields, as these masks are just 32 bits, by GPS prn
177        if (info.constellation == GNSS_CONSTELLATION_GPS) {
178            int32_t this_svid_mask = (1 << (info.svid - 1));
179            if ((ephemeris_mask & this_svid_mask) != 0) {
180                info.flags |= GNSS_SV_FLAGS_HAS_EPHEMERIS_DATA;
181            }
182            if ((almanac_mask & this_svid_mask) != 0) {
183                info.flags |= GNSS_SV_FLAGS_HAS_ALMANAC_DATA;
184            }
185            if ((used_in_fix_mask & this_svid_mask) != 0) {
186                info.flags |= GNSS_SV_FLAGS_USED_IN_FIX;
187            }
188        }
189    }
190    env->CallVoidMethod(mCallbacksObj, method_reportSvStatus);
191    checkAndClearExceptionFromCallback(env, __FUNCTION__);
192}
193
194static void gnss_sv_status_callback(GnssSvStatus* sv_status) {
195    JNIEnv* env = AndroidRuntime::getJNIEnv();
196    size_t status_size = sv_status->size;
197    // Check the size, and reject the object that has invalid size.
198    if (status_size != sizeof(GnssSvStatus)) {
199        ALOGE("Invalid size of GnssSvStatus found: %zd.", status_size);
200        return;
201    }
202    sGnssSvListSize = sv_status->num_svs;
203    // Clamp the list size
204    if (sGnssSvListSize > GNSS_MAX_SATELLITE_COUNT) {
205        ALOGD("Too many satellites %zd. Clamps to %d.",
206              sGnssSvListSize,
207              GNSS_MAX_SATELLITE_COUNT);
208        sGnssSvListSize = GNSS_MAX_SATELLITE_COUNT;
209    }
210    // Copy GNSS SV info into sGnssSvList, if any.
211    if (sGnssSvListSize > 0) {
212        memcpy(sGnssSvList,
213               sv_status->gnss_sv_list,
214               sizeof(GnssSvInfo) * sGnssSvListSize);
215    }
216    env->CallVoidMethod(mCallbacksObj, method_reportSvStatus);
217    checkAndClearExceptionFromCallback(env, __FUNCTION__);
218}
219
220static void nmea_callback(GpsUtcTime timestamp, const char* nmea, int length)
221{
222    JNIEnv* env = AndroidRuntime::getJNIEnv();
223    // The Java code will call back to read these values
224    // We do this to avoid creating unnecessary String objects
225    sNmeaString = nmea;
226    sNmeaStringLength = length;
227    env->CallVoidMethod(mCallbacksObj, method_reportNmea, timestamp);
228    checkAndClearExceptionFromCallback(env, __FUNCTION__);
229}
230
231static void set_system_info_callback(const GnssSystemInfo* info) {
232    ALOGD("set_system_info_callback: year_of_hw=%d\n", info->year_of_hw);
233    JNIEnv* env = AndroidRuntime::getJNIEnv();
234    env->CallVoidMethod(mCallbacksObj, method_setGnssYearOfHardware,
235                        info->year_of_hw);
236    checkAndClearExceptionFromCallback(env, __FUNCTION__);
237}
238
239static void set_capabilities_callback(uint32_t capabilities)
240{
241    ALOGD("set_capabilities_callback: %du\n", capabilities);
242    JNIEnv* env = AndroidRuntime::getJNIEnv();
243    env->CallVoidMethod(mCallbacksObj, method_setEngineCapabilities, capabilities);
244    checkAndClearExceptionFromCallback(env, __FUNCTION__);
245}
246
247static void acquire_wakelock_callback()
248{
249    acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME);
250}
251
252static void release_wakelock_callback()
253{
254    release_wake_lock(WAKE_LOCK_NAME);
255}
256
257static void request_utc_time_callback()
258{
259    JNIEnv* env = AndroidRuntime::getJNIEnv();
260    env->CallVoidMethod(mCallbacksObj, method_requestUtcTime);
261    checkAndClearExceptionFromCallback(env, __FUNCTION__);
262}
263
264static pthread_t create_thread_callback(const char* name, void (*start)(void *), void* arg)
265{
266    return (pthread_t)AndroidRuntime::createJavaThread(name, start, arg);
267}
268
269GpsCallbacks sGpsCallbacks = {
270    sizeof(GpsCallbacks),
271    location_callback,
272    status_callback,
273    sv_status_callback,
274    nmea_callback,
275    set_capabilities_callback,
276    acquire_wakelock_callback,
277    release_wakelock_callback,
278    create_thread_callback,
279    request_utc_time_callback,
280    set_system_info_callback,
281    gnss_sv_status_callback,
282};
283
284static void xtra_download_request_callback()
285{
286    JNIEnv* env = AndroidRuntime::getJNIEnv();
287    env->CallVoidMethod(mCallbacksObj, method_xtraDownloadRequest);
288    checkAndClearExceptionFromCallback(env, __FUNCTION__);
289}
290
291GpsXtraCallbacks sGpsXtraCallbacks = {
292    xtra_download_request_callback,
293    create_thread_callback,
294};
295
296static jbyteArray convert_to_ipv4(uint32_t ip, bool net_order)
297{
298    if (INADDR_NONE == ip) {
299        return NULL;
300    }
301
302    JNIEnv* env = AndroidRuntime::getJNIEnv();
303    jbyteArray byteArray = env->NewByteArray(4);
304    if (byteArray == NULL) {
305        ALOGE("Unable to allocate byte array for IPv4 address");
306        return NULL;
307    }
308
309    jbyte ipv4[4];
310    if (net_order) {
311        ALOGV("Converting IPv4 address(net_order) %x", ip);
312        memcpy(ipv4, &ip, sizeof(ipv4));
313    } else {
314        ALOGV("Converting IPv4 address(host_order) %x", ip);
315        //endianess transparent conversion from int to char[]
316        ipv4[0] = (jbyte) (ip & 0xFF);
317        ipv4[1] = (jbyte)((ip>>8) & 0xFF);
318        ipv4[2] = (jbyte)((ip>>16) & 0xFF);
319        ipv4[3] = (jbyte) (ip>>24);
320    }
321
322    env->SetByteArrayRegion(byteArray, 0, 4, (const jbyte*) ipv4);
323    return byteArray;
324}
325
326static void agps_status_callback(AGpsStatus* agps_status)
327{
328    JNIEnv* env = AndroidRuntime::getJNIEnv();
329    jbyteArray byteArray = NULL;
330    bool isSupported = false;
331
332    size_t status_size = agps_status->size;
333    if (status_size == sizeof(AGpsStatus)) {
334      ALOGV("AGpsStatus is V3: %zd", status_size);
335      switch (agps_status->addr.ss_family)
336      {
337      case AF_INET:
338          {
339            struct sockaddr_in *in = (struct sockaddr_in*)&(agps_status->addr);
340            uint32_t ipAddr = *(uint32_t*)&(in->sin_addr);
341            byteArray = convert_to_ipv4(ipAddr, true /* net_order */);
342            if (ipAddr == INADDR_NONE || byteArray != NULL) {
343                isSupported = true;
344            }
345            IF_ALOGD() {
346                // log the IP for reference in case there is a bogus value pushed by HAL
347                char str[INET_ADDRSTRLEN];
348                inet_ntop(AF_INET, &(in->sin_addr), str, INET_ADDRSTRLEN);
349                ALOGD("AGPS IP is v4: %s", str);
350            }
351          }
352          break;
353      case AF_INET6:
354          {
355            struct sockaddr_in6 *in6 = (struct sockaddr_in6*)&(agps_status->addr);
356            byteArray = env->NewByteArray(16);
357            if (byteArray != NULL) {
358                env->SetByteArrayRegion(byteArray, 0, 16, (const jbyte *)&(in6->sin6_addr));
359                isSupported = true;
360            } else {
361                ALOGE("Unable to allocate byte array for IPv6 address.");
362            }
363            IF_ALOGD() {
364                // log the IP for reference in case there is a bogus value pushed by HAL
365                char str[INET6_ADDRSTRLEN];
366                inet_ntop(AF_INET6, &(in6->sin6_addr), str, INET6_ADDRSTRLEN);
367                ALOGD("AGPS IP is v6: %s", str);
368            }
369          }
370          break;
371      default:
372          ALOGE("Invalid ss_family found: %d", agps_status->addr.ss_family);
373          break;
374      }
375    } else if (status_size >= sizeof(AGpsStatus_v2)) {
376      ALOGV("AGpsStatus is V2+: %zd", status_size);
377      // for back-compatibility reasons we check in v2 that the data structure size is greater or
378      // equal to the declared size in gps.h
379      uint32_t ipaddr = agps_status->ipaddr;
380      ALOGV("AGPS IP is v4: %x", ipaddr);
381      byteArray = convert_to_ipv4(ipaddr, false /* net_order */);
382      if (ipaddr == INADDR_NONE || byteArray != NULL) {
383          isSupported = true;
384      }
385    } else if (status_size >= sizeof(AGpsStatus_v1)) {
386        ALOGV("AGpsStatus is V1+: %zd", status_size);
387        // because we have to check for >= with regards to v2, we also need to relax the check here
388        // and only make sure that the size is at least what we expect
389        isSupported = true;
390    } else {
391        ALOGE("Invalid size of AGpsStatus found: %zd.", status_size);
392    }
393
394    if (isSupported) {
395        jsize byteArrayLength = byteArray != NULL ? env->GetArrayLength(byteArray) : 0;
396        ALOGV("Passing AGPS IP addr: size %d", byteArrayLength);
397        env->CallVoidMethod(mCallbacksObj, method_reportAGpsStatus, agps_status->type,
398                            agps_status->status, byteArray);
399
400        checkAndClearExceptionFromCallback(env, __FUNCTION__);
401    } else {
402        ALOGD("Skipping calling method_reportAGpsStatus.");
403    }
404
405    if (byteArray) {
406        env->DeleteLocalRef(byteArray);
407    }
408}
409
410AGpsCallbacks sAGpsCallbacks = {
411    agps_status_callback,
412    create_thread_callback,
413};
414
415static void gps_ni_notify_callback(GpsNiNotification *notification)
416{
417    ALOGD("gps_ni_notify_callback\n");
418    JNIEnv* env = AndroidRuntime::getJNIEnv();
419    jstring requestor_id = env->NewStringUTF(notification->requestor_id);
420    jstring text = env->NewStringUTF(notification->text);
421    jstring extras = env->NewStringUTF(notification->extras);
422
423    if (requestor_id && text && extras) {
424        env->CallVoidMethod(mCallbacksObj, method_reportNiNotification,
425            notification->notification_id, notification->ni_type,
426            notification->notify_flags, notification->timeout,
427            notification->default_response, requestor_id, text,
428            notification->requestor_id_encoding,
429            notification->text_encoding, extras);
430    } else {
431        ALOGE("out of memory in gps_ni_notify_callback\n");
432    }
433
434    if (requestor_id)
435        env->DeleteLocalRef(requestor_id);
436    if (text)
437        env->DeleteLocalRef(text);
438    if (extras)
439        env->DeleteLocalRef(extras);
440    checkAndClearExceptionFromCallback(env, __FUNCTION__);
441}
442
443GpsNiCallbacks sGpsNiCallbacks = {
444    gps_ni_notify_callback,
445    create_thread_callback,
446};
447
448static void agps_request_set_id(uint32_t flags)
449{
450    JNIEnv* env = AndroidRuntime::getJNIEnv();
451    env->CallVoidMethod(mCallbacksObj, method_requestSetID, flags);
452    checkAndClearExceptionFromCallback(env, __FUNCTION__);
453}
454
455static void agps_request_ref_location(uint32_t flags)
456{
457    JNIEnv* env = AndroidRuntime::getJNIEnv();
458    env->CallVoidMethod(mCallbacksObj, method_requestRefLocation, flags);
459    checkAndClearExceptionFromCallback(env, __FUNCTION__);
460}
461
462AGpsRilCallbacks sAGpsRilCallbacks = {
463    agps_request_set_id,
464    agps_request_ref_location,
465    create_thread_callback,
466};
467
468static void gps_geofence_transition_callback(int32_t geofence_id,  GpsLocation* location,
469        int32_t transition, GpsUtcTime timestamp)
470{
471    JNIEnv* env = AndroidRuntime::getJNIEnv();
472
473    env->CallVoidMethod(mCallbacksObj, method_reportGeofenceTransition, geofence_id,
474            location->flags, (jdouble)location->latitude, (jdouble)location->longitude,
475            (jdouble)location->altitude,
476            (jfloat)location->speed, (jfloat)location->bearing,
477            (jfloat)location->accuracy, (jlong)location->timestamp,
478            transition, timestamp);
479    checkAndClearExceptionFromCallback(env, __FUNCTION__);
480};
481
482static void gps_geofence_status_callback(int32_t status, GpsLocation* location)
483{
484    JNIEnv* env = AndroidRuntime::getJNIEnv();
485    jint flags = 0;
486    jdouble latitude = 0;
487    jdouble longitude = 0;
488    jdouble altitude = 0;
489    jfloat speed = 0;
490    jfloat bearing = 0;
491    jfloat accuracy = 0;
492    jlong timestamp = 0;
493    if (location != NULL) {
494        flags = location->flags;
495        latitude = location->latitude;
496        longitude = location->longitude;
497        altitude = location->altitude;
498        speed = location->speed;
499        bearing = location->bearing;
500        accuracy = location->accuracy;
501        timestamp = location->timestamp;
502    }
503
504    env->CallVoidMethod(mCallbacksObj, method_reportGeofenceStatus, status,
505            flags, latitude, longitude, altitude, speed, bearing, accuracy, timestamp);
506    checkAndClearExceptionFromCallback(env, __FUNCTION__);
507};
508
509static void gps_geofence_add_callback(int32_t geofence_id, int32_t status)
510{
511    JNIEnv* env = AndroidRuntime::getJNIEnv();
512    if (status != GPS_GEOFENCE_OPERATION_SUCCESS) {
513        ALOGE("Error in geofence_add_callback: %d\n", status);
514    }
515    env->CallVoidMethod(mCallbacksObj, method_reportGeofenceAddStatus, geofence_id, status);
516    checkAndClearExceptionFromCallback(env, __FUNCTION__);
517};
518
519static void gps_geofence_remove_callback(int32_t geofence_id, int32_t status)
520{
521    JNIEnv* env = AndroidRuntime::getJNIEnv();
522    if (status != GPS_GEOFENCE_OPERATION_SUCCESS) {
523        ALOGE("Error in geofence_remove_callback: %d\n", status);
524    }
525    env->CallVoidMethod(mCallbacksObj, method_reportGeofenceRemoveStatus, geofence_id, status);
526    checkAndClearExceptionFromCallback(env, __FUNCTION__);
527};
528
529static void gps_geofence_resume_callback(int32_t geofence_id, int32_t status)
530{
531    JNIEnv* env = AndroidRuntime::getJNIEnv();
532    if (status != GPS_GEOFENCE_OPERATION_SUCCESS) {
533        ALOGE("Error in geofence_resume_callback: %d\n", status);
534    }
535    env->CallVoidMethod(mCallbacksObj, method_reportGeofenceResumeStatus, geofence_id, status);
536    checkAndClearExceptionFromCallback(env, __FUNCTION__);
537};
538
539static void gps_geofence_pause_callback(int32_t geofence_id, int32_t status)
540{
541    JNIEnv* env = AndroidRuntime::getJNIEnv();
542    if (status != GPS_GEOFENCE_OPERATION_SUCCESS) {
543        ALOGE("Error in geofence_pause_callback: %d\n", status);
544    }
545    env->CallVoidMethod(mCallbacksObj, method_reportGeofencePauseStatus, geofence_id, status);
546    checkAndClearExceptionFromCallback(env, __FUNCTION__);
547};
548
549GpsGeofenceCallbacks sGpsGeofenceCallbacks = {
550    gps_geofence_transition_callback,
551    gps_geofence_status_callback,
552    gps_geofence_add_callback,
553    gps_geofence_remove_callback,
554    gps_geofence_pause_callback,
555    gps_geofence_resume_callback,
556    create_thread_callback,
557};
558
559static void android_location_GnssLocationProvider_class_init_native(JNIEnv* env, jclass clazz) {
560    int err;
561    hw_module_t* module;
562
563    method_reportLocation = env->GetMethodID(clazz, "reportLocation", "(IDDDFFFJ)V");
564    method_reportStatus = env->GetMethodID(clazz, "reportStatus", "(I)V");
565    method_reportSvStatus = env->GetMethodID(clazz, "reportSvStatus", "()V");
566    method_reportAGpsStatus = env->GetMethodID(clazz, "reportAGpsStatus", "(II[B)V");
567    method_reportNmea = env->GetMethodID(clazz, "reportNmea", "(J)V");
568    method_setEngineCapabilities = env->GetMethodID(clazz, "setEngineCapabilities", "(I)V");
569    method_setGnssYearOfHardware = env->GetMethodID(clazz, "setGnssYearOfHardware", "(I)V");
570    method_xtraDownloadRequest = env->GetMethodID(clazz, "xtraDownloadRequest", "()V");
571    method_reportNiNotification = env->GetMethodID(clazz, "reportNiNotification",
572            "(IIIIILjava/lang/String;Ljava/lang/String;IILjava/lang/String;)V");
573    method_requestRefLocation = env->GetMethodID(clazz,"requestRefLocation","(I)V");
574    method_requestSetID = env->GetMethodID(clazz,"requestSetID","(I)V");
575    method_requestUtcTime = env->GetMethodID(clazz,"requestUtcTime","()V");
576    method_reportGeofenceTransition = env->GetMethodID(clazz,"reportGeofenceTransition",
577            "(IIDDDFFFJIJ)V");
578    method_reportGeofenceStatus = env->GetMethodID(clazz,"reportGeofenceStatus",
579            "(IIDDDFFFJ)V");
580    method_reportGeofenceAddStatus = env->GetMethodID(clazz,"reportGeofenceAddStatus",
581            "(II)V");
582    method_reportGeofenceRemoveStatus = env->GetMethodID(clazz,"reportGeofenceRemoveStatus",
583            "(II)V");
584    method_reportGeofenceResumeStatus = env->GetMethodID(clazz,"reportGeofenceResumeStatus",
585            "(II)V");
586    method_reportGeofencePauseStatus = env->GetMethodID(clazz,"reportGeofencePauseStatus",
587            "(II)V");
588    method_reportMeasurementData = env->GetMethodID(
589            clazz,
590            "reportMeasurementData",
591            "(Landroid/location/GnssMeasurementsEvent;)V");
592    method_reportNavigationMessages = env->GetMethodID(
593            clazz,
594            "reportNavigationMessage",
595            "(Landroid/location/GnssNavigationMessage;)V");
596
597    err = hw_get_module(GPS_HARDWARE_MODULE_ID, (hw_module_t const**)&module);
598    if (err == 0) {
599        hw_device_t* device;
600        err = module->methods->open(module, GPS_HARDWARE_MODULE_ID, &device);
601        if (err == 0) {
602            gps_device_t* gps_device = (gps_device_t *)device;
603            sGpsInterface = gps_device->get_gps_interface(gps_device);
604        }
605    }
606    if (sGpsInterface) {
607        sGpsXtraInterface =
608            (const GpsXtraInterface*)sGpsInterface->get_extension(GPS_XTRA_INTERFACE);
609        sAGpsInterface =
610            (const AGpsInterface*)sGpsInterface->get_extension(AGPS_INTERFACE);
611        sGpsNiInterface =
612            (const GpsNiInterface*)sGpsInterface->get_extension(GPS_NI_INTERFACE);
613        sGpsDebugInterface =
614            (const GpsDebugInterface*)sGpsInterface->get_extension(GPS_DEBUG_INTERFACE);
615        sAGpsRilInterface =
616            (const AGpsRilInterface*)sGpsInterface->get_extension(AGPS_RIL_INTERFACE);
617        sGpsGeofencingInterface =
618            (const GpsGeofencingInterface*)sGpsInterface->get_extension(GPS_GEOFENCING_INTERFACE);
619        sGpsMeasurementInterface =
620            (const GpsMeasurementInterface*)sGpsInterface->get_extension(GPS_MEASUREMENT_INTERFACE);
621        sGpsNavigationMessageInterface =
622            (const GpsNavigationMessageInterface*)sGpsInterface->get_extension(
623                    GPS_NAVIGATION_MESSAGE_INTERFACE);
624        sGnssConfigurationInterface =
625            (const GnssConfigurationInterface*)sGpsInterface->get_extension(
626                    GNSS_CONFIGURATION_INTERFACE);
627    }
628}
629
630static jboolean android_location_GnssLocationProvider_is_supported(
631        JNIEnv* /* env */, jclass /* clazz */)
632{
633    return (sGpsInterface != NULL) ?  JNI_TRUE : JNI_FALSE;
634}
635
636static jboolean android_location_GnssLocationProvider_is_agps_ril_supported(
637        JNIEnv* /* env */, jclass /* clazz */)
638{
639    return (sAGpsRilInterface != NULL) ? JNI_TRUE : JNI_FALSE;
640}
641
642static jboolean android_location_gpsLocationProvider_is_gnss_configuration_supported(
643        JNIEnv* /* env */, jclass /* jclazz */)
644{
645    return (sGnssConfigurationInterface != NULL) ? JNI_TRUE : JNI_FALSE;
646}
647
648static jboolean android_location_GnssLocationProvider_init(JNIEnv* env, jobject obj)
649{
650    // this must be set before calling into the HAL library
651    if (!mCallbacksObj)
652        mCallbacksObj = env->NewGlobalRef(obj);
653
654    // fail if the main interface fails to initialize
655    if (!sGpsInterface || sGpsInterface->init(&sGpsCallbacks) != 0)
656        return JNI_FALSE;
657
658    // if XTRA initialization fails we will disable it by sGpsXtraInterface to NULL,
659    // but continue to allow the rest of the GPS interface to work.
660    if (sGpsXtraInterface && sGpsXtraInterface->init(&sGpsXtraCallbacks) != 0)
661        sGpsXtraInterface = NULL;
662    if (sAGpsInterface)
663        sAGpsInterface->init(&sAGpsCallbacks);
664    if (sGpsNiInterface)
665        sGpsNiInterface->init(&sGpsNiCallbacks);
666    if (sAGpsRilInterface)
667        sAGpsRilInterface->init(&sAGpsRilCallbacks);
668    if (sGpsGeofencingInterface)
669        sGpsGeofencingInterface->init(&sGpsGeofenceCallbacks);
670
671    return JNI_TRUE;
672}
673
674static void android_location_GnssLocationProvider_cleanup(JNIEnv* /* env */, jobject /* obj */)
675{
676    if (sGpsInterface)
677        sGpsInterface->cleanup();
678}
679
680static jboolean android_location_GnssLocationProvider_set_position_mode(JNIEnv* /* env */,
681        jobject /* obj */, jint mode, jint recurrence, jint min_interval, jint preferred_accuracy,
682        jint preferred_time)
683{
684    if (sGpsInterface) {
685        if (sGpsInterface->set_position_mode(mode, recurrence, min_interval, preferred_accuracy,
686                preferred_time) == 0) {
687            return JNI_TRUE;
688        } else {
689            return JNI_FALSE;
690        }
691    }
692    else
693        return JNI_FALSE;
694}
695
696static jboolean android_location_GnssLocationProvider_start(JNIEnv* /* env */, jobject /* obj */)
697{
698    if (sGpsInterface) {
699        if (sGpsInterface->start() == 0) {
700            return JNI_TRUE;
701        } else {
702            return JNI_FALSE;
703        }
704    }
705    else
706        return JNI_FALSE;
707}
708
709static jboolean android_location_GnssLocationProvider_stop(JNIEnv* /* env */, jobject /* obj */)
710{
711    if (sGpsInterface) {
712        if (sGpsInterface->stop() == 0) {
713            return JNI_TRUE;
714        } else {
715            return JNI_FALSE;
716        }
717    }
718    else
719        return JNI_FALSE;
720}
721
722static void android_location_GnssLocationProvider_delete_aiding_data(JNIEnv* /* env */,
723                                                                    jobject /* obj */,
724                                                                    jint flags)
725{
726    if (sGpsInterface)
727        sGpsInterface->delete_aiding_data(flags);
728}
729
730static jint android_location_GnssLocationProvider_read_sv_status(JNIEnv* env, jobject /* obj */,
731        jintArray svidWithFlagArray, jfloatArray cn0Array, jfloatArray elevArray,
732        jfloatArray azumArray)
733{
734    // this should only be called from within a call to reportSvStatus
735    jint* svidWithFlags = env->GetIntArrayElements(svidWithFlagArray, 0);
736    jfloat* cn0s = env->GetFloatArrayElements(cn0Array, 0);
737    jfloat* elev = env->GetFloatArrayElements(elevArray, 0);
738    jfloat* azim = env->GetFloatArrayElements(azumArray, 0);
739
740    // GNSS SV info.
741    for (size_t i = 0; i < sGnssSvListSize; ++i) {
742        const GnssSvInfo& info = sGnssSvList[i];
743        svidWithFlags[i] = (info.svid << SVID_SHIFT_WIDTH) |
744            (info.constellation << CONSTELLATION_TYPE_SHIFT_WIDTH) |
745            info.flags;
746        cn0s[i] = info.c_n0_dbhz;
747        elev[i] = info.elevation;
748        azim[i] = info.azimuth;
749    }
750
751    env->ReleaseIntArrayElements(svidWithFlagArray, svidWithFlags, 0);
752    env->ReleaseFloatArrayElements(cn0Array, cn0s, 0);
753    env->ReleaseFloatArrayElements(elevArray, elev, 0);
754    env->ReleaseFloatArrayElements(azumArray, azim, 0);
755    return (jint) sGnssSvListSize;
756}
757
758static void android_location_GnssLocationProvider_agps_set_reference_location_cellid(
759        JNIEnv* /* env */, jobject /* obj */, jint type, jint mcc, jint mnc, jint lac, jint cid)
760{
761    AGpsRefLocation location;
762
763    if (!sAGpsRilInterface) {
764        ALOGE("no AGPS RIL interface in agps_set_reference_location_cellid");
765        return;
766    }
767
768    switch(type) {
769        case AGPS_REF_LOCATION_TYPE_GSM_CELLID:
770        case AGPS_REF_LOCATION_TYPE_UMTS_CELLID:
771            location.type = type;
772            location.u.cellID.mcc = mcc;
773            location.u.cellID.mnc = mnc;
774            location.u.cellID.lac = lac;
775            location.u.cellID.cid = cid;
776            break;
777        default:
778            ALOGE("Neither a GSM nor a UMTS cellid (%s:%d).",__FUNCTION__,__LINE__);
779            return;
780            break;
781    }
782    sAGpsRilInterface->set_ref_location(&location, sizeof(location));
783}
784
785static void android_location_GnssLocationProvider_agps_send_ni_message(JNIEnv* env,
786        jobject /* obj */, jbyteArray ni_msg, jint size)
787{
788    size_t sz;
789
790    if (!sAGpsRilInterface) {
791        ALOGE("no AGPS RIL interface in send_ni_message");
792        return;
793    }
794    if (size < 0)
795        return;
796    sz = (size_t)size;
797    jbyte* b = env->GetByteArrayElements(ni_msg, 0);
798    sAGpsRilInterface->ni_message((uint8_t *)b,sz);
799    env->ReleaseByteArrayElements(ni_msg,b,0);
800}
801
802static void android_location_GnssLocationProvider_agps_set_id(JNIEnv *env, jobject /* obj */,
803                                                             jint type, jstring  setid_string)
804{
805    if (!sAGpsRilInterface) {
806        ALOGE("no AGPS RIL interface in agps_set_id");
807        return;
808    }
809
810    const char *setid = env->GetStringUTFChars(setid_string, NULL);
811    sAGpsRilInterface->set_set_id(type, setid);
812    env->ReleaseStringUTFChars(setid_string, setid);
813}
814
815static jint android_location_GnssLocationProvider_read_nmea(JNIEnv* env, jobject /* obj */,
816                                            jbyteArray nmeaArray, jint buffer_size)
817{
818    // this should only be called from within a call to reportNmea
819    jbyte* nmea = (jbyte *)env->GetPrimitiveArrayCritical(nmeaArray, 0);
820    int length = sNmeaStringLength;
821    if (length > buffer_size)
822        length = buffer_size;
823    memcpy(nmea, sNmeaString, length);
824    env->ReleasePrimitiveArrayCritical(nmeaArray, nmea, JNI_ABORT);
825    return (jint) length;
826}
827
828static void android_location_GnssLocationProvider_inject_time(JNIEnv* /* env */, jobject /* obj */,
829        jlong time, jlong timeReference, jint uncertainty)
830{
831    if (sGpsInterface)
832        sGpsInterface->inject_time(time, timeReference, uncertainty);
833}
834
835static void android_location_GnssLocationProvider_inject_location(JNIEnv* /* env */,
836        jobject /* obj */, jdouble latitude, jdouble longitude, jfloat accuracy)
837{
838    if (sGpsInterface)
839        sGpsInterface->inject_location(latitude, longitude, accuracy);
840}
841
842static jboolean android_location_GnssLocationProvider_supports_xtra(
843        JNIEnv* /* env */, jobject /* obj */)
844{
845    return (sGpsXtraInterface != NULL) ? JNI_TRUE : JNI_FALSE;
846}
847
848static void android_location_GnssLocationProvider_inject_xtra_data(JNIEnv* env, jobject /* obj */,
849        jbyteArray data, jint length)
850{
851    if (!sGpsXtraInterface) {
852        ALOGE("no XTRA interface in inject_xtra_data");
853        return;
854    }
855
856    jbyte* bytes = (jbyte *)env->GetPrimitiveArrayCritical(data, 0);
857    sGpsXtraInterface->inject_xtra_data((char *)bytes, length);
858    env->ReleasePrimitiveArrayCritical(data, bytes, JNI_ABORT);
859}
860
861static void android_location_GnssLocationProvider_agps_data_conn_open(
862        JNIEnv* env, jobject /* obj */, jstring apn, jint apnIpType)
863{
864    if (!sAGpsInterface) {
865        ALOGE("no AGPS interface in agps_data_conn_open");
866        return;
867    }
868    if (apn == NULL) {
869        jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
870        return;
871    }
872
873    const char *apnStr = env->GetStringUTFChars(apn, NULL);
874
875    size_t interface_size = sAGpsInterface->size;
876    if (interface_size == sizeof(AGpsInterface)) {
877        sAGpsInterface->data_conn_open_with_apn_ip_type(apnStr, apnIpType);
878    } else if (interface_size == sizeof(AGpsInterface_v1)) {
879        sAGpsInterface->data_conn_open(apnStr);
880    } else {
881        ALOGE("Invalid size of AGpsInterface found: %zd.", interface_size);
882    }
883
884    env->ReleaseStringUTFChars(apn, apnStr);
885}
886
887static void android_location_GnssLocationProvider_agps_data_conn_closed(JNIEnv* /* env */,
888                                                                       jobject /* obj */)
889{
890    if (!sAGpsInterface) {
891        ALOGE("no AGPS interface in agps_data_conn_closed");
892        return;
893    }
894    sAGpsInterface->data_conn_closed();
895}
896
897static void android_location_GnssLocationProvider_agps_data_conn_failed(JNIEnv* /* env */,
898                                                                       jobject /* obj */)
899{
900    if (!sAGpsInterface) {
901        ALOGE("no AGPS interface in agps_data_conn_failed");
902        return;
903    }
904    sAGpsInterface->data_conn_failed();
905}
906
907static void android_location_GnssLocationProvider_set_agps_server(JNIEnv* env, jobject /* obj */,
908        jint type, jstring hostname, jint port)
909{
910    if (!sAGpsInterface) {
911        ALOGE("no AGPS interface in set_agps_server");
912        return;
913    }
914    const char *c_hostname = env->GetStringUTFChars(hostname, NULL);
915    sAGpsInterface->set_server(type, c_hostname, port);
916    env->ReleaseStringUTFChars(hostname, c_hostname);
917}
918
919static void android_location_GnssLocationProvider_send_ni_response(JNIEnv* /* env */,
920      jobject /* obj */, jint notifId, jint response)
921{
922    if (!sGpsNiInterface) {
923        ALOGE("no NI interface in send_ni_response");
924        return;
925    }
926
927    sGpsNiInterface->respond(notifId, response);
928}
929
930static jstring android_location_GnssLocationProvider_get_internal_state(JNIEnv* env,
931                                                                       jobject /* obj */) {
932    jstring result = NULL;
933    if (sGpsDebugInterface) {
934        const size_t maxLength = 2047;
935        char buffer[maxLength+1];
936        size_t length = sGpsDebugInterface->get_internal_state(buffer, maxLength);
937        if (length > maxLength) length = maxLength;
938        buffer[length] = 0;
939        result = env->NewStringUTF(buffer);
940    }
941    return result;
942}
943
944static void android_location_GnssLocationProvider_update_network_state(JNIEnv* env, jobject /* obj */,
945        jboolean connected, jint type, jboolean roaming, jboolean available, jstring extraInfo, jstring apn)
946{
947
948    if (sAGpsRilInterface && sAGpsRilInterface->update_network_state) {
949        if (extraInfo) {
950            const char *extraInfoStr = env->GetStringUTFChars(extraInfo, NULL);
951            sAGpsRilInterface->update_network_state(connected, type, roaming, extraInfoStr);
952            env->ReleaseStringUTFChars(extraInfo, extraInfoStr);
953        } else {
954            sAGpsRilInterface->update_network_state(connected, type, roaming, NULL);
955        }
956
957        // update_network_availability callback was not included in original AGpsRilInterface
958        if (sAGpsRilInterface->size >= sizeof(AGpsRilInterface)
959                && sAGpsRilInterface->update_network_availability) {
960            const char *c_apn = env->GetStringUTFChars(apn, NULL);
961            sAGpsRilInterface->update_network_availability(available, c_apn);
962            env->ReleaseStringUTFChars(apn, c_apn);
963        }
964    }
965}
966
967static jboolean android_location_GnssLocationProvider_is_geofence_supported(
968        JNIEnv* /* env */, jobject /* obj */)
969{
970    return (sGpsGeofencingInterface != NULL) ? JNI_TRUE : JNI_FALSE;
971}
972
973static jboolean android_location_GnssLocationProvider_add_geofence(JNIEnv* /* env */,
974        jobject /* obj */, jint geofence_id, jdouble latitude, jdouble longitude, jdouble radius,
975        jint last_transition, jint monitor_transition, jint notification_responsiveness,
976        jint unknown_timer) {
977    if (sGpsGeofencingInterface != NULL) {
978        sGpsGeofencingInterface->add_geofence_area(geofence_id, latitude, longitude,
979                radius, last_transition, monitor_transition, notification_responsiveness,
980                unknown_timer);
981        return JNI_TRUE;
982    } else {
983        ALOGE("Geofence interface not available");
984    }
985    return JNI_FALSE;
986}
987
988static jboolean android_location_GnssLocationProvider_remove_geofence(JNIEnv* /* env */,
989        jobject /* obj */, jint geofence_id) {
990    if (sGpsGeofencingInterface != NULL) {
991        sGpsGeofencingInterface->remove_geofence_area(geofence_id);
992        return JNI_TRUE;
993    } else {
994        ALOGE("Geofence interface not available");
995    }
996    return JNI_FALSE;
997}
998
999static jboolean android_location_GnssLocationProvider_pause_geofence(JNIEnv* /* env */,
1000        jobject /* obj */, jint geofence_id) {
1001    if (sGpsGeofencingInterface != NULL) {
1002        sGpsGeofencingInterface->pause_geofence(geofence_id);
1003        return JNI_TRUE;
1004    } else {
1005        ALOGE("Geofence interface not available");
1006    }
1007    return JNI_FALSE;
1008}
1009
1010static jboolean android_location_GnssLocationProvider_resume_geofence(JNIEnv* /* env */,
1011        jobject /* obj */, jint geofence_id, jint monitor_transition) {
1012    if (sGpsGeofencingInterface != NULL) {
1013        sGpsGeofencingInterface->resume_geofence(geofence_id, monitor_transition);
1014        return JNI_TRUE;
1015    } else {
1016        ALOGE("Geofence interface not available");
1017    }
1018    return JNI_FALSE;
1019}
1020
1021template<class T>
1022class JavaMethodHelper {
1023  public:
1024   // Helper function to call setter on a Java object.
1025   static void callJavaMethod(
1026           JNIEnv* env,
1027           jclass clazz,
1028           jobject object,
1029           const char* method_name,
1030           T value);
1031
1032  private:
1033    static const char *const signature_;
1034};
1035
1036template<class T>
1037void JavaMethodHelper<T>::callJavaMethod(
1038        JNIEnv* env,
1039        jclass clazz,
1040        jobject object,
1041        const char* method_name,
1042        T value) {
1043    jmethodID method = env->GetMethodID(clazz, method_name, signature_);
1044    env->CallVoidMethod(object, method, value);
1045}
1046
1047class JavaObject {
1048  public:
1049   JavaObject(JNIEnv* env, const char* class_name);
1050   virtual ~JavaObject();
1051
1052   template<class T>
1053   void callSetter(const char* method_name, T value);
1054   template<class T>
1055   void callSetter(const char* method_name, T* value, size_t size);
1056   jobject get();
1057
1058  private:
1059   JNIEnv* env_;
1060   jclass clazz_;
1061   jobject object_;
1062};
1063
1064JavaObject::JavaObject(JNIEnv* env, const char* class_name) : env_(env) {
1065    clazz_ = env_->FindClass(class_name);
1066    jmethodID ctor = env->GetMethodID(clazz_, "<init>", "()V");
1067    object_ = env_->NewObject(clazz_, ctor);
1068}
1069
1070JavaObject::~JavaObject() {
1071    env_->DeleteLocalRef(clazz_);
1072}
1073
1074template<class T>
1075void JavaObject::callSetter(const char* method_name, T value) {
1076    JavaMethodHelper<T>::callJavaMethod(
1077            env_, clazz_, object_, method_name, value);
1078}
1079
1080template<>
1081void JavaObject::callSetter(
1082        const char* method_name, uint8_t* value, size_t size) {
1083    jbyteArray array = env_->NewByteArray(size);
1084    env_->SetByteArrayRegion(array, 0, size, (jbyte*) value);
1085    jmethodID method = env_->GetMethodID(
1086            clazz_,
1087            method_name,
1088            "([B)V");
1089    env_->CallVoidMethod(object_, method, array);
1090}
1091
1092jobject JavaObject::get() {
1093    return object_;
1094}
1095
1096// Define Java method signatures for all known types.
1097
1098template<>
1099const char *const JavaMethodHelper<uint8_t>::signature_ = "(B)V";
1100template<>
1101const char *const JavaMethodHelper<int8_t>::signature_ = "(B)V";
1102template<>
1103const char *const JavaMethodHelper<int16_t>::signature_ = "(S)V";
1104template<>
1105const char *const JavaMethodHelper<uint16_t>::signature_ = "(S)V";
1106template<>
1107const char *const JavaMethodHelper<int32_t>::signature_ = "(I)V";
1108template<>
1109const char *const JavaMethodHelper<uint32_t>::signature_ = "(I)V";
1110template<>
1111const char *const JavaMethodHelper<int64_t>::signature_ = "(J)V";
1112template<>
1113const char *const JavaMethodHelper<float>::signature_ = "(F)V";
1114template<>
1115const char *const JavaMethodHelper<double>::signature_ = "(D)V";
1116template<>
1117const char *const JavaMethodHelper<bool>::signature_ = "(Z)V";
1118
1119#define SET(setter, value) object.callSetter("set" # setter, (value))
1120
1121// If you want to check if a flag is not set, use SET_IF_NOT(FLAG, setter,
1122// value) to do that. SET_IF(!FLAG, setter, value) won't compile.
1123//
1124// This macros generates compilation error if the provided 'flag' is not a
1125// single token. For example, 'GNSS_CLOCK_HAS_BIAS' can be accepted, but
1126// '!GNSS_CLOCK_HAS_DRIFT' will fail to compile.
1127#define SET_IF(flag, setter, value) do { \
1128        if (flags & flag) { \
1129            JavaObject& name_check_##flag = object; \
1130            name_check_##flag.callSetter("set" # setter, (value)); \
1131        } \
1132    } while (false)
1133#define SET_IF_NOT(flag, setter, value) do { \
1134        if (!(flags & flag)) { \
1135            JavaObject& name_check_##flag = object; \
1136            name_check_##flag.callSetter("set" # setter, (value)); \
1137        } \
1138    } while (false)
1139
1140static jobject translate_gps_clock(JNIEnv* env, GpsClock* clock) {
1141    static uint32_t discontinuity_count_to_handle_old_clock_type = 0;
1142    JavaObject object(env, "android/location/GnssClock");
1143    GpsClockFlags flags = clock->flags;
1144
1145    SET_IF(GPS_CLOCK_HAS_LEAP_SECOND,
1146           LeapSecond,
1147           static_cast<int32_t>(clock->leap_second));
1148
1149    // GnssClock only supports the more effective HW_CLOCK type, so type
1150    // handling and documentation complexity has been removed.  To convert the
1151    // old GPS_CLOCK types (active only in a limited number of older devices),
1152    // the GPS time information is handled as an always discontinuous HW clock,
1153    // with the GPS time information put into the full_bias_ns instead - so that
1154    // time_ns - full_bias_ns = local estimate of GPS time. Additionally, the
1155    // sign of full_bias_ns and bias_ns has flipped between GpsClock &
1156    // GnssClock, so that is also handled below.
1157    switch (clock->type) {
1158      case GPS_CLOCK_TYPE_UNKNOWN:
1159        // Clock type unsupported.
1160        ALOGE("Unknown clock type provided.");
1161        break;
1162      case GPS_CLOCK_TYPE_LOCAL_HW_TIME:
1163        // Already local hardware time. No need to do anything.
1164        break;
1165      case GPS_CLOCK_TYPE_GPS_TIME:
1166        // GPS time, need to convert.
1167        flags |= GPS_CLOCK_HAS_FULL_BIAS;
1168        clock->full_bias_ns = clock->time_ns;
1169        clock->time_ns = 0;
1170        SET(HardwareClockDiscontinuityCount,
1171            discontinuity_count_to_handle_old_clock_type++);
1172        break;
1173    }
1174
1175    SET(TimeNanos, clock->time_ns);
1176    SET_IF(GPS_CLOCK_HAS_TIME_UNCERTAINTY,
1177           TimeUncertaintyNanos,
1178           clock->time_uncertainty_ns);
1179
1180    // Definition of sign for full_bias_ns & bias_ns has been changed since N,
1181    // so flip signs here.
1182    SET_IF(GPS_CLOCK_HAS_FULL_BIAS, FullBiasNanos, -(clock->full_bias_ns));
1183    SET_IF(GPS_CLOCK_HAS_BIAS, BiasNanos, -(clock->bias_ns));
1184
1185    SET_IF(GPS_CLOCK_HAS_BIAS_UNCERTAINTY,
1186           BiasUncertaintyNanos,
1187           clock->bias_uncertainty_ns);
1188    SET_IF(GPS_CLOCK_HAS_DRIFT, DriftNanosPerSecond, clock->drift_nsps);
1189    SET_IF(GPS_CLOCK_HAS_DRIFT_UNCERTAINTY,
1190           DriftUncertaintyNanosPerSecond,
1191           clock->drift_uncertainty_nsps);
1192
1193    return object.get();
1194}
1195
1196static jobject translate_gnss_clock(JNIEnv* env, GnssClock* clock) {
1197    JavaObject object(env, "android/location/GnssClock");
1198    GnssClockFlags flags = clock->flags;
1199
1200    SET_IF(GNSS_CLOCK_HAS_LEAP_SECOND,
1201           LeapSecond,
1202           static_cast<int32_t>(clock->leap_second));
1203    SET(TimeNanos, clock->time_ns);
1204    SET_IF(GNSS_CLOCK_HAS_TIME_UNCERTAINTY,
1205           TimeUncertaintyNanos,
1206           clock->time_uncertainty_ns);
1207    SET_IF(GNSS_CLOCK_HAS_FULL_BIAS, FullBiasNanos, clock->full_bias_ns);
1208    SET_IF(GNSS_CLOCK_HAS_BIAS, BiasNanos, clock->bias_ns);
1209    SET_IF(GNSS_CLOCK_HAS_BIAS_UNCERTAINTY,
1210           BiasUncertaintyNanos,
1211           clock->bias_uncertainty_ns);
1212    SET_IF(GNSS_CLOCK_HAS_DRIFT, DriftNanosPerSecond, clock->drift_nsps);
1213    SET_IF(GNSS_CLOCK_HAS_DRIFT_UNCERTAINTY,
1214           DriftUncertaintyNanosPerSecond,
1215           clock->drift_uncertainty_nsps);
1216
1217    SET(HardwareClockDiscontinuityCount, clock->hw_clock_discontinuity_count);
1218
1219    return object.get();
1220}
1221
1222static jobject translate_gps_measurement(JNIEnv* env,
1223                                         GpsMeasurement* measurement) {
1224    JavaObject object(env, "android/location/GnssMeasurement");
1225    GpsMeasurementFlags flags = measurement->flags;
1226    SET(Svid, static_cast<int32_t>(measurement->prn));
1227    if (measurement->prn >= 1 && measurement->prn <= 32) {
1228        SET(ConstellationType, static_cast<int32_t>(GNSS_CONSTELLATION_GPS));
1229    } else {
1230        ALOGD("Unknown constellation type with Svid = %d.", measurement->prn);
1231        SET(ConstellationType,
1232            static_cast<int32_t>(GNSS_CONSTELLATION_UNKNOWN));
1233    }
1234    SET(TimeOffsetNanos, measurement->time_offset_ns);
1235    SET(State, static_cast<int32_t>(measurement->state));
1236    SET(ReceivedSvTimeNanos, measurement->received_gps_tow_ns);
1237    SET(ReceivedSvTimeUncertaintyNanos,
1238        measurement->received_gps_tow_uncertainty_ns);
1239    SET(Cn0DbHz, measurement->c_n0_dbhz);
1240    SET(PseudorangeRateMetersPerSecond, measurement->pseudorange_rate_mps);
1241    SET(PseudorangeRateUncertaintyMetersPerSecond,
1242        measurement->pseudorange_rate_uncertainty_mps);
1243    SET(AccumulatedDeltaRangeState,
1244        static_cast<int32_t>(measurement->accumulated_delta_range_state));
1245    SET(AccumulatedDeltaRangeMeters, measurement->accumulated_delta_range_m);
1246    SET(AccumulatedDeltaRangeUncertaintyMeters,
1247        measurement->accumulated_delta_range_uncertainty_m);
1248    SET_IF(GNSS_MEASUREMENT_HAS_CARRIER_FREQUENCY,
1249           CarrierFrequencyHz,
1250           measurement->carrier_frequency_hz);
1251    SET_IF(GNSS_MEASUREMENT_HAS_CARRIER_CYCLES,
1252           CarrierCycles,
1253           measurement->carrier_cycles);
1254    SET_IF(GNSS_MEASUREMENT_HAS_CARRIER_PHASE,
1255           CarrierPhase,
1256           measurement->carrier_phase);
1257    SET_IF(GNSS_MEASUREMENT_HAS_CARRIER_PHASE_UNCERTAINTY,
1258           CarrierPhaseUncertainty,
1259           measurement->carrier_phase_uncertainty);
1260    SET(MultipathIndicator,
1261        static_cast<int32_t>(measurement->multipath_indicator));
1262    SET_IF(GNSS_MEASUREMENT_HAS_SNR, SnrInDb, measurement->snr_db);
1263
1264    return object.get();
1265}
1266
1267static jobject translate_gnss_measurement(JNIEnv* env,
1268                                          GnssMeasurement* measurement) {
1269    JavaObject object(env, "android/location/GnssMeasurement");
1270
1271    GnssMeasurementFlags flags = measurement->flags;
1272
1273    SET(Svid, static_cast<int32_t>(measurement->svid));
1274    SET(ConstellationType, static_cast<int32_t>(measurement->constellation));
1275    SET(TimeOffsetNanos, measurement->time_offset_ns);
1276    SET(State, static_cast<int32_t>(measurement->state));
1277    SET(ReceivedSvTimeNanos, measurement->received_sv_time_in_ns);
1278    SET(ReceivedSvTimeUncertaintyNanos,
1279        measurement->received_sv_time_uncertainty_in_ns);
1280    SET(Cn0DbHz, measurement->c_n0_dbhz);
1281    SET(PseudorangeRateMetersPerSecond, measurement->pseudorange_rate_mps);
1282    SET(PseudorangeRateUncertaintyMetersPerSecond,
1283        measurement->pseudorange_rate_uncertainty_mps);
1284    SET(AccumulatedDeltaRangeState,
1285        static_cast<int32_t>(measurement->accumulated_delta_range_state));
1286    SET(AccumulatedDeltaRangeMeters, measurement->accumulated_delta_range_m);
1287    SET(AccumulatedDeltaRangeUncertaintyMeters,
1288        measurement->accumulated_delta_range_uncertainty_m);
1289    SET_IF(GNSS_MEASUREMENT_HAS_CARRIER_FREQUENCY,
1290           CarrierFrequencyHz,
1291           measurement->carrier_frequency_hz);
1292    SET_IF(GNSS_MEASUREMENT_HAS_CARRIER_CYCLES,
1293           CarrierCycles,
1294           measurement->carrier_cycles);
1295    SET_IF(GNSS_MEASUREMENT_HAS_CARRIER_PHASE,
1296           CarrierPhase,
1297           measurement->carrier_phase);
1298    SET_IF(GNSS_MEASUREMENT_HAS_CARRIER_PHASE_UNCERTAINTY,
1299           CarrierPhaseUncertainty,
1300           measurement->carrier_phase_uncertainty);
1301    SET(MultipathIndicator,
1302        static_cast<int32_t>(measurement->multipath_indicator));
1303    SET_IF(GNSS_MEASUREMENT_HAS_SNR, SnrInDb, measurement->snr_db);
1304
1305    return object.get();
1306}
1307
1308static jobjectArray translate_gps_measurements(JNIEnv* env,
1309                                               GpsMeasurement* measurements,
1310                                               size_t count) {
1311    if (count == 0) {
1312        return NULL;
1313    }
1314
1315    jclass gnssMeasurementClass = env->FindClass(
1316            "android/location/GnssMeasurement");
1317    jobjectArray gnssMeasurementArray = env->NewObjectArray(
1318            count,
1319            gnssMeasurementClass,
1320            NULL /* initialElement */);
1321
1322    for (uint16_t i = 0; i < count; ++i) {
1323        jobject gnssMeasurement = translate_gps_measurement(
1324            env,
1325            &measurements[i]);
1326        env->SetObjectArrayElement(gnssMeasurementArray, i, gnssMeasurement);
1327        env->DeleteLocalRef(gnssMeasurement);
1328    }
1329
1330    env->DeleteLocalRef(gnssMeasurementClass);
1331    return gnssMeasurementArray;
1332}
1333
1334static jobjectArray translate_gnss_measurements(JNIEnv* env,
1335                                                GnssMeasurement* measurements,
1336                                                size_t count) {
1337    if (count == 0) {
1338        return NULL;
1339    }
1340
1341    jclass gnssMeasurementClass = env->FindClass(
1342            "android/location/GnssMeasurement");
1343    jobjectArray gnssMeasurementArray = env->NewObjectArray(
1344            count,
1345            gnssMeasurementClass,
1346            NULL /* initialElement */);
1347
1348    for (uint16_t i = 0; i < count; ++i) {
1349        jobject gnssMeasurement = translate_gnss_measurement(
1350            env,
1351            &measurements[i]);
1352        env->SetObjectArrayElement(gnssMeasurementArray, i, gnssMeasurement);
1353        env->DeleteLocalRef(gnssMeasurement);
1354    }
1355
1356    env->DeleteLocalRef(gnssMeasurementClass);
1357    return gnssMeasurementArray;
1358}
1359
1360static void set_measurement_data(JNIEnv *env,
1361                                 jobject clock,
1362                                 jobjectArray measurementArray) {
1363    jclass gnssMeasurementsEventClass = env->FindClass(
1364            "android/location/GnssMeasurementsEvent");
1365    jmethodID gnssMeasurementsEventCtor = env->GetMethodID(
1366        gnssMeasurementsEventClass,
1367        "<init>",
1368        "(Landroid/location/GnssClock;[Landroid/location/GnssMeasurement;)V");
1369
1370    jobject gnssMeasurementsEvent = env->NewObject(
1371        gnssMeasurementsEventClass,
1372        gnssMeasurementsEventCtor,
1373        clock,
1374        measurementArray);
1375    env->CallVoidMethod(mCallbacksObj,
1376                        method_reportMeasurementData,
1377                        gnssMeasurementsEvent);
1378    checkAndClearExceptionFromCallback(env, __FUNCTION__);
1379    env->DeleteLocalRef(gnssMeasurementsEventClass);
1380    env->DeleteLocalRef(gnssMeasurementsEvent);
1381}
1382
1383static void measurement_callback(GpsData* data) {
1384    JNIEnv* env = AndroidRuntime::getJNIEnv();
1385    if (data == NULL) {
1386        ALOGE("Invalid data provided to gps_measurement_callback");
1387        return;
1388    }
1389    if (data->size != sizeof(GpsData)) {
1390        ALOGE("Invalid GpsData size found in gps_measurement_callback, "
1391              "size=%zd",
1392              data->size);
1393        return;
1394    }
1395
1396    jobject clock;
1397    jobjectArray measurementArray;
1398    clock = translate_gps_clock(env, &data->clock);
1399    measurementArray = translate_gps_measurements(
1400            env, data->measurements, data->measurement_count);
1401    set_measurement_data(env, clock, measurementArray);
1402
1403    env->DeleteLocalRef(clock);
1404    env->DeleteLocalRef(measurementArray);
1405}
1406
1407static void gnss_measurement_callback(GnssData* data) {
1408    JNIEnv* env = AndroidRuntime::getJNIEnv();
1409    if (data == NULL) {
1410        ALOGE("Invalid data provided to gps_measurement_callback");
1411        return;
1412    }
1413    if (data->size != sizeof(GnssData)) {
1414        ALOGE("Invalid GnssData size found in gnss_measurement_callback, "
1415              "size=%zd",
1416              data->size);
1417        return;
1418    }
1419
1420    jobject clock;
1421    jobjectArray measurementArray;
1422    clock = translate_gnss_clock(env, &data->clock);
1423    measurementArray = translate_gnss_measurements(
1424            env, data->measurements, data->measurement_count);
1425    set_measurement_data(env, clock, measurementArray);
1426
1427    env->DeleteLocalRef(clock);
1428    env->DeleteLocalRef(measurementArray);
1429}
1430
1431GpsMeasurementCallbacks sGpsMeasurementCallbacks = {
1432    sizeof(GpsMeasurementCallbacks),
1433    measurement_callback,
1434    gnss_measurement_callback,
1435};
1436
1437static jboolean android_location_GnssLocationProvider_is_measurement_supported(
1438        JNIEnv* env,
1439        jclass clazz) {
1440    if (sGpsMeasurementInterface != NULL) {
1441        return JNI_TRUE;
1442    }
1443    return JNI_FALSE;
1444}
1445
1446static jboolean android_location_GnssLocationProvider_start_measurement_collection(
1447        JNIEnv* env,
1448        jobject obj) {
1449    if (sGpsMeasurementInterface == NULL) {
1450        ALOGE("Measurement interface is not available.");
1451        return JNI_FALSE;
1452    }
1453
1454    int result = sGpsMeasurementInterface->init(&sGpsMeasurementCallbacks);
1455    if (result != GPS_GEOFENCE_OPERATION_SUCCESS) {
1456        ALOGE("An error has been found on GpsMeasurementInterface::init, status=%d", result);
1457        return JNI_FALSE;
1458    }
1459
1460    return JNI_TRUE;
1461}
1462
1463static jboolean android_location_GnssLocationProvider_stop_measurement_collection(
1464        JNIEnv* env,
1465        jobject obj) {
1466    if (sGpsMeasurementInterface == NULL) {
1467        ALOGE("Measurement interface not available");
1468        return JNI_FALSE;
1469    }
1470
1471    sGpsMeasurementInterface->close();
1472    return JNI_TRUE;
1473}
1474
1475static jobject translate_gps_navigation_message(JNIEnv* env, GpsNavigationMessage* message) {
1476    size_t dataLength = message->data_length;
1477    uint8_t* data = message->data;
1478    if (dataLength == 0 || data == NULL) {
1479        ALOGE("Invalid Navigation Message found: data=%p, length=%zd", data, dataLength);
1480        return NULL;
1481    }
1482    JavaObject object(env, "android/location/GnssNavigationMessage");
1483    SET(Svid, static_cast<int32_t>(message->prn));
1484    if (message->prn >=1 && message->prn <= 32) {
1485        SET(ConstellationType, static_cast<int32_t>(GNSS_CONSTELLATION_GPS));
1486        // Legacy driver doesn't set the higher byte to constellation type
1487        // correctly. Set the higher byte to 'GPS'.
1488        SET(Type, static_cast<int32_t>(message->type | 0x0100));
1489    } else {
1490        ALOGD("Unknown constellation type with Svid = %d.", message->prn);
1491        SET(ConstellationType,
1492            static_cast<int32_t>(GNSS_CONSTELLATION_UNKNOWN));
1493        SET(Type, static_cast<int32_t>(GNSS_NAVIGATION_MESSAGE_TYPE_UNKNOWN));
1494    }
1495    SET(MessageId, static_cast<int32_t>(message->message_id));
1496    SET(SubmessageId, static_cast<int32_t>(message->submessage_id));
1497    object.callSetter("setData", data, dataLength);
1498    SET(Status, static_cast<int32_t>(message->status));
1499    return object.get();
1500}
1501
1502static jobject translate_gnss_navigation_message(
1503        JNIEnv* env, GnssNavigationMessage* message) {
1504    size_t dataLength = message->data_length;
1505    uint8_t* data = message->data;
1506    if (dataLength == 0 || data == NULL) {
1507        ALOGE("Invalid Navigation Message found: data=%p, length=%zd", data, dataLength);
1508        return NULL;
1509    }
1510    JavaObject object(env, "android/location/GnssNavigationMessage");
1511    SET(Type, static_cast<int32_t>(message->type));
1512    SET(Svid, static_cast<int32_t>(message->svid));
1513    SET(MessageId, static_cast<int32_t>(message->message_id));
1514    SET(SubmessageId, static_cast<int32_t>(message->submessage_id));
1515    object.callSetter("setData", data, dataLength);
1516    SET(Status, static_cast<int32_t>(message->status));
1517    return object.get();
1518}
1519
1520static void navigation_message_callback(GpsNavigationMessage* message) {
1521    if (message == NULL) {
1522        ALOGE("Invalid Navigation Message provided to callback");
1523        return;
1524    }
1525    if (message->size != sizeof(GpsNavigationMessage)) {
1526        ALOGE("Invalid GpsNavigationMessage size found: %zd", message->size);
1527        return;
1528    }
1529    JNIEnv* env = AndroidRuntime::getJNIEnv();
1530    jobject navigationMessage = translate_gps_navigation_message(env, message);
1531    env->CallVoidMethod(mCallbacksObj,
1532                        method_reportNavigationMessages,
1533                        navigationMessage);
1534    env->DeleteLocalRef(navigationMessage);
1535}
1536
1537static void gnss_navigation_message_callback(GnssNavigationMessage* message) {
1538    if (message == NULL) {
1539        ALOGE("Invalid Navigation Message provided to callback");
1540        return;
1541    }
1542    if (message->size != sizeof(GnssNavigationMessage)) {
1543        ALOGE("Invalid GnssNavigationMessage size found: %zd", message->size);
1544        return;
1545    }
1546    JNIEnv* env = AndroidRuntime::getJNIEnv();
1547    jobject navigationMessage = translate_gnss_navigation_message(env, message);
1548    env->CallVoidMethod(mCallbacksObj,
1549                        method_reportNavigationMessages,
1550                        navigationMessage);
1551    env->DeleteLocalRef(navigationMessage);
1552}
1553
1554GpsNavigationMessageCallbacks sGpsNavigationMessageCallbacks = {
1555    sizeof(GpsNavigationMessageCallbacks),
1556    navigation_message_callback,
1557    gnss_navigation_message_callback,
1558};
1559
1560static jboolean android_location_GnssLocationProvider_is_navigation_message_supported(
1561        JNIEnv* env,
1562        jclass clazz) {
1563    if(sGpsNavigationMessageInterface != NULL) {
1564        return JNI_TRUE;
1565    }
1566    return JNI_FALSE;
1567}
1568
1569static jboolean android_location_GnssLocationProvider_start_navigation_message_collection(
1570        JNIEnv* env,
1571        jobject obj) {
1572    if (sGpsNavigationMessageInterface == NULL) {
1573        ALOGE("Navigation Message interface is not available.");
1574        return JNI_FALSE;
1575    }
1576
1577    int result = sGpsNavigationMessageInterface->init(&sGpsNavigationMessageCallbacks);
1578    if (result != GPS_NAVIGATION_MESSAGE_OPERATION_SUCCESS) {
1579        ALOGE("An error has been found in %s: %d", __FUNCTION__, result);
1580        return JNI_FALSE;
1581    }
1582
1583    return JNI_TRUE;
1584}
1585
1586static jboolean android_location_GnssLocationProvider_stop_navigation_message_collection(
1587        JNIEnv* env,
1588        jobject obj) {
1589    if (sGpsNavigationMessageInterface == NULL) {
1590        ALOGE("Navigation Message interface is not available.");
1591        return JNI_FALSE;
1592    }
1593
1594    sGpsNavigationMessageInterface->close();
1595    return JNI_TRUE;
1596}
1597
1598static void android_location_GnssLocationProvider_configuration_update(JNIEnv* env, jobject obj,
1599        jstring config_content)
1600{
1601    if (!sGnssConfigurationInterface) {
1602        ALOGE("no GPS configuration interface in configuraiton_update");
1603        return;
1604    }
1605    const char *data = env->GetStringUTFChars(config_content, NULL);
1606    ALOGD("GPS configuration:\n %s", data);
1607    sGnssConfigurationInterface->configuration_update(
1608            data, env->GetStringUTFLength(config_content));
1609    env->ReleaseStringUTFChars(config_content, data);
1610}
1611
1612static const JNINativeMethod sMethods[] = {
1613     /* name, signature, funcPtr */
1614    {"class_init_native", "()V", (void *)android_location_GnssLocationProvider_class_init_native},
1615    {"native_is_supported", "()Z", (void*)android_location_GnssLocationProvider_is_supported},
1616    {"native_is_agps_ril_supported", "()Z",
1617            (void*)android_location_GnssLocationProvider_is_agps_ril_supported},
1618    {"native_is_gnss_configuration_supported", "()Z",
1619            (void*)android_location_gpsLocationProvider_is_gnss_configuration_supported},
1620    {"native_init", "()Z", (void*)android_location_GnssLocationProvider_init},
1621    {"native_cleanup", "()V", (void*)android_location_GnssLocationProvider_cleanup},
1622    {"native_set_position_mode",
1623            "(IIIII)Z",
1624            (void*)android_location_GnssLocationProvider_set_position_mode},
1625    {"native_start", "()Z", (void*)android_location_GnssLocationProvider_start},
1626    {"native_stop", "()Z", (void*)android_location_GnssLocationProvider_stop},
1627    {"native_delete_aiding_data",
1628            "(I)V",
1629            (void*)android_location_GnssLocationProvider_delete_aiding_data},
1630    {"native_read_sv_status",
1631            "([I[F[F[F)I",
1632            (void*)android_location_GnssLocationProvider_read_sv_status},
1633    {"native_read_nmea", "([BI)I", (void*)android_location_GnssLocationProvider_read_nmea},
1634    {"native_inject_time", "(JJI)V", (void*)android_location_GnssLocationProvider_inject_time},
1635    {"native_inject_location",
1636            "(DDF)V",
1637            (void*)android_location_GnssLocationProvider_inject_location},
1638    {"native_supports_xtra", "()Z", (void*)android_location_GnssLocationProvider_supports_xtra},
1639    {"native_inject_xtra_data",
1640            "([BI)V",
1641            (void*)android_location_GnssLocationProvider_inject_xtra_data},
1642    {"native_agps_data_conn_open",
1643            "(Ljava/lang/String;I)V",
1644            (void*)android_location_GnssLocationProvider_agps_data_conn_open},
1645    {"native_agps_data_conn_closed",
1646            "()V",
1647            (void*)android_location_GnssLocationProvider_agps_data_conn_closed},
1648    {"native_agps_data_conn_failed",
1649            "()V",
1650            (void*)android_location_GnssLocationProvider_agps_data_conn_failed},
1651    {"native_agps_set_id",
1652            "(ILjava/lang/String;)V",
1653            (void*)android_location_GnssLocationProvider_agps_set_id},
1654    {"native_agps_set_ref_location_cellid",
1655            "(IIIII)V",
1656            (void*)android_location_GnssLocationProvider_agps_set_reference_location_cellid},
1657    {"native_set_agps_server",
1658            "(ILjava/lang/String;I)V",
1659            (void*)android_location_GnssLocationProvider_set_agps_server},
1660    {"native_send_ni_response",
1661            "(II)V",
1662            (void*)android_location_GnssLocationProvider_send_ni_response},
1663    {"native_agps_ni_message",
1664            "([BI)V",
1665            (void *)android_location_GnssLocationProvider_agps_send_ni_message},
1666    {"native_get_internal_state",
1667            "()Ljava/lang/String;",
1668            (void*)android_location_GnssLocationProvider_get_internal_state},
1669    {"native_update_network_state",
1670            "(ZIZZLjava/lang/String;Ljava/lang/String;)V",
1671            (void*)android_location_GnssLocationProvider_update_network_state },
1672    {"native_is_geofence_supported",
1673            "()Z",
1674            (void*) android_location_GnssLocationProvider_is_geofence_supported},
1675    {"native_add_geofence",
1676            "(IDDDIIII)Z",
1677            (void *)android_location_GnssLocationProvider_add_geofence},
1678    {"native_remove_geofence",
1679            "(I)Z",
1680            (void *)android_location_GnssLocationProvider_remove_geofence},
1681    {"native_pause_geofence", "(I)Z", (void *)android_location_GnssLocationProvider_pause_geofence},
1682    {"native_resume_geofence",
1683            "(II)Z",
1684            (void *)android_location_GnssLocationProvider_resume_geofence},
1685    {"native_is_measurement_supported",
1686            "()Z",
1687            (void*) android_location_GnssLocationProvider_is_measurement_supported},
1688    {"native_start_measurement_collection",
1689            "()Z",
1690            (void*) android_location_GnssLocationProvider_start_measurement_collection},
1691    {"native_stop_measurement_collection",
1692            "()Z",
1693            (void*) android_location_GnssLocationProvider_stop_measurement_collection},
1694    {"native_is_navigation_message_supported",
1695            "()Z",
1696            (void*) android_location_GnssLocationProvider_is_navigation_message_supported},
1697    {"native_start_navigation_message_collection",
1698            "()Z",
1699            (void*) android_location_GnssLocationProvider_start_navigation_message_collection},
1700    {"native_stop_navigation_message_collection",
1701            "()Z",
1702            (void*) android_location_GnssLocationProvider_stop_navigation_message_collection},
1703    {"native_configuration_update",
1704            "(Ljava/lang/String;)V",
1705            (void*)android_location_GnssLocationProvider_configuration_update},
1706};
1707
1708int register_android_server_location_GnssLocationProvider(JNIEnv* env)
1709{
1710    return jniRegisterNativeMethods(
1711            env,
1712            "com/android/server/location/GnssLocationProvider",
1713            sMethods,
1714            NELEM(sMethods));
1715}
1716
1717} /* namespace android */
1718