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 #define LOG_TAG "GnssMeasCbJni"
18
19 #include "GnssMeasurementCallback.h"
20
21 namespace android::gnss {
22
23 using binder::Status;
24 using hardware::gnss::CorrelationVector;
25 using hardware::gnss::ElapsedRealtime;
26 using hardware::gnss::GnssClock;
27 using hardware::gnss::GnssData;
28 using hardware::gnss::GnssMeasurement;
29 using hardware::gnss::SatellitePvt;
30 using GnssAgc = hardware::gnss::GnssData::GnssAgc;
31
32 namespace {
33 jclass class_arrayList;
34 jclass class_clockInfo;
35 jclass class_correlationVectorBuilder;
36 jclass class_gnssAgc;
37 jclass class_gnssAgcBuilder;
38 jclass class_gnssMeasurementsEvent;
39 jclass class_gnssMeasurementsEventBuilder;
40 jclass class_gnssMeasurement;
41 jclass class_gnssClock;
42 jclass class_positionEcef;
43 jclass class_satellitePvtBuilder;
44 jclass class_velocityEcef;
45
46 jmethodID method_arrayListAdd;
47 jmethodID method_arrayListCtor;
48 jmethodID method_correlationVectorBuilderBuild;
49 jmethodID method_correlationVectorBuilderCtor;
50 jmethodID method_correlationVectorBuilderSetFrequencyOffsetMetersPerSecond;
51 jmethodID method_correlationVectorBuilderSetMagnitude;
52 jmethodID method_correlationVectorBuilderSetSamplingStartMeters;
53 jmethodID method_correlationVectorBuilderSetSamplingWidthMeters;
54 jmethodID method_gnssAgcBuilderCtor;
55 jmethodID method_gnssAgcBuilderSetLevelDb;
56 jmethodID method_gnssAgcBuilderSetConstellationType;
57 jmethodID method_gnssAgcBuilderSetCarrierFrequencyHz;
58 jmethodID method_gnssAgcBuilderBuild;
59 jmethodID method_gnssMeasurementsEventBuilderCtor;
60 jmethodID method_gnssMeasurementsEventBuilderSetClock;
61 jmethodID method_gnssMeasurementsEventBuilderSetMeasurements;
62 jmethodID method_gnssMeasurementsEventBuilderSetGnssAutomaticGainControls;
63 jmethodID method_gnssMeasurementsEventBuilderBuild;
64 jmethodID method_gnssMeasurementsSetCorrelationVectors;
65 jmethodID method_gnssMeasurementsSetSatellitePvt;
66 jmethodID method_gnssClockCtor;
67 jmethodID method_gnssMeasurementCtor;
68 jmethodID method_reportMeasurementData;
69 jmethodID method_satellitePvtBuilderBuild;
70 jmethodID method_satellitePvtBuilderCtor;
71 jmethodID method_satellitePvtBuilderSetPositionEcef;
72 jmethodID method_satellitePvtBuilderSetVelocityEcef;
73 jmethodID method_satellitePvtBuilderSetClockInfo;
74 jmethodID method_satellitePvtBuilderSetIonoDelayMeters;
75 jmethodID method_satellitePvtBuilderSetTropoDelayMeters;
76 jmethodID method_satellitePvtBuilderSetTimeOfClock;
77 jmethodID method_satellitePvtBuilderSetTimeOfEphemeris;
78 jmethodID method_satellitePvtBuilderSetIssueOfDataClock;
79 jmethodID method_satellitePvtBuilderSetIssueOfDataEphemeris;
80 jmethodID method_satellitePvtBuilderSetEphemerisSource;
81 jmethodID method_positionEcef;
82 jmethodID method_velocityEcef;
83 jmethodID method_clockInfo;
84
85 } // anonymous namespace
86
GnssMeasurement_class_init_once(JNIEnv * env,jclass & clazz)87 void GnssMeasurement_class_init_once(JNIEnv* env, jclass& clazz) {
88 method_reportMeasurementData = env->GetMethodID(clazz, "reportMeasurementData",
89 "(Landroid/location/GnssMeasurementsEvent;)V");
90
91 // Initialize GnssMeasurement related classes and methods
92 jclass gnssMeasurementsEventClass = env->FindClass("android/location/GnssMeasurementsEvent");
93 class_gnssMeasurementsEvent = (jclass)env->NewGlobalRef(gnssMeasurementsEventClass);
94 jclass gnssMeasurementsEventBuilderClass =
95 env->FindClass("android/location/GnssMeasurementsEvent$Builder");
96 class_gnssMeasurementsEventBuilder =
97 (jclass)env->NewGlobalRef(gnssMeasurementsEventBuilderClass);
98 method_gnssMeasurementsEventBuilderCtor =
99 env->GetMethodID(class_gnssMeasurementsEventBuilder, "<init>", "()V");
100 method_gnssMeasurementsEventBuilderSetClock =
101 env->GetMethodID(class_gnssMeasurementsEventBuilder, "setClock",
102 "(Landroid/location/GnssClock;)"
103 "Landroid/location/GnssMeasurementsEvent$Builder;");
104 method_gnssMeasurementsEventBuilderSetMeasurements =
105 env->GetMethodID(class_gnssMeasurementsEventBuilder, "setMeasurements",
106 "([Landroid/location/GnssMeasurement;)"
107 "Landroid/location/GnssMeasurementsEvent$Builder;");
108 method_gnssMeasurementsEventBuilderSetGnssAutomaticGainControls =
109 env->GetMethodID(class_gnssMeasurementsEventBuilder, "setGnssAutomaticGainControls",
110 "([Landroid/location/GnssAutomaticGainControl;)"
111 "Landroid/location/GnssMeasurementsEvent$Builder;");
112 method_gnssMeasurementsEventBuilderBuild =
113 env->GetMethodID(class_gnssMeasurementsEventBuilder, "build",
114 "()Landroid/location/GnssMeasurementsEvent;");
115
116 // Initialize GnssAgc related classes and methods
117 jclass gnssAgcClass = env->FindClass("android/location/GnssAutomaticGainControl");
118 class_gnssAgc = (jclass)env->NewGlobalRef(gnssAgcClass);
119 jclass gnssAgcBuilderClass =
120 env->FindClass("android/location/GnssAutomaticGainControl$Builder");
121 class_gnssAgcBuilder = (jclass)env->NewGlobalRef(gnssAgcBuilderClass);
122 method_gnssAgcBuilderCtor = env->GetMethodID(class_gnssAgcBuilder, "<init>", "()V");
123 method_gnssAgcBuilderSetLevelDb =
124 env->GetMethodID(class_gnssAgcBuilder, "setLevelDb",
125 "(D)"
126 "Landroid/location/GnssAutomaticGainControl$Builder;");
127 method_gnssAgcBuilderSetConstellationType =
128 env->GetMethodID(class_gnssAgcBuilder, "setConstellationType",
129 "(I)"
130 "Landroid/location/GnssAutomaticGainControl$Builder;");
131 method_gnssAgcBuilderSetCarrierFrequencyHz =
132 env->GetMethodID(class_gnssAgcBuilder, "setCarrierFrequencyHz",
133 "(J)"
134 "Landroid/location/GnssAutomaticGainControl$Builder;");
135 method_gnssAgcBuilderBuild = env->GetMethodID(class_gnssAgcBuilder, "build",
136 "()Landroid/location/GnssAutomaticGainControl;");
137
138 // Initialize GnssMeasurement related classes and methods
139 jclass gnssMeasurementClass = env->FindClass("android/location/GnssMeasurement");
140 class_gnssMeasurement = (jclass)env->NewGlobalRef(gnssMeasurementClass);
141 method_gnssMeasurementCtor = env->GetMethodID(class_gnssMeasurement, "<init>", "()V");
142 method_gnssMeasurementsSetSatellitePvt =
143 env->GetMethodID(class_gnssMeasurement, "setSatellitePvt",
144 "(Landroid/location/SatellitePvt;)V");
145 method_gnssMeasurementsSetCorrelationVectors =
146 env->GetMethodID(class_gnssMeasurement, "setCorrelationVectors",
147 "(Ljava/util/Collection;)V");
148
149 jclass gnssClockClass = env->FindClass("android/location/GnssClock");
150 class_gnssClock = (jclass)env->NewGlobalRef(gnssClockClass);
151 method_gnssClockCtor = env->GetMethodID(class_gnssClock, "<init>", "()V");
152
153 jclass satellitePvtBuilder = env->FindClass("android/location/SatellitePvt$Builder");
154 class_satellitePvtBuilder = (jclass)env->NewGlobalRef(satellitePvtBuilder);
155 method_satellitePvtBuilderCtor = env->GetMethodID(class_satellitePvtBuilder, "<init>", "()V");
156 method_satellitePvtBuilderSetPositionEcef =
157 env->GetMethodID(class_satellitePvtBuilder, "setPositionEcef",
158 "(Landroid/location/SatellitePvt$PositionEcef;)"
159 "Landroid/location/SatellitePvt$Builder;");
160 method_satellitePvtBuilderSetVelocityEcef =
161 env->GetMethodID(class_satellitePvtBuilder, "setVelocityEcef",
162 "(Landroid/location/SatellitePvt$VelocityEcef;)"
163 "Landroid/location/SatellitePvt$Builder;");
164 method_satellitePvtBuilderSetClockInfo =
165 env->GetMethodID(class_satellitePvtBuilder, "setClockInfo",
166 "(Landroid/location/SatellitePvt$ClockInfo;)"
167 "Landroid/location/SatellitePvt$Builder;");
168 method_satellitePvtBuilderSetIonoDelayMeters =
169 env->GetMethodID(class_satellitePvtBuilder, "setIonoDelayMeters",
170 "(D)Landroid/location/SatellitePvt$Builder;");
171 method_satellitePvtBuilderSetTropoDelayMeters =
172 env->GetMethodID(class_satellitePvtBuilder, "setTropoDelayMeters",
173 "(D)Landroid/location/SatellitePvt$Builder;");
174 method_satellitePvtBuilderSetTimeOfClock =
175 env->GetMethodID(class_satellitePvtBuilder, "setTimeOfClockSeconds",
176 "(J)Landroid/location/SatellitePvt$Builder;");
177 method_satellitePvtBuilderSetTimeOfEphemeris =
178 env->GetMethodID(class_satellitePvtBuilder, "setTimeOfEphemerisSeconds",
179 "(J)Landroid/location/SatellitePvt$Builder;");
180 method_satellitePvtBuilderSetIssueOfDataClock =
181 env->GetMethodID(class_satellitePvtBuilder, "setIssueOfDataClock",
182 "(I)Landroid/location/SatellitePvt$Builder;");
183 method_satellitePvtBuilderSetIssueOfDataEphemeris =
184 env->GetMethodID(class_satellitePvtBuilder, "setIssueOfDataEphemeris",
185 "(I)Landroid/location/SatellitePvt$Builder;");
186 method_satellitePvtBuilderSetEphemerisSource =
187 env->GetMethodID(class_satellitePvtBuilder, "setEphemerisSource",
188 "(I)Landroid/location/SatellitePvt$Builder;");
189 method_satellitePvtBuilderBuild = env->GetMethodID(class_satellitePvtBuilder, "build",
190 "()Landroid/location/SatellitePvt;");
191
192 jclass positionEcefClass = env->FindClass("android/location/SatellitePvt$PositionEcef");
193 class_positionEcef = (jclass)env->NewGlobalRef(positionEcefClass);
194 method_positionEcef = env->GetMethodID(class_positionEcef, "<init>", "(DDDD)V");
195
196 jclass velocityEcefClass = env->FindClass("android/location/SatellitePvt$VelocityEcef");
197 class_velocityEcef = (jclass)env->NewGlobalRef(velocityEcefClass);
198 method_velocityEcef = env->GetMethodID(class_velocityEcef, "<init>", "(DDDD)V");
199
200 jclass clockInfoClass = env->FindClass("android/location/SatellitePvt$ClockInfo");
201 class_clockInfo = (jclass)env->NewGlobalRef(clockInfoClass);
202 method_clockInfo = env->GetMethodID(class_clockInfo, "<init>", "(DDD)V");
203
204 jclass correlationVectorBuilder = env->FindClass("android/location/CorrelationVector$Builder");
205 class_correlationVectorBuilder = (jclass)env->NewGlobalRef(correlationVectorBuilder);
206 method_correlationVectorBuilderCtor =
207 env->GetMethodID(class_correlationVectorBuilder, "<init>", "()V");
208 method_correlationVectorBuilderSetMagnitude =
209 env->GetMethodID(class_correlationVectorBuilder, "setMagnitude",
210 "([I)Landroid/location/CorrelationVector$Builder;");
211 method_correlationVectorBuilderSetFrequencyOffsetMetersPerSecond =
212 env->GetMethodID(class_correlationVectorBuilder, "setFrequencyOffsetMetersPerSecond",
213 "(D)Landroid/location/CorrelationVector$Builder;");
214 method_correlationVectorBuilderSetSamplingStartMeters =
215 env->GetMethodID(class_correlationVectorBuilder, "setSamplingStartMeters",
216 "(D)Landroid/location/CorrelationVector$Builder;");
217 method_correlationVectorBuilderSetSamplingWidthMeters =
218 env->GetMethodID(class_correlationVectorBuilder, "setSamplingWidthMeters",
219 "(D)Landroid/location/CorrelationVector$Builder;");
220 method_correlationVectorBuilderBuild =
221 env->GetMethodID(class_correlationVectorBuilder, "build",
222 "()Landroid/location/CorrelationVector;");
223
224 jclass arrayListClass = env->FindClass("java/util/ArrayList");
225 class_arrayList = (jclass)env->NewGlobalRef(arrayListClass);
226 method_arrayListCtor = env->GetMethodID(class_arrayList, "<init>", "()V");
227 method_arrayListAdd = env->GetMethodID(class_arrayList, "add", "(Ljava/lang/Object;)Z");
228 }
229
setMeasurementData(JNIEnv * env,jobject & callbacksObj,jobject clock,jobjectArray measurementArray,jobjectArray gnssAgcArray)230 void setMeasurementData(JNIEnv* env, jobject& callbacksObj, jobject clock,
231 jobjectArray measurementArray, jobjectArray gnssAgcArray) {
232 jobject gnssMeasurementsEventBuilderObject =
233 env->NewObject(class_gnssMeasurementsEventBuilder,
234 method_gnssMeasurementsEventBuilderCtor);
235 callObjectMethodIgnoringResult(env, gnssMeasurementsEventBuilderObject,
236 method_gnssMeasurementsEventBuilderSetClock, clock);
237 callObjectMethodIgnoringResult(env, gnssMeasurementsEventBuilderObject,
238 method_gnssMeasurementsEventBuilderSetMeasurements,
239 measurementArray);
240 callObjectMethodIgnoringResult(env, gnssMeasurementsEventBuilderObject,
241 method_gnssMeasurementsEventBuilderSetGnssAutomaticGainControls,
242 gnssAgcArray);
243 jobject gnssMeasurementsEventObject =
244 env->CallObjectMethod(gnssMeasurementsEventBuilderObject,
245 method_gnssMeasurementsEventBuilderBuild);
246
247 env->CallVoidMethod(callbacksObj, method_reportMeasurementData, gnssMeasurementsEventObject);
248 checkAndClearExceptionFromCallback(env, __FUNCTION__);
249 env->DeleteLocalRef(gnssMeasurementsEventBuilderObject);
250 env->DeleteLocalRef(gnssMeasurementsEventObject);
251 }
252
253 template <class T_Measurement, class T_Flags>
setMeasurementFields_V1_0(const T_Measurement & measurement,JavaObject & object)254 void setMeasurementFields_V1_0(const T_Measurement& measurement, JavaObject& object) {
255 uint32_t flags = static_cast<uint32_t>(measurement.flags);
256
257 SET(Svid, static_cast<int32_t>(measurement.svid));
258 SET(TimeOffsetNanos, measurement.timeOffsetNs);
259 SET(State, static_cast<int32_t>(measurement.state));
260 SET(ReceivedSvTimeNanos, measurement.receivedSvTimeInNs);
261 SET(ReceivedSvTimeUncertaintyNanos, measurement.receivedSvTimeUncertaintyInNs);
262 SET(PseudorangeRateMetersPerSecond, measurement.pseudorangeRateMps);
263 SET(PseudorangeRateUncertaintyMetersPerSecond, measurement.pseudorangeRateUncertaintyMps);
264 SET(AccumulatedDeltaRangeState,
265 (static_cast<int32_t>(measurement.accumulatedDeltaRangeState) &
266 ~ADR_STATE_HALF_CYCLE_REPORTED)); // Half Cycle state not reported from Hardware in V1_0
267 SET(AccumulatedDeltaRangeMeters, measurement.accumulatedDeltaRangeM);
268 SET(AccumulatedDeltaRangeUncertaintyMeters, measurement.accumulatedDeltaRangeUncertaintyM);
269
270 // Intentionally not copying deprecated fields of carrierCycles,
271 // carrierPhase, carrierPhaseUncertainty
272
273 SET(MultipathIndicator, static_cast<int32_t>(measurement.multipathIndicator));
274
275 if (flags & static_cast<uint32_t>(T_Flags::HAS_SNR)) {
276 SET(SnrInDb, measurement.snrDb);
277 }
278
279 if (flags & static_cast<uint32_t>(T_Flags::HAS_AUTOMATIC_GAIN_CONTROL)) {
280 SET(AutomaticGainControlLevelInDb, measurement.agcLevelDb);
281 }
282 }
283
284 template <class T_Measurement, class T_Flags>
setMeasurementFields_V2_1(const T_Measurement & measurement,JavaObject & object)285 void setMeasurementFields_V2_1(const T_Measurement& measurement, JavaObject& object) {
286 SET(BasebandCn0DbHz, measurement.basebandCN0DbHz);
287
288 if (measurement.flags & T_Flags::HAS_FULL_ISB) {
289 SET(FullInterSignalBiasNanos, measurement.fullInterSignalBiasNs);
290 }
291
292 if (measurement.flags & T_Flags::HAS_FULL_ISB_UNCERTAINTY) {
293 SET(FullInterSignalBiasUncertaintyNanos, measurement.fullInterSignalBiasUncertaintyNs);
294 }
295
296 if (measurement.flags & T_Flags::HAS_SATELLITE_ISB) {
297 SET(SatelliteInterSignalBiasNanos, measurement.satelliteInterSignalBiasNs);
298 }
299
300 if (measurement.flags & T_Flags::HAS_SATELLITE_ISB_UNCERTAINTY) {
301 SET(SatelliteInterSignalBiasUncertaintyNanos,
302 measurement.satelliteInterSignalBiasUncertaintyNs);
303 }
304 }
305
306 template <class T_Clock, class T_Flags>
setClockFields_V1_0(const T_Clock & clock,JavaObject & object)307 void setClockFields_V1_0(const T_Clock& clock, JavaObject& object) {
308 uint32_t flags = static_cast<uint32_t>(clock.gnssClockFlags);
309 if (flags & static_cast<uint32_t>(T_Flags::HAS_LEAP_SECOND)) {
310 SET(LeapSecond, static_cast<int32_t>(clock.leapSecond));
311 }
312
313 if (flags & static_cast<uint32_t>(T_Flags::HAS_TIME_UNCERTAINTY)) {
314 SET(TimeUncertaintyNanos, clock.timeUncertaintyNs);
315 }
316
317 if (flags & static_cast<uint32_t>(T_Flags::HAS_FULL_BIAS)) {
318 SET(FullBiasNanos, clock.fullBiasNs);
319 }
320
321 if (flags & static_cast<uint32_t>(T_Flags::HAS_BIAS)) {
322 SET(BiasNanos, clock.biasNs);
323 }
324
325 if (flags & static_cast<uint32_t>(T_Flags::HAS_BIAS_UNCERTAINTY)) {
326 SET(BiasUncertaintyNanos, clock.biasUncertaintyNs);
327 }
328
329 if (flags & static_cast<uint32_t>(T_Flags::HAS_DRIFT)) {
330 SET(DriftNanosPerSecond, clock.driftNsps);
331 }
332
333 if (flags & static_cast<uint32_t>(T_Flags::HAS_DRIFT_UNCERTAINTY)) {
334 SET(DriftUncertaintyNanosPerSecond, clock.driftUncertaintyNsps);
335 }
336
337 SET(TimeNanos, clock.timeNs);
338 SET(HardwareClockDiscontinuityCount, clock.hwClockDiscontinuityCount);
339 }
340
341 template <class T_Clock, class T_Flags>
setClockFields_V2_1(const T_Clock & clock,JavaObject & object)342 void setClockFields_V2_1(const T_Clock& clock, JavaObject& object) {
343 JNIEnv* env = getJniEnv();
344 SET(ReferenceConstellationTypeForIsb,
345 static_cast<int32_t>(clock.referenceSignalTypeForIsb.constellation));
346 SET(ReferenceCarrierFrequencyHzForIsb, clock.referenceSignalTypeForIsb.carrierFrequencyHz);
347
348 jstring referenceCodeTypeForIsb =
349 env->NewStringUTF(clock.referenceSignalTypeForIsb.codeType.c_str());
350 SET(ReferenceCodeTypeForIsb, referenceCodeTypeForIsb);
351 env->DeleteLocalRef(referenceCodeTypeForIsb);
352 }
353
354 template <class T_ElapsedRealtime, class T_Flags>
setElapsedRealtimeFields(const T_ElapsedRealtime & elapsedRealtime,JavaObject & object)355 void setElapsedRealtimeFields(const T_ElapsedRealtime& elapsedRealtime, JavaObject& object) {
356 uint32_t flags = static_cast<uint32_t>(elapsedRealtime.flags);
357 if (flags & T_Flags::HAS_TIMESTAMP_NS) {
358 SET(ElapsedRealtimeNanos, static_cast<uint64_t>(elapsedRealtime.timestampNs));
359 }
360 if (flags & T_Flags::HAS_TIME_UNCERTAINTY_NS) {
361 SET(ElapsedRealtimeUncertaintyNanos,
362 static_cast<double>(elapsedRealtime.timeUncertaintyNs));
363 }
364 }
365
366 // Implementation of GnssMeasurementCallbackAidl class.
367
gnssMeasurementCb(const GnssData & data)368 Status GnssMeasurementCallbackAidl::gnssMeasurementCb(const GnssData& data) {
369 ALOGD("%s", __func__);
370 translateAndSetGnssData(data);
371 return Status::ok();
372 }
373
translateAndSetGnssData(const GnssData & data)374 void GnssMeasurementCallbackAidl::translateAndSetGnssData(const GnssData& data) {
375 JNIEnv* env = getJniEnv();
376
377 JavaObject gnssClockJavaObject(env, class_gnssClock, method_gnssClockCtor);
378 translateGnssClock(env, data, gnssClockJavaObject);
379 jobject clock = gnssClockJavaObject.get();
380 jobjectArray measurementArray = translateAllGnssMeasurements(env, data.measurements);
381
382 jobjectArray gnssAgcArray = nullptr;
383 gnssAgcArray = translateAllGnssAgcs(env, data.gnssAgcs);
384 setMeasurementData(env, mCallbacksObj, clock, measurementArray, gnssAgcArray);
385
386 env->DeleteLocalRef(clock);
387 env->DeleteLocalRef(measurementArray);
388 env->DeleteLocalRef(gnssAgcArray);
389 }
390
translateSingleGnssMeasurement(JNIEnv * env,const GnssMeasurement & measurement,JavaObject & object)391 void GnssMeasurementCallbackAidl::translateSingleGnssMeasurement(JNIEnv* env,
392 const GnssMeasurement& measurement,
393 JavaObject& object) {
394 setMeasurementFields_V1_0<GnssMeasurement, GnssMeasurement>(measurement, object);
395 setMeasurementFields_V2_1<GnssMeasurement, GnssMeasurement>(measurement, object);
396
397 SET(Cn0DbHz, measurement.antennaCN0DbHz);
398 SET(ConstellationType, static_cast<int32_t>(measurement.signalType.constellation));
399 // Half cycle state is reported in the AIDL version of GnssMeasurement
400 SET(AccumulatedDeltaRangeState,
401 (static_cast<int32_t>(measurement.accumulatedDeltaRangeState) |
402 ADR_STATE_HALF_CYCLE_REPORTED));
403
404 if (measurement.flags & static_cast<uint32_t>(GnssMeasurement::HAS_CARRIER_FREQUENCY)) {
405 SET(CarrierFrequencyHz, static_cast<float>(measurement.signalType.carrierFrequencyHz));
406 }
407
408 if (measurement.flags & static_cast<uint32_t>(GnssMeasurement::HAS_SATELLITE_PVT)) {
409 const SatellitePvt& satellitePvt = measurement.satellitePvt;
410 uint16_t satFlags = static_cast<uint16_t>(satellitePvt.flags);
411 jobject positionEcef = nullptr;
412 jobject velocityEcef = nullptr;
413 jobject clockInfo = nullptr;
414 jobject satellitePvtBuilderObject =
415 env->NewObject(class_satellitePvtBuilder, method_satellitePvtBuilderCtor);
416
417 if (satFlags & SatellitePvt::HAS_POSITION_VELOCITY_CLOCK_INFO) {
418 positionEcef = env->NewObject(class_positionEcef, method_positionEcef,
419 satellitePvt.satPosEcef.posXMeters,
420 satellitePvt.satPosEcef.posYMeters,
421 satellitePvt.satPosEcef.posZMeters,
422 satellitePvt.satPosEcef.ureMeters);
423 velocityEcef =
424 env->NewObject(class_velocityEcef, method_velocityEcef,
425 satellitePvt.satVelEcef.velXMps, satellitePvt.satVelEcef.velYMps,
426 satellitePvt.satVelEcef.velZMps,
427 satellitePvt.satVelEcef.ureRateMps);
428 clockInfo = env->NewObject(class_clockInfo, method_clockInfo,
429 satellitePvt.satClockInfo.satHardwareCodeBiasMeters,
430 satellitePvt.satClockInfo.satTimeCorrectionMeters,
431 satellitePvt.satClockInfo.satClkDriftMps);
432 callObjectMethodIgnoringResult(env, satellitePvtBuilderObject,
433 method_satellitePvtBuilderSetPositionEcef, positionEcef);
434 callObjectMethodIgnoringResult(env, satellitePvtBuilderObject,
435 method_satellitePvtBuilderSetVelocityEcef, velocityEcef);
436 callObjectMethodIgnoringResult(env, satellitePvtBuilderObject,
437 method_satellitePvtBuilderSetClockInfo, clockInfo);
438 }
439
440 if (satFlags & SatellitePvt::HAS_IONO) {
441 callObjectMethodIgnoringResult(env, satellitePvtBuilderObject,
442 method_satellitePvtBuilderSetIonoDelayMeters,
443 satellitePvt.ionoDelayMeters);
444 }
445
446 if (satFlags & SatellitePvt::HAS_TROPO) {
447 callObjectMethodIgnoringResult(env, satellitePvtBuilderObject,
448 method_satellitePvtBuilderSetTropoDelayMeters,
449 satellitePvt.tropoDelayMeters);
450 }
451
452 if (this->getInterfaceVersion() >= 2) {
453 callObjectMethodIgnoringResult(env, satellitePvtBuilderObject,
454 method_satellitePvtBuilderSetTimeOfClock,
455 satellitePvt.timeOfClockSeconds);
456 callObjectMethodIgnoringResult(env, satellitePvtBuilderObject,
457 method_satellitePvtBuilderSetTimeOfEphemeris,
458 satellitePvt.timeOfEphemerisSeconds);
459 callObjectMethodIgnoringResult(env, satellitePvtBuilderObject,
460 method_satellitePvtBuilderSetIssueOfDataClock,
461 satellitePvt.issueOfDataClock);
462 callObjectMethodIgnoringResult(env, satellitePvtBuilderObject,
463 method_satellitePvtBuilderSetIssueOfDataEphemeris,
464 satellitePvt.issueOfDataEphemeris);
465 callObjectMethodIgnoringResult(env, satellitePvtBuilderObject,
466 method_satellitePvtBuilderSetEphemerisSource,
467 static_cast<int>(satellitePvt.ephemerisSource));
468 }
469
470 jobject satellitePvtObject =
471 env->CallObjectMethod(satellitePvtBuilderObject, method_satellitePvtBuilderBuild);
472 env->CallVoidMethod(object.get(), method_gnssMeasurementsSetSatellitePvt,
473 satellitePvtObject);
474 env->DeleteLocalRef(positionEcef);
475 env->DeleteLocalRef(velocityEcef);
476 env->DeleteLocalRef(clockInfo);
477 env->DeleteLocalRef(satellitePvtBuilderObject);
478 env->DeleteLocalRef(satellitePvtObject);
479 }
480
481 if (measurement.flags & static_cast<uint32_t>(GnssMeasurement::HAS_CORRELATION_VECTOR)) {
482 jobject correlationVectorList = env->NewObject(class_arrayList, method_arrayListCtor);
483 for (uint16_t i = 0; i < measurement.correlationVectors.size(); ++i) {
484 const CorrelationVector& correlationVector = measurement.correlationVectors[i];
485 const std::vector<int32_t>& magnitudeVector = correlationVector.magnitude;
486
487 jsize numMagnitude = magnitudeVector.size();
488 jintArray magnitudeArray = env->NewIntArray(numMagnitude);
489 env->SetIntArrayRegion(magnitudeArray, 0, numMagnitude,
490 reinterpret_cast<const jint*>(magnitudeVector.data()));
491
492 jobject correlationVectorBuilderObject =
493 env->NewObject(class_correlationVectorBuilder,
494 method_correlationVectorBuilderCtor);
495 callObjectMethodIgnoringResult(env, correlationVectorBuilderObject,
496 method_correlationVectorBuilderSetMagnitude,
497 magnitudeArray);
498 callObjectMethodIgnoringResult(
499 env, correlationVectorBuilderObject,
500 method_correlationVectorBuilderSetFrequencyOffsetMetersPerSecond,
501 correlationVector.frequencyOffsetMps);
502 callObjectMethodIgnoringResult(env, correlationVectorBuilderObject,
503 method_correlationVectorBuilderSetSamplingStartMeters,
504 correlationVector.samplingStartM);
505 callObjectMethodIgnoringResult(env, correlationVectorBuilderObject,
506 method_correlationVectorBuilderSetSamplingWidthMeters,
507 correlationVector.samplingWidthM);
508 jobject correlationVectorObject =
509 env->CallObjectMethod(correlationVectorBuilderObject,
510 method_correlationVectorBuilderBuild);
511
512 env->CallBooleanMethod(correlationVectorList, method_arrayListAdd,
513 correlationVectorObject);
514
515 env->DeleteLocalRef(magnitudeArray);
516 env->DeleteLocalRef(correlationVectorBuilderObject);
517 env->DeleteLocalRef(correlationVectorObject);
518 }
519 env->CallVoidMethod(object.get(), method_gnssMeasurementsSetCorrelationVectors,
520 correlationVectorList);
521 env->DeleteLocalRef(correlationVectorList);
522 }
523
524 jstring codeType = env->NewStringUTF(measurement.signalType.codeType.c_str());
525 SET(CodeType, codeType);
526 env->DeleteLocalRef(codeType);
527 }
528
translateAllGnssMeasurements(JNIEnv * env,const std::vector<GnssMeasurement> & measurements)529 jobjectArray GnssMeasurementCallbackAidl::translateAllGnssMeasurements(
530 JNIEnv* env, const std::vector<GnssMeasurement>& measurements) {
531 if (measurements.size() == 0) {
532 return nullptr;
533 }
534
535 jobjectArray gnssMeasurementArray =
536 env->NewObjectArray(measurements.size(), class_gnssMeasurement,
537 nullptr /* initialElement */);
538
539 for (uint16_t i = 0; i < measurements.size(); ++i) {
540 JavaObject object(env, class_gnssMeasurement, method_gnssMeasurementCtor);
541 translateSingleGnssMeasurement(env, measurements[i], object);
542 jobject gnssMeasurement = object.get();
543 env->SetObjectArrayElement(gnssMeasurementArray, i, gnssMeasurement);
544 env->DeleteLocalRef(gnssMeasurement);
545 }
546
547 return gnssMeasurementArray;
548 }
549
translateAllGnssAgcs(JNIEnv * env,const std::vector<GnssAgc> & agcs)550 jobjectArray GnssMeasurementCallbackAidl::translateAllGnssAgcs(JNIEnv* env,
551 const std::vector<GnssAgc>& agcs) {
552 if (agcs.size() == 0) {
553 return nullptr;
554 }
555
556 jobjectArray gnssAgcArray =
557 env->NewObjectArray(agcs.size(), class_gnssAgc, nullptr /* initialElement */);
558
559 for (uint16_t i = 0; i < agcs.size(); ++i) {
560 const GnssAgc& gnssAgc = agcs[i];
561
562 jobject agcBuilderObject = env->NewObject(class_gnssAgcBuilder, method_gnssAgcBuilderCtor);
563 callObjectMethodIgnoringResult(env, agcBuilderObject, method_gnssAgcBuilderSetLevelDb,
564 gnssAgc.agcLevelDb);
565 callObjectMethodIgnoringResult(env, agcBuilderObject,
566 method_gnssAgcBuilderSetConstellationType,
567 (int)gnssAgc.constellation);
568 callObjectMethodIgnoringResult(env, agcBuilderObject,
569 method_gnssAgcBuilderSetCarrierFrequencyHz,
570 gnssAgc.carrierFrequencyHz);
571 jobject agcObject = env->CallObjectMethod(agcBuilderObject, method_gnssAgcBuilderBuild);
572
573 env->SetObjectArrayElement(gnssAgcArray, i, agcObject);
574 env->DeleteLocalRef(agcBuilderObject);
575 env->DeleteLocalRef(agcObject);
576 }
577
578 return gnssAgcArray;
579 }
580
translateGnssClock(JNIEnv * env,const GnssData & data,JavaObject & object)581 void GnssMeasurementCallbackAidl::translateGnssClock(JNIEnv* env, const GnssData& data,
582 JavaObject& object) {
583 setElapsedRealtimeFields<ElapsedRealtime, ElapsedRealtime>(data.elapsedRealtime, object);
584 setClockFields_V1_0<GnssClock, GnssClock>(data.clock, object);
585 setClockFields_V2_1<GnssClock, GnssClock>(data.clock, object);
586 }
587
588 // Implementation of GnssMeasurementCallbackHidl class.
589
gnssMeasurementCb_2_1(const hardware::gnss::V2_1::IGnssMeasurementCallback::GnssData & data)590 hardware::Return<void> GnssMeasurementCallbackHidl::gnssMeasurementCb_2_1(
591 const hardware::gnss::V2_1::IGnssMeasurementCallback::GnssData& data) {
592 translateAndSetGnssData(data);
593 return hardware::Void();
594 }
595
gnssMeasurementCb_2_0(const hardware::gnss::V2_0::IGnssMeasurementCallback::GnssData & data)596 hardware::Return<void> GnssMeasurementCallbackHidl::gnssMeasurementCb_2_0(
597 const hardware::gnss::V2_0::IGnssMeasurementCallback::GnssData& data) {
598 translateAndSetGnssData(data);
599 return hardware::Void();
600 }
601
gnssMeasurementCb(const hardware::gnss::V1_1::IGnssMeasurementCallback::GnssData & data)602 hardware::Return<void> GnssMeasurementCallbackHidl::gnssMeasurementCb(
603 const hardware::gnss::V1_1::IGnssMeasurementCallback::GnssData& data) {
604 translateAndSetGnssData(data);
605 return hardware::Void();
606 }
607
GnssMeasurementCb(const hardware::gnss::V1_0::IGnssMeasurementCallback::GnssData & data)608 hardware::Return<void> GnssMeasurementCallbackHidl::GnssMeasurementCb(
609 const hardware::gnss::V1_0::IGnssMeasurementCallback::GnssData& data) {
610 translateAndSetGnssData(data);
611 return hardware::Void();
612 }
613
614 template <>
getMeasurementCount(const hardware::gnss::V1_0::IGnssMeasurementCallback::GnssData & data)615 size_t GnssMeasurementCallbackHidl::getMeasurementCount<
616 hardware::gnss::V1_0::IGnssMeasurementCallback::GnssData>(
617 const hardware::gnss::V1_0::IGnssMeasurementCallback::GnssData& data) {
618 return data.measurementCount;
619 }
620
621 // Preallocate object as: JavaObject object(env, "android/location/GnssMeasurement");
622 template <>
translateSingleGnssMeasurement(const hardware::gnss::V1_0::IGnssMeasurementCallback::GnssMeasurement & measurement,JavaObject & object)623 void GnssMeasurementCallbackHidl::translateSingleGnssMeasurement<
624 hardware::gnss::V1_0::IGnssMeasurementCallback::GnssMeasurement>(
625 const hardware::gnss::V1_0::IGnssMeasurementCallback::GnssMeasurement& measurement,
626 JavaObject& object) {
627 setMeasurementFields_V1_0<hardware::gnss::V1_0::IGnssMeasurementCallback::GnssMeasurement,
628 GnssMeasurementFlags>(measurement, object);
629
630 SET(ConstellationType, static_cast<int32_t>(measurement.constellation));
631 SET(Cn0DbHz, measurement.cN0DbHz);
632 if (measurement.flags & static_cast<uint32_t>(GnssMeasurementFlags::HAS_CARRIER_FREQUENCY)) {
633 SET(CarrierFrequencyHz, measurement.carrierFrequencyHz);
634 }
635 }
636
637 // Preallocate object as: JavaObject object(env, "android/location/GnssMeasurement");
638 template <>
translateSingleGnssMeasurement(const hardware::gnss::V1_1::IGnssMeasurementCallback::GnssMeasurement & measurement_V1_1,JavaObject & object)639 void GnssMeasurementCallbackHidl::translateSingleGnssMeasurement<
640 hardware::gnss::V1_1::IGnssMeasurementCallback::GnssMeasurement>(
641 const hardware::gnss::V1_1::IGnssMeasurementCallback::GnssMeasurement& measurement_V1_1,
642 JavaObject& object) {
643 translateSingleGnssMeasurement(measurement_V1_1.v1_0, object);
644
645 // Half cycle state is reported in HIDL v1.1 or newer.
646 SET(AccumulatedDeltaRangeState,
647 (static_cast<int32_t>(measurement_V1_1.accumulatedDeltaRangeState) |
648 ADR_STATE_HALF_CYCLE_REPORTED));
649 }
650
651 // Preallocate object as: JavaObject object(env, "android/location/GnssMeasurement");
652 template <>
translateSingleGnssMeasurement(const hardware::gnss::V2_0::IGnssMeasurementCallback::GnssMeasurement & measurement_V2_0,JavaObject & object)653 void GnssMeasurementCallbackHidl::translateSingleGnssMeasurement<
654 hardware::gnss::V2_0::IGnssMeasurementCallback::GnssMeasurement>(
655 const hardware::gnss::V2_0::IGnssMeasurementCallback::GnssMeasurement& measurement_V2_0,
656 JavaObject& object) {
657 JNIEnv* env = getJniEnv();
658 translateSingleGnssMeasurement(measurement_V2_0.v1_1, object);
659
660 jstring codeType = env->NewStringUTF(measurement_V2_0.codeType.c_str());
661 SET(CodeType, codeType);
662
663 // Overwrite with v2_0.state since V2_0.v1_1.v1_0.state is deprecated.
664 SET(State, static_cast<int32_t>(measurement_V2_0.state));
665
666 // Overwrite with v2_0.constellation since V2_0.v1_1.v1_0.constellation is deprecated.
667 SET(ConstellationType, static_cast<int32_t>(measurement_V2_0.constellation));
668
669 if (codeType) {
670 env->DeleteLocalRef(codeType);
671 }
672 }
673
674 // Preallocate object as: JavaObject object(env, "android/location/GnssMeasurement");
675 template <>
translateSingleGnssMeasurement(const hardware::gnss::V2_1::IGnssMeasurementCallback::GnssMeasurement & measurement_V2_1,JavaObject & object)676 void GnssMeasurementCallbackHidl::translateSingleGnssMeasurement<
677 hardware::gnss::V2_1::IGnssMeasurementCallback::GnssMeasurement>(
678 const hardware::gnss::V2_1::IGnssMeasurementCallback::GnssMeasurement& measurement_V2_1,
679 JavaObject& object) {
680 translateSingleGnssMeasurement(measurement_V2_1.v2_0, object);
681
682 setMeasurementFields_V2_1<hardware::gnss::V2_1::IGnssMeasurementCallback::GnssMeasurement,
683 GnssMeasurementFlags>(measurement_V2_1, object);
684 }
685
686 template <>
translateGnssClock(const hardware::gnss::V1_0::IGnssMeasurementCallback::GnssClock & clock,JavaObject & object)687 void GnssMeasurementCallbackHidl::translateGnssClock(
688 const hardware::gnss::V1_0::IGnssMeasurementCallback::GnssClock& clock,
689 JavaObject& object) {
690 setClockFields_V1_0<hardware::gnss::V1_0::IGnssMeasurementCallback::GnssClock,
691 GnssClockFlags>(clock, object);
692 }
693
694 template <>
translateGnssClock(const hardware::gnss::V2_1::IGnssMeasurementCallback::GnssClock & clock,JavaObject & object)695 void GnssMeasurementCallbackHidl::translateGnssClock(
696 const hardware::gnss::V2_1::IGnssMeasurementCallback::GnssClock& clock,
697 JavaObject& object) {
698 setClockFields_V2_1<hardware::gnss::V2_1::IGnssMeasurementCallback::GnssClock,
699 GnssClockFlags>(clock, object);
700 translateGnssClock(clock.v1_0, object);
701 }
702
703 template <>
translateGnssClock(const hardware::gnss::V2_0::IGnssMeasurementCallback::GnssData & data,JavaObject & object)704 void GnssMeasurementCallbackHidl::translateGnssClock(
705 const hardware::gnss::V2_0::IGnssMeasurementCallback::GnssData& data, JavaObject& object) {
706 setElapsedRealtimeFields<hardware::gnss::V2_0::ElapsedRealtime,
707 hardware::gnss::V2_0::ElapsedRealtimeFlags>(data.elapsedRealtime,
708 object);
709 translateGnssClock(data.clock, object);
710 }
711
712 template <>
translateGnssClock(const hardware::gnss::V2_1::IGnssMeasurementCallback::GnssData & data,JavaObject & object)713 void GnssMeasurementCallbackHidl::translateGnssClock(
714 const hardware::gnss::V2_1::IGnssMeasurementCallback::GnssData& data, JavaObject& object) {
715 auto elapsedRealtime = data.elapsedRealtime;
716 uint16_t flags = static_cast<uint16_t>(elapsedRealtime.flags);
717 if (flags & hardware::gnss::V2_0::ElapsedRealtimeFlags::HAS_TIMESTAMP_NS) {
718 SET(ElapsedRealtimeNanos, static_cast<uint64_t>(elapsedRealtime.timestampNs));
719 }
720 if (flags & hardware::gnss::V2_0::ElapsedRealtimeFlags::HAS_TIME_UNCERTAINTY_NS) {
721 SET(ElapsedRealtimeUncertaintyNanos,
722 static_cast<double>(elapsedRealtime.timeUncertaintyNs));
723 }
724 translateGnssClock(data.clock, object);
725 }
726
727 } // namespace android::gnss
728