1 /*
2 * Copyright (C) 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <chrono>
18 #include "gnss_measurement.h"
19
20 namespace goldfish {
21 using ::android::hardware::hidl_vec;
22 using GnssClockFlags10 = ahg10::IGnssMeasurementCallback::GnssClockFlags;
23 using GnssMeasurementT20 = ahg20::IGnssMeasurementCallback::GnssMeasurement;
24
25 namespace {
initGnssData(GnssData20 & data,int64_t elapsedRealtimeNs,int64_t timeNs,int64_t fullBiasNs,double biasUncertaintyNs,size_t nMeasurements)26 void initGnssData(GnssData20& data,
27 int64_t elapsedRealtimeNs,
28 int64_t timeNs,
29 int64_t fullBiasNs,
30 double biasUncertaintyNs,
31 size_t nMeasurements) {
32 data.elapsedRealtime.flags = ahg20::ElapsedRealtimeFlags::HAS_TIMESTAMP_NS | 0;
33 data.elapsedRealtime.timestampNs = static_cast<uint64_t>(elapsedRealtimeNs);
34 data.clock.gnssClockFlags = GnssClockFlags10::HAS_FULL_BIAS | 0;
35 data.clock.timeNs = timeNs;
36 data.clock.fullBiasNs = fullBiasNs;
37 data.clock.biasUncertaintyNs = biasUncertaintyNs;
38 data.measurements.resize(nMeasurements);
39 }
40
makeGnssMeasurementT20(int svid,int state,int64_t receivedSvTimeInNs,int64_t receivedSvTimeUncertaintyInNs,double cN0DbHz,double pseudorangeRateMps,double pseudorangeRateUncertaintyMps,int accumulatedDeltaRangeState,double accumulatedDeltaRangeM,double accumulatedDeltaRangeUncertaintyM,int multipathIndicator,int constellation)41 GnssMeasurementT20 makeGnssMeasurementT20(int svid,
42 int state,
43 int64_t receivedSvTimeInNs,
44 int64_t receivedSvTimeUncertaintyInNs,
45 double cN0DbHz,
46 double pseudorangeRateMps,
47 double pseudorangeRateUncertaintyMps,
48 int accumulatedDeltaRangeState,
49 double accumulatedDeltaRangeM,
50 double accumulatedDeltaRangeUncertaintyM,
51 int multipathIndicator,
52 int constellation) {
53 using GnssMeasurementFlags10 = ahg10::IGnssMeasurementCallback::GnssMeasurementFlags;
54 using GnssMultipathIndicator10 = ahg10::IGnssMeasurementCallback::GnssMultipathIndicator;
55 using GnssAccumulatedDeltaRangeState11 = ahg11::IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState;
56 using GnssMeasurementState20 = ahg20::IGnssMeasurementCallback::GnssMeasurementState;
57
58 GnssMeasurementT20 m20;
59 auto& m11 = m20.v1_1;
60 auto& m10 = m11.v1_0;
61
62 m10.flags = GnssMeasurementFlags10::HAS_CARRIER_FREQUENCY | 0;
63 m10.svid = svid;
64 m10.receivedSvTimeInNs = receivedSvTimeInNs;
65 m10.receivedSvTimeUncertaintyInNs = receivedSvTimeUncertaintyInNs;
66 m10.cN0DbHz = cN0DbHz;
67 m10.pseudorangeRateMps = pseudorangeRateMps;
68 m10.pseudorangeRateUncertaintyMps = pseudorangeRateUncertaintyMps;
69 m10.accumulatedDeltaRangeM = accumulatedDeltaRangeM;
70 m10.accumulatedDeltaRangeUncertaintyM = accumulatedDeltaRangeUncertaintyM;
71 m10.carrierFrequencyHz = 1.59975e+09;
72 m10.multipathIndicator = static_cast<GnssMultipathIndicator10>(multipathIndicator);
73 m11.accumulatedDeltaRangeState =
74 GnssAccumulatedDeltaRangeState11::ADR_STATE_UNKNOWN | accumulatedDeltaRangeState;
75 m20.codeType = "UNKNOWN";
76 m20.state = GnssMeasurementState20::STATE_UNKNOWN | state;
77 m20.constellation = static_cast<ahg20::GnssConstellationType>(constellation);
78
79 return m20;
80 }
81 } // namespace
82
GnssMeasurement20()83 GnssMeasurement20::GnssMeasurement20() {
84 m_gnssData.resize(1);
85
86 initGnssData(m_gnssData[0], 139287, 116834000000, -1189181444165780000, 5.26068202130163, 7);
87 m_gnssData[0].measurements[0] = makeGnssMeasurementT20(22, 47, 3927349114, 29, 29.9917297363281, 245.509362821673, 0.148940800975766, 1, 6620.74237064615, 0.00271145859733223, 0, 1);
88 m_gnssData[0].measurements[1] = makeGnssMeasurementT20(23, 47, 3920005435, 14, 36.063377380371, -731.947951627658, 0.0769754027959242, 1, -23229.096048105, 0.00142954161856323, 0, 1);
89 m_gnssData[0].measurements[2] = makeGnssMeasurementT20(25, 47, 3923720994, 56, 24.5171585083007, -329.789995021822, 0.277918601850871, 1, -15511.1976492851, 0.00509250536561012, 0, 1);
90 m_gnssData[0].measurements[3] = makeGnssMeasurementT20(31, 47, 3925772934, 11, 37.9193840026855, -380.23772244582, 0.0602980729893803, 1, -11325.9094456612, 0.00115450704470276, 0, 1);
91 m_gnssData[0].measurements[4] = makeGnssMeasurementT20(32, 47, 3919018415, 21, 32.8980560302734, 581.800347848025, 0.109060249597082, 1, 15707.8963147985, 0.00205808319151401, 0, 1);
92 m_gnssData[0].measurements[5] = makeGnssMeasurementT20(10, 227, 69142929947304, 127, 23.432445526123, 259.17838762857, 0.31591691295607, 4, 8152.78081298147, 3.40282346638528E+38, 0, 3);
93 m_gnssData[0].measurements[6] = makeGnssMeasurementT20(2, 227, 69142935176327, 41, 33.180908203125, -53.8773853795901, 0.104984458760586, 1, -1708.08166640048, 0.00196184404194355, 0, 3);
94 }
95
~GnssMeasurement20()96 GnssMeasurement20::~GnssMeasurement20() {
97 if (m_isRunning) {
98 stopLocked();
99 }
100 }
101
102 Return<GnssMeasurementStatus10>
setCallback_2_0(const sp<ahg20::IGnssMeasurementCallback> & callback,bool enableFullTracking)103 GnssMeasurement20::setCallback_2_0(const sp<ahg20::IGnssMeasurementCallback>& callback,
104 bool enableFullTracking) {
105 (void)enableFullTracking;
106 if (callback == nullptr) {
107 return GnssMeasurementStatus10::ERROR_GENERIC;
108 }
109
110 std::unique_lock<std::mutex> lock(m_mtx);
111 if (m_isRunning) {
112 stopLocked();
113 }
114
115 m_callback = callback;
116 startLocked();
117
118 return GnssMeasurementStatus10::SUCCESS;
119 }
120
close()121 Return<void> GnssMeasurement20::close() {
122 std::unique_lock<std::mutex> lock(m_mtx);
123 if (m_isRunning) {
124 stopLocked();
125 }
126
127 m_callback = nullptr;
128 return {};
129 }
130
startLocked()131 void GnssMeasurement20::startLocked() {
132 m_thread = std::thread([this](){
133 while (m_isRunning) {
134 update();
135 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
136 }
137 });
138 m_isRunning = true;
139 }
140
stopLocked()141 void GnssMeasurement20::stopLocked() {
142 m_isRunning = false;
143 m_thread.join();
144 }
145
update()146 void GnssMeasurement20::update() {
147 std::unique_lock<std::mutex> lock(m_mtx);
148
149 m_callback->gnssMeasurementCb_2_0(m_gnssData[m_gnssDataIndex]);
150 m_gnssDataIndex = (m_gnssDataIndex + 1) % m_gnssData.size();
151 }
152
153 /// old and deprecated /////////////////////////////////////////////////////////
setCallback_1_1(const sp<ahg11::IGnssMeasurementCallback> &,bool)154 Return<GnssMeasurementStatus10> GnssMeasurement20::setCallback_1_1(const sp<ahg11::IGnssMeasurementCallback>&, bool) {
155 return GnssMeasurementStatus10::ERROR_GENERIC;
156 }
157
setCallback(const sp<ahg10::IGnssMeasurementCallback> &)158 Return<GnssMeasurementStatus10> GnssMeasurement20::setCallback(const sp<ahg10::IGnssMeasurementCallback>&) {
159 return GnssMeasurementStatus10::ERROR_GENERIC;
160 }
161
162 } // namespace goldfish
163