Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Add GnssAutomaticGainControl to GnssMeasurementsEvent (frameworks/base)"

Browse Source
This commit is contained in:
Yu-Han Yang
2022-01-14 22:07:59 +00:00
committed by Android (Google) Code Review
parent 188675b29f af90af7931
commit 4ff8affb7c
8 changed files with 515 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
core/api/current.txt
View File

@@ -20150,6 +20150,24 @@ package android.location {
field @NonNull public static final android.os.Parcelable.Creator<android.location.GnssAntennaInfo.SphericalCorrections> CREATOR;
}
public final class GnssAutomaticGainControl implements android.os.Parcelable {
method public int describeContents();
method @IntRange(from=0) public long getCarrierFrequencyHz();
method public int getConstellationType();
method @FloatRange(from=0xffffd8f0, to=10000) public double getLevelDb();
method public void writeToParcel(@NonNull android.os.Parcel, int);
field @NonNull public static final android.os.Parcelable.Creator<android.location.GnssAutomaticGainControl> CREATOR;
}
public static final class GnssAutomaticGainControl.Builder {
ctor public GnssAutomaticGainControl.Builder();
ctor public GnssAutomaticGainControl.Builder(@NonNull android.location.GnssAutomaticGainControl);
method @NonNull public android.location.GnssAutomaticGainControl build();
method @NonNull public android.location.GnssAutomaticGainControl.Builder setCarrierFrequencyHz(@IntRange(from=0) long);
method @NonNull public android.location.GnssAutomaticGainControl.Builder setConstellationType(int);
method @NonNull public android.location.GnssAutomaticGainControl.Builder setLevelDb(@FloatRange(from=0xffffd8f0, to=10000) double);
}
public final class GnssCapabilities implements android.os.Parcelable {
method public int describeContents();
method public boolean hasAntennaInfo();
@@ -20206,7 +20224,7 @@ package android.location {
method public double getAccumulatedDeltaRangeMeters();
method public int getAccumulatedDeltaRangeState();
method public double getAccumulatedDeltaRangeUncertaintyMeters();
method public double getAutomaticGainControlLevelDb();
method @Deprecated public double getAutomaticGainControlLevelDb();
method @FloatRange(from=0, to=63) public double getBasebandCn0DbHz();
method @Deprecated public long getCarrierCycles();
method public float getCarrierFrequencyHz();
@@ -20228,7 +20246,7 @@ package android.location {
method public int getState();
method public int getSvid();
method public double getTimeOffsetNanos();
method public boolean hasAutomaticGainControlLevelDb();
method @Deprecated public boolean hasAutomaticGainControlLevelDb();
method public boolean hasBasebandCn0DbHz();
method @Deprecated public boolean hasCarrierCycles();
method public boolean hasCarrierFrequencyHz();
@@ -20290,11 +20308,21 @@ package android.location {
public final class GnssMeasurementsEvent implements android.os.Parcelable {
method public int describeContents();
method @NonNull public android.location.GnssClock getClock();
method @NonNull public java.util.Collection<android.location.GnssAutomaticGainControl> getGnssAutomaticGainControls();
method @NonNull public java.util.Collection<android.location.GnssMeasurement> getMeasurements();
method public void writeToParcel(android.os.Parcel, int);
field @NonNull public static final android.os.Parcelable.Creator<android.location.GnssMeasurementsEvent> CREATOR;
}
public static final class GnssMeasurementsEvent.Builder {
ctor public GnssMeasurementsEvent.Builder();
ctor public GnssMeasurementsEvent.Builder(@NonNull android.location.GnssMeasurementsEvent);
method @NonNull public android.location.GnssMeasurementsEvent build();
method @NonNull public android.location.GnssMeasurementsEvent.Builder setClock(@NonNull android.location.GnssClock);
method @NonNull public android.location.GnssMeasurementsEvent.Builder setGnssAutomaticGainControls(@NonNull java.util.Collection<android.location.GnssAutomaticGainControl>);
method @NonNull public android.location.GnssMeasurementsEvent.Builder setMeasurements(@NonNull java.util.Collection<android.location.GnssMeasurement>);
}
public abstract static class GnssMeasurementsEvent.Callback {
ctor public GnssMeasurementsEvent.Callback();
method public void onGnssMeasurementsReceived(android.location.GnssMeasurementsEvent);

6
core/api/test-current.txt
View File

@@ -1319,7 +1319,7 @@ package android.location {
method public void setAccumulatedDeltaRangeMeters(double);
method public void setAccumulatedDeltaRangeState(int);
method public void setAccumulatedDeltaRangeUncertaintyMeters(double);
method public void setAutomaticGainControlLevelInDb(double);
method @Deprecated public void setAutomaticGainControlLevelInDb(double);
method public void setBasebandCn0DbHz(double);
method @Deprecated public void setCarrierCycles(long);
method public void setCarrierFrequencyHz(float);
@@ -1346,10 +1346,6 @@ package android.location {
field public static final int ADR_STATE_ALL = 31; // 0x1f
}
public final class GnssMeasurementsEvent implements android.os.Parcelable {
ctor public GnssMeasurementsEvent(android.location.GnssClock, android.location.GnssMeasurement[]);
}
public final class GnssNavigationMessage implements android.os.Parcelable {
ctor public GnssNavigationMessage();
method public void reset();

19
location/java/android/location/GnssAutomaticGainControl.aidl Normal file
View File

@@ -0,0 +1,19 @@
/*
* Copyright (C) 2022 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.location;
parcelable GnssAutomaticGainControl;

215
location/java/android/location/GnssAutomaticGainControl.java Normal file
View File

@@ -0,0 +1,215 @@
/*
* Copyright (C) 2022 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.location;
import android.annotation.FloatRange;
import android.annotation.IntRange;
import android.annotation.NonNull;
import android.os.Parcel;
import android.os.Parcelable;
import com.android.internal.util.Preconditions;
import java.util.Objects;
/**
* A class that contains GNSS Automatic Gain Control (AGC) information.
*
* <p> AGC acts as a variable gain amplifier adjusting the power of the incoming signal. The AGC
* level may be used to indicate potential interference. Higher gain (and/or lower input power)
* shall be output as a positive number. Hence in cases of strong jamming, in the band of this
* signal, this value will go more negative. This value must be consistent given the same level
* of the incoming signal power.
*
* <p> Note: Different hardware designs (e.g. antenna, pre-amplification, or other RF HW
* components) may also affect the typical output of this value on any given hardware design
* in an open sky test - the important aspect of this output is that changes in this value are
* indicative of changes on input signal power in the frequency band for this measurement.
*/
public final class GnssAutomaticGainControl implements Parcelable {
private final double mLevelDb;
private final int mConstellationType;
private final long mCarrierFrequencyHz;
/**
* Creates a {@link GnssAutomaticGainControl} with a full list of parameters.
*/
private GnssAutomaticGainControl(double levelDb, int constellationType,
long carrierFrequencyHz) {
mLevelDb = levelDb;
mConstellationType = constellationType;
mCarrierFrequencyHz = carrierFrequencyHz;
}
/**
* Gets the Automatic Gain Control level in dB.
*/
@FloatRange(from = -10000, to = 10000)
public double getLevelDb() {
return mLevelDb;
}
/**
* Gets the constellation type.
*
* <p>The return value is one of those constants with {@code CONSTELLATION_} prefix in
* {@link GnssStatus}.
*/
@GnssStatus.ConstellationType
public int getConstellationType() {
return mConstellationType;
}
/**
* Gets the carrier frequency of the tracked signal.
*
* <p>For example it can be the GPS central frequency for L1 = 1575.45 MHz, or L2 = 1227.60 MHz,
* L5 = 1176.45 MHz, varying GLO channels, etc.
*
* @return the carrier frequency of the signal tracked in Hz.
*/
@IntRange(from = 0)
public long getCarrierFrequencyHz() {
return mCarrierFrequencyHz;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(@NonNull Parcel parcel, int flag) {
parcel.writeDouble(mLevelDb);
parcel.writeInt(mConstellationType);
parcel.writeLong(mCarrierFrequencyHz);
}
@NonNull
public static final Creator<GnssAutomaticGainControl> CREATOR =
new Creator<GnssAutomaticGainControl>() {
@Override
@NonNull
public GnssAutomaticGainControl createFromParcel(@NonNull Parcel parcel) {
return new GnssAutomaticGainControl(parcel.readDouble(), parcel.readInt(),
parcel.readLong());
}
@Override
public GnssAutomaticGainControl[] newArray(int i) {
return new GnssAutomaticGainControl[i];
}
};
@NonNull
@Override
public String toString() {
StringBuilder s = new StringBuilder();
s.append("GnssAutomaticGainControl[");
s.append("Level=").append(mLevelDb).append(" dB");
s.append(" Constellation=").append(
GnssStatus.constellationTypeToString(mConstellationType));
s.append(" CarrierFrequency=").append(mCarrierFrequencyHz).append(" Hz");
s.append(']');
return s.toString();
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof GnssAutomaticGainControl)) {
return false;
}
GnssAutomaticGainControl other = (GnssAutomaticGainControl) obj;
if (Double.compare(mLevelDb, other.mLevelDb)
!= 0) {
return false;
}
if (mConstellationType != other.mConstellationType) {
return false;
}
if (mCarrierFrequencyHz != other.mCarrierFrequencyHz) {
return false;
}
return true;
}
@Override
public int hashCode() {
return Objects.hash(mLevelDb, mConstellationType, mCarrierFrequencyHz);
}
/** Builder for {@link GnssAutomaticGainControl} */
public static final class Builder {
private double mLevelDb;
private int mConstellationType;
private long mCarrierFrequencyHz;
/**
* Constructs a {@link GnssAutomaticGainControl.Builder} instance.
*/
public Builder() {
}
/**
* Constructs a {@link GnssAutomaticGainControl.Builder} instance by copying a
* {@link GnssAutomaticGainControl}.
*/
public Builder(@NonNull GnssAutomaticGainControl agc) {
mLevelDb = agc.getLevelDb();
mConstellationType = agc.getConstellationType();
mCarrierFrequencyHz = agc.getCarrierFrequencyHz();
}
/**
* Sets the Automatic Gain Control level in dB.
*/
@NonNull
public Builder setLevelDb(@FloatRange(from = -10000, to = 10000) double levelDb) {
Preconditions.checkArgument(levelDb >= -10000 && levelDb <= 10000);
mLevelDb = levelDb;
return this;
}
/**
* Sets the constellation type.
*/
@NonNull
public Builder setConstellationType(@GnssStatus.ConstellationType int constellationType) {
mConstellationType = constellationType;
return this;
}
/**
* Sets the Carrier frequency in Hz.
*/
@NonNull public Builder setCarrierFrequencyHz(@IntRange(from = 0) long carrierFrequencyHz) {
Preconditions.checkArgumentNonnegative(carrierFrequencyHz);
mCarrierFrequencyHz = carrierFrequencyHz;
return this;
}
/** Builds a {@link GnssAutomaticGainControl} instance as specified by this builder. */
@NonNull
public GnssAutomaticGainControl build() {
return new GnssAutomaticGainControl(mLevelDb, mConstellationType, mCarrierFrequencyHz);
}
}
}

8
location/java/android/location/GnssMeasurement.java
View File

@@ -1381,7 +1381,10 @@ public final class GnssMeasurement implements Parcelable {
/**
* Returns {@code true} if {@link #getAutomaticGainControlLevelDb()} is available,
* {@code false} otherwise.
*
* @deprecated Use {@link GnssMeasurementsEvent#getGnssAutomaticGainControls()} instead.
*/
@Deprecated
public boolean hasAutomaticGainControlLevelDb() {
return isFlagSet(HAS_AUTOMATIC_GAIN_CONTROL);
}
@@ -1401,7 +1404,10 @@ public final class GnssMeasurement implements Parcelable {
* indicative of changes on input signal power in the frequency band for this measurement.
*
* <p> The value is only available if {@link #hasAutomaticGainControlLevelDb()} is {@code true}
*
* @deprecated Use {@link GnssMeasurementsEvent#getGnssAutomaticGainControls()} instead.
*/
@Deprecated
public double getAutomaticGainControlLevelDb() {
return mAutomaticGainControlLevelInDb;
}
@@ -1409,7 +1415,9 @@ public final class GnssMeasurement implements Parcelable {
/**
* Sets the Automatic Gain Control level in dB.
* @hide
* @deprecated Use {@link GnssMeasurementsEvent.Builder#setGnssAutomaticGainControls()} instead.
*/
@Deprecated
@TestApi
public void setAutomaticGainControlLevelInDb(double agcLevelDb) {
setFlag(HAS_AUTOMATIC_GAIN_CONTROL);

167
location/java/android/location/GnssMeasurementsEvent.java
View File

@@ -18,16 +18,19 @@ package android.location;
import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.TestApi;
import android.annotation.Nullable;
import android.os.Parcel;
import android.os.Parcelable;
import com.android.internal.util.Preconditions;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/**
* A class implementing a container for data associated with a measurement event.
@@ -35,7 +38,8 @@ import java.util.Collections;
*/
public final class GnssMeasurementsEvent implements Parcelable {
private final GnssClock mClock;
private final Collection<GnssMeasurement> mReadOnlyMeasurements;
private final List<GnssMeasurement> mMeasurements;
private final List<GnssAutomaticGainControl> mGnssAgcs;
/**
* Used for receiving GNSS satellite measurements from the GNSS engine.
@@ -116,20 +120,13 @@ public final class GnssMeasurementsEvent implements Parcelable {
}
/**
* @hide
* Create a {@link GnssMeasurementsEvent} instance with a full list of parameters.
*/
@TestApi
public GnssMeasurementsEvent(GnssClock clock, GnssMeasurement[] measurements) {
if (clock == null) {
throw new InvalidParameterException("Parameter 'clock' must not be null.");
}
if (measurements == null || measurements.length == 0) {
mReadOnlyMeasurements = Collections.emptyList();
} else {
Collection<GnssMeasurement> measurementCollection = Arrays.asList(measurements);
mReadOnlyMeasurements = Collections.unmodifiableCollection(measurementCollection);
}
private GnssMeasurementsEvent(@NonNull GnssClock clock,
@NonNull List<GnssMeasurement> measurements,
@NonNull List<GnssAutomaticGainControl> agcs) {
mMeasurements = measurements;
mGnssAgcs = agcs;
mClock = clock;
}
@@ -143,26 +140,31 @@ public final class GnssMeasurementsEvent implements Parcelable {
}
/**
* Gets a read-only collection of measurements associated with the current event.
* Gets the collection of measurements associated with the current event.
*/
@NonNull
public Collection<GnssMeasurement> getMeasurements() {
return mReadOnlyMeasurements;
return mMeasurements;
}
/**
* Gets the collection of {@link GnssAutomaticGainControl} associated with the
* current event.
*/
@NonNull
public Collection<GnssAutomaticGainControl> getGnssAutomaticGainControls() {
return mGnssAgcs;
}
public static final @android.annotation.NonNull Creator<GnssMeasurementsEvent> CREATOR =
new Creator<GnssMeasurementsEvent>() {
@Override
public GnssMeasurementsEvent createFromParcel(Parcel in) {
ClassLoader classLoader = getClass().getClassLoader();
GnssClock clock = in.readParcelable(classLoader);
int measurementsLength = in.readInt();
GnssMeasurement[] measurementsArray = new GnssMeasurement[measurementsLength];
in.readTypedArray(measurementsArray, GnssMeasurement.CREATOR);
return new GnssMeasurementsEvent(clock, measurementsArray);
GnssClock clock = in.readParcelable(getClass().getClassLoader());
List<GnssMeasurement> measurements = in.createTypedArrayList(GnssMeasurement.CREATOR);
List<GnssAutomaticGainControl> agcs = in.createTypedArrayList(
GnssAutomaticGainControl.CREATOR);
return new GnssMeasurementsEvent(clock, measurements, agcs);
}
@Override
@@ -179,28 +181,105 @@ public final class GnssMeasurementsEvent implements Parcelable {
@Override
public void writeToParcel(Parcel parcel, int flags) {
parcel.writeParcelable(mClock, flags);
int measurementsCount = mReadOnlyMeasurements.size();
GnssMeasurement[] measurementsArray =
mReadOnlyMeasurements.toArray(new GnssMeasurement[measurementsCount]);
parcel.writeInt(measurementsArray.length);
parcel.writeTypedArray(measurementsArray, flags);
parcel.writeTypedList(mMeasurements);
parcel.writeTypedList(mGnssAgcs);
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder("[ GnssMeasurementsEvent:\n\n");
builder.append(mClock.toString());
builder.append("\n");
for (GnssMeasurement measurement : mReadOnlyMeasurements) {
builder.append(measurement.toString());
builder.append("\n");
}
StringBuilder builder = new StringBuilder("GnssMeasurementsEvent[");
builder.append(mClock);
builder.append(' ').append(mMeasurements.toString());
builder.append(' ').append(mGnssAgcs.toString());
builder.append("]");
return builder.toString();
}
/** Builder for {@link GnssMeasurementsEvent} */
public static final class Builder {
private GnssClock mClock;
private List<GnssMeasurement> mMeasurements;
private List<GnssAutomaticGainControl> mGnssAgcs;
/**
* Constructs a {@link GnssMeasurementsEvent.Builder} instance.
*/
public Builder() {
mClock = new GnssClock();
mMeasurements = new ArrayList<>();
mGnssAgcs = new ArrayList<>();
}
/**
* Constructs a {@link GnssMeasurementsEvent.Builder} instance by copying a
* {@link GnssMeasurementsEvent}.
*/
public Builder(@NonNull GnssMeasurementsEvent event) {
mClock = event.getClock();
mMeasurements = (List<GnssMeasurement>) event.getMeasurements();
mGnssAgcs = (List<GnssAutomaticGainControl>) event.getGnssAutomaticGainControls();
}
/**
* Sets the {@link GnssClock}.
*/
@NonNull
public Builder setClock(@NonNull GnssClock clock) {
Preconditions.checkNotNull(clock);
mClock = clock;
return this;
}
/**
* Sets the collection of {@link GnssMeasurement}.
*
* This API exists for JNI since it is easier for JNI to work with an array than a
* collection.
* @hide
*/
@NonNull
public Builder setMeasurements(@Nullable GnssMeasurement... measurements) {
mMeasurements = measurements == null ? Collections.emptyList() : Arrays.asList(
measurements);
return this;
}
/**
* Sets the collection of {@link GnssMeasurement}.
*/
@NonNull
public Builder setMeasurements(@NonNull Collection<GnssMeasurement> measurements) {
mMeasurements = new ArrayList<>(measurements);
return this;
}
/**
* Sets the collection of {@link GnssAutomaticGainControl}.
*
* This API exists for JNI since it is easier for JNI to work with an array than a
* collection.
* @hide
*/
@NonNull
public Builder setGnssAutomaticGainControls(@Nullable GnssAutomaticGainControl... agcs) {
mGnssAgcs = agcs == null ? Collections.emptyList() : Arrays.asList(agcs);
return this;
}
/**
* Sets the collection of {@link GnssAutomaticGainControl}.
*/
@NonNull
public Builder setGnssAutomaticGainControls(
@NonNull Collection<GnssAutomaticGainControl> agcs) {
mGnssAgcs = new ArrayList<>(agcs);
return this;
}
/** Builds a {@link GnssMeasurementsEvent} instance as specified by this builder. */
@NonNull
public GnssMeasurementsEvent build() {
return new GnssMeasurementsEvent(mClock, mMeasurements, mGnssAgcs);
}
}
}

127
services/core/jni/gnss/GnssMeasurementCallback.cpp
View File

@@ -27,12 +27,16 @@ using hardware::gnss::GnssClock;
using hardware::gnss::GnssData;
using hardware::gnss::GnssMeasurement;
using hardware::gnss::SatellitePvt;
using GnssAgc = hardware::gnss::GnssData::GnssAgc;
namespace {
jclass class_arrayList;
jclass class_clockInfo;
jclass class_correlationVectorBuilder;
jclass class_gnssAgc;
jclass class_gnssAgcBuilder;
jclass class_gnssMeasurementsEvent;
jclass class_gnssMeasurementsEventBuilder;
jclass class_gnssMeasurement;
jclass class_gnssClock;
jclass class_positionEcef;
@@ -47,7 +51,16 @@ jmethodID method_correlationVectorBuilderSetFrequencyOffsetMetersPerSecond;
jmethodID method_correlationVectorBuilderSetMagnitude;
jmethodID method_correlationVectorBuilderSetSamplingStartMeters;
jmethodID method_correlationVectorBuilderSetSamplingWidthMeters;
jmethodID method_gnssMeasurementsEventCtor;
jmethodID method_gnssAgcBuilderCtor;
jmethodID method_gnssAgcBuilderSetLevelDb;
jmethodID method_gnssAgcBuilderSetConstellationType;
jmethodID method_gnssAgcBuilderSetCarrierFrequencyHz;
jmethodID method_gnssAgcBuilderBuild;
jmethodID method_gnssMeasurementsEventBuilderCtor;
jmethodID method_gnssMeasurementsEventBuilderSetClock;
jmethodID method_gnssMeasurementsEventBuilderSetMeasurements;
jmethodID method_gnssMeasurementsEventBuilderSetGnssAutomaticGainControls;
jmethodID method_gnssMeasurementsEventBuilderBuild;
jmethodID method_gnssMeasurementsSetCorrelationVectors;
jmethodID method_gnssMeasurementsSetSatellitePvt;
jmethodID method_gnssClockCtor;
@@ -69,12 +82,55 @@ jmethodID method_clockInfo;
void GnssMeasurement_class_init_once(JNIEnv* env, jclass& clazz) {
method_reportMeasurementData = env->GetMethodID(clazz, "reportMeasurementData",
"(Landroid/location/GnssMeasurementsEvent;)V");
// Initialize GnssMeasurement related classes and methods
jclass gnssMeasurementsEventClass = env->FindClass("android/location/GnssMeasurementsEvent");
class_gnssMeasurementsEvent = (jclass)env->NewGlobalRef(gnssMeasurementsEventClass);
method_gnssMeasurementsEventCtor =
env->GetMethodID(class_gnssMeasurementsEvent, "<init>",
"(Landroid/location/GnssClock;[Landroid/location/GnssMeasurement;)V");
jclass gnssMeasurementsEventBuilderClass =
env->FindClass("android/location/GnssMeasurementsEvent$Builder");
class_gnssMeasurementsEventBuilder =
(jclass)env->NewGlobalRef(gnssMeasurementsEventBuilderClass);
method_gnssMeasurementsEventBuilderCtor =
env->GetMethodID(class_gnssMeasurementsEventBuilder, "<init>", "()V");
method_gnssMeasurementsEventBuilderSetClock =
env->GetMethodID(class_gnssMeasurementsEventBuilder, "setClock",
"(Landroid/location/GnssClock;)"
"Landroid/location/GnssMeasurementsEvent$Builder;");
method_gnssMeasurementsEventBuilderSetMeasurements =
env->GetMethodID(class_gnssMeasurementsEventBuilder, "setMeasurements",
"([Landroid/location/GnssMeasurement;)"
"Landroid/location/GnssMeasurementsEvent$Builder;");
method_gnssMeasurementsEventBuilderSetGnssAutomaticGainControls =
env->GetMethodID(class_gnssMeasurementsEventBuilder, "setGnssAutomaticGainControls",
"([Landroid/location/GnssAutomaticGainControl;)"
"Landroid/location/GnssMeasurementsEvent$Builder;");
method_gnssMeasurementsEventBuilderBuild =
env->GetMethodID(class_gnssMeasurementsEventBuilder, "build",
"()Landroid/location/GnssMeasurementsEvent;");
// Initialize GnssAgc related classes and methods
jclass gnssAgcClass = env->FindClass("android/location/GnssAutomaticGainControl");
class_gnssAgc = (jclass)env->NewGlobalRef(gnssAgcClass);
jclass gnssAgcBuilderClass =
env->FindClass("android/location/GnssAutomaticGainControl$Builder");
class_gnssAgcBuilder = (jclass)env->NewGlobalRef(gnssAgcBuilderClass);
method_gnssAgcBuilderCtor = env->GetMethodID(class_gnssAgcBuilder, "<init>", "()V");
method_gnssAgcBuilderSetLevelDb =
env->GetMethodID(class_gnssAgcBuilder, "setLevelDb",
"(D)"
"Landroid/location/GnssAutomaticGainControl$Builder;");
method_gnssAgcBuilderSetConstellationType =
env->GetMethodID(class_gnssAgcBuilder, "setConstellationType",
"(I)"
"Landroid/location/GnssAutomaticGainControl$Builder;");
method_gnssAgcBuilderSetCarrierFrequencyHz =
env->GetMethodID(class_gnssAgcBuilder, "setCarrierFrequencyHz",
"(J)"
"Landroid/location/GnssAutomaticGainControl$Builder;");
method_gnssAgcBuilderBuild = env->GetMethodID(class_gnssAgcBuilder, "build",
"()Landroid/location/GnssAutomaticGainControl;");
// Initialize GnssMeasurement related classes and methods
jclass gnssMeasurementClass = env->FindClass("android/location/GnssMeasurement");
class_gnssMeasurement = (jclass)env->NewGlobalRef(gnssMeasurementClass);
method_gnssMeasurementCtor = env->GetMethodID(class_gnssMeasurement, "<init>", "()V");
@@ -152,14 +208,25 @@ void GnssMeasurement_class_init_once(JNIEnv* env, jclass& clazz) {
}
void setMeasurementData(JNIEnv* env, jobject& callbacksObj, jobject clock,
jobjectArray measurementArray) {
jobject gnssMeasurementsEvent =
env->NewObject(class_gnssMeasurementsEvent, method_gnssMeasurementsEventCtor, clock,
measurementArray);
jobjectArray measurementArray, jobjectArray gnssAgcArray) {
jobject gnssMeasurementsEventBuilderObject =
env->NewObject(class_gnssMeasurementsEventBuilder,
method_gnssMeasurementsEventBuilderCtor);
env->CallObjectMethod(gnssMeasurementsEventBuilderObject,
method_gnssMeasurementsEventBuilderSetClock, clock);
env->CallObjectMethod(gnssMeasurementsEventBuilderObject,
method_gnssMeasurementsEventBuilderSetMeasurements, measurementArray);
env->CallObjectMethod(gnssMeasurementsEventBuilderObject,
method_gnssMeasurementsEventBuilderSetGnssAutomaticGainControls,
gnssAgcArray);
jobject gnssMeasurementsEventObject =
env->CallObjectMethod(gnssMeasurementsEventBuilderObject,
method_gnssMeasurementsEventBuilderBuild);
env->CallVoidMethod(callbacksObj, method_reportMeasurementData, gnssMeasurementsEvent);
env->CallVoidMethod(callbacksObj, method_reportMeasurementData, gnssMeasurementsEventObject);
checkAndClearExceptionFromCallback(env, __FUNCTION__);
env->DeleteLocalRef(gnssMeasurementsEvent);
env->DeleteLocalRef(gnssMeasurementsEventBuilderObject);
env->DeleteLocalRef(gnssMeasurementsEventObject);
}
template <class T_Measurement, class T_Flags>
@@ -289,9 +356,13 @@ void GnssMeasurementCallbackAidl::translateAndSetGnssData(const GnssData& data)
JavaObject gnssClockJavaObject(env, class_gnssClock, method_gnssClockCtor);
translateGnssClock(env, data, gnssClockJavaObject);
jobject clock = gnssClockJavaObject.get();
jobjectArray measurementArray = translateAllGnssMeasurements(env, data.measurements);
setMeasurementData(env, mCallbacksObj, clock, measurementArray);
jobjectArray gnssAgcArray = nullptr;
if (data.gnssAgcs.has_value()) {
gnssAgcArray = translateAllGnssAgcs(env, data.gnssAgcs.value());
}
setMeasurementData(env, mCallbacksObj, clock, measurementArray, gnssAgcArray);
env->DeleteLocalRef(clock);
env->DeleteLocalRef(measurementArray);
@@ -436,6 +507,38 @@ jobjectArray GnssMeasurementCallbackAidl::translateAllGnssMeasurements(
return gnssMeasurementArray;
}
jobjectArray GnssMeasurementCallbackAidl::translateAllGnssAgcs(
JNIEnv* env, const std::vector<std::optional<GnssAgc>>& agcs) {
if (agcs.size() == 0) {
return nullptr;
}
jobjectArray gnssAgcArray =
env->NewObjectArray(agcs.size(), class_gnssAgc, nullptr /* initialElement */);
for (uint16_t i = 0; i < agcs.size(); ++i) {
if (!agcs[i].has_value()) {
continue;
}
const GnssAgc& gnssAgc = agcs[i].value();
jobject agcBuilderObject = env->NewObject(class_gnssAgcBuilder, method_gnssAgcBuilderCtor);
env->CallObjectMethod(agcBuilderObject, method_gnssAgcBuilderSetLevelDb,
gnssAgc.agcLevelDb);
env->CallObjectMethod(agcBuilderObject, method_gnssAgcBuilderSetConstellationType,
(int)gnssAgc.constellation);
env->CallObjectMethod(agcBuilderObject, method_gnssAgcBuilderSetCarrierFrequencyHz,
gnssAgc.carrierFrequencyHz);
jobject agcObject = env->CallObjectMethod(agcBuilderObject, method_gnssAgcBuilderBuild);
env->SetObjectArrayElement(gnssAgcArray, i, agcObject);
env->DeleteLocalRef(agcBuilderObject);
env->DeleteLocalRef(agcObject);
}
return gnssAgcArray;
}
void GnssMeasurementCallbackAidl::translateGnssClock(JNIEnv* env, const GnssData& data,
JavaObject& object) {
setElapsedRealtimeFields<ElapsedRealtime, ElapsedRealtime>(data.elapsedRealtime, object);

6
services/core/jni/gnss/GnssMeasurementCallback.h
View File

@@ -48,7 +48,7 @@ extern jmethodID method_reportMeasurementData;
void GnssMeasurement_class_init_once(JNIEnv* env, jclass& clazz);
void setMeasurementData(JNIEnv* env, jobject& callbacksObj, jobject clock,
jobjectArray measurementArray);
jobjectArray measurementArray, jobjectArray gnssAgcArray);
class GnssMeasurementCallbackAidl : public hardware::gnss::BnGnssMeasurementCallback {
public:
@@ -62,6 +62,8 @@ private:
jobjectArray translateAllGnssMeasurements(
JNIEnv* env, const std::vector<hardware::gnss::GnssMeasurement>& measurements);
jobjectArray translateAllGnssAgcs(
JNIEnv* env, const std::vector<std::optional<hardware::gnss::GnssData::GnssAgc>>& agcs);
void translateAndSetGnssData(const hardware::gnss::GnssData& data);
@@ -139,7 +141,7 @@ void GnssMeasurementCallbackHidl::translateAndSetGnssData(const T& data) {
size_t count = getMeasurementCount(data);
jobjectArray measurementArray =
translateAllGnssMeasurements(env, data.measurements.data(), count);
setMeasurementData(env, mCallbacksObj, clock, measurementArray);
setMeasurementData(env, mCallbacksObj, clock, measurementArray, nullptr);
env->DeleteLocalRef(clock);
env->DeleteLocalRef(measurementArray);