Android4.4 GPS框架分析【转】

本文转载自：http://blog.csdn.net/junzhang1122/article/details/46674569

 GPS HAL层代码在目录trunk/Android/hardware/xxx/gps/skytraqskytraq_gsp.c，向下与硬件驱动通讯，向上提供接口
 GPS JNI层层代码在目录trunk/Android/frameworks/base/services/jni/com_android_server_location_GpsLocationProvider.cpp  C与java转换，给java层提供接口
 GPS framework层代码目录Android/frameworks/base/services/java/com/android/server下，主要文件是location服务对内部的封装并提供provider服务
 Android/frameworks/base/location/java/com/android/internal/location这个是framework对location服务内部的实现  

 启动GPS服务代码流程如下
 public static void main(String[] args)
     -->ServerThread thr = new ServerThread();
         -->location = new LocationManagerService(context);
         -->ServiceManager.addService(Context.LOCATION_SERVICE, location);
         -->locationF.systemRunning()
             -->systemRunning()
                 -->loadProvidersLocked();
                     -->GpsLocationProvider gpsProvider = new GpsLocationProvider(mContext, this, mLocationHandler.getLooper());
                         -->class_init_native();
                             -->android_location_GpsLocationProvider_class_init_native(JNIEnv* env, jclass clazz)
                                 -->err = module->methods->open(module, GPS_HARDWARE_MODULE_ID, &device);
                                     -->pen_gps(const struct hw_module_t *module, char const *name, struct hw_device_t **device)
                                 -->sGpsInterface = gps_device->get_gps_interface(gps_device);
                                     -->const GpsInterface *gps__get_gps_interface(struct gps_device_t *dev)
                                         -->return &skytraqGpsInterface;
                     -->GpsLocationProvider.isSupported()
                         -->native_is_supported()
                             -->android_location_GpsLocationProvider_is_supported(JNIEnv* env, jclass clazz)
                                 -->return (sGpsInterface != NULL);
                 -->updateProvidersLocked
                     -->  updateProviderListenersLocked
                         -->  applyRequirementsLocked(provider);
                                 --> p.setRequest(providerRequest, worksource);
                                     -->  public void setRequest(ProviderRequest request, WorkSource source)
                                     --> sendMessage(SET_REQUEST, , new GpsRequest(request, source));
                                         -->public void handleMessage(Message msg)
                                             -->handleSetRequest(gpsRequest.request, gpsRequest.source);
                                                 -->startNavigating(singleShot);
                                                     -->native_set_position_mode(mPositionMode, GPS_POSITION_RECURRENCE_PERIODIC,interval, , )
                                                     -->native_start()  

 Android系统运行的第一个进程就是init进程，在该进程中创建的第一个虚拟机就是zygote，zygote孵化的第一个虚拟机就是Dalvik,该进程就是SystemServer,
 对于的SystemServer代码是framework\base\services\java\com\android\server\SystemServer.java
 该SystemServer对于的第一个运行函数就是main  

 public static void main(String[] args) //SystemServer运行的第一个函数
     ServerThread thr = new ServerThread(); //初始化一个server线程
         class ServerThread
         {
              public void initAndLoop()
              {
                    if (!disableLocation) //开始的时候这里的 disableLocation = false
                    {
              try{
                      Slog.i(TAG, "Location Manager");
  <>                 location = new LocationManagerService(context); //实例化一个LocationManagerService服务，该服务主要用来管理GPS地理位置的变化
                      ServiceManager.addService(Context.LOCATION_SERVICE, location); //将这个service添加到SystemManager中
              }
              catch (Throwable e)
              {
                 reportWtf("starting Location Manager", e);
              }  

              try {
                     Slog.i(TAG, "Country Detector");
                     countryDetector = new CountryDetectorService(context);//实例化一个CountryDetectorService服务，用来探测不同国家，也就是不同地区和时区
                     ServiceManager.addService(Context.COUNTRY_DETECTOR, countryDetector);
              } catch (Throwable e) {
                     reportWtf("starting Country Detector", e);
              }
           }  

         ActivityManagerService.self().systemReady(new Runnable()
         {
             public void run()
             {
                 try
                 {
 <>             if (locationF != null) locationF.systemRunning();//在<1>的位置已给locationF赋值，在这里调用LocationManagerService的systemRunning()函数
             }
             catch(Throwable e)
             {
                reportWtf("Notifying Location Service running", e);
             }
             }
         }  

             }
         }  

 接下来分析LocationManagerService(context)
 /**framework\base\services\java\com\android\server\LocationManagerService.java**/
 public class LocationManagerService extends ILocationManager.Stub
 {
     public void systemRunning() //该函数有<2>处调用
     {
         synchronized (mLock)
         {
         /*GPS启动到运行及监听都在这两个函数里*/
 <>           loadProvidersLocked(); //在这里加载各种provider
 <>           updateProvidersLocked(); //加载后更新
         }
     }
 }  

 /**framework\base\services\java\com\android\server\LocationManagerService.java**/
 private void loadProvidersLocked()
 {
  // create a passive location provider, which is always enabled
     PassiveProvider passiveProvider = new PassiveProvider(this);
     addProviderLocked(passiveProvider);
     mEnabledProviders.add(passiveProvider.getName());
     mPassiveProvider = passiveProvider;
     // Create a gps location provider
 <> GpsLocationProvider gpsProvider = new GpsLocationProvider(mContext, this,
             mLocationHandler.getLooper());  

 <> if (GpsLocationProvider.isSupported()) //这里调用JNI的函数接口
     {
         mGpsStatusProvider = gpsProvider.getGpsStatusProvider(); //获取gps状态provider
         mNetInitiatedListener = gpsProvider.getNetInitiatedListener(); //初始网络监听
         addProviderLocked(gpsProvider); //将gpsProvider添加到mProviders中
         mRealProviders.put(LocationManager.GPS_PROVIDER, gpsProvider);
     }
 }  

 /**分析  <5>  ***/
 public class GpsLocationProvider implements LocationProviderInterface
 {
     static { class_init_native(); } //在这里调用JNI的android_location_GpsLocationProvider_class_init_native函数
 }  

 static void android_location_GpsLocationProvider_class_init_native(JNIEnv* env, jclass clazz)
 {
     err = module->methods->open(module, GPS_HARDWARE_MODULE_ID, &device);//打开GPS设备文件，对应trunk/Android/hardware/xxx/gps/skytraq/skytraq_gps.c
                 -->static int open_gps(const struct hw_module_t *module, char const *name, struct hw_device_t **device)  

     //获取gpsInterface接口，该函数接口在trunk/Android/hardware/xxx/gps/skytraq/skytraq_gps.c中,对应的函数是gps__get_gps_interface
     sGpsInterface = gps_device->get_gps_interface(gps_device);
 }  

 const GpsInterface *gps__get_gps_interface(struct gps_device_t *dev)
 {
     return &skytraqGpsInterface;
 }  

 /**分析 <6>  **/
 public static boolean GpsLocationProvider.isSupported()
 {
     return native_is_supported(); //该函数对应JNI的函数如下
 }  

 static jboolean android_location_GpsLocationProvider_is_supported(JNIEnv* env, jclass clazz)
 {
     return (sGpsInterface != NULL);
 }
 GpsLocationProvider.isSupported()返回true，所以会走if{}里面的。在网上查阅资料，都是基于2.3的系统，.3的系统里是直接在isSupported()函数里来获取接口，没有在GpsLocationProvider类中实现调用class_init_native()来获取接口  

 /**分析 <4> **/
 /**framework\base\services\java\com\android\server\LocationManagerService.java**/
 private void updateProvidersLocked()
 {
     for (int i = mProviders.size() - ; i >= ; i--)
     {
         boolean isEnabled = p.isEnabled(); //开始的时候返回false
         boolean shouldBeEnabled = isAllowedByCurrentUserSettingsLocked(name); //在loadProvidersLocked()函数就说了，一直是enabled
         所以会走else
         else if (!isEnabled && shouldBeEnabled)
          {
 <>      updateProviderListenersLocked(name, true, mCurrentUserId);
          changesMade = true;
      }
     }
     /*发送广播，app和framework都可以接受该广播*/
     if (changesMade) {
             mContext.sendBroadcastAsUser(new Intent(LocationManager.PROVIDERS_CHANGED_ACTION),
                     UserHandle.ALL);
             mContext.sendBroadcastAsUser(new Intent(LocationManager.MODE_CHANGED_ACTION),
                     UserHandle.ALL);
   }
 }  

 /**分析 <7>   framework\base\services\java\com\android\server\locationManagerService.java **/
 private void updateProviderListenersLocked(String provider, boolean enabled, int userId)
 {
     if (records != null)
     {
         //这里主要是从UserHandle里解析UserId 是否等于 mCurrentUserId，如果是则发送notification给receiver
     }
     if (enabled) //这里的 enabled == true
     {
 <>  p.enable();
      if (listeners > )
      {
 <>       applyRequirementsLocked(provider);
      }
   }
      else
      {
      p.disable();
    }  

 }  

 /**分析 <8>   framework\base\services\java\com\android\server\location\gpsLocationProvider.java**/
 public void enable()
 {
     synchronized (mLock)
     {
     if (mEnabled) return;//开始的时候这里是false
     mEnabled = true;
     }
 <>  sendMessage(ENABLE, , null);//发送消息
 }
 /**分析  <10>     base\services\java\com\android\server\location\gpsLocationProvider.java**/
 private void sendMessage(int message, int arg, Object obj)
 {
         // hold a wake lock until this message is delivered
         // note that this assumes the message will not be removed from the queue before
         // it is handled (otherwise the wake lock would be leaked).
         mWakeLock.acquire();
 <>    mHandler.obtainMessage(message, arg, , obj).sendToTarget(); //通过handler机制来发送消息
 }  

 /**分析  <11>     base\services\java\com\android\server\location\gpsLocationProvider.java**/
 private final class ProviderHandler extends Handler
 {
     public void handleMessage(Message msg)
     {
         switch (message)
         {
         case ENABLE:  //有<10>可知，message == ENABLE ， msg.arg1 == 1
         if (msg.arg1 == ) {
 <>        handleEnable(); //所以会调用这个函数
         } else {
             handleDisable();
         }
         break;
     .....
     }
     }
 }  

 /**分析  <12>     framework\base\services\java\com\android\server\location\gpsLocationProvider.java**/
 private void handleEnable()
 {
 <>  boolean enabled = native_init(); //调用JNI中的 static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject obj)
   if (enabled)
   {
       mSupportsXtra = native_supports_xtra(); //native_supports_xtra()直接返回true，在class_init_native()已经赋值  

       if (mSuplServerHost != null)
       {
         /*这里没做任何事，因为sAGpsInterface为空，代码流程如下*/
           native_set_agps_server(AGPS_TYPE_SUPL, mSuplServerHost, mSuplServerPort);
             -->static void android_location_GpsLocationProvider_set_agps_server(JNIEnv* env, jobject obj, jint type, jstring hostname, jint port)
                 -->if (!sAGpsInterface) return;
             -->sAGpsInterface = (const AGpsInterface*)sGpsInterface->get_extension(AGPS_INTERFACE);
                 -->static const void *skytraq_gps_get_extension(const char* name)
                                 {
                                 ALOGD("%s: called", __FUNCTION__);
                                 return NULL;
                                 }  

       }
       if (mC2KServerHost != null) { //同理这里也直接返回了
           native_set_agps_server(AGPS_TYPE_C2K, mC2KServerHost, mC2KServerPort);
       }
   }else{
       synchronized (mLock) {
           mEnabled = false;
       }
       Log.w(TAG, "Failed to enable location provider");
   }  

 }  

 /**分析  <13>  framework\base\services\jni\com_android_server_location_GpsLocationProvider.cpp **/
 static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject obj)
 {
 <>  if (!sGpsInterface || sGpsInterface->init(&sGpsCallbacks) != )//sGpsInterface不为null，在一开始的就已赋值，所以会调用init函数
             return false;
             .....
 }  

 /**分析  <14>   hardware\xxx\gps\skytraq\Skytraq_gps.c **/
 static int skytraq_gps_init(GpsCallbacks* callbacks) //callbacks回调函数时有JNI传下来的，在JNI中实现的
 {
     GpsState*  s = &_gps_state; //该结构图数组初始化的时候都为0
     if (!s->init)
 <>      gps_state_init(s, callbacks);
 }  

 /**分析  <15>   hardware\xxx\gps\skytraq\Skytraq_gps.c **/
 static void gps_state_init( GpsState*  state, GpsCallbacks* callbacks )
 {
     state->fd = gps_channel_open(GPS_CHANNEL_NAME);
             --> fd = open("/dev/skytraq_gps_ipc", O_RDWR |  O_SYNC); //打开串口
     int ret = ioctl(state->fd, GPS_IPC_SET, &gps_connect_info); //调用驱动函数ioctl设置gps
     state->thread = callbacks->create_thread_cb( "gps_state_thread", gps_state_thread, state );//创建线程，用来监听发送的命令和监听数据上报，
 }  

 /**分析<9> frwmework\base\services\java\com\android\server\LocationManagerService.java
 private void applyRequirementsLocked(String provider)
 {
     //设置worksource和providerRequest
     .....
 <16>  p.setRequest(providerRequest, worksource); //location provider 发送请求
 } 

 /**分析<16> frwmework\base\services\java\com\android\server\location\GpsLocationProvider.java**/
 public void setRequest(ProviderRequest request, WorkSource source)
 {
 <>   sendMessage(SET_REQUEST, , new GpsRequest(request, source)); //发送消息，SET_REQUEST == 3
 }  

 /**分析<17> frwmework\base\services\java\com\android\server\location\GpsLocationProvider.java**/
 public void handleMessage(Message msg)
 {
     ...
     case SET_REQUEST:
        GpsRequest gpsRequest = (GpsRequest) msg.obj;
 <>   handleSetRequest(gpsRequest.request, gpsRequest.source);
        break;
 }  

 /**分析<18> frwmework\base\services\java\com\android\server\location\GpsLocationProvider.java**/
 private void handleSetRequest(ProviderRequest request, WorkSource source)
 {
     ...
 <>  startNavigating(singleShot);//开始导航
 }  

 /**分析<19> frwmework\base\services\java\com\android\server\location\GpsLocationProvider.java**/
 private void startNavigating(boolean singleShot)
 {
 <>  native_set_position_mode(mPositionMode, GPS_POSITION_RECURRENCE_PERIODIC, interval, , )//该函数在HAL层直接返回了，没做任何事
 <>  native_start()
 }   

 /**分析<20> framework\base\services\jni\com_android_server_location_GpsLocationProvider.cpp**/
 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)
 {
     if (sGpsInterface)
 <>        return (sGpsInterface->set_position_mode(mode, recurrence, min_interval, preferred_accuracy,
                 preferred_time) == ); //调用HAL层接口
 }  

 /**分析<22> xxx\gps\skytraq\skytraq.gps.c**/
 static int skytraq_gps_set_position_mode(GpsPositionMode mode,
                                       GpsPositionRecurrence recurrence,
                                       uint32_t min_interval,
                                       uint32_t preferred_accuracy,
                                       uint32_t preferred_time)
 {
     ALOGD("%s: called", __FUNCTION__);
     return ;
 }
 /**分析<21> framework\base\services\jni\com_android_server_location_GpsLocationProvider.cpp**/
 static jboolean android_location_GpsLocationProvider_start(JNIEnv* env, jobject obj)
 {
     if (sGpsInterface)
 <>      return (sGpsInterface->start() == ); //调用HAL 层的static int skytraq_gps_start()
 }  

 /**分析<23> xxx\gps\skytraq\skytraq.gps.c**/
 static int skytraq_gps_start()
 {
     gps_state_start(s);
         -->s->status = CMD_START;
   /*在<15>线程函数gps_state_thread()中while(1)中等该命令，进入获取数据*/
 }
 此时GPS就已运行  

1. GPS HAL层代码在目录trunk/Android/hardware/xxx/gps/skytraqskytraq_gsp.c，向下与硬件驱动通讯，向上提供接口
2. GPS JNI层层代码在目录trunk/Android/frameworks/base/services/jni/com_android_server_location_GpsLocationProvider.cpp  C与java转换，给java层提供接口
3. GPS framework层代码目录Android/frameworks/base/services/java/com/android/server下，主要文件是location服务对内部的封装并提供provider服务
4. Android/frameworks/base/location/java/com/android/internal/location这个是framework对location服务内部的实现
5. 启动GPS服务代码流程如下
6. public static void main(String[] args)
7. -->ServerThread thr = new ServerThread();
8. -->location = new LocationManagerService(context);
9. -->ServiceManager.addService(Context.LOCATION_SERVICE, location);
10. -->locationF.systemRunning()
11. -->systemRunning()
12. -->loadProvidersLocked();
13. -->GpsLocationProvider gpsProvider = new GpsLocationProvider(mContext, this, mLocationHandler.getLooper());
14. -->class_init_native();
15. -->android_location_GpsLocationProvider_class_init_native(JNIEnv* env, jclass clazz)
16. -->err = module->methods->open(module, GPS_HARDWARE_MODULE_ID, &device);
17. -->pen_gps(const struct hw_module_t *module, char const *name, struct hw_device_t **device)
18. -->sGpsInterface = gps_device->get_gps_interface(gps_device);
19. -->const GpsInterface *gps__get_gps_interface(struct gps_device_t *dev)
20. -->return &skytraqGpsInterface;
21. -->GpsLocationProvider.isSupported()
22. -->native_is_supported()
23. -->android_location_GpsLocationProvider_is_supported(JNIEnv* env, jclass clazz)
24. -->return (sGpsInterface != NULL);
25. -->updateProvidersLocked
26. -->  updateProviderListenersLocked
27. -->  applyRequirementsLocked(provider);
28. --> p.setRequest(providerRequest, worksource);
29. -->  public void setRequest(ProviderRequest request, WorkSource source)
30. --> sendMessage(SET_REQUEST, 0, new GpsRequest(request, source));
31. -->public void handleMessage(Message msg)
32. -->handleSetRequest(gpsRequest.request, gpsRequest.source);
33. -->startNavigating(singleShot);
34. -->native_set_position_mode(mPositionMode, GPS_POSITION_RECURRENCE_PERIODIC,interval, 0, 0)
35. -->native_start()
36. Android系统运行的第一个进程就是init进程，在该进程中创建的第一个虚拟机就是zygote，zygote孵化的第一个虚拟机就是Dalvik,该进程就是SystemServer,
37. 对于的SystemServer代码是framework\base\services\java\com\android\server\SystemServer.java
38. 该SystemServer对于的第一个运行函数就是main
39. public static void main(String[] args) //SystemServer运行的第一个函数
40. ServerThread thr = new ServerThread(); //初始化一个server线程
41. class ServerThread
42. {
43. public void initAndLoop()
44. {
45. if (!disableLocation) //开始的时候这里的 disableLocation = false
46. {
47. try{
48. Slog.i(TAG, "Location Manager");
49. <1>                 location = new LocationManagerService(context); //实例化一个LocationManagerService服务，该服务主要用来管理GPS地理位置的变化
50. ServiceManager.addService(Context.LOCATION_SERVICE, location); //将这个service添加到SystemManager中
51. }
52. catch (Throwable e)
53. {
54. reportWtf("starting Location Manager", e);
55. }
56. try {
57. Slog.i(TAG, "Country Detector");
58. countryDetector = new CountryDetectorService(context);//实例化一个CountryDetectorService服务，用来探测不同国家，也就是不同地区和时区
59. ServiceManager.addService(Context.COUNTRY_DETECTOR, countryDetector);
60. } catch (Throwable e) {
61. reportWtf("starting Country Detector", e);
62. }
63. }
64. ActivityManagerService.self().systemReady(new Runnable()
65. {
66. public void run()
67. {
68. try
69. {
70. <2>             if (locationF != null) locationF.systemRunning();//在<1>的位置已给locationF赋值，在这里调用LocationManagerService的systemRunning()函数
71. }
72. catch(Throwable e)
73. {
74. reportWtf("Notifying Location Service running", e);
75. }
76. }
77. }
78. }
79. }
80. 接下来分析LocationManagerService(context)
81. /**framework\base\services\java\com\android\server\LocationManagerService.java**/
82. public class LocationManagerService extends ILocationManager.Stub
83. {
84. public void systemRunning() //该函数有<2>处调用
85. {
86. synchronized (mLock)
87. {
88. /*GPS启动到运行及监听都在这两个函数里*/
89. <3>           loadProvidersLocked(); //在这里加载各种provider
90. <4>           updateProvidersLocked(); //加载后更新
91. }
92. }
93. }
94. /**framework\base\services\java\com\android\server\LocationManagerService.java**/
95. private void loadProvidersLocked()
96. {
97. // create a passive location provider, which is always enabled
98. PassiveProvider passiveProvider = new PassiveProvider(this);
99. addProviderLocked(passiveProvider);
100. mEnabledProviders.add(passiveProvider.getName());
101. mPassiveProvider = passiveProvider;
102. // Create a gps location provider
103. <5> GpsLocationProvider gpsProvider = new GpsLocationProvider(mContext, this,
104. mLocationHandler.getLooper());
105. <6> if (GpsLocationProvider.isSupported()) //这里调用JNI的函数接口
106. {
107. mGpsStatusProvider = gpsProvider.getGpsStatusProvider(); //获取gps状态provider
108. mNetInitiatedListener = gpsProvider.getNetInitiatedListener(); //初始网络监听
109. addProviderLocked(gpsProvider); //将gpsProvider添加到mProviders中
110. mRealProviders.put(LocationManager.GPS_PROVIDER, gpsProvider);
111. }
112. }
113. /**分析  <5>  ***/
114. public class GpsLocationProvider implements LocationProviderInterface
115. {
116. static { class_init_native(); } //在这里调用JNI的android_location_GpsLocationProvider_class_init_native函数
117. }
118. static void android_location_GpsLocationProvider_class_init_native(JNIEnv* env, jclass clazz)
119. {
120. err = module->methods->open(module, GPS_HARDWARE_MODULE_ID, &device);//打开GPS设备文件，对应trunk/Android/hardware/xxx/gps/skytraq/skytraq_gps.c
121. -->static int open_gps(const struct hw_module_t *module, char const *name, struct hw_device_t **device)
122. //获取gpsInterface接口，该函数接口在trunk/Android/hardware/xxx/gps/skytraq/skytraq_gps.c中,对应的函数是gps__get_gps_interface
123. sGpsInterface = gps_device->get_gps_interface(gps_device);
124. }
125. const GpsInterface *gps__get_gps_interface(struct gps_device_t *dev)
126. {
127. return &skytraqGpsInterface;
128. }
129. /**分析 <6>  **/
130. public static boolean GpsLocationProvider.isSupported()
131. {
132. return native_is_supported(); //该函数对应JNI的函数如下
133. }
134. static jboolean android_location_GpsLocationProvider_is_supported(JNIEnv* env, jclass clazz)
135. {
136. return (sGpsInterface != NULL);
137. }
138. GpsLocationProvider.isSupported()返回true，所以会走if{}里面的。在网上查阅资料，都是基于2.3的系统，2.3的系统里是直接在isSupported()函数里来获取接口，没有在GpsLocationProvider类中实现调用class_init_native()来获取接口
139. /**分析 <4> **/
140. /**framework\base\services\java\com\android\server\LocationManagerService.java**/
141. private void updateProvidersLocked()
142. {
143. for (int i = mProviders.size() - 1; i >= 0; i--)
144. {
145. boolean isEnabled = p.isEnabled(); //开始的时候返回false
146. boolean shouldBeEnabled = isAllowedByCurrentUserSettingsLocked(name); //在loadProvidersLocked()函数就说了，一直是enabled
147. 所以会走else
148. else if (!isEnabled && shouldBeEnabled)
149. {
150. <7>      updateProviderListenersLocked(name, true, mCurrentUserId);
151. changesMade = true;
152. }
153. }
154. /*发送广播，app和framework都可以接受该广播*/
155. if (changesMade) {
156. mContext.sendBroadcastAsUser(new Intent(LocationManager.PROVIDERS_CHANGED_ACTION),
157. UserHandle.ALL);
158. mContext.sendBroadcastAsUser(new Intent(LocationManager.MODE_CHANGED_ACTION),
159. UserHandle.ALL);
160. }
161. }
162. /**分析 <7>   framework\base\services\java\com\android\server\locationManagerService.java **/
163. private void updateProviderListenersLocked(String provider, boolean enabled, int userId)
164. {
165. if (records != null)
166. {
167. //这里主要是从UserHandle里解析UserId 是否等于 mCurrentUserId，如果是则发送notification给receiver
168. }
169. if (enabled) //这里的 enabled == true
170. {
171. <8>  p.enable();
172. if (listeners > 0)
173. {
174. <9>       applyRequirementsLocked(provider);
175. }
176. }
177. else
178. {
179. p.disable();
180. }
181. }
182. /**分析 <8>   framework\base\services\java\com\android\server\location\gpsLocationProvider.java**/
183. public void enable()
184. {
185. synchronized (mLock)
186. {
187. if (mEnabled) return;//开始的时候这里是false
188. mEnabled = true;
189. }
190. <10>  sendMessage(ENABLE, 1, null);//发送消息
191. }
192. /**分析  <10>     base\services\java\com\android\server\location\gpsLocationProvider.java**/
193. private void sendMessage(int message, int arg, Object obj)
194. {
195. // hold a wake lock until this message is delivered
196. // note that this assumes the message will not be removed from the queue before
197. // it is handled (otherwise the wake lock would be leaked).
198. mWakeLock.acquire();
199. <11>    mHandler.obtainMessage(message, arg, 1, obj).sendToTarget(); //通过handler机制来发送消息
200. }
201. /**分析  <11>     base\services\java\com\android\server\location\gpsLocationProvider.java**/
202. private final class ProviderHandler extends Handler
203. {
204. public void handleMessage(Message msg)
205. {
206. switch (message)
207. {
208. case ENABLE:  //有<10>可知，message == ENABLE ， msg.arg1 == 1
209. if (msg.arg1 == 1) {
210. <12>        handleEnable(); //所以会调用这个函数
211. } else {
212. handleDisable();
213. }
214. break;
215. .....
216. }
217. }
218. }
219. /**分析  <12>     framework\base\services\java\com\android\server\location\gpsLocationProvider.java**/
220. private void handleEnable()
221. {
222. <13>  boolean enabled = native_init(); //调用JNI中的 static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject obj)
223. if (enabled)
224. {
225. mSupportsXtra = native_supports_xtra(); //native_supports_xtra()直接返回true，在class_init_native()已经赋值
226. if (mSuplServerHost != null)
227. {
228. /*这里没做任何事，因为sAGpsInterface为空，代码流程如下*/
229. native_set_agps_server(AGPS_TYPE_SUPL, mSuplServerHost, mSuplServerPort);
230. -->static void android_location_GpsLocationProvider_set_agps_server(JNIEnv* env, jobject obj, jint type, jstring hostname, jint port)
231. -->if (!sAGpsInterface) return;
232. -->sAGpsInterface = (const AGpsInterface*)sGpsInterface->get_extension(AGPS_INTERFACE);
233. -->static const void *skytraq_gps_get_extension(const char* name)
234. {
235. ALOGD("%s: called", __FUNCTION__);
236. return NULL;
237. }
238. }
239. if (mC2KServerHost != null) { //同理这里也直接返回了
240. native_set_agps_server(AGPS_TYPE_C2K, mC2KServerHost, mC2KServerPort);
241. }
242. }else{
243. synchronized (mLock) {
244. mEnabled = false;
245. }
246. Log.w(TAG, "Failed to enable location provider");
247. }
248. }
249. /**分析  <13>  framework\base\services\jni\com_android_server_location_GpsLocationProvider.cpp **/
250. static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject obj)
251. {
252. <14>  if (!sGpsInterface || sGpsInterface->init(&sGpsCallbacks) != 0)//sGpsInterface不为null，在一开始的就已赋值，所以会调用init函数
253. return false;
254. .....
255. }
256. /**分析  <14>   hardware\xxx\gps\skytraq\Skytraq_gps.c **/
257. static int skytraq_gps_init(GpsCallbacks* callbacks) //callbacks回调函数时有JNI传下来的，在JNI中实现的
258. {
259. GpsState*  s = &_gps_state; //该结构图数组初始化的时候都为0
260. if (!s->init)
261. <15>      gps_state_init(s, callbacks);
262. }
263. /**分析  <15>   hardware\xxx\gps\skytraq\Skytraq_gps.c **/
264. static void gps_state_init( GpsState*  state, GpsCallbacks* callbacks )
265. {
266. state->fd = gps_channel_open(GPS_CHANNEL_NAME);
267. --> fd = open("/dev/skytraq_gps_ipc", O_RDWR |  O_SYNC); //打开串口
268. int ret = ioctl(state->fd, GPS_IPC_SET, &gps_connect_info); //调用驱动函数ioctl设置gps
269. state->thread = callbacks->create_thread_cb( "gps_state_thread", gps_state_thread, state );//创建线程，用来监听发送的命令和监听数据上报，
270. }
271. /**分析<9> frwmework\base\services\java\com\android\server\LocationManagerService.java
272. private void applyRequirementsLocked(String provider)
273. {
274. //设置worksource和providerRequest
275. .....
276. <16>  p.setRequest(providerRequest, worksource); //location provider 发送请求
277. }
278. /**分析<16> frwmework\base\services\java\com\android\server\location\GpsLocationProvider.java**/
279. public void setRequest(ProviderRequest request, WorkSource source)
280. {
281. <17>   sendMessage(SET_REQUEST, 0, new GpsRequest(request, source)); //发送消息，SET_REQUEST == 3
282. }
283. /**分析<17> frwmework\base\services\java\com\android\server\location\GpsLocationProvider.java**/
284. public void handleMessage(Message msg)
285. {
286. ...
287. case SET_REQUEST:
288. GpsRequest gpsRequest = (GpsRequest) msg.obj;
289. <18>   handleSetRequest(gpsRequest.request, gpsRequest.source);
290. break;
291. }
292. /**分析<18> frwmework\base\services\java\com\android\server\location\GpsLocationProvider.java**/
293. private void handleSetRequest(ProviderRequest request, WorkSource source)
294. {
295. ...
296. <19>  startNavigating(singleShot);//开始导航
297. }
298. /**分析<19> frwmework\base\services\java\com\android\server\location\GpsLocationProvider.java**/
299. private void startNavigating(boolean singleShot)
300. {
301. <20>  native_set_position_mode(mPositionMode, GPS_POSITION_RECURRENCE_PERIODIC, interval, 0, 0)//该函数在HAL层直接返回了，没做任何事
302. <21>  native_start()
303. }
304. /**分析<20> framework\base\services\jni\com_android_server_location_GpsLocationProvider.cpp**/
305. static jboolean android_location_GpsLocationProvider_set_position_mode(JNIEnv* env, jobject obj,
306. jint mode, jint recurrence, jint min_interval, jint preferred_accuracy, jint preferred_time)
307. {
308. if (sGpsInterface)
309. <22>        return (sGpsInterface->set_position_mode(mode, recurrence, min_interval, preferred_accuracy,
310. preferred_time) == 0); //调用HAL层接口
311. }
312. /**分析<22> xxx\gps\skytraq\skytraq.gps.c**/
313. static int skytraq_gps_set_position_mode(GpsPositionMode mode,
314. GpsPositionRecurrence recurrence,
315. uint32_t min_interval,
316. uint32_t preferred_accuracy,
317. uint32_t preferred_time)
318. {
319. ALOGD("%s: called", __FUNCTION__);
320. return 0;
321. }
322. /**分析<21> framework\base\services\jni\com_android_server_location_GpsLocationProvider.cpp**/
323. static jboolean android_location_GpsLocationProvider_start(JNIEnv* env, jobject obj)
324. {
325. if (sGpsInterface)
326. <23>      return (sGpsInterface->start() == 0); //调用HAL 层的static int skytraq_gps_start()
327. }
328. /**分析<23> xxx\gps\skytraq\skytraq.gps.c**/
329. static int skytraq_gps_start()
330. {
331. gps_state_start(s);
332. -->s->status = CMD_START;
333. /*在<15>线程函数gps_state_thread()中while(1)中等该命令，进入获取数据*/
334. }
335. 此时GPS就已运行