Home | History | Annotate | Download | only in jni 
      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 <android/hardware/gnss/1.0/IGnss.h>
     22 #include <android/hardware/gnss/1.1/IGnss.h>
     23 
     24 #include <android/hardware/gnss/1.0/IGnssMeasurement.h>
     25 #include <android/hardware/gnss/1.1/IGnssMeasurement.h>
     26 #include <nativehelper/JNIHelp.h>
     27 #include "jni.h"
     28 #include "hardware_legacy/power.h"
     29 #include "utils/Log.h"
     30 #include "utils/misc.h"
     31 #include "android_runtime/AndroidRuntime.h"
     32 #include "android_runtime/Log.h"
     33 
     34 #include <arpa/inet.h>
     35 #include <limits>
     36 #include <linux/in.h>
     37 #include <linux/in6.h>
     38 #include <pthread.h>
     39 #include <string.h>
     40 #include <cinttypes>
     41 #include <iomanip>
     42 
     43 static jobject mCallbacksObj = NULL;
     44 
     45 static jmethodID method_reportLocation;
     46 static jmethodID method_reportStatus;
     47 static jmethodID method_reportSvStatus;
     48 static jmethodID method_reportAGpsStatus;
     49 static jmethodID method_reportNmea;
     50 static jmethodID method_setEngineCapabilities;
     51 static jmethodID method_setGnssYearOfHardware;
     52 static jmethodID method_setGnssHardwareModelName;
     53 static jmethodID method_xtraDownloadRequest;
     54 static jmethodID method_reportNiNotification;
     55 static jmethodID method_requestLocation;
     56 static jmethodID method_requestRefLocation;
     57 static jmethodID method_requestSetID;
     58 static jmethodID method_requestUtcTime;
     59 static jmethodID method_reportGeofenceTransition;
     60 static jmethodID method_reportGeofenceStatus;
     61 static jmethodID method_reportGeofenceAddStatus;
     62 static jmethodID method_reportGeofenceRemoveStatus;
     63 static jmethodID method_reportGeofencePauseStatus;
     64 static jmethodID method_reportGeofenceResumeStatus;
     65 static jmethodID method_reportMeasurementData;
     66 static jmethodID method_reportNavigationMessages;
     67 static jmethodID method_reportLocationBatch;
     68 static jmethodID method_reportGnssServiceDied;
     69 
     70 /*
     71  * Save a pointer to JavaVm to attach/detach threads executing
     72  * callback methods that need to make JNI calls.
     73  */
     74 static JavaVM* sJvm;
     75 
     76 using android::OK;
     77 using android::sp;
     78 using android::wp;
     79 using android::status_t;
     80 using android::String16;
     81 
     82 using android::hardware::Return;
     83 using android::hardware::Void;
     84 using android::hardware::hidl_vec;
     85 using android::hardware::hidl_death_recipient;
     86 using android::hardware::gnss::V1_0::GnssConstellationType;
     87 using android::hardware::gnss::V1_0::GnssLocation;
     88 using android::hardware::gnss::V1_0::GnssLocationFlags;
     89 
     90 using android::hardware::gnss::V1_0::IAGnss;
     91 using android::hardware::gnss::V1_0::IAGnssCallback;
     92 using android::hardware::gnss::V1_0::IAGnssCallback;
     93 using android::hardware::gnss::V1_0::IAGnssRil;
     94 using android::hardware::gnss::V1_0::IAGnssRilCallback;
     95 using android::hardware::gnss::V1_0::IGnssBatching;
     96 using android::hardware::gnss::V1_0::IGnssBatchingCallback;
     97 using android::hardware::gnss::V1_0::IGnssDebug;
     98 using android::hardware::gnss::V1_0::IGnssGeofenceCallback;
     99 using android::hardware::gnss::V1_0::IGnssGeofencing;
    100 using android::hardware::gnss::V1_0::IGnssNavigationMessage;
    101 using android::hardware::gnss::V1_0::IGnssNavigationMessageCallback;
    102 using android::hardware::gnss::V1_0::IGnssNi;
    103 using android::hardware::gnss::V1_0::IGnssNiCallback;
    104 using android::hardware::gnss::V1_0::IGnssXtra;
    105 using android::hardware::gnss::V1_0::IGnssXtraCallback;
    106 
    107 using android::hardware::gnss::V1_1::IGnssCallback;
    108 
    109 using android::hidl::base::V1_0::IBase;
    110 
    111 using IGnss_V1_0 = android::hardware::gnss::V1_0::IGnss;
    112 using IGnss_V1_1 = android::hardware::gnss::V1_1::IGnss;
    113 using IGnssConfiguration_V1_0 = android::hardware::gnss::V1_0::IGnssConfiguration;
    114 using IGnssConfiguration_V1_1 = android::hardware::gnss::V1_1::IGnssConfiguration;
    115 using IGnssMeasurement_V1_0 = android::hardware::gnss::V1_0::IGnssMeasurement;
    116 using IGnssMeasurement_V1_1 = android::hardware::gnss::V1_1::IGnssMeasurement;
    117 using IGnssMeasurementCallback_V1_0 = android::hardware::gnss::V1_0::IGnssMeasurementCallback;
    118 using IGnssMeasurementCallback_V1_1 = android::hardware::gnss::V1_1::IGnssMeasurementCallback;
    119 
    120 
    121 struct GnssDeathRecipient : virtual public hidl_death_recipient
    122 {
    123     // hidl_death_recipient interface
    124     virtual void serviceDied(uint64_t cookie, const wp<IBase>& who) override {
    125         ALOGE("IGNSS hidl service failed, trying to recover...");
    126 
    127         JNIEnv* env = android::AndroidRuntime::getJNIEnv();
    128         env->CallVoidMethod(mCallbacksObj, method_reportGnssServiceDied);
    129     }
    130 };
    131 
    132 // Must match the value from GnssMeasurement.java
    133 static const uint32_t ADR_STATE_HALF_CYCLE_REPORTED = (1<<4);
    134 
    135 sp<GnssDeathRecipient> gnssHalDeathRecipient = nullptr;
    136 sp<IGnss_V1_0> gnssHal = nullptr;
    137 sp<IGnss_V1_1> gnssHal_V1_1 = nullptr;
    138 sp<IGnssXtra> gnssXtraIface = nullptr;
    139 sp<IAGnssRil> agnssRilIface = nullptr;
    140 sp<IGnssGeofencing> gnssGeofencingIface = nullptr;
    141 sp<IAGnss> agnssIface = nullptr;
    142 sp<IGnssBatching> gnssBatchingIface = nullptr;
    143 sp<IGnssDebug> gnssDebugIface = nullptr;
    144 sp<IGnssConfiguration_V1_0> gnssConfigurationIface = nullptr;
    145 sp<IGnssConfiguration_V1_1> gnssConfigurationIface_V1_1 = nullptr;
    146 sp<IGnssNi> gnssNiIface = nullptr;
    147 sp<IGnssMeasurement_V1_0> gnssMeasurementIface = nullptr;
    148 sp<IGnssMeasurement_V1_1> gnssMeasurementIface_V1_1 = nullptr;
    149 sp<IGnssNavigationMessage> gnssNavigationMessageIface = nullptr;
    150 
    151 #define WAKE_LOCK_NAME  "GPS"
    152 
    153 namespace android {
    154 
    155 template<class T>
    156 class JavaMethodHelper {
    157  public:
    158     // Helper function to call setter on a Java object.
    159     static void callJavaMethod(
    160            JNIEnv* env,
    161            jclass clazz,
    162            jobject object,
    163            const char* method_name,
    164            T value);
    165 
    166  private:
    167     static const char *const signature_;
    168 };
    169 
    170 template<class T>
    171 void JavaMethodHelper<T>::callJavaMethod(
    172         JNIEnv* env,
    173         jclass clazz,
    174         jobject object,
    175         const char* method_name,
    176         T value) {
    177     jmethodID method = env->GetMethodID(clazz, method_name, signature_);
    178     env->CallVoidMethod(object, method, value);
    179 }
    180 
    181 class JavaObject {
    182  public:
    183     JavaObject(JNIEnv* env, const char* class_name);
    184     JavaObject(JNIEnv* env, const char* class_name, const char * sz_arg_1);
    185     virtual ~JavaObject();
    186 
    187     template<class T>
    188     void callSetter(const char* method_name, T value);
    189     template<class T>
    190     void callSetter(const char* method_name, T* value, size_t size);
    191     jobject get();
    192 
    193  private:
    194     JNIEnv* env_;
    195     jclass clazz_;
    196     jobject object_;
    197 };
    198 
    199 JavaObject::JavaObject(JNIEnv* env, const char* class_name) : env_(env) {
    200     clazz_ = env_->FindClass(class_name);
    201     jmethodID ctor = env->GetMethodID(clazz_, "<init>", "()V");
    202     object_ = env_->NewObject(clazz_, ctor);
    203 }
    204 
    205 JavaObject::JavaObject(JNIEnv* env, const char* class_name, const char * sz_arg_1) : env_(env) {
    206     clazz_ = env_->FindClass(class_name);
    207     jmethodID ctor = env->GetMethodID(clazz_, "<init>", "(Ljava/lang/String;)V");
    208     object_ = env_->NewObject(clazz_, ctor, env->NewStringUTF(sz_arg_1));
    209 }
    210 
    211 JavaObject::~JavaObject() {
    212     env_->DeleteLocalRef(clazz_);
    213 }
    214 
    215 template<class T>
    216 void JavaObject::callSetter(const char* method_name, T value) {
    217     JavaMethodHelper<T>::callJavaMethod(
    218             env_, clazz_, object_, method_name, value);
    219 }
    220 
    221 template<>
    222 void JavaObject::callSetter(
    223         const char* method_name, uint8_t* value, size_t size) {
    224     jbyteArray array = env_->NewByteArray(size);
    225     env_->SetByteArrayRegion(array, 0, size, reinterpret_cast<jbyte*>(value));
    226     jmethodID method = env_->GetMethodID(
    227             clazz_,
    228             method_name,
    229             "([B)V");
    230     env_->CallVoidMethod(object_, method, array);
    231     env_->DeleteLocalRef(array);
    232 }
    233 
    234 jobject JavaObject::get() {
    235     return object_;
    236 }
    237 
    238 // Define Java method signatures for all known types.
    239 template<>
    240 const char *const JavaMethodHelper<uint8_t>::signature_ = "(B)V";
    241 template<>
    242 const char *const JavaMethodHelper<int8_t>::signature_ = "(B)V";
    243 template<>
    244 const char *const JavaMethodHelper<int16_t>::signature_ = "(S)V";
    245 template<>
    246 const char *const JavaMethodHelper<uint16_t>::signature_ = "(S)V";
    247 template<>
    248 const char *const JavaMethodHelper<int32_t>::signature_ = "(I)V";
    249 template<>
    250 const char *const JavaMethodHelper<uint32_t>::signature_ = "(I)V";
    251 template<>
    252 const char *const JavaMethodHelper<int64_t>::signature_ = "(J)V";
    253 template<>
    254 const char *const JavaMethodHelper<float>::signature_ = "(F)V";
    255 template<>
    256 const char *const JavaMethodHelper<double>::signature_ = "(D)V";
    257 template<>
    258 const char *const JavaMethodHelper<bool>::signature_ = "(Z)V";
    259 
    260 #define SET(setter, value) object.callSetter("set" # setter, (value))
    261 
    262 static inline jboolean boolToJbool(bool value) {
    263     return value ? JNI_TRUE : JNI_FALSE;
    264 }
    265 
    266 static void checkAndClearExceptionFromCallback(JNIEnv* env, const char* methodName) {
    267     if (env->ExceptionCheck()) {
    268         ALOGE("An exception was thrown by callback '%s'.", methodName);
    269         LOGE_EX(env);
    270         env->ExceptionClear();
    271     }
    272 }
    273 
    274 class ScopedJniThreadAttach {
    275 public:
    276     ScopedJniThreadAttach() {
    277         /*
    278          * attachResult will also be JNI_OK if the thead was already attached to
    279          * JNI before the call to AttachCurrentThread().
    280          */
    281         jint attachResult = sJvm->AttachCurrentThread(&mEnv, nullptr);
    282         LOG_ALWAYS_FATAL_IF(attachResult != JNI_OK, "Unable to attach thread. Error %d",
    283                             attachResult);
    284     }
    285 
    286     ~ScopedJniThreadAttach() {
    287         jint detachResult = sJvm->DetachCurrentThread();
    288         /*
    289          * Return if the thread was already detached. Log error for any other
    290          * failure.
    291          */
    292         if (detachResult == JNI_EDETACHED) {
    293             return;
    294         }
    295 
    296         LOG_ALWAYS_FATAL_IF(detachResult != JNI_OK, "Unable to detach thread. Error %d",
    297                             detachResult);
    298     }
    299 
    300     JNIEnv* getEnv() {
    301         /*
    302          * Checking validity of mEnv in case the thread was detached elsewhere.
    303          */
    304         LOG_ALWAYS_FATAL_IF(AndroidRuntime::getJNIEnv() != mEnv);
    305         return mEnv;
    306     }
    307 
    308 private:
    309     JNIEnv* mEnv = nullptr;
    310 };
    311 
    312 thread_local std::unique_ptr<ScopedJniThreadAttach> tJniThreadAttacher;
    313 
    314 static JNIEnv* getJniEnv() {
    315     JNIEnv* env = AndroidRuntime::getJNIEnv();
    316 
    317     /*
    318      * If env is nullptr, the thread is not already attached to
    319      * JNI. It is attached below and the destructor for ScopedJniThreadAttach
    320      * will detach it on thread exit.
    321      */
    322     if (env == nullptr) {
    323         tJniThreadAttacher.reset(new ScopedJniThreadAttach());
    324         env = tJniThreadAttacher->getEnv();
    325     }
    326 
    327     return env;
    328 }
    329 
    330 static jobject translateLocation(JNIEnv* env, const GnssLocation& location) {
    331     JavaObject object(env, "android/location/Location", "gps");
    332 
    333     uint16_t flags = static_cast<uint32_t>(location.gnssLocationFlags);
    334     if (flags & GnssLocationFlags::HAS_LAT_LONG) {
    335         SET(Latitude, location.latitudeDegrees);
    336         SET(Longitude, location.longitudeDegrees);
    337     }
    338     if (flags & GnssLocationFlags::HAS_ALTITUDE) {
    339         SET(Altitude, location.altitudeMeters);
    340     }
    341     if (flags & GnssLocationFlags::HAS_SPEED) {
    342         SET(Speed, location.speedMetersPerSec);
    343     }
    344     if (flags & GnssLocationFlags::HAS_BEARING) {
    345         SET(Bearing, location.bearingDegrees);
    346     }
    347     if (flags & GnssLocationFlags::HAS_HORIZONTAL_ACCURACY) {
    348         SET(Accuracy, location.horizontalAccuracyMeters);
    349     }
    350     if (flags & GnssLocationFlags::HAS_VERTICAL_ACCURACY) {
    351         SET(VerticalAccuracyMeters, location.verticalAccuracyMeters);
    352     }
    353     if (flags & GnssLocationFlags::HAS_SPEED_ACCURACY) {
    354         SET(SpeedAccuracyMetersPerSecond, location.speedAccuracyMetersPerSecond);
    355     }
    356     if (flags & GnssLocationFlags::HAS_BEARING_ACCURACY) {
    357         SET(BearingAccuracyDegrees, location.bearingAccuracyDegrees);
    358     }
    359     SET(Time, location.timestamp);
    360 
    361     return object.get();
    362 }
    363 
    364 static GnssLocation createGnssLocation(
    365         jint gnssLocationFlags,
    366         jdouble latitudeDegrees,
    367         jdouble longitudeDegrees,
    368         jdouble altitudeMeters,
    369         jfloat speedMetersPerSec,
    370         jfloat bearingDegrees,
    371         jfloat horizontalAccuracyMeters,
    372         jfloat verticalAccuracyMeters,
    373         jfloat speedAccuracyMetersPerSecond,
    374         jfloat bearingAccuracyDegrees,
    375         jlong timestamp) {
    376     GnssLocation location;
    377     location.gnssLocationFlags = static_cast<uint16_t>(gnssLocationFlags);
    378     location.latitudeDegrees = static_cast<double>(latitudeDegrees);
    379     location.longitudeDegrees = static_cast<double>(longitudeDegrees);
    380     location.altitudeMeters = static_cast<double>(altitudeMeters);
    381     location.speedMetersPerSec = static_cast<float>(speedMetersPerSec);
    382     location.bearingDegrees = static_cast<float>(bearingDegrees);
    383     location.horizontalAccuracyMeters = static_cast<float>(horizontalAccuracyMeters);
    384     location.verticalAccuracyMeters = static_cast<float>(verticalAccuracyMeters);
    385     location.speedAccuracyMetersPerSecond = static_cast<float>(speedAccuracyMetersPerSecond);
    386     location.bearingAccuracyDegrees = static_cast<float>(bearingAccuracyDegrees);
    387     location.timestamp = static_cast<uint64_t>(timestamp);
    388 
    389     return location;
    390 }
    391 
    392 /*
    393  * GnssCallback class implements the callback methods for IGnss interface.
    394  */
    395 struct GnssCallback : public IGnssCallback {
    396     Return<void> gnssLocationCb(const GnssLocation& location) override;
    397     Return<void> gnssStatusCb(const IGnssCallback::GnssStatusValue status) override;
    398     Return<void> gnssSvStatusCb(const IGnssCallback::GnssSvStatus& svStatus) override;
    399     Return<void> gnssNmeaCb(int64_t timestamp, const android::hardware::hidl_string& nmea) override;
    400     Return<void> gnssSetCapabilitesCb(uint32_t capabilities) override;
    401     Return<void> gnssAcquireWakelockCb() override;
    402     Return<void> gnssReleaseWakelockCb() override;
    403     Return<void> gnssRequestTimeCb() override;
    404     Return<void> gnssRequestLocationCb(const bool independentFromGnss) override;
    405     Return<void> gnssSetSystemInfoCb(const IGnssCallback::GnssSystemInfo& info) override;
    406 
    407     // New in 1.1
    408     Return<void> gnssNameCb(const android::hardware::hidl_string& name) override;
    409 
    410     // TODO(b/73306084): Reconsider allocation cost vs threadsafety on these statics
    411     static const char* sNmeaString;
    412     static size_t sNmeaStringLength;
    413 };
    414 
    415 Return<void> GnssCallback::gnssNameCb(const android::hardware::hidl_string& name) {
    416     ALOGD("%s: name=%s\n", __func__, name.c_str());
    417 
    418     JNIEnv* env = getJniEnv();
    419     jstring jstringName = env->NewStringUTF(name.c_str());
    420     env->CallVoidMethod(mCallbacksObj, method_setGnssHardwareModelName, jstringName);
    421     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    422 
    423     return Void();
    424 }
    425 
    426 const char* GnssCallback::sNmeaString = nullptr;
    427 size_t GnssCallback::sNmeaStringLength = 0;
    428 
    429 Return<void> GnssCallback::gnssLocationCb(const GnssLocation& location) {
    430     JNIEnv* env = getJniEnv();
    431 
    432     jobject jLocation = translateLocation(env, location);
    433     bool hasLatLong = (static_cast<uint32_t>(location.gnssLocationFlags) &
    434             GnssLocationFlags::HAS_LAT_LONG) != 0;
    435 
    436     env->CallVoidMethod(mCallbacksObj,
    437                         method_reportLocation,
    438                         boolToJbool(hasLatLong),
    439                         jLocation);
    440     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    441     env->DeleteLocalRef(jLocation);
    442     return Void();
    443 }
    444 
    445 Return<void> GnssCallback::gnssStatusCb(const IGnssCallback::GnssStatusValue status) {
    446     JNIEnv* env = getJniEnv();
    447     env->CallVoidMethod(mCallbacksObj, method_reportStatus, status);
    448     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    449     return Void();
    450 }
    451 
    452 Return<void> GnssCallback::gnssSvStatusCb(const IGnssCallback::GnssSvStatus& svStatus) {
    453     JNIEnv* env = getJniEnv();
    454 
    455     uint32_t listSize = svStatus.numSvs;
    456     if (listSize > static_cast<uint32_t>(
    457             android::hardware::gnss::V1_0::GnssMax::SVS_COUNT)) {
    458         ALOGD("Too many satellites %u. Clamps to %u.", listSize,
    459               static_cast<uint32_t>(android::hardware::gnss::V1_0::GnssMax::SVS_COUNT));
    460         listSize = static_cast<uint32_t>(android::hardware::gnss::V1_0::GnssMax::SVS_COUNT);
    461     }
    462 
    463     jintArray svidWithFlagArray = env->NewIntArray(listSize);
    464     jfloatArray cn0Array = env->NewFloatArray(listSize);
    465     jfloatArray elevArray = env->NewFloatArray(listSize);
    466     jfloatArray azimArray = env->NewFloatArray(listSize);
    467     jfloatArray carrierFreqArray = env->NewFloatArray(listSize);
    468 
    469     jint* svidWithFlags = env->GetIntArrayElements(svidWithFlagArray, 0);
    470     jfloat* cn0s = env->GetFloatArrayElements(cn0Array, 0);
    471     jfloat* elev = env->GetFloatArrayElements(elevArray, 0);
    472     jfloat* azim = env->GetFloatArrayElements(azimArray, 0);
    473     jfloat* carrierFreq = env->GetFloatArrayElements(carrierFreqArray, 0);
    474 
    475     /*
    476      * Read GNSS SV info.
    477      */
    478     for (size_t i = 0; i < listSize; ++i) {
    479         enum ShiftWidth: uint8_t {
    480             SVID_SHIFT_WIDTH = 8,
    481             CONSTELLATION_TYPE_SHIFT_WIDTH = 4
    482         };
    483 
    484         const IGnssCallback::GnssSvInfo& info = svStatus.gnssSvList.data()[i];
    485         svidWithFlags[i] = (info.svid << SVID_SHIFT_WIDTH) |
    486             (static_cast<uint32_t>(info.constellation) << CONSTELLATION_TYPE_SHIFT_WIDTH) |
    487             static_cast<uint32_t>(info.svFlag);
    488         cn0s[i] = info.cN0Dbhz;
    489         elev[i] = info.elevationDegrees;
    490         azim[i] = info.azimuthDegrees;
    491         carrierFreq[i] = info.carrierFrequencyHz;
    492     }
    493 
    494     env->ReleaseIntArrayElements(svidWithFlagArray, svidWithFlags, 0);
    495     env->ReleaseFloatArrayElements(cn0Array, cn0s, 0);
    496     env->ReleaseFloatArrayElements(elevArray, elev, 0);
    497     env->ReleaseFloatArrayElements(azimArray, azim, 0);
    498     env->ReleaseFloatArrayElements(carrierFreqArray, carrierFreq, 0);
    499 
    500     env->CallVoidMethod(mCallbacksObj, method_reportSvStatus,
    501             static_cast<jint>(listSize), svidWithFlagArray, cn0Array, elevArray, azimArray,
    502             carrierFreqArray);
    503 
    504     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    505     return Void();
    506 }
    507 
    508 Return<void> GnssCallback::gnssNmeaCb(
    509     int64_t timestamp, const ::android::hardware::hidl_string& nmea) {
    510     JNIEnv* env = getJniEnv();
    511     /*
    512      * The Java code will call back to read these values.
    513      * We do this to avoid creating unnecessary String objects.
    514      */
    515     sNmeaString = nmea.c_str();
    516     sNmeaStringLength = nmea.size();
    517 
    518     env->CallVoidMethod(mCallbacksObj, method_reportNmea, timestamp);
    519     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    520     return Void();
    521 }
    522 
    523 Return<void> GnssCallback::gnssSetCapabilitesCb(uint32_t capabilities) {
    524     ALOGD("%s: %du\n", __func__, capabilities);
    525 
    526     JNIEnv* env = getJniEnv();
    527     env->CallVoidMethod(mCallbacksObj, method_setEngineCapabilities, capabilities);
    528     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    529     return Void();
    530 }
    531 
    532 Return<void> GnssCallback::gnssAcquireWakelockCb() {
    533     acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME);
    534     return Void();
    535 }
    536 
    537 Return<void> GnssCallback::gnssReleaseWakelockCb() {
    538     release_wake_lock(WAKE_LOCK_NAME);
    539     return Void();
    540 }
    541 
    542 Return<void> GnssCallback::gnssRequestTimeCb() {
    543     JNIEnv* env = getJniEnv();
    544     env->CallVoidMethod(mCallbacksObj, method_requestUtcTime);
    545     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    546     return Void();
    547 }
    548 
    549 Return<void> GnssCallback::gnssRequestLocationCb(const bool independentFromGnss) {
    550     JNIEnv* env = getJniEnv();
    551     env->CallVoidMethod(mCallbacksObj, method_requestLocation, boolToJbool(independentFromGnss));
    552     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    553     return Void();
    554 }
    555 
    556 Return<void> GnssCallback::gnssSetSystemInfoCb(const IGnssCallback::GnssSystemInfo& info) {
    557     ALOGD("%s: yearOfHw=%d\n", __func__, info.yearOfHw);
    558 
    559     JNIEnv* env = getJniEnv();
    560     env->CallVoidMethod(mCallbacksObj, method_setGnssYearOfHardware,
    561                         info.yearOfHw);
    562     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    563     return Void();
    564 }
    565 
    566 class GnssXtraCallback : public IGnssXtraCallback {
    567     Return<void> downloadRequestCb() override;
    568 };
    569 
    570 /*
    571  * GnssXtraCallback class implements the callback methods for the IGnssXtra
    572  * interface.
    573  */
    574 Return<void> GnssXtraCallback::downloadRequestCb() {
    575     JNIEnv* env = getJniEnv();
    576     env->CallVoidMethod(mCallbacksObj, method_xtraDownloadRequest);
    577     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    578     return Void();
    579 }
    580 
    581 /*
    582  * GnssGeofenceCallback class implements the callback methods for the
    583  * IGnssGeofence interface.
    584  */
    585 struct GnssGeofenceCallback : public IGnssGeofenceCallback {
    586     // Methods from ::android::hardware::gps::V1_0::IGnssGeofenceCallback follow.
    587     Return<void> gnssGeofenceTransitionCb(
    588             int32_t geofenceId,
    589             const GnssLocation& location,
    590             GeofenceTransition transition,
    591             hardware::gnss::V1_0::GnssUtcTime timestamp) override;
    592     Return<void> gnssGeofenceStatusCb(
    593             GeofenceAvailability status,
    594             const GnssLocation& location) override;
    595     Return<void> gnssGeofenceAddCb(int32_t geofenceId,
    596                                    GeofenceStatus status) override;
    597     Return<void> gnssGeofenceRemoveCb(int32_t geofenceId,
    598                                       GeofenceStatus status) override;
    599     Return<void> gnssGeofencePauseCb(int32_t geofenceId,
    600                                      GeofenceStatus status) override;
    601     Return<void> gnssGeofenceResumeCb(int32_t geofenceId,
    602                                       GeofenceStatus status) override;
    603 };
    604 
    605 Return<void> GnssGeofenceCallback::gnssGeofenceTransitionCb(
    606         int32_t geofenceId,
    607         const GnssLocation& location,
    608         GeofenceTransition transition,
    609         hardware::gnss::V1_0::GnssUtcTime timestamp) {
    610     JNIEnv* env = getJniEnv();
    611 
    612     jobject jLocation = translateLocation(env, location);
    613 
    614     env->CallVoidMethod(mCallbacksObj,
    615                         method_reportGeofenceTransition,
    616                         geofenceId,
    617                         jLocation,
    618                         transition,
    619                         timestamp);
    620 
    621     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    622     env->DeleteLocalRef(jLocation);
    623     return Void();
    624 }
    625 
    626 Return<void> GnssGeofenceCallback::gnssGeofenceStatusCb(
    627         GeofenceAvailability status,
    628         const GnssLocation& location) {
    629     JNIEnv* env = getJniEnv();
    630 
    631     jobject jLocation = translateLocation(env, location);
    632 
    633     env->CallVoidMethod(mCallbacksObj,
    634                         method_reportGeofenceStatus,
    635                         status,
    636                         jLocation);
    637     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    638     env->DeleteLocalRef(jLocation);
    639     return Void();
    640 }
    641 
    642 Return<void> GnssGeofenceCallback::gnssGeofenceAddCb(int32_t geofenceId,
    643                                                     GeofenceStatus status) {
    644     JNIEnv* env = getJniEnv();
    645     if (status != IGnssGeofenceCallback::GeofenceStatus::OPERATION_SUCCESS) {
    646         ALOGE("%s: Error in adding a Geofence: %d\n", __func__, status);
    647     }
    648 
    649     env->CallVoidMethod(mCallbacksObj,
    650                         method_reportGeofenceAddStatus,
    651                         geofenceId,
    652                         status);
    653     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    654     return Void();
    655 }
    656 
    657 Return<void> GnssGeofenceCallback::gnssGeofenceRemoveCb(int32_t geofenceId,
    658                                                        GeofenceStatus status) {
    659     JNIEnv* env = getJniEnv();
    660     if (status != IGnssGeofenceCallback::GeofenceStatus::OPERATION_SUCCESS) {
    661         ALOGE("%s: Error in removing a Geofence: %d\n", __func__, status);
    662     }
    663 
    664     env->CallVoidMethod(mCallbacksObj,
    665                         method_reportGeofenceRemoveStatus,
    666                         geofenceId, status);
    667     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    668     return Void();
    669 }
    670 
    671 Return<void> GnssGeofenceCallback::gnssGeofencePauseCb(int32_t geofenceId,
    672                                                       GeofenceStatus status) {
    673     JNIEnv* env = getJniEnv();
    674     if (status != IGnssGeofenceCallback::GeofenceStatus::OPERATION_SUCCESS) {
    675         ALOGE("%s: Error in pausing Geofence: %d\n", __func__, status);
    676     }
    677 
    678     env->CallVoidMethod(mCallbacksObj,
    679                         method_reportGeofencePauseStatus,
    680                         geofenceId, status);
    681     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    682     return Void();
    683 }
    684 
    685 Return<void> GnssGeofenceCallback::gnssGeofenceResumeCb(int32_t geofenceId,
    686                                                        GeofenceStatus status) {
    687     JNIEnv* env = getJniEnv();
    688     if (status != IGnssGeofenceCallback::GeofenceStatus::OPERATION_SUCCESS) {
    689         ALOGE("%s: Error in resuming Geofence: %d\n", __func__, status);
    690     }
    691 
    692     env->CallVoidMethod(mCallbacksObj,
    693                         method_reportGeofenceResumeStatus,
    694                         geofenceId, status);
    695     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    696     return Void();
    697 }
    698 
    699 /*
    700  * GnssNavigationMessageCallback interface implements the callback methods
    701  * required by the IGnssNavigationMessage interface.
    702  */
    703 struct GnssNavigationMessageCallback : public IGnssNavigationMessageCallback {
    704   /*
    705    * Methods from ::android::hardware::gps::V1_0::IGnssNavigationMessageCallback
    706    * follow.
    707    */
    708   Return<void> gnssNavigationMessageCb(
    709           const IGnssNavigationMessageCallback::GnssNavigationMessage& message) override;
    710 };
    711 
    712 Return<void> GnssNavigationMessageCallback::gnssNavigationMessageCb(
    713         const IGnssNavigationMessageCallback::GnssNavigationMessage& message) {
    714     JNIEnv* env = getJniEnv();
    715 
    716     size_t dataLength = message.data.size();
    717 
    718     std::vector<uint8_t> navigationData = message.data;
    719     uint8_t* data = &(navigationData[0]);
    720     if (dataLength == 0 || data == NULL) {
    721       ALOGE("Invalid Navigation Message found: data=%p, length=%zd", data,
    722             dataLength);
    723       return Void();
    724     }
    725 
    726     JavaObject object(env, "android/location/GnssNavigationMessage");
    727     SET(Type, static_cast<int32_t>(message.type));
    728     SET(Svid, static_cast<int32_t>(message.svid));
    729     SET(MessageId, static_cast<int32_t>(message.messageId));
    730     SET(SubmessageId, static_cast<int32_t>(message.submessageId));
    731     object.callSetter("setData", data, dataLength);
    732     SET(Status, static_cast<int32_t>(message.status));
    733 
    734     jobject navigationMessage = object.get();
    735     env->CallVoidMethod(mCallbacksObj,
    736                         method_reportNavigationMessages,
    737                         navigationMessage);
    738     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    739     env->DeleteLocalRef(navigationMessage);
    740     return Void();
    741 }
    742 
    743 /*
    744  * GnssMeasurementCallback implements the callback methods required for the
    745  * GnssMeasurement interface.
    746  */
    747 struct GnssMeasurementCallback : public IGnssMeasurementCallback_V1_1 {
    748     Return<void> gnssMeasurementCb(const IGnssMeasurementCallback_V1_1::GnssData& data) override;
    749     Return<void> GnssMeasurementCb(const IGnssMeasurementCallback_V1_0::GnssData& data) override;
    750  private:
    751     void translateGnssMeasurement_V1_0(
    752             JNIEnv* env, const IGnssMeasurementCallback_V1_0::GnssMeasurement* measurement,
    753             JavaObject& object);
    754     jobjectArray translateGnssMeasurements(
    755             JNIEnv* env,
    756             const IGnssMeasurementCallback_V1_1::GnssMeasurement* measurements_v1_1,
    757             const IGnssMeasurementCallback_V1_0::GnssMeasurement* measurements_v1_0,
    758             size_t count);
    759     jobject translateGnssClock(
    760             JNIEnv* env, const IGnssMeasurementCallback_V1_0::GnssClock* clock);
    761     void setMeasurementData(JNIEnv* env, jobject clock, jobjectArray measurementArray);
    762 };
    763 
    764 
    765 Return<void> GnssMeasurementCallback::gnssMeasurementCb(
    766         const IGnssMeasurementCallback_V1_1::GnssData& data) {
    767     JNIEnv* env = getJniEnv();
    768 
    769     jobject clock;
    770     jobjectArray measurementArray;
    771 
    772     clock = translateGnssClock(env, &data.clock);
    773 
    774     measurementArray = translateGnssMeasurements(
    775         env, data.measurements.data(), NULL, data.measurements.size());
    776     setMeasurementData(env, clock, measurementArray);
    777 
    778     env->DeleteLocalRef(clock);
    779     env->DeleteLocalRef(measurementArray);
    780     return Void();
    781 }
    782 
    783 Return<void> GnssMeasurementCallback::GnssMeasurementCb(
    784         const IGnssMeasurementCallback_V1_0::GnssData& data) {
    785     JNIEnv* env = getJniEnv();
    786 
    787     jobject clock;
    788     jobjectArray measurementArray;
    789 
    790     clock = translateGnssClock(env, &data.clock);
    791     measurementArray = translateGnssMeasurements(
    792         env, NULL, data.measurements.data(), data.measurementCount);
    793     setMeasurementData(env, clock, measurementArray);
    794 
    795     env->DeleteLocalRef(clock);
    796     env->DeleteLocalRef(measurementArray);
    797     return Void();
    798 }
    799 
    800 // preallocate object as: JavaObject object(env, "android/location/GnssMeasurement");
    801 void GnssMeasurementCallback::translateGnssMeasurement_V1_0(
    802         JNIEnv* env, const IGnssMeasurementCallback_V1_0::GnssMeasurement* measurement,
    803         JavaObject& object) {
    804     uint32_t flags = static_cast<uint32_t>(measurement->flags);
    805 
    806     SET(Svid, static_cast<int32_t>(measurement->svid));
    807     SET(ConstellationType, static_cast<int32_t>(measurement->constellation));
    808     SET(TimeOffsetNanos, measurement->timeOffsetNs);
    809     SET(State, static_cast<int32_t>(measurement->state));
    810     SET(ReceivedSvTimeNanos, measurement->receivedSvTimeInNs);
    811     SET(ReceivedSvTimeUncertaintyNanos,
    812         measurement->receivedSvTimeUncertaintyInNs);
    813     SET(Cn0DbHz, measurement->cN0DbHz);
    814     SET(PseudorangeRateMetersPerSecond, measurement->pseudorangeRateMps);
    815     SET(PseudorangeRateUncertaintyMetersPerSecond,
    816         measurement->pseudorangeRateUncertaintyMps);
    817     SET(AccumulatedDeltaRangeState,
    818         (static_cast<int32_t>(measurement->accumulatedDeltaRangeState) &
    819         !ADR_STATE_HALF_CYCLE_REPORTED)); // Half Cycle state not reported from Hardware in V1_0
    820     SET(AccumulatedDeltaRangeMeters, measurement->accumulatedDeltaRangeM);
    821     SET(AccumulatedDeltaRangeUncertaintyMeters,
    822         measurement->accumulatedDeltaRangeUncertaintyM);
    823 
    824     if (flags & static_cast<uint32_t>(GnssMeasurementFlags::HAS_CARRIER_FREQUENCY)) {
    825         SET(CarrierFrequencyHz, measurement->carrierFrequencyHz);
    826     }
    827 
    828     // Intentionally not copying deprecated fields of carrierCycles,
    829     // carrierPhase, carrierPhaseUncertainty
    830 
    831     SET(MultipathIndicator, static_cast<int32_t>(measurement->multipathIndicator));
    832 
    833     if (flags & static_cast<uint32_t>(GnssMeasurementFlags::HAS_SNR)) {
    834         SET(SnrInDb, measurement->snrDb);
    835     }
    836 
    837     if (flags & static_cast<uint32_t>(GnssMeasurementFlags::HAS_AUTOMATIC_GAIN_CONTROL)) {
    838         SET(AutomaticGainControlLevelInDb, measurement->agcLevelDb);
    839     }
    840 }
    841 
    842 jobject GnssMeasurementCallback::translateGnssClock(
    843        JNIEnv* env, const IGnssMeasurementCallback_V1_0::GnssClock* clock) {
    844     JavaObject object(env, "android/location/GnssClock");
    845 
    846     uint32_t flags = static_cast<uint32_t>(clock->gnssClockFlags);
    847     if (flags & static_cast<uint32_t>(GnssClockFlags::HAS_LEAP_SECOND)) {
    848         SET(LeapSecond, static_cast<int32_t>(clock->leapSecond));
    849     }
    850 
    851     if (flags & static_cast<uint32_t>(GnssClockFlags::HAS_TIME_UNCERTAINTY)) {
    852         SET(TimeUncertaintyNanos, clock->timeUncertaintyNs);
    853     }
    854 
    855     if (flags & static_cast<uint32_t>(GnssClockFlags::HAS_FULL_BIAS)) {
    856         SET(FullBiasNanos, clock->fullBiasNs);
    857     }
    858 
    859     if (flags & static_cast<uint32_t>(GnssClockFlags::HAS_BIAS)) {
    860         SET(BiasNanos, clock->biasNs);
    861     }
    862 
    863     if (flags & static_cast<uint32_t>(GnssClockFlags::HAS_BIAS_UNCERTAINTY)) {
    864         SET(BiasUncertaintyNanos, clock->biasUncertaintyNs);
    865     }
    866 
    867     if (flags & static_cast<uint32_t>(GnssClockFlags::HAS_DRIFT)) {
    868         SET(DriftNanosPerSecond, clock->driftNsps);
    869     }
    870 
    871     if (flags & static_cast<uint32_t>(GnssClockFlags::HAS_DRIFT_UNCERTAINTY)) {
    872         SET(DriftUncertaintyNanosPerSecond, clock->driftUncertaintyNsps);
    873     }
    874 
    875     SET(TimeNanos, clock->timeNs);
    876     SET(HardwareClockDiscontinuityCount, clock->hwClockDiscontinuityCount);
    877 
    878     return object.get();
    879 }
    880 
    881 jobjectArray GnssMeasurementCallback::translateGnssMeasurements(JNIEnv* env,
    882          const IGnssMeasurementCallback_V1_1::GnssMeasurement* measurements_v1_1,
    883          const IGnssMeasurementCallback_V1_0::GnssMeasurement* measurements_v1_0,
    884          size_t count) {
    885     if (count == 0) {
    886         return NULL;
    887     }
    888 
    889     jclass gnssMeasurementClass = env->FindClass("android/location/GnssMeasurement");
    890     jobjectArray gnssMeasurementArray = env->NewObjectArray(
    891             count,
    892             gnssMeasurementClass,
    893             NULL /* initialElement */);
    894 
    895     for (uint16_t i = 0; i < count; ++i) {
    896         JavaObject object(env, "android/location/GnssMeasurement");
    897         if (measurements_v1_1 != NULL) {
    898             translateGnssMeasurement_V1_0(env, &(measurements_v1_1[i].v1_0), object);
    899 
    900             // Set the V1_1 flag, and mark that new field has valid information for Java Layer
    901             SET(AccumulatedDeltaRangeState,
    902                     (static_cast<int32_t>(measurements_v1_1[i].accumulatedDeltaRangeState) |
    903                     ADR_STATE_HALF_CYCLE_REPORTED));
    904         } else {
    905             translateGnssMeasurement_V1_0(env, &(measurements_v1_0[i]), object);
    906         }
    907 
    908         env->SetObjectArrayElement(gnssMeasurementArray, i, object.get());
    909     }
    910 
    911     env->DeleteLocalRef(gnssMeasurementClass);
    912     return gnssMeasurementArray;
    913 }
    914 
    915 void GnssMeasurementCallback::setMeasurementData(JNIEnv* env, jobject clock,
    916                              jobjectArray measurementArray) {
    917     jclass gnssMeasurementsEventClass =
    918             env->FindClass("android/location/GnssMeasurementsEvent");
    919     jmethodID gnssMeasurementsEventCtor =
    920             env->GetMethodID(
    921                     gnssMeasurementsEventClass,
    922                     "<init>",
    923                     "(Landroid/location/GnssClock;[Landroid/location/GnssMeasurement;)V");
    924 
    925     jobject gnssMeasurementsEvent = env->NewObject(gnssMeasurementsEventClass,
    926                                                    gnssMeasurementsEventCtor,
    927                                                    clock,
    928                                                    measurementArray);
    929 
    930     env->CallVoidMethod(mCallbacksObj, method_reportMeasurementData,
    931                       gnssMeasurementsEvent);
    932     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    933     env->DeleteLocalRef(gnssMeasurementsEventClass);
    934     env->DeleteLocalRef(gnssMeasurementsEvent);
    935 }
    936 
    937 /*
    938  * GnssNiCallback implements callback methods required by the IGnssNi interface.
    939  */
    940 struct GnssNiCallback : public IGnssNiCallback {
    941     Return<void> niNotifyCb(const IGnssNiCallback::GnssNiNotification& notification)
    942             override;
    943 };
    944 
    945 Return<void> GnssNiCallback::niNotifyCb(
    946         const IGnssNiCallback::GnssNiNotification& notification) {
    947     JNIEnv* env = getJniEnv();
    948     jstring requestorId = env->NewStringUTF(notification.requestorId.c_str());
    949     jstring text = env->NewStringUTF(notification.notificationMessage.c_str());
    950 
    951     if (requestorId && text) {
    952         env->CallVoidMethod(mCallbacksObj, method_reportNiNotification,
    953                             notification.notificationId, notification.niType,
    954                             notification.notifyFlags, notification.timeoutSec,
    955                             notification.defaultResponse, requestorId, text,
    956                             notification.requestorIdEncoding,
    957                             notification.notificationIdEncoding);
    958     } else {
    959         ALOGE("%s: OOM Error\n", __func__);
    960     }
    961 
    962     if (requestorId) {
    963         env->DeleteLocalRef(requestorId);
    964     }
    965 
    966     if (text) {
    967         env->DeleteLocalRef(text);
    968     }
    969     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    970     return Void();
    971 }
    972 
    973 /*
    974  * AGnssCallback implements callback methods required by the IAGnss interface.
    975  */
    976 struct AGnssCallback : public IAGnssCallback {
    977     // Methods from ::android::hardware::gps::V1_0::IAGnssCallback follow.
    978     Return<void> agnssStatusIpV6Cb(
    979       const IAGnssCallback::AGnssStatusIpV6& agps_status) override;
    980 
    981     Return<void> agnssStatusIpV4Cb(
    982       const IAGnssCallback::AGnssStatusIpV4& agps_status) override;
    983  private:
    984     jbyteArray convertToIpV4(uint32_t ip);
    985 };
    986 
    987 Return<void> AGnssCallback::agnssStatusIpV6Cb(
    988         const IAGnssCallback::AGnssStatusIpV6& agps_status) {
    989     JNIEnv* env = getJniEnv();
    990     jbyteArray byteArray = NULL;
    991     bool isSupported = false;
    992 
    993     byteArray = env->NewByteArray(16);
    994     if (byteArray != NULL) {
    995         env->SetByteArrayRegion(byteArray, 0, 16,
    996                                 (const jbyte*)(agps_status.ipV6Addr.data()));
    997         isSupported = true;
    998     } else {
    999         ALOGE("Unable to allocate byte array for IPv6 address.");
   1000     }
   1001 
   1002     IF_ALOGD() {
   1003         // log the IP for reference in case there is a bogus value pushed by HAL
   1004         char str[INET6_ADDRSTRLEN];
   1005         inet_ntop(AF_INET6, agps_status.ipV6Addr.data(), str, INET6_ADDRSTRLEN);
   1006         ALOGD("AGPS IP is v6: %s", str);
   1007     }
   1008 
   1009     jsize byteArrayLength = byteArray != NULL ? env->GetArrayLength(byteArray) : 0;
   1010     ALOGV("Passing AGPS IP addr: size %d", byteArrayLength);
   1011     env->CallVoidMethod(mCallbacksObj, method_reportAGpsStatus,
   1012                         agps_status.type, agps_status.status, byteArray);
   1013 
   1014     checkAndClearExceptionFromCallback(env, __FUNCTION__);
   1015 
   1016     if (byteArray) {
   1017         env->DeleteLocalRef(byteArray);
   1018     }
   1019 
   1020     return Void();
   1021 }
   1022 
   1023 Return<void> AGnssCallback::agnssStatusIpV4Cb(
   1024         const IAGnssCallback::AGnssStatusIpV4& agps_status) {
   1025     JNIEnv* env = getJniEnv();
   1026     jbyteArray byteArray = NULL;
   1027 
   1028     uint32_t ipAddr = agps_status.ipV4Addr;
   1029     byteArray = convertToIpV4(ipAddr);
   1030 
   1031     IF_ALOGD() {
   1032         /*
   1033          * log the IP for reference in case there is a bogus value pushed by
   1034          * HAL.
   1035          */
   1036         char str[INET_ADDRSTRLEN];
   1037         inet_ntop(AF_INET, &ipAddr, str, INET_ADDRSTRLEN);
   1038         ALOGD("AGPS IP is v4: %s", str);
   1039     }
   1040 
   1041     jsize byteArrayLength =
   1042       byteArray != NULL ? env->GetArrayLength(byteArray) : 0;
   1043     ALOGV("Passing AGPS IP addr: size %d", byteArrayLength);
   1044     env->CallVoidMethod(mCallbacksObj, method_reportAGpsStatus,
   1045                       agps_status.type, agps_status.status, byteArray);
   1046 
   1047     checkAndClearExceptionFromCallback(env, __FUNCTION__);
   1048 
   1049     if (byteArray) {
   1050         env->DeleteLocalRef(byteArray);
   1051     }
   1052     return Void();
   1053 }
   1054 
   1055 jbyteArray AGnssCallback::convertToIpV4(uint32_t ip) {
   1056     if (INADDR_NONE == ip) {
   1057         return NULL;
   1058     }
   1059 
   1060     JNIEnv* env = getJniEnv();
   1061     jbyteArray byteArray = env->NewByteArray(4);
   1062     if (byteArray == NULL) {
   1063         ALOGE("Unable to allocate byte array for IPv4 address");
   1064         return NULL;
   1065     }
   1066 
   1067     jbyte ipv4[4];
   1068     ALOGV("Converting IPv4 address byte array (net_order) %x", ip);
   1069     memcpy(ipv4, &ip, sizeof(ipv4));
   1070     env->SetByteArrayRegion(byteArray, 0, 4, (const jbyte*)ipv4);
   1071     return byteArray;
   1072 }
   1073 
   1074 /*
   1075  * AGnssRilCallback implements the callback methods required by the AGnssRil
   1076  * interface.
   1077  */
   1078 struct AGnssRilCallback : IAGnssRilCallback {
   1079     Return<void> requestSetIdCb(uint32_t setIdFlag) override;
   1080     Return<void> requestRefLocCb() override;
   1081 };
   1082 
   1083 Return<void> AGnssRilCallback::requestSetIdCb(uint32_t setIdFlag) {
   1084     JNIEnv* env = getJniEnv();
   1085     env->CallVoidMethod(mCallbacksObj, method_requestSetID, setIdFlag);
   1086     checkAndClearExceptionFromCallback(env, __FUNCTION__);
   1087     return Void();
   1088 }
   1089 
   1090 Return<void> AGnssRilCallback::requestRefLocCb() {
   1091     JNIEnv* env = getJniEnv();
   1092     env->CallVoidMethod(mCallbacksObj, method_requestRefLocation);
   1093     checkAndClearExceptionFromCallback(env, __FUNCTION__);
   1094     return Void();
   1095 }
   1096 
   1097 /*
   1098  * GnssBatchingCallback interface implements the callback methods
   1099  * required by the IGnssBatching interface.
   1100  */
   1101 struct GnssBatchingCallback : public IGnssBatchingCallback {
   1102     /*
   1103     * Methods from ::android::hardware::gps::V1_0::IGnssBatchingCallback
   1104     * follow.
   1105     */
   1106     Return<void> gnssLocationBatchCb(const hidl_vec<GnssLocation> & locations)
   1107         override;
   1108 };
   1109 
   1110 Return<void> GnssBatchingCallback::gnssLocationBatchCb(const hidl_vec<GnssLocation> & locations) {
   1111     JNIEnv* env = getJniEnv();
   1112 
   1113     jobjectArray jLocations = env->NewObjectArray(locations.size(),
   1114             env->FindClass("android/location/Location"), nullptr);
   1115 
   1116     for (uint16_t i = 0; i < locations.size(); ++i) {
   1117         jobject jLocation = translateLocation(env, locations[i]);
   1118         env->SetObjectArrayElement(jLocations, i, jLocation);
   1119         env->DeleteLocalRef(jLocation);
   1120     }
   1121 
   1122     env->CallVoidMethod(mCallbacksObj, method_reportLocationBatch, jLocations);
   1123     checkAndClearExceptionFromCallback(env, __FUNCTION__);
   1124 
   1125     env->DeleteLocalRef(jLocations);
   1126 
   1127     return Void();
   1128 }
   1129 
   1130 static void android_location_GnssLocationProvider_class_init_native(JNIEnv* env, jclass clazz) {
   1131     gnssHal_V1_1 = IGnss_V1_1::getService();
   1132     if (gnssHal_V1_1 == nullptr) {
   1133         ALOGD("gnssHal 1.1 was null, trying 1.0");
   1134         gnssHal = IGnss_V1_0::getService();
   1135     } else {
   1136         gnssHal = gnssHal_V1_1;
   1137     }
   1138 }
   1139 
   1140 static void android_location_GnssLocationProvider_init_once(JNIEnv* env, jclass clazz) {
   1141     method_reportLocation = env->GetMethodID(clazz, "reportLocation",
   1142             "(ZLandroid/location/Location;)V");
   1143     method_reportStatus = env->GetMethodID(clazz, "reportStatus", "(I)V");
   1144     method_reportSvStatus = env->GetMethodID(clazz, "reportSvStatus", "(I[I[F[F[F[F)V");
   1145     method_reportAGpsStatus = env->GetMethodID(clazz, "reportAGpsStatus", "(II[B)V");
   1146     method_reportNmea = env->GetMethodID(clazz, "reportNmea", "(J)V");
   1147     method_setEngineCapabilities = env->GetMethodID(clazz, "setEngineCapabilities", "(I)V");
   1148     method_setGnssYearOfHardware = env->GetMethodID(clazz, "setGnssYearOfHardware", "(I)V");
   1149     method_setGnssHardwareModelName = env->GetMethodID(clazz, "setGnssHardwareModelName",
   1150             "(Ljava/lang/String;)V");
   1151     method_xtraDownloadRequest = env->GetMethodID(clazz, "xtraDownloadRequest", "()V");
   1152     method_reportNiNotification = env->GetMethodID(clazz, "reportNiNotification",
   1153             "(IIIIILjava/lang/String;Ljava/lang/String;II)V");
   1154     method_requestLocation = env->GetMethodID(clazz, "requestLocation", "(Z)V");
   1155     method_requestRefLocation = env->GetMethodID(clazz, "requestRefLocation", "()V");
   1156     method_requestSetID = env->GetMethodID(clazz, "requestSetID", "(I)V");
   1157     method_requestUtcTime = env->GetMethodID(clazz, "requestUtcTime", "()V");
   1158     method_reportGeofenceTransition = env->GetMethodID(clazz, "reportGeofenceTransition",
   1159             "(ILandroid/location/Location;IJ)V");
   1160     method_reportGeofenceStatus = env->GetMethodID(clazz, "reportGeofenceStatus",
   1161             "(ILandroid/location/Location;)V");
   1162     method_reportGeofenceAddStatus = env->GetMethodID(clazz, "reportGeofenceAddStatus",
   1163             "(II)V");
   1164     method_reportGeofenceRemoveStatus = env->GetMethodID(clazz, "reportGeofenceRemoveStatus",
   1165             "(II)V");
   1166     method_reportGeofenceResumeStatus = env->GetMethodID(clazz, "reportGeofenceResumeStatus",
   1167             "(II)V");
   1168     method_reportGeofencePauseStatus = env->GetMethodID(clazz, "reportGeofencePauseStatus",
   1169             "(II)V");
   1170     method_reportMeasurementData = env->GetMethodID(
   1171             clazz,
   1172             "reportMeasurementData",
   1173             "(Landroid/location/GnssMeasurementsEvent;)V");
   1174     method_reportNavigationMessages = env->GetMethodID(
   1175             clazz,
   1176             "reportNavigationMessage",
   1177             "(Landroid/location/GnssNavigationMessage;)V");
   1178     method_reportLocationBatch = env->GetMethodID(
   1179             clazz,
   1180             "reportLocationBatch",
   1181             "([Landroid/location/Location;)V");
   1182     method_reportGnssServiceDied = env->GetMethodID(clazz, "reportGnssServiceDied", "()V");
   1183 
   1184     /*
   1185      * Save a pointer to JVM.
   1186      */
   1187     jint jvmStatus = env->GetJavaVM(&sJvm);
   1188     if (jvmStatus != JNI_OK) {
   1189         LOG_ALWAYS_FATAL("Unable to get Java VM. Error: %d", jvmStatus);
   1190     }
   1191 
   1192     if (gnssHal != nullptr) {
   1193       gnssHalDeathRecipient = new GnssDeathRecipient();
   1194       hardware::Return<bool> linked = gnssHal->linkToDeath(
   1195           gnssHalDeathRecipient, /*cookie*/ 0);
   1196         if (!linked.isOk()) {
   1197             ALOGE("Transaction error in linking to GnssHAL death: %s",
   1198                     linked.description().c_str());
   1199         } else if (!linked) {
   1200             ALOGW("Unable to link to GnssHal death notifications");
   1201         } else {
   1202             ALOGD("Link to death notification successful");
   1203         }
   1204 
   1205         auto gnssXtra = gnssHal->getExtensionXtra();
   1206         if (!gnssXtra.isOk()) {
   1207             ALOGD("Unable to get a handle to Xtra");
   1208         } else {
   1209             gnssXtraIface = gnssXtra;
   1210         }
   1211 
   1212         auto gnssRil = gnssHal->getExtensionAGnssRil();
   1213         if (!gnssRil.isOk()) {
   1214             ALOGD("Unable to get a handle to AGnssRil");
   1215         } else {
   1216             agnssRilIface = gnssRil;
   1217         }
   1218 
   1219         auto gnssAgnss = gnssHal->getExtensionAGnss();
   1220         if (!gnssAgnss.isOk()) {
   1221             ALOGD("Unable to get a handle to AGnss");
   1222         } else {
   1223             agnssIface = gnssAgnss;
   1224         }
   1225 
   1226         auto gnssNavigationMessage = gnssHal->getExtensionGnssNavigationMessage();
   1227         if (!gnssNavigationMessage.isOk()) {
   1228             ALOGD("Unable to get a handle to GnssNavigationMessage");
   1229         } else {
   1230             gnssNavigationMessageIface = gnssNavigationMessage;
   1231         }
   1232 
   1233         if (gnssHal_V1_1 != nullptr) {
   1234              auto gnssMeasurement = gnssHal_V1_1->getExtensionGnssMeasurement_1_1();
   1235              if (!gnssMeasurement.isOk()) {
   1236                  ALOGD("Unable to get a handle to GnssMeasurement");
   1237              } else {
   1238                  gnssMeasurementIface_V1_1 = gnssMeasurement;
   1239                  gnssMeasurementIface = gnssMeasurementIface_V1_1;
   1240              }
   1241         } else {
   1242              auto gnssMeasurement_V1_0 = gnssHal->getExtensionGnssMeasurement();
   1243              if (!gnssMeasurement_V1_0.isOk()) {
   1244                  ALOGD("Unable to get a handle to GnssMeasurement");
   1245              } else {
   1246                  gnssMeasurementIface = gnssMeasurement_V1_0;
   1247              }
   1248         }
   1249 
   1250         auto gnssDebug = gnssHal->getExtensionGnssDebug();
   1251         if (!gnssDebug.isOk()) {
   1252             ALOGD("Unable to get a handle to GnssDebug");
   1253         } else {
   1254             gnssDebugIface = gnssDebug;
   1255         }
   1256 
   1257         auto gnssNi = gnssHal->getExtensionGnssNi();
   1258         if (!gnssNi.isOk()) {
   1259             ALOGD("Unable to get a handle to GnssNi");
   1260         } else {
   1261             gnssNiIface = gnssNi;
   1262         }
   1263 
   1264         if (gnssHal_V1_1 != nullptr) {
   1265             auto gnssConfiguration = gnssHal_V1_1->getExtensionGnssConfiguration_1_1();
   1266             if (!gnssConfiguration.isOk()) {
   1267                 ALOGD("Unable to get a handle to GnssConfiguration");
   1268             } else {
   1269                 gnssConfigurationIface_V1_1 = gnssConfiguration;
   1270                 gnssConfigurationIface = gnssConfigurationIface_V1_1;
   1271             }
   1272         } else {
   1273             auto gnssConfiguration_V1_0 = gnssHal->getExtensionGnssConfiguration();
   1274             if (!gnssConfiguration_V1_0.isOk()) {
   1275                 ALOGD("Unable to get a handle to GnssConfiguration");
   1276             } else {
   1277                 gnssConfigurationIface = gnssConfiguration_V1_0;
   1278             }
   1279         }
   1280 
   1281         auto gnssGeofencing = gnssHal->getExtensionGnssGeofencing();
   1282         if (!gnssGeofencing.isOk()) {
   1283             ALOGD("Unable to get a handle to GnssGeofencing");
   1284         } else {
   1285             gnssGeofencingIface = gnssGeofencing;
   1286         }
   1287 
   1288         auto gnssBatching = gnssHal->getExtensionGnssBatching();
   1289         if (!gnssBatching.isOk()) {
   1290             ALOGD("Unable to get a handle to gnssBatching");
   1291         } else {
   1292             gnssBatchingIface = gnssBatching;
   1293         }
   1294     } else {
   1295       ALOGE("Unable to get GPS service\n");
   1296     }
   1297 }
   1298 
   1299 static jboolean android_location_GnssLocationProvider_is_supported(
   1300         JNIEnv* /* env */, jclass /* clazz */) {
   1301     return (gnssHal != nullptr) ?  JNI_TRUE : JNI_FALSE;
   1302 }
   1303 
   1304 static jboolean android_location_GnssLocationProvider_is_agps_ril_supported(
   1305         JNIEnv* /* env */, jclass /* clazz */) {
   1306     return (agnssRilIface != nullptr) ? JNI_TRUE : JNI_FALSE;
   1307 }
   1308 
   1309 static jboolean android_location_gpsLocationProvider_is_gnss_configuration_supported(
   1310         JNIEnv* /* env */, jclass /* jclazz */) {
   1311     return (gnssConfigurationIface != nullptr) ? JNI_TRUE : JNI_FALSE;
   1312 }
   1313 
   1314 static jboolean android_location_GnssLocationProvider_init(JNIEnv* env, jobject obj) {
   1315     /*
   1316      * This must be set before calling into the HAL library.
   1317      */
   1318     if (!mCallbacksObj)
   1319         mCallbacksObj = env->NewGlobalRef(obj);
   1320 
   1321     /*
   1322      * Fail if the main interface fails to initialize
   1323      */
   1324     if (gnssHal == nullptr) {
   1325         ALOGE("Unable to Initialize GNSS HAL\n");
   1326         return JNI_FALSE;
   1327     }
   1328 
   1329     sp<IGnssCallback> gnssCbIface = new GnssCallback();
   1330 
   1331     Return<bool> result = false;
   1332     if (gnssHal_V1_1 != nullptr) {
   1333         result = gnssHal_V1_1->setCallback_1_1(gnssCbIface);
   1334     } else {
   1335         result = gnssHal->setCallback(gnssCbIface);
   1336     }
   1337     if (!result.isOk() || !result) {
   1338         ALOGE("SetCallback for Gnss Interface fails\n");
   1339         return JNI_FALSE;
   1340     }
   1341 
   1342     sp<IGnssXtraCallback> gnssXtraCbIface = new GnssXtraCallback();
   1343     if (gnssXtraIface == nullptr) {
   1344         ALOGE("Unable to initialize GNSS Xtra interface\n");
   1345     } else {
   1346         result = gnssXtraIface->setCallback(gnssXtraCbIface);
   1347         if (!result.isOk() || !result) {
   1348             gnssXtraIface = nullptr;
   1349             ALOGI("SetCallback for Gnss Xtra Interface fails\n");
   1350         }
   1351     }
   1352 
   1353     sp<IAGnssCallback> aGnssCbIface = new AGnssCallback();
   1354     if (agnssIface != nullptr) {
   1355         agnssIface->setCallback(aGnssCbIface);
   1356     } else {
   1357         ALOGI("Unable to Initialize AGnss interface\n");
   1358     }
   1359 
   1360     sp<IGnssGeofenceCallback> gnssGeofencingCbIface = new GnssGeofenceCallback();
   1361     if (gnssGeofencingIface != nullptr) {
   1362       gnssGeofencingIface->setCallback(gnssGeofencingCbIface);
   1363     } else {
   1364         ALOGI("Unable to initialize GNSS Geofencing interface\n");
   1365     }
   1366 
   1367     sp<IGnssNiCallback> gnssNiCbIface = new GnssNiCallback();
   1368     if (gnssNiIface != nullptr) {
   1369         gnssNiIface->setCallback(gnssNiCbIface);
   1370     } else {
   1371         ALOGI("Unable to initialize GNSS NI interface\n");
   1372     }
   1373 
   1374     sp<IAGnssRilCallback> aGnssRilCbIface = new AGnssRilCallback();
   1375     if (agnssRilIface != nullptr) {
   1376         agnssRilIface->setCallback(aGnssRilCbIface);
   1377     } else {
   1378         ALOGI("Unable to Initialize AGnss Ril interface\n");
   1379     }
   1380 
   1381     return JNI_TRUE;
   1382 }
   1383 
   1384 static void android_location_GnssLocationProvider_cleanup(JNIEnv* /* env */, jobject /* obj */) {
   1385     if (gnssHal != nullptr) {
   1386         gnssHal->cleanup();
   1387     }
   1388 }
   1389 
   1390 static jboolean android_location_GnssLocationProvider_set_position_mode(JNIEnv* /* env */,
   1391         jobject /* obj */, jint mode, jint recurrence, jint min_interval, jint preferred_accuracy,
   1392         jint preferred_time, jboolean low_power_mode) {
   1393     Return<bool> result = false;
   1394     if (gnssHal_V1_1 != nullptr) {
   1395          result = gnssHal_V1_1->setPositionMode_1_1(static_cast<IGnss_V1_0::GnssPositionMode>(mode),
   1396                  static_cast<IGnss_V1_0::GnssPositionRecurrence>(recurrence),
   1397                  min_interval,
   1398                  preferred_accuracy,
   1399                  preferred_time,
   1400                  low_power_mode);
   1401      } else if (gnssHal != nullptr) {
   1402          result = gnssHal->setPositionMode(static_cast<IGnss_V1_0::GnssPositionMode>(mode),
   1403                  static_cast<IGnss_V1_0::GnssPositionRecurrence>(recurrence),
   1404                  min_interval,
   1405                  preferred_accuracy,
   1406                  preferred_time);
   1407     }
   1408     if (!result.isOk()) {
   1409        ALOGE("%s: GNSS setPositionMode failed\n", __func__);
   1410        return JNI_FALSE;
   1411     } else {
   1412        return result;
   1413     }
   1414 }
   1415 
   1416 static jboolean android_location_GnssLocationProvider_start(JNIEnv* /* env */, jobject /* obj */) {
   1417     if (gnssHal != nullptr) {
   1418         auto result = gnssHal->start();
   1419         if (!result.isOk()) {
   1420             return JNI_FALSE;
   1421         } else {
   1422             return result;
   1423         }
   1424     } else {
   1425         return JNI_FALSE;
   1426     }
   1427 }
   1428 
   1429 static jboolean android_location_GnssLocationProvider_stop(JNIEnv* /* env */, jobject /* obj */) {
   1430     if (gnssHal != nullptr) {
   1431         auto result = gnssHal->stop();
   1432         if (!result.isOk()) {
   1433             return JNI_FALSE;
   1434         } else {
   1435             return result;
   1436         }
   1437     } else {
   1438         return JNI_FALSE;
   1439     }
   1440 }
   1441 static void android_location_GnssLocationProvider_delete_aiding_data(JNIEnv* /* env */,
   1442                                                                     jobject /* obj */,
   1443                                                                     jint flags) {
   1444     if (gnssHal != nullptr) {
   1445         auto result = gnssHal->deleteAidingData(static_cast<IGnss_V1_0::GnssAidingData>(flags));
   1446         if (!result.isOk()) {
   1447             ALOGE("Error in deleting aiding data");
   1448         }
   1449     }
   1450 }
   1451 
   1452 static void android_location_GnssLocationProvider_agps_set_reference_location_cellid(
   1453         JNIEnv* /* env */, jobject /* obj */, jint type, jint mcc, jint mnc, jint lac, jint cid) {
   1454     IAGnssRil::AGnssRefLocation location;
   1455 
   1456     if (agnssRilIface == nullptr) {
   1457         ALOGE("No AGPS RIL interface in agps_set_reference_location_cellid");
   1458         return;
   1459     }
   1460 
   1461     switch (static_cast<IAGnssRil::AGnssRefLocationType>(type)) {
   1462         case IAGnssRil::AGnssRefLocationType::GSM_CELLID:
   1463         case IAGnssRil::AGnssRefLocationType::UMTS_CELLID:
   1464           location.type = static_cast<IAGnssRil::AGnssRefLocationType>(type);
   1465           location.cellID.mcc = mcc;
   1466           location.cellID.mnc = mnc;
   1467           location.cellID.lac = lac;
   1468           location.cellID.cid = cid;
   1469           break;
   1470         default:
   1471             ALOGE("Neither a GSM nor a UMTS cellid (%s:%d).", __FUNCTION__, __LINE__);
   1472             return;
   1473             break;
   1474     }
   1475 
   1476     agnssRilIface->setRefLocation(location);
   1477 }
   1478 
   1479 static void android_location_GnssLocationProvider_agps_set_id(JNIEnv *env, jobject /* obj */,
   1480                                                              jint type, jstring  setid_string) {
   1481     if (agnssRilIface == nullptr) {
   1482         ALOGE("no AGPS RIL interface in agps_set_id");
   1483         return;
   1484     }
   1485 
   1486     const char *setid = env->GetStringUTFChars(setid_string, NULL);
   1487     agnssRilIface->setSetId((IAGnssRil::SetIDType)type, setid);
   1488     env->ReleaseStringUTFChars(setid_string, setid);
   1489 }
   1490 
   1491 static jint android_location_GnssLocationProvider_read_nmea(JNIEnv* env, jobject /* obj */,
   1492                                             jbyteArray nmeaArray, jint buffer_size) {
   1493     // this should only be called from within a call to reportNmea
   1494     jbyte* nmea = reinterpret_cast<jbyte *>(env->GetPrimitiveArrayCritical(nmeaArray, 0));
   1495     int length = GnssCallback::sNmeaStringLength;
   1496     if (length > buffer_size)
   1497         length = buffer_size;
   1498     memcpy(nmea, GnssCallback::sNmeaString, length);
   1499     env->ReleasePrimitiveArrayCritical(nmeaArray, nmea, JNI_ABORT);
   1500     return (jint) length;
   1501 }
   1502 
   1503 static void android_location_GnssLocationProvider_inject_time(JNIEnv* /* env */, jobject /* obj */,
   1504         jlong time, jlong timeReference, jint uncertainty) {
   1505     if (gnssHal != nullptr) {
   1506         auto result = gnssHal->injectTime(time, timeReference, uncertainty);
   1507         if (!result.isOk() || !result) {
   1508             ALOGE("%s: Gnss injectTime() failed", __func__);
   1509         }
   1510     }
   1511 }
   1512 
   1513 static void android_location_GnssLocationProvider_inject_best_location(
   1514         JNIEnv*,
   1515         jobject,
   1516         jint gnssLocationFlags,
   1517         jdouble latitudeDegrees,
   1518         jdouble longitudeDegrees,
   1519         jdouble altitudeMeters,
   1520         jfloat speedMetersPerSec,
   1521         jfloat bearingDegrees,
   1522         jfloat horizontalAccuracyMeters,
   1523         jfloat verticalAccuracyMeters,
   1524         jfloat speedAccuracyMetersPerSecond,
   1525         jfloat bearingAccuracyDegrees,
   1526         jlong timestamp) {
   1527     if (gnssHal_V1_1 != nullptr) {
   1528         GnssLocation location = createGnssLocation(
   1529                 gnssLocationFlags,
   1530                 latitudeDegrees,
   1531                 longitudeDegrees,
   1532                 altitudeMeters,
   1533                 speedMetersPerSec,
   1534                 bearingDegrees,
   1535                 horizontalAccuracyMeters,
   1536                 verticalAccuracyMeters,
   1537                 speedAccuracyMetersPerSecond,
   1538                 bearingAccuracyDegrees,
   1539                 timestamp);
   1540         auto result = gnssHal_V1_1->injectBestLocation(location);
   1541         if (!result.isOk() || !result) {
   1542             ALOGE("%s: Gnss injectBestLocation() failed.", __func__);
   1543         }
   1544     } else {
   1545         ALOGE("%s: injectBestLocation() is called but gnssHal_V1_1 is not available.", __func__);
   1546     }
   1547 }
   1548 
   1549 static void android_location_GnssLocationProvider_inject_location(JNIEnv* /* env */,
   1550         jobject /* obj */, jdouble latitude, jdouble longitude, jfloat accuracy) {
   1551     if (gnssHal != nullptr) {
   1552         auto result = gnssHal->injectLocation(latitude, longitude, accuracy);
   1553         if (!result.isOk() || !result) {
   1554             ALOGE("%s: Gnss injectLocation() failed", __func__);
   1555         }
   1556     }
   1557 }
   1558 
   1559 static jboolean android_location_GnssLocationProvider_supports_xtra(
   1560         JNIEnv* /* env */, jobject /* obj */) {
   1561     return (gnssXtraIface != nullptr) ? JNI_TRUE : JNI_FALSE;
   1562 }
   1563 
   1564 static void android_location_GnssLocationProvider_inject_xtra_data(JNIEnv* env, jobject /* obj */,
   1565         jbyteArray data, jint length) {
   1566     if (gnssXtraIface == nullptr) {
   1567         ALOGE("XTRA Interface not supported");
   1568         return;
   1569     }
   1570 
   1571     jbyte* bytes = reinterpret_cast<jbyte *>(env->GetPrimitiveArrayCritical(data, 0));
   1572     gnssXtraIface->injectXtraData(std::string((const char*)bytes, length));
   1573     env->ReleasePrimitiveArrayCritical(data, bytes, JNI_ABORT);
   1574 }
   1575 
   1576 static void android_location_GnssLocationProvider_agps_data_conn_open(
   1577         JNIEnv* env, jobject /* obj */, jstring apn, jint apnIpType) {
   1578     if (agnssIface == nullptr) {
   1579         ALOGE("no AGPS interface in agps_data_conn_open");
   1580         return;
   1581     }
   1582     if (apn == NULL) {
   1583         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
   1584         return;
   1585     }
   1586 
   1587     const char *apnStr = env->GetStringUTFChars(apn, NULL);
   1588 
   1589     auto result = agnssIface->dataConnOpen(apnStr, static_cast<IAGnss::ApnIpType>(apnIpType));
   1590     if (!result.isOk() || !result){
   1591         ALOGE("%s: Failed to set APN and its IP type", __func__);
   1592     }
   1593     env->ReleaseStringUTFChars(apn, apnStr);
   1594 }
   1595 
   1596 static void android_location_GnssLocationProvider_agps_data_conn_closed(JNIEnv* /* env */,
   1597                                                                        jobject /* obj */) {
   1598     if (agnssIface == nullptr) {
   1599         ALOGE("%s: AGPS interface not supported", __func__);
   1600         return;
   1601     }
   1602 
   1603     auto result = agnssIface->dataConnClosed();
   1604     if (!result.isOk() || !result) {
   1605         ALOGE("%s: Failed to close AGnss data connection", __func__);
   1606     }
   1607 }
   1608 
   1609 static void android_location_GnssLocationProvider_agps_data_conn_failed(JNIEnv* /* env */,
   1610                                                                        jobject /* obj */) {
   1611     if (agnssIface == nullptr) {
   1612         ALOGE("%s: AGPS interface not supported", __func__);
   1613         return;
   1614     }
   1615 
   1616     auto result = agnssIface->dataConnFailed();
   1617     if (!result.isOk() || !result) {
   1618         ALOGE("%s: Failed to notify unavailability of AGnss data connection", __func__);
   1619     }
   1620 }
   1621 
   1622 static void android_location_GnssLocationProvider_set_agps_server(JNIEnv* env, jobject /* obj */,
   1623         jint type, jstring hostname, jint port) {
   1624     if (agnssIface == nullptr) {
   1625         ALOGE("no AGPS interface in set_agps_server");
   1626         return;
   1627     }
   1628 
   1629     const char *c_hostname = env->GetStringUTFChars(hostname, NULL);
   1630     auto result = agnssIface->setServer(static_cast<IAGnssCallback::AGnssType>(type),
   1631                                        c_hostname,
   1632                                        port);
   1633     if (!result.isOk() || !result) {
   1634         ALOGE("%s: Failed to set AGnss host name and port", __func__);
   1635     }
   1636 
   1637     env->ReleaseStringUTFChars(hostname, c_hostname);
   1638 }
   1639 
   1640 static void android_location_GnssLocationProvider_send_ni_response(JNIEnv* /* env */,
   1641       jobject /* obj */, jint notifId, jint response) {
   1642     if (gnssNiIface == nullptr) {
   1643         ALOGE("no NI interface in send_ni_response");
   1644         return;
   1645     }
   1646 
   1647     gnssNiIface->respond(notifId, static_cast<IGnssNiCallback::GnssUserResponseType>(response));
   1648 }
   1649 
   1650 static jstring android_location_GnssLocationProvider_get_internal_state(JNIEnv* env,
   1651                                                                        jobject /* obj */) {
   1652     jstring result = NULL;
   1653     /*
   1654      * TODO(b/33089503) : Create a jobject to represent GnssDebug.
   1655      */
   1656 
   1657     std::stringstream internalState;
   1658 
   1659     if (gnssDebugIface == nullptr) {
   1660         internalState << "Gnss Debug Interface not available"  << std::endl;
   1661     } else {
   1662         IGnssDebug::DebugData data;
   1663         gnssDebugIface->getDebugData([&data](const IGnssDebug::DebugData& debugData) {
   1664             data = debugData;
   1665         });
   1666 
   1667         internalState << "Gnss Location Data:: ";
   1668         if (!data.position.valid) {
   1669             internalState << "not valid";
   1670         } else {
   1671             internalState << "LatitudeDegrees: " << data.position.latitudeDegrees
   1672                           << ", LongitudeDegrees: " << data.position.longitudeDegrees
   1673                           << ", altitudeMeters: " << data.position.altitudeMeters
   1674                           << ", speedMetersPerSecond: " << data.position.speedMetersPerSec
   1675                           << ", bearingDegrees: " << data.position.bearingDegrees
   1676                           << ", horizontalAccuracyMeters: "
   1677                           << data.position.horizontalAccuracyMeters
   1678                           << ", verticalAccuracyMeters: " << data.position.verticalAccuracyMeters
   1679                           << ", speedAccuracyMetersPerSecond: "
   1680                           << data.position.speedAccuracyMetersPerSecond
   1681                           << ", bearingAccuracyDegrees: " << data.position.bearingAccuracyDegrees
   1682                           << ", ageSeconds: " << data.position.ageSeconds;
   1683         }
   1684         internalState << std::endl;
   1685 
   1686         internalState << "Gnss Time Data:: timeEstimate: " << data.time.timeEstimate
   1687                       << ", timeUncertaintyNs: " << data.time.timeUncertaintyNs
   1688                       << ", frequencyUncertaintyNsPerSec: "
   1689                       << data.time.frequencyUncertaintyNsPerSec << std::endl;
   1690 
   1691         if (data.satelliteDataArray.size() != 0) {
   1692             internalState << "Satellite Data for " << data.satelliteDataArray.size()
   1693                           << " satellites:: " << std::endl;
   1694         }
   1695 
   1696         internalState << "constell: 1=GPS, 2=SBAS, 3=GLO, 4=QZSS, 5=BDS, 6=GAL; "
   1697                       << "ephType: 0=Eph, 1=Alm, 2=Unk; "
   1698                       << "ephSource: 0=Demod, 1=Supl, 2=Server, 3=Unk; "
   1699                       << "ephHealth: 0=Good, 1=Bad, 2=Unk" << std::endl;
   1700         for (size_t i = 0; i < data.satelliteDataArray.size(); i++) {
   1701             internalState << "constell: "
   1702                           << static_cast<uint32_t>(data.satelliteDataArray[i].constellation)
   1703                           << ", svid: " << std::setw(3) << data.satelliteDataArray[i].svid
   1704                           << ", serverPredAvail: "
   1705                           << data.satelliteDataArray[i].serverPredictionIsAvailable
   1706                           << ", serverPredAgeSec: " << std::setw(7)
   1707                           << data.satelliteDataArray[i].serverPredictionAgeSeconds
   1708                           << ", ephType: "
   1709                           << static_cast<uint32_t>(data.satelliteDataArray[i].ephemerisType)
   1710                           << ", ephSource: "
   1711                           << static_cast<uint32_t>(data.satelliteDataArray[i].ephemerisSource)
   1712                           << ", ephHealth: "
   1713                           << static_cast<uint32_t>(data.satelliteDataArray[i].ephemerisHealth)
   1714                           << ", ephAgeSec: " << std::setw(7)
   1715                           << data.satelliteDataArray[i].ephemerisAgeSeconds << std::endl;
   1716         }
   1717     }
   1718 
   1719     result = env->NewStringUTF(internalState.str().c_str());
   1720     return result;
   1721 }
   1722 
   1723 static void android_location_GnssLocationProvider_update_network_state(JNIEnv* env,
   1724                                                                        jobject /* obj */,
   1725                                                                        jboolean connected,
   1726                                                                        jint type,
   1727                                                                        jboolean roaming,
   1728                                                                        jboolean available,
   1729                                                                        jstring extraInfo,
   1730                                                                        jstring apn) {
   1731     if (agnssRilIface != nullptr) {
   1732         auto result = agnssRilIface->updateNetworkState(connected,
   1733                                                        static_cast<IAGnssRil::NetworkType>(type),
   1734                                                        roaming);
   1735         if (!result.isOk() || !result) {
   1736             ALOGE("updateNetworkState failed");
   1737         }
   1738 
   1739         const char *c_apn = env->GetStringUTFChars(apn, NULL);
   1740         result = agnssRilIface->updateNetworkAvailability(available, c_apn);
   1741         if (!result.isOk() || !result) {
   1742             ALOGE("updateNetworkAvailability failed");
   1743         }
   1744 
   1745         env->ReleaseStringUTFChars(apn, c_apn);
   1746     } else {
   1747         ALOGE("AGnssRilInterface does not exist");
   1748     }
   1749 }
   1750 
   1751 static jboolean android_location_GnssGeofenceProvider_is_geofence_supported(
   1752         JNIEnv* /* env */, jobject /* obj */) {
   1753     return (gnssGeofencingIface != nullptr) ? JNI_TRUE : JNI_FALSE;
   1754 }
   1755 
   1756 static jboolean android_location_GnssGeofenceProvider_add_geofence(JNIEnv* /* env */,
   1757         jobject /* obj */, jint geofenceId, jdouble latitude, jdouble longitude, jdouble radius,
   1758         jint last_transition, jint monitor_transition, jint notification_responsiveness,
   1759         jint unknown_timer) {
   1760     if (gnssGeofencingIface != nullptr) {
   1761         auto result = gnssGeofencingIface->addGeofence(
   1762                 geofenceId, latitude, longitude, radius,
   1763                 static_cast<IGnssGeofenceCallback::GeofenceTransition>(last_transition),
   1764                 monitor_transition, notification_responsiveness, unknown_timer);
   1765         return boolToJbool(result.isOk());
   1766     } else {
   1767         ALOGE("Geofence Interface not available");
   1768     }
   1769     return JNI_FALSE;
   1770 }
   1771 
   1772 static jboolean android_location_GnssGeofenceProvider_remove_geofence(JNIEnv* /* env */,
   1773         jobject /* obj */, jint geofenceId) {
   1774     if (gnssGeofencingIface != nullptr) {
   1775         auto result = gnssGeofencingIface->removeGeofence(geofenceId);
   1776         return boolToJbool(result.isOk());
   1777     } else {
   1778         ALOGE("Geofence interface not available");
   1779     }
   1780     return JNI_FALSE;
   1781 }
   1782 
   1783 static jboolean android_location_GnssGeofenceProvider_pause_geofence(JNIEnv* /* env */,
   1784         jobject /* obj */, jint geofenceId) {
   1785     if (gnssGeofencingIface != nullptr) {
   1786         auto result = gnssGeofencingIface->pauseGeofence(geofenceId);
   1787         return boolToJbool(result.isOk());
   1788     } else {
   1789         ALOGE("Geofence interface not available");
   1790     }
   1791     return JNI_FALSE;
   1792 }
   1793 
   1794 static jboolean android_location_GnssGeofenceProvider_resume_geofence(JNIEnv* /* env */,
   1795         jobject /* obj */, jint geofenceId, jint monitor_transition) {
   1796     if (gnssGeofencingIface != nullptr) {
   1797         auto result = gnssGeofencingIface->resumeGeofence(geofenceId, monitor_transition);
   1798         return boolToJbool(result.isOk());
   1799     } else {
   1800         ALOGE("Geofence interface not available");
   1801     }
   1802     return JNI_FALSE;
   1803 }
   1804 
   1805 static jboolean android_location_GnssMeasurementsProvider_is_measurement_supported(
   1806     JNIEnv* env, jclass clazz) {
   1807     if (gnssMeasurementIface != nullptr) {
   1808         return JNI_TRUE;
   1809     }
   1810 
   1811     return JNI_FALSE;
   1812 }
   1813 
   1814 static jboolean android_location_GnssMeasurementsProvider_start_measurement_collection(
   1815         JNIEnv* /* env */,
   1816         jobject /* obj */,
   1817         jboolean enableFullTracking) {
   1818     if (gnssMeasurementIface == nullptr) {
   1819         ALOGE("GNSS Measurement interface is not available.");
   1820         return JNI_FALSE;
   1821     }
   1822 
   1823     sp<GnssMeasurementCallback> cbIface = new GnssMeasurementCallback();
   1824     IGnssMeasurement_V1_0::GnssMeasurementStatus result =
   1825                     IGnssMeasurement_V1_0::GnssMeasurementStatus::ERROR_GENERIC;;
   1826     if (gnssMeasurementIface_V1_1 != nullptr) {
   1827          result = gnssMeasurementIface_V1_1->setCallback_1_1(cbIface,
   1828                         enableFullTracking);
   1829     } else {
   1830         if (enableFullTracking == JNI_TRUE) {
   1831             // full tracking mode not supported in 1.0 HAL
   1832             return JNI_FALSE;
   1833         }
   1834         result = gnssMeasurementIface->setCallback(cbIface);
   1835     }
   1836 
   1837     if (result != IGnssMeasurement_V1_0::GnssMeasurementStatus::SUCCESS) {
   1838         ALOGE("An error has been found on GnssMeasurementInterface::init, status=%d",
   1839               static_cast<int32_t>(result));
   1840         return JNI_FALSE;
   1841     } else {
   1842       ALOGD("gnss measurement infc has been enabled");
   1843     }
   1844 
   1845     return JNI_TRUE;
   1846 }
   1847 
   1848 static jboolean android_location_GnssMeasurementsProvider_stop_measurement_collection(
   1849         JNIEnv* env,
   1850         jobject obj) {
   1851     if (gnssMeasurementIface == nullptr) {
   1852         ALOGE("Measurement interface not available");
   1853         return JNI_FALSE;
   1854     }
   1855 
   1856     auto result = gnssMeasurementIface->close();
   1857     return boolToJbool(result.isOk());
   1858 }
   1859 
   1860 static jboolean android_location_GnssNavigationMessageProvider_is_navigation_message_supported(
   1861         JNIEnv* env,
   1862         jclass clazz) {
   1863     if (gnssNavigationMessageIface != nullptr) {
   1864         return JNI_TRUE;
   1865     }
   1866     return JNI_FALSE;
   1867 }
   1868 
   1869 static jboolean android_location_GnssNavigationMessageProvider_start_navigation_message_collection(
   1870         JNIEnv* env,
   1871         jobject obj) {
   1872     if (gnssNavigationMessageIface == nullptr) {
   1873         ALOGE("Navigation Message interface is not available.");
   1874         return JNI_FALSE;
   1875     }
   1876 
   1877     sp<IGnssNavigationMessageCallback> gnssNavigationMessageCbIface =
   1878             new GnssNavigationMessageCallback();
   1879     IGnssNavigationMessage::GnssNavigationMessageStatus result =
   1880             gnssNavigationMessageIface->setCallback(gnssNavigationMessageCbIface);
   1881 
   1882     if (result != IGnssNavigationMessage::GnssNavigationMessageStatus::SUCCESS) {
   1883         ALOGE("An error has been found in %s: %d", __FUNCTION__, static_cast<int32_t>(result));
   1884         return JNI_FALSE;
   1885     }
   1886 
   1887     return JNI_TRUE;
   1888 }
   1889 
   1890 static jboolean android_location_GnssNavigationMessageProvider_stop_navigation_message_collection(
   1891         JNIEnv* env,
   1892         jobject obj) {
   1893     if (gnssNavigationMessageIface == nullptr) {
   1894         ALOGE("Navigation Message interface is not available.");
   1895         return JNI_FALSE;
   1896     }
   1897 
   1898     auto result = gnssNavigationMessageIface->close();
   1899     return boolToJbool(result.isOk());
   1900 }
   1901 
   1902 static jboolean android_location_GnssLocationProvider_set_emergency_supl_pdn(JNIEnv*,
   1903                                                                     jobject,
   1904                                                                     jint emergencySuplPdn) {
   1905     if (gnssConfigurationIface == nullptr) {
   1906         ALOGE("no GNSS configuration interface available");
   1907         return JNI_FALSE;
   1908     }
   1909 
   1910     auto result = gnssConfigurationIface->setEmergencySuplPdn(emergencySuplPdn);
   1911     if (result.isOk()) {
   1912         return result;
   1913     } else {
   1914         return JNI_FALSE;
   1915     }
   1916 }
   1917 
   1918 static jboolean android_location_GnssLocationProvider_set_supl_version(JNIEnv*,
   1919                                                                     jobject,
   1920                                                                     jint version) {
   1921     if (gnssConfigurationIface == nullptr) {
   1922         ALOGE("no GNSS configuration interface available");
   1923         return JNI_FALSE;
   1924     }
   1925     auto result = gnssConfigurationIface->setSuplVersion(version);
   1926     if (result.isOk()) {
   1927         return result;
   1928     } else {
   1929         return JNI_FALSE;
   1930     }
   1931 }
   1932 
   1933 static jboolean android_location_GnssLocationProvider_set_supl_es(JNIEnv*,
   1934                                                                     jobject,
   1935                                                                     jint suplEs) {
   1936     if (gnssConfigurationIface == nullptr) {
   1937         ALOGE("no GNSS configuration interface available");
   1938         return JNI_FALSE;
   1939     }
   1940 
   1941     auto result = gnssConfigurationIface->setSuplEs(suplEs);
   1942     if (result.isOk()) {
   1943         return result;
   1944     } else {
   1945         return JNI_FALSE;
   1946     }
   1947 }
   1948 
   1949 static jboolean android_location_GnssLocationProvider_set_supl_mode(JNIEnv*,
   1950                                                                     jobject,
   1951                                                                     jint mode) {
   1952     if (gnssConfigurationIface == nullptr) {
   1953         ALOGE("no GNSS configuration interface available");
   1954         return JNI_FALSE;
   1955     }
   1956 
   1957     auto result = gnssConfigurationIface->setSuplMode(mode);
   1958     if (result.isOk()) {
   1959         return result;
   1960     } else {
   1961         return JNI_FALSE;
   1962     }
   1963 }
   1964 
   1965 static jboolean android_location_GnssLocationProvider_set_gps_lock(JNIEnv*,
   1966                                                                    jobject,
   1967                                                                    jint gpsLock) {
   1968     if (gnssConfigurationIface == nullptr) {
   1969         ALOGE("no GNSS configuration interface available");
   1970         return JNI_FALSE;
   1971     }
   1972 
   1973     auto result = gnssConfigurationIface->setGpsLock(gpsLock);
   1974     if (result.isOk()) {
   1975         return result;
   1976     } else {
   1977         return JNI_FALSE;
   1978     }
   1979 }
   1980 
   1981 static jboolean android_location_GnssLocationProvider_set_lpp_profile(JNIEnv*,
   1982                                                                    jobject,
   1983                                                                    jint lppProfile) {
   1984     if (gnssConfigurationIface == nullptr) {
   1985         ALOGE("no GNSS configuration interface available");
   1986         return JNI_FALSE;
   1987     }
   1988 
   1989     auto result = gnssConfigurationIface->setLppProfile(lppProfile);
   1990 
   1991     if (result.isOk()) {
   1992         return result;
   1993     } else {
   1994         return JNI_FALSE;
   1995     }
   1996 }
   1997 
   1998 static jboolean android_location_GnssLocationProvider_set_gnss_pos_protocol_select(JNIEnv*,
   1999                                                                    jobject,
   2000                                                                    jint gnssPosProtocol) {
   2001     if (gnssConfigurationIface == nullptr) {
   2002         ALOGE("no GNSS configuration interface available");
   2003         return JNI_FALSE;
   2004     }
   2005 
   2006     auto result = gnssConfigurationIface->setGlonassPositioningProtocol(gnssPosProtocol);
   2007     if (result.isOk()) {
   2008         return result;
   2009     } else {
   2010         return JNI_FALSE;
   2011     }
   2012 }
   2013 
   2014 static jboolean android_location_GnssLocationProvider_set_satellite_blacklist(
   2015         JNIEnv* env, jobject, jintArray constellations, jintArray sv_ids) {
   2016     if (gnssConfigurationIface_V1_1 == nullptr) {
   2017         ALOGI("No GNSS Satellite Blacklist interface available");
   2018         return JNI_FALSE;
   2019     }
   2020 
   2021     jint *constellation_array = env->GetIntArrayElements(constellations, 0);
   2022     if (NULL == constellation_array) {
   2023         ALOGI("GetIntArrayElements returns NULL.");
   2024         return JNI_FALSE;
   2025     }
   2026     jsize length = env->GetArrayLength(constellations);
   2027 
   2028     jint *sv_id_array = env->GetIntArrayElements(sv_ids, 0);
   2029     if (NULL == sv_id_array) {
   2030         ALOGI("GetIntArrayElements returns NULL.");
   2031         return JNI_FALSE;
   2032     }
   2033 
   2034     if (length != env->GetArrayLength(sv_ids)) {
   2035         ALOGI("Lengths of constellations and sv_ids are inconsistent.");
   2036         return JNI_FALSE;
   2037     }
   2038 
   2039     hidl_vec<IGnssConfiguration_V1_1::BlacklistedSource> sources;
   2040     sources.resize(length);
   2041 
   2042     for (int i = 0; i < length; i++) {
   2043         sources[i].constellation = static_cast<GnssConstellationType>(constellation_array[i]);
   2044         sources[i].svid = sv_id_array[i];
   2045     }
   2046 
   2047     auto result = gnssConfigurationIface_V1_1->setBlacklist(sources);
   2048     if (result.isOk()) {
   2049         return result;
   2050     } else {
   2051         return JNI_FALSE;
   2052     }
   2053 }
   2054 
   2055 
   2056 static jint android_location_GnssBatchingProvider_get_batch_size(JNIEnv*, jclass) {
   2057     if (gnssBatchingIface == nullptr) {
   2058         return 0; // batching not supported, size = 0
   2059     }
   2060     auto result = gnssBatchingIface->getBatchSize();
   2061     if (result.isOk()) {
   2062         return static_cast<jint>(result);
   2063     } else {
   2064         return 0; // failure in binder, don't support batching
   2065     }
   2066 }
   2067 
   2068 static jboolean android_location_GnssBatchingProvider_init_batching(JNIEnv*, jclass) {
   2069     if (gnssBatchingIface == nullptr) {
   2070         return JNI_FALSE; // batching not supported
   2071     }
   2072     sp<IGnssBatchingCallback> gnssBatchingCbIface = new GnssBatchingCallback();
   2073 
   2074     return static_cast<jboolean>(gnssBatchingIface->init(gnssBatchingCbIface));
   2075 }
   2076 
   2077 static void android_location_GnssBatchingProvider_cleanup_batching(JNIEnv*, jclass) {
   2078     if (gnssBatchingIface == nullptr) {
   2079         return; // batching not supported
   2080     }
   2081     gnssBatchingIface->cleanup();
   2082 }
   2083 
   2084 static jboolean android_location_GnssBatchingProvider_start_batch(JNIEnv*, jclass,
   2085         jlong periodNanos, jboolean wakeOnFifoFull) {
   2086     if (gnssBatchingIface == nullptr) {
   2087         return JNI_FALSE; // batching not supported
   2088     }
   2089 
   2090     IGnssBatching::Options options;
   2091     options.periodNanos = periodNanos;
   2092     if (wakeOnFifoFull) {
   2093         options.flags = static_cast<uint8_t>(IGnssBatching::Flag::WAKEUP_ON_FIFO_FULL);
   2094     } else {
   2095         options.flags = 0;
   2096     }
   2097 
   2098     return static_cast<jboolean>(gnssBatchingIface->start(options));
   2099 }
   2100 
   2101 static void android_location_GnssBatchingProvider_flush_batch(JNIEnv*, jclass) {
   2102     if (gnssBatchingIface == nullptr) {
   2103         return; // batching not supported
   2104     }
   2105 
   2106     gnssBatchingIface->flush();
   2107 }
   2108 
   2109 static jboolean android_location_GnssBatchingProvider_stop_batch(JNIEnv*, jclass) {
   2110     if (gnssBatchingIface == nullptr) {
   2111         return JNI_FALSE; // batching not supported
   2112     }
   2113 
   2114     return gnssBatchingIface->stop();
   2115 }
   2116 
   2117 static const JNINativeMethod sMethods[] = {
   2118      /* name, signature, funcPtr */
   2119     {"class_init_native", "()V", reinterpret_cast<void *>(
   2120             android_location_GnssLocationProvider_class_init_native)},
   2121     {"native_is_supported", "()Z", reinterpret_cast<void *>(
   2122             android_location_GnssLocationProvider_is_supported)},
   2123     {"native_is_agps_ril_supported", "()Z",
   2124             reinterpret_cast<void *>(android_location_GnssLocationProvider_is_agps_ril_supported)},
   2125     {"native_is_gnss_configuration_supported", "()Z",
   2126             reinterpret_cast<void *>(
   2127                     android_location_gpsLocationProvider_is_gnss_configuration_supported)},
   2128     {"native_init_once", "()V", reinterpret_cast<void *>(
   2129             android_location_GnssLocationProvider_init_once)},
   2130     {"native_init", "()Z", reinterpret_cast<void *>(android_location_GnssLocationProvider_init)},
   2131     {"native_cleanup", "()V", reinterpret_cast<void *>(
   2132             android_location_GnssLocationProvider_cleanup)},
   2133     {"native_set_position_mode",
   2134                 "(IIIIIZ)Z",
   2135                 reinterpret_cast<void*>(android_location_GnssLocationProvider_set_position_mode)},
   2136     {"native_start", "()Z", reinterpret_cast<void*>(android_location_GnssLocationProvider_start)},
   2137     {"native_stop", "()Z", reinterpret_cast<void*>(android_location_GnssLocationProvider_stop)},
   2138     {"native_delete_aiding_data",
   2139             "(I)V",
   2140             reinterpret_cast<void*>(android_location_GnssLocationProvider_delete_aiding_data)},
   2141     {"native_read_nmea", "([BI)I", reinterpret_cast<void *>(
   2142             android_location_GnssLocationProvider_read_nmea)},
   2143     {"native_inject_time", "(JJI)V", reinterpret_cast<void *>(
   2144             android_location_GnssLocationProvider_inject_time)},
   2145     {"native_inject_best_location",
   2146             "(IDDDFFFFFFJ)V",
   2147             reinterpret_cast<void *>(android_location_GnssLocationProvider_inject_best_location)},
   2148     {"native_inject_location",
   2149             "(DDF)V",
   2150             reinterpret_cast<void *>(android_location_GnssLocationProvider_inject_location)},
   2151     {"native_supports_xtra", "()Z", reinterpret_cast<void *>(
   2152             android_location_GnssLocationProvider_supports_xtra)},
   2153     {"native_inject_xtra_data",
   2154             "([BI)V",
   2155             reinterpret_cast<void *>(android_location_GnssLocationProvider_inject_xtra_data)},
   2156     {"native_agps_data_conn_open",
   2157             "(Ljava/lang/String;I)V",
   2158             reinterpret_cast<void *>(android_location_GnssLocationProvider_agps_data_conn_open)},
   2159     {"native_agps_data_conn_closed",
   2160             "()V",
   2161             reinterpret_cast<void *>(android_location_GnssLocationProvider_agps_data_conn_closed)},
   2162     {"native_agps_data_conn_failed",
   2163             "()V",
   2164             reinterpret_cast<void *>(android_location_GnssLocationProvider_agps_data_conn_failed)},
   2165     {"native_agps_set_id",
   2166             "(ILjava/lang/String;)V",
   2167             reinterpret_cast<void *>(android_location_GnssLocationProvider_agps_set_id)},
   2168     {"native_agps_set_ref_location_cellid",
   2169             "(IIIII)V",
   2170             reinterpret_cast<void *>(
   2171                     android_location_GnssLocationProvider_agps_set_reference_location_cellid)},
   2172     {"native_set_agps_server",
   2173             "(ILjava/lang/String;I)V",
   2174             reinterpret_cast<void *>(android_location_GnssLocationProvider_set_agps_server)},
   2175     {"native_send_ni_response",
   2176             "(II)V",
   2177             reinterpret_cast<void *>(android_location_GnssLocationProvider_send_ni_response)},
   2178     {"native_get_internal_state",
   2179             "()Ljava/lang/String;",
   2180             reinterpret_cast<void *>(android_location_GnssLocationProvider_get_internal_state)},
   2181     {"native_update_network_state",
   2182             "(ZIZZLjava/lang/String;Ljava/lang/String;)V",
   2183             reinterpret_cast<void *>(android_location_GnssLocationProvider_update_network_state)},
   2184     {"native_set_supl_es",
   2185             "(I)Z",
   2186             reinterpret_cast<void *>(android_location_GnssLocationProvider_set_supl_es)},
   2187     {"native_set_supl_version",
   2188             "(I)Z",
   2189             reinterpret_cast<void *>(android_location_GnssLocationProvider_set_supl_version)},
   2190     {"native_set_supl_mode",
   2191             "(I)Z",
   2192             reinterpret_cast<void *>(android_location_GnssLocationProvider_set_supl_mode)},
   2193     {"native_set_lpp_profile",
   2194             "(I)Z",
   2195             reinterpret_cast<void *>(android_location_GnssLocationProvider_set_lpp_profile)},
   2196     {"native_set_gnss_pos_protocol_select",
   2197             "(I)Z",
   2198             reinterpret_cast<void *>(
   2199                     android_location_GnssLocationProvider_set_gnss_pos_protocol_select)},
   2200     {"native_set_gps_lock",
   2201             "(I)Z",
   2202             reinterpret_cast<void *>(android_location_GnssLocationProvider_set_gps_lock)},
   2203     {"native_set_emergency_supl_pdn",
   2204             "(I)Z",
   2205             reinterpret_cast<void *>(android_location_GnssLocationProvider_set_emergency_supl_pdn)},
   2206     {"native_set_satellite_blacklist",
   2207             "([I[I)Z",
   2208             reinterpret_cast<void *>(android_location_GnssLocationProvider_set_satellite_blacklist)},
   2209 };
   2210 
   2211 static const JNINativeMethod sMethodsBatching[] = {
   2212      /* name, signature, funcPtr */
   2213     {"native_get_batch_size",
   2214             "()I",
   2215             reinterpret_cast<void *>(android_location_GnssBatchingProvider_get_batch_size)},
   2216     {"native_start_batch",
   2217             "(JZ)Z",
   2218             reinterpret_cast<void *>(android_location_GnssBatchingProvider_start_batch)},
   2219     {"native_flush_batch",
   2220             "()V",
   2221             reinterpret_cast<void *>(android_location_GnssBatchingProvider_flush_batch)},
   2222     {"native_stop_batch",
   2223             "()Z",
   2224             reinterpret_cast<void *>(android_location_GnssBatchingProvider_stop_batch)},
   2225     {"native_init_batching",
   2226             "()Z",
   2227             reinterpret_cast<void *>(android_location_GnssBatchingProvider_init_batching)},
   2228     {"native_cleanup_batching",
   2229             "()V",
   2230             reinterpret_cast<void *>(android_location_GnssBatchingProvider_cleanup_batching)},
   2231 };
   2232 
   2233 static const JNINativeMethod sGeofenceMethods[] = {
   2234      /* name, signature, funcPtr */
   2235     {"native_is_geofence_supported",
   2236             "()Z",
   2237             reinterpret_cast<void *>(android_location_GnssGeofenceProvider_is_geofence_supported)},
   2238     {"native_add_geofence",
   2239             "(IDDDIIII)Z",
   2240             reinterpret_cast<void *>(android_location_GnssGeofenceProvider_add_geofence)},
   2241     {"native_remove_geofence",
   2242             "(I)Z",
   2243             reinterpret_cast<void *>(android_location_GnssGeofenceProvider_remove_geofence)},
   2244     {"native_pause_geofence", "(I)Z", reinterpret_cast<void *>(
   2245             android_location_GnssGeofenceProvider_pause_geofence)},
   2246     {"native_resume_geofence",
   2247             "(II)Z",
   2248             reinterpret_cast<void *>(android_location_GnssGeofenceProvider_resume_geofence)},
   2249 };
   2250 
   2251 static const JNINativeMethod sMeasurementMethods[] = {
   2252      /* name, signature, funcPtr */
   2253     {"native_is_measurement_supported",
   2254             "()Z",
   2255             reinterpret_cast<void *>(
   2256                     android_location_GnssMeasurementsProvider_is_measurement_supported)},
   2257     {"native_start_measurement_collection",
   2258              "(Z)Z",
   2259             reinterpret_cast<void *>(
   2260                     android_location_GnssMeasurementsProvider_start_measurement_collection)},
   2261     {"native_stop_measurement_collection",
   2262             "()Z",
   2263             reinterpret_cast<void *>(
   2264                     android_location_GnssMeasurementsProvider_stop_measurement_collection)},
   2265 };
   2266 
   2267 static const JNINativeMethod sNavigationMessageMethods[] = {
   2268      /* name, signature, funcPtr */
   2269     {"native_is_navigation_message_supported",
   2270             "()Z",
   2271             reinterpret_cast<void *>(
   2272                     android_location_GnssNavigationMessageProvider_is_navigation_message_supported)},
   2273     {"native_start_navigation_message_collection",
   2274             "()Z",
   2275             reinterpret_cast<void *>(
   2276                     android_location_GnssNavigationMessageProvider_start_navigation_message_collection)},
   2277     {"native_stop_navigation_message_collection",
   2278             "()Z",
   2279             reinterpret_cast<void *>(
   2280                     android_location_GnssNavigationMessageProvider_stop_navigation_message_collection)},
   2281 };
   2282 
   2283 int register_android_server_location_GnssLocationProvider(JNIEnv* env) {
   2284     jniRegisterNativeMethods(
   2285             env,
   2286             "com/android/server/location/GnssBatchingProvider",
   2287             sMethodsBatching,
   2288             NELEM(sMethodsBatching));
   2289     jniRegisterNativeMethods(
   2290             env,
   2291             "com/android/server/location/GnssGeofenceProvider",
   2292             sGeofenceMethods,
   2293             NELEM(sGeofenceMethods));
   2294     jniRegisterNativeMethods(
   2295             env,
   2296             "com/android/server/location/GnssMeasurementsProvider",
   2297             sMeasurementMethods,
   2298             NELEM(sMeasurementMethods));
   2299     jniRegisterNativeMethods(
   2300             env,
   2301             "com/android/server/location/GnssNavigationMessageProvider",
   2302             sNavigationMessageMethods,
   2303             NELEM(sNavigationMessageMethods));
   2304     return jniRegisterNativeMethods(
   2305             env,
   2306             "com/android/server/location/GnssLocationProvider",
   2307             sMethods,
   2308             NELEM(sMethods));
   2309 }
   2310 
   2311 } /* namespace android */
   2312