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

和菜鸟一起学android4.0.3源码之硬件gps简单移植
关于android定位方式

android 定位一般有四种方法，这四种方式分别是GPS定位、WIFI定位、基站定位、AGPS定位。

1、 Android GPS

需要GPS硬件支持直接和卫星交互来获取当前经纬度，这种方式需要手机支持GPS模块现在大部分的智能机应该都有了。通过GPS方式准确度是最高的但是它的缺点也非常明显。

1、比较耗电

2、绝大部分用户默认不开启GPS模块

3、从GPS模块启动到获取第一次定位数据可能需要比较长的时间

4、室内几乎无法使用。

这其中缺点2、3都是比较致命的。需要指出的是GPS走的是卫星通信的通道在没有网络连接的情况下也能用。

2、 Android基站定位

Android基站定位只要明白了基站/WIFI定位的原理自己实现基站/WIFI定位其实不难。基站定位一般有几种：第一种是利用手机附近的三个基站进行三角定位，由于每个基站的位置是固定的，利用电磁波在这三个基站间中转所需要时间来算出手机所在的坐标；第二种则是利用获取最近的基站的信息，其中包括基站 id、location area code、mobile country code、mobile network code和信号强度将这些数据发送到google的定位web服务里，就能拿到当前所在的位置信息，误差一般在几十米到几百米之内。其中信号强度这个数据很重要。

3、 Android Wifi定位�

根据一个固定的Wifi MAC地址通过收集到的该Wifi热点的位置然后访问网络上的定位服务以获得经纬度坐标。因为它和基站定位其实都需要使用网络所以在Android也统称为Network方式。

4、 AGPS定位�

AGPS（AssistedGPS）辅助全球卫星定位系统是结合GSM或GPRS与传统卫星定位�利用基地台代送辅助卫星信息以缩减GPS芯片获取卫星信号的延迟时间受遮盖的室内也能借基地台讯号弥补减轻GPS芯片对卫星的依赖度。和纯GPS、基地台三角定位比较，AGPS能提供范围更广、更省电、速度更快的定位服务。理想误差范围在10公尺以内，日本和美国都已经成熟运用AGPS于LBS服务（Location Based Service）基于位置的服务。AGPS技术是一种结合了网络基站信息和GPS信息对移动台进行定位的技术，可以在GSM/GPRS、WCDMA和CDMA2000网络中进行使用。该技术需要在手机内增加GPS接收机模块并改造手机的天线，同时要在移动网络上加建位置服务器、差分GPS基准站等设备。AGPS解决方案的优势主要体现在其定位精度上在室外等空旷地区�其精度在正常的GPS工作环境下可以达到10米左右，堪称目前定位精度最高的一种定位技术。该技术的另一优点为首次捕获GPS信号的时间一般仅需几秒，不像GPS的首次捕获时间可能要2-3分钟。

关于android上的gps定位

关于gps定位，从卫星信号到android终端地图显示的整体流程图如下：

以下简单介绍下GPS定位的相关知识

一、GPS简介

GPS(Global Positioning System), 即全球定位系统，它是一个由覆盖全球的24颗卫星组成的卫星系统。其目的是在全球范围内对地面和空中目标进行准确定位和监测。随着全球性空间定位信息应用的日益广泛，GPS提供的全时域、全天候、高精度定位服务将给空间技术、地球物理、大地测绘、遥感技术、交通调度、军事作战以及人们的日常生活带来巨大的变化和深远的影响。

目前的民用GPS设备包括测量型和导航型。其中测量型产品的精度可达到米级甚至毫米级，但至少需要两台（套）才能达到设计精度要求，而且其内部结构复杂，单机成本一般在几万到几十万，适合专业高精度测量环境使用；导航型产品，由于其使用者对精度要求不高，一般为几十米，因此机器内部硬件相对简单，只须一台就可以完成导航工作，加之其价格相对较低，因而更有普及和推广价值。

GPS系统一般由地面控制站、导航卫星和用户接收机（GPS的移动用户端）三大部分组成。导航卫星至少24颗，均匀分布在6个极地轨道上，轨道的夹角为60度，距地平均高度为20200公里，每12恒星时绕地球一周。

二、GPS卫星信号结构

GPS卫星发射的信号包含有三种成分，即50Hz导航电文(D码)、伪随机码(C/A码或P码)和载波(Ll，L2波段)。这3种信号分量都是在同一基准频率F0=10.23MHZ的控制下产生的。

GPS卫星信号结构

GPS卫星所采用的两种测距码，即C/A码和P码（或Y码），均属于伪随机码。

1）C/A码：是由两个10级反馈移位寄存器组合而产生。码长Nu=1024-1=1023比特，码元宽为tu=1/f1=0.97752s,（f1为基准频率f0的10分之1，1.023 MHz）,相应的距离为293.1m。周期为Tu= Nutu=1ms，数码率为1.023Mbit/s。

    C/A码的码长短，共1023个码元，若以每秒50码元的速度搜索，只需20.5s，易于捕获，称捕获码。

    码元宽度大，假设两序列的码元对齐误差为为码元宽度的1/100，则相应的测距误差为2.9m。由于精度低，又称粗码。

2）P码

    P码产生的原理与C/A码相似，但更复杂。发生电路采用的是两组各由12级反馈移位寄存器构成。码长Nu=2.35*10^14比特，码元宽为tu=1/f0=0.097752s，相应的距离为29.3m。周期为Tu= Nutu=267d，数码率为10.23Mbit/s。

     P码的周期长，267天重复一次，实际应用时P码的周期被分成38部分，（每一部分为7天，码长约6.19 ，1012比特），其中1部分闲置，5部分给地面监控站使用，32部分分配给不同卫星，每颗卫星使用P码的不同部分，都具有相同的码长和周期，但结构不同。P码的捕获一般是先捕获C/A码，再根据导航电文信息，捕获P码。由于P码的码元宽度为C/A码的1/10，若取码元对齐精度仍为码元宽度的1/100，则相应的距离误差为0.29m，故P码称为精码。

导航电文是包含有关卫星的参考星历、卫星工作状态、时间改正参数、卫星钟运行状态、轨道摄动改正、大气折射改正和由C/A码捕获P码等导航信息的数据码（或D码）。

    导航电文也是二进制码，依规定格式组成，按帧向外播送。每帧电文含有1500比特，播送速度50bit/s，每帧播送时间30s。

    每帧导航电文含5个子帧，每个子帧分别含有10个字，每个字30比特，故每个子帧共300比特，播发时间6s。为记载多达25颗卫星，子帧4、5各含有25页。子帧1、2、3和子帧4、5的每一页构成一个主帧。主帧中1、2、3的内容每小时更新一次，4、5的内容仅当给卫星注入新的导航电文后才得以更新。

       导航电文的格式：

一帧导航电文的内容

1、 遥测字（TLM-Telemetry WORD）

    位于每个子帧的开头，作为捕获导航电文的前导。

2、转换码（交接字）（HOW-Hand Over Word）

紧接各子帧的遥测字，主要向用户提供用于捕获P码的Z记数。所谓Z记数是从每个星期六/星期日子夜零时起算的时间记数（1.5s），表明下一子帧开始瞬间的GPS时。

3、数据块1：含有卫星钟改正参数及数据龄期、星期的周数编号、电离层改正参数、和卫星工作状态等信息。卫星钟改正参数a0、a1、a2分别表示该卫星的钟差、钟速和钟速变化率。任意时刻t的钟改正数为: 

t=a0+a1(t-t0c)+a2(t-t0c)^2。

参考历元t0e为数据块1的基准时间，从GPS时星期六/星期日子夜零时起算，变化于0-604800s之间。

数据龄期AODC表示卫星钟改正参数的参考时刻t0c与最近一次更新钟改正参数的时间TL之差，主要用于评价钟改正数的可信程度。

现时星期编号WN：表示从1980年1月6日协调时零点起算的GPS时星期数。

4、数据块2：包含在2、3两个子帧里，主要向用户提供有关计算该卫星运行位置的信息。该数据一般称为卫星星历，每30s重复1次，每小时更新一次。

5、数据块3：包含在4、5两个子帧中，主要向用户提供其他GPS卫星的概略星历及其工作状态信息，称为卫星的历书。第3数据块的内容每12.5分钟重复一次，每天更新一次。

三、GPS接收机

天线单元

GPS信号接收机的天线单元为接收设备的前置部分。天线单元包含接收天线和前置放大器两部分。

其中天线部分可能是全向振子天线或小型螺旋天线或微带天线，但从发展趋势来看，以微带天线用的最广、最有前途。

为了提高信号强度，一般在天线后端设置前置放大器，前置放大器的作用是将由极微弱的GPS信号的电磁波能量转换成为弱电流放大。前置放大器分外差式和高放式两种。由于外差式前置放大器不仅具有放大功能，还具有变频功能，即将高频的GPS信号变换成中频信号，这有利于获得稳定的定位精度，所以绝大多数GPS接收机采用外差式天线单元。

信号通道

信号通道是一种软件和硬件相结合的复杂电子装置，是GPS接收机中的核心部分。其主要功能是捕获、跟踪、处理和量测卫星信号，以获得导航定位所需要的数据和信息。通道数目有1到24个不等，由接收机的类型而定。总的来讲，信号通道目前有相关型、平方型和相位型等三种。新一代GPS信号接收机广泛采用相关型通道,主要由信号捕获电路、伪噪声跟踪环路和载波跟踪环路组成。

存储器

这是GPS信号中接收机将定位现场采集的伪距、载波相位测量、人工量测的数据及解译的卫星星历储存起来的一种装置，以供差分导航和作相对定位的测后数据。

微处理机

接收机的计算部分由微处理机和机内软件组成。机内软件是由接收机生产厂家提供的，是实现数据采集、通道自校自动化的重要组成部分，主要用于信号捕获、跟踪和定位计算。微处理机结合机内软件作下列计算和处理：

（1）开机后指令各通道自检，并测定、校正和存储各通道的时延值；

（2）解译卫星星历，计算测站的三维坐标；

（3）由测站定位坐标和卫星星历计算所有卫星的升降时间、方位和高度角，提供可视卫星数据及卫星的工作状况，以便获得最佳定位星位，提高定位精度。

定位

静态定位时，GPS接收机在捕获和跟踪GPS卫星的过程中固定不变，接收机通过高精度测量GPS信号的传播时间，并利用GPS卫星在轨的已知位置解算出接收机天线所在位置的三维坐标。而动态定位则是用GPS接收机测定一个运动物体的运行轨迹。GPS信号接收机所在的运动物体叫做载体（如航行中的船舰，空中的飞机，行走的车辆等）。由于载体上的GPS接收机天线在跟踪GPS卫星的过程中将相对地球而运动，这样，接收机用GPS信号就可实时地测量运动载体的状态参数（瞬间三维位置和三维速度）。

GPS定位还受GPS网的限制，应用GPS卫星定位技术建立的控制网叫GPS网。归纳起来大致可分为两大类：一类是全球或全国性的高精度GPS网，这类GPS网中相邻点的距离在数千公里至上万公里，其主要任务是作为全球高精度坐标框架或全国高精度坐标框架，以为全球性地球动力学和空间科学方面的科学研究工作服务。另一类是区域性的 GPS网，包括城市或矿区GPS网，GPS工程网等，这类网中的相邻点间的距离为几公里至几十公里，其主要任务是直接为国民经济建设服务。

二维位置的确定

由卫星产生的测距信号确定三维位置

GPS接收机常识：

1. 坐标 (coordinate)

　　有2维、3维两种坐标表示，当GPS能够收到4颗及以上卫星的信号时，它能计算出本地的3维坐标：经度、纬度、高度，若只能收到3颗卫星的信号，它只能计算出2维坐标：经度和纬度，这时它可能还会显示高度数据，但这数据是无效的。大部分GPS不仅能以经/纬度(Lat/Long) 的方式，显示坐标，而且还可以用 UTM(Universal TransverseMercator) 等坐标系统显示坐标但我们一般还是使用 LAT/LONG 系统，这主要是由你所使用的地图的坐标系统决定的。

2. 航点 (Landmark or Waypoint)

　　GPS内存中保存的一个点的坐标值。在有GPS信号时，你可以存储成一个易认的名字，还可以给它选定一个图标。航点是GPS数据核心，它是构成“航线”的基础。标记航点是GPS主要功能之一，但是你也可以从地图上读出一个地点的坐标，手工或通过计算机接口输入GPS，成为一个航点。一个航点可以将来用于GOTO功能的目标，也可以选进一条航线 Route，作为一个支点。一般 GPS 能记录500个或以上的航点。

      3. 航线 (ROUTE)

　　航线是GPS内存中存储的一组数据，包括一个起点和一个终点的坐标，还可以包括若干中间点的坐标，每两个坐标点之间的线段叫一条"腿"(leg) 。常见 GPS 能存储20条线路，每条线路30条"腿"。各坐标点可以从现有航点中选择，或是手工/计算机输入数值，输入的路点同时做为一个航点 (Waypoint/Landmark) 保存。

4. 前进方向 (Heading)

　　GPS没有指北针的功能，静止不动时它是不知道方向的。但是一旦动了起来，它就能知道自己的运动方向。GPS每隔一秒更新一次当前地点信息，每一点的坐标和上一点的坐标一比较，就可以知道前进的方向。

      5. 导向 (Bearing)

　　导向功能在以下条件下起作用：

　　1.) 以设定"走向"(GOTO) 目标。"走向"目标的设定可以按"GOTO"键，然后从列表中选择一个航点。以后"导向"功能将导向此航点

　　 2.) 目前有活跃航线 (Activity route)。活跃航线一般在设置 -> 航线菜单下设定。如果目前有活动航线，那么"导向"的点是航线中第一个路点，每到达一个路点后，自动指到下一个路点。

6. 日出日落时间 (Sun set/raise time)

　　大多数GPS能够显示当地的日出、日落时间，这在计划出发 / 宿营时间时是有用的。这个时间是 GPS 根据当地经度和日期计算得到的，是指平原地区的日出、日落时间，在山区因为有山脊遮挡，日照时间根据情况要早晚各少半个小时以上。GPS的时间是从卫星信号得到的格林尼制时间，在设置 (setup) 菜单里可以设置本地的时间偏移，对中国来说，应设+8小时，此值只与时间的显示有关。

7. 航迹 (Plot trail)

　 GPS每秒更新一次坐标信息，所以可以记载自己的运动轨迹。一般GPS能记录1024个以上足迹点，在一个专用页面上，以可调比例尺显示移动轨迹。足迹点的采样有自动和定时两种方式自动采样由 GPS 自动决定足迹点的采样方式，一般是只记录方向转折点，长距离直线行走时不记点；定时采样可以规定采样时间间隔，比如30秒、一分钟、 5 分钟或其他时间，每隔这么长时间记一个足迹点。

四、主流GPS方案供应商

一台GPS设备关键的元件有天线、低噪音放大器(LNA)、射频接收转换(RF Section)、数字部分(也称数字基带，Digital Baseband)、微处理器(Microprocessor)、微处理器周边外设(Processor Peripherals)、输入输出和驱动(I/OandDriver)等几个部分。芯片提供商也强手如云，包括 SiRF、u-blox、Ti、Analog Devices、NXP、高通、英飞凌、索尼、意法半导体、Trimble(天宝)、Atmel、SiGe、u-Nav 等等。

1、SiRF公司

SiRF是GPS芯片的龙头供应商，产品线完整，能够提供完整的解决方案。

代表产品：基于SiRFstarIII 架构的芯片GSC3e/LP与GSC3f/LP、GSC3LT与 GSC3LTf、GSC3LTi and GSC3Ltif，基于 SiRF Instant 架构的 GSCi-5000。现最新的模块为Fastrax iT430，它是基于SiRFstar IV芯片和SiRFaware软件技术的GPS模块。

尺寸：9.6 x 9.6 x 1.85 mm

2、Nemerix

NemeriX 提供的产品包括模拟射频接收器和数字基带处理器。

Nemerix NB1042GPS 接收器模块，世界上功耗最低的GPS芯片组。

3、TI

TI的辅助GPS (A-GPS)解决方案在异步和同步蜂窝式网络内提供快速而精确的定位服务。这些解决方案在优化之后，适用于所有当前和发展中的无线标准（如 GSM、GPRS、EDGE、CDMA、UMTS 和 WCDMA）。 TI 在 2005 年推出的 90nm 工艺技术的单芯片 A-GPS 解决方案，GPS5300NaviLink 4.0单芯片采用 TI DRP技术，可实现离散的GPS解决方案。

4、Atmel

Atmel 的低功耗 GPS 模块芯片组高度集成并能极大节省制版空间。

Atmel与Magellan推出新的GPS芯片组ATR0663，包括一个先进的 GPS 基带和一个具备集成 2D 图形加速器的 LCD 控制器（以实现 2048 x 2048像素的虚拟屏幕支持）、一个 AC97 音频控制器，以及一个图像传感器接口。多种输入/输出 (I/O) 选项，包括以太网 (Ethernet)、USB 2.0 Full Speed Hostand Device、SD/MMC、TWI 和 USART，为PND应用提供了一个高针对性的片上系统 (SoC) 解决方案。

5、意法半导体

ST 也能够提供面向 GPS 应用的全系列解决方案，适用于车载与便携式导航系统。最新一代的 ST 导航/信息娱乐平台名为 NaviFlex，其集成度更高：融合 GPS 接收器和 Nomadik 应用处理器，保证了汽车多媒体应用无与伦比的音频、视频和成像质量。

6、Maxim

       Maxim 公司能够提供低噪声、低功耗的GPS前端接收器和独特的GPS方案。

7、NXP

恩智浦半导体 (NXP Semiconductors，原飞利浦半导体)，恩智浦的解决方案成功地将高质量导航功能与丰富的多媒体处理结合在一起，包括 MP3 播放、标准的以及高清晰的视频播放及录制、调频收音机、图像存储和游戏等。

8、英飞凌

Infineon和Global Locate合作推出的Hammerhead是全球首款单芯片CMOS GPS 接收器。该芯片支持移动站辅助式（MS-A）、移动站基于式（MS-B）、自主式和增强式跟踪模式。一流的室内信号跟踪效果，完全支持辅助式和自主式跟踪模式，即使在最微弱的信号环境中也可以进行高度精确的导航。Hammerhead 芯片的基于主机的软件架构，不仅将器件尺寸和成本减至最小，还允许将协议消息直接嵌入到 GPS 导航软件中。

9、U-Blox

来自瑞士的GPS技术公司u-blox AG公司以往主要提供命名为 TIM的GPS 模块,其中采用的SiRF公司GPS芯片。现在u-blox 也开始注重核心芯片的开发。新推出的 u-blox 5 系列全球定位系统以及随时可用的伽利略系统单芯片和芯片组拥有不到一秒的接收性能。这种新的芯片还拥有 SuperSense-160 dBm 探测和跟踪灵敏度、小于 50mW 的功率需求以及一个小于 100 平方毫米的覆盖区，适用于掌上电脑(PDA)、个人导航设备、照相机、手机、媒体播放器和其它电池操作便携式设备。

10、高通

目前，全球已有总计超过两亿部手机装备了高通公司的gpsOne辅助型GPS 技术。gpsOne 技术支持一系列极具吸引力的位置服务，其中包括各种各样针对消费者、商务和个人安全的应用。

五、GPS标准格式数据

模块输出信息主要包括4个部分：

1、GPS定位信息GPGGA（Global Positioning SystemFix Data）
[html] view plain copy print ?
1. $GPGGA,063740.998,2234.2551,N,11408.0339,E,1,08,00.9,00053.A,M,-2.1,M,,*7B
2. $GPGGA,<1>,<2>,<3>,<4>,<5>,<6>,<7>,<8>,<9>,M,<10>,M,<11>,<12>*hh<CR><LF>
3. <1> UTC时间，hhmmss（时分秒）格式
4. <2> 纬度ddmm.mmmm（度分）格式（前面的0也将被传输）
5. <3> 纬度半球N（北半球）或S（南半球）
6. <4> 经度dddmm.mmmm（度分）格式（前面的0也将被传输）
7. <5> 经度半球E（东经）或W（西经）
8. <6> GPS状态：0=未定位，1=非差分定位，2=差分定位，6=正在估算
9. <7> 正在使用解算位置的卫星数量（00~12）（前面的0也将被传输）
10. <8> HDOP水平精度因子（0.5~99.9）
11. <9> 海拔高度（-9999.9~99999.9）
12. <10> 地球椭球面相对大地水准面的高度
13. <11> 差分时间（从最近一次接收到差分信号开始的秒数，如果不是差分定位将为空）
14. <12> 差分站ID号0000~1023（前面的0也将被传输，如果不是差分定位将为空）
```
$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也将被传输，如果不是差分定位将为空）
```
2、当前卫星信息GPGSA（GPS DOP and ActiveSatellites）
[html] view plain copy print ?
1. $GPGSA,A,3,06,16,14,22,25,01,30,20,,,,,01.6,00.9,01.3*0D
2. $GPGSA,<1>,<2>,<3>,<3>,,,,,<3>,<3>,<3>,<4>,<5>,<6>,<7><CR><LF>
3. <1>模式：M = 手动， A = 自动。
4. <2>定位型式 1 = 未定位， 2 = 二维定位， 3 = 三维定位。
5. <3>PRN 数字：01 至 32 表天空使用中的卫星编号，最多可接收12颗卫星信息。
6. <4> PDOP位置精度因子（0.5~99.9）
7. <5> HDOP水平精度因子（0.5~99.9）
8. <6> VDOP垂直精度因子（0.5~99.9）
9. <7> Checksum.(检查位).
```
$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.(检查位).
```
3、可见卫星信息GPGSV（GPS Satellites in View）
[html] view plain copy print ?
1. $GPGSV,2,1,08,06,26,075,44,16,50,227,47,14,57,097,44,22,17,169,41*70
2. $GPGSV,2,2,08,25,49,352,45,01,64,006,45,30,13,039,39,20,15,312,34*7A
3. $GPGSV,<1>,<2>,<3>,<4>,<5>,<6>,<7>,?<4>,<5>,<6>,<7>,<8><CR><LF>
4. <1> GSV语句的总数
5. <2> 本句GSV的编号
6. <3> 可见卫星的总数，00 至 12。
7. <4> 卫星编号， 01 至 32。
8. <5>卫星仰角， 00 至 90 度。
9. <6>卫星方位角， 000 至 359 度。实际值。
10. <7>讯号噪声比（C/No）， 00 至 99 dB；无表未接收到讯号。
11. <8>Checksum.(检查位).
12. 第<4>,<5>,<6>,<7>项个别卫星会重复出现，每行最多有四颗卫星。其余卫星信息会于次一行出现，若未使用，这些字段会空白。
```
$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>项个别卫星会重复出现，每行最多有四颗卫星。其余卫星信息会于次一行出现，若未使用，这些字段会空白。
```
4、推荐最小定位信息GPRMC（Recommended MinimumSpecific GPS/TRANSIT Data）
[html] view plain copy print ?
1. $GPRMC,012724.000,A,2234.3157,N,11408.0921,E,0.00,,290108,,,A*71
2. $GPRMC,<1>,<2>,<3>,<4>,<5>,<6>,<7>,<8>,<9>,<10>,<11>,<12>*hh<CR><LF>
3. <1> UTC时间，hhmmss（时分秒）格式
4. <2> 定位状态，A=有效定位，V=无效定位
5. <3> 纬度ddmm.mmmm（度分）格式（前面的0也将被传输）
6. <4> 纬度半球N（北半球）或S（南半球）
7. <5> 经度dddmm.mmmm（度分）格式（前面的0也将被传输）
8. <6> 经度半球E（东经）或W（西经）
9. <7> 地面速率（000.0~999.9节，前面的0也将被传输）
10. <8> 地面航向（000.0~359.9度，以真北为参考基准，前面的0也将被传输）
11. <9> UTC日期，ddmmyy（日月年）格式
12. <10> 磁偏角（000.0~180.0度，前面的0也将被传输）
13. <11> 磁偏角方向，E（东）或W（西）
14. <12> 模式指示（仅NMEA0183 3.00版本输出，A=自主定位，D=差分，E=估算，N=数据无效）
15. 我们所关心的是GPRMC这条信息，因为其中包括当前格林威治时间、经度、纬度、日期等。
```
$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这条信息，因为其中包括当前格林威治时间、经度、纬度、日期等。
```
六、linux driver层

UART接口，与gps模块通信，即读取gps的信息。

七、android GPS hal层

因为linux底层驱动只需要有uart接口就可以接收到gps数据了，而android的hal层会调用linux内核层的uart驱动，所以，这里uart驱动就不再分析了，只要hal层打开串口，然后read就可以了，这里我参考的是模拟器的gps。

自己新建的文件夹，用来适配gps：

hardware/libhardware_legacy/gps

gps头文件：

hardware/libhardware_legacy/include/hardware_legacy/gps.h

首先看一下GpsLocation这个结构体。
[html] view plain copy print ?
1. /** Represents a location. */
2. typedef struct {
3. /**set to sizeof(GpsLocation) */
4. size_t size;
5. /**Contains GpsLocationFlags bits. */
6. uint16_t flags;
7. /**Represents latitude in degrees. */
8. double latitude;
9. /**Represents longitude in degrees. */
10. double longitude;
11. /**Represents altitude in meters above the WGS 84 reference
12. *ellipsoid. */
13. double altitude;
14. /**Represents speed in meters per second. */
15. float speed;
16. /**Represents heading in degrees. */
17. float bearing;
18. /**Represents expected accuracy in meters. */
19. float accuracy;
20. /**Timestamp for the location fix. */
21. GpsUtcTime timestamp;
22. } GpsLocation;
```
/** 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;
```
所有我们要知道的数据都在这里了：经度、纬度、海拔、速度、精确度、世界标准时间等。而上层也只是需要这个数据结构，所以只要把这个数据结构给android上层，那么就OK了。

下面还是主要分析下android模拟器是如何实现的。先看下简单的流程图：

首先看下hw主要结构体，gps是注册为hw模块的。编译后是生成gps.*.so的，而他的方法是调用gps_module_methods。
[html] view plain copy print ?
1. const struct hw_module_t HAL_MODULE_INFO_SYM = {
2. .tag =HARDWARE_MODULE_TAG,
3. .version_major = 1,
4. .version_minor = 0,
5. .id =GPS_HARDWARE_MODULE_ID,
6. .name ="Goldfish GPS Module",
7. .author ="The Android Open Source Project",
8. .methods =&gps_module_methods,
9. };
10. 而gps_module_methods又调用了open_gps
11. static struct hw_module_methods_t gps_module_methods ={
12. .open = open_gps
13. };
```
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
};
```
再看看open_gps做了什么，初始化了很多函数指针，具体含义可以看
[html] view plain copy print ?
1. static constGpsInterface qemuGpsInterface = {
2. sizeof(GpsInterface),
3. qemu_gps_init, //打开接口，提供callback函数
4. qemu_gps_start, //开始导航
5. qemu_gps_stop, //停止导航
6. qemu_gps_cleanup, //关闭接口
7. qemu_gps_inject_time,//注入当前时间
8. qemu_gps_inject_location, //注入从其他定位方式得的当前位置。
9. qemu_gps_delete_aiding_data, //
10. qemu_gps_set_position_mode, //设置坐标模式
11. qemu_gps_get_extension, //扩展信息
12. };
```
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, //扩展信息
};
```
然后再看看各个函数，这些函数是jni层会调用到的，这里简单介绍初始化、数据上报等操作。

首先是初始化函数qemu_gps_init，这里调用了gps_state_init函数，然后在这里打开我们要的串口驱动设备，开启读取gps数据的线程。
[html] view plain copy print ?
1. state->fd = open(GPS_Serial_Name, O_RDONLY );
2. state->thread = callbacks->eate_thread_cb("gps_state_thread”,gps_state_thread, tate);
```
state->fd = open(GPS_Serial_Name, O_RDONLY );
state->thread = callbacks->eate_thread_cb("gps_state_thread”,gps_state_thread,  tate);
```
当线程启动以后，那么就会在这个线程中处理一些事情了，接着看下gps_state_thread函数。

这里会把callback函数给设置好，用以传数据给jni层。
[html] view plain copy print ?
1. nmea_reader_set_callback( reader,state->callbacks.location_cb );
```
nmea_reader_set_callback( reader,state->callbacks.location_cb );
```
串口读取gps的数据ret = read( fd, buff, sizeof(buff) );

解析数据 nmea_reader_addc(reader, buff[nn] );

       然后他会调用nmea_reader_parse(r );函数

这个函数会根据不同的gps协议格式来分别处理。

if ( !memcmp(tok.p, "GGA", 3) )

这里会根据GGA的格式来处理，比如：

更新时间nmea_reader_update_time(r, tok_time);

       更新经纬度nmea_reader_update_latlong

       更新海拔nmea_reader_update_altitude
[html] view plain copy print ?
1. else if ( !memcmp(tok.p, "GLL", 3) )
2. else if ( !memcmp(tok.p, "GSA", 3) )
3. else if ( !memcmp(tok.p, "GSV", 3) )
```
else if ( !memcmp(tok.p, "GLL", 3) )
else if ( !memcmp(tok.p, "GSA", 3) )
else if ( !memcmp(tok.p, "GSV", 3) )
```
其他的依次都差不多。具体可以看源码。

最后处理完了以后，把便要把数据给jni层了。通过r->callback( &r->fix );这个callback函数，就是数据传输的主要函数了。

八、android GPS的JNI层

先还是看下jni层的主要流程吧：分为1、java到jni到hal和2、hal到jni到java。

GPS的jni的代码是在下面这个目录下的：
[html] view plain copy print ?
1. /framework/base/services/jni/com_android_server_location_GpsLocationProvider.cpp
```
/framework/base/services/jni/com_android_server_location_GpsLocationProvider.cpp
```
在com_android_server_location_GpsLocationProvider.cpp文件中，实现JNI方法。注意文件的命令方法，com_android_server_location前缀表示的是包名，表示硬件服务GpsLocationProvider是放在frameworks/base/services/java目录的com/android/server/location目录下的，即存在一个命令为

com.android.server.location.GpsLocationProvider的类。

在同一个目录下有一个onload.cpp，这个会注册这个jni并且调用register_android_server_location_GpsLocationProvider来实现java层到hal层的接口的调用。

在android_location_GpsLocationProvider_init函数中，通过Android硬件抽象层提供的hw_get_module方法来加载模块ID为GPS_HARDWARE_MODULE_ID的硬件抽象层模块，其中，GPS_HARDWARE_MODULE_ID是在<hardware/gps.h>中定义的。Android硬件抽象层会根据GPS_HARDWARE_MODULE_ID的值在Android系统的/system/lib/hw目录中找到相应的模块，然后加载起来，并且返回hw_module_t接口给调用者使用。在jniRegisterNativeMethods函数中，第二个参数的值必须对应GpsLocationProvider所在的包的路径，即com/android/server/location/GpsLocationProvider。

下面分步来看下，jni是如何工作的。

首先是onload.cpp这里会调用到

com_android_server_location_GpsLocationProvider.cpp的注册函数

register_android_server_location_GpsLocationProvider，而这个注册函数就注册了应用层的GpsLocationProvider的jni。他会调用下面这个注册函数。具体各个参数含义，第一个是env，是jni技术的主要结构体JNIEnv，第二个参数就是所要注册的java服务程序的包。最后一个是native方法的回调函数了。
[html] view plain copy print ?
1. jniRegisterNativeMethods(env,"com/android/server/location/GpsLocationProvider", sMethods,NELEM(sMethods));
```
jniRegisterNativeMethods(env,"com/android/server/location/GpsLocationProvider", sMethods,NELEM(sMethods));
```
下面的是native方法的一些函数。
[html] view plain copy print ?
1. staticJNINativeMethod sMethods[] = {
2. {"class_init_native","()V", (void*)android_location_GpsLocationProvider_class_init_native},
3. {"native_is_supported","()Z",(void*)android_location_GpsLocationProvider_is_supported},
4. {"native_init", "()Z",(void*)android_location_GpsLocationProvider_init},
5. {"native_cleanup","()V", (void*)android_location_GpsLocationProvider_cleanup},
6. {"native_set_position_mode","(IIIII)Z",(void*)android_location_GpsLocationProvider_set_position_mode},
7. {"native_start", "()Z",(void*)android_location_GpsLocationProvider_start},
8. {"native_stop", "()Z",(void*)android_location_GpsLocationProvider_stop},
9. …………………………
10. };
```
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},
…………………………
};
```
对于这个method做一些简单的解释吧：。

第一个参数name是在java服务层定义的native函数。具体可以看

frameworks/base/location/java/com/android/server/location/GpsLocationProvide.java下的代码。

这个稍后分析。

第二个参数signature是java服务层调用jni层的参数，具体的可以先看下面这个表：
[html] view plain copy print ?
1. 字符 Java类型 C类型
2. V void void
3. Z jboolean boolean
4. I jint int
5. J jlong long
6. D jdouble double
7. F jfloat float
8. B jbyte byte
9. C jchar char
10. S jshort short
```
字符   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
```
数组则以"["开始，用两个字符表示
[html] view plain copy print ?
2. [I jintArray int[]
3. [F jfloatArray float[]
4. [B jbyteArray byte[]
5. [C jcharArray char[]
6. [S jshortArray short[]
7. [D jdoubleArray double[]
8. [J jlongArray long[]
9. [Z jbooleanArray boolean[]
```
 
[I       jintArray      int[]
[F     jfloatArray      float[]
[B     jbyteArray      byte[]
[C    jcharArray       char[]
[S    jshortArray       short[]
[D    jdoubleArray     double[]
[J     jlongArray       long[]
[Z    jbooleanArray     boolean[]
 
```
实际上这些字符是与函数的参数类型一一对应的。

"()"中的字符表示参数，后面的则代表返回值。例如"()V" 就表示void Func();

"(II)V"表示 void Func(int, int);

上面的都是基本类型。如果Java函数的参数是class，则以"L"开头，以";"结尾中间是用"/" 隔开的包及类名。而其对应的C函数名的参数则为jobject. 一个例外是String类，其对应的类为jstring
[html] view plain copy print ?
1. Ljava/lang/String;String jstring
2. Ljava/net/Socket;Socket jobject
```
Ljava/lang/String;String jstring
Ljava/net/Socket;Socket jobject
```
如果JAVA函数位于一个嵌入类，则用$作为类名间的分隔符。

例如"(Ljava/lang/String;Landroid/os/FileUtils$FileStatus;)Z"

由此，上面写函数的参数也知道了。

第三个变量fnPtr是函数指针，指向C函数，也就是在jni的cpp代码中的。

而jni和java代码的交互可以看下图所示：

其实，java层和jni层都是可以互相调用的，而具体的java层调用jni的方法就是native声明的方法；jni调用java的话，要先获取java层的方法id，然后通过CallVoidMethod（）等回调函数实现。

有了以上的知识点作为基础的话，那么现在来分析下GPS的jni代码了。

1、首先是android_location_GpsLocationProvider_class_init_native这个函数了。
[html] view plain copy print ?
1. method_reportLocation =env->GetMethodID(clazz, "reportLocation","(IDDDFFFJ)V");
2. ……………………………………
3. method_requestUtcTime = env->GetMethodID(clazz,"requestUtcTime","()V")
```
method_reportLocation =env->GetMethodID(clazz, "reportLocation","(IDDDFFFJ)V");
    ……………………………………
   method_requestUtcTime = env->GetMethodID(clazz,"requestUtcTime","()V")
```
他先是获取所有的方法id。然后调用hw模块，也就是上面hal层编译的gps.*.so链接库
[html] view plain copy print ?
1. err =hw_get_module(GPS_HARDWARE_MODULE_ID, (hw_module_t const**)&module);
```
err =hw_get_module(GPS_HARDWARE_MODULE_ID, (hw_module_t const**)&module);
```
然后调用了hal层的gps的open函数了。
[html] view plain copy print ?
1. err =module->methods->open(module, GPS_HARDWARE_MODULE_ID, &device);
```
err =module->methods->open(module, GPS_HARDWARE_MODULE_ID, &device);
```
获取接口sGpsInterface =gps_device->get_gps_interface(gps_device);

因为是gps不是agps所以
[html] view plain copy print ?
1. sGpsXtraInterface =
2. (constGpsXtraInterface*)sGpsInterface->get_extension(GPS_XTRA_INTERFACE);
```
sGpsXtraInterface =
          (constGpsXtraInterface*)sGpsInterface->get_extension(GPS_XTRA_INTERFACE);
```
2、接着便是android_location_GpsLocationProvider_init这个初始化函数了。

该函数主要是调用了
[html] view plain copy print ?
1. if(sGpsXtraInterface &&sGpsXtraInterface->init(&sGpsXtraCallbacks) != 0)
2. sGpsXtraInterface = NULL;
```
if(sGpsXtraInterface &&sGpsXtraInterface->init(&sGpsXtraCallbacks) != 0)
        sGpsXtraInterface = NULL;
```
这个函数的函数指针init就调用到hal层的init函数。也就是qemu_gps_init函数了。

这里传进来了callback函数了。

具体如下：
[html] view plain copy print ?
1. GpsCallbackssGpsCallbacks = {
2. sizeof(GpsCallbacks),
3. location_callback, //回调位置信息
4. status_callback, //回调状态信息
5. sv_status_callback, //回调sv状态信息
6. nmea_callback, //上报nema信息
7. set_capabilities_callback, //回调告知框架层GPS的性能
8. acquire_wakelock_callback, //获取GPS锁，不进行休眠
9. release_wakelock_callback, //释放GPS锁
10. create_thread_callback, //创建线程，可以调用java framework的代码
11. request_utc_time_callback, //获取utc时间
12. };
```
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时间
};
```
具体函数可以看下面：
[html] view plain copy print ?
1. staticvoid location_callback(GpsLocation* location)
2. {
3. JNIEnv* env = AndroidRuntime::getJNIEnv();
4. env->CallVoidMethod(mCallbacksObj, method_reportLocation,location->flags,
5. (jdouble)location->latitude,(jdouble)location->longitude,
6. (jdouble)location->altitude,
7. (jfloat)location->speed,(jfloat)location->bearing,
8. (jfloat)location->accuracy,(jlong)location->timestamp);
9. checkAndClearExceptionFromCallback(env,__FUNCTION__);
10. }
```
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__);
}
```
这里会调用method_reportLocation这个方法，这个方法是在java服务层调用的。这里通过CallVoidMethod函数调用了java framework的函数。
[html] view plain copy print ?
1. staticvoid status_callback(GpsStatus* status)
2. {
3. JNIEnv* env = AndroidRuntime::getJNIEnv();
4. env->CallVoidMethod(mCallbacksObj, method_reportStatus,status->status);
5. checkAndClearExceptionFromCallback(env,__FUNCTION__);
6. }
8. staticvoid sv_status_callback(GpsSvStatus* sv_status)
9. {
10. JNIEnv* env = AndroidRuntime::getJNIEnv();
11. memcpy(&sGpsSvStatus, sv_status,sizeof(sGpsSvStatus));
12. env->CallVoidMethod(mCallbacksObj,method_reportSvStatus);
13. checkAndClearExceptionFromCallback(env,__FUNCTION__);
14. }
16. staticvoid nmea_callback(GpsUtcTime timestamp, const char* nmea, int length)
17. {
18. JNIEnv* env = AndroidRuntime::getJNIEnv();
19. // The Java code will call back to readthese values
20. // We do this to avoid creating unnecessaryString objects
21. sNmeaString = nmea;
22. sNmeaStringLength = length;
23. env->CallVoidMethod(mCallbacksObj,method_reportNmea, timestamp);
24. checkAndClearExceptionFromCallback(env,__FUNCTION__);
25. }
27. staticvoid set_capabilities_callback(uint32_t capabilities)
28. {
29. LOGD("set_capabilities_callback:%ld ", capabilities);
30. JNIEnv* env = AndroidRuntime::getJNIEnv();
31. env->CallVoidMethod(mCallbacksObj,method_setEngineCapabilities, capabilities);
32. checkAndClearExceptionFromCallback(env,__FUNCTION__);
33. }
35. staticvoid acquire_wakelock_callback()
36. {
37. acquire_wake_lock(PARTIAL_WAKE_LOCK,WAKE_LOCK_NAME);
38. }
39. 获取GPS的锁
40. staticvoid release_wakelock_callback()
41. {
42. release_wake_lock(WAKE_LOCK_NAME);
43. }
44. 释放了GPS的锁
45. staticvoid request_utc_time_callback()
46. {
47. JNIEnv* env = AndroidRuntime::getJNIEnv();
48. env->CallVoidMethod(mCallbacksObj,method_requestUtcTime);
49. checkAndClearExceptionFromCallback(env,__FUNCTION__);
50. }
51. 更新时间
52. staticpthread_t create_thread_callback(const char* name, void (*start)(void *), void*arg)
53. {
54. return(pthread_t)AndroidRuntime::createJavaThread(name, start, arg);
55. }
56. 创建线程。
```
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
", 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);
}
创建线程。
```
3、其他函数，开启导航，关闭导航等的就不一一介绍了，和上面的类似。可以看源码。

好了，jni层就大概分析好了，那么接着就是framework层的代码了。

九、android GPS的framework层

首先还是主要流程图吧：

Framework层主要就是为上层应用调用提供接口。而GPS的framework层，根据jni的代码我们也可以知道就在下面这个目录下了。

frameworks/base/services/java/com/android/server/location/GpsLocationProvide.java

那么android framework是怎么开始往下调用jni的呢？还是看代码吧。

首先是在frameworks/base/services/java/com/android/server/SystemServer.Java

对于这个系统服务，还是要从android启动流程讲起，首先linux内核启动完了之后，会调用android的init程序，然后挂载文件最小系统，解析init.rc和init.*.rc等脚本，接着zygote，启动虚拟机，然后就是运行到了systemserver了，也就是上面那个SystemServer.Java函数，在这个函数中，先看下SystemServer 这个类，发现了有一个native的init1函数。

native public static void init1(String[]args);

这个函数是调用了jni层的函数的，可以看

frameworks/base/services/jni/com_android_server_SystemServer.cpp

首先是进入其main函数，
[html] view plain copy print ?
1. System.loadLibrary("android_servers");
2. init1(args);
```
System.loadLibrary("android_servers");
      init1(args);
```
加载库，然后就是调用了jni层的init1函数。
[html] view plain copy print ?
1. static voidandroid_server_SystemServer_init1(JNIEnv* env, jobject clazz)
2. {
3. system_init();
4. }
```
static voidandroid_server_SystemServer_init1(JNIEnv* env, jobject clazz)
{
   system_init();
}
```
其调用了system_init();函数，而在system_init函数中
[html] view plain copy print ?
1. jmethodID methodId =env->GetStaticMethodID(clazz, "init2", "()V");
2. env->CallStaticVoidMethod(clazz,methodId);
```
jmethodID methodId =env->GetStaticMethodID(clazz, "init2", "()V");
env->CallStaticVoidMethod(clazz,methodId);
```
他又回调了SystemServer.Java中的init2函数。

在init2函数中
[html] view plain copy print ?
1. public static final void init2() {
2. Slog.i(TAG, "Entered the Android system server!");
3. Thread thr = new ServerThread();
4. thr.setName("android.server.ServerThread");
5. thr.start();
6. }
```
public static final void init2() {
       Slog.i(TAG, "Entered the Android system server!");
       Thread thr = new ServerThread();
       thr.setName("android.server.ServerThread");
       thr.start();
    }
```
创建了一个线程，最后他会调用到ServerThread的run方法。

在其run()方法中会启动很多服务，比如Account Manager、ContentManager、System Content Providers、Lights Service、BatteryService、Vibrator Service、Alarm Manager、InitWatchdog、Window Manager等等，我们这里最主要的就是关注LocationManagerService。
[html] view plain copy print ?
1. try {
2. Slog.i(TAG, "LocationManager");
3. location = new LocationManagerService(context);
4. ServiceManager.addService(Context.LOCATION_SERVICE, location);
5. } catch (Throwable e) {
6. reportWtf("startingLocation Manager", e);
7. }
```
try {
                Slog.i(TAG, "LocationManager");
                location = new LocationManagerService(context);
               ServiceManager.addService(Context.LOCATION_SERVICE, location);
            } catch (Throwable e) {
                reportWtf("startingLocation Manager", e);
           }
```
这里new了一个LocationManagerService对象，并且添加了这个service。

然后finalLocationManagerService locationF = location;
[html] view plain copy print ?
1. try {
2. if (locationF != null)locationF.systemReady();
3. } catch (Throwable e) {
4. reportWtf("makingLocation Service ready", e);
5. }
```
try {
                    if (locationF != null)locationF.systemReady();
                } catch (Throwable e) {
                    reportWtf("makingLocation Service ready", e);
                }
```
当activity manager好了之后就调用了locationF.systemReady();函数了。

下面进LocationManagerService.java中的system函数。
[html] view plain copy print ?
1. voidsystemReady() {
2. // we defer starting up the service untilthe system is ready
3. Thread thread = new Thread(null, this,"LocationManagerService");
4. thread.start();
5. }
```
voidsystemReady() {

        // we defer starting up the service untilthe system is ready
        Thread thread = new Thread(null, this,"LocationManagerService");
        thread.start();
    }
```
这里创建了一个线程，然后线程启动了，接着他会调用run方法。也就是
[html] view plain copy print ?
1. publicvoid run()
2. {
3. Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
4. Looper.prepare();
5. mLocationHandler = newLocationWorkerHandler();
6. initialize();
7. Looper.loop();
8. }
```
publicvoid run()
    {
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        Looper.prepare();
        mLocationHandler = newLocationWorkerHandler();
        initialize();
        Looper.loop();
    }
```
在run方法中，他会初始化一些东东，也就是initialize();函数了。
[html] view plain copy print ?
1. privatevoid initialize() {
2. // Create a wake lock, needs to be donebefore calling loadProviders() below
3. PowerManager powerManager =(PowerManager)
4. mContext.getSystemService(Context.POWER_SERVICE);
5. mWakeLock =
6. powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,WAKELOCK_KEY);
8. // Load providers
9. loadProviders();
10. ………………
11. ………………
12. ｝
```
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();
………………
………………
｝
```
这里主要看loadProviders();函数。
[html] view plain copy print ?
1. privatevoid loadProviders() {
2. synchronized (mLock) {
3. if (sProvidersLoaded) {
4. return;
5. }
7. // Load providers
8. loadProvidersLocked();
9. sProvidersLoaded = true;
10. }
11. }
```
privatevoid loadProviders() {
        synchronized (mLock) {
            if (sProvidersLoaded) {
                return;
            }
 
            // Load providers
            loadProvidersLocked();
            sProvidersLoaded = true;
        }
    }
```
这里又会调用loadProvidersLocked()，然后是_loadProvidersLocked()函数。其中就会调用到我们需要的gpsprovider了。
[html] view plain copy print ?
1. if(GpsLocationProvider.isSupported()) {
2. // Create a gps location provider
3. GpsLocationProvider gpsProvider =new GpsLocationProvider(mContext, this);
4. mGpsStatusProvider =gpsProvider.getGpsStatusProvider();
5. mNetInitiatedListener =gpsProvider.getNetInitiatedListener();
6. addProvider(gpsProvider);
7. mGpsLocationProvider = gpsProvider;
8. }
```
if(GpsLocationProvider.isSupported()) {
            // Create a gps location provider
            GpsLocationProvider gpsProvider =new GpsLocationProvider(mContext, this);
            mGpsStatusProvider =gpsProvider.getGpsStatusProvider();
            mNetInitiatedListener =gpsProvider.getNetInitiatedListener();
            addProvider(gpsProvider);
            mGpsLocationProvider = gpsProvider;
        }
```
在new一个GpsLocationProvider的时候会开一个GpsLocationProviderThread的线程
[html] view plain copy print ?
1. mThread =new GpsLocationProviderThread();
2. mThread.start();
```
mThread =new GpsLocationProviderThread();
mThread.start();
```
然后启动了线程，在这里会初始化，然后主要还是new了一个ProviderHandler的类。
[html] view plain copy print ?
1. initialize();
2. mHandler = new ProviderHandler();
```
   initialize();
            mHandler = new ProviderHandler();
```
这个类中
[html] view plain copy print ?
1. publicvoid handleMessage(Message msg) {
2. int message = msg.what;
3. switch (message) {
4. case ENABLE:
5. if (msg.arg1 == 1) {
6. handleEnable();
7. } else {
8. handleDisable();
9. }
10. break;
11. case ENABLE_TRACKING:
12. handleEnableLocationTracking(msg.arg1 == 1);
13. break;
14. case REQUEST_SINGLE_SHOT:
15. handleRequestSingleShot();
16. break;
17. case UPDATE_NETWORK_STATE:
18. handleUpdateNetworkState(msg.arg1, (NetworkInfo)msg.obj);
19. break;
20. case INJECT_NTP_TIME:
21. handleInjectNtpTime();
22. break;
23. case DOWNLOAD_XTRA_DATA:
24. if (mSupportsXtra) {
25. handleDownloadXtraData();
26. }
27. break;
28. case UPDATE_LOCATION:
29. handleUpdateLocation((Location)msg.obj);
30. break;
31. case ADD_LISTENER:
32. handleAddListener(msg.arg1);
33. break;
34. case REMOVE_LISTENER:
35. handleRemoveListener(msg.arg1);
36. break;
37. }
```
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;
            }
```
就会处理很多事情了。具体可以看上面的代码。

接着他调用了updateProvidersLocked();这个函数。

updateProviderListenersLocked(name,true);

然后就启动了gps服务了
[html] view plain copy print ?
1. if (enabled) {
2. p.enable();
3. if (listeners > 0) {
4. p.setMinTime(getMinTimeLocked(provider), mTmpWorkSource);
5. p.enableLocationTracking(true);
6. }
7. }
```
if (enabled) {
            p.enable();
            if (listeners > 0) {
               p.setMinTime(getMinTimeLocked(provider), mTmpWorkSource);
                p.enableLocationTracking(true);
            }
        }
```
接着我们开始往GpsLocationProvide.java这里看
[html] view plain copy print ?
1. public void enable() {
2. synchronized (mHandler) {
3. sendMessage(ENABLE, 1, null);
4. }
5. }
```
public void enable() {
        synchronized (mHandler) {
            sendMessage(ENABLE, 1, null);
        }
    }
```
这里发送了一个ENABLE消息，然后就会调用到上面ProviderHandler的函数，handleEnable();
[html] view plain copy print ?
1. privatevoid handleEnable() {
2. ……
3. mEnabled = native_init();
5. if (mEnabled) {
6. mSupportsXtra =native_supports_xtra();
7. ……
8. }
```
privatevoid handleEnable() {
       ……
        mEnabled = native_init();
 
        if (mEnabled) {
            mSupportsXtra =native_supports_xtra();
       ……
    }
```
这里就会调用到了jni的native函数了。

而native的所有函数，在jni中我们都已经分析过了。

接着便是

enable函数结束后，那便是
[html] view plain copy print ?
1. publicvoid enableLocationTracking(boolean enable) {
2. // FIXME - should set a flag here to avoidrace conditions with single shot request
3. synchronized (mHandler) {
4. sendMessage(ENABLE_TRACKING,(enable ? 1 : 0), null);
5. }
6. }
```
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);
        }
    }
```
同样，他也发送了ENABLE_TRACKING的消息，接着调用
[html] view plain copy print ?
1. handleEnableLocationTracking(msg.arg1== 1);
2. if (enable) {
3. mTTFF = 0;
4. mLastFixTime = 0;
5. startNavigating(false);
6. }
```
handleEnableLocationTracking(msg.arg1== 1);
if (enable) {
            mTTFF = 0;
            mLastFixTime = 0;
            startNavigating(false);
        }
```
接着调用了startNavigating函数，
[html] view plain copy print ?
1. privatevoid startNavigating(boolean singleShot) {
2. ……
3. if (!native_set_position_mode(mPositionMode,GPS_POSITION_RECURRENCE_PERIODIC,
4. interval, 0, 0)) {
5. mStarted = false;
6. Log.e(TAG,"set_position_mode failed in startNavigating()");
7. return;
8. }
9. if(!native_start()) {
10. mStarted = false;
11. Log.e(TAG, "native_start failedin startNavigating()");
12. return;
13. ……
14. }
15. ｝
```
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;
    ……
   }
｝
```
这里主要还是设置position mode，然后启动了。

接下来，我们看看，jni调用的一些callback函数在这里做了些什么。

首先就是reportLocation函数了。
[html] view plain copy print ?
1. privatevoid reportLocation(int flags, double latitude, double longitude, doublealtitude,
2. float speed, float bearing, floataccuracy, long timestamp) {
3. …………
4. synchronized (mLocation) {
5. mLocationFlags = flags;
6. if ((flags &LOCATION_HAS_LAT_LONG) == LOCATION_HAS_LAT_LONG) {
7. mLocation.setLatitude(latitude);
8. mLocation.setLongitude(longitude);
9. mLocation.setTime(timestamp);
10. }
11. if ((flags &LOCATION_HAS_ALTITUDE) == LOCATION_HAS_ALTITUDE) {
12. mLocation.setAltitude(altitude);
13. } else {
14. mLocation.removeAltitude();
15. }
16. if ((flags &LOCATION_HAS_SPEED) == LOCATION_HAS_SPEED) {
17. mLocation.setSpeed(speed);
18. } else {
19. mLocation.removeSpeed();
20. }
21. if ((flags &LOCATION_HAS_BEARING) == LOCATION_HAS_BEARING) {
22. mLocation.setBearing(bearing);
23. } else {
24. mLocation.removeBearing();
25. }
26. if ((flags & LOCATION_HAS_ACCURACY) ==LOCATION_HAS_ACCURACY) {
27. mLocation.setAccuracy(accuracy);
28. } else {
29. mLocation.removeAccuracy();
30. }
32. try {
33. mLocationManager.reportLocation(mLocation,false);
34. } catch (RemoteException e) {
35. Log.e(TAG,"RemoteException calling reportLocation");
36. }
37. }
39. mLastFixTime =System.currentTimeMillis();
40. // report time to first fix
41. if (mTTFF == 0 && (flags &LOCATION_HAS_LAT_LONG) == LOCATION_HAS_LAT_LONG) {
42. mTTFF = (int)(mLastFixTime -mFixRequestTime);
43. if (DEBUG) Log.d(TAG, "TTFF:" + mTTFF);
45. // notify status listeners
46. synchronized(mListeners) {
47. int size = mListeners.size();
48. for (int i = 0; i <size;i++) {
49. Listener listener =mListeners.get(i);
50. try {
51. listener.mListener.onFirstFix(mTTFF);
52. } catch (RemoteException e){
53. Log.w(TAG,"RemoteException in stopNavigating");
54. mListeners.remove(listener);
55. // adjust for size oflist changing
56. size--;
57. }
58. }
59. }
60. }
62. if (mSingleShot) {
63. stopNavigating();
64. }
65. if (mStarted && mStatus !=LocationProvider.AVAILABLE) {
66. // we want to time out if we do notreceive a fix
67. // within the time out and we arerequesting infrequent fixes
68. if(!hasCapability(GPS_CAPABILITY_SCHEDULING) && mFixInterval <NO_FIX_TIMEOUT) {
69. mAlarmManager.cancel(mTimeoutIntent);
70. }
72. // send an intent to notify that the GPSis receiving fixes.
73. Intent intent = newIntent(LocationManager.GPS_FIX_CHANGE_ACTION);
74. intent.putExtra(LocationManager.EXTRA_GPS_ENABLED, true);
75. mContext.sendBroadcast(intent);
76. updateStatus(LocationProvider.AVAILABLE, mSvCount);
77. }
79. if(!hasCapability(GPS_CAPABILITY_SCHEDULING) && mStarted &&mFixInterval > 1000) {
80. if (DEBUG) Log.d(TAG, "gotfix, hibernating");
81. hibernate();
82. }
83. }
```
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();
        }
   }
```
这里对于jni层获取的数据，做了处理后，更新了location信息。

其中下面这些都是给应用层的接口。
[html] view plain copy print ?
1. mLocation.setLatitude(latitude);
2. Location.setLongitude(longitude);
3. mLocation.setTime(timestamp);
```
                           mLocation.setLatitude(latitude);
               mLocation.setLongitude(longitude);
                mLocation.setTime(timestamp);
```
Ok，那么framwork层就介绍到这里了。

十、android GPS的APP层

首先看流程：

接上面的framework层，这里调用了mLocation是new了一个Location的类，这个类主要是给应用层接口的。
[html] view plain copy print ?
1. if((flags & LOCATION_HAS_LAT_LONG) == LOCATION_HAS_LAT_LONG) {
2. mLocation.setLatitude(latitude);
3. mLocation.setLongitude(longitude);
4. mLocation.setTime(timestamp);
5. }
```
if((flags & LOCATION_HAS_LAT_LONG) == LOCATION_HAS_LAT_LONG) {
               mLocation.setLatitude(latitude);
               mLocation.setLongitude(longitude);
                mLocation.setTime(timestamp);
            }
```
其代码在frameworks/base/location/java/android/location/Location.java

取其中一部分的函数做下简单的介绍。
[html] view plain copy print ?
1. /**
2. * Sets the UTC time of this fix, inmilliseconds since January 1,
3. * 1970.
4. */
5. public void setTime(long time) {
6. mTime = time;
7. }
9. /**
10. * Returns the latitude of this fix.
11. */
12. public double getLatitude(){
13. return mLatitude;
14. }
16. /**
17. * Sets the latitude of this fix.
18. */
19. public void setLatitude(double latitude) {
20. mLatitude = latitude;
21. }
23. /**
24. * Returns the longitude of this fix.
25. */
26. public double getLongitude() {
27. return mLongitude;
28. }
30. /**
31. * Sets the longitude of this fix.
32. */
33. public void setLongitude(double longitude){
34. mLongitude = longitude;
35. }
```
    /**
     * 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;
    }
 
```
mLocation.setLatitude(latitude);函数就会把

mLatitude= latitude;

然后，应用层只要getLatitude()就知道了纬度了。

其他的函数接口类似。

简单看下下面的一段应用层的代码

功能：展示GPS信息
[html] view plain copy print ?
1. private void updateToNewLocation(Locationlocation)
2. {
4. if (location != null)
5. {
6. bear = location.getBearing(); //偏离正北方的度数
7. double latitude =location.getLatitude(); //维度
8. double longitude=location.getLongitude(); //经度
9. double GpsSpeed = location.getSpeed(); //速度
10. long GpsTime = location.getTime(); //时间
11. Date date = new Date(GpsTime);
12. DateFormat df = newSimpleDateFormat("yyyy-MM-dd HH:mm:ss");
14. float GpsAlt =(float)location.getAltitude(); //海拔
15. latitudeview.setText("" +latitude);
16. longitudeview.setText("" +longitude);
17. speedview.setText(""+GpsSpeed);
18. timeview.setText(""+df.format(date));
19. altitudeview.setText(""+GpsAlt);
20. bearingview.setText(""+bear);
21. }
22. else
23. {
24. Toast.makeText(this, "无法获取地理信息", Toast.LENGTH_SHORT).show();
25. }
27. }
```
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();
      }
 
}
```
终于，从卫星信号到android APP层获取到数据那个简单的数据流程分析好了。要想更加细致的了解其机制，还是得需要花更多的时间继续深入下去的。其中还有很多的细节，很多概念都不是很明白。只知道个大概。不过通过这次分析，收获不少。凡事都需要从整体到部分再到整理，从整理的GPS框架，到分成很多块理解，再把那些模块整合在一起，从而了解其整个机制。
相关阅读:
Centos7 定时任务
 Linux启动配置文件和运行等级runlevel
Linux 网卡命名规则
 将博客搬至CSDN
Lua调用C++动态链接库.so
使用shell脚本执行批量mongosh语句
 TCP和UDP详解
 经受时延的确认(Delay ACK)
18张图带你了解衡量网络性能的四大指标：带宽、时延、抖动、丢包
 TCP学习
原文地址：https://www.cnblogs.com/LiaoHao/p/3298511.html