frameworks/base/services/jni/com_android_server_location_GpsLocationProvider.cpp

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