diff --git a/services/core/jni/com_android_server_location_GnssLocationProvider.cpp b/services/core/jni/com_android_server_location_GnssLocationProvider.cpp
index 54cb79adb7415..c7f1367256cab 100644
--- a/services/core/jni/com_android_server_location_GnssLocationProvider.cpp
+++ b/services/core/jni/com_android_server_location_GnssLocationProvider.cpp
@@ -28,6 +28,7 @@
 #include <android/hardware/gnss/2.1/IGnssAntennaInfo.h>
 #include <android/hardware/gnss/2.1/IGnssMeasurement.h>
 #include <android/hardware/gnss/BnGnss.h>
+#include <android/hardware/gnss/BnGnssAntennaInfo.h>
 #include <android/hardware/gnss/BnGnssCallback.h>
 #include <android/hardware/gnss/BnGnssDebug.h>
 #include <android/hardware/gnss/BnGnssGeofence.h>
@@ -51,6 +52,7 @@
 #include "android_runtime/Log.h"
 #include "gnss/AGnss.h"
 #include "gnss/AGnssRil.h"
+#include "gnss/GnssAntennaInfo.h"
 #include "gnss/GnssAntennaInfoCallback.h"
 #include "gnss/GnssBatching.h"
 #include "gnss/GnssConfiguration.h"
@@ -155,7 +157,6 @@ using IGnss_V2_1 = android::hardware::gnss::V2_1::IGnss;
 using IGnssCallback_V1_0 = android::hardware::gnss::V1_0::IGnssCallback;
 using IGnssCallback_V2_0 = android::hardware::gnss::V2_0::IGnssCallback;
 using IGnssCallback_V2_1 = android::hardware::gnss::V2_1::IGnssCallback;
-using IGnssAntennaInfo = android::hardware::gnss::V2_1::IGnssAntennaInfo;
 
 using IMeasurementCorrections_V1_0 = android::hardware::gnss::measurement_corrections::V1_0::IMeasurementCorrections;
 using IMeasurementCorrections_V1_1 = android::hardware::gnss::measurement_corrections::V1_1::IMeasurementCorrections;
@@ -179,6 +180,7 @@ using IGnssPsdsAidl = android::hardware::gnss::IGnssPsds;
 using IGnssPsdsCallbackAidl = android::hardware::gnss::IGnssPsdsCallback;
 using IGnssConfigurationAidl = android::hardware::gnss::IGnssConfiguration;
 using GnssLocationAidl = android::hardware::gnss::GnssLocation;
+using IGnssAntennaInfoAidl = android::hardware::gnss::IGnssAntennaInfo;
 
 struct GnssDeathRecipient : virtual public hidl_death_recipient
 {
@@ -207,7 +209,6 @@ sp<IGnssNi> gnssNiIface = nullptr;
 sp<IGnssPowerIndication> gnssPowerIndicationIface = nullptr;
 sp<IMeasurementCorrections_V1_0> gnssCorrectionsIface_V1_0 = nullptr;
 sp<IMeasurementCorrections_V1_1> gnssCorrectionsIface_V1_1 = nullptr;
-sp<IGnssAntennaInfo> gnssAntennaInfoIface = nullptr;
 
 std::unique_ptr<GnssConfigurationInterface> gnssConfigurationIface = nullptr;
 std::unique_ptr<android::gnss::GnssMeasurementInterface> gnssMeasurementIface = nullptr;
@@ -218,6 +219,7 @@ std::unique_ptr<android::gnss::AGnssInterface> agnssIface = nullptr;
 std::unique_ptr<android::gnss::GnssDebugInterface> gnssDebugIface = nullptr;
 std::unique_ptr<android::gnss::AGnssRilInterface> agnssRilIface = nullptr;
 std::unique_ptr<android::gnss::GnssVisibilityControlInterface> gnssVisibilityControlIface = nullptr;
+std::unique_ptr<android::gnss::GnssAntennaInfoInterface> gnssAntennaInfoIface = nullptr;
 
 #define WAKE_LOCK_NAME  "GPS"
 
@@ -1163,12 +1165,18 @@ static void android_location_gnss_hal_GnssNative_init_once(JNIEnv* env, jobject
         }
     }
 
-    if (gnssHal_V2_1 != nullptr) {
-        auto gnssAntennaInfo = gnssHal_V2_1->getExtensionGnssAntennaInfo();
-        if (!gnssAntennaInfo.isOk()) {
-            ALOGD("Unable to get a handle to GnssAntennaInfo");
-        } else {
-            gnssAntennaInfoIface = gnssAntennaInfo;
+    if (gnssHalAidl != nullptr && gnssHalAidl->getInterfaceVersion() >= 2) {
+        sp<IGnssAntennaInfoAidl> gnssAntennaInfoAidl;
+        auto status = gnssHalAidl->getExtensionGnssAntennaInfo(&gnssAntennaInfoAidl);
+        if (checkAidlStatus(status, "Unable to get a handle to GnssAntennaInfo interface.")) {
+            gnssAntennaInfoIface = std::make_unique<gnss::GnssAntennaInfoAidl>(gnssAntennaInfoAidl);
+        }
+    } else if (gnssHal_V2_1 != nullptr) {
+        auto gnssAntennaInfo_V2_1 = gnssHal_V2_1->getExtensionGnssAntennaInfo();
+        if (checkHidlReturn(gnssAntennaInfo_V2_1,
+                            "Unable to get a handle to GnssAntennaInfo_V2_1")) {
+            gnssAntennaInfoIface =
+                    std::make_unique<gnss::GnssAntennaInfo_V2_1>(gnssAntennaInfo_V2_1);
         }
     }
 
@@ -1933,25 +1941,7 @@ static jboolean android_location_gnss_hal_GnssNative_start_antenna_info_listenin
         ALOGE("%s: IGnssAntennaInfo interface not available.", __func__);
         return JNI_FALSE;
     }
-
-    sp<gnss::GnssAntennaInfoCallback> cbIface = new gnss::GnssAntennaInfoCallback(mCallbacksObj);
-
-    auto result = gnssAntennaInfoIface->setCallback(cbIface);
-
-    if (!checkHidlReturn(result, "IGnssAntennaInfo setCallback() failed.")) {
-        return JNI_FALSE;
-    }
-
-    IGnssAntennaInfo::GnssAntennaInfoStatus initRet = result;
-    if (initRet != IGnssAntennaInfo::GnssAntennaInfoStatus::SUCCESS) {
-        ALOGE("An error has been found on GnssAntennaInfoInterface::init, status=%d",
-              static_cast<int32_t>(initRet));
-        return JNI_FALSE;
-    } else {
-        ALOGD("gnss antenna info has been enabled");
-    }
-
-    return JNI_TRUE;
+    return gnssAntennaInfoIface->setCallback(std::make_unique<gnss::GnssAntennaInfoCallback>());
 }
 
 static jboolean android_location_gnss_hal_GnssNative_stop_antenna_info_listening(JNIEnv* /* env */,
@@ -1960,9 +1950,7 @@ static jboolean android_location_gnss_hal_GnssNative_stop_antenna_info_listening
         ALOGE("%s: IGnssAntennaInfo interface not available.", __func__);
         return JNI_FALSE;
     }
-
-    auto result = gnssAntennaInfoIface->close();
-    return checkHidlReturn(result, "IGnssAntennaInfo close() failed.");
+    return gnssAntennaInfoIface->close();
 }
 
 static jboolean android_location_gnss_hal_GnssNative_is_measurement_supported(JNIEnv* env, jclass) {
diff --git a/services/core/jni/gnss/Android.bp b/services/core/jni/gnss/Android.bp
index bed72a8aa87cf..252f0e8bad89a 100644
--- a/services/core/jni/gnss/Android.bp
+++ b/services/core/jni/gnss/Android.bp
@@ -27,6 +27,7 @@ cc_library_shared {
         "AGnssCallback.cpp",
         "AGnssRil.cpp",
         "AGnssRilCallback.cpp",
+        "GnssAntennaInfo.cpp",
         "GnssAntennaInfoCallback.cpp",
         "GnssBatching.cpp",
         "GnssBatchingCallback.cpp",
diff --git a/services/core/jni/gnss/GnssAntennaInfo.cpp b/services/core/jni/gnss/GnssAntennaInfo.cpp
new file mode 100644
index 0000000000000..0f41b0f4e8693
--- /dev/null
+++ b/services/core/jni/gnss/GnssAntennaInfo.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+// Define LOG_TAG before <log/log.h> to overwrite the default value.
+#define LOG_TAG "GnssAntennaInfoJni"
+
+#include "GnssAntennaInfo.h"
+
+#include "Utils.h"
+
+using IGnssAntennaInfoAidl = android::hardware::gnss::IGnssAntennaInfo;
+using IGnssAntennaInfo_V2_1 = android::hardware::gnss::V2_1::IGnssAntennaInfo;
+
+namespace android::gnss {
+
+// Implementation of GnssAntennaInfo (AIDL HAL)
+
+GnssAntennaInfoAidl::GnssAntennaInfoAidl(const sp<IGnssAntennaInfoAidl>& iGnssAntennaInfo)
+      : mIGnssAntennaInfoAidl(iGnssAntennaInfo) {
+    assert(mIGnssAntennaInfoAidl != nullptr);
+}
+
+jboolean GnssAntennaInfoAidl::setCallback(
+        const std::unique_ptr<GnssAntennaInfoCallback>& callback) {
+    auto status = mIGnssAntennaInfoAidl->setCallback(callback->getAidl());
+    return checkAidlStatus(status, "IGnssAntennaInfoAidl setCallback() failed.");
+}
+
+jboolean GnssAntennaInfoAidl::close() {
+    auto status = mIGnssAntennaInfoAidl->close();
+    return checkAidlStatus(status, "IGnssAntennaInfoAidl close() failed");
+}
+
+// Implementation of GnssAntennaInfo_V2_1
+
+GnssAntennaInfo_V2_1::GnssAntennaInfo_V2_1(const sp<IGnssAntennaInfo_V2_1>& iGnssAntennaInfo)
+      : mIGnssAntennaInfo_V2_1(iGnssAntennaInfo) {
+    assert(mIGnssAntennaInfo_V2_1 != nullptr);
+}
+
+jboolean GnssAntennaInfo_V2_1::setCallback(
+        const std::unique_ptr<GnssAntennaInfoCallback>& callback) {
+    auto result = mIGnssAntennaInfo_V2_1->setCallback(callback->getV2_1());
+    if (!checkHidlReturn(result, "IGnssAntennaInfo_V2_1 setCallback() failed.")) {
+        return JNI_FALSE;
+    }
+
+    IGnssAntennaInfo_V2_1::GnssAntennaInfoStatus initRet = result;
+    if (initRet != IGnssAntennaInfo_V2_1::GnssAntennaInfoStatus::SUCCESS) {
+        ALOGE("An error has been found on GnssAntennaInfoInterface::init, status=%d",
+              static_cast<int32_t>(initRet));
+        return JNI_FALSE;
+    } else {
+        ALOGD("gnss antenna info v2_1 has been enabled");
+    }
+    return JNI_TRUE;
+}
+
+jboolean GnssAntennaInfo_V2_1::close() {
+    auto result = mIGnssAntennaInfo_V2_1->close();
+    return checkHidlReturn(result, "IGnssAntennaInfo_V2_1 close() failed.");
+}
+
+} // namespace android::gnss
diff --git a/services/core/jni/gnss/GnssAntennaInfo.h b/services/core/jni/gnss/GnssAntennaInfo.h
new file mode 100644
index 0000000000000..9a9dc2a333168
--- /dev/null
+++ b/services/core/jni/gnss/GnssAntennaInfo.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+#ifndef _ANDROID_SERVER_GNSS_GNSSANTENNAINFO_H
+#define _ANDROID_SERVER_GNSS_GNSSANTENNAINFO_H
+
+#pragma once
+
+#ifndef LOG_TAG
+#error LOG_TAG must be defined before including this file.
+#endif
+
+#include <android/hardware/gnss/2.1/IGnssAntennaInfo.h>
+#include <android/hardware/gnss/BnGnssAntennaInfo.h>
+#include <log/log.h>
+
+#include "GnssAntennaInfoCallback.h"
+#include "jni.h"
+
+namespace android::gnss {
+
+class GnssAntennaInfoInterface {
+public:
+    virtual ~GnssAntennaInfoInterface() {}
+    virtual jboolean setCallback(const std::unique_ptr<GnssAntennaInfoCallback>& callback) = 0;
+    virtual jboolean close() = 0;
+};
+
+class GnssAntennaInfoAidl : public GnssAntennaInfoInterface {
+public:
+    GnssAntennaInfoAidl(const sp<android::hardware::gnss::IGnssAntennaInfo>& iGnssAntennaInfo);
+    jboolean setCallback(const std::unique_ptr<GnssAntennaInfoCallback>& callback) override;
+    jboolean close() override;
+
+private:
+    const sp<android::hardware::gnss::IGnssAntennaInfo> mIGnssAntennaInfoAidl;
+};
+
+class GnssAntennaInfo_V2_1 : public GnssAntennaInfoInterface {
+public:
+    GnssAntennaInfo_V2_1(
+            const sp<android::hardware::gnss::V2_1::IGnssAntennaInfo>& iGnssAntennaInfo);
+    jboolean setCallback(const std::unique_ptr<GnssAntennaInfoCallback>& callback) override;
+    jboolean close() override;
+
+private:
+    const sp<android::hardware::gnss::V2_1::IGnssAntennaInfo> mIGnssAntennaInfo_V2_1;
+};
+
+} // namespace android::gnss
+
+#endif // _ANDROID_SERVER_GNSS_GNSSANTENNAINFO_H
diff --git a/services/core/jni/gnss/GnssAntennaInfoCallback.cpp b/services/core/jni/gnss/GnssAntennaInfoCallback.cpp
index 99d06eb062da9..2e99b2b79d370 100644
--- a/services/core/jni/gnss/GnssAntennaInfoCallback.cpp
+++ b/services/core/jni/gnss/GnssAntennaInfoCallback.cpp
@@ -25,8 +25,10 @@ namespace android::gnss {
 using android::hardware::hidl_vec;
 using android::hardware::Return;
 using android::hardware::Void;
+using binder::Status;
 
-using IGnssAntennaInfoCallback = android::hardware::gnss::V2_1::IGnssAntennaInfoCallback;
+using IGnssAntennaInfoCallbackAidl = android::hardware::gnss::IGnssAntennaInfoCallback;
+using IGnssAntennaInfoCallback_V2_1 = android::hardware::gnss::V2_1::IGnssAntennaInfoCallback;
 
 namespace {
 jclass class_gnssAntennaInfoBuilder;
@@ -92,14 +94,21 @@ void GnssAntennaInfo_class_init_once(JNIEnv* env, jclass& clazz) {
     class_doubleArray = (jclass)env->NewGlobalRef(doubleArrayClass);
 }
 
-Return<void> GnssAntennaInfoCallback::gnssAntennaInfoCb(
-        const hidl_vec<IGnssAntennaInfoCallback::GnssAntennaInfo>& gnssAntennaInfos) {
-    translateAndReportGnssAntennaInfo(gnssAntennaInfos);
+binder::Status GnssAntennaInfoCallbackAidl::gnssAntennaInfoCb(
+        const std::vector<IGnssAntennaInfoCallbackAidl::GnssAntennaInfo>& gnssAntennaInfos) {
+    GnssAntennaInfoCallbackUtil::translateAndReportGnssAntennaInfo(gnssAntennaInfos);
+    return Status::ok();
+}
+
+Return<void> GnssAntennaInfoCallback_V2_1::gnssAntennaInfoCb(
+        const hidl_vec<IGnssAntennaInfoCallback_V2_1::GnssAntennaInfo>& gnssAntennaInfos) {
+    GnssAntennaInfoCallbackUtil::translateAndReportGnssAntennaInfo(gnssAntennaInfos);
     return Void();
 }
 
-jobjectArray GnssAntennaInfoCallback::translate2dDoubleArray(
-        JNIEnv* env, const hidl_vec<IGnssAntennaInfoCallback::Row>& array) {
+template <template <class...> class T_vector, class T_info>
+jobjectArray GnssAntennaInfoCallbackUtil::translate2dDoubleArray(JNIEnv* env,
+                                                                 const T_vector<T_info>& array) {
     jsize numRows = array.size();
     if (numRows == 0) {
         // Empty array
@@ -124,8 +133,9 @@ jobjectArray GnssAntennaInfoCallback::translate2dDoubleArray(
     return returnArray;
 }
 
-jobject GnssAntennaInfoCallback::translateAllGnssAntennaInfos(
-        JNIEnv* env, const hidl_vec<IGnssAntennaInfoCallback::GnssAntennaInfo>& gnssAntennaInfos) {
+template <template <class...> class T_vector, class T_info>
+jobject GnssAntennaInfoCallbackUtil::translateAllGnssAntennaInfos(
+        JNIEnv* env, const T_vector<T_info>& gnssAntennaInfos) {
     jobject arrayList = env->NewObject(class_arrayList,
                                        method_arrayListCtor); // Create new ArrayList instance
 
@@ -141,8 +151,9 @@ jobject GnssAntennaInfoCallback::translateAllGnssAntennaInfos(
     return arrayList;
 }
 
-jobject GnssAntennaInfoCallback::translatePhaseCenterOffset(
-        JNIEnv* env, const IGnssAntennaInfoCallback::GnssAntennaInfo& gnssAntennaInfo) {
+template <class T>
+jobject GnssAntennaInfoCallbackUtil::translatePhaseCenterOffset(JNIEnv* env,
+                                                                const T& gnssAntennaInfo) {
     jobject phaseCenterOffset =
             env->NewObject(class_phaseCenterOffset, method_phaseCenterOffsetCtor,
                            gnssAntennaInfo.phaseCenterOffsetCoordinateMillimeters.x,
@@ -155,10 +166,11 @@ jobject GnssAntennaInfoCallback::translatePhaseCenterOffset(
     return phaseCenterOffset;
 }
 
-jobject GnssAntennaInfoCallback::translatePhaseCenterVariationCorrections(
-        JNIEnv* env, const IGnssAntennaInfoCallback::GnssAntennaInfo& gnssAntennaInfo) {
-    if (gnssAntennaInfo.phaseCenterVariationCorrectionMillimeters == NULL ||
-        gnssAntennaInfo.phaseCenterVariationCorrectionUncertaintyMillimeters == NULL) {
+template <>
+jobject GnssAntennaInfoCallbackUtil::translatePhaseCenterVariationCorrections(
+        JNIEnv* env, const IGnssAntennaInfoCallbackAidl::GnssAntennaInfo& gnssAntennaInfo) {
+    if (gnssAntennaInfo.phaseCenterVariationCorrectionMillimeters.empty() ||
+        gnssAntennaInfo.phaseCenterVariationCorrectionUncertaintyMillimeters.empty()) {
         return NULL;
     }
 
@@ -171,6 +183,8 @@ jobject GnssAntennaInfoCallback::translatePhaseCenterVariationCorrections(
 
     if (phaseCenterVariationCorrectionsArray == NULL ||
         phaseCenterVariationCorrectionsUncertaintiesArray == NULL) {
+        env->DeleteLocalRef(phaseCenterVariationCorrectionsArray);
+        env->DeleteLocalRef(phaseCenterVariationCorrectionsUncertaintiesArray);
         return NULL;
     }
 
@@ -185,10 +199,44 @@ jobject GnssAntennaInfoCallback::translatePhaseCenterVariationCorrections(
     return phaseCenterVariationCorrections;
 }
 
-jobject GnssAntennaInfoCallback::translateSignalGainCorrections(
-        JNIEnv* env, const IGnssAntennaInfoCallback::GnssAntennaInfo& gnssAntennaInfo) {
-    if (gnssAntennaInfo.signalGainCorrectionDbi == NULL ||
-        gnssAntennaInfo.signalGainCorrectionUncertaintyDbi == NULL) {
+template <>
+jobject GnssAntennaInfoCallbackUtil::translatePhaseCenterVariationCorrections(
+        JNIEnv* env, const IGnssAntennaInfoCallback_V2_1::GnssAntennaInfo& gnssAntennaInfo) {
+    if (gnssAntennaInfo.phaseCenterVariationCorrectionMillimeters == NULL ||
+        gnssAntennaInfo.phaseCenterVariationCorrectionUncertaintyMillimeters == NULL) {
+        return NULL;
+    }
+
+    jobjectArray phaseCenterVariationCorrectionsArray =
+            translate2dDoubleArray(env, gnssAntennaInfo.phaseCenterVariationCorrectionMillimeters);
+    jobjectArray phaseCenterVariationCorrectionsUncertaintiesArray =
+            translate2dDoubleArray(env,
+                                   gnssAntennaInfo
+                                           .phaseCenterVariationCorrectionUncertaintyMillimeters);
+
+    if (phaseCenterVariationCorrectionsArray == NULL ||
+        phaseCenterVariationCorrectionsUncertaintiesArray == NULL) {
+        env->DeleteLocalRef(phaseCenterVariationCorrectionsArray);
+        env->DeleteLocalRef(phaseCenterVariationCorrectionsUncertaintiesArray);
+        return NULL;
+    }
+
+    jobject phaseCenterVariationCorrections =
+            env->NewObject(class_sphericalCorrections, method_sphericalCorrectionsCtor,
+                           phaseCenterVariationCorrectionsArray,
+                           phaseCenterVariationCorrectionsUncertaintiesArray);
+
+    env->DeleteLocalRef(phaseCenterVariationCorrectionsArray);
+    env->DeleteLocalRef(phaseCenterVariationCorrectionsUncertaintiesArray);
+
+    return phaseCenterVariationCorrections;
+}
+
+template <>
+jobject GnssAntennaInfoCallbackUtil::translateSignalGainCorrections(
+        JNIEnv* env, const IGnssAntennaInfoCallbackAidl::GnssAntennaInfo& gnssAntennaInfo) {
+    if (gnssAntennaInfo.signalGainCorrectionDbi.empty() ||
+        gnssAntennaInfo.signalGainCorrectionUncertaintyDbi.empty()) {
         return NULL;
     }
     jobjectArray signalGainCorrectionsArray =
@@ -197,6 +245,8 @@ jobject GnssAntennaInfoCallback::translateSignalGainCorrections(
             translate2dDoubleArray(env, gnssAntennaInfo.signalGainCorrectionUncertaintyDbi);
 
     if (signalGainCorrectionsArray == NULL || signalGainCorrectionsUncertaintiesArray == NULL) {
+        env->DeleteLocalRef(signalGainCorrectionsArray);
+        env->DeleteLocalRef(signalGainCorrectionsUncertaintiesArray);
         return NULL;
     }
 
@@ -210,8 +260,37 @@ jobject GnssAntennaInfoCallback::translateSignalGainCorrections(
     return signalGainCorrections;
 }
 
-jobject GnssAntennaInfoCallback::translateSingleGnssAntennaInfo(
-        JNIEnv* env, const IGnssAntennaInfoCallback::GnssAntennaInfo& gnssAntennaInfo) {
+template <>
+jobject GnssAntennaInfoCallbackUtil::translateSignalGainCorrections(
+        JNIEnv* env, const IGnssAntennaInfoCallback_V2_1::GnssAntennaInfo& gnssAntennaInfo) {
+    if (gnssAntennaInfo.signalGainCorrectionDbi == NULL ||
+        gnssAntennaInfo.signalGainCorrectionUncertaintyDbi == NULL) {
+        return NULL;
+    }
+    jobjectArray signalGainCorrectionsArray =
+            translate2dDoubleArray(env, gnssAntennaInfo.signalGainCorrectionDbi);
+    jobjectArray signalGainCorrectionsUncertaintiesArray =
+            translate2dDoubleArray(env, gnssAntennaInfo.signalGainCorrectionUncertaintyDbi);
+
+    if (signalGainCorrectionsArray == NULL || signalGainCorrectionsUncertaintiesArray == NULL) {
+        env->DeleteLocalRef(signalGainCorrectionsArray);
+        env->DeleteLocalRef(signalGainCorrectionsUncertaintiesArray);
+        return NULL;
+    }
+
+    jobject signalGainCorrections =
+            env->NewObject(class_sphericalCorrections, method_sphericalCorrectionsCtor,
+                           signalGainCorrectionsArray, signalGainCorrectionsUncertaintiesArray);
+
+    env->DeleteLocalRef(signalGainCorrectionsArray);
+    env->DeleteLocalRef(signalGainCorrectionsUncertaintiesArray);
+
+    return signalGainCorrections;
+}
+
+template <class T>
+jobject GnssAntennaInfoCallbackUtil::translateSingleGnssAntennaInfo(JNIEnv* env,
+                                                                    const T& gnssAntennaInfo) {
     jobject phaseCenterOffset = translatePhaseCenterOffset(env, gnssAntennaInfo);
 
     // Nullable
@@ -228,7 +307,7 @@ jobject GnssAntennaInfoCallback::translateSingleGnssAntennaInfo(
     // Set fields
     callObjectMethodIgnoringResult(env, gnssAntennaInfoBuilderObject,
                                    method_gnssAntennaInfoBuilderSetCarrierFrequencyMHz,
-                                   gnssAntennaInfo.carrierFrequencyMHz);
+                                   getCarrierFrequencyMHz(gnssAntennaInfo));
     callObjectMethodIgnoringResult(env, gnssAntennaInfoBuilderObject,
                                    method_gnssAntennaInfoBuilderSetPhaseCenterOffset,
                                    phaseCenterOffset);
@@ -251,8 +330,9 @@ jobject GnssAntennaInfoCallback::translateSingleGnssAntennaInfo(
     return gnssAntennaInfoObject;
 }
 
-void GnssAntennaInfoCallback::translateAndReportGnssAntennaInfo(
-        const hidl_vec<IGnssAntennaInfoCallback::GnssAntennaInfo>& gnssAntennaInfos) {
+template <template <class...> class T_vector, class T_info>
+void GnssAntennaInfoCallbackUtil::translateAndReportGnssAntennaInfo(
+        const T_vector<T_info>& gnssAntennaInfos) {
     JNIEnv* env = getJniEnv();
 
     jobject arrayList = translateAllGnssAntennaInfos(env, gnssAntennaInfos);
@@ -262,7 +342,7 @@ void GnssAntennaInfoCallback::translateAndReportGnssAntennaInfo(
     env->DeleteLocalRef(arrayList);
 }
 
-void GnssAntennaInfoCallback::reportAntennaInfo(JNIEnv* env, const jobject antennaInfosArray) {
+void GnssAntennaInfoCallbackUtil::reportAntennaInfo(JNIEnv* env, const jobject antennaInfosArray) {
     env->CallVoidMethod(mCallbacksObj, method_reportAntennaInfo, antennaInfosArray);
     checkAndClearExceptionFromCallback(env, __FUNCTION__);
 }
diff --git a/services/core/jni/gnss/GnssAntennaInfoCallback.h b/services/core/jni/gnss/GnssAntennaInfoCallback.h
index 0fc763336077e..89f27e0381b27 100644
--- a/services/core/jni/gnss/GnssAntennaInfoCallback.h
+++ b/services/core/jni/gnss/GnssAntennaInfoCallback.h
@@ -24,7 +24,9 @@
 #endif
 
 #include <android/hardware/gnss/2.1/IGnssAntennaInfo.h>
+#include <android/hardware/gnss/BnGnssAntennaInfoCallback.h>
 #include <log/log.h>
+
 #include "Utils.h"
 #include "jni.h"
 
@@ -33,50 +35,86 @@ namespace android::gnss {
 void GnssAntennaInfo_class_init_once(JNIEnv* env, jclass& clazz);
 
 /*
- * GnssAntennaInfoCallback implements the callback methods required for the
- * GnssAntennaInfo interface.
+ * GnssAntennaInfoCallbackAidl implements the callback methods required for the
+ * android::hardware::gnss::IGnssAntennaInfo interface.
  */
-struct GnssAntennaInfoCallback : public android::hardware::gnss::V2_1::IGnssAntennaInfoCallback {
-    GnssAntennaInfoCallback(jobject& callbacksObj) : mCallbacksObj(callbacksObj) {}
+class GnssAntennaInfoCallbackAidl : public android::hardware::gnss::BnGnssAntennaInfoCallback {
+public:
+    binder::Status gnssAntennaInfoCb(const std::vector<GnssAntennaInfo>& gnssAntennaInfos) override;
+};
+
+/*
+ * GnssAntennaInfoCallback implements the callback methods required for the
+ * V2_1::GnssAntennaInfo interface.
+ */
+class GnssAntennaInfoCallback_V2_1
+      : public android::hardware::gnss::V2_1::IGnssAntennaInfoCallback {
+public:
     // Methods from V2_1::GnssAntennaInfoCallback follow.
     hardware::Return<void> gnssAntennaInfoCb(
             const hardware::hidl_vec<
                     android::hardware::gnss::V2_1::IGnssAntennaInfoCallback::GnssAntennaInfo>&
-                    gnssAntennaInfos);
+                    gnssAntennaInfos) override;
+};
+
+class GnssAntennaInfoCallback {
+public:
+    GnssAntennaInfoCallback() {}
+    sp<GnssAntennaInfoCallbackAidl> getAidl() {
+        if (callbackAidl == nullptr) {
+            callbackAidl = sp<GnssAntennaInfoCallbackAidl>::make();
+        }
+        return callbackAidl;
+    }
+
+    sp<GnssAntennaInfoCallback_V2_1> getV2_1() {
+        if (callbackV2_1 == nullptr) {
+            callbackV2_1 = sp<GnssAntennaInfoCallback_V2_1>::make();
+        }
+        return callbackV2_1;
+    }
 
 private:
-    jobject translateAllGnssAntennaInfos(
-            JNIEnv* env,
-            const hardware::hidl_vec<
-                    android::hardware::gnss::V2_1::IGnssAntennaInfoCallback::GnssAntennaInfo>&
-                    gnssAntennaInfos);
-    jobject translateSingleGnssAntennaInfo(
-            JNIEnv* env,
-            const android::hardware::gnss::V2_1::IGnssAntennaInfoCallback::GnssAntennaInfo&
-                    gnssAntennaInfo);
-    jobject translatePhaseCenterOffset(
-            JNIEnv* env,
-            const android::hardware::gnss::V2_1::IGnssAntennaInfoCallback::GnssAntennaInfo&
-                    gnssAntennaInfo);
-    jobject translatePhaseCenterVariationCorrections(
-            JNIEnv* env,
-            const android::hardware::gnss::V2_1::IGnssAntennaInfoCallback::GnssAntennaInfo&
-                    gnssAntennaInfo);
-    jobject translateSignalGainCorrections(
-            JNIEnv* env,
-            const android::hardware::gnss::V2_1::IGnssAntennaInfoCallback::GnssAntennaInfo&
-                    gnssAntennaInfo);
-    jobjectArray translate2dDoubleArray(
-            JNIEnv* env,
-            const hardware::hidl_vec<android::hardware::gnss::V2_1::IGnssAntennaInfoCallback::Row>&
-                    array);
-    void translateAndReportGnssAntennaInfo(
-            const hardware::hidl_vec<
-                    android::hardware::gnss::V2_1::IGnssAntennaInfoCallback::GnssAntennaInfo>&
-                    gnssAntennaInfos);
-    void reportAntennaInfo(JNIEnv* env, const jobject antennaInfosArray);
+    sp<GnssAntennaInfoCallbackAidl> callbackAidl;
+    sp<GnssAntennaInfoCallback_V2_1> callbackV2_1;
+};
 
-    jobject& mCallbacksObj;
+struct GnssAntennaInfoCallbackUtil {
+    template <template <class...> class T_vector, class T_info>
+    static jobject translateAllGnssAntennaInfos(JNIEnv* env,
+                                                const T_vector<T_info>& gnssAntennaInfos);
+
+    template <class T>
+    static jobject translateSingleGnssAntennaInfo(JNIEnv* env, const T& gnssAntennaInfo);
+
+    template <class T>
+    static jobject translatePhaseCenterOffset(JNIEnv* env, const T& gnssAntennaInfo);
+
+    template <class T>
+    static jobject translatePhaseCenterVariationCorrections(JNIEnv* env, const T& gnssAntennaInfo);
+
+    template <class T>
+    static jobject translateSignalGainCorrections(JNIEnv* env, const T& gnssAntennaInfo);
+
+    template <template <class...> class T_vector, class T_info>
+    static jobjectArray translate2dDoubleArray(JNIEnv* env, const T_vector<T_info>& array);
+
+    template <template <class...> class T_vector, class T_info>
+    static void translateAndReportGnssAntennaInfo(const T_vector<T_info>& gnssAntennaInfos);
+
+    static void reportAntennaInfo(JNIEnv* env, const jobject antennaInfosArray);
+
+    static double getCarrierFrequencyMHz(
+            const android::hardware::gnss::IGnssAntennaInfoCallback::GnssAntennaInfo&
+                    gnssAntennaInfo) {
+        return gnssAntennaInfo.carrierFrequencyHz * 1e-6;
+    };
+
+    static double getCarrierFrequencyMHz(
+            const android::hardware::gnss::V2_1::IGnssAntennaInfoCallback::GnssAntennaInfo&
+                    gnssAntennaInfo) {
+        return gnssAntennaInfo.carrierFrequencyMHz;
+    };
 };
 
 } // namespace android::gnss
diff --git a/services/core/jni/gnss/GnssDebug.h b/services/core/jni/gnss/GnssDebug.h
index 9f5ff21a00c0b..1e1a7b4c1abd5 100644
--- a/services/core/jni/gnss/GnssDebug.h
+++ b/services/core/jni/gnss/GnssDebug.h
@@ -75,7 +75,7 @@ struct GnssDebugUtil {
     static uint32_t getConstellationType(const std::vector<T>& satelliteDataArray, size_t i);
 
     template <class T>
-    static uint32_t getTimeEstimateMs(const T& data);
+    static int64_t getTimeEstimateMs(const T& data);
 
     template <class T_DebugData, class T_SatelliteData>
     static jstring parseDebugData(JNIEnv* env, std::stringstream& internalState,
@@ -109,12 +109,12 @@ uint32_t GnssDebugUtil::getConstellationType(const std::vector<T>& satelliteData
 }
 
 template <class T>
-uint32_t GnssDebugUtil::getTimeEstimateMs(const T& data) {
+int64_t GnssDebugUtil::getTimeEstimateMs(const T& data) {
     return data.time.timeEstimate;
 }
 
 template <>
-uint32_t GnssDebugUtil::getTimeEstimateMs(
+int64_t GnssDebugUtil::getTimeEstimateMs(
         const android::hardware::gnss::IGnssDebug::DebugData& data) {
     return data.time.timeEstimateMs;
 }