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 "GpsLocationProvider"
     18 
     19 #define LOG_NDEBUG 0
     20 
     21 #include "JNIHelp.h"
     22 #include "jni.h"
     23 #include "hardware/hardware.h"
     24 #include "hardware/gps.h"
     25 #include "hardware_legacy/power.h"
     26 #include "utils/Log.h"
     27 #include "utils/misc.h"
     28 #include "android_runtime/AndroidRuntime.h"
     29 
     30 #include <string.h>
     31 #include <pthread.h>
     32 
     33 static jobject mCallbacksObj = NULL;
     34 
     35 static jmethodID method_reportLocation;
     36 static jmethodID method_reportStatus;
     37 static jmethodID method_reportSvStatus;
     38 static jmethodID method_reportAGpsStatus;
     39 static jmethodID method_reportNmea;
     40 static jmethodID method_setEngineCapabilities;
     41 static jmethodID method_xtraDownloadRequest;
     42 static jmethodID method_reportNiNotification;
     43 static jmethodID method_requestRefLocation;
     44 static jmethodID method_requestSetID;
     45 static jmethodID method_requestUtcTime;
     46 
     47 static const GpsInterface* sGpsInterface = NULL;
     48 static const GpsXtraInterface* sGpsXtraInterface = NULL;
     49 static const AGpsInterface* sAGpsInterface = NULL;
     50 static const GpsNiInterface* sGpsNiInterface = NULL;
     51 static const GpsDebugInterface* sGpsDebugInterface = NULL;
     52 static const AGpsRilInterface* sAGpsRilInterface = NULL;
     53 
     54 // temporary storage for GPS callbacks
     55 static GpsSvStatus  sGpsSvStatus;
     56 static const char* sNmeaString;
     57 static int sNmeaStringLength;
     58 
     59 #define WAKE_LOCK_NAME  "GPS"
     60 
     61 namespace android {
     62 
     63 static void checkAndClearExceptionFromCallback(JNIEnv* env, const char* methodName) {
     64     if (env->ExceptionCheck()) {
     65         ALOGE("An exception was thrown by callback '%s'.", methodName);
     66         LOGE_EX(env);
     67         env->ExceptionClear();
     68     }
     69 }
     70 
     71 static void location_callback(GpsLocation* location)
     72 {
     73     JNIEnv* env = AndroidRuntime::getJNIEnv();
     74     env->CallVoidMethod(mCallbacksObj, method_reportLocation, location->flags,
     75             (jdouble)location->latitude, (jdouble)location->longitude,
     76             (jdouble)location->altitude,
     77             (jfloat)location->speed, (jfloat)location->bearing,
     78             (jfloat)location->accuracy, (jlong)location->timestamp);
     79     checkAndClearExceptionFromCallback(env, __FUNCTION__);
     80 }
     81 
     82 static void status_callback(GpsStatus* status)
     83 {
     84     JNIEnv* env = AndroidRuntime::getJNIEnv();
     85     env->CallVoidMethod(mCallbacksObj, method_reportStatus, status->status);
     86     checkAndClearExceptionFromCallback(env, __FUNCTION__);
     87 }
     88 
     89 static void sv_status_callback(GpsSvStatus* sv_status)
     90 {
     91     JNIEnv* env = AndroidRuntime::getJNIEnv();
     92     memcpy(&sGpsSvStatus, sv_status, sizeof(sGpsSvStatus));
     93     env->CallVoidMethod(mCallbacksObj, method_reportSvStatus);
     94     checkAndClearExceptionFromCallback(env, __FUNCTION__);
     95 }
     96 
     97 static void nmea_callback(GpsUtcTime timestamp, const char* nmea, int length)
     98 {
     99     JNIEnv* env = AndroidRuntime::getJNIEnv();
    100     // The Java code will call back to read these values
    101     // We do this to avoid creating unnecessary String objects
    102     sNmeaString = nmea;
    103     sNmeaStringLength = length;
    104     env->CallVoidMethod(mCallbacksObj, method_reportNmea, timestamp);
    105     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    106 }
    107 
    108 static void set_capabilities_callback(uint32_t capabilities)
    109 {
    110     ALOGD("set_capabilities_callback: %ld\n", capabilities);
    111     JNIEnv* env = AndroidRuntime::getJNIEnv();
    112     env->CallVoidMethod(mCallbacksObj, method_setEngineCapabilities, capabilities);
    113     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    114 }
    115 
    116 static void acquire_wakelock_callback()
    117 {
    118     acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME);
    119 }
    120 
    121 static void release_wakelock_callback()
    122 {
    123     release_wake_lock(WAKE_LOCK_NAME);
    124 }
    125 
    126 static void request_utc_time_callback()
    127 {
    128     JNIEnv* env = AndroidRuntime::getJNIEnv();
    129     env->CallVoidMethod(mCallbacksObj, method_requestUtcTime);
    130     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    131 }
    132 
    133 static pthread_t create_thread_callback(const char* name, void (*start)(void *), void* arg)
    134 {
    135     return (pthread_t)AndroidRuntime::createJavaThread(name, start, arg);
    136 }
    137 
    138 GpsCallbacks sGpsCallbacks = {
    139     sizeof(GpsCallbacks),
    140     location_callback,
    141     status_callback,
    142     sv_status_callback,
    143     nmea_callback,
    144     set_capabilities_callback,
    145     acquire_wakelock_callback,
    146     release_wakelock_callback,
    147     create_thread_callback,
    148     request_utc_time_callback,
    149 };
    150 
    151 static void xtra_download_request_callback()
    152 {
    153     JNIEnv* env = AndroidRuntime::getJNIEnv();
    154     env->CallVoidMethod(mCallbacksObj, method_xtraDownloadRequest);
    155     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    156 }
    157 
    158 GpsXtraCallbacks sGpsXtraCallbacks = {
    159     xtra_download_request_callback,
    160     create_thread_callback,
    161 };
    162 
    163 static void agps_status_callback(AGpsStatus* agps_status)
    164 {
    165     JNIEnv* env = AndroidRuntime::getJNIEnv();
    166 
    167     uint32_t ipaddr;
    168     // ipaddr field was not included in original AGpsStatus
    169     if (agps_status->size >= sizeof(AGpsStatus))
    170         ipaddr = agps_status->ipaddr;
    171     else
    172         ipaddr = 0xFFFFFFFF;
    173     env->CallVoidMethod(mCallbacksObj, method_reportAGpsStatus,
    174                         agps_status->type, agps_status->status, ipaddr);
    175     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    176 }
    177 
    178 AGpsCallbacks sAGpsCallbacks = {
    179     agps_status_callback,
    180     create_thread_callback,
    181 };
    182 
    183 static void gps_ni_notify_callback(GpsNiNotification *notification)
    184 {
    185     ALOGD("gps_ni_notify_callback\n");
    186     JNIEnv* env = AndroidRuntime::getJNIEnv();
    187     jstring requestor_id = env->NewStringUTF(notification->requestor_id);
    188     jstring text = env->NewStringUTF(notification->text);
    189     jstring extras = env->NewStringUTF(notification->extras);
    190 
    191     if (requestor_id && text && extras) {
    192         env->CallVoidMethod(mCallbacksObj, method_reportNiNotification,
    193             notification->notification_id, notification->ni_type,
    194             notification->notify_flags, notification->timeout,
    195             notification->default_response, requestor_id, text,
    196             notification->requestor_id_encoding,
    197             notification->text_encoding, extras);
    198     } else {
    199         ALOGE("out of memory in gps_ni_notify_callback\n");
    200     }
    201 
    202     if (requestor_id)
    203         env->DeleteLocalRef(requestor_id);
    204     if (text)
    205         env->DeleteLocalRef(text);
    206     if (extras)
    207         env->DeleteLocalRef(extras);
    208     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    209 }
    210 
    211 GpsNiCallbacks sGpsNiCallbacks = {
    212     gps_ni_notify_callback,
    213     create_thread_callback,
    214 };
    215 
    216 static void agps_request_set_id(uint32_t flags)
    217 {
    218     JNIEnv* env = AndroidRuntime::getJNIEnv();
    219     env->CallVoidMethod(mCallbacksObj, method_requestSetID, flags);
    220     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    221 }
    222 
    223 static void agps_request_ref_location(uint32_t flags)
    224 {
    225     JNIEnv* env = AndroidRuntime::getJNIEnv();
    226     env->CallVoidMethod(mCallbacksObj, method_requestRefLocation, flags);
    227     checkAndClearExceptionFromCallback(env, __FUNCTION__);
    228 }
    229 
    230 AGpsRilCallbacks sAGpsRilCallbacks = {
    231     agps_request_set_id,
    232     agps_request_ref_location,
    233     create_thread_callback,
    234 };
    235 
    236 static void android_location_GpsLocationProvider_class_init_native(JNIEnv* env, jclass clazz) {
    237     int err;
    238     hw_module_t* module;
    239 
    240     method_reportLocation = env->GetMethodID(clazz, "reportLocation", "(IDDDFFFJ)V");
    241     method_reportStatus = env->GetMethodID(clazz, "reportStatus", "(I)V");
    242     method_reportSvStatus = env->GetMethodID(clazz, "reportSvStatus", "()V");
    243     method_reportAGpsStatus = env->GetMethodID(clazz, "reportAGpsStatus", "(III)V");
    244     method_reportNmea = env->GetMethodID(clazz, "reportNmea", "(J)V");
    245     method_setEngineCapabilities = env->GetMethodID(clazz, "setEngineCapabilities", "(I)V");
    246     method_xtraDownloadRequest = env->GetMethodID(clazz, "xtraDownloadRequest", "()V");
    247     method_reportNiNotification = env->GetMethodID(clazz, "reportNiNotification",
    248             "(IIIIILjava/lang/String;Ljava/lang/String;IILjava/lang/String;)V");
    249     method_requestRefLocation = env->GetMethodID(clazz,"requestRefLocation","(I)V");
    250     method_requestSetID = env->GetMethodID(clazz,"requestSetID","(I)V");
    251     method_requestUtcTime = env->GetMethodID(clazz,"requestUtcTime","()V");
    252 
    253     err = hw_get_module(GPS_HARDWARE_MODULE_ID, (hw_module_t const**)&module);
    254     if (err == 0) {
    255         hw_device_t* device;
    256         err = module->methods->open(module, GPS_HARDWARE_MODULE_ID, &device);
    257         if (err == 0) {
    258             gps_device_t* gps_device = (gps_device_t *)device;
    259             sGpsInterface = gps_device->get_gps_interface(gps_device);
    260         }
    261     }
    262     if (sGpsInterface) {
    263         sGpsXtraInterface =
    264             (const GpsXtraInterface*)sGpsInterface->get_extension(GPS_XTRA_INTERFACE);
    265         sAGpsInterface =
    266             (const AGpsInterface*)sGpsInterface->get_extension(AGPS_INTERFACE);
    267         sGpsNiInterface =
    268             (const GpsNiInterface*)sGpsInterface->get_extension(GPS_NI_INTERFACE);
    269         sGpsDebugInterface =
    270             (const GpsDebugInterface*)sGpsInterface->get_extension(GPS_DEBUG_INTERFACE);
    271         sAGpsRilInterface =
    272             (const AGpsRilInterface*)sGpsInterface->get_extension(AGPS_RIL_INTERFACE);
    273     }
    274 }
    275 
    276 static jboolean android_location_GpsLocationProvider_is_supported(JNIEnv* env, jclass clazz) {
    277     return (sGpsInterface != NULL);
    278 }
    279 
    280 static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject obj)
    281 {
    282     // this must be set before calling into the HAL library
    283     if (!mCallbacksObj)
    284         mCallbacksObj = env->NewGlobalRef(obj);
    285 
    286     // fail if the main interface fails to initialize
    287     if (!sGpsInterface || sGpsInterface->init(&sGpsCallbacks) != 0)
    288         return false;
    289 
    290     // if XTRA initialization fails we will disable it by sGpsXtraInterface to null,
    291     // but continue to allow the rest of the GPS interface to work.
    292     if (sGpsXtraInterface && sGpsXtraInterface->init(&sGpsXtraCallbacks) != 0)
    293         sGpsXtraInterface = NULL;
    294     if (sAGpsInterface)
    295         sAGpsInterface->init(&sAGpsCallbacks);
    296     if (sGpsNiInterface)
    297         sGpsNiInterface->init(&sGpsNiCallbacks);
    298     if (sAGpsRilInterface)
    299         sAGpsRilInterface->init(&sAGpsRilCallbacks);
    300 
    301     return true;
    302 }
    303 
    304 static void android_location_GpsLocationProvider_cleanup(JNIEnv* env, jobject obj)
    305 {
    306     if (sGpsInterface)
    307         sGpsInterface->cleanup();
    308 }
    309 
    310 static jboolean android_location_GpsLocationProvider_set_position_mode(JNIEnv* env, jobject obj,
    311         jint mode, jint recurrence, jint min_interval, jint preferred_accuracy, jint preferred_time)
    312 {
    313     if (sGpsInterface)
    314         return (sGpsInterface->set_position_mode(mode, recurrence, min_interval, preferred_accuracy,
    315                 preferred_time) == 0);
    316     else
    317         return false;
    318 }
    319 
    320 static jboolean android_location_GpsLocationProvider_start(JNIEnv* env, jobject obj)
    321 {
    322     if (sGpsInterface)
    323         return (sGpsInterface->start() == 0);
    324     else
    325         return false;
    326 }
    327 
    328 static jboolean android_location_GpsLocationProvider_stop(JNIEnv* env, jobject obj)
    329 {
    330     if (sGpsInterface)
    331         return (sGpsInterface->stop() == 0);
    332     else
    333         return false;
    334 }
    335 
    336 static void android_location_GpsLocationProvider_delete_aiding_data(JNIEnv* env, jobject obj, jint flags)
    337 {
    338     if (sGpsInterface)
    339         sGpsInterface->delete_aiding_data(flags);
    340 }
    341 
    342 static jint android_location_GpsLocationProvider_read_sv_status(JNIEnv* env, jobject obj,
    343         jintArray prnArray, jfloatArray snrArray, jfloatArray elevArray, jfloatArray azumArray,
    344         jintArray maskArray)
    345 {
    346     // this should only be called from within a call to reportSvStatus
    347 
    348     jint* prns = env->GetIntArrayElements(prnArray, 0);
    349     jfloat* snrs = env->GetFloatArrayElements(snrArray, 0);
    350     jfloat* elev = env->GetFloatArrayElements(elevArray, 0);
    351     jfloat* azim = env->GetFloatArrayElements(azumArray, 0);
    352     jint* mask = env->GetIntArrayElements(maskArray, 0);
    353 
    354     int num_svs = sGpsSvStatus.num_svs;
    355     for (int i = 0; i < num_svs; i++) {
    356         prns[i] = sGpsSvStatus.sv_list[i].prn;
    357         snrs[i] = sGpsSvStatus.sv_list[i].snr;
    358         elev[i] = sGpsSvStatus.sv_list[i].elevation;
    359         azim[i] = sGpsSvStatus.sv_list[i].azimuth;
    360     }
    361     mask[0] = sGpsSvStatus.ephemeris_mask;
    362     mask[1] = sGpsSvStatus.almanac_mask;
    363     mask[2] = sGpsSvStatus.used_in_fix_mask;
    364 
    365     env->ReleaseIntArrayElements(prnArray, prns, 0);
    366     env->ReleaseFloatArrayElements(snrArray, snrs, 0);
    367     env->ReleaseFloatArrayElements(elevArray, elev, 0);
    368     env->ReleaseFloatArrayElements(azumArray, azim, 0);
    369     env->ReleaseIntArrayElements(maskArray, mask, 0);
    370     return num_svs;
    371 }
    372 
    373 static void android_location_GpsLocationProvider_agps_set_reference_location_cellid(JNIEnv* env,
    374         jobject obj, jint type, jint mcc, jint mnc, jint lac, jint cid)
    375 {
    376     AGpsRefLocation location;
    377 
    378     if (!sAGpsRilInterface) {
    379         ALOGE("no AGPS RIL interface in agps_set_reference_location_cellid");
    380         return;
    381     }
    382 
    383     switch(type) {
    384         case AGPS_REF_LOCATION_TYPE_GSM_CELLID:
    385         case AGPS_REF_LOCATION_TYPE_UMTS_CELLID:
    386             location.type = type;
    387             location.u.cellID.mcc = mcc;
    388             location.u.cellID.mnc = mnc;
    389             location.u.cellID.lac = lac;
    390             location.u.cellID.cid = cid;
    391             break;
    392         default:
    393             ALOGE("Neither a GSM nor a UMTS cellid (%s:%d).",__FUNCTION__,__LINE__);
    394             return;
    395             break;
    396     }
    397     sAGpsRilInterface->set_ref_location(&location, sizeof(location));
    398 }
    399 
    400 static void android_location_GpsLocationProvider_agps_send_ni_message(JNIEnv* env,
    401         jobject obj, jbyteArray ni_msg, jint size)
    402 {
    403     size_t sz;
    404 
    405     if (!sAGpsRilInterface) {
    406         ALOGE("no AGPS RIL interface in send_ni_message");
    407         return;
    408     }
    409     if (size < 0)
    410         return;
    411     sz = (size_t)size;
    412     jbyte* b = env->GetByteArrayElements(ni_msg, 0);
    413     sAGpsRilInterface->ni_message((uint8_t *)b,sz);
    414     env->ReleaseByteArrayElements(ni_msg,b,0);
    415 }
    416 
    417 static void android_location_GpsLocationProvider_agps_set_id(JNIEnv *env,
    418         jobject obj, jint type, jstring  setid_string)
    419 {
    420     if (!sAGpsRilInterface) {
    421         ALOGE("no AGPS RIL interface in agps_set_id");
    422         return;
    423     }
    424 
    425     const char *setid = env->GetStringUTFChars(setid_string, NULL);
    426     sAGpsRilInterface->set_set_id(type, setid);
    427     env->ReleaseStringUTFChars(setid_string, setid);
    428 }
    429 
    430 static jint android_location_GpsLocationProvider_read_nmea(JNIEnv* env, jobject obj,
    431                                             jbyteArray nmeaArray, jint buffer_size)
    432 {
    433     // this should only be called from within a call to reportNmea
    434     jbyte* nmea = (jbyte *)env->GetPrimitiveArrayCritical(nmeaArray, 0);
    435     int length = sNmeaStringLength;
    436     if (length > buffer_size)
    437         length = buffer_size;
    438     memcpy(nmea, sNmeaString, length);
    439     env->ReleasePrimitiveArrayCritical(nmeaArray, nmea, JNI_ABORT);
    440     return length;
    441 }
    442 
    443 static void android_location_GpsLocationProvider_inject_time(JNIEnv* env, jobject obj,
    444         jlong time, jlong timeReference, jint uncertainty)
    445 {
    446     if (sGpsInterface)
    447         sGpsInterface->inject_time(time, timeReference, uncertainty);
    448 }
    449 
    450 static void android_location_GpsLocationProvider_inject_location(JNIEnv* env, jobject obj,
    451         jdouble latitude, jdouble longitude, jfloat accuracy)
    452 {
    453     if (sGpsInterface)
    454         sGpsInterface->inject_location(latitude, longitude, accuracy);
    455 }
    456 
    457 static jboolean android_location_GpsLocationProvider_supports_xtra(JNIEnv* env, jobject obj)
    458 {
    459     return (sGpsXtraInterface != NULL);
    460 }
    461 
    462 static void android_location_GpsLocationProvider_inject_xtra_data(JNIEnv* env, jobject obj,
    463         jbyteArray data, jint length)
    464 {
    465     if (!sGpsXtraInterface) {
    466         ALOGE("no XTRA interface in inject_xtra_data");
    467         return;
    468     }
    469 
    470     jbyte* bytes = (jbyte *)env->GetPrimitiveArrayCritical(data, 0);
    471     sGpsXtraInterface->inject_xtra_data((char *)bytes, length);
    472     env->ReleasePrimitiveArrayCritical(data, bytes, JNI_ABORT);
    473 }
    474 
    475 static void android_location_GpsLocationProvider_agps_data_conn_open(JNIEnv* env, jobject obj, jstring apn)
    476 {
    477     if (!sAGpsInterface) {
    478         ALOGE("no AGPS interface in agps_data_conn_open");
    479         return;
    480     }
    481     if (apn == NULL) {
    482         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
    483         return;
    484     }
    485     const char *apnStr = env->GetStringUTFChars(apn, NULL);
    486     sAGpsInterface->data_conn_open(apnStr);
    487     env->ReleaseStringUTFChars(apn, apnStr);
    488 }
    489 
    490 static void android_location_GpsLocationProvider_agps_data_conn_closed(JNIEnv* env, jobject obj)
    491 {
    492     if (!sAGpsInterface) {
    493         ALOGE("no AGPS interface in agps_data_conn_open");
    494         return;
    495     }
    496     sAGpsInterface->data_conn_closed();
    497 }
    498 
    499 static void android_location_GpsLocationProvider_agps_data_conn_failed(JNIEnv* env, jobject obj)
    500 {
    501     if (!sAGpsInterface) {
    502         ALOGE("no AGPS interface in agps_data_conn_open");
    503         return;
    504     }
    505     sAGpsInterface->data_conn_failed();
    506 }
    507 
    508 static void android_location_GpsLocationProvider_set_agps_server(JNIEnv* env, jobject obj,
    509         jint type, jstring hostname, jint port)
    510 {
    511     if (!sAGpsInterface) {
    512         ALOGE("no AGPS interface in agps_data_conn_open");
    513         return;
    514     }
    515     const char *c_hostname = env->GetStringUTFChars(hostname, NULL);
    516     sAGpsInterface->set_server(type, c_hostname, port);
    517     env->ReleaseStringUTFChars(hostname, c_hostname);
    518 }
    519 
    520 static void android_location_GpsLocationProvider_send_ni_response(JNIEnv* env, jobject obj,
    521       jint notifId, jint response)
    522 {
    523     if (!sGpsNiInterface) {
    524         ALOGE("no NI interface in send_ni_response");
    525         return;
    526     }
    527 
    528     sGpsNiInterface->respond(notifId, response);
    529 }
    530 
    531 static jstring android_location_GpsLocationProvider_get_internal_state(JNIEnv* env, jobject obj)
    532 {
    533     jstring result = NULL;
    534     if (sGpsDebugInterface) {
    535         const size_t maxLength = 2047;
    536         char buffer[maxLength+1];
    537         size_t length = sGpsDebugInterface->get_internal_state(buffer, maxLength);
    538         if (length > maxLength) length = maxLength;
    539         buffer[length] = 0;
    540         result = env->NewStringUTF(buffer);
    541     }
    542     return result;
    543 }
    544 
    545 static void android_location_GpsLocationProvider_update_network_state(JNIEnv* env, jobject obj,
    546         jboolean connected, int type, jboolean roaming, jboolean available, jstring extraInfo, jstring apn)
    547 {
    548 
    549     if (sAGpsRilInterface && sAGpsRilInterface->update_network_state) {
    550         if (extraInfo) {
    551             const char *extraInfoStr = env->GetStringUTFChars(extraInfo, NULL);
    552             sAGpsRilInterface->update_network_state(connected, type, roaming, extraInfoStr);
    553             env->ReleaseStringUTFChars(extraInfo, extraInfoStr);
    554         } else {
    555             sAGpsRilInterface->update_network_state(connected, type, roaming, NULL);
    556         }
    557 
    558         // update_network_availability callback was not included in original AGpsRilInterface
    559         if (sAGpsRilInterface->size >= sizeof(AGpsRilInterface)
    560                 && sAGpsRilInterface->update_network_availability) {
    561             const char *c_apn = env->GetStringUTFChars(apn, NULL);
    562             sAGpsRilInterface->update_network_availability(available, c_apn);
    563             env->ReleaseStringUTFChars(apn, c_apn);
    564         }
    565     }
    566 }
    567 
    568 static JNINativeMethod sMethods[] = {
    569      /* name, signature, funcPtr */
    570     {"class_init_native", "()V", (void *)android_location_GpsLocationProvider_class_init_native},
    571     {"native_is_supported", "()Z", (void*)android_location_GpsLocationProvider_is_supported},
    572     {"native_init", "()Z", (void*)android_location_GpsLocationProvider_init},
    573     {"native_cleanup", "()V", (void*)android_location_GpsLocationProvider_cleanup},
    574     {"native_set_position_mode", "(IIIII)Z", (void*)android_location_GpsLocationProvider_set_position_mode},
    575     {"native_start", "()Z", (void*)android_location_GpsLocationProvider_start},
    576     {"native_stop", "()Z", (void*)android_location_GpsLocationProvider_stop},
    577     {"native_delete_aiding_data", "(I)V", (void*)android_location_GpsLocationProvider_delete_aiding_data},
    578     {"native_read_sv_status", "([I[F[F[F[I)I", (void*)android_location_GpsLocationProvider_read_sv_status},
    579     {"native_read_nmea", "([BI)I", (void*)android_location_GpsLocationProvider_read_nmea},
    580     {"native_inject_time", "(JJI)V", (void*)android_location_GpsLocationProvider_inject_time},
    581     {"native_inject_location", "(DDF)V", (void*)android_location_GpsLocationProvider_inject_location},
    582     {"native_supports_xtra", "()Z", (void*)android_location_GpsLocationProvider_supports_xtra},
    583     {"native_inject_xtra_data", "([BI)V", (void*)android_location_GpsLocationProvider_inject_xtra_data},
    584     {"native_agps_data_conn_open", "(Ljava/lang/String;)V", (void*)android_location_GpsLocationProvider_agps_data_conn_open},
    585     {"native_agps_data_conn_closed", "()V", (void*)android_location_GpsLocationProvider_agps_data_conn_closed},
    586     {"native_agps_data_conn_failed", "()V", (void*)android_location_GpsLocationProvider_agps_data_conn_failed},
    587     {"native_agps_set_id","(ILjava/lang/String;)V",(void*)android_location_GpsLocationProvider_agps_set_id},
    588     {"native_agps_set_ref_location_cellid","(IIIII)V",(void*)android_location_GpsLocationProvider_agps_set_reference_location_cellid},
    589     {"native_set_agps_server", "(ILjava/lang/String;I)V", (void*)android_location_GpsLocationProvider_set_agps_server},
    590     {"native_send_ni_response", "(II)V", (void*)android_location_GpsLocationProvider_send_ni_response},
    591     {"native_agps_ni_message", "([BI)V", (void *)android_location_GpsLocationProvider_agps_send_ni_message},
    592     {"native_get_internal_state", "()Ljava/lang/String;", (void*)android_location_GpsLocationProvider_get_internal_state},
    593     {"native_update_network_state", "(ZIZZLjava/lang/String;Ljava/lang/String;)V", (void*)android_location_GpsLocationProvider_update_network_state },
    594 };
    595 
    596 int register_android_server_location_GpsLocationProvider(JNIEnv* env)
    597 {
    598     return jniRegisterNativeMethods(env, "com/android/server/location/GpsLocationProvider", sMethods, NELEM(sMethods));
    599 }
    600 
    601 } /* namespace android */
    602