typedef struct {

// set to sizeof(GpsLocation) */

size_t          size;

//标志位. */

uint16_t        flags;

//维度

double          latitude;

//经度

double          longitude;

//以WSG 84坐标系统表示高度信息

double          altitude;

/速度

float           speed;

//方向

float           bearing;

//精确度

float           accuracy;

//时间戳

GpsUtcTime      timestamp;

} GpsLocation;

typedef struct {

size_t          size;

GpsStatusValue status;

} GpsStatus;

typedef uint16_t GpsStatusValue;

// IMPORTANT: Note that the following values must match

// constants in GpsLocationProvider.java.

//未知

#define GPS_STATUS_NONE             0

//已经开始导航

#define GPS_STATUS_SESSION_BEGIN    1

//已经停止导航

#define GPS_STATUS_SESSION_END      2

//已经通电但是设备没有导航

#define GPS_STATUS_ENGINE_ON        3

//没有通电状态

#define GPS_STATUS_ENGINE_OFF       4

typedef struct {

//

size_t          size;

//初始化GPS时设置回调函数的结构体GpsCallbacks

int   (*init)( GpsCallbacks* callbacks );

//开始导航

int   (*start)( void );

/停止导航

int   (*stop)( void );

//关闭接口

void  (*cleanup)( void );

//置入当前时间

int   (*inject_time)(GpsUtcTime time, int64_t timeReference,

int uncertainty);

//置入位置信息

int  (*inject_location)(double latitude, double longitude, float accuracy);

//删除帮助数据

void  (*delete_aiding_data)(GpsAidingData flags);

//设置位置模式

int   (*set_position_mode)(GpsPositionMode mode, GpsPositionRecurrence recurrence,

uint32_t min_interval, uint32_t preferred_accuracy, uint32_t preferred_time);

//得到扩展信息指针

const void* (*get_extension)(const char* name);

} GpsInterface;

typedef void (* gps_location_callback)(GpsLocation* location);

typedef void (* gps_status_callback)(GpsStatus* status);

typedef void (* gps_sv_status_callback)(GpsSvStatus* sv_info);

typedef void (* gps_nmea_callback)(GpsUtcTime timestamp, const char* nmea, int length);

typedef void (* gps_set_capabilities)(uint32_t capabilities);

typedef void (* gps_acquire_wakelock)();

typedef void (* gps_release_wakelock)();

typedef void (* gps_request_utc_time)();

typedef pthread_t (* gps_create_thread)(const char* name, void (*start)(void *), void* arg);

typedef struct {

size_t      size;

gps_location_callback location_cb;

gps_status_callback status_cb;

gps_sv_status_callback sv_status_cb;

gps_nmea_callback nmea_cb;

gps_set_capabilities set_capabilities_cb;

gps_acquire_wakelock acquire_wakelock_cb;

gps_release_wakelock release_wakelock_cb;

gps_create_thread create_thread_cb;

gps_request_utc_time request_utc_time_cb;

} GpsCallbacks;

typedef void (* gps_xtra_download_request)();

typedef pthread_t (* gps_create_thread)(const char* name, void (*start)(void *), void* arg);

typedef struct {

gps_xtra_download_request download_request_cb;

gps_create_thread create_thread_cb;

} GpsXtraCallbacks;

typedef struct {

size_t          size;

int  (*init)( GpsXtraCallbacks* callbacks );

//植入XTRA数据到GPS

int  (*inject_xtra_data)( char* data, int length );

} GpsXtraInterface;

struct gps_device_t {

struct hw_device_t common;

//获取Gps硬件接口

const GpsInterface* (*get_gps_interface)(struct gps_device_t* dev);

};

// GpsInterface  结构体中函数初始化

static const GpsInterface  qemuGpsInterface = {

sizeof(GpsInterface),

qemu_gps_init,

qemu_gps_start,

qemu_gps_stop,

qemu_gps_cleanup,

qemu_gps_inject_time,

qemu_gps_inject_location,

qemu_gps_delete_aiding_data,

qemu_gps_set_position_mode,

qemu_gps_get_extension,

};

//获取Gps接口具体实现

const GpsInterface* gps__get_gps_interface(struct gps_device_t* dev)

{

return &qemuGpsInterface;

}

//打开模拟gps设备

static int open_gps(const struct hw_module_t* module, char const* name,

struct hw_device_t** device)

{

struct gps_device_t *dev = malloc(sizeof(struct gps_device_t));

memset(dev, 0, sizeof(*dev));

dev->common.tag = HARDWARE_DEVICE_TAG;

dev->common.version = 0;

dev->common.module = (struct hw_module_t*)module;

dev->get_gps_interface = gps__get_gps_interface;

*device = (struct hw_device_t*)dev;

return 0;

}

//打开设备open函数的具体实现到open_gps

static struct hw_module_methods_t gps_module_methods = {

//设置open函数实现

.open = open_gps

};

//初始化hw_module_t结构体

const struct hw_module_t HAL_MODULE_INFO_SYM = {

.tag = HARDWARE_MODULE_TAG,

.version_major = 1,

.version_minor = 0,

.id = GPS_HARDWARE_MODULE_ID,

.name = "Goldfish GPS Module",

.author = "The Android Open Source Project",

.methods = &gps_module_methods,

};

static void android_location_GpsLocationProvider_class_init_native(JNIEnv* env, jclass clazz) {

int err;

hw_module_t* module;

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;

sGpsInterface = gps_device->get_gps_interface(gps_device);

}

}

……

}

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,

request_utc_time_callback,

};

static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject obj)

{

// this must be set before calling into the HAL library

if (!mCallbacksObj)

mCallbacksObj = env->NewGlobalRef(obj);

// fail if the main interface fails to initialize

if (!sGpsInterface || sGpsInterface->init(&sGpsCallbacks) != 0)

return false;

......

return true;

}