am aaf39f84: Merge "GPS: remove GpsEventThread from GpsLocationProvider" into gingerbread (dae19d7c) · Commits · e / os / android_frameworks_base

core/jni/AndroidRuntime.cpp

+4 −2

Original line number	Original line	Diff line number	Diff line
	@@ -1136,11 +1136,13 @@ static int javaDetachThread(void)
	*		*
	* This is called from elsewhere in the library.		* This is called from elsewhere in the library.
	*/		*/
	/static/ void AndroidRuntime::createJavaThread(const char* name,		/static/ android_thread_id_t AndroidRuntime::createJavaThread(const char* name,
	void (start)(void ), void* arg)		void (start)(void ), void* arg)
	{		{
			android_thread_id_t threadId = 0;
	javaCreateThreadEtc((android_thread_func_t) start, arg, name,		javaCreateThreadEtc((android_thread_func_t) start, arg, name,
	ANDROID_PRIORITY_DEFAULT, 0, NULL);		ANDROID_PRIORITY_DEFAULT, 0, &threadId);
			return threadId;
	}		}

	#if 0		#if 0

include/android_runtime/AndroidRuntime.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -87,7 +87,7 @@ public:
	virtual void onExit(int code);		virtual void onExit(int code);

	/** create a new thread that is visible from Java */		/** create a new thread that is visible from Java */
	static void createJavaThread(const char* name, void (start)(void ),		static android_thread_id_t createJavaThread(const char* name, void (start)(void ),
	void* arg);		void* arg);

	/** return a pointer to the VM running in this process */		/** return a pointer to the VM running in this process */

services/java/com/android/server/location/GpsLocationProvider.java

+3 −53

Original line number	Original line	Diff line number	Diff line
	@@ -226,8 +226,6 @@ public class GpsLocationProvider implements LocationProviderInterface {
	private Handler mHandler;		private Handler mHandler;
	// Used to signal when our main thread has initialized everything		// Used to signal when our main thread has initialized everything
	private final CountDownLatch mInitializedLatch = new CountDownLatch(1);		private final CountDownLatch mInitializedLatch = new CountDownLatch(1);
	// Thread for receiving events from the native code
	private Thread mEventThread;

	private String mAGpsApn;		private String mAGpsApn;
	private int mAGpsDataConnectionState;		private int mAGpsDataConnectionState;
	@@ -643,10 +641,6 @@ public class GpsLocationProvider implements LocationProviderInterface {
	if (mC2KServerHost != null) {		if (mC2KServerHost != null) {
	native_set_agps_server(AGPS_TYPE_C2K, mC2KServerHost, mC2KServerPort);		native_set_agps_server(AGPS_TYPE_C2K, mC2KServerHost, mC2KServerPort);
	}		}

	// run event listener thread while we are enabled
	mEventThread = new GpsEventThread();
	mEventThread.start();
	} else {		} else {
	Log.w(TAG, "Failed to enable location provider");		Log.w(TAG, "Failed to enable location provider");
	}		}
	@@ -669,29 +663,9 @@ public class GpsLocationProvider implements LocationProviderInterface {

	mEnabled = false;		mEnabled = false;
	stopNavigating();		stopNavigating();
	native_disable();

	// make sure our event thread exits
	if (mEventThread != null) {
	try {
	mEventThread.join();
	} catch (InterruptedException e) {
	Log.w(TAG, "InterruptedException when joining mEventThread");
	}
	mEventThread = null;
	}

	// do this before releasing wakelock		// do this before releasing wakelock
	native_cleanup();		native_cleanup();

	// The GpsEventThread does not wait for the GPS to shutdown
	// so we need to report the GPS_STATUS_ENGINE_OFF event here
	if (mNavigating) {
	reportStatus(GPS_STATUS_SESSION_END);
	}
	if (mEngineOn) {
	reportStatus(GPS_STATUS_ENGINE_OFF);
	}
	}		}

	public boolean isEnabled() {		public boolean isEnabled() {
	@@ -1231,12 +1205,12 @@ public class GpsLocationProvider implements LocationProviderInterface {
	/**		/**
	* called from native code to report NMEA data received		* called from native code to report NMEA data received
	*/		*/
	private void reportNmea(int index, long timestamp) {		private void reportNmea(long timestamp) {
	synchronized(mListeners) {		synchronized(mListeners) {
	int size = mListeners.size();		int size = mListeners.size();
	if (size > 0) {		if (size > 0) {
	// don't bother creating the String if we have no listeners		// don't bother creating the String if we have no listeners
	int length = native_read_nmea(index, mNmeaBuffer, mNmeaBuffer.length);		int length = native_read_nmea(mNmeaBuffer, mNmeaBuffer.length);
	String nmea = new String(mNmeaBuffer, 0, length);		String nmea = new String(mNmeaBuffer, 0, length);

	for (int i = 0; i < size; i++) {		for (int i = 0; i < size; i++) {
	@@ -1359,28 +1333,6 @@ public class GpsLocationProvider implements LocationProviderInterface {
	mNIHandler.handleNiNotification(notification);		mNIHandler.handleNiNotification(notification);
	}		}

	// this thread is used to receive events from the native code.
	// native_wait_for_event() will callback to us via reportLocation(), reportStatus(), etc.
	// this is necessary because native code cannot call Java on a thread that the JVM does
	// not know about.
	private final class GpsEventThread extends Thread {

	public GpsEventThread() {
	super("GpsEventThread");
	}

	public void run() {
	if (DEBUG) Log.d(TAG, "GpsEventThread starting");
	// Exit as soon as disable() is called instead of waiting for the GPS to stop.
	while (mEnabled) {
	// this will wait for an event from the GPS,
	// which will be reported via reportLocation or reportStatus
	native_wait_for_event();
	}
	if (DEBUG) Log.d(TAG, "GpsEventThread exiting");
	}
	}

	private void sendMessage(int message, int arg, Object obj) {		private void sendMessage(int message, int arg, Object obj) {
	// hold a wake lock while messages are pending		// hold a wake lock while messages are pending
	synchronized (mWakeLock) {		synchronized (mWakeLock) {
	@@ -1485,19 +1437,17 @@ public class GpsLocationProvider implements LocationProviderInterface {
	private static native boolean native_is_supported();		private static native boolean native_is_supported();

	private native boolean native_init();		private native boolean native_init();
	private native void native_disable();
	private native void native_cleanup();		private native void native_cleanup();
	private native boolean native_set_position_mode(int mode, int recurrence, int min_interval,		private native boolean native_set_position_mode(int mode, int recurrence, int min_interval,
	int preferred_accuracy, int preferred_time);		int preferred_accuracy, int preferred_time);
	private native boolean native_start();		private native boolean native_start();
	private native boolean native_stop();		private native boolean native_stop();
	private native void native_delete_aiding_data(int flags);		private native void native_delete_aiding_data(int flags);
	private native void native_wait_for_event();
	// returns number of SVs		// returns number of SVs
	// mask[0] is ephemeris mask and mask[1] is almanac mask		// mask[0] is ephemeris mask and mask[1] is almanac mask
	private native int native_read_sv_status(int[] svs, float[] snrs,		private native int native_read_sv_status(int[] svs, float[] snrs,
	float[] elevations, float[] azimuths, int[] masks);		float[] elevations, float[] azimuths, int[] masks);
	private native int native_read_nmea(int index, byte[] buffer, int bufferSize);		private native int native_read_nmea(byte[] buffer, int bufferSize);
	private native void native_inject_location(double latitude, double longitude, float accuracy);		private native void native_inject_location(double latitude, double longitude, float accuracy);

	// XTRA Support		// XTRA Support

services/jni/com_android_server_location_GpsLocationProvider.cpp

+124 −233

Original line number	Original line	Diff line number	Diff line
	@@ -25,12 +25,13 @@
	#include "hardware_legacy/power.h"		#include "hardware_legacy/power.h"
	#include "utils/Log.h"		#include "utils/Log.h"
	#include "utils/misc.h"		#include "utils/misc.h"
			#include "android_runtime/AndroidRuntime.h"

	#include <string.h>		#include <string.h>
	#include <pthread.h>		#include <pthread.h>

	static pthread_mutex_t sEventMutex = PTHREAD_MUTEX_INITIALIZER;		static jobject mCallbacksObj = NULL;
	static pthread_cond_t sEventCond = PTHREAD_COND_INITIALIZER;
	static jmethodID method_reportLocation;		static jmethodID method_reportLocation;
	static jmethodID method_reportStatus;		static jmethodID method_reportStatus;
	static jmethodID method_reportSvStatus;		static jmethodID method_reportSvStatus;
	@@ -46,140 +47,89 @@ static const AGpsInterface* sAGpsInterface = NULL;
	static const GpsNiInterface* sGpsNiInterface = NULL;		static const GpsNiInterface* sGpsNiInterface = NULL;
	static const GpsDebugInterface* sGpsDebugInterface = NULL;		static const GpsDebugInterface* sGpsDebugInterface = NULL;

	// data written to by GPS callbacks		// temporary storage for GPS callbacks
	static GpsLocation sGpsLocation;
	static GpsStatus sGpsStatus;
	static GpsSvStatus sGpsSvStatus;		static GpsSvStatus sGpsSvStatus;
	static AGpsStatus sAGpsStatus;		static const char* sNmeaString;
	static GpsNiNotification sGpsNiNotification;		static int sNmeaStringLength;

	#define WAKE_LOCK_NAME "GPS"		#define WAKE_LOCK_NAME "GPS"

	// buffer for NMEA data
	#define NMEA_SENTENCE_LENGTH 100
	#define NMEA_SENTENCE_COUNT 40
	struct NmeaSentence {
	GpsUtcTime timestamp;
	char nmea[NMEA_SENTENCE_LENGTH];
	};
	static NmeaSentence sNmeaBuffer[NMEA_SENTENCE_COUNT];
	static int mNmeaSentenceCount = 0;

	// a copy of the data shared by android_location_GpsLocationProvider_wait_for_event
	// and android_location_GpsLocationProvider_read_status
	static GpsLocation sGpsLocationCopy;
	static GpsStatus sGpsStatusCopy;
	static GpsSvStatus sGpsSvStatusCopy;
	static AGpsStatus sAGpsStatusCopy;
	static NmeaSentence sNmeaBufferCopy[NMEA_SENTENCE_COUNT];
	static GpsNiNotification sGpsNiNotificationCopy;
	static uint32_t sEngineCapabilities;


	enum CallbackType {
	kLocation = 1,
	kStatus = 2,
	kSvStatus = 4,
	kAGpsStatus = 8,
	kXtraDownloadRequest = 16,
	kDisableRequest = 32,
	kNmeaAvailable = 64,
	kNiNotification = 128,
	kSetCapabilities = 256,
	};
	static int sPendingCallbacks;

	namespace android {		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)		static void location_callback(GpsLocation* location)
	{		{
	pthread_mutex_lock(&sEventMutex);		LOGD("location_callback\n");
			JNIEnv* env = AndroidRuntime::getJNIEnv();
	sPendingCallbacks \|= kLocation;		env->CallVoidMethod(mCallbacksObj, method_reportLocation, location->flags,
	memcpy(&sGpsLocation, location, sizeof(sGpsLocation));		(jdouble)location->latitude, (jdouble)location->longitude,
			(jdouble)location->altitude,
	pthread_cond_signal(&sEventCond);		(jfloat)location->speed, (jfloat)location->bearing,
	pthread_mutex_unlock(&sEventMutex);		(jfloat)location->accuracy, (jlong)location->timestamp);
			checkAndClearExceptionFromCallback(env, __FUNCTION__);
	}		}

	static void status_callback(GpsStatus* status)		static void status_callback(GpsStatus* status)
	{		{
	pthread_mutex_lock(&sEventMutex);		LOGD("status_callback\n");
			JNIEnv* env = AndroidRuntime::getJNIEnv();
	sPendingCallbacks \|= kStatus;		LOGD("env: %p obj: %p\n", env, mCallbacksObj);
	memcpy(&sGpsStatus, status, sizeof(sGpsStatus));		env->CallVoidMethod(mCallbacksObj, method_reportStatus, status->status);
			checkAndClearExceptionFromCallback(env, __FUNCTION__);
	pthread_cond_signal(&sEventCond);
	pthread_mutex_unlock(&sEventMutex);
	}		}

	static void sv_status_callback(GpsSvStatus* sv_status)		static void sv_status_callback(GpsSvStatus* sv_status)
	{		{
	pthread_mutex_lock(&sEventMutex);		LOGD("sv_status_callback\n");
			JNIEnv* env = AndroidRuntime::getJNIEnv();
	sPendingCallbacks \|= kSvStatus;		memcpy(&sGpsSvStatus, sv_status, sizeof(sGpsSvStatus));
	memcpy(&sGpsSvStatus, sv_status, sizeof(GpsSvStatus));		env->CallVoidMethod(mCallbacksObj, method_reportSvStatus);
			checkAndClearExceptionFromCallback(env, __FUNCTION__);
	pthread_cond_signal(&sEventCond);
	pthread_mutex_unlock(&sEventMutex);
	}		}

	static void nmea_callback(GpsUtcTime timestamp, const char* nmea, int length)		static void nmea_callback(GpsUtcTime timestamp, const char* nmea, int length)
	{		{
	pthread_mutex_lock(&sEventMutex);		LOGD("nmea_callback\n");
			JNIEnv* env = AndroidRuntime::getJNIEnv();
	if (length >= NMEA_SENTENCE_LENGTH) {		// The Java code will call back to read these values
	LOGE("NMEA data too long in nmea_callback (length = %d)\n", length);		// We do this to avoid creating unnecessary String objects
	length = NMEA_SENTENCE_LENGTH - 1;		sNmeaString = nmea;
	}		sNmeaStringLength = length;
	if (mNmeaSentenceCount >= NMEA_SENTENCE_COUNT) {		env->CallVoidMethod(mCallbacksObj, method_reportNmea, timestamp);
	LOGE("NMEA data overflowed buffer\n");		checkAndClearExceptionFromCallback(env, __FUNCTION__);
	pthread_mutex_unlock(&sEventMutex);
	return;
	}

	sPendingCallbacks \|= kNmeaAvailable;
	sNmeaBuffer[mNmeaSentenceCount].timestamp = timestamp;
	memcpy(sNmeaBuffer[mNmeaSentenceCount].nmea, nmea, length);
	sNmeaBuffer[mNmeaSentenceCount].nmea[length] = 0;
	mNmeaSentenceCount++;

	pthread_cond_signal(&sEventCond);
	pthread_mutex_unlock(&sEventMutex);
	}		}

	static void set_capabilities_callback(uint32_t capabilities)		static void set_capabilities_callback(uint32_t capabilities)
	{		{
	LOGD("set_capabilities_callback: %08X", capabilities);		LOGD("set_capabilities_callback\n");
			JNIEnv* env = AndroidRuntime::getJNIEnv();
	pthread_mutex_lock(&sEventMutex);		env->CallVoidMethod(mCallbacksObj, method_setEngineCapabilities, capabilities);
			checkAndClearExceptionFromCallback(env, __FUNCTION__);
	sPendingCallbacks \|= kSetCapabilities;
	sEngineCapabilities = capabilities;

	pthread_cond_signal(&sEventCond);
	pthread_mutex_unlock(&sEventMutex);
	}		}

	static void acquire_wakelock_callback()		static void acquire_wakelock_callback()
	{		{
			LOGD("acquire_wakelock_callback\n");
	acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME);		acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME);
	}		}

	static void release_wakelock_callback()		static void release_wakelock_callback()
	{		{
			LOGD("release_wakelock_callback\n");
	release_wake_lock(WAKE_LOCK_NAME);		release_wake_lock(WAKE_LOCK_NAME);
	}		}

	static void agps_status_callback(AGpsStatus* agps_status)		static pthread_t create_thread_callback(const char* name, void (start)(void ), void* arg)
	{		{
	pthread_mutex_lock(&sEventMutex);		LOGD("create_thread_callback\n");
			return (pthread_t)AndroidRuntime::createJavaThread(name, start, arg);
	sPendingCallbacks \|= kAGpsStatus;
	memcpy(&sAGpsStatus, agps_status, sizeof(AGpsStatus));

	pthread_cond_signal(&sEventCond);
	pthread_mutex_unlock(&sEventMutex);
	}		}

	GpsCallbacks sGpsCallbacks = {		GpsCallbacks sGpsCallbacks = {
	@@ -191,41 +141,67 @@ GpsCallbacks sGpsCallbacks = {
	set_capabilities_callback,		set_capabilities_callback,
	acquire_wakelock_callback,		acquire_wakelock_callback,
	release_wakelock_callback,		release_wakelock_callback,
			create_thread_callback,
	};		};

	static void		static void xtra_download_request_callback()
	download_request_callback()
	{		{
	pthread_mutex_lock(&sEventMutex);		LOGD("xtra_download_request_callback\n");
	sPendingCallbacks \|= kXtraDownloadRequest;		JNIEnv* env = AndroidRuntime::getJNIEnv();
	pthread_cond_signal(&sEventCond);		env->CallVoidMethod(mCallbacksObj, method_xtraDownloadRequest);
	pthread_mutex_unlock(&sEventMutex);		checkAndClearExceptionFromCallback(env, __FUNCTION__);
	}

	static void
	gps_ni_notify_callback(GpsNiNotification *notification)
	{
	LOGD("gps_ni_notify_callback: notif=%d", notification->notification_id);

	pthread_mutex_lock(&sEventMutex);

	sPendingCallbacks \|= kNiNotification;
	memcpy(&sGpsNiNotification, notification, sizeof(GpsNiNotification));

	pthread_cond_signal(&sEventCond);
	pthread_mutex_unlock(&sEventMutex);
	}		}

	GpsXtraCallbacks sGpsXtraCallbacks = {		GpsXtraCallbacks sGpsXtraCallbacks = {
	download_request_callback,		xtra_download_request_callback,
			create_thread_callback,
	};		};

			static void agps_status_callback(AGpsStatus* agps_status)
			{
			LOGD("agps_status_callback\n");
			JNIEnv* env = AndroidRuntime::getJNIEnv();
			env->CallVoidMethod(mCallbacksObj, method_reportAGpsStatus,
			agps_status->type, agps_status->status);
			checkAndClearExceptionFromCallback(env, __FUNCTION__);
			}

	AGpsCallbacks sAGpsCallbacks = {		AGpsCallbacks sAGpsCallbacks = {
	agps_status_callback,		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 = {		GpsNiCallbacks sGpsNiCallbacks = {
	gps_ni_notify_callback,		gps_ni_notify_callback,
			create_thread_callback,
	};		};

	static void android_location_GpsLocationProvider_class_init_native(JNIEnv* env, jclass clazz) {		static void android_location_GpsLocationProvider_class_init_native(JNIEnv* env, jclass clazz) {
	@@ -233,7 +209,7 @@ static void android_location_GpsLocationProvider_class_init_native(JNIEnv* env,
	method_reportStatus = env->GetMethodID(clazz, "reportStatus", "(I)V");		method_reportStatus = env->GetMethodID(clazz, "reportStatus", "(I)V");
	method_reportSvStatus = env->GetMethodID(clazz, "reportSvStatus", "()V");		method_reportSvStatus = env->GetMethodID(clazz, "reportSvStatus", "()V");
	method_reportAGpsStatus = env->GetMethodID(clazz, "reportAGpsStatus", "(II)V");		method_reportAGpsStatus = env->GetMethodID(clazz, "reportAGpsStatus", "(II)V");
	method_reportNmea = env->GetMethodID(clazz, "reportNmea", "(IJ)V");		method_reportNmea = env->GetMethodID(clazz, "reportNmea", "(J)V");
	method_setEngineCapabilities = env->GetMethodID(clazz, "setEngineCapabilities", "(I)V");		method_setEngineCapabilities = env->GetMethodID(clazz, "setEngineCapabilities", "(I)V");
	method_xtraDownloadRequest = env->GetMethodID(clazz, "xtraDownloadRequest", "()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_reportNiNotification = env->GetMethodID(clazz, "reportNiNotification", "(IIIIILjava/lang/String;Ljava/lang/String;IILjava/lang/String;)V");
	@@ -265,6 +241,12 @@ static jboolean android_location_GpsLocationProvider_is_supported(JNIEnv* env, j

	static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject obj)		static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject obj)
	{		{
			LOGD("android_location_GpsLocationProvider_init obj: %p\n", obj);

			// this must be set before calling into the HAL library
			if (!mCallbacksObj)
			mCallbacksObj = env->NewGlobalRef(obj);

	if (!sGpsInterface)		if (!sGpsInterface)
	sGpsInterface = get_gps_interface();		sGpsInterface = get_gps_interface();
	if (!sGpsInterface \|\| sGpsInterface->init(&sGpsCallbacks) != 0)		if (!sGpsInterface \|\| sGpsInterface->init(&sGpsCallbacks) != 0)
	@@ -286,14 +268,6 @@ static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject o
	return true;		return true;
	}		}

	static void android_location_GpsLocationProvider_disable(JNIEnv* env, jobject obj)
	{
	pthread_mutex_lock(&sEventMutex);
	sPendingCallbacks \|= kDisableRequest;
	pthread_cond_signal(&sEventCond);
	pthread_mutex_unlock(&sEventMutex);
	}

	static void android_location_GpsLocationProvider_cleanup(JNIEnv* env, jobject obj)		static void android_location_GpsLocationProvider_cleanup(JNIEnv* env, jobject obj)
	{		{
	sGpsInterface->cleanup();		sGpsInterface->cleanup();
	@@ -321,90 +295,11 @@ static void android_location_GpsLocationProvider_delete_aiding_data(JNIEnv* env,
	sGpsInterface->delete_aiding_data(flags);		sGpsInterface->delete_aiding_data(flags);
	}		}

	static void android_location_GpsLocationProvider_wait_for_event(JNIEnv* env, jobject obj)
	{
	pthread_mutex_lock(&sEventMutex);
	while (sPendingCallbacks == 0) {
	pthread_cond_wait(&sEventCond, &sEventMutex);
	}

	// copy and clear the callback flags
	int pendingCallbacks = sPendingCallbacks;
	sPendingCallbacks = 0;
	int nmeaSentenceCount = mNmeaSentenceCount;
	mNmeaSentenceCount = 0;

	// copy everything and unlock the mutex before calling into Java code to avoid the possibility
	// of timeouts in the GPS engine.
	if (pendingCallbacks & kLocation)
	memcpy(&sGpsLocationCopy, &sGpsLocation, sizeof(sGpsLocationCopy));
	if (pendingCallbacks & kStatus)
	memcpy(&sGpsStatusCopy, &sGpsStatus, sizeof(sGpsStatusCopy));
	if (pendingCallbacks & kSvStatus)
	memcpy(&sGpsSvStatusCopy, &sGpsSvStatus, sizeof(sGpsSvStatusCopy));
	if (pendingCallbacks & kAGpsStatus)
	memcpy(&sAGpsStatusCopy, &sAGpsStatus, sizeof(sAGpsStatusCopy));
	if (pendingCallbacks & kNmeaAvailable)
	memcpy(&sNmeaBufferCopy, &sNmeaBuffer, nmeaSentenceCount * sizeof(sNmeaBuffer[0]));
	if (pendingCallbacks & kNiNotification)
	memcpy(&sGpsNiNotificationCopy, &sGpsNiNotification, sizeof(sGpsNiNotificationCopy));
	pthread_mutex_unlock(&sEventMutex);

	if (pendingCallbacks & kLocation) {
	env->CallVoidMethod(obj, method_reportLocation, sGpsLocationCopy.flags,
	(jdouble)sGpsLocationCopy.latitude, (jdouble)sGpsLocationCopy.longitude,
	(jdouble)sGpsLocationCopy.altitude,
	(jfloat)sGpsLocationCopy.speed, (jfloat)sGpsLocationCopy.bearing,
	(jfloat)sGpsLocationCopy.accuracy, (jlong)sGpsLocationCopy.timestamp);
	}
	if (pendingCallbacks & kStatus) {
	env->CallVoidMethod(obj, method_reportStatus, sGpsStatusCopy.status);
	}
	if (pendingCallbacks & kSvStatus) {
	env->CallVoidMethod(obj, method_reportSvStatus);
	}
	if (pendingCallbacks & kAGpsStatus) {
	env->CallVoidMethod(obj, method_reportAGpsStatus, sAGpsStatusCopy.type, sAGpsStatusCopy.status);
	}
	if (pendingCallbacks & kNmeaAvailable) {
	for (int i = 0; i < nmeaSentenceCount; i++) {
	env->CallVoidMethod(obj, method_reportNmea, i, sNmeaBuffer[i].timestamp);
	}
	}
	if (pendingCallbacks & kXtraDownloadRequest) {
	env->CallVoidMethod(obj, method_xtraDownloadRequest);
	}
	if (pendingCallbacks & kDisableRequest) {
	// don't need to do anything - we are just poking so wait_for_event will return.
	}
	if (pendingCallbacks & kNiNotification) {
	LOGD("android_location_GpsLocationProvider_wait_for_event: sent notification callback.");
	jstring reqId = env->NewStringUTF(sGpsNiNotificationCopy.requestor_id);
	jstring text = env->NewStringUTF(sGpsNiNotificationCopy.text);
	jstring extras = env->NewStringUTF(sGpsNiNotificationCopy.extras);
	env->CallVoidMethod(obj, method_reportNiNotification,
	sGpsNiNotificationCopy.notification_id,
	sGpsNiNotificationCopy.ni_type,
	sGpsNiNotificationCopy.notify_flags,
	sGpsNiNotificationCopy.timeout,
	sGpsNiNotificationCopy.default_response,
	reqId,
	text,
	sGpsNiNotificationCopy.requestor_id_encoding,
	sGpsNiNotificationCopy.text_encoding,
	extras
	);
	}
	if (pendingCallbacks & kSetCapabilities) {
	env->CallVoidMethod(obj, method_setEngineCapabilities, sEngineCapabilities);
	}
	}

	static jint android_location_GpsLocationProvider_read_sv_status(JNIEnv* env, jobject obj,		static jint android_location_GpsLocationProvider_read_sv_status(JNIEnv* env, jobject obj,
	jintArray prnArray, jfloatArray snrArray, jfloatArray elevArray, jfloatArray azumArray,		jintArray prnArray, jfloatArray snrArray, jfloatArray elevArray, jfloatArray azumArray,
	jintArray maskArray)		jintArray maskArray)
	{		{
	// this should only be called from within a call to reportStatus, so we don't need to lock here		// this should only be called from within a call to reportSvStatus

	jint* prns = env->GetIntArrayElements(prnArray, 0);		jint* prns = env->GetIntArrayElements(prnArray, 0);
	jfloat* snrs = env->GetFloatArrayElements(snrArray, 0);		jfloat* snrs = env->GetFloatArrayElements(snrArray, 0);
	@@ -412,16 +307,16 @@ static jint android_location_GpsLocationProvider_read_sv_status(JNIEnv* env, job
	jfloat* azim = env->GetFloatArrayElements(azumArray, 0);		jfloat* azim = env->GetFloatArrayElements(azumArray, 0);
	jint* mask = env->GetIntArrayElements(maskArray, 0);		jint* mask = env->GetIntArrayElements(maskArray, 0);

	int num_svs = sGpsSvStatusCopy.num_svs;		int num_svs = sGpsSvStatus.num_svs;
	for (int i = 0; i < num_svs; i++) {		for (int i = 0; i < num_svs; i++) {
	prns[i] = sGpsSvStatusCopy.sv_list[i].prn;		prns[i] = sGpsSvStatus.sv_list[i].prn;
	snrs[i] = sGpsSvStatusCopy.sv_list[i].snr;		snrs[i] = sGpsSvStatus.sv_list[i].snr;
	elev[i] = sGpsSvStatusCopy.sv_list[i].elevation;		elev[i] = sGpsSvStatus.sv_list[i].elevation;
	azim[i] = sGpsSvStatusCopy.sv_list[i].azimuth;		azim[i] = sGpsSvStatus.sv_list[i].azimuth;
	}		}
	mask[0] = sGpsSvStatusCopy.ephemeris_mask;		mask[0] = sGpsSvStatus.ephemeris_mask;
	mask[1] = sGpsSvStatusCopy.almanac_mask;		mask[1] = sGpsSvStatus.almanac_mask;
	mask[2] = sGpsSvStatusCopy.used_in_fix_mask;		mask[2] = sGpsSvStatus.used_in_fix_mask;

	env->ReleaseIntArrayElements(prnArray, prns, 0);		env->ReleaseIntArrayElements(prnArray, prns, 0);
	env->ReleaseFloatArrayElements(snrArray, snrs, 0);		env->ReleaseFloatArrayElements(snrArray, snrs, 0);
	@@ -431,23 +326,21 @@ static jint android_location_GpsLocationProvider_read_sv_status(JNIEnv* env, job
	return num_svs;		return num_svs;
	}		}

	static jint android_location_GpsLocationProvider_read_nmea(JNIEnv* env, jobject obj, jint index, jbyteArray nmeaArray, jint buffer_size)		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, so we don't need to lock here		// this should only be called from within a call to reportNmea
			jbyte* nmea = (jbyte *)env->GetPrimitiveArrayCritical(nmeaArray, 0);
	jbyte* nmea = env->GetByteArrayElements(nmeaArray, 0);		int length = sNmeaStringLength;

	int length = strlen(sNmeaBufferCopy[index].nmea);
	if (length > buffer_size)		if (length > buffer_size)
	length = buffer_size;		length = buffer_size;
	memcpy(nmea, sNmeaBufferCopy[index].nmea, length);		memcpy(nmea, sNmeaString, length);
			env->ReleasePrimitiveArrayCritical(nmeaArray, nmea, JNI_ABORT);
	env->ReleaseByteArrayElements(nmeaArray, nmea, 0);
	return length;		return length;
	}		}

	static void android_location_GpsLocationProvider_inject_time(JNIEnv* env, jobject obj, jlong time,		static void android_location_GpsLocationProvider_inject_time(JNIEnv* env, jobject obj,
	jlong timeReference, jint uncertainty)		jlong time, jlong timeReference, jint uncertainty)
	{		{
	sGpsInterface->inject_time(time, timeReference, uncertainty);		sGpsInterface->inject_time(time, timeReference, uncertainty);
	}		}
	@@ -476,9 +369,9 @@ static jboolean android_location_GpsLocationProvider_supports_xtra(JNIEnv* env,
	static void android_location_GpsLocationProvider_inject_xtra_data(JNIEnv* env, jobject obj,		static void android_location_GpsLocationProvider_inject_xtra_data(JNIEnv* env, jobject obj,
	jbyteArray data, jint length)		jbyteArray data, jint length)
	{		{
	jbyte* bytes = env->GetByteArrayElements(data, 0);		jbyte* bytes = (jbyte *)env->GetPrimitiveArrayCritical(data, 0);
	sGpsXtraInterface->inject_xtra_data((char *)bytes, length);		sGpsXtraInterface->inject_xtra_data((char *)bytes, length);
	env->ReleaseByteArrayElements(data, bytes, 0);		env->ReleasePrimitiveArrayCritical(data, bytes, JNI_ABORT);
	}		}

	static void android_location_GpsLocationProvider_agps_data_conn_open(JNIEnv* env, jobject obj, jstring apn)		static void android_location_GpsLocationProvider_agps_data_conn_open(JNIEnv* env, jobject obj, jstring apn)
	@@ -560,15 +453,13 @@ static JNINativeMethod sMethods[] = {
	{"class_init_native", "()V", (void *)android_location_GpsLocationProvider_class_init_native},		{"class_init_native", "()V", (void *)android_location_GpsLocationProvider_class_init_native},
	{"native_is_supported", "()Z", (void*)android_location_GpsLocationProvider_is_supported},		{"native_is_supported", "()Z", (void*)android_location_GpsLocationProvider_is_supported},
	{"native_init", "()Z", (void*)android_location_GpsLocationProvider_init},		{"native_init", "()Z", (void*)android_location_GpsLocationProvider_init},
	{"native_disable", "()V", (void*)android_location_GpsLocationProvider_disable},
	{"native_cleanup", "()V", (void*)android_location_GpsLocationProvider_cleanup},		{"native_cleanup", "()V", (void*)android_location_GpsLocationProvider_cleanup},
	{"native_set_position_mode", "(IIIII)Z", (void*)android_location_GpsLocationProvider_set_position_mode},		{"native_set_position_mode", "(IIIII)Z", (void*)android_location_GpsLocationProvider_set_position_mode},
	{"native_start", "()Z", (void*)android_location_GpsLocationProvider_start},		{"native_start", "()Z", (void*)android_location_GpsLocationProvider_start},
	{"native_stop", "()Z", (void*)android_location_GpsLocationProvider_stop},		{"native_stop", "()Z", (void*)android_location_GpsLocationProvider_stop},
	{"native_delete_aiding_data", "(I)V", (void*)android_location_GpsLocationProvider_delete_aiding_data},		{"native_delete_aiding_data", "(I)V", (void*)android_location_GpsLocationProvider_delete_aiding_data},
	{"native_wait_for_event", "()V", (void*)android_location_GpsLocationProvider_wait_for_event},
	{"native_read_sv_status", "([I[F[F[F[I)I", (void*)android_location_GpsLocationProvider_read_sv_status},		{"native_read_sv_status", "([I[F[F[F[I)I", (void*)android_location_GpsLocationProvider_read_sv_status},
	{"native_read_nmea", "(I[BI)I", (void*)android_location_GpsLocationProvider_read_nmea},		{"native_read_nmea", "([BI)I", (void*)android_location_GpsLocationProvider_read_nmea},
	{"native_inject_time", "(JJI)V", (void*)android_location_GpsLocationProvider_inject_time},		{"native_inject_time", "(JJI)V", (void*)android_location_GpsLocationProvider_inject_time},
	{"native_inject_location", "(DDF)V", (void*)android_location_GpsLocationProvider_inject_location},		{"native_inject_location", "(DDF)V", (void*)android_location_GpsLocationProvider_inject_location},
	{"native_supports_xtra", "()Z", (void*)android_location_GpsLocationProvider_supports_xtra},		{"native_supports_xtra", "()Z", (void*)android_location_GpsLocationProvider_supports_xtra},