/** Represents the standard GPS interface. */
typedef struct {
/**
* Opens the interface and provides the callback routines
* to the implemenation of this interface.
*/
int (*init)( GpsCallbacks* callbacks );
/** Starts navigating. */
int (*start)( void );
/** Stops navigating. */
int (*stop)( void );
/** Closes the interface. */
void (*cleanup)( void );
/** Injects the current time. */
int (*inject_time)(GpsUtcTime time, int64_t timeReference,
int uncertainty);
/** Injects current location from another location provider
* (typically cell ID).
* latitude and longitude are measured in degrees
* expected accuracy is measured in meters
*/
int (*inject_location)(double latitude, double longitude, float accuracy);
/**
* Specifies that the next call to start will not use the
* information defined in the flags. GPS_DELETE_ALL is passed for
* a cold start.
*/
void (*delete_aiding_data)(GpsAidingData flags);
/**
* fix_frequency represents the time between fixes in seconds.
* Set fix_frequency to zero for a single-shot fix.
*/
int (*set_position_mode)(GpsPositionMode mode, int fix_frequency);
/** Get a pointer to extension information. */
const void* (*get_extension)(const char* name);
} GpsInterface;


/** GPS callback structure. */
typedef struct {
gps_location_callback location_cb;
gps_status_callback status_cb;
gps_sv_status_callback sv_status_cb;
gps_nmea_callback nmea_cb;
} GpsCallbacks;
/** Callback with location information. */
typedef void (* gps_location_callback)(GpsLocation* location);
/** Callback with status information. */
typedef void (* gps_status_callback)(GpsStatus* status);
/** Callback with SV status information. */
typedef void (* gps_sv_status_callback)(GpsSvStatus* sv_info);
/** Callback for reporting NMEA sentences. */
typedef void (* gps_nmea_callback)(GpsUtcTime timestamp, const char* nmea, int length);


privatevoidinitialize(){
// Create a wake lock, needs to be done before calling loadProviders() below
PowerManager powerManager=(PowerManager)mContext.getSystemService(Context.POWER_SERVICE);
mWakeLock=powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,WAKELOCK_KEY);
// Load providers
loadProviders();

...


privatevoid_loadProvidersLocked(){
// Attempt to load "real" providers first
if(GpsLocationProvider.isSupported()){
// Create a gps location provider
GpsLocationProvider gpsProvider=newGpsLocationProvider(mContext,this);
mGpsStatusProvider=gpsProvider.getGpsStatusProvider();
mNetInitiatedListener=gpsProvider.getNetInitiatedListener();
addProvider(gpsProvider);
mGpsLocationProvider=gpsProvider;
}

...

publicstaticboolean isSupported(){
returnnative_is_supported();
}

staticjboolean android_location_GpsLocationProvider_is_supported(JNIEnv*env,jclass clazz){
if(!sGpsInterface)
sGpsInterface=gps_get_interface();
return(sGpsInterface!=NULL);
}

constGpsInterface*
gps_get_interface()
{
if(sGpsInterface==NULL)
gps_find_hardware();
returnsGpsInterface;
}

staticvoid
gps_find_hardware(void)
{
#ifdefHAVE_QEMU_GPS_HARDWARE
if(qemu_check()){
sGpsInterface=gps_get_qemu_interface();
if(sGpsInterface){
LOGD("using QEMU GPS Hardware emulation/n");
return;
}
}
#endif
#ifdefHAVE_GPS_HARDWARE
sGpsInterface=gps_get_hardware_interface();
#endif
if(!sGpsInterface)
LOGD("no GPS hardware on this device/n");
}

constGpsInterface*gps_get_qemu_interface()
{
return&qemuGpsInterface;
}

GpsLocationProvider gpsProvider=newGpsLocationProvider(mContext,this);

publicGpsLocationProvider(Context context,ILocationManager locationManager){
mContext=context;
mLocationManager=locationManager;
mNIHandler=newGpsNetInitiatedHandler(context,this);

...

}

privatevoid_loadProvidersLocked(){
// Attempt to load "real" providers first
if(GpsLocationProvider.isSupported()){
// Create a gps location provider
GpsLocationProvider gpsProvider=newGpsLocationProvider(mContext,this);
mGpsStatusProvider=gpsProvider.getGpsStatusProvider();
mNetInitiatedListener=gpsProvider.getNetInitiatedListener();
addProvider(gpsProvider);
mGpsLocationProvider=gpsProvider;
}
// create a passive location provider, which is always enabled
PassiveProvider passiveProvider=newPassiveProvider(this);
addProvider(passiveProvider);
mEnabledProviders.add(passiveProvider.getName());
// initialize external network location and geocoder services
Resources resources=mContext.getResources();
StringserviceName=resources.getString(
com.android.internal.R.string.config_networkLocationProvider);
if(serviceName!=null){
mNetworkLocationProvider=
newLocationProviderProxy(mContext,LocationManager.NETWORK_PROVIDER,
serviceName,mLocationHandler);
addProvider(mNetworkLocationProvider);
}
serviceName=resources.getString(com.android.internal.R.string.config_geocodeProvider);
if(serviceName!=null){
mGeocodeProvider=newGeocoderProxy(mContext,serviceName);
}
updateProvidersLocked();
}

<!--Componentnameofthe service providing network location support.-->
<stringname="config_networkLocationProvider">@null</string>
<!--Componentnameofthe service providing geocoder API support.-->
<stringname="config_geocodeProvider">@null</string>

privatevoidupdateProvidersLocked(){
for(inti=mProviders.size()-1;i>=0;i--){
LocationProviderInterface p=mProviders.get(i);
booleanisEnabled=p.isEnabled();
Stringname=p.getName();
booleanshouldBeEnabled=isAllowedBySettingsLocked(name);
if(isEnabled&&!shouldBeEnabled){
updateProviderListenersLocked(name,false);
}elseif(!isEnabled&&shouldBeEnabled){
updateProviderListenersLocked(name,true);
}
}
}

staticint
qemu_gps_init(GpsCallbacks*callbacks)
{
GpsState*s=_gps_state;
if(!s->init)
gps_state_init(s);
if(s->fd<0)
return-1;
s->callbacks=*callbacks;
return0;
}

staticvoid
gps_state_init(GpsState*state)
{
state->init=1;
state->control[0]=-1;
state->control[1]=-1;
state->fd=-1;
state->fd=qemu_channel_open(&state->channel,
QEMU_CHANNEL_NAME,
O_RDONLY);
if(state->fd<0){
D("no gps emulation detected");
return;
}
D("gps emulation will read from '%s' qemud channel",QEMU_CHANNEL_NAME);
if(socketpair(AF_LOCAL,SOCK_STREAM,0,state->control)<0){
LOGE("could not create thread control socket pair: %s",strerror(errno));
gotoFail;
}
if(pthread_create(&state->thread,NULL,gps_state_thread,state)!=0){
LOGE("could not create gps thread: %s",strerror(errno));
gotoFail;
}
D("gps state initialized");
return;
Fail:
gps_state_done(state);
}

mEventThread=newGpsEventThread();
mEventThread.start();

publicvoidrun(){
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");
}
}

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

publicvoidenableLocationTracking(booleanenable){
synchronized(mHandler){
mHandler.removeMessages(ENABLE_TRACKING);
Message m=Message.obtain(mHandler,ENABLE_TRACKING);
m.arg1=(enable?1:0);
mHandler.sendMessage(m);
}
}

privatevoidhandleEnableLocationTracking(booleanenable){
if(enable){
mTTFF=0;
mLastFixTime=0;
startNavigating();
}else{
mAlarmManager.cancel(mWakeupIntent);
mAlarmManager.cancel(mTimeoutIntent);
stopNavigating();
}
}

privatevoidstartNavigating(){
if(!mStarted){
if(DEBUG)Log.d(TAG,"startNavigating");
mStarted=true;
intpositionMode;
if(Settings.Secure.getInt(mContext.getContentResolver(),
Settings.Secure.ASSISTED_GPS_ENABLED,1)!=0){
positionMode=GPS_POSITION_MODE_MS_BASED;
}else{
positionMode=GPS_POSITION_MODE_STANDALONE;
}

if(!native_start(positionMode,false,1)){
mStarted=false;
Log.e(TAG,"native_start failed in startNavigating()");
return;
}

...

staticjboolean android_location_GpsLocationProvider_start(JNIEnv*env,jobject obj,jint positionMode,
jboolean singleFix,jint fixFrequency)
{
intresult=sGpsInterface->set_position_mode(positionMode,(singleFix?0:fixFrequency));
if(result){
returnfalse;
}
return(sGpsInterface->start()==0);
}

staticint
qemu_gps_start()
{
GpsState*s=_gps_state;
if(!s->init){
D("%s: called with uninitialized state !!",__FUNCTION__);
return-1;
}
D("%s: called",__FUNCTION__);
gps_state_start(s);
return0;
}

staticvoid
gps_state_start(GpsState*s)
{
charcmd=CMD_START;
intret;
do{ret=write(s->control[0],&cmd,1);}
while(ret<0&&errno==EINTR);
if(ret!=1)
D("%s: could not send CMD_START command: ret=%d: %s",
__FUNCTION__,ret,strerror(errno));
}

staticvoid*
gps_state_thread(void*arg)
{
...
// now loop
for(;;){
...
if(cmd==CMD_QUIT){
D("gps thread quitting on demand");
gotoExit;
}else

if(cmd==CMD_START){

if (!started) {
D("gps thread starting location_cb=%p", state>callbacks.location_cb);
started = 1;
nmea_reader_set_callback( reader, state->callbacks.location_cb );
}}
else if (cmd == CMD_STOP) {

...

}