1 /* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
2 *
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are
5 * met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above
9 * copyright notice, this list of conditions and the following
10 * disclaimer in the documentation and/or other materials provided
11 * with the distribution.
12 * * Neither the name of The Linux Foundation, nor the names of its
13 * contributors may be used to endorse or promote products derived
14 * from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30 #define LOG_NDEBUG 0
31 #define LOG_TAG "LocSvc_MeasurementAPIClient"
32
33 #include <log_util.h>
34 #include <loc_cfg.h>
35 #include <inttypes.h>
36
37 #include "LocationUtil.h"
38 #include "MeasurementAPIClient.h"
39 #include <loc_misc_utils.h>
40
41 namespace android {
42 namespace hardware {
43 namespace gnss {
44 namespace V2_1 {
45 namespace implementation {
46
47 using ::android::hardware::gnss::V1_0::IGnssMeasurement;
48 using ::android::hardware::gnss::V2_0::IGnssMeasurementCallback;
49
50 static void convertGnssData(GnssMeasurementsNotification& in,
51 V1_0::IGnssMeasurementCallback::GnssData& out);
52 static void convertGnssData_1_1(GnssMeasurementsNotification& in,
53 V1_1::IGnssMeasurementCallback::GnssData& out);
54 static void convertGnssData_2_0(GnssMeasurementsNotification& in,
55 V2_0::IGnssMeasurementCallback::GnssData& out);
56 static void convertGnssData_2_1(GnssMeasurementsNotification& in,
57 V2_1::IGnssMeasurementCallback::GnssData& out);
58 static void convertGnssMeasurement(GnssMeasurementsData& in,
59 V1_0::IGnssMeasurementCallback::GnssMeasurement& out);
60 static void convertGnssClock(GnssMeasurementsClock& in, IGnssMeasurementCallback::GnssClock& out);
61 static void convertGnssClock_2_1(GnssMeasurementsClock& in,
62 V2_1::IGnssMeasurementCallback::GnssClock& out);
63 static void convertGnssMeasurementsCodeType(GnssMeasurementsCodeType& inCodeType,
64 char* inOtherCodeTypeName,
65 ::android::hardware::hidl_string& out);
66 static void convertGnssMeasurementsAccumulatedDeltaRangeState(GnssMeasurementsAdrStateMask& in,
67 ::android::hardware::hidl_bitfield
68 <V1_1::IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState>& out);
69 static void convertGnssMeasurementsState(GnssMeasurementsStateMask& in,
70 ::android::hardware::hidl_bitfield
71 <V2_0::IGnssMeasurementCallback::GnssMeasurementState>& out);
72 static void convertElapsedRealtimeNanos(GnssMeasurementsNotification& in,
73 ::android::hardware::gnss::V2_0::ElapsedRealtime& elapsedRealtimeNanos);
74
MeasurementAPIClient()75 MeasurementAPIClient::MeasurementAPIClient() :
76 mGnssMeasurementCbIface(nullptr),
77 mGnssMeasurementCbIface_1_1(nullptr),
78 mGnssMeasurementCbIface_2_0(nullptr),
79 mGnssMeasurementCbIface_2_1(nullptr),
80 mTracking(false)
81 {
82 LOC_LOGD("%s]: ()", __FUNCTION__);
83 }
84
~MeasurementAPIClient()85 MeasurementAPIClient::~MeasurementAPIClient()
86 {
87 LOC_LOGD("%s]: ()", __FUNCTION__);
88 }
89
90 // for GpsInterface
91 Return<IGnssMeasurement::GnssMeasurementStatus>
measurementSetCallback(const sp<V1_0::IGnssMeasurementCallback> & callback)92 MeasurementAPIClient::measurementSetCallback(const sp<V1_0::IGnssMeasurementCallback>& callback)
93 {
94 LOC_LOGD("%s]: (%p)", __FUNCTION__, &callback);
95
96 mMutex.lock();
97 mGnssMeasurementCbIface = callback;
98 mMutex.unlock();
99
100 return startTracking();
101 }
102
103 Return<IGnssMeasurement::GnssMeasurementStatus>
measurementSetCallback_1_1(const sp<V1_1::IGnssMeasurementCallback> & callback,GnssPowerMode powerMode,uint32_t timeBetweenMeasurement)104 MeasurementAPIClient::measurementSetCallback_1_1(
105 const sp<V1_1::IGnssMeasurementCallback>& callback,
106 GnssPowerMode powerMode, uint32_t timeBetweenMeasurement)
107 {
108 LOC_LOGD("%s]: (%p) (powermode: %d) (tbm: %d)",
109 __FUNCTION__, &callback, (int)powerMode, timeBetweenMeasurement);
110
111 mMutex.lock();
112 mGnssMeasurementCbIface_1_1 = callback;
113 mMutex.unlock();
114
115 return startTracking(powerMode, timeBetweenMeasurement);
116 }
117
118 Return<IGnssMeasurement::GnssMeasurementStatus>
measurementSetCallback_2_0(const sp<V2_0::IGnssMeasurementCallback> & callback,GnssPowerMode powerMode,uint32_t timeBetweenMeasurement)119 MeasurementAPIClient::measurementSetCallback_2_0(
120 const sp<V2_0::IGnssMeasurementCallback>& callback,
121 GnssPowerMode powerMode, uint32_t timeBetweenMeasurement)
122 {
123 LOC_LOGD("%s]: (%p) (powermode: %d) (tbm: %d)",
124 __FUNCTION__, &callback, (int)powerMode, timeBetweenMeasurement);
125
126 mMutex.lock();
127 mGnssMeasurementCbIface_2_0 = callback;
128 mMutex.unlock();
129
130 return startTracking(powerMode, timeBetweenMeasurement);
131 }
132
measurementSetCallback_2_1(const sp<V2_1::IGnssMeasurementCallback> & callback,GnssPowerMode powerMode,uint32_t timeBetweenMeasurement)133 Return<IGnssMeasurement::GnssMeasurementStatus> MeasurementAPIClient::measurementSetCallback_2_1(
134 const sp<V2_1::IGnssMeasurementCallback>& callback,
135 GnssPowerMode powerMode, uint32_t timeBetweenMeasurement) {
136 LOC_LOGD("%s]: (%p) (powermode: %d) (tbm: %d)",
137 __FUNCTION__, &callback, (int)powerMode, timeBetweenMeasurement);
138
139 mMutex.lock();
140 mGnssMeasurementCbIface_2_1 = callback;
141 mMutex.unlock();
142
143 return startTracking(powerMode, timeBetweenMeasurement);
144 }
145 Return<IGnssMeasurement::GnssMeasurementStatus>
startTracking(GnssPowerMode powerMode,uint32_t timeBetweenMeasurement)146 MeasurementAPIClient::startTracking(
147 GnssPowerMode powerMode, uint32_t timeBetweenMeasurement)
148 {
149 LocationCallbacks locationCallbacks;
150 memset(&locationCallbacks, 0, sizeof(LocationCallbacks));
151 locationCallbacks.size = sizeof(LocationCallbacks);
152
153 locationCallbacks.trackingCb = nullptr;
154 locationCallbacks.batchingCb = nullptr;
155 locationCallbacks.geofenceBreachCb = nullptr;
156 locationCallbacks.geofenceStatusCb = nullptr;
157 locationCallbacks.gnssLocationInfoCb = nullptr;
158 locationCallbacks.gnssNiCb = nullptr;
159 locationCallbacks.gnssSvCb = nullptr;
160 locationCallbacks.gnssNmeaCb = nullptr;
161
162 locationCallbacks.gnssMeasurementsCb = nullptr;
163 if (mGnssMeasurementCbIface_2_1 != nullptr ||
164 mGnssMeasurementCbIface_2_0 != nullptr ||
165 mGnssMeasurementCbIface_1_1 != nullptr ||
166 mGnssMeasurementCbIface != nullptr) {
167 locationCallbacks.gnssMeasurementsCb =
168 [this](GnssMeasurementsNotification gnssMeasurementsNotification) {
169 onGnssMeasurementsCb(gnssMeasurementsNotification);
170 };
171 }
172
173 locAPISetCallbacks(locationCallbacks);
174
175 TrackingOptions options = {};
176 memset(&options, 0, sizeof(TrackingOptions));
177 options.size = sizeof(TrackingOptions);
178 options.minInterval = 1000;
179 options.mode = GNSS_SUPL_MODE_STANDALONE;
180 if (GNSS_POWER_MODE_INVALID != powerMode) {
181 options.powerMode = powerMode;
182 options.tbm = timeBetweenMeasurement;
183 }
184
185 mTracking = true;
186 LOC_LOGD("%s]: start tracking session", __FUNCTION__);
187 locAPIStartTracking(options);
188 return IGnssMeasurement::GnssMeasurementStatus::SUCCESS;
189 }
190
191 // for GpsMeasurementInterface
measurementClose()192 void MeasurementAPIClient::measurementClose() {
193 LOC_LOGD("%s]: ()", __FUNCTION__);
194 mTracking = false;
195 locAPIStopTracking();
196 }
197
198 // callbacks
onGnssMeasurementsCb(GnssMeasurementsNotification gnssMeasurementsNotification)199 void MeasurementAPIClient::onGnssMeasurementsCb(
200 GnssMeasurementsNotification gnssMeasurementsNotification)
201 {
202 LOC_LOGD("%s]: (count: %u active: %d)",
203 __FUNCTION__, gnssMeasurementsNotification.count, mTracking);
204 if (mTracking) {
205 mMutex.lock();
206 sp<V1_0::IGnssMeasurementCallback> gnssMeasurementCbIface = nullptr;
207 sp<V1_1::IGnssMeasurementCallback> gnssMeasurementCbIface_1_1 = nullptr;
208 sp<V2_0::IGnssMeasurementCallback> gnssMeasurementCbIface_2_0 = nullptr;
209 sp<V2_1::IGnssMeasurementCallback> gnssMeasurementCbIface_2_1 = nullptr;
210 if (mGnssMeasurementCbIface_2_1 != nullptr) {
211 gnssMeasurementCbIface_2_1 = mGnssMeasurementCbIface_2_1;
212 } else if (mGnssMeasurementCbIface_2_0 != nullptr) {
213 gnssMeasurementCbIface_2_0 = mGnssMeasurementCbIface_2_0;
214 } else if (mGnssMeasurementCbIface_1_1 != nullptr) {
215 gnssMeasurementCbIface_1_1 = mGnssMeasurementCbIface_1_1;
216 } else if (mGnssMeasurementCbIface != nullptr) {
217 gnssMeasurementCbIface = mGnssMeasurementCbIface;
218 }
219 mMutex.unlock();
220
221 if (gnssMeasurementCbIface_2_1 != nullptr) {
222 V2_1::IGnssMeasurementCallback::GnssData gnssData;
223 convertGnssData_2_1(gnssMeasurementsNotification, gnssData);
224 auto r = gnssMeasurementCbIface_2_1->gnssMeasurementCb_2_1(gnssData);
225 if (!r.isOk()) {
226 LOC_LOGE("%s] Error from gnssMeasurementCb description=%s",
227 __func__, r.description().c_str());
228 }
229 } else if (gnssMeasurementCbIface_2_0 != nullptr) {
230 V2_0::IGnssMeasurementCallback::GnssData gnssData;
231 convertGnssData_2_0(gnssMeasurementsNotification, gnssData);
232 auto r = gnssMeasurementCbIface_2_0->gnssMeasurementCb_2_0(gnssData);
233 if (!r.isOk()) {
234 LOC_LOGE("%s] Error from gnssMeasurementCb description=%s",
235 __func__, r.description().c_str());
236 }
237 } else if (gnssMeasurementCbIface_1_1 != nullptr) {
238 V1_1::IGnssMeasurementCallback::GnssData gnssData;
239 convertGnssData_1_1(gnssMeasurementsNotification, gnssData);
240 auto r = gnssMeasurementCbIface_1_1->gnssMeasurementCb(gnssData);
241 if (!r.isOk()) {
242 LOC_LOGE("%s] Error from gnssMeasurementCb description=%s",
243 __func__, r.description().c_str());
244 }
245 } else if (gnssMeasurementCbIface != nullptr) {
246 V1_0::IGnssMeasurementCallback::GnssData gnssData;
247 convertGnssData(gnssMeasurementsNotification, gnssData);
248 auto r = gnssMeasurementCbIface->GnssMeasurementCb(gnssData);
249 if (!r.isOk()) {
250 LOC_LOGE("%s] Error from GnssMeasurementCb description=%s",
251 __func__, r.description().c_str());
252 }
253 }
254 }
255 }
256
convertGnssMeasurement(GnssMeasurementsData & in,V1_0::IGnssMeasurementCallback::GnssMeasurement & out)257 static void convertGnssMeasurement(GnssMeasurementsData& in,
258 V1_0::IGnssMeasurementCallback::GnssMeasurement& out)
259 {
260 memset(&out, 0, sizeof(out));
261 if (in.flags & GNSS_MEASUREMENTS_DATA_SIGNAL_TO_NOISE_RATIO_BIT)
262 out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_SNR;
263 if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_FREQUENCY_BIT)
264 out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_FREQUENCY;
265 if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_CYCLES_BIT)
266 out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_CYCLES;
267 if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_BIT)
268 out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_PHASE;
269 if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_UNCERTAINTY_BIT)
270 out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_PHASE_UNCERTAINTY;
271 if (in.flags & GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT)
272 out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_AUTOMATIC_GAIN_CONTROL;
273 out.svid = in.svId;
274 convertGnssConstellationType(in.svType, out.constellation);
275 out.timeOffsetNs = in.timeOffsetNs;
276 if (in.stateMask & GNSS_MEASUREMENTS_STATE_CODE_LOCK_BIT)
277 out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_CODE_LOCK;
278 if (in.stateMask & GNSS_MEASUREMENTS_STATE_BIT_SYNC_BIT)
279 out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_BIT_SYNC;
280 if (in.stateMask & GNSS_MEASUREMENTS_STATE_SUBFRAME_SYNC_BIT)
281 out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_SUBFRAME_SYNC;
282 if (in.stateMask & GNSS_MEASUREMENTS_STATE_TOW_DECODED_BIT)
283 out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_TOW_DECODED;
284 if (in.stateMask & GNSS_MEASUREMENTS_STATE_MSEC_AMBIGUOUS_BIT)
285 out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_MSEC_AMBIGUOUS;
286 if (in.stateMask & GNSS_MEASUREMENTS_STATE_SYMBOL_SYNC_BIT)
287 out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_SYMBOL_SYNC;
288 if (in.stateMask & GNSS_MEASUREMENTS_STATE_GLO_STRING_SYNC_BIT)
289 out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GLO_STRING_SYNC;
290 if (in.stateMask & GNSS_MEASUREMENTS_STATE_GLO_TOD_DECODED_BIT)
291 out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GLO_TOD_DECODED;
292 if (in.stateMask & GNSS_MEASUREMENTS_STATE_BDS_D2_BIT_SYNC_BIT)
293 out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_BDS_D2_BIT_SYNC;
294 if (in.stateMask & GNSS_MEASUREMENTS_STATE_BDS_D2_SUBFRAME_SYNC_BIT)
295 out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_BDS_D2_SUBFRAME_SYNC;
296 if (in.stateMask & GNSS_MEASUREMENTS_STATE_GAL_E1BC_CODE_LOCK_BIT)
297 out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GAL_E1BC_CODE_LOCK;
298 if (in.stateMask & GNSS_MEASUREMENTS_STATE_GAL_E1C_2ND_CODE_LOCK_BIT)
299 out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GAL_E1C_2ND_CODE_LOCK;
300 if (in.stateMask & GNSS_MEASUREMENTS_STATE_GAL_E1B_PAGE_SYNC_BIT)
301 out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GAL_E1B_PAGE_SYNC;
302 if (in.stateMask & GNSS_MEASUREMENTS_STATE_SBAS_SYNC_BIT)
303 out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_SBAS_SYNC;
304 out.receivedSvTimeInNs = in.receivedSvTimeNs;
305 out.receivedSvTimeUncertaintyInNs = in.receivedSvTimeUncertaintyNs;
306 out.cN0DbHz = in.carrierToNoiseDbHz;
307 out.pseudorangeRateMps = in.pseudorangeRateMps;
308 out.pseudorangeRateUncertaintyMps = in.pseudorangeRateUncertaintyMps;
309 if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_VALID_BIT)
310 out.accumulatedDeltaRangeState |=
311 IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState::ADR_STATE_VALID;
312 if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_RESET_BIT)
313 out.accumulatedDeltaRangeState |=
314 IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState::ADR_STATE_RESET;
315 if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_CYCLE_SLIP_BIT)
316 out.accumulatedDeltaRangeState |=
317 IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState::ADR_STATE_CYCLE_SLIP;
318 out.accumulatedDeltaRangeM = in.adrMeters;
319 out.accumulatedDeltaRangeUncertaintyM = in.adrUncertaintyMeters;
320 out.carrierFrequencyHz = in.carrierFrequencyHz;
321 out.carrierCycles = in.carrierCycles;
322 out.carrierPhase = in.carrierPhase;
323 out.carrierPhaseUncertainty = in.carrierPhaseUncertainty;
324 uint8_t indicator =
325 static_cast<uint8_t>(IGnssMeasurementCallback::GnssMultipathIndicator::INDICATOR_UNKNOWN);
326 if (in.multipathIndicator & GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_PRESENT)
327 indicator |= IGnssMeasurementCallback::GnssMultipathIndicator::INDICATOR_PRESENT;
328 if (in.multipathIndicator & GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_NOT_PRESENT)
329 indicator |= IGnssMeasurementCallback::GnssMultipathIndicator::INDICATIOR_NOT_PRESENT;
330 out.multipathIndicator =
331 static_cast<IGnssMeasurementCallback::GnssMultipathIndicator>(indicator);
332 out.snrDb = in.signalToNoiseRatioDb;
333 out.agcLevelDb = in.agcLevelDb;
334 }
335
convertGnssClock(GnssMeasurementsClock & in,IGnssMeasurementCallback::GnssClock & out)336 static void convertGnssClock(GnssMeasurementsClock& in, IGnssMeasurementCallback::GnssClock& out)
337 {
338 memset(&out, 0, sizeof(out));
339 if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_LEAP_SECOND_BIT)
340 out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_LEAP_SECOND;
341 if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_UNCERTAINTY_BIT)
342 out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_TIME_UNCERTAINTY;
343 if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_FULL_BIAS_BIT)
344 out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_FULL_BIAS;
345 if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_BIT)
346 out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_BIAS;
347 if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_UNCERTAINTY_BIT)
348 out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_BIAS_UNCERTAINTY;
349 if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_BIT)
350 out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_DRIFT;
351 if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_UNCERTAINTY_BIT)
352 out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_DRIFT_UNCERTAINTY;
353 out.leapSecond = in.leapSecond;
354 out.timeNs = in.timeNs;
355 out.timeUncertaintyNs = in.timeUncertaintyNs;
356 out.fullBiasNs = in.fullBiasNs;
357 out.biasNs = in.biasNs;
358 out.biasUncertaintyNs = in.biasUncertaintyNs;
359 out.driftNsps = in.driftNsps;
360 out.driftUncertaintyNsps = in.driftUncertaintyNsps;
361 out.hwClockDiscontinuityCount = in.hwClockDiscontinuityCount;
362 }
363
convertGnssClock_2_1(GnssMeasurementsClock & in,V2_1::IGnssMeasurementCallback::GnssClock & out)364 static void convertGnssClock_2_1(GnssMeasurementsClock& in,
365 V2_1::IGnssMeasurementCallback::GnssClock& out)
366 {
367 memset(&out, 0, sizeof(out));
368 convertGnssClock(in, out.v1_0);
369 convertGnssConstellationType(in.referenceSignalTypeForIsb.svType,
370 out.referenceSignalTypeForIsb.constellation);
371 out.referenceSignalTypeForIsb.carrierFrequencyHz =
372 in.referenceSignalTypeForIsb.carrierFrequencyHz;
373 convertGnssMeasurementsCodeType(in.referenceSignalTypeForIsb.codeType,
374 in.referenceSignalTypeForIsb.otherCodeTypeName,
375 out.referenceSignalTypeForIsb.codeType);
376 }
377
convertGnssData(GnssMeasurementsNotification & in,V1_0::IGnssMeasurementCallback::GnssData & out)378 static void convertGnssData(GnssMeasurementsNotification& in,
379 V1_0::IGnssMeasurementCallback::GnssData& out)
380 {
381 memset(&out, 0, sizeof(out));
382 out.measurementCount = in.count;
383 if (out.measurementCount > static_cast<uint32_t>(V1_0::GnssMax::SVS_COUNT)) {
384 LOC_LOGW("%s]: Too many measurement %u. Clamps to %d.",
385 __FUNCTION__, out.measurementCount, V1_0::GnssMax::SVS_COUNT);
386 out.measurementCount = static_cast<uint32_t>(V1_0::GnssMax::SVS_COUNT);
387 }
388 for (size_t i = 0; i < out.measurementCount; i++) {
389 convertGnssMeasurement(in.measurements[i], out.measurements[i]);
390 }
391 convertGnssClock(in.clock, out.clock);
392 }
393
convertGnssData_1_1(GnssMeasurementsNotification & in,V1_1::IGnssMeasurementCallback::GnssData & out)394 static void convertGnssData_1_1(GnssMeasurementsNotification& in,
395 V1_1::IGnssMeasurementCallback::GnssData& out)
396 {
397 memset(&out, 0, sizeof(out));
398 out.measurements.resize(in.count);
399 for (size_t i = 0; i < in.count; i++) {
400 convertGnssMeasurement(in.measurements[i], out.measurements[i].v1_0);
401 convertGnssMeasurementsAccumulatedDeltaRangeState(in.measurements[i].adrStateMask,
402 out.measurements[i].accumulatedDeltaRangeState);
403 }
404 convertGnssClock(in.clock, out.clock);
405 }
406
convertGnssData_2_0(GnssMeasurementsNotification & in,V2_0::IGnssMeasurementCallback::GnssData & out)407 static void convertGnssData_2_0(GnssMeasurementsNotification& in,
408 V2_0::IGnssMeasurementCallback::GnssData& out)
409 {
410 memset(&out, 0, sizeof(out));
411 out.measurements.resize(in.count);
412 for (size_t i = 0; i < in.count; i++) {
413 convertGnssMeasurement(in.measurements[i], out.measurements[i].v1_1.v1_0);
414 convertGnssConstellationType(in.measurements[i].svType, out.measurements[i].constellation);
415 convertGnssMeasurementsCodeType(in.measurements[i].codeType,
416 in.measurements[i].otherCodeTypeName,
417 out.measurements[i].codeType);
418 convertGnssMeasurementsAccumulatedDeltaRangeState(in.measurements[i].adrStateMask,
419 out.measurements[i].v1_1.accumulatedDeltaRangeState);
420 convertGnssMeasurementsState(in.measurements[i].stateMask, out.measurements[i].state);
421 }
422 convertGnssClock(in.clock, out.clock);
423 convertElapsedRealtimeNanos(in, out.elapsedRealtime);
424 }
425
convertGnssMeasurementsCodeType(GnssMeasurementsCodeType & inCodeType,char * inOtherCodeTypeName,::android::hardware::hidl_string & out)426 static void convertGnssMeasurementsCodeType(GnssMeasurementsCodeType& inCodeType,
427 char* inOtherCodeTypeName, ::android::hardware::hidl_string& out)
428 {
429 memset(&out, 0, sizeof(out));
430 switch(inCodeType) {
431 case GNSS_MEASUREMENTS_CODE_TYPE_A:
432 out = "A";
433 break;
434 case GNSS_MEASUREMENTS_CODE_TYPE_B:
435 out = "B";
436 break;
437 case GNSS_MEASUREMENTS_CODE_TYPE_C:
438 out = "C";
439 break;
440 case GNSS_MEASUREMENTS_CODE_TYPE_I:
441 out = "I";
442 break;
443 case GNSS_MEASUREMENTS_CODE_TYPE_L:
444 out = "L";
445 break;
446 case GNSS_MEASUREMENTS_CODE_TYPE_M:
447 out = "M";
448 break;
449 case GNSS_MEASUREMENTS_CODE_TYPE_P:
450 out = "P";
451 break;
452 case GNSS_MEASUREMENTS_CODE_TYPE_Q:
453 out = "Q";
454 break;
455 case GNSS_MEASUREMENTS_CODE_TYPE_S:
456 out = "S";
457 break;
458 case GNSS_MEASUREMENTS_CODE_TYPE_W:
459 out = "W";
460 break;
461 case GNSS_MEASUREMENTS_CODE_TYPE_X:
462 out = "X";
463 break;
464 case GNSS_MEASUREMENTS_CODE_TYPE_Y:
465 out = "Y";
466 break;
467 case GNSS_MEASUREMENTS_CODE_TYPE_Z:
468 out = "Z";
469 break;
470 case GNSS_MEASUREMENTS_CODE_TYPE_N:
471 out = "N";
472 break;
473 case GNSS_MEASUREMENTS_CODE_TYPE_OTHER:
474 default:
475 out = inOtherCodeTypeName;
476 break;
477 }
478 }
479
convertGnssMeasurementsAccumulatedDeltaRangeState(GnssMeasurementsAdrStateMask & in,::android::hardware::hidl_bitfield<V1_1::IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState> & out)480 static void convertGnssMeasurementsAccumulatedDeltaRangeState(GnssMeasurementsAdrStateMask& in,
481 ::android::hardware::hidl_bitfield
482 <V1_1::IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState>& out)
483 {
484 memset(&out, 0, sizeof(out));
485 if (in & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_VALID_BIT)
486 out |= IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState::ADR_STATE_VALID;
487 if (in & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_RESET_BIT)
488 out |= IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState::ADR_STATE_RESET;
489 if (in & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_CYCLE_SLIP_BIT)
490 out |= IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState::ADR_STATE_CYCLE_SLIP;
491 if (in & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_HALF_CYCLE_RESOLVED_BIT)
492 out |= IGnssMeasurementCallback::
493 GnssAccumulatedDeltaRangeState::ADR_STATE_HALF_CYCLE_RESOLVED;
494 }
495
convertGnssMeasurementsState(GnssMeasurementsStateMask & in,::android::hardware::hidl_bitfield<V2_0::IGnssMeasurementCallback::GnssMeasurementState> & out)496 static void convertGnssMeasurementsState(GnssMeasurementsStateMask& in,
497 ::android::hardware::hidl_bitfield
498 <V2_0::IGnssMeasurementCallback::GnssMeasurementState>& out)
499 {
500 memset(&out, 0, sizeof(out));
501 if (in & GNSS_MEASUREMENTS_STATE_CODE_LOCK_BIT)
502 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_CODE_LOCK;
503 if (in & GNSS_MEASUREMENTS_STATE_BIT_SYNC_BIT)
504 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_BIT_SYNC;
505 if (in & GNSS_MEASUREMENTS_STATE_SUBFRAME_SYNC_BIT)
506 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_SUBFRAME_SYNC;
507 if (in & GNSS_MEASUREMENTS_STATE_TOW_DECODED_BIT)
508 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_TOW_DECODED;
509 if (in & GNSS_MEASUREMENTS_STATE_MSEC_AMBIGUOUS_BIT)
510 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_MSEC_AMBIGUOUS;
511 if (in & GNSS_MEASUREMENTS_STATE_SYMBOL_SYNC_BIT)
512 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_SYMBOL_SYNC;
513 if (in & GNSS_MEASUREMENTS_STATE_GLO_STRING_SYNC_BIT)
514 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GLO_STRING_SYNC;
515 if (in & GNSS_MEASUREMENTS_STATE_GLO_TOD_DECODED_BIT)
516 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GLO_TOD_DECODED;
517 if (in & GNSS_MEASUREMENTS_STATE_BDS_D2_BIT_SYNC_BIT)
518 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_BDS_D2_BIT_SYNC;
519 if (in & GNSS_MEASUREMENTS_STATE_BDS_D2_SUBFRAME_SYNC_BIT)
520 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_BDS_D2_SUBFRAME_SYNC;
521 if (in & GNSS_MEASUREMENTS_STATE_GAL_E1BC_CODE_LOCK_BIT)
522 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GAL_E1BC_CODE_LOCK;
523 if (in & GNSS_MEASUREMENTS_STATE_GAL_E1C_2ND_CODE_LOCK_BIT)
524 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GAL_E1C_2ND_CODE_LOCK;
525 if (in & GNSS_MEASUREMENTS_STATE_GAL_E1B_PAGE_SYNC_BIT)
526 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GAL_E1B_PAGE_SYNC;
527 if (in & GNSS_MEASUREMENTS_STATE_SBAS_SYNC_BIT)
528 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_SBAS_SYNC;
529 if (in & GNSS_MEASUREMENTS_STATE_TOW_KNOWN_BIT)
530 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_TOW_KNOWN;
531 if (in & GNSS_MEASUREMENTS_STATE_GLO_TOD_KNOWN_BIT)
532 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GLO_TOD_KNOWN;
533 if (in & GNSS_MEASUREMENTS_STATE_2ND_CODE_LOCK_BIT)
534 out |= IGnssMeasurementCallback::GnssMeasurementState::STATE_2ND_CODE_LOCK;
535 }
536
convertGnssData_2_1(GnssMeasurementsNotification & in,V2_1::IGnssMeasurementCallback::GnssData & out)537 static void convertGnssData_2_1(GnssMeasurementsNotification& in,
538 V2_1::IGnssMeasurementCallback::GnssData& out)
539 {
540 memset(&out, 0, sizeof(out));
541 out.measurements.resize(in.count);
542 for (size_t i = 0; i < in.count; i++) {
543 out.measurements[i].flags = 0;
544 convertGnssMeasurement(in.measurements[i], out.measurements[i].v2_0.v1_1.v1_0);
545 convertGnssConstellationType(in.measurements[i].svType,
546 out.measurements[i].v2_0.constellation);
547 convertGnssMeasurementsCodeType(in.measurements[i].codeType,
548 in.measurements[i].otherCodeTypeName,
549 out.measurements[i].v2_0.codeType);
550 convertGnssMeasurementsAccumulatedDeltaRangeState(in.measurements[i].adrStateMask,
551 out.measurements[i].v2_0.v1_1.accumulatedDeltaRangeState);
552 convertGnssMeasurementsState(in.measurements[i].stateMask,
553 out.measurements[i].v2_0.state);
554 out.measurements[i].basebandCN0DbHz = in.measurements[i].basebandCarrierToNoiseDbHz;
555
556 if (in.measurements[i].flags & GNSS_MEASUREMENTS_DATA_SIGNAL_TO_NOISE_RATIO_BIT) {
557 out.measurements[i].flags |=
558 V2_1::IGnssMeasurementCallback::GnssMeasurementFlags::HAS_SNR;
559 }
560 if (in.measurements[i].flags & GNSS_MEASUREMENTS_DATA_CARRIER_FREQUENCY_BIT) {
561 out.measurements[i].flags |=
562 V2_1::IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_FREQUENCY;
563 }
564 if (in.measurements[i].flags & GNSS_MEASUREMENTS_DATA_CARRIER_CYCLES_BIT) {
565 out.measurements[i].flags |=
566 V2_1::IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_CYCLES;
567 }
568 if (in.measurements[i].flags & GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_BIT) {
569 out.measurements[i].flags |=
570 V2_1::IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_PHASE;
571 }
572 if (in.measurements[i].flags & GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_UNCERTAINTY_BIT) {
573 out.measurements[i].flags |=
574 V2_1::IGnssMeasurementCallback::
575 GnssMeasurementFlags::HAS_CARRIER_PHASE_UNCERTAINTY;
576 }
577 if (in.measurements[i].flags & GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT) {
578 out.measurements[i].flags |=
579 V2_1::IGnssMeasurementCallback::GnssMeasurementFlags::HAS_AUTOMATIC_GAIN_CONTROL;
580 }
581 if (in.measurements[i].flags & GNSS_MEASUREMENTS_DATA_FULL_ISB_BIT) {
582 out.measurements[i].fullInterSignalBiasNs = in.measurements[i].fullInterSignalBiasNs;
583 out.measurements[i].flags |=
584 V2_1::IGnssMeasurementCallback::GnssMeasurementFlags::HAS_FULL_ISB;
585 }
586 if (in.measurements[i].flags & GNSS_MEASUREMENTS_DATA_FULL_ISB_UNCERTAINTY_BIT) {
587 out.measurements[i].fullInterSignalBiasUncertaintyNs =
588 in.measurements[i].fullInterSignalBiasUncertaintyNs;
589 out.measurements[i].flags |=
590 V2_1::IGnssMeasurementCallback::
591 GnssMeasurementFlags::HAS_FULL_ISB_UNCERTAINTY;
592 }
593 if (in.measurements[i].flags & GNSS_MEASUREMENTS_DATA_SATELLITE_ISB_BIT) {
594 out.measurements[i].satelliteInterSignalBiasNs =
595 in.measurements[i].satelliteInterSignalBiasNs;
596 out.measurements[i].flags |=
597 V2_1::IGnssMeasurementCallback::GnssMeasurementFlags::HAS_SATELLITE_ISB;
598 }
599 if (in.measurements[i].flags & GNSS_MEASUREMENTS_DATA_SATELLITE_ISB_UNCERTAINTY_BIT) {
600 out.measurements[i].satelliteInterSignalBiasUncertaintyNs =
601 in.measurements[i].satelliteInterSignalBiasUncertaintyNs;
602 out.measurements[i].flags |=
603 V2_1::IGnssMeasurementCallback::
604 GnssMeasurementFlags::HAS_SATELLITE_ISB_UNCERTAINTY;
605 }
606 }
607 convertGnssClock_2_1(in.clock, out.clock);
608 convertElapsedRealtimeNanos(in, out.elapsedRealtime);
609 }
610
convertElapsedRealtimeNanos(GnssMeasurementsNotification & in,::android::hardware::gnss::V2_0::ElapsedRealtime & elapsedRealtime)611 static void convertElapsedRealtimeNanos(GnssMeasurementsNotification& in,
612 ::android::hardware::gnss::V2_0::ElapsedRealtime& elapsedRealtime)
613 {
614 if (in.clock.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_ELAPSED_REAL_TIME_BIT) {
615 elapsedRealtime.flags |= V2_0::ElapsedRealtimeFlags::HAS_TIMESTAMP_NS;
616 uint64_t qtimerDiff = in.clock.elapsedRealTime - getQTimerTickCount();
617 elapsedRealtime.timestampNs = qTimerTicksToNanos(double(qtimerDiff));
618 elapsedRealtime.flags |= V2_0::ElapsedRealtimeFlags::HAS_TIME_UNCERTAINTY_NS;
619 elapsedRealtime.timeUncertaintyNs = in.clock.elapsedRealTimeUnc;
620 } else {
621 const uint32_t UTC_TO_GPS_SECONDS = 315964800;
622 struct timespec currentTime;
623 int64_t sinceBootTimeNanos;
624
625 if (getCurrentTime(currentTime, sinceBootTimeNanos) &&
626 in.clock.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_LEAP_SECOND_BIT &&
627 in.clock.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_FULL_BIAS_BIT &&
628 in.clock.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_BIT &&
629 in.clock.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_UNCERTAINTY_BIT) {
630 int64_t currentTimeNanos = currentTime.tv_sec * 1000000000 + currentTime.tv_nsec;
631 int64_t measTimeNanos = (int64_t)in.clock.timeNs - (int64_t)in.clock.fullBiasNs
632 - (int64_t)in.clock.biasNs - (int64_t)in.clock.leapSecond * 1000000000
633 + (int64_t)UTC_TO_GPS_SECONDS * 1000000000;
634
635 LOC_LOGd("sinceBootTimeNanos:%" PRIi64 " currentTimeNanos:%" PRIi64 ""
636 " measTimeNanos:%" PRIi64 "",
637 sinceBootTimeNanos, currentTimeNanos, measTimeNanos);
638 if (currentTimeNanos >= measTimeNanos) {
639 int64_t ageTimeNanos = currentTimeNanos - measTimeNanos;
640 LOC_LOGD("%s]: ageTimeNanos:%" PRIi64 ")", __FUNCTION__, ageTimeNanos);
641 // the max trusted propagation time 30s for ageTimeNanos to avoid user setting
642 //wrong time, it will affect elapsedRealtimeNanos
643 if (ageTimeNanos >= 0 && ageTimeNanos <= 30000000000) {
644 elapsedRealtime.flags |= V2_0::ElapsedRealtimeFlags::HAS_TIMESTAMP_NS;
645 elapsedRealtime.timestampNs = sinceBootTimeNanos - ageTimeNanos;
646 elapsedRealtime.flags |= V2_0::ElapsedRealtimeFlags::HAS_TIME_UNCERTAINTY_NS;
647 // time uncertainty is the max value between abs(AP_UTC - MP_UTC) and 100ms, to
648 //verify if user change the sys time
649 elapsedRealtime.timeUncertaintyNs =
650 std::max((int64_t)abs(currentTimeNanos - measTimeNanos),
651 (int64_t)100000000);
652 LOC_LOGd("timestampNs:%" PRIi64 ") timeUncertaintyNs:%" PRIi64 ")",
653 elapsedRealtime.timestampNs,
654 elapsedRealtime.timeUncertaintyNs);
655 }
656 }
657 } else {
658 LOC_LOGe("Failed to calculate elapsedRealtimeNanos timestamp");
659 }
660 }
661 }
662
663 } // namespace implementation
664 } // namespace V2_1
665 } // namespace gnss
666 } // namespace hardware
667 } // namespace android
668