692 lines
25 KiB
C++
692 lines
25 KiB
C++
/*
|
|
* Copyright (C) 2008 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define LOG_TAG "GpsLocationProvider"
|
|
|
|
#define LOG_NDEBUG 0
|
|
|
|
#include "JNIHelp.h"
|
|
#include "jni.h"
|
|
#include "hardware/hardware.h"
|
|
#include "hardware/gps.h"
|
|
#include "hardware_legacy/power.h"
|
|
#include "utils/Log.h"
|
|
#include "utils/misc.h"
|
|
#include "android_runtime/AndroidRuntime.h"
|
|
|
|
#include <string.h>
|
|
#include <pthread.h>
|
|
|
|
static jobject mCallbacksObj = NULL;
|
|
|
|
static jmethodID method_reportLocation;
|
|
static jmethodID method_reportStatus;
|
|
static jmethodID method_reportSvStatus;
|
|
static jmethodID method_reportAGpsStatus;
|
|
static jmethodID method_reportNmea;
|
|
static jmethodID method_setEngineCapabilities;
|
|
static jmethodID method_xtraDownloadRequest;
|
|
static jmethodID method_reportNiNotification;
|
|
static jmethodID method_requestRefLocation;
|
|
static jmethodID method_requestSetID;
|
|
|
|
static const GpsInterface* sGpsInterface = NULL;
|
|
static const GpsXtraInterface* sGpsXtraInterface = NULL;
|
|
static const AGpsInterface* sAGpsInterface = NULL;
|
|
static const GpsNiInterface* sGpsNiInterface = NULL;
|
|
static const GpsDebugInterface* sGpsDebugInterface = NULL;
|
|
static const AGpsRilInterface* sAGpsRilInterface = NULL;
|
|
static const InjectRawCmdInterface* sInjectRawCmdInterface = NULL;
|
|
|
|
// temporary storage for GPS callbacks
|
|
static GpsSvStatus sGpsSvStatus;
|
|
static const char* sNmeaString;
|
|
static int sNmeaStringLength;
|
|
|
|
#define WAKE_LOCK_NAME "GPS"
|
|
|
|
namespace android {
|
|
|
|
static void checkAndClearExceptionFromCallback(JNIEnv* env, const char* methodName) {
|
|
if (env->ExceptionCheck()) {
|
|
LOGE("An exception was thrown by callback '%s'.", methodName);
|
|
LOGE_EX(env);
|
|
env->ExceptionClear();
|
|
}
|
|
}
|
|
|
|
static void location_callback(GpsLocation* location)
|
|
{
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
|
|
jbyteArray byteArray = env->NewByteArray(location->rawDataSize);
|
|
LOG_ASSERT(byteArray, "Native could not create new byte[]");
|
|
env->SetByteArrayRegion(byteArray, 0, location->rawDataSize, (const jbyte *) location->rawData );
|
|
env->CallVoidMethod(mCallbacksObj, method_reportLocation, location->flags,
|
|
(jdouble)location->latitude, (jdouble)location->longitude,
|
|
(jdouble)location->altitude,
|
|
(jfloat)location->speed, (jfloat)location->bearing,
|
|
(jfloat)location->accuracy, (jlong)location->timestamp,
|
|
byteArray);
|
|
env->DeleteLocalRef(byteArray);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
static void status_callback(GpsStatus* status)
|
|
{
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
env->CallVoidMethod(mCallbacksObj, method_reportStatus, status->status);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
static void sv_status_callback(GpsSvStatus* sv_status)
|
|
{
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
memcpy(&sGpsSvStatus, sv_status, sizeof(sGpsSvStatus));
|
|
env->CallVoidMethod(mCallbacksObj, method_reportSvStatus);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
static void nmea_callback(GpsUtcTime timestamp, const char* nmea, int length)
|
|
{
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
// The Java code will call back to read these values
|
|
// We do this to avoid creating unnecessary String objects
|
|
sNmeaString = nmea;
|
|
sNmeaStringLength = length;
|
|
env->CallVoidMethod(mCallbacksObj, method_reportNmea, timestamp);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
static void set_capabilities_callback(uint32_t capabilities)
|
|
{
|
|
LOGD("set_capabilities_callback: %ld\n", (long ) capabilities);
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
env->CallVoidMethod(mCallbacksObj, method_setEngineCapabilities, capabilities);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
static void acquire_wakelock_callback()
|
|
{
|
|
acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME);
|
|
}
|
|
|
|
static void release_wakelock_callback()
|
|
{
|
|
release_wake_lock(WAKE_LOCK_NAME);
|
|
}
|
|
|
|
static pthread_t create_thread_callback(const char* name, void (*start)(void *), void* arg)
|
|
{
|
|
return (pthread_t)AndroidRuntime::createJavaThread(name, start, arg);
|
|
}
|
|
|
|
GpsCallbacks sGpsCallbacks = {
|
|
sizeof(GpsCallbacks),
|
|
location_callback,
|
|
status_callback,
|
|
sv_status_callback,
|
|
nmea_callback,
|
|
set_capabilities_callback,
|
|
acquire_wakelock_callback,
|
|
release_wakelock_callback,
|
|
create_thread_callback,
|
|
};
|
|
|
|
static void xtra_download_request_callback()
|
|
{
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
env->CallVoidMethod(mCallbacksObj, method_xtraDownloadRequest);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
GpsXtraCallbacks sGpsXtraCallbacks = {
|
|
xtra_download_request_callback,
|
|
create_thread_callback,
|
|
};
|
|
|
|
static void agps_status_callback(AGpsStatus* agps_status)
|
|
{
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jbyteArray byteArray = env->NewByteArray(16);
|
|
LOG_ASSERT(byteArray, "Native could not create new byte[]");
|
|
|
|
env->SetByteArrayRegion(byteArray, 0, 16, (const jbyte *) agps_status->ipv6_addr );
|
|
env->CallVoidMethod(mCallbacksObj, method_reportAGpsStatus,
|
|
agps_status->type, agps_status->status, agps_status->ipv4_addr, byteArray);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
env->DeleteLocalRef(byteArray);
|
|
}
|
|
|
|
AGpsCallbacks sAGpsCallbacks = {
|
|
agps_status_callback,
|
|
create_thread_callback,
|
|
};
|
|
|
|
static void gps_ni_notify_callback(GpsNiNotification *notification)
|
|
{
|
|
LOGD("gps_ni_notify_callback\n");
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jstring requestor_id = env->NewStringUTF(notification->requestor_id);
|
|
jstring text = env->NewStringUTF(notification->text);
|
|
jstring extras = env->NewStringUTF(notification->extras);
|
|
|
|
if (requestor_id && text && extras) {
|
|
env->CallVoidMethod(mCallbacksObj, method_reportNiNotification,
|
|
notification->notification_id, notification->ni_type,
|
|
notification->notify_flags, notification->timeout,
|
|
notification->default_response, requestor_id, text,
|
|
notification->requestor_id_encoding,
|
|
notification->text_encoding, extras);
|
|
} else {
|
|
LOGE("out of memory in gps_ni_notify_callback\n");
|
|
}
|
|
|
|
if (requestor_id)
|
|
env->DeleteLocalRef(requestor_id);
|
|
if (text)
|
|
env->DeleteLocalRef(text);
|
|
if (extras)
|
|
env->DeleteLocalRef(extras);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
GpsNiCallbacks sGpsNiCallbacks = {
|
|
gps_ni_notify_callback,
|
|
create_thread_callback,
|
|
};
|
|
|
|
static void agps_request_set_id(uint32_t flags)
|
|
{
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
env->CallVoidMethod(mCallbacksObj, method_requestSetID, flags);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
static void agps_request_ref_location(uint32_t flags)
|
|
{
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
env->CallVoidMethod(mCallbacksObj, method_requestRefLocation, flags);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
AGpsRilCallbacks sAGpsRilCallbacks = {
|
|
agps_request_set_id,
|
|
agps_request_ref_location,
|
|
create_thread_callback,
|
|
};
|
|
|
|
static const GpsInterface* get_gps_interface() {
|
|
int err;
|
|
hw_module_t* module;
|
|
const GpsInterface* interface = NULL;
|
|
|
|
err = hw_get_module(GPS_HARDWARE_MODULE_ID, (hw_module_t const**)&module);
|
|
if (err == 0) {
|
|
hw_device_t* device;
|
|
err = module->methods->open(module, GPS_HARDWARE_MODULE_ID, &device);
|
|
if (err == 0) {
|
|
gps_device_t* gps_device = (gps_device_t *)device;
|
|
interface = gps_device->get_gps_interface(gps_device);
|
|
}
|
|
}
|
|
|
|
return interface;
|
|
}
|
|
|
|
static const GpsInterface* GetGpsInterface(JNIEnv* env, jobject obj) {
|
|
// this must be set before calling into the HAL library
|
|
if (!mCallbacksObj)
|
|
mCallbacksObj = env->NewGlobalRef(obj);
|
|
|
|
if (!sGpsInterface) {
|
|
sGpsInterface = get_gps_interface();
|
|
if (!sGpsInterface || sGpsInterface->init(&sGpsCallbacks) != 0) {
|
|
sGpsInterface = NULL;
|
|
return NULL;
|
|
}
|
|
}
|
|
return sGpsInterface;
|
|
}
|
|
|
|
static const AGpsInterface* GetAGpsInterface(JNIEnv* env, jobject obj)
|
|
{
|
|
const GpsInterface* interface = GetGpsInterface(env, obj);
|
|
if (!interface)
|
|
return NULL;
|
|
|
|
if (!sAGpsInterface) {
|
|
sAGpsInterface = (const AGpsInterface*)interface->get_extension(AGPS_INTERFACE);
|
|
if (sAGpsInterface)
|
|
sAGpsInterface->init(&sAGpsCallbacks);
|
|
}
|
|
return sAGpsInterface;
|
|
}
|
|
|
|
static const GpsNiInterface* GetNiInterface(JNIEnv* env, jobject obj)
|
|
{
|
|
const GpsInterface* interface = GetGpsInterface(env, obj);
|
|
if (!interface)
|
|
return NULL;
|
|
|
|
if (!sGpsNiInterface) {
|
|
sGpsNiInterface = (const GpsNiInterface*)interface->get_extension(GPS_NI_INTERFACE);
|
|
if (sGpsNiInterface)
|
|
sGpsNiInterface->init(&sGpsNiCallbacks);
|
|
}
|
|
return sGpsNiInterface;
|
|
}
|
|
|
|
static const AGpsRilInterface* GetAGpsRilInterface(JNIEnv* env, jobject obj)
|
|
{
|
|
const GpsInterface* interface = GetGpsInterface(env, obj);
|
|
if (!interface)
|
|
return NULL;
|
|
|
|
if (!sAGpsRilInterface) {
|
|
sAGpsRilInterface = (const AGpsRilInterface*)interface->get_extension(AGPS_RIL_INTERFACE);
|
|
if (sAGpsRilInterface)
|
|
sAGpsRilInterface->init(&sAGpsRilCallbacks);
|
|
}
|
|
return sAGpsRilInterface;
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_class_init_native(JNIEnv* env, jclass clazz) {
|
|
method_reportLocation = env->GetMethodID(clazz, "reportLocation", "(IDDDFFFJ[B)V");
|
|
method_reportStatus = env->GetMethodID(clazz, "reportStatus", "(I)V");
|
|
method_reportSvStatus = env->GetMethodID(clazz, "reportSvStatus", "()V");
|
|
method_reportAGpsStatus = env->GetMethodID(clazz, "reportAGpsStatus", "(III[B)V");
|
|
method_reportNmea = env->GetMethodID(clazz, "reportNmea", "(J)V");
|
|
method_setEngineCapabilities = env->GetMethodID(clazz, "setEngineCapabilities", "(I)V");
|
|
method_xtraDownloadRequest = env->GetMethodID(clazz, "xtraDownloadRequest", "()V");
|
|
method_reportNiNotification = env->GetMethodID(clazz, "reportNiNotification", "(IIIIILjava/lang/String;Ljava/lang/String;IILjava/lang/String;)V");
|
|
method_requestRefLocation = env->GetMethodID(clazz,"requestRefLocation","(I)V");
|
|
method_requestSetID = env->GetMethodID(clazz,"requestSetID","(I)V");
|
|
}
|
|
|
|
static jboolean android_location_GpsLocationProvider_is_supported(JNIEnv* env, jclass clazz) {
|
|
return (sGpsInterface != NULL || get_gps_interface() != NULL);
|
|
}
|
|
|
|
static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject obj)
|
|
{
|
|
const GpsInterface* interface = GetGpsInterface(env, obj);
|
|
if (!interface)
|
|
return false;
|
|
|
|
if (!sGpsDebugInterface)
|
|
sGpsDebugInterface = (const GpsDebugInterface*)interface->get_extension(GPS_DEBUG_INTERFACE);
|
|
|
|
if (!sInjectRawCmdInterface)
|
|
sInjectRawCmdInterface = (const InjectRawCmdInterface*)interface->get_extension(ULP_RAW_CMD_INTERFACE);
|
|
|
|
//Initialize the interface for AGPS call flow at this point as AGPS connection requests can come
|
|
//in anytime after the main native GPS itnerface is initialized
|
|
if (!sAGpsInterface) {
|
|
sAGpsInterface = (const AGpsInterface*)interface->get_extension(AGPS_INTERFACE);
|
|
if (sAGpsInterface)
|
|
sAGpsInterface->init(&sAGpsCallbacks);
|
|
}
|
|
|
|
//Initialize the interface for AGPS NI call flow at this point as NI call backs may come in
|
|
//anytime after the main native GPS itnerface is initialized
|
|
if (!sGpsNiInterface) {
|
|
sGpsNiInterface = (const GpsNiInterface*)interface->get_extension(GPS_NI_INTERFACE);
|
|
if (sGpsNiInterface)
|
|
{
|
|
sGpsNiInterface->init(&sGpsNiCallbacks);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_cleanup(JNIEnv* env, jobject obj)
|
|
{
|
|
const GpsInterface* interface = GetGpsInterface(env, obj);
|
|
if (interface)
|
|
interface->cleanup();
|
|
}
|
|
|
|
static jboolean android_location_GpsLocationProvider_set_position_mode(JNIEnv* env, jobject obj,
|
|
jint mode, jint recurrence, jint min_interval, jint preferred_accuracy, jint preferred_time)
|
|
{
|
|
const GpsInterface* interface = GetGpsInterface(env, obj);
|
|
if (interface)
|
|
return (interface->set_position_mode(mode, recurrence, min_interval, preferred_accuracy,
|
|
preferred_time) == 0);
|
|
else
|
|
return false;
|
|
}
|
|
|
|
static jboolean android_location_GpsLocationProvider_start(JNIEnv* env, jobject obj)
|
|
{
|
|
const GpsInterface* interface = GetGpsInterface(env, obj);
|
|
if (interface)
|
|
return (interface->start() == 0);
|
|
else
|
|
return false;
|
|
}
|
|
|
|
static jboolean android_location_GpsLocationProvider_stop(JNIEnv* env, jobject obj)
|
|
{
|
|
const GpsInterface* interface = GetGpsInterface(env, obj);
|
|
if (interface)
|
|
return (interface->stop() == 0);
|
|
else
|
|
return false;
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_delete_aiding_data(JNIEnv* env, jobject obj, jint flags)
|
|
{
|
|
const GpsInterface* interface = GetGpsInterface(env, obj);
|
|
if (interface)
|
|
interface->delete_aiding_data(flags);
|
|
}
|
|
|
|
static jint android_location_GpsLocationProvider_read_sv_status(JNIEnv* env, jobject obj,
|
|
jintArray prnArray, jfloatArray snrArray, jfloatArray elevArray, jfloatArray azumArray,
|
|
jintArray maskArray)
|
|
{
|
|
// this should only be called from within a call to reportSvStatus
|
|
|
|
jint* prns = env->GetIntArrayElements(prnArray, 0);
|
|
jfloat* snrs = env->GetFloatArrayElements(snrArray, 0);
|
|
jfloat* elev = env->GetFloatArrayElements(elevArray, 0);
|
|
jfloat* azim = env->GetFloatArrayElements(azumArray, 0);
|
|
jint* mask = env->GetIntArrayElements(maskArray, 0);
|
|
|
|
int num_svs = sGpsSvStatus.num_svs;
|
|
for (int i = 0; i < num_svs; i++) {
|
|
prns[i] = sGpsSvStatus.sv_list[i].prn;
|
|
snrs[i] = sGpsSvStatus.sv_list[i].snr;
|
|
elev[i] = sGpsSvStatus.sv_list[i].elevation;
|
|
azim[i] = sGpsSvStatus.sv_list[i].azimuth;
|
|
}
|
|
mask[0] = sGpsSvStatus.ephemeris_mask;
|
|
mask[1] = sGpsSvStatus.almanac_mask;
|
|
mask[2] = sGpsSvStatus.used_in_fix_mask;
|
|
|
|
env->ReleaseIntArrayElements(prnArray, prns, 0);
|
|
env->ReleaseFloatArrayElements(snrArray, snrs, 0);
|
|
env->ReleaseFloatArrayElements(elevArray, elev, 0);
|
|
env->ReleaseFloatArrayElements(azumArray, azim, 0);
|
|
env->ReleaseIntArrayElements(maskArray, mask, 0);
|
|
return num_svs;
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_agps_set_reference_location_cellid(JNIEnv* env,
|
|
jobject obj, jint type, jint mcc, jint mnc, jint lac, jint cid)
|
|
{
|
|
AGpsRefLocation location;
|
|
const AGpsRilInterface* interface = GetAGpsRilInterface(env, obj);
|
|
if (!interface || !interface->set_ref_location) {
|
|
LOGE("no AGPS RIL interface in agps_set_reference_location_cellid");
|
|
return;
|
|
}
|
|
|
|
switch(type) {
|
|
case AGPS_REF_LOCATION_TYPE_GSM_CELLID:
|
|
case AGPS_REF_LOCATION_TYPE_UMTS_CELLID:
|
|
location.type = type;
|
|
location.u.cellID.mcc = mcc;
|
|
location.u.cellID.mnc = mnc;
|
|
location.u.cellID.lac = lac;
|
|
location.u.cellID.cid = cid;
|
|
break;
|
|
default:
|
|
LOGE("Neither a GSM nor a UMTS cellid (%s:%d).",__FUNCTION__,__LINE__);
|
|
return;
|
|
break;
|
|
}
|
|
interface->set_ref_location(&location, sizeof(location));
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_agps_send_ni_message(JNIEnv* env,
|
|
jobject obj, jbyteArray ni_msg, jint size)
|
|
{
|
|
size_t sz;
|
|
const AGpsRilInterface* interface = GetAGpsRilInterface(env, obj);
|
|
if (!interface || !interface->ni_message) {
|
|
LOGE("no AGPS RIL interface in send_ni_message");
|
|
return;
|
|
}
|
|
if (size < 0)
|
|
return;
|
|
sz = (size_t)size;
|
|
jbyte* b = env->GetByteArrayElements(ni_msg, 0);
|
|
interface->ni_message((uint8_t *)b,sz);
|
|
env->ReleaseByteArrayElements(ni_msg,b,0);
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_agps_set_id(JNIEnv *env,
|
|
jobject obj, jint type, jstring setid_string)
|
|
{
|
|
const AGpsRilInterface* interface = GetAGpsRilInterface(env, obj);
|
|
if (!interface || !interface->set_set_id) {
|
|
LOGE("no AGPS RIL interface in agps_set_id");
|
|
return;
|
|
}
|
|
|
|
const char *setid = env->GetStringUTFChars(setid_string, NULL);
|
|
interface->set_set_id(type, setid);
|
|
env->ReleaseStringUTFChars(setid_string, setid);
|
|
}
|
|
|
|
static jint android_location_GpsLocationProvider_read_nmea(JNIEnv* env, jobject obj,
|
|
jbyteArray nmeaArray, jint buffer_size)
|
|
{
|
|
// this should only be called from within a call to reportNmea
|
|
jbyte* nmea = (jbyte *)env->GetPrimitiveArrayCritical(nmeaArray, 0);
|
|
int length = sNmeaStringLength;
|
|
if (length > buffer_size)
|
|
length = buffer_size;
|
|
memcpy(nmea, sNmeaString, length);
|
|
env->ReleasePrimitiveArrayCritical(nmeaArray, nmea, JNI_ABORT);
|
|
return length;
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_inject_time(JNIEnv* env, jobject obj,
|
|
jlong time, jlong timeReference, jint uncertainty)
|
|
{
|
|
const GpsInterface* interface = GetGpsInterface(env, obj);
|
|
if (interface)
|
|
interface->inject_time(time, timeReference, uncertainty);
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_inject_location(JNIEnv* env, jobject obj,
|
|
jdouble latitude, jdouble longitude, jfloat accuracy)
|
|
{
|
|
const GpsInterface* interface = GetGpsInterface(env, obj);
|
|
if (interface)
|
|
interface->inject_location(latitude, longitude, accuracy);
|
|
}
|
|
|
|
static jboolean android_location_GpsLocationProvider_supports_xtra(JNIEnv* env, jobject obj)
|
|
{
|
|
if (!sGpsXtraInterface) {
|
|
const GpsInterface* interface = GetGpsInterface(env, obj);
|
|
if (!interface)
|
|
return false;
|
|
sGpsXtraInterface = (const GpsXtraInterface*)interface->get_extension(GPS_XTRA_INTERFACE);
|
|
if (sGpsXtraInterface) {
|
|
int result = sGpsXtraInterface->init(&sGpsXtraCallbacks);
|
|
if (result) {
|
|
sGpsXtraInterface = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (sGpsXtraInterface != NULL);
|
|
}
|
|
|
|
static jboolean android_location_GpsLocationProvider_inject_raw_command(JNIEnv* env, jobject obj, jbyteArray data, jint length)
|
|
{
|
|
jboolean result = false;
|
|
|
|
if (sInjectRawCmdInterface) {
|
|
if (data != NULL) {
|
|
jbyte* bytes = env->GetByteArrayElements(data, 0);
|
|
result = sInjectRawCmdInterface->inject_raw_cmd((char *)bytes, length);
|
|
env->ReleaseByteArrayElements(data, bytes, 0);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_inject_xtra_data(JNIEnv* env, jobject obj,
|
|
jbyteArray data, jint length)
|
|
{
|
|
jbyte* bytes = (jbyte *)env->GetPrimitiveArrayCritical(data, 0);
|
|
sGpsXtraInterface->inject_xtra_data((char *)bytes, length);
|
|
env->ReleasePrimitiveArrayCritical(data, bytes, JNI_ABORT);
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_agps_data_conn_open(JNIEnv* env, jobject obj,
|
|
jint agpsType, jstring apn, jint bearerType)
|
|
{
|
|
const AGpsInterface* interface = GetAGpsInterface(env, obj);
|
|
if (!interface) {
|
|
LOGE("no AGPS interface in agps_data_conn_open");
|
|
return;
|
|
}
|
|
if (apn == NULL) {
|
|
jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
|
|
return;
|
|
}
|
|
const char *apnStr = env->GetStringUTFChars(apn, NULL);
|
|
interface->data_conn_open(agpsType, apnStr, bearerType);
|
|
env->ReleaseStringUTFChars(apn, apnStr);
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_agps_data_conn_closed(JNIEnv* env, jobject obj,
|
|
jint agpsType)
|
|
{
|
|
const AGpsInterface* interface = GetAGpsInterface(env, obj);
|
|
if (!interface) {
|
|
LOGE("no AGPS interface in agps_data_conn_open");
|
|
return;
|
|
}
|
|
interface->data_conn_closed(agpsType);
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_agps_data_conn_failed(JNIEnv* env, jobject obj,
|
|
jint agpsType)
|
|
{
|
|
const AGpsInterface* interface = GetAGpsInterface(env, obj);
|
|
if (!interface) {
|
|
LOGE("no AGPS interface in agps_data_conn_open");
|
|
return;
|
|
}
|
|
interface->data_conn_failed(agpsType);
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_set_agps_server(JNIEnv* env, jobject obj,
|
|
jint type, jstring hostname, jint port)
|
|
{
|
|
const AGpsInterface* interface = GetAGpsInterface(env, obj);
|
|
if (!interface) {
|
|
LOGE("no AGPS interface in agps_data_conn_open");
|
|
return;
|
|
}
|
|
const char *c_hostname = env->GetStringUTFChars(hostname, NULL);
|
|
interface->set_server(type, c_hostname, port);
|
|
env->ReleaseStringUTFChars(hostname, c_hostname);
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_send_ni_response(JNIEnv* env, jobject obj,
|
|
jint notifId, jint response)
|
|
{
|
|
const GpsNiInterface* interface = GetNiInterface(env, obj);
|
|
if (!interface) {
|
|
LOGE("no NI interface in send_ni_response");
|
|
return;
|
|
}
|
|
|
|
interface->respond(notifId, response);
|
|
}
|
|
|
|
static jstring android_location_GpsLocationProvider_get_internal_state(JNIEnv* env, jobject obj)
|
|
{
|
|
jstring result = NULL;
|
|
if (sGpsDebugInterface) {
|
|
const size_t maxLength = 2047;
|
|
char buffer[maxLength+1];
|
|
size_t length = sGpsDebugInterface->get_internal_state(buffer, maxLength);
|
|
if (length > maxLength) length = maxLength;
|
|
buffer[length] = 0;
|
|
result = env->NewStringUTF(buffer);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static void android_location_GpsLocationProvider_update_network_state(JNIEnv* env, jobject obj,
|
|
jboolean connected, int type, jboolean roaming, jboolean available, jstring extraInfo, jstring apn)
|
|
{
|
|
const AGpsRilInterface* interface = GetAGpsRilInterface(env, obj);
|
|
if (interface && interface->update_network_state) {
|
|
if (extraInfo) {
|
|
const char *extraInfoStr = env->GetStringUTFChars(extraInfo, NULL);
|
|
interface->update_network_state(connected, type, roaming, extraInfoStr);
|
|
env->ReleaseStringUTFChars(extraInfo, extraInfoStr);
|
|
} else {
|
|
interface->update_network_state(connected, type, roaming, NULL);
|
|
}
|
|
|
|
if (interface->update_network_availability) {
|
|
const char *c_apn = env->GetStringUTFChars(apn, NULL);
|
|
interface->update_network_availability(available, c_apn);
|
|
env->ReleaseStringUTFChars(apn, c_apn);
|
|
}
|
|
}
|
|
}
|
|
|
|
static JNINativeMethod sMethods[] = {
|
|
/* name, signature, funcPtr */
|
|
{"class_init_native", "()V", (void *)android_location_GpsLocationProvider_class_init_native},
|
|
{"native_is_supported", "()Z", (void*)android_location_GpsLocationProvider_is_supported},
|
|
{"native_init", "()Z", (void*)android_location_GpsLocationProvider_init},
|
|
{"native_cleanup", "()V", (void*)android_location_GpsLocationProvider_cleanup},
|
|
{"native_set_position_mode", "(IIIII)Z", (void*)android_location_GpsLocationProvider_set_position_mode},
|
|
{"native_start", "()Z", (void*)android_location_GpsLocationProvider_start},
|
|
{"native_stop", "()Z", (void*)android_location_GpsLocationProvider_stop},
|
|
{"native_delete_aiding_data", "(I)V", (void*)android_location_GpsLocationProvider_delete_aiding_data},
|
|
{"native_read_sv_status", "([I[F[F[F[I)I", (void*)android_location_GpsLocationProvider_read_sv_status},
|
|
{"native_read_nmea", "([BI)I", (void*)android_location_GpsLocationProvider_read_nmea},
|
|
{"native_inject_time", "(JJI)V", (void*)android_location_GpsLocationProvider_inject_time},
|
|
{"native_inject_location", "(DDF)V", (void*)android_location_GpsLocationProvider_inject_location},
|
|
{"native_supports_xtra", "()Z", (void*)android_location_GpsLocationProvider_supports_xtra},
|
|
{"native_inject_xtra_data", "([BI)V", (void*)android_location_GpsLocationProvider_inject_xtra_data},
|
|
{"native_inject_raw_command", "([BI)Z", (void*)android_location_GpsLocationProvider_inject_raw_command},
|
|
{"native_agps_data_conn_open", "(ILjava/lang/String;I)V", (void*)android_location_GpsLocationProvider_agps_data_conn_open},
|
|
{"native_agps_data_conn_closed", "(I)V", (void*)android_location_GpsLocationProvider_agps_data_conn_closed},
|
|
{"native_agps_data_conn_failed", "(I)V", (void*)android_location_GpsLocationProvider_agps_data_conn_failed},
|
|
{"native_agps_set_id","(ILjava/lang/String;)V",(void*)android_location_GpsLocationProvider_agps_set_id},
|
|
{"native_agps_set_ref_location_cellid","(IIIII)V",(void*)android_location_GpsLocationProvider_agps_set_reference_location_cellid},
|
|
{"native_set_agps_server", "(ILjava/lang/String;I)V", (void*)android_location_GpsLocationProvider_set_agps_server},
|
|
{"native_send_ni_response", "(II)V", (void*)android_location_GpsLocationProvider_send_ni_response},
|
|
{"native_agps_ni_message", "([BI)V", (void *)android_location_GpsLocationProvider_agps_send_ni_message},
|
|
{"native_get_internal_state", "()Ljava/lang/String;", (void*)android_location_GpsLocationProvider_get_internal_state},
|
|
{"native_update_network_state", "(ZIZZLjava/lang/String;Ljava/lang/String;)V", (void*)android_location_GpsLocationProvider_update_network_state },
|
|
};
|
|
|
|
int register_android_server_location_GpsLocationProvider(JNIEnv* env)
|
|
{
|
|
return jniRegisterNativeMethods(env, "com/android/server/location/GpsLocationProvider", sMethods, NELEM(sMethods));
|
|
}
|
|
|
|
} /* namespace android */
|