• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
3  * Not a Contribution
4  */
5 /*
6  * Copyright (C) 2016 The Android Open Source Project
7  *
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * You may obtain a copy of the License at
11  *
12  *      http://www.apache.org/licenses/LICENSE-2.0
13  *
14  * Unless required by applicable law or agreed to in writing, software
15  * distributed under the License is distributed on an "AS IS" BASIS,
16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * See the License for the specific language governing permissions and
18  * limitations under the License.
19  */
20 
21 #define LOG_TAG "LocSvc_GnssDebugInterface"
22 
23 #include <log/log.h>
24 #include <log_util.h>
25 #include "Gnss.h"
26 #include "GnssDebug.h"
27 #include "LocationUtil.h"
28 
29 namespace android {
30 namespace hardware {
31 namespace gnss {
32 namespace V2_1 {
33 namespace implementation {
34 
35 using ::android::hardware::hidl_vec;
36 using ::android::hardware::gnss::V2_0::IGnssDebug;
37 
38 #define GNSS_DEBUG_UNKNOWN_HORIZONTAL_ACCURACY_METERS (20000000)
39 #define GNSS_DEBUG_UNKNOWN_VERTICAL_ACCURACY_METERS   (20000)
40 #define GNSS_DEBUG_UNKNOWN_SPEED_ACCURACY_PER_SEC     (500)
41 #define GNSS_DEBUG_UNKNOWN_BEARING_ACCURACY_DEG       (180)
42 
43 #define GNSS_DEBUG_UNKNOWN_UTC_TIME            (1483228800000LL) // 1/1/2017 00:00 GMT
44 #define GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MIN    (999) // 999 ns
45 #define GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MAX    (1.57783680E17) // 5 years in ns
46 #define GNSS_DEBUG_UNKNOWN_FREQ_UNC_NS_PER_SEC (2.0e5)  // ppm
47 
GnssDebug(Gnss * gnss)48 GnssDebug::GnssDebug(Gnss* gnss) : mGnss(gnss)
49 {
50 }
51 
52 /*
53  * This methods requests position, time and satellite ephemeris debug information
54  * from the HAL.
55  *
56  * @return void
57 */
getDebugData(getDebugData_cb _hidl_cb)58 Return<void> GnssDebug::getDebugData(getDebugData_cb _hidl_cb)
59 {
60     LOC_LOGD("%s]: ", __func__);
61 
62     V1_0::IGnssDebug::DebugData data = { };
63 
64     if((nullptr == mGnss) || (nullptr == mGnss->getGnssInterface())){
65         LOC_LOGE("GnssDebug - Null GNSS interface");
66         _hidl_cb(data);
67         return Void();
68     }
69 
70     // get debug report snapshot via hal interface
71     GnssDebugReport reports = { };
72     mGnss->getGnssInterface()->getDebugReport(reports);
73 
74     // location block
75     if (reports.mLocation.mValid) {
76         data.position.valid = true;
77         data.position.latitudeDegrees = reports.mLocation.mLocation.latitude;
78         data.position.longitudeDegrees = reports.mLocation.mLocation.longitude;
79         data.position.altitudeMeters = reports.mLocation.mLocation.altitude;
80 
81         data.position.speedMetersPerSec =
82             (double)(reports.mLocation.mLocation.speed);
83         data.position.bearingDegrees =
84             (double)(reports.mLocation.mLocation.bearing);
85         data.position.horizontalAccuracyMeters =
86             (double)(reports.mLocation.mLocation.accuracy);
87         data.position.verticalAccuracyMeters =
88             reports.mLocation.verticalAccuracyMeters;
89         data.position.speedAccuracyMetersPerSecond =
90             reports.mLocation.speedAccuracyMetersPerSecond;
91         data.position.bearingAccuracyDegrees =
92             reports.mLocation.bearingAccuracyDegrees;
93 
94         timeval tv_now, tv_report;
95         tv_report.tv_sec  = reports.mLocation.mUtcReported.tv_sec;
96         tv_report.tv_usec = reports.mLocation.mUtcReported.tv_nsec / 1000ULL;
97         gettimeofday(&tv_now, NULL);
98         data.position.ageSeconds =
99             (tv_now.tv_sec - tv_report.tv_sec) +
100             (float)((tv_now.tv_usec - tv_report.tv_usec)) / 1000000;
101     }
102     else {
103         data.position.valid = false;
104     }
105 
106     if (data.position.horizontalAccuracyMeters <= 0 ||
107         data.position.horizontalAccuracyMeters > GNSS_DEBUG_UNKNOWN_HORIZONTAL_ACCURACY_METERS) {
108         data.position.horizontalAccuracyMeters = GNSS_DEBUG_UNKNOWN_HORIZONTAL_ACCURACY_METERS;
109     }
110     if (data.position.verticalAccuracyMeters <= 0 ||
111         data.position.verticalAccuracyMeters > GNSS_DEBUG_UNKNOWN_VERTICAL_ACCURACY_METERS) {
112         data.position.verticalAccuracyMeters = GNSS_DEBUG_UNKNOWN_VERTICAL_ACCURACY_METERS;
113     }
114     if (data.position.speedAccuracyMetersPerSecond <= 0 ||
115         data.position.speedAccuracyMetersPerSecond > GNSS_DEBUG_UNKNOWN_SPEED_ACCURACY_PER_SEC) {
116         data.position.speedAccuracyMetersPerSecond = GNSS_DEBUG_UNKNOWN_SPEED_ACCURACY_PER_SEC;
117     }
118     if (data.position.bearingAccuracyDegrees <= 0 ||
119         data.position.bearingAccuracyDegrees > GNSS_DEBUG_UNKNOWN_BEARING_ACCURACY_DEG) {
120         data.position.bearingAccuracyDegrees = GNSS_DEBUG_UNKNOWN_BEARING_ACCURACY_DEG;
121     }
122 
123     // time block
124     if (reports.mTime.mValid) {
125         data.time.timeEstimate = reports.mTime.timeEstimate;
126         data.time.timeUncertaintyNs = reports.mTime.timeUncertaintyNs;
127         data.time.frequencyUncertaintyNsPerSec =
128             reports.mTime.frequencyUncertaintyNsPerSec;
129     }
130 
131     if (data.time.timeEstimate < GNSS_DEBUG_UNKNOWN_UTC_TIME) {
132         data.time.timeEstimate = GNSS_DEBUG_UNKNOWN_UTC_TIME;
133     }
134     if (data.time.timeUncertaintyNs <= 0) {
135         data.time.timeUncertaintyNs = (float)GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MIN;
136     } else if (data.time.timeUncertaintyNs > GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MAX) {
137         data.time.timeUncertaintyNs = (float)GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MAX;
138     }
139     if (data.time.frequencyUncertaintyNsPerSec <= 0 ||
140         data.time.frequencyUncertaintyNsPerSec > (float)GNSS_DEBUG_UNKNOWN_FREQ_UNC_NS_PER_SEC) {
141         data.time.frequencyUncertaintyNsPerSec = (float)GNSS_DEBUG_UNKNOWN_FREQ_UNC_NS_PER_SEC;
142     }
143 
144     // satellite data block
145     V1_0::IGnssDebug::SatelliteData s = { };
146     std::vector<V1_0::IGnssDebug::SatelliteData> s_array;
147 
148     for (uint32_t i=0; i<reports.mSatelliteInfo.size(); i++) {
149         memset(&s, 0, sizeof(s));
150         s.svid = reports.mSatelliteInfo[i].svid;
151         convertGnssConstellationType(
152             reports.mSatelliteInfo[i].constellation, s.constellation);
153         convertGnssEphemerisType(
154             reports.mSatelliteInfo[i].mEphemerisType, s.ephemerisType);
155         convertGnssEphemerisSource(
156             reports.mSatelliteInfo[i].mEphemerisSource, s.ephemerisSource);
157         convertGnssEphemerisHealth(
158             reports.mSatelliteInfo[i].mEphemerisHealth, s.ephemerisHealth);
159 
160         s.ephemerisAgeSeconds =
161             reports.mSatelliteInfo[i].ephemerisAgeSeconds;
162         s.serverPredictionIsAvailable =
163             reports.mSatelliteInfo[i].serverPredictionIsAvailable;
164         s.serverPredictionAgeSeconds =
165             reports.mSatelliteInfo[i].serverPredictionAgeSeconds;
166 
167         s_array.push_back(s);
168     }
169     data.satelliteDataArray = s_array;
170 
171     // callback HIDL with collected debug data
172     _hidl_cb(data);
173     return Void();
174 }
175 
getDebugData_2_0(getDebugData_2_0_cb _hidl_cb)176 Return<void> GnssDebug::getDebugData_2_0(getDebugData_2_0_cb _hidl_cb)
177 {
178     LOC_LOGD("%s]: ", __func__);
179 
180     V2_0::IGnssDebug::DebugData data = { };
181 
182     if((nullptr == mGnss) || (nullptr == mGnss->getGnssInterface())){
183         LOC_LOGE("GnssDebug - Null GNSS interface");
184         _hidl_cb(data);
185         return Void();
186     }
187 
188     // get debug report snapshot via hal interface
189     GnssDebugReport reports = { };
190     mGnss->getGnssInterface()->getDebugReport(reports);
191 
192     // location block
193     if (reports.mLocation.mValid) {
194         data.position.valid = true;
195         data.position.latitudeDegrees = reports.mLocation.mLocation.latitude;
196         data.position.longitudeDegrees = reports.mLocation.mLocation.longitude;
197         data.position.altitudeMeters = reports.mLocation.mLocation.altitude;
198 
199         data.position.speedMetersPerSec =
200             (double)(reports.mLocation.mLocation.speed);
201         data.position.bearingDegrees =
202             (double)(reports.mLocation.mLocation.bearing);
203         data.position.horizontalAccuracyMeters =
204             (double)(reports.mLocation.mLocation.accuracy);
205         data.position.verticalAccuracyMeters =
206             reports.mLocation.verticalAccuracyMeters;
207         data.position.speedAccuracyMetersPerSecond =
208             reports.mLocation.speedAccuracyMetersPerSecond;
209         data.position.bearingAccuracyDegrees =
210             reports.mLocation.bearingAccuracyDegrees;
211 
212         timeval tv_now, tv_report;
213         tv_report.tv_sec  = reports.mLocation.mUtcReported.tv_sec;
214         tv_report.tv_usec = reports.mLocation.mUtcReported.tv_nsec / 1000ULL;
215         gettimeofday(&tv_now, NULL);
216         data.position.ageSeconds =
217             (tv_now.tv_sec - tv_report.tv_sec) +
218             (float)((tv_now.tv_usec - tv_report.tv_usec)) / 1000000;
219     }
220     else {
221         data.position.valid = false;
222     }
223 
224     if (data.position.horizontalAccuracyMeters <= 0 ||
225         data.position.horizontalAccuracyMeters > GNSS_DEBUG_UNKNOWN_HORIZONTAL_ACCURACY_METERS) {
226         data.position.horizontalAccuracyMeters = GNSS_DEBUG_UNKNOWN_HORIZONTAL_ACCURACY_METERS;
227     }
228     if (data.position.verticalAccuracyMeters <= 0 ||
229         data.position.verticalAccuracyMeters > GNSS_DEBUG_UNKNOWN_VERTICAL_ACCURACY_METERS) {
230         data.position.verticalAccuracyMeters = GNSS_DEBUG_UNKNOWN_VERTICAL_ACCURACY_METERS;
231     }
232     if (data.position.speedAccuracyMetersPerSecond <= 0 ||
233         data.position.speedAccuracyMetersPerSecond > GNSS_DEBUG_UNKNOWN_SPEED_ACCURACY_PER_SEC) {
234         data.position.speedAccuracyMetersPerSecond = GNSS_DEBUG_UNKNOWN_SPEED_ACCURACY_PER_SEC;
235     }
236     if (data.position.bearingAccuracyDegrees <= 0 ||
237         data.position.bearingAccuracyDegrees > GNSS_DEBUG_UNKNOWN_BEARING_ACCURACY_DEG) {
238         data.position.bearingAccuracyDegrees = GNSS_DEBUG_UNKNOWN_BEARING_ACCURACY_DEG;
239     }
240 
241     // time block
242     if (reports.mTime.mValid) {
243         data.time.timeEstimate = reports.mTime.timeEstimate;
244         data.time.timeUncertaintyNs = reports.mTime.timeUncertaintyNs;
245         data.time.frequencyUncertaintyNsPerSec =
246             reports.mTime.frequencyUncertaintyNsPerSec;
247     }
248 
249     if (data.time.timeEstimate < GNSS_DEBUG_UNKNOWN_UTC_TIME) {
250         data.time.timeEstimate = GNSS_DEBUG_UNKNOWN_UTC_TIME;
251     }
252     if (data.time.timeUncertaintyNs <= 0) {
253         data.time.timeUncertaintyNs = (float)GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MIN;
254     }
255     else if (data.time.timeUncertaintyNs > GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MAX) {
256         data.time.timeUncertaintyNs = (float)GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MAX;
257     }
258     if (data.time.frequencyUncertaintyNsPerSec <= 0 ||
259         data.time.frequencyUncertaintyNsPerSec > (float)GNSS_DEBUG_UNKNOWN_FREQ_UNC_NS_PER_SEC) {
260         data.time.frequencyUncertaintyNsPerSec = (float)GNSS_DEBUG_UNKNOWN_FREQ_UNC_NS_PER_SEC;
261     }
262 
263     // satellite data block
264     V2_0::IGnssDebug::SatelliteData s = { };
265     std::vector<V2_0::IGnssDebug::SatelliteData> s_array;
266 
267     for (uint32_t i=0; i<reports.mSatelliteInfo.size(); i++) {
268         memset(&s, 0, sizeof(s));
269         s.v1_0.svid = reports.mSatelliteInfo[i].svid;
270         convertGnssConstellationType(
271             reports.mSatelliteInfo[i].constellation, s.constellation);
272         convertGnssEphemerisType(
273             reports.mSatelliteInfo[i].mEphemerisType, s.v1_0.ephemerisType);
274         convertGnssEphemerisSource(
275             reports.mSatelliteInfo[i].mEphemerisSource, s.v1_0.ephemerisSource);
276         convertGnssEphemerisHealth(
277             reports.mSatelliteInfo[i].mEphemerisHealth, s.v1_0.ephemerisHealth);
278 
279         s.v1_0.ephemerisAgeSeconds =
280             reports.mSatelliteInfo[i].ephemerisAgeSeconds;
281         s.v1_0.serverPredictionIsAvailable =
282             reports.mSatelliteInfo[i].serverPredictionIsAvailable;
283         s.v1_0.serverPredictionAgeSeconds =
284             reports.mSatelliteInfo[i].serverPredictionAgeSeconds;
285 
286         s_array.push_back(s);
287     }
288     data.satelliteDataArray = s_array;
289 
290     // callback HIDL with collected debug data
291     _hidl_cb(data);
292     return Void();
293 }
294 
295 }  // namespace implementation
296 }  // namespace V2_1
297 }  // namespace gnss
298 }  // namespace hardware
299 }  // namespace android
300