diff --git a/gnss/2.0/IGnssCallback.hal b/gnss/2.0/IGnssCallback.hal
index 7924b64..4c31cf5 100644
--- a/gnss/2.0/IGnssCallback.hal
+++ b/gnss/2.0/IGnssCallback.hal
@@ -21,7 +21,7 @@
 import GnssLocation;
 
 /**
- * The interface is required for the HAL to communicate certain information
+ * This interface is required for the HAL to communicate certain information
  * like status and location info back to the platform, the platform implements
  * the interfaces and passes a handle to the HAL.
  */
@@ -29,17 +29,36 @@
 
     /** Flags for the gnssSetCapabilities callback. */
     @export(name="", value_prefix="GPS_CAPABILITY_")
-    enum Capabilities : @1.0::IGnssCallback.Capabilities {
-        /** GNSS supports line-of-sight satellite identification measurement Corrections */
-        MEASUREMENT_CORRECTIONS_LOS_SATS                        = 1 << 8,
-        /** GNSS supports per satellite excess-path-length measurement Corrections */
-        MEASUREMENT_CORRECTIONS_EXCESS_PATH_LENGTH              = 1 << 9,
-        /** GNSS supports reflecting planes measurement Corrections */
-        MEASUREMENT_CORRECTIONS_REFLECTING_PLANE                = 1 << 10
+    enum Capabilities : uint32_t {
+        /**
+         * GNSS HAL schedules fixes for RECURRENCE_PERIODIC mode.
+         * If this is not set, then the framework will use 1000ms for
+         * minInterval and must call start() and stop() to schedule the GNSS.
+         */
+        SCHEDULING                      = 1 << 0,
+        /** GNSS supports MS-Based AGNSS mode */
+        MSB                             = 1 << 1,
+        /** GNSS supports MS-Assisted AGNSS mode */
+        MSA                             = 1 << 2,
+        /** GNSS supports single-shot fixes */
+        SINGLE_SHOT                     = 1 << 3,
+        /** GNSS supports on demand time injection */
+        ON_DEMAND_TIME                  = 1 << 4,
+        /**
+         * Values for the flags removed from IGnssCallback.hal@1.0 Capabilities
+         * enum are marked as reserved and not reused here to avoid confusion.
+         */
+        RESERVED_1                      = 1 << 5,
+        RESERVED_2                      = 1 << 6,
+        RESERVED_3                      = 1 << 7,
+        /** GNSS supports low power mode */
+        LOW_POWER_MODE                  = 1 << 8,
+        /** GNSS supports blacklisting satellites */
+        SATELLITE_BLACKLIST             = 1 << 9
     };
 
     /**
-     * Callback to inform framework of the GNSS engine's capabilities.
+     * Callback to inform framework of the GNSS HAL implementation's capabilities.
      *
      * @param capabilities Capability parameter is a bit field of the Capabilities enum.
      */
@@ -75,4 +94,4 @@
      *        during-call to E911, or up to 5 minutes after end-of-call or text to E911).
      */
     gnssRequestLocationCb_2_0(bool independentFromGnss, bool isUserEmergency);
-};
\ No newline at end of file
+};
diff --git a/gnss/2.0/default/Gnss.cpp b/gnss/2.0/default/Gnss.cpp
index ee6da53..1dfdadb 100644
--- a/gnss/2.0/default/Gnss.cpp
+++ b/gnss/2.0/default/Gnss.cpp
@@ -269,8 +269,9 @@
 
     sGnssCallback_2_0 = callback;
 
-    uint32_t capabilities = static_cast<uint32_t>(V1_0::IGnssCallback::Capabilities::MEASUREMENTS);
-    auto ret = sGnssCallback_2_0->gnssSetCapabilitesCb(capabilities);
+    using Capabilities = V2_0::IGnssCallback::Capabilities;
+    const auto capabilities = Capabilities::LOW_POWER_MODE | Capabilities::SATELLITE_BLACKLIST;
+    auto ret = sGnssCallback_2_0->gnssSetCapabilitiesCb_2_0(capabilities);
     if (!ret.isOk()) {
         ALOGE("%s: Unable to invoke callback", __func__);
     }
diff --git a/gnss/2.0/default/GnssMeasurementCorrections.cpp b/gnss/2.0/default/GnssMeasurementCorrections.cpp
index cbf34ba..2bf5601 100644
--- a/gnss/2.0/default/GnssMeasurementCorrections.cpp
+++ b/gnss/2.0/default/GnssMeasurementCorrections.cpp
@@ -54,6 +54,19 @@
     return true;
 }
 
+Return<bool> GnssMeasurementCorrections::setCallback(
+        const sp<V1_0::IMeasurementCorrectionsCallback>& callback) {
+    using Capabilities = V1_0::IMeasurementCorrectionsCallback::Capabilities;
+    auto ret =
+            callback->setCapabilitiesCb(Capabilities::LOS_SATS | Capabilities::EXCESS_PATH_LENGTH |
+                                        Capabilities::REFLECTING_PLANE);
+    if (!ret.isOk()) {
+        ALOGE("%s: Unable to invoke callback", __func__);
+        return false;
+    }
+    return true;
+}
+
 }  // namespace implementation
 }  // namespace V1_0
 }  // namespace measurement_corrections
diff --git a/gnss/2.0/default/GnssMeasurementCorrections.h b/gnss/2.0/default/GnssMeasurementCorrections.h
index f758bc8..4339bed 100644
--- a/gnss/2.0/default/GnssMeasurementCorrections.h
+++ b/gnss/2.0/default/GnssMeasurementCorrections.h
@@ -38,6 +38,7 @@
 struct GnssMeasurementCorrections : public IMeasurementCorrections {
     // Methods from V1_0::IMeasurementCorrections follow.
     Return<bool> setCorrections(const MeasurementCorrections& corrections) override;
+    Return<bool> setCallback(const sp<V1_0::IMeasurementCorrectionsCallback>& callback) override;
 };
 
 }  // namespace implementation
diff --git a/gnss/2.0/types.hal b/gnss/2.0/types.hal
index 4abb604..21b64f9 100644
--- a/gnss/2.0/types.hal
+++ b/gnss/2.0/types.hal
@@ -69,7 +69,7 @@
      *
      * This clock information can be obtained from SystemClock.elapsedRealtimeNanos(), when the GNSS
      * is attached straight to the AP/SOC. When it is attached to a separate module the timestamp
-     * needs to be estimatedd by syncing the notion of time via PTP or some other mechanism. 
+     * needs to be estimated by syncing the notion of time via PTP or some other mechanism.
      */
     ElapsedRealtime elapsedRealtime;
 };
\ No newline at end of file
diff --git a/gnss/2.0/vts/functional/gnss_hal_test.cpp b/gnss/2.0/vts/functional/gnss_hal_test.cpp
index c564f41..b2b62fc 100644
--- a/gnss/2.0/vts/functional/gnss_hal_test.cpp
+++ b/gnss/2.0/vts/functional/gnss_hal_test.cpp
@@ -77,6 +77,16 @@
     EXPECT_EQ(capabilities_called_count_, 1);
     EXPECT_EQ(info_called_count_, 1);
     EXPECT_EQ(name_called_count_, 1);
+
+    // Setup measurement corrections callback.
+    auto measurementCorrections = gnss_hal_->getExtensionMeasurementCorrections();
+    ASSERT_TRUE(measurementCorrections.isOk());
+    sp<IMeasurementCorrections> iMeasurementCorrections = measurementCorrections;
+    if (iMeasurementCorrections != nullptr) {
+        sp<IMeasurementCorrectionsCallback> iMeasurementCorrectionsCallback =
+                new GnssMeasurementCorrectionsCallback(*this);
+        iMeasurementCorrections->setCallback(iMeasurementCorrectionsCallback);
+    }
 }
 
 void GnssHalTest::StopAndClearLocations() {
@@ -176,6 +186,16 @@
     return status;
 }
 
+std::cv_status GnssHalTest::waitForMeasurementCorrectionsCapabilities(int timeout_seconds) {
+    std::unique_lock<std::mutex> lock(mtx_);
+    auto status = std::cv_status::no_timeout;
+    while (measurement_corrections_capabilities_called_count_ == 0) {
+        status = cv_.wait_for(lock, std::chrono::seconds(timeout_seconds));
+        if (status == std::cv_status::timeout) return status;
+    }
+    return status;
+}
+
 Return<void> GnssHalTest::GnssCallback::gnssSetSystemInfoCb(
     const IGnssCallback::GnssSystemInfo& info) {
     ALOGI("Info received, year %d", info.yearOfHw);
@@ -243,3 +263,12 @@
     parent_.notify();
     return Void();
 }
+
+Return<void> GnssHalTest::GnssMeasurementCorrectionsCallback::setCapabilitiesCb(
+        uint32_t capabilities) {
+    ALOGI("GnssMeasurementCorrectionsCallback capabilities received %d", capabilities);
+    parent_.measurement_corrections_capabilities_called_count_++;
+    parent_.last_measurement_corrections_capabilities_ = capabilities;
+    parent_.notify();
+    return Void();
+}
diff --git a/gnss/2.0/vts/functional/gnss_hal_test.h b/gnss/2.0/vts/functional/gnss_hal_test.h
index 31750a6..7354aea 100644
--- a/gnss/2.0/vts/functional/gnss_hal_test.h
+++ b/gnss/2.0/vts/functional/gnss_hal_test.h
@@ -28,6 +28,7 @@
 using android::hardware::Return;
 using android::hardware::Void;
 
+using android::hardware::gnss::measurement_corrections::V1_0::IMeasurementCorrectionsCallback;
 using android::hardware::gnss::V1_0::GnssLocationFlags;
 using android::hardware::gnss::V2_0::IGnss;
 using android::hardware::gnss::V2_0::IGnssCallback;
@@ -73,6 +74,8 @@
     /* Test code calls this function to wait for a callback */
     std::cv_status wait(int timeout_seconds);
 
+    std::cv_status waitForMeasurementCorrectionsCapabilities(int timeout_seconds);
+
     /* Callback class for data & Event. */
     class GnssCallback : public IGnssCallback {
        public:
@@ -136,6 +139,17 @@
         Return<void> gnssMeasurementCb_2_0(const IGnssMeasurementCallback_2_0::GnssData&) override;
     };
 
+    /* Callback class for GnssMeasurementCorrections. */
+    class GnssMeasurementCorrectionsCallback : public IMeasurementCorrectionsCallback {
+      public:
+        GnssHalTest& parent_;
+        GnssMeasurementCorrectionsCallback(GnssHalTest& parent) : parent_(parent){};
+        virtual ~GnssMeasurementCorrectionsCallback() = default;
+
+        // Methods from V1_0::IMeasurementCorrectionsCallback follow.
+        Return<void> setCapabilitiesCb(uint32_t capabilities) override;
+    };
+
     /*
      * SetUpGnssCallback:
      *   Set GnssCallback and verify the result.
@@ -192,12 +206,14 @@
      */
     int info_called_count_;
     int capabilities_called_count_;
+    int measurement_corrections_capabilities_called_count_;
     int location_called_count_;
     int measurement_called_count_;
     int name_called_count_;
 
     IGnssCallback::GnssSystemInfo last_info_;
     uint32_t last_capabilities_;
+    uint32_t last_measurement_corrections_capabilities_;
     GnssLocation_2_0 last_location_;
     IGnssMeasurementCallback_2_0::GnssData last_measurement_;
     android::hardware::hidl_string last_name_;
diff --git a/gnss/2.0/vts/functional/gnss_hal_test_cases.cpp b/gnss/2.0/vts/functional/gnss_hal_test_cases.cpp
index 67fda89..f3559c5 100644
--- a/gnss/2.0/vts/functional/gnss_hal_test_cases.cpp
+++ b/gnss/2.0/vts/functional/gnss_hal_test_cases.cpp
@@ -38,6 +38,7 @@
 using android::hardware::gnss::measurement_corrections::V1_0::MeasurementCorrections;
 using android::hardware::gnss::V1_0::IGnssNi;
 using android::hardware::gnss::V2_0::ElapsedRealtimeFlags;
+using android::hardware::gnss::V2_0::IGnssCallback;
 using android::hardware::gnss::visibility_control::V1_0::IGnssVisibilityControl;
 
 /*
@@ -50,23 +51,21 @@
 
 /*
  * TestGnssMeasurementCallback:
- * Gets the GnssMeasurementExtension and verify that it returns an actual extension.
+ * Gets the GnssMeasurementExtension and verifies that it returns an actual extension.
  */
 TEST_F(GnssHalTest, TestGnssMeasurementCallback) {
     auto gnssMeasurement_2_0 = gnss_hal_->getExtensionGnssMeasurement_2_0();
     auto gnssMeasurement_1_1 = gnss_hal_->getExtensionGnssMeasurement_1_1();
     auto gnssMeasurement_1_0 = gnss_hal_->getExtensionGnssMeasurement();
-    ASSERT_TRUE(gnssMeasurement_2_0.isOk() || gnssMeasurement_1_1.isOk() ||
+    ASSERT_TRUE(gnssMeasurement_2_0.isOk() && gnssMeasurement_1_1.isOk() &&
                 gnssMeasurement_1_0.isOk());
-    if (last_capabilities_ & IGnssCallback::Capabilities::MEASUREMENTS) {
-        sp<IGnssMeasurement_2_0> iGnssMeas_2_0 = gnssMeasurement_2_0;
-        sp<IGnssMeasurement_1_1> iGnssMeas_1_1 = gnssMeasurement_1_1;
-        sp<IGnssMeasurement_1_0> iGnssMeas_1_0 = gnssMeasurement_1_0;
-        // At least one interface is non-null.
-        int numNonNull = (int)(iGnssMeas_2_0 != nullptr) + (int)(iGnssMeas_1_1 != nullptr) +
-                         (int)(iGnssMeas_1_0 != nullptr);
-        ASSERT_TRUE(numNonNull >= 1);
-    }
+    sp<IGnssMeasurement_2_0> iGnssMeas_2_0 = gnssMeasurement_2_0;
+    sp<IGnssMeasurement_1_1> iGnssMeas_1_1 = gnssMeasurement_1_1;
+    sp<IGnssMeasurement_1_0> iGnssMeas_1_0 = gnssMeasurement_1_0;
+    // At least one interface is non-null.
+    int numNonNull = (int)(iGnssMeas_2_0 != nullptr) + (int)(iGnssMeas_1_1 != nullptr) +
+                     (int)(iGnssMeas_1_0 != nullptr);
+    ASSERT_TRUE(numNonNull >= 1);
 }
 
 /*
@@ -267,8 +266,30 @@
 }
 
 /*
+ * TestGnssMeasurementCorrectionsCapabilities:
+ * If the GnssMeasurementCorrectionsExtension is not null, verifies that the measurement corrections
+ * capabilities are reported and the mandatory LOS_SATS or the EXCESS_PATH_LENGTH
+ * capability flag is set.
+ */
+TEST_F(GnssHalTest, TestGnssMeasurementCorrectionsCapabilities) {
+    auto measurementCorrections = gnss_hal_->getExtensionMeasurementCorrections();
+    ASSERT_TRUE(measurementCorrections.isOk());
+    sp<IMeasurementCorrections> iMeasurementCorrections = measurementCorrections;
+    if (iMeasurementCorrections == nullptr) {
+        return;
+    }
+
+    const int kMeasurementCorrectionsCapabilitiesTimeoutSeconds = 5;
+    waitForMeasurementCorrectionsCapabilities(kMeasurementCorrectionsCapabilitiesTimeoutSeconds);
+    ASSERT_TRUE(measurement_corrections_capabilities_called_count_ > 0);
+    using Capabilities = IMeasurementCorrectionsCallback::Capabilities;
+    ASSERT_TRUE((last_measurement_corrections_capabilities_ &
+                 (Capabilities::LOS_SATS | Capabilities::EXCESS_PATH_LENGTH)) != 0);
+}
+
+/*
  * TestGnssMeasurementCorrections:
- * Gets the GnssMeasurementCorrectionsExtension and verifies that it supports the
+ * If the GnssMeasurementCorrectionsExtension is not null, verifies that it supports the
  * gnss.measurement_corrections@1.0::IMeasurementCorrections interface by invoking a method.
  */
 TEST_F(GnssHalTest, TestGnssMeasurementCorrections) {
@@ -276,8 +297,13 @@
     auto measurementCorrections = gnss_hal_->getExtensionMeasurementCorrections();
     ASSERT_TRUE(measurementCorrections.isOk());
     sp<IMeasurementCorrections> iMeasurementCorrections = measurementCorrections;
-    ASSERT_NE(iMeasurementCorrections, nullptr);
+    if (iMeasurementCorrections == nullptr) {
+        return;
+    }
 
+    const int kMeasurementCorrectionsCapabilitiesTimeoutSeconds = 5;
+    waitForMeasurementCorrectionsCapabilities(kMeasurementCorrectionsCapabilitiesTimeoutSeconds);
+    ASSERT_TRUE(measurement_corrections_capabilities_called_count_ > 0);
     // Set a mock MeasurementCorrections.
     auto result = iMeasurementCorrections->setCorrections(Utils::getMockMeasurementCorrections());
     ASSERT_TRUE(result.isOk());