和菜鸟一起学android4.0.3源码之硬件gps简单移植

$GPGGA,063740.998,2234.2551,N,11408.0339,E,1,08,00.9,00053.A,M,-2.1,M,,*7B
$GPGGA,<1>,<2>,<3>,<4>,<5>,<6>,<7>,<8>,<9>,M,<10>,M,<11>,<12>*hh<CR><LF>
<1> UTC时间，hhmmss（时分秒）格式
<2> 纬度ddmm.mmmm（度分）格式（前面的0也将被传输）
<3> 纬度半球N（北半球）或S（南半球）
<4> 经度dddmm.mmmm（度分）格式（前面的0也将被传输）
<5> 经度半球E（东经）或W（西经）
<6> GPS状态：0=未定位，1=非差分定位，2=差分定位，6=正在估算
<7> 正在使用解算位置的卫星数量（00~12）（前面的0也将被传输）
<8> HDOP水平精度因子（0.5~99.9）
<9> 海拔高度（-9999.9~99999.9）
<10> 地球椭球面相对大地水准面的高度
<11> 差分时间（从最近一次接收到差分信号开始的秒数，如果不是差分定位将为空）
<12> 差分站ID号0000~1023（前面的0也将被传输，如果不是差分定位将为空）

$GPGSA,A,3,06,16,14,22,25,01,30,20,,,,,01.6,00.9,01.3*0D
$GPGSA,<1>,<2>,<3>,<3>,,,,,<3>,<3>,<3>,<4>,<5>,<6>,<7><CR><LF>
<1>模式 ：M = 手动， A = 自动。
<2>定位型式 1 = 未定位， 2 = 二维定位， 3 = 三维定位。
<3>PRN 数字：01 至 32 表天空使用中的卫星编号，最多可接收12颗卫星信息。
<4> PDOP位置精度因子（0.5~99.9）
<5> HDOP水平精度因子（0.5~99.9）
<6> VDOP垂直精度因子（0.5~99.9）
<7> Checksum.(检查位).

$GPGSV,2,1,08,06,26,075,44,16,50,227,47,14,57,097,44,22,17,169,41*70
$GPGSV,2,2,08,25,49,352,45,01,64,006,45,30,13,039,39,20,15,312,34*7A
$GPGSV,<1>,<2>,<3>,<4>,<5>,<6>,<7>,?<4>,<5>,<6>,<7>,<8><CR><LF>
<1> GSV语句的总数
<2> 本句GSV的编号
<3> 可见卫星的总数，00 至 12。
<4> 卫星编号， 01 至 32。
<5>卫星仰角， 00 至 90 度。
<6>卫星方位角， 000 至 359 度。实际值。
<7>讯号噪声比（C/No）， 00 至 99 dB；无表未接收到讯号。
<8>Checksum.(检查位).
第<4>,<5>,<6>,<7>项个别卫星会重复出现，每行最多有四颗卫星。其余卫星信息会于次一行出现，若未使用，这些字段会空白。

$GPRMC,012724.000,A,2234.3157,N,11408.0921,E,0.00,,290108,,,A*71
$GPRMC,<1>,<2>,<3>,<4>,<5>,<6>,<7>,<8>,<9>,<10>,<11>,<12>*hh<CR><LF>
<1> UTC时间，hhmmss（时分秒）格式
<2> 定位状态，A=有效定位，V=无效定位
<3> 纬度ddmm.mmmm（度分）格式（前面的0也将被传输）
<4> 纬度半球N（北半球）或S（南半球）
<5> 经度dddmm.mmmm（度分）格式（前面的0也将被传输）
<6> 经度半球E（东经）或W（西经）
<7> 地面速率（000.0~999.9节，前面的0也将被传输）
<8> 地面航向（000.0~359.9度，以真北为参考基准，前面的0也将被传输）
<9> UTC日期，ddmmyy（日月年）格式
<10> 磁偏角（000.0~180.0度，前面的0也将被传输）
<11> 磁偏角方向，E（东）或W（西）
<12> 模式指示（仅NMEA0183 3.00版本输出，A=自主定位，D=差分，E=估算，N=数据无效）
我们所关心的是GPRMC这条信息，因为其中包括当前格林威治时间、经度、纬度、日期等。

/** Represents a location. */
typedef struct {
    /**set to sizeof(GpsLocation) */
   size_t          size;
    /**Contains GpsLocationFlags bits. */
   uint16_t        flags;
    /**Represents latitude in degrees. */
   double          latitude;
    /**Represents longitude in degrees. */
   double          longitude;
    /**Represents altitude in meters above the WGS 84 reference
     *ellipsoid. */
   double          altitude;
    /**Represents speed in meters per second. */
   float           speed;
    /**Represents heading in degrees. */
   float           bearing;
    /**Represents expected accuracy in meters. */
   float           accuracy;
    /**Timestamp for the location fix. */
   GpsUtcTime      timestamp;
} GpsLocation;

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,
};
而gps_module_methods又调用了open_gps
static struct hw_module_methods_t gps_module_methods ={
    .open = open_gps
};

static constGpsInterface  qemuGpsInterface = {
    sizeof(GpsInterface),
    qemu_gps_init,   //打开接口，提供callback函数
    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, //扩展信息
};

state->fd = open(GPS_Serial_Name, O_RDONLY );
state->thread = callbacks->eate_thread_cb("gps_state_thread”,gps_state_thread,  tate);

nmea_reader_set_callback( reader,state->callbacks.location_cb );

else if ( !memcmp(tok.p, "GLL", 3) )
else if ( !memcmp(tok.p, "GSA", 3) )
else if ( !memcmp(tok.p, "GSV", 3) )

/framework/base/services/jni/com_android_server_location_GpsLocationProvider.cpp

jniRegisterNativeMethods(env,"com/android/server/location/GpsLocationProvider", sMethods,NELEM(sMethods));

staticJNINativeMethod sMethods[] = {
{"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},
…………………………
};

字符   Java类型    C类型
V      void         void
Z       jboolean     boolean
I        jint         int
J       jlong        long
D      jdouble       double
F      jfloat         float
B      jbyte         byte
C      jchar         char
S      jshort         short

[I       jintArray      int[]
[F     jfloatArray      float[]
[B     jbyteArray      byte[]
[C    jcharArray       char[]
[S    jshortArray       short[]
[D    jdoubleArray     double[]
[J     jlongArray       long[]
[Z    jbooleanArray     boolean[]

Ljava/lang/String;String jstring
Ljava/net/Socket;Socket jobject

method_reportLocation =env->GetMethodID(clazz, "reportLocation","(IDDDFFFJ)V");
    ……………………………………
   method_requestUtcTime = env->GetMethodID(clazz,"requestUtcTime","()V")

err =hw_get_module(GPS_HARDWARE_MODULE_ID, (hw_module_t const**)&module);

err =module->methods->open(module, GPS_HARDWARE_MODULE_ID, &device);

sGpsXtraInterface =
          (constGpsXtraInterface*)sGpsInterface->get_extension(GPS_XTRA_INTERFACE);

if(sGpsXtraInterface &&sGpsXtraInterface->init(&sGpsXtraCallbacks) != 0)
        sGpsXtraInterface = NULL;

GpsCallbackssGpsCallbacks = {
    sizeof(GpsCallbacks),
    location_callback,  //回调位置信息
    status_callback,    //回调状态信息
    sv_status_callback,  //回调sv状态信息
    nmea_callback,    //上报nema信息
    set_capabilities_callback, //回调告知框架层GPS的性能
    acquire_wakelock_callback, //获取GPS锁，不进行休眠
    release_wakelock_callback, //释放GPS锁
    create_thread_callback, //创建线程，可以调用java framework的代码
    request_utc_time_callback, //获取utc时间
};

staticvoid location_callback(GpsLocation* location)
{
    JNIEnv* env = AndroidRuntime::getJNIEnv();
    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);
    checkAndClearExceptionFromCallback(env,__FUNCTION__);
}

staticvoid status_callback(GpsStatus* status)
{
    JNIEnv* env = AndroidRuntime::getJNIEnv();
   env->CallVoidMethod(mCallbacksObj, method_reportStatus,status->status);
    checkAndClearExceptionFromCallback(env,__FUNCTION__);
}
 
staticvoid sv_status_callback(GpsSvStatus* sv_status)
{
    JNIEnv* env = AndroidRuntime::getJNIEnv();
    memcpy(&sGpsSvStatus, sv_status,sizeof(sGpsSvStatus));
    env->CallVoidMethod(mCallbacksObj,method_reportSvStatus);
    checkAndClearExceptionFromCallback(env,__FUNCTION__);
}
 
staticvoid nmea_callback(GpsUtcTime timestamp, const char* nmea, int length)
{
    JNIEnv* env = AndroidRuntime::getJNIEnv();
    // The Java code will call back to readthese values
    // We do this to avoid creating unnecessaryString objects
    sNmeaString = nmea;
    sNmeaStringLength = length;
    env->CallVoidMethod(mCallbacksObj,method_reportNmea, timestamp);
    checkAndClearExceptionFromCallback(env,__FUNCTION__);
}
 
staticvoid set_capabilities_callback(uint32_t capabilities)
{
    LOGD("set_capabilities_callback:%ld\n", capabilities);
    JNIEnv* env = AndroidRuntime::getJNIEnv();
    env->CallVoidMethod(mCallbacksObj,method_setEngineCapabilities, capabilities);
    checkAndClearExceptionFromCallback(env,__FUNCTION__);
}
 
staticvoid acquire_wakelock_callback()
{
    acquire_wake_lock(PARTIAL_WAKE_LOCK,WAKE_LOCK_NAME);
}
获取GPS的锁
staticvoid release_wakelock_callback()
{
    release_wake_lock(WAKE_LOCK_NAME);
}
释放了GPS的锁
staticvoid request_utc_time_callback()
{
    JNIEnv* env = AndroidRuntime::getJNIEnv();
    env->CallVoidMethod(mCallbacksObj,method_requestUtcTime);
    checkAndClearExceptionFromCallback(env,__FUNCTION__);
}
更新时间
staticpthread_t create_thread_callback(const char* name, void (*start)(void *), void*arg)
{
    return(pthread_t)AndroidRuntime::createJavaThread(name, start, arg);
}
创建线程。

System.loadLibrary("android_servers");
      init1(args);

static voidandroid_server_SystemServer_init1(JNIEnv* env, jobject clazz)
{
   system_init();
}

jmethodID methodId =env->GetStaticMethodID(clazz, "init2", "()V");
env->CallStaticVoidMethod(clazz,methodId);

public static final void init2() {
       Slog.i(TAG, "Entered the Android system server!");
       Thread thr = new ServerThread();
       thr.setName("android.server.ServerThread");
       thr.start();
    }

try {
                Slog.i(TAG, "LocationManager");
                location = new LocationManagerService(context);
               ServiceManager.addService(Context.LOCATION_SERVICE, location);
            } catch (Throwable e) {
                reportWtf("startingLocation Manager", e);
           }

try {
                    if (locationF != null)locationF.systemReady();
                } catch (Throwable e) {
                    reportWtf("makingLocation Service ready", e);
                }

voidsystemReady() {
        // we defer starting up the service untilthe system is ready
        Thread thread = new Thread(null, this,"LocationManagerService");
        thread.start();
    }

publicvoid run()
    {
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        Looper.prepare();
        mLocationHandler = newLocationWorkerHandler();
        initialize();
        Looper.loop();
    }

privatevoid initialize() {
        // Create a wake lock, needs to be donebefore calling loadProviders() below
        PowerManager powerManager =(PowerManager)
mContext.getSystemService(Context.POWER_SERVICE);
        mWakeLock =
powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,WAKELOCK_KEY);
 
        // Load providers
        loadProviders();
………………
………………
｝

privatevoid loadProviders() {
        synchronized (mLock) {
            if (sProvidersLoaded) {
                return;
            }
 
            // Load providers
            loadProvidersLocked();
            sProvidersLoaded = true;
        }
    }

if(GpsLocationProvider.isSupported()) {
            // Create a gps location provider
            GpsLocationProvider gpsProvider =new GpsLocationProvider(mContext, this);
            mGpsStatusProvider =gpsProvider.getGpsStatusProvider();
            mNetInitiatedListener =gpsProvider.getNetInitiatedListener();
            addProvider(gpsProvider);
            mGpsLocationProvider = gpsProvider;
        }

mThread =new GpsLocationProviderThread();
mThread.start();

initialize();
            mHandler = new ProviderHandler();

publicvoid handleMessage(Message msg) {
            int message = msg.what;
            switch (message) {
                case ENABLE:
                    if (msg.arg1 == 1) {
                        handleEnable();
                    } else {
                        handleDisable();
                    }
                    break;
                case ENABLE_TRACKING:
                   handleEnableLocationTracking(msg.arg1 == 1);
                    break;
                case REQUEST_SINGLE_SHOT:
                    handleRequestSingleShot();
                    break;
                case UPDATE_NETWORK_STATE:
                   handleUpdateNetworkState(msg.arg1, (NetworkInfo)msg.obj);
                    break;
                case INJECT_NTP_TIME:
                    handleInjectNtpTime();
                    break;
                case DOWNLOAD_XTRA_DATA:
                    if (mSupportsXtra) {
                        handleDownloadXtraData();
                    }
                    break;
                case UPDATE_LOCATION:
                   handleUpdateLocation((Location)msg.obj);
                    break;
                case ADD_LISTENER:
                    handleAddListener(msg.arg1);
                    break;
                case REMOVE_LISTENER:
                   handleRemoveListener(msg.arg1);
                    break;
            }

if (enabled) {
            p.enable();
            if (listeners > 0) {
               p.setMinTime(getMinTimeLocked(provider), mTmpWorkSource);
                p.enableLocationTracking(true);
            }
        }

public void enable() {
        synchronized (mHandler) {
            sendMessage(ENABLE, 1, null);
        }
    }

privatevoid handleEnable() {
       ……
        mEnabled = native_init();
 
        if (mEnabled) {
            mSupportsXtra =native_supports_xtra();
       ……
    }

publicvoid enableLocationTracking(boolean enable) {
        // FIXME - should set a flag here to avoidrace conditions with single shot request
        synchronized (mHandler) {
            sendMessage(ENABLE_TRACKING,(enable ? 1 : 0), null);
        }
    }

handleEnableLocationTracking(msg.arg1== 1);
if (enable) {
            mTTFF = 0;
            mLastFixTime = 0;
            startNavigating(false);
        }

privatevoid startNavigating(boolean singleShot) {
       ……
 if (!native_set_position_mode(mPositionMode,GPS_POSITION_RECURRENCE_PERIODIC,
    interval, 0, 0)) {
                mStarted = false;
                Log.e(TAG,"set_position_mode failed in startNavigating()");
                return;
   }
    if(!native_start()) {
         mStarted = false;
         Log.e(TAG, "native_start failedin startNavigating()");
        return;
    ……
   }
｝

privatevoid reportLocation(int flags, double latitude, double longitude, doublealtitude,
            float speed, float bearing, floataccuracy, long timestamp) {
        …………
        synchronized (mLocation) {
            mLocationFlags = flags;
            if ((flags &LOCATION_HAS_LAT_LONG) == LOCATION_HAS_LAT_LONG) {
               mLocation.setLatitude(latitude);
               mLocation.setLongitude(longitude);
                mLocation.setTime(timestamp);
            }
            if ((flags &LOCATION_HAS_ALTITUDE) == LOCATION_HAS_ALTITUDE) {
                mLocation.setAltitude(altitude);
            } else {
                mLocation.removeAltitude();
            }
            if ((flags &LOCATION_HAS_SPEED) == LOCATION_HAS_SPEED) {
                mLocation.setSpeed(speed);
            } else {
                mLocation.removeSpeed();
            }
            if ((flags &LOCATION_HAS_BEARING) == LOCATION_HAS_BEARING) {
                mLocation.setBearing(bearing);
            } else {
                mLocation.removeBearing();
            }
            if ((flags & LOCATION_HAS_ACCURACY) ==LOCATION_HAS_ACCURACY) {
               mLocation.setAccuracy(accuracy);
            } else {
                mLocation.removeAccuracy();
            }
 
            try {
                mLocationManager.reportLocation(mLocation,false);
            } catch (RemoteException e) {
                Log.e(TAG,"RemoteException calling reportLocation");
            }
        }
 
        mLastFixTime =System.currentTimeMillis();
        // report time to first fix
        if (mTTFF == 0 && (flags &LOCATION_HAS_LAT_LONG) == LOCATION_HAS_LAT_LONG) {
            mTTFF = (int)(mLastFixTime -mFixRequestTime);
            if (DEBUG) Log.d(TAG, "TTFF:" + mTTFF);
 
            // notify status listeners
            synchronized(mListeners) {
                int size = mListeners.size();
                for (int i = 0; i < size;i++) {
                    Listener listener =mListeners.get(i);
                    try {
                       listener.mListener.onFirstFix(mTTFF);
                    } catch (RemoteException e){
                        Log.w(TAG,"RemoteException in stopNavigating");
                       mListeners.remove(listener);
                        // adjust for size oflist changing
                        size--;
                    }
                }
            }
        }
 
        if (mSingleShot) {
            stopNavigating();
        }
        if (mStarted && mStatus !=LocationProvider.AVAILABLE) {
            // we want to time out if we do notreceive a fix
            // within the time out and we arerequesting infrequent fixes
            if(!hasCapability(GPS_CAPABILITY_SCHEDULING) && mFixInterval <NO_FIX_TIMEOUT) {
               mAlarmManager.cancel(mTimeoutIntent);
            }
 
            // send an intent to notify that the GPSis receiving fixes.
            Intent intent = newIntent(LocationManager.GPS_FIX_CHANGE_ACTION);
           intent.putExtra(LocationManager.EXTRA_GPS_ENABLED, true);
            mContext.sendBroadcast(intent);
           updateStatus(LocationProvider.AVAILABLE, mSvCount);
        }
 
       if(!hasCapability(GPS_CAPABILITY_SCHEDULING) && mStarted &&mFixInterval > 1000) {
            if (DEBUG) Log.d(TAG, "gotfix, hibernating");
            hibernate();
        }
   }

mLocation.setLatitude(latitude);
               mLocation.setLongitude(longitude);
                mLocation.setTime(timestamp);

if((flags & LOCATION_HAS_LAT_LONG) == LOCATION_HAS_LAT_LONG) {
               mLocation.setLatitude(latitude);
               mLocation.setLongitude(longitude);
                mLocation.setTime(timestamp);
            }

/**
     * Sets the UTC time of this fix, inmilliseconds since January 1,
     * 1970.
     */
    public void setTime(long time) {
        mTime = time;
    }
 
    /**
     * Returns the latitude of this fix.
     */
    public double getLatitude(){
        return mLatitude;
    }
 
    /**
     * Sets the latitude of this fix.
     */
    public void setLatitude(double latitude) {
        mLatitude = latitude;
    }
 
    /**
     * Returns the longitude of this fix.
     */
    public double getLongitude() {
        return mLongitude;
    }
 
    /**
     * Sets the longitude of this fix.
     */
    public void setLongitude(double longitude){
        mLongitude = longitude;
    }

private void updateToNewLocation(Locationlocation)
   {     
 
     if (location != null)
     {         
      bear = location.getBearing(); //偏离正北方的度数
      double latitude =location.getLatitude();      //维度
      double longitude=location.getLongitude();     //经度
      double GpsSpeed = location.getSpeed(); //速度
      long GpsTime = location.getTime(); //时间
      Date date = new Date(GpsTime);
      DateFormat df = newSimpleDateFormat("yyyy-MM-dd HH:mm:ss");
     
      float GpsAlt =(float)location.getAltitude();  //海拔
      latitudeview.setText("" +latitude);
      longitudeview.setText("" +longitude);
      speedview.setText(""+GpsSpeed);
     timeview.setText(""+df.format(date));
     altitudeview.setText(""+GpsAlt);
      bearingview.setText(""+bear);
      }
      else
      {   
       Toast.makeText(this, "无法获取地理信息", Toast.LENGTH_SHORT).show();
      }
 
}