Add hasFullTracking for backward compatibility

Also add plumbing for isFullTracking in JNI Bug: 257549183 Test: atest GnssMeasurementRegistrationTest Change-Id: I2d41b7aaaceb225c29cf282a2733ab9dfdd9d6c0
2022-11-22 18:58:23 +00:00
parent c85432c4bf
commit dcb79a624f
4 changed files with 67 additions and 13 deletions
--- a/core/api/current.txt
+++ b/core/api/current.txt
@@ -19872,8 +19872,9 @@ package android.location {
    method public int describeContents();
    method @NonNull public android.location.GnssClock getClock();
    method @NonNull public java.util.Collection<android.location.GnssAutomaticGainControl> getGnssAutomaticGainControls();
-    method public boolean getIsFullTracking();
    method @NonNull public java.util.Collection<android.location.GnssMeasurement> getMeasurements();
+    method public boolean hasFullTracking();
+    method public boolean isFullTracking();
    method public void writeToParcel(android.os.Parcel, int);
    field @NonNull public static final android.os.Parcelable.Creator<android.location.GnssMeasurementsEvent> CREATOR;
  }
@@ -19882,9 +19883,10 @@ package android.location {
    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 clearFullTracking();
    method @NonNull public android.location.GnssMeasurementsEvent.Builder setClock(@NonNull android.location.GnssClock);
+    method @NonNull public android.location.GnssMeasurementsEvent.Builder setFullTracking(boolean);
    method @NonNull public android.location.GnssMeasurementsEvent.Builder setGnssAutomaticGainControls(@NonNull java.util.Collection<android.location.GnssAutomaticGainControl>);
-    method @NonNull public android.location.GnssMeasurementsEvent.Builder setIsFullTracking(boolean);
    method @NonNull public android.location.GnssMeasurementsEvent.Builder setMeasurements(@NonNull java.util.Collection<android.location.GnssMeasurement>);
  }

--- a/location/java/android/location/GnssMeasurementsEvent.java
+++ b/location/java/android/location/GnssMeasurementsEvent.java
@@ -37,11 +37,14 @@ import java.util.List;
 * Events are delivered to registered instances of {@link Callback}.
 */
 public final class GnssMeasurementsEvent implements Parcelable {
+    private final int mFlag;
    private final GnssClock mClock;
    private final List<GnssMeasurement> mMeasurements;
    private final List<GnssAutomaticGainControl> mGnssAgcs;
    private final boolean mIsFullTracking;

+    private static final int HAS_FULL_TRACKING = 1;
+
    /**
     * Used for receiving GNSS satellite measurements from the GNSS engine.
     * Each measurement contains raw and computed data identifying a satellite.
@@ -123,10 +126,12 @@ public final class GnssMeasurementsEvent implements Parcelable {
    /**
     * Create a {@link GnssMeasurementsEvent} instance with a full list of parameters.
     */
-    private GnssMeasurementsEvent(@NonNull GnssClock clock,
+    private GnssMeasurementsEvent(int flag,
+            @NonNull GnssClock clock,
            @NonNull List<GnssMeasurement> measurements,
            @NonNull List<GnssAutomaticGainControl> agcs,
            boolean isFullTracking) {
+        mFlag = flag;
        mMeasurements = measurements;
        mGnssAgcs = agcs;
        mClock = clock;
@@ -168,22 +173,32 @@ public final class GnssMeasurementsEvent implements Parcelable {
     *
     * False indicates that the GNSS chipset may optimize power via duty cycling, constellations and
     * frequency limits, etc.
+     *
+     * <p>The value is only available if {@link #hasFullTracking()} is {@code true}.
     */
-    public boolean getIsFullTracking() {
+    public boolean isFullTracking() {
        return mIsFullTracking;
    }

+    /**
+     * Return {@code true} if {@link #isFullTracking()} is available, {@code false} otherwise.
+     */
+    public boolean hasFullTracking() {
+        return (mFlag & HAS_FULL_TRACKING) == HAS_FULL_TRACKING;
+    }
+
    public static final @android.annotation.NonNull Creator<GnssMeasurementsEvent> CREATOR =
            new Creator<GnssMeasurementsEvent>() {
        @Override
        public GnssMeasurementsEvent createFromParcel(Parcel in) {
+            int flag = in.readInt();
            GnssClock clock = in.readParcelable(getClass().getClassLoader(),
                    android.location.GnssClock.class);
            List<GnssMeasurement> measurements = in.createTypedArrayList(GnssMeasurement.CREATOR);
            List<GnssAutomaticGainControl> agcs = in.createTypedArrayList(
                    GnssAutomaticGainControl.CREATOR);
            boolean isFullTracking = in.readBoolean();
-            return new GnssMeasurementsEvent(clock, measurements, agcs, isFullTracking);
+            return new GnssMeasurementsEvent(flag, clock, measurements, agcs, isFullTracking);
        }

        @Override
@@ -199,6 +214,7 @@ public final class GnssMeasurementsEvent implements Parcelable {

    @Override
    public void writeToParcel(Parcel parcel, int flags) {
+        parcel.writeInt(mFlag);
        parcel.writeParcelable(mClock, flags);
        parcel.writeTypedList(mMeasurements);
        parcel.writeTypedList(mGnssAgcs);
@@ -211,13 +227,16 @@ public final class GnssMeasurementsEvent implements Parcelable {
        builder.append(mClock);
        builder.append(' ').append(mMeasurements.toString());
        builder.append(' ').append(mGnssAgcs.toString());
-        builder.append(" isFullTracking=").append(mIsFullTracking);
+        if (hasFullTracking()) {
+            builder.append(" isFullTracking=").append(mIsFullTracking);
+        }
        builder.append("]");
        return builder.toString();
    }

    /** Builder for {@link GnssMeasurementsEvent} */
    public static final class Builder {
+        private int mFlag;
        private GnssClock mClock;
        private List<GnssMeasurement> mMeasurements;
        private List<GnssAutomaticGainControl> mGnssAgcs;
@@ -237,10 +256,11 @@ public final class GnssMeasurementsEvent implements Parcelable {
         * {@link GnssMeasurementsEvent}.
         */
        public Builder(@NonNull GnssMeasurementsEvent event) {
+            mFlag = event.mFlag;
            mClock = event.getClock();
            mMeasurements = (List<GnssMeasurement>) event.getMeasurements();
            mGnssAgcs = (List<GnssAutomaticGainControl>) event.getGnssAutomaticGainControls();
-            mIsFullTracking = event.getIsFullTracking();
+            mIsFullTracking = event.isFullTracking();
        }

        /**
@@ -313,15 +333,26 @@ public final class GnssMeasurementsEvent implements Parcelable {
         * and frequency limits, etc.
         */
        @NonNull
-        public Builder setIsFullTracking(boolean isFullTracking) {
+        public Builder setFullTracking(boolean isFullTracking) {
+            mFlag |= HAS_FULL_TRACKING;
            mIsFullTracking = isFullTracking;
            return this;
        }

+        /**
+         * Clears the full tracking mode indicator.
+         */
+        @NonNull
+        public Builder clearFullTracking() {
+            mFlag &= ~HAS_FULL_TRACKING;
+            return this;
+        }
+
        /** Builds a {@link GnssMeasurementsEvent} instance as specified by this builder. */
        @NonNull
        public GnssMeasurementsEvent build() {
-            return new GnssMeasurementsEvent(mClock, mMeasurements, mGnssAgcs, mIsFullTracking);
+            return new GnssMeasurementsEvent(mFlag, mClock, mMeasurements, mGnssAgcs,
+                    mIsFullTracking);
        }
    }
 }
--- a/services/core/jni/gnss/GnssMeasurementCallback.cpp
+++ b/services/core/jni/gnss/GnssMeasurementCallback.cpp
@@ -58,6 +58,7 @@ jmethodID method_gnssAgcBuilderSetCarrierFrequencyHz;
 jmethodID method_gnssAgcBuilderBuild;
 jmethodID method_gnssMeasurementsEventBuilderCtor;
 jmethodID method_gnssMeasurementsEventBuilderSetClock;
+jmethodID method_gnssMeasurementsEventBuilderSetFullTracking;
 jmethodID method_gnssMeasurementsEventBuilderSetMeasurements;
 jmethodID method_gnssMeasurementsEventBuilderSetGnssAutomaticGainControls;
 jmethodID method_gnssMeasurementsEventBuilderBuild;
@@ -109,6 +110,10 @@ void GnssMeasurement_class_init_once(JNIEnv* env, jclass& clazz) {
            env->GetMethodID(class_gnssMeasurementsEventBuilder, "setGnssAutomaticGainControls",
                             "([Landroid/location/GnssAutomaticGainControl;)"
                             "Landroid/location/GnssMeasurementsEvent$Builder;");
+    method_gnssMeasurementsEventBuilderSetFullTracking =
+            env->GetMethodID(class_gnssMeasurementsEventBuilder, "setFullTracking",
+                             "(Z)"
+                             "Landroid/location/GnssMeasurementsEvent$Builder;");
    method_gnssMeasurementsEventBuilderBuild =
            env->GetMethodID(class_gnssMeasurementsEventBuilder, "build",
                             "()Landroid/location/GnssMeasurementsEvent;");
@@ -228,7 +233,8 @@ void GnssMeasurement_class_init_once(JNIEnv* env, jclass& clazz) {
 }

 void setMeasurementData(JNIEnv* env, jobject& callbacksObj, jobject clock,
-                        jobjectArray measurementArray, jobjectArray gnssAgcArray) {
+                        jobjectArray measurementArray, jobjectArray gnssAgcArray,
+                        bool hasFullTracking, jboolean isFullTracking) {
    jobject gnssMeasurementsEventBuilderObject =
            env->NewObject(class_gnssMeasurementsEventBuilder,
                           method_gnssMeasurementsEventBuilderCtor);
@@ -240,6 +246,11 @@ void setMeasurementData(JNIEnv* env, jobject& callbacksObj, jobject clock,
    callObjectMethodIgnoringResult(env, gnssMeasurementsEventBuilderObject,
                                   method_gnssMeasurementsEventBuilderSetGnssAutomaticGainControls,
                                   gnssAgcArray);
+    if (hasFullTracking) {
+        callObjectMethodIgnoringResult(env, gnssMeasurementsEventBuilderObject,
+                                       method_gnssMeasurementsEventBuilderSetFullTracking,
+                                       isFullTracking);
+    }
    jobject gnssMeasurementsEventObject =
            env->CallObjectMethod(gnssMeasurementsEventBuilderObject,
                                  method_gnssMeasurementsEventBuilderBuild);
@@ -381,7 +392,14 @@ void GnssMeasurementCallbackAidl::translateAndSetGnssData(const GnssData& data)

    jobjectArray gnssAgcArray = nullptr;
    gnssAgcArray = translateAllGnssAgcs(env, data.gnssAgcs);
-    setMeasurementData(env, mCallbacksObj, clock, measurementArray, gnssAgcArray);
+    if (this->getInterfaceVersion() >= 3) {
+        setMeasurementData(env, mCallbacksObj, clock, measurementArray, gnssAgcArray,
+                           /*hasFullTracking=*/true, data.isFullTracking);
+    } else {
+        setMeasurementData(env, mCallbacksObj, clock, measurementArray, gnssAgcArray,
+                           /*hasFullTracking=*/false,
+                           /*isFullTracking=*/JNI_FALSE);
+    }

    env->DeleteLocalRef(clock);
    env->DeleteLocalRef(measurementArray);
--- a/services/core/jni/gnss/GnssMeasurementCallback.h
+++ b/services/core/jni/gnss/GnssMeasurementCallback.h
@@ -48,7 +48,8 @@ extern jmethodID method_reportMeasurementData;
 void GnssMeasurement_class_init_once(JNIEnv* env, jclass& clazz);

 void setMeasurementData(JNIEnv* env, jobject& callbacksObj, jobject clock,
-                        jobjectArray measurementArray, jobjectArray gnssAgcArray);
+                        jobjectArray measurementArray, jobjectArray gnssAgcArray,
+                        bool hasFullTracking, jboolean isFullTracking);

 class GnssMeasurementCallbackAidl : public hardware::gnss::BnGnssMeasurementCallback {
 public:
@@ -140,7 +141,9 @@ void GnssMeasurementCallbackHidl::translateAndSetGnssData(const T& data) {
    size_t count = getMeasurementCount(data);
    jobjectArray measurementArray =
            translateAllGnssMeasurements(env, data.measurements.data(), count);
-    setMeasurementData(env, mCallbacksObj, clock, measurementArray, nullptr);
+    setMeasurementData(env, mCallbacksObj, clock, measurementArray, /*gnssAgcArray=*/nullptr,
+                       /*hasFullTracking=*/false,
+                       /*isFullTracking=*/JNI_FALSE);

    env->DeleteLocalRef(clock);
    env->DeleteLocalRef(measurementArray);