Add support for NAN periodic ranging.

Add changes to configure rtt and channel parameters in
SubscribeConfig. Add support to receive ranging
results on Publisher side. Enable the configuration only
when support is advertised in capabilities. Also,
add support for OnRangingResultsReceived callback
which will be called periodically.

Bug: 336376538
Test: atest FrameworksWifiApiTests
Flag: com.android.ranging.flags.ranging_rtt_enabled
Change-Id: I0934ef29ff20e845755577f6d9d6e6c11c98a636

20 files changed, 984 insertions, 27 deletions

diff --git a/framework/Android.bp b/framework/Android.bp
index f4adca6952..c0280f0988 100644
--- a/framework/Android.bp
+++ b/framework/Android.bp
@@ -110,6 +110,7 @@ java_defaults {
         "wifi-modules-utils",
         "PlatformProperties",
         "android.net.wifi.flags-aconfig-java",
+        "ranging_aconfig_flags_lib",
     ],
     libs: [
         "androidx.annotation_annotation",
diff --git a/framework/api/system-current.txt b/framework/api/system-current.txt
index fd4ab0f291..b481db2e02 100644
--- a/framework/api/system-current.txt
+++ b/framework/api/system-current.txt
@@ -1525,6 +1525,17 @@ package android.net.wifi.aware {
     field public static final int UNSET_PARAMETER = -1; // 0xffffffff
   }
 
+  public final class Characteristics implements android.os.Parcelable {
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public int getMaxSupportedRangingPktBandwidth();
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public int getMaxSupportedRxChains();
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public boolean isPeriodicRangingSupported();
+    field @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public static final int SUPPORTED_RX_CHAINS_1 = 1; // 0x1
+    field @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public static final int SUPPORTED_RX_CHAINS_2 = 2; // 0x2
+    field @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public static final int SUPPORTED_RX_CHAINS_3 = 3; // 0x3
+    field @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public static final int SUPPORTED_RX_CHAINS_4 = 4; // 0x4
+    field @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public static final int SUPPORTED_RX_CHAINS_UNSPECIFIED = 0; // 0x0
+  }
+
   @FlaggedApi("com.android.wifi.flags.android_v_wifi_api") public final class ConfigRequest implements android.os.Parcelable {
     method @FlaggedApi("com.android.wifi.flags.android_v_wifi_api") public int describeContents();
     method @FlaggedApi("com.android.wifi.flags.android_v_wifi_api") @NonNull public java.util.List<android.net.wifi.OuiKeyedData> getVendorData();
@@ -1545,6 +1556,7 @@ package android.net.wifi.aware {
   }
 
   public class DiscoverySessionCallback {
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public void onRangingResultsReceived(@NonNull java.util.List<android.net.wifi.rtt.RangingResult>);
     method public void onSessionResumeFailed(int);
     method public void onSessionResumeSucceeded();
     method public void onSessionSuspendFailed(int);
@@ -1553,10 +1565,12 @@ package android.net.wifi.aware {
 
   public final class PublishConfig implements android.os.Parcelable {
     method @FlaggedApi("com.android.wifi.flags.android_v_wifi_api") @NonNull public java.util.List<android.net.wifi.OuiKeyedData> getVendorData();
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public boolean isPeriodicRangingResultsEnabled();
     method public boolean isSuspendable();
   }
 
   public static final class PublishConfig.Builder {
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") @NonNull public android.net.wifi.aware.PublishConfig.Builder setPeriodicRangingResultsEnabled(boolean);
     method @NonNull @RequiresPermission(android.Manifest.permission.MANAGE_WIFI_NETWORK_SELECTION) public android.net.wifi.aware.PublishConfig.Builder setSuspendable(boolean);
     method @FlaggedApi("com.android.wifi.flags.android_v_wifi_api") @NonNull public android.net.wifi.aware.PublishConfig.Builder setVendorData(@NonNull java.util.List<android.net.wifi.OuiKeyedData>);
   }
@@ -1566,11 +1580,35 @@ package android.net.wifi.aware {
   }
 
   public final class SubscribeConfig implements android.os.Parcelable {
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") @IntRange(from=0) public int getCenterFreq0Mhz();
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") @IntRange(from=0) public int getCenterFreq1Mhz();
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public int getChannelWidth();
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") @IntRange(from=0) public int getFrequencyMhz();
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public int getPeriodicRangingInterval();
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public int getPreamble();
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public int getRttBurstSize();
     method @FlaggedApi("com.android.wifi.flags.android_v_wifi_api") @NonNull public java.util.List<android.net.wifi.OuiKeyedData> getVendorData();
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public boolean isPeriodicRangingEnabled();
     method public boolean isSuspendable();
+    field @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public static final int PERIODIC_RANGING_INTERVAL_1024TU = 1024; // 0x400
+    field @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public static final int PERIODIC_RANGING_INTERVAL_128TU = 128; // 0x80
+    field @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public static final int PERIODIC_RANGING_INTERVAL_2048TU = 2048; // 0x800
+    field @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public static final int PERIODIC_RANGING_INTERVAL_256TU = 256; // 0x100
+    field @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public static final int PERIODIC_RANGING_INTERVAL_4096TU = 4096; // 0x1000
+    field @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public static final int PERIODIC_RANGING_INTERVAL_512TU = 512; // 0x200
+    field @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public static final int PERIODIC_RANGING_INTERVAL_8192TU = 8192; // 0x2000
+    field @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") public static final int PERIODIC_RANGING_INTERVAL_NONE = 0; // 0x0
   }
 
   public static final class SubscribeConfig.Builder {
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") @NonNull public android.net.wifi.aware.SubscribeConfig.Builder setCenterFreq0Mhz(@IntRange(from=0) int);
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") @NonNull public android.net.wifi.aware.SubscribeConfig.Builder setCenterFreq1Mhz(@IntRange(from=0) int);
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") @NonNull public android.net.wifi.aware.SubscribeConfig.Builder setChannelWidth(int);
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") @NonNull public android.net.wifi.aware.SubscribeConfig.Builder setFrequencyMhz(@IntRange(from=0) int);
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") @NonNull public android.net.wifi.aware.SubscribeConfig.Builder setPeriodicRangingEnabled(boolean);
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") @NonNull public android.net.wifi.aware.SubscribeConfig.Builder setPeriodicRangingInterval(int);
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") @NonNull public android.net.wifi.aware.SubscribeConfig.Builder setPreamble(int);
+    method @FlaggedApi("com.android.ranging.flags.ranging_rtt_enabled") @NonNull public android.net.wifi.aware.SubscribeConfig.Builder setRttBurstSize(int);
     method @NonNull @RequiresPermission(android.Manifest.permission.MANAGE_WIFI_NETWORK_SELECTION) public android.net.wifi.aware.SubscribeConfig.Builder setSuspendable(boolean);
     method @FlaggedApi("com.android.wifi.flags.android_v_wifi_api") @NonNull public android.net.wifi.aware.SubscribeConfig.Builder setVendorData(@NonNull java.util.List<android.net.wifi.OuiKeyedData>);
   }
diff --git a/framework/jarjar-rules.txt b/framework/jarjar-rules.txt
index 920bb0f120..dbd5811d7d 100644
--- a/framework/jarjar-rules.txt
+++ b/framework/jarjar-rules.txt
@@ -86,6 +86,10 @@ rule android.util.BackupUtils* com.android.wifi.x.@0
 rule android.util.LocalLog* com.android.wifi.x.@0
 rule android.util.Rational* com.android.wifi.x.@0
 
+# Statically included ranging flags.
+rule com.android.ranging.flags.Flags com.android.wifi.x.@0
+rule com.android.ranging.flags.*Flags* com.android.wifi.x.@0
+
 # Repackage generated flag classes.
 # Need to specify the rule on classes to avoid transform the literals
 rule com.android.wifi.flags.*FeatureFlags* com.android.wifi.x.@0
diff --git a/framework/java/android/net/wifi/aware/Characteristics.java b/framework/java/android/net/wifi/aware/Characteristics.java
index df36140c10..fa8c4ed6fc 100644
--- a/framework/java/android/net/wifi/aware/Characteristics.java
+++ b/framework/java/android/net/wifi/aware/Characteristics.java
@@ -16,8 +16,13 @@
 
 package android.net.wifi.aware;
 
+import static com.android.ranging.flags.Flags.FLAG_RANGING_RTT_ENABLED;
+
+import android.annotation.FlaggedApi;
 import android.annotation.IntDef;
 import android.annotation.IntRange;
+import android.annotation.SystemApi;
+import android.net.wifi.WifiAnnotations;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Parcel;
@@ -62,6 +67,16 @@ public final class Characteristics implements Parcelable {
     public static final String KEY_SUPPORT_NAN_PAIRING = "key_support_nan_pairing";
     /** @hide */
     public static final String KEY_SUPPORT_SUSPENSION = "key_support_suspension";
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    public static final String KEY_SUPPORT_PERIODIC_RANGING = "key_support_periodic_ranging";
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    public static final String KEY_MAX_SUPPORTED_RANGING_PKT_BANDWIDTH =
+            "key_max_supported_ranging_pkt_bandwidth";
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    public static final String KEY_MAX_SUPPORTED_RX_CHAINS = "key_max_supported_rx_chains";
 
     private final Bundle mCharacteristics;
 
@@ -187,6 +202,78 @@ public final class Characteristics implements Parcelable {
         return mCharacteristics.getBoolean(KEY_SUPPORT_SUSPENSION);
     }
 
+    /**
+     * Check if Periodic Ranging is supported.
+     * Periodic Ranging on Aware allows applications to get the asynchronous ranging
+     * report periodically.
+     * @return True if supported, false otherwise.
+     * @hide
+     */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public boolean isPeriodicRangingSupported() {
+        return mCharacteristics.getBoolean(KEY_SUPPORT_PERIODIC_RANGING);
+    }
+
+    /** @hide */
+    @IntDef(flag = true, prefix = { "SUPPORTED_RX_CHAINS_" }, value = {
+            SUPPORTED_RX_CHAINS_UNSPECIFIED,
+            SUPPORTED_RX_CHAINS_1,
+            SUPPORTED_RX_CHAINS_2,
+            SUPPORTED_RX_CHAINS_3,
+            SUPPORTED_RX_CHAINS_4,
+    })
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface SupportedRxChains {}
+
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public static final int SUPPORTED_RX_CHAINS_1 = 1;
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public static final int SUPPORTED_RX_CHAINS_2 = 2;
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public static final int SUPPORTED_RX_CHAINS_3 = 3;
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public static final int SUPPORTED_RX_CHAINS_4 = 4;
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public static final int SUPPORTED_RX_CHAINS_UNSPECIFIED = 0;
+
+    /**
+     * Get the supported number of receive chains.
+     *
+     * @return Number of supported receive chains.
+     * @hide
+     */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public @SupportedRxChains int getMaxSupportedRxChains() {
+        return mCharacteristics.getInt(KEY_MAX_SUPPORTED_RX_CHAINS);
+    }
+
+    /**
+     * Get Max supported ranging per packet Bandwidth
+     *
+     * @return the bandwidth representation of the Wi-Fi channel from
+     * {@link ScanResult#CHANNEL_WIDTH_20MHZ}, {@link ScanResult#CHANNEL_WIDTH_40MHZ},
+     * {@link ScanResult#CHANNEL_WIDTH_80MHZ}, {@link ScanResult#CHANNEL_WIDTH_160MHZ},
+     * or {@link ScanResult#CHANNEL_WIDTH_320MHZ}.
+     * @hide
+     */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public @WifiAnnotations.ChannelWidth int getMaxSupportedRangingPktBandwidth() {
+        return mCharacteristics.getInt(KEY_MAX_SUPPORTED_RANGING_PKT_BANDWIDTH);
+    }
+
     /** @hide */
     @IntDef(flag = true, prefix = { "WIFI_AWARE_CIPHER_SUITE_" }, value = {
             WIFI_AWARE_CIPHER_SUITE_NONE,
diff --git a/framework/java/android/net/wifi/aware/DiscoverySessionCallback.java b/framework/java/android/net/wifi/aware/DiscoverySessionCallback.java
index 80bce68d83..ad37287f2c 100644
--- a/framework/java/android/net/wifi/aware/DiscoverySessionCallback.java
+++ b/framework/java/android/net/wifi/aware/DiscoverySessionCallback.java
@@ -16,8 +16,12 @@
 
 package android.net.wifi.aware;
 
+import static com.android.ranging.flags.Flags.FLAG_RANGING_RTT_ENABLED;
+
+import android.annotation.FlaggedApi;
 import android.annotation.NonNull;
 import android.annotation.SystemApi;
+import android.net.wifi.rtt.RangingResult;
 
 import java.util.List;
 
@@ -382,4 +386,16 @@ public class DiscoverySessionCallback {
     public void onBootstrappingFailed(@NonNull PeerHandle peerHandle) {
 
     }
+
+    /**
+     * Callback indicating that ranging results have been received.
+     *
+     * @param rangingResults List of range measurements.
+     * @hide
+     */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public void onRangingResultsReceived(@NonNull List<RangingResult> rangingResults) {
+
+    }
 }
diff --git a/framework/java/android/net/wifi/aware/IWifiAwareDiscoverySessionCallback.aidl b/framework/java/android/net/wifi/aware/IWifiAwareDiscoverySessionCallback.aidl
index 392ec6cc2e..326f236f19 100644
--- a/framework/java/android/net/wifi/aware/IWifiAwareDiscoverySessionCallback.aidl
+++ b/framework/java/android/net/wifi/aware/IWifiAwareDiscoverySessionCallback.aidl
@@ -16,16 +16,16 @@
 
 package android.net.wifi.aware;
 
-import android.net.wifi.aware.AwarePairingConfig;
 import android.net.wifi.OuiKeyedData;
+import android.net.wifi.aware.AwarePairingConfig;
+import android.net.wifi.rtt.RangingResult;
 
 /**
  * Callback interface that WifiAwareManager implements
  *
  * {@hide}
  */
-oneway interface IWifiAwareDiscoverySessionCallback
-{
+oneway interface IWifiAwareDiscoverySessionCallback {
     void onSessionStarted(int discoverySessionId);
     void onSessionConfigSuccess();
     void onSessionConfigFail(int reason);
@@ -50,4 +50,5 @@ oneway interface IWifiAwareDiscoverySessionCallback
     void onPairingSetupConfirmed(int peerId, boolean accept, String alias);
     void onPairingVerificationConfirmed(int peerId, boolean accept, String alias);
     void onBootstrappingVerificationConfirmed(int peerId, boolean accept, int method);
+    void onRangingResultsReceived(in List<RangingResult> rangingResults);
 }
diff --git a/framework/java/android/net/wifi/aware/PublishConfig.java b/framework/java/android/net/wifi/aware/PublishConfig.java
index b429fac63d..774708f372 100644
--- a/framework/java/android/net/wifi/aware/PublishConfig.java
+++ b/framework/java/android/net/wifi/aware/PublishConfig.java
@@ -18,6 +18,8 @@ package android.net.wifi.aware;
 
 import static android.Manifest.permission.MANAGE_WIFI_NETWORK_SELECTION;
 
+import static com.android.ranging.flags.Flags.FLAG_RANGING_RTT_ENABLED;
+
 import android.annotation.FlaggedApi;
 import android.annotation.IntDef;
 import android.annotation.NonNull;
@@ -112,12 +114,15 @@ public final class PublishConfig implements Parcelable {
     private final List<OuiKeyedData> mVendorData;
 
     /** @hide */
+    public final boolean mEnablePeriodicRangingResults;
+
+    /** @hide */
     public PublishConfig(byte[] serviceName, byte[] serviceSpecificInfo, byte[] matchFilter,
             int publishType, int ttlSec, boolean enableTerminateNotification,
             boolean enableRanging, boolean enableInstantMode, @WifiScanner.WifiBand int
             band, WifiAwareDataPathSecurityConfig securityConfig,
             AwarePairingConfig pairingConfig, boolean isSuspendable,
-            @NonNull List<OuiKeyedData> vendorData) {
+            @NonNull List<OuiKeyedData> vendorData, boolean enablePeriodicRangingResults) {
         mServiceName = serviceName;
         mServiceSpecificInfo = serviceSpecificInfo;
         mMatchFilter = matchFilter;
@@ -131,6 +136,7 @@ public final class PublishConfig implements Parcelable {
         mPairingConfig = pairingConfig;
         mIsSuspendable = isSuspendable;
         mVendorData = vendorData;
+        mEnablePeriodicRangingResults = enablePeriodicRangingResults;
     }
 
     @Override
@@ -152,7 +158,8 @@ public final class PublishConfig implements Parcelable {
                 + ", mSecurityConfig" + mSecurityConfig
                 + ", mPairingConfig" + mPairingConfig
                 + ", mIsSuspendable=" + mIsSuspendable
-                + ", mVendorData=" + mVendorData + "]";
+                + ", mVendorData=" + mVendorData + "]"
+                + ", mEnablePeriodicRangingResults=" + mEnablePeriodicRangingResults;
     }
 
     @Override
@@ -175,6 +182,7 @@ public final class PublishConfig implements Parcelable {
         dest.writeParcelable(mPairingConfig, flags);
         dest.writeBoolean(mIsSuspendable);
         dest.writeList(mVendorData);
+        dest.writeBoolean(mEnablePeriodicRangingResults);
     }
 
     @NonNull
@@ -201,10 +209,12 @@ public final class PublishConfig implements Parcelable {
                     .readParcelable(AwarePairingConfig.class.getClassLoader());
             boolean isSuspendable = in.readBoolean();
             List<OuiKeyedData> vendorData = ParcelUtil.readOuiKeyedDataList(in);
+            boolean enablePeriodicRangingResults = in.readBoolean();
 
             return new PublishConfig(serviceName, ssi, matchFilter, publishType, ttlSec,
                     enableTerminateNotification, enableRanging, enableInstantMode,
-                    band, securityConfig, pairingConfig, isSuspendable, vendorData);
+                    band, securityConfig, pairingConfig, isSuspendable, vendorData,
+                    enablePeriodicRangingResults);
         }
     };
 
@@ -226,6 +236,7 @@ public final class PublishConfig implements Parcelable {
                 && mTtlSec == lhs.mTtlSec
                 && mEnableTerminateNotification == lhs.mEnableTerminateNotification
                 && mEnableRanging == lhs.mEnableRanging
+                && mEnablePeriodicRangingResults == lhs.mEnablePeriodicRangingResults
                 && mEnableInstantMode == lhs.mEnableInstantMode
                 && mBand == lhs.mBand
                 && mIsSuspendable == lhs.mIsSuspendable
@@ -239,7 +250,7 @@ public final class PublishConfig implements Parcelable {
         return Objects.hash(Arrays.hashCode(mServiceName), Arrays.hashCode(mServiceSpecificInfo),
                 Arrays.hashCode(mMatchFilter), mPublishType, mTtlSec, mEnableTerminateNotification,
                 mEnableRanging, mEnableInstantMode, mBand, mSecurityConfig, mPairingConfig,
-                mIsSuspendable, mVendorData);
+                mIsSuspendable, mVendorData, mEnablePeriodicRangingResults);
     }
 
     /**
@@ -310,6 +321,11 @@ public final class PublishConfig implements Parcelable {
         if (!rttSupported && mEnableRanging) {
             throw new IllegalArgumentException("Ranging is not supported");
         }
+
+        if ((!rttSupported || !characteristics.isPeriodicRangingSupported())
+                && mEnablePeriodicRangingResults) {
+            throw new IllegalArgumentException("Periodic Ranging is not supported");
+        }
     }
 
     /**
@@ -387,6 +403,18 @@ public final class PublishConfig implements Parcelable {
     }
 
     /**
+     * Check if periodic ranging reporting is enabled for publish session
+     * @see Builder#setPeriodicRangingResultsEnabled(boolean)
+     * @return true for enabled, false otherwise.
+     * @hide
+     */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public boolean isPeriodicRangingResultsEnabled() {
+        return mEnablePeriodicRangingResults;
+    }
+
+    /**
      * Builder used to build {@link PublishConfig} objects.
      */
     public static final class Builder {
@@ -403,6 +431,7 @@ public final class PublishConfig implements Parcelable {
         private AwarePairingConfig mPairingConfig = null;
         private boolean mIsSuspendable = false;
         private @NonNull List<OuiKeyedData> mVendorData = Collections.emptyList();
+        private boolean mEnablePeriodicRangingResults = false;
 
         /**
          * Specify the service name of the publish session. The actual on-air
@@ -555,6 +584,33 @@ public final class PublishConfig implements Parcelable {
         }
 
         /**
+         * Configure whether periodic ranging results need to be notified to Publisher
+         * <p>
+         * Optional. Disabled by default - i.e. any ranging result will not be notified to
+         * the Publisher.
+         * <p>
+         * The device must support Periodic Ranging for this feature to be used.
+         * Feature support check is determined by
+         * {@link Characteristics#isPeriodicRangingSupported()}.
+         * <p>
+         * The ranging result will be notified to Publisher via
+         * {@link DiscoverySessionCallback#onRangingResultsReceived(RangingResults)}.
+         *
+         * @param enable If true, ranging result will be notified to Publisher.
+         *
+         * @return The builder to facilitate chaining
+         *         {@code builder.setXXX(..).setXXX(..)}.
+         * @hide
+         */
+        @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+        @SystemApi
+        @NonNull
+        public Builder setPeriodicRangingResultsEnabled(boolean enable) {
+            mEnablePeriodicRangingResults = enable;
+            return this;
+        }
+
+        /**
          * Configure whether to enable and use instant communication for this publish session.
          * Instant communication will speed up service discovery and any data-path set up as part of
          * this session. Use {@link Characteristics#isInstantCommunicationModeSupported()} to check
@@ -694,7 +750,8 @@ public final class PublishConfig implements Parcelable {
         public PublishConfig build() {
             return new PublishConfig(mServiceName, mServiceSpecificInfo, mMatchFilter, mPublishType,
                     mTtlSec, mEnableTerminateNotification, mEnableRanging, mEnableInstantMode,
-                    mBand, mSecurityConfig, mPairingConfig, mIsSuspendable, mVendorData);
+                    mBand, mSecurityConfig, mPairingConfig, mIsSuspendable, mVendorData,
+                    mEnablePeriodicRangingResults);
         }
     }
 }
diff --git a/framework/java/android/net/wifi/aware/SubscribeConfig.java b/framework/java/android/net/wifi/aware/SubscribeConfig.java
index ea99d819cd..e9d680623b 100644
--- a/framework/java/android/net/wifi/aware/SubscribeConfig.java
+++ b/framework/java/android/net/wifi/aware/SubscribeConfig.java
@@ -18,8 +18,11 @@ package android.net.wifi.aware;
 
 import static android.Manifest.permission.MANAGE_WIFI_NETWORK_SELECTION;
 
+import static com.android.ranging.flags.Flags.FLAG_RANGING_RTT_ENABLED;
+
 import android.annotation.FlaggedApi;
 import android.annotation.IntDef;
+import android.annotation.IntRange;
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.annotation.RequiresPermission;
@@ -27,7 +30,10 @@ import android.annotation.SystemApi;
 import android.net.wifi.OuiKeyedData;
 import android.net.wifi.ParcelUtil;
 import android.net.wifi.ScanResult;
+import android.net.wifi.WifiAnnotations;
 import android.net.wifi.WifiScanner;
+import android.net.wifi.rtt.RangingRequest;
+import android.net.wifi.rtt.ResponderConfig;
 import android.net.wifi.util.HexEncoding;
 import android.os.Build;
 import android.os.Parcel;
@@ -76,6 +82,72 @@ public final class SubscribeConfig implements Parcelable {
      */
     public static final int SUBSCRIBE_TYPE_ACTIVE = 1;
 
+    private static final int AWARE_BAND_2_DISCOVERY_CHANNEL = 2437;
+    private static final int MIN_RTT_BURST_SIZE = RangingRequest.getMinRttBurstSize();
+    private static final int MAX_RTT_BURST_SIZE = RangingRequest.getMaxRttBurstSize();
+
+    /**
+     * Ranging Interval's are in binary Time Unit (TU). As per IEEE 802.11-1999 1 TU equals
+     * 1024 microseconds.
+     *
+     * @hide
+     */
+    @IntDef({
+            PERIODIC_RANGING_INTERVAL_NONE, PERIODIC_RANGING_INTERVAL_128TU,
+            PERIODIC_RANGING_INTERVAL_256TU, PERIODIC_RANGING_INTERVAL_512TU,
+            PERIODIC_RANGING_INTERVAL_1024TU, PERIODIC_RANGING_INTERVAL_2048TU,
+            PERIODIC_RANGING_INTERVAL_4096TU, PERIODIC_RANGING_INTERVAL_8192TU})
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface PeriodicRangingInterval {
+    }
+    /* Ranging is not repeated */
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public static final int PERIODIC_RANGING_INTERVAL_NONE = 0;
+
+    /* Ranging interval is 128TU [= (128 * 1024) / 1000 = 131.072 ms] */
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public static final int PERIODIC_RANGING_INTERVAL_128TU = 128;
+
+    /* Ranging interval is 256TU [= (256 * 1024) / 1000 = 262.144 ms] */
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public static final int PERIODIC_RANGING_INTERVAL_256TU = 256;
+
+    /* Ranging interval is 512TU [= (512 * 1024) / 1000 = 524.288 ms] */
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public static final int PERIODIC_RANGING_INTERVAL_512TU = 512;
+
+    /* Ranging interval is 1024TU [= (1024 * 1024) / 1000 = 1048.576 ms] */
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public static final int PERIODIC_RANGING_INTERVAL_1024TU = 1024;
+
+    /* Ranging interval is 2048TU [= (2048 * 1024) / 1000 = 2097.152 ms] */
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public static final int PERIODIC_RANGING_INTERVAL_2048TU = 2048;
+
+    /* Ranging interval is 4096TU [= (4096 * 1024) / 1000 = 4194.304 ms] */
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public static final int PERIODIC_RANGING_INTERVAL_4096TU = 4096;
+
+    /* Ranging interval is 8192TU [= (8192 * 1024) / 1000 = 8388.608 ms] */
+    /** @hide */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public static final int PERIODIC_RANGING_INTERVAL_8192TU = 8192;
+
     /** @hide */
     public final byte[] mServiceName;
 
@@ -116,12 +188,39 @@ public final class SubscribeConfig implements Parcelable {
     private final List<OuiKeyedData> mVendorData;
 
     /** @hide */
+    public final int mPeriodicRangingInterval;
+
+    /** @hide */
+    public final boolean mPeriodicRangingEnabled;
+
+    /** @hide */
+    public final int mRttBurstSize;
+
+    /** @hide */
+    public final int mFrequencyMhz;
+
+    /** @hide */
+    public final int mCenterFrequency0Mhz;
+
+    /** @hide */
+    public final int mCenterFrequency1Mhz;
+
+    /** @hide */
+    public final int mPreamble;
+
+    /** @hide */
+    public final int mChannelWidth;
+
+    /** @hide */
     public SubscribeConfig(byte[] serviceName, byte[] serviceSpecificInfo, byte[] matchFilter,
             int subscribeType, int ttlSec, boolean enableTerminateNotification,
             boolean minDistanceMmSet, int minDistanceMm, boolean maxDistanceMmSet,
             int maxDistanceMm, boolean enableInstantMode, @WifiScanner.WifiBand int band,
             AwarePairingConfig pairingConfig, boolean isSuspendable,
-            @NonNull List<OuiKeyedData> vendorData) {
+            @NonNull List<OuiKeyedData> vendorData, int rangingInterval,
+            boolean enablePeriodicRanging, int rttBurstSize, int frequencyMhz,
+            int centerFrequency0Mhz, int centerFrequency1Mhz, int preamble,
+            int channelWidth) {
         mServiceName = serviceName;
         mServiceSpecificInfo = serviceSpecificInfo;
         mMatchFilter = matchFilter;
@@ -137,6 +236,14 @@ public final class SubscribeConfig implements Parcelable {
         mPairingConfig = pairingConfig;
         mIsSuspendable = isSuspendable;
         mVendorData = vendorData;
+        mPeriodicRangingInterval = rangingInterval;
+        mPeriodicRangingEnabled = enablePeriodicRanging;
+        mRttBurstSize = rttBurstSize;
+        mFrequencyMhz = frequencyMhz;
+        mCenterFrequency0Mhz = centerFrequency0Mhz;
+        mCenterFrequency1Mhz = centerFrequency1Mhz;
+        mPreamble = preamble;
+        mChannelWidth = channelWidth;
     }
 
     @Override
@@ -160,7 +267,15 @@ public final class SubscribeConfig implements Parcelable {
                 + ", mBand=" + mBand
                 + ", mPairingConfig" + mPairingConfig
                 + ", mIsSuspendable=" + mIsSuspendable
-                + ", mVendorData=" + mVendorData + "]";
+                + ", mVendorData=" + mVendorData + "]"
+                + ", mPeriodicRangingInterval" + mPeriodicRangingInterval
+                + ", mPeriodicRangingEnabled" + mPeriodicRangingEnabled
+                + ", mRttBurstSize" + mRttBurstSize
+                + ", mFrequencyMhz" + mFrequencyMhz
+                + ", mCenterFrequency0Mhz" + mCenterFrequency0Mhz
+                + ", mCenterFrequency1Mhz" + mCenterFrequency1Mhz
+                + ", mPreamble" + mPreamble
+                + ", mChannelWidth" + mChannelWidth;
     }
 
     @Override
@@ -185,6 +300,14 @@ public final class SubscribeConfig implements Parcelable {
         dest.writeParcelable(mPairingConfig, flags);
         dest.writeBoolean(mIsSuspendable);
         dest.writeList(mVendorData);
+        dest.writeInt(mPeriodicRangingInterval);
+        dest.writeBoolean(mPeriodicRangingEnabled);
+        dest.writeInt(mRttBurstSize);
+        dest.writeInt(mFrequencyMhz);
+        dest.writeInt(mCenterFrequency0Mhz);
+        dest.writeInt(mCenterFrequency1Mhz);
+        dest.writeInt(mPreamble);
+        dest.writeInt(mChannelWidth);
     }
 
     @NonNull
@@ -212,11 +335,21 @@ public final class SubscribeConfig implements Parcelable {
                     AwarePairingConfig.class.getClassLoader());
             boolean isSuspendable = in.readBoolean();
             List<OuiKeyedData> vendorData = ParcelUtil.readOuiKeyedDataList(in);
+            int rangingInterval = in.readInt();
+            boolean enablePeriodicRanging = in.readBoolean();
+            int burstSize = in.readInt();
+            int frequencyMhz = in.readInt();
+            int centerFrequency0Mhz = in.readInt();
+            int centerFrequency1Mhz = in.readInt();
+            int preamble = in.readInt();
+            int channelWidth = in.readInt();
 
             return new SubscribeConfig(serviceName, ssi, matchFilter, subscribeType, ttlSec,
                     enableTerminateNotification, minDistanceMmSet, minDistanceMm, maxDistanceMmSet,
                     maxDistanceMm, enableInstantMode, band, pairingConfig, isSuspendable,
-                    vendorData);
+                    vendorData, rangingInterval, enablePeriodicRanging, burstSize,
+                    frequencyMhz, centerFrequency0Mhz, centerFrequency1Mhz, preamble,
+                    channelWidth);
         }
     };
 
@@ -241,7 +374,14 @@ public final class SubscribeConfig implements Parcelable {
                 && mEnableInstantMode == lhs.mEnableInstantMode
                 && mBand == lhs.mBand
                 && mIsSuspendable == lhs.mIsSuspendable
-                && Objects.equals(mVendorData, lhs.mVendorData))) {
+                && Objects.equals(mVendorData, lhs.mVendorData)
+                && mPeriodicRangingEnabled == lhs.mPeriodicRangingEnabled
+                && mRttBurstSize == lhs.mRttBurstSize
+                && mFrequencyMhz == lhs.mFrequencyMhz
+                && mCenterFrequency0Mhz == lhs.mCenterFrequency0Mhz
+                && mCenterFrequency1Mhz == lhs.mCenterFrequency1Mhz
+                && mPreamble == lhs.mPreamble
+                && mChannelWidth == lhs.mChannelWidth)) {
             return false;
         }
 
@@ -253,6 +393,9 @@ public final class SubscribeConfig implements Parcelable {
             return false;
         }
 
+        if (mPeriodicRangingEnabled && mPeriodicRangingInterval != lhs.mPeriodicRangingInterval) {
+            return false;
+        }
         return true;
     }
 
@@ -261,7 +404,9 @@ public final class SubscribeConfig implements Parcelable {
         int result = Objects.hash(Arrays.hashCode(mServiceName),
                 Arrays.hashCode(mServiceSpecificInfo), Arrays.hashCode(mMatchFilter),
                 mSubscribeType, mTtlSec, mEnableTerminateNotification, mMinDistanceMmSet,
-                mMaxDistanceMmSet, mEnableInstantMode, mBand, mIsSuspendable, mVendorData);
+                mMaxDistanceMmSet, mEnableInstantMode, mBand,  mIsSuspendable, mVendorData,
+                mPeriodicRangingEnabled, mRttBurstSize, mFrequencyMhz, mCenterFrequency0Mhz,
+                mCenterFrequency1Mhz, mPreamble, mChannelWidth);
 
         if (mMinDistanceMmSet) {
             result = Objects.hash(result, mMinDistanceMm);
@@ -269,6 +414,9 @@ public final class SubscribeConfig implements Parcelable {
         if (mMaxDistanceMmSet) {
             result = Objects.hash(result, mMaxDistanceMm);
         }
+        if (mPeriodicRangingEnabled) {
+            result = Objects.hash(result, mPeriodicRangingInterval);
+        }
 
         return result;
     }
@@ -339,9 +487,39 @@ public final class SubscribeConfig implements Parcelable {
                     "Maximum distance must be greater than minimum distance");
         }
 
+        if (mPeriodicRangingEnabled && (mMinDistanceMmSet || mMaxDistanceMmSet)) {
+            throw new IllegalArgumentException(
+                    "Either Periodic Ranging or Min/Max distance is allowed. Not both.");
+        }
+
         if (!rttSupported && (mMinDistanceMmSet || mMaxDistanceMmSet)) {
             throw new IllegalArgumentException("Ranging is not supported");
         }
+        if ((!rttSupported || !characteristics.isPeriodicRangingSupported())
+                && mPeriodicRangingEnabled) {
+            throw new IllegalArgumentException("Periodic ranging is not supported");
+        }
+        if (mPeriodicRangingEnabled && mPeriodicRangingInterval < 0) {
+            throw new IllegalArgumentException("Periodic ranging interval must be non-negative");
+        }
+        if (mPeriodicRangingEnabled && mRttBurstSize < 0) {
+            throw new IllegalArgumentException("Rtt Burst size must be non-negative");
+        }
+        if (mPeriodicRangingEnabled && mFrequencyMhz < 0) {
+            throw new IllegalArgumentException(" Frequency must be non-negative");
+        }
+        if (mPeriodicRangingEnabled && mCenterFrequency0Mhz < 0) {
+            throw new IllegalArgumentException("Center Frequency0 must be non-negative");
+        }
+        if (mPeriodicRangingEnabled && mCenterFrequency1Mhz < 0) {
+            throw new IllegalArgumentException("Center Frequency1 must be non-negative");
+        }
+        if (mPeriodicRangingEnabled && mPreamble < 0) {
+            throw new IllegalArgumentException("Preamble must be non-negative");
+        }
+        if (mPeriodicRangingEnabled && mChannelWidth < 0) {
+            throw new IllegalArgumentException("Channel width must be non-negative");
+        }
     }
 
     /**
@@ -409,6 +587,108 @@ public final class SubscribeConfig implements Parcelable {
     }
 
     /**
+     * Check if periodic range reporting is enabled for subscribe session
+     * @see Builder#setPeriodicRangingEnabled(boolean)
+     * @return true for enabled, false otherwise.
+     * @hide
+     */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public boolean isPeriodicRangingEnabled() {
+        return mPeriodicRangingEnabled;
+    }
+
+    /**
+     * Get periodic range reporting interval for subscribe session
+     * @see Builder#setPeriodicRangingInterval(int)
+     * @return interval of reporting.
+     * @hide
+     */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public @PeriodicRangingInterval int getPeriodicRangingInterval() {
+        return mPeriodicRangingInterval;
+    }
+
+    /**
+     * Get the RTT burst size used to determine the average range.
+     * @see Builder#setRttBurstSize(int)
+     * @return the RTT burst size.
+     * @hide
+     */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public int getRttBurstSize() {
+        return mRttBurstSize;
+    }
+
+    /**
+     * Get the frequency in MHz of the Wi-Fi channel
+     * @see Builder#setFrequencyMhz(int)
+     * @return frequency in MHz.
+     * @hide
+     */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    @IntRange(from = 0)
+    public int getFrequencyMhz() {
+        return mFrequencyMhz;
+    }
+
+    /**
+     * Get the center frequency in MHz of the first channel segment
+     * @see Builder#setCenterFreq0Mhz(int)
+     * @return the center frequency in MHz of the first channel segment.
+     * @hide
+     */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    @IntRange(from = 0)
+    public int getCenterFreq0Mhz() {
+        return mCenterFrequency0Mhz;
+    }
+
+    /**
+     * Get the center frequency in MHz of the second channel segment (if used)
+     * @see Builder#setCenterFreq1Mhz(int)
+     * @return the center frequency in MHz of the second channel segment
+     * @hide
+     */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    @IntRange(from = 0)
+    public int getCenterFreq1Mhz() {
+        return mCenterFrequency1Mhz;
+    }
+
+    /**
+     * Get the preamble type of the channel.
+     * @see Builder#setPreamble(int)
+     * @return the preamble used for this channel.
+     * @hide
+     */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public @WifiAnnotations.PreambleType int getPreamble() {
+        return ResponderConfig.translateFromLocalToScanResultPreamble(mPreamble);
+    }
+
+    /**
+     * Channel bandwidth; one of {@link ScanResult#CHANNEL_WIDTH_20MHZ},
+     * {@link ScanResult#CHANNEL_WIDTH_40MHZ},
+     * {@link ScanResult#CHANNEL_WIDTH_80MHZ}, {@link ScanResult#CHANNEL_WIDTH_160MHZ},
+     * {@link ScanResult #CHANNEL_WIDTH_80MHZ_PLUS_MHZ} or {@link ScanResult#CHANNEL_WIDTH_320MHZ}.
+     * @see Builder#setChannelWidth(int)
+     * @return the bandwidth repsentation of the Wi-Fi channel
+     * @hide
+     */
+    @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+    @SystemApi
+    public @WifiAnnotations.ChannelWidth int getChannelWidth() {
+        return ResponderConfig.translateFromLocalToScanResultChannelWidth(mChannelWidth);
+    }
+
+    /**
      * Builder used to build {@link SubscribeConfig} objects.
      */
     public static final class Builder {
@@ -427,6 +707,14 @@ public final class SubscribeConfig implements Parcelable {
         private AwarePairingConfig mPairingConfig;
         private boolean mIsSuspendable = false;
         private @NonNull List<OuiKeyedData> mVendorData = Collections.emptyList();
+        private boolean mPeriodicRangingEnabled = false;
+        private int mPeriodicRangingInterval = PERIODIC_RANGING_INTERVAL_512TU;
+        private int mRttBurstSize = RangingRequest.getDefaultRttBurstSize();
+        private int mFrequencyMhz = AWARE_BAND_2_DISCOVERY_CHANNEL;
+        private int mCenterFrequency0Mhz = 0;
+        private int mCenterFrequency1Mhz = 0;
+        private int mPreamble = ResponderConfig.PREAMBLE_HT;
+        private int mChannelWidth = ResponderConfig.CHANNEL_WIDTH_20MHZ;
 
         /**
          * Specify the service name of the subscribe session. The actual on-air
@@ -724,6 +1012,194 @@ public final class SubscribeConfig implements Parcelable {
         }
 
         /**
+         * Configure the interval for Wifi Aware periodic ranging.
+         * <p>
+         * To get the periodic ranging support use
+         * {@link Characteristics#isPeriodicRangingSupported()}
+         * When interval is not configured, default interval {@link PERIODIC_RANGING_INTERVAL_512TU}
+         * is used.
+         * </p>
+         *
+         * @param interval Ranging interval as described in {@link PeriodicRangingInterval}
+         * @return The builder to facilitate chaining
+         *         {@code builder.setXXX(..).setXXX(..)}.
+         * @hide
+         */
+        @NonNull
+        @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+        @SystemApi
+        public Builder setPeriodicRangingInterval(@PeriodicRangingInterval int interval) {
+            if (interval != PERIODIC_RANGING_INTERVAL_NONE
+                    && interval != PERIODIC_RANGING_INTERVAL_128TU
+                    && interval != PERIODIC_RANGING_INTERVAL_256TU
+                    && interval != PERIODIC_RANGING_INTERVAL_512TU
+                    && interval != PERIODIC_RANGING_INTERVAL_1024TU
+                    && interval != PERIODIC_RANGING_INTERVAL_2048TU
+                    && interval != PERIODIC_RANGING_INTERVAL_4096TU
+                    && interval != PERIODIC_RANGING_INTERVAL_8192TU) {
+                throw new IllegalArgumentException("Invalid Ranging interval - " + interval);
+            }
+            mPeriodicRangingInterval = interval;
+            return this;
+        }
+
+        /**
+         * Enable Wifi Aware periodic ranging.
+         * <p>
+         * To get the periodic ranging support use
+         * {@link Characteristics#isPeriodicRangingSupported()}
+         *
+         * Wifi aware based periodic ranging allows continuous ranging report based on configured
+         * interval through {@link #setPeriodicRangingInterval()}. To stop continuous ranging
+         * results, reset the {@link #setPeriodicRangingEnabled()} and reconfigure using updated
+         * {@link SubscribeDiscoverySession#updateSubscribe(SubscribeConfig)}
+         * </p>
+         *
+         * @param enable Enable or disable periodic ranging report
+         * @return The builder to facilitate chaining
+         *         {@code builder.setXXX(..).setXXX(..)}.
+         * @hide
+         */
+        @NonNull
+        @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+        @SystemApi
+        public Builder setPeriodicRangingEnabled(boolean enable) {
+            mPeriodicRangingEnabled = enable;
+            return this;
+        }
+
+        /**
+         * Set the RTT Burst size for the Aware Periodic Ranging.
+         * <p>
+         * If not set, the default RTT burst size given by
+         * {@link RangingRequest#getDefaultRttBurstSize()} is used to determine the default value.
+         * If set, the value must be in the range {@link RangingRequest#getMinRttBurstSize()} and
+         * {@link RangingRequest#getMaxRttBurstSize()} inclusively, or a
+         * {@link java.lang.IllegalArgumentException} will be thrown.
+         * </p>
+         *
+         * @param burstSize The number of FTM packets used to estimate a range
+         * @return The builder to facilitate chaining
+         *         {@code builder.setXXX(..).setXXX(..)}.
+         * @hide
+         */
+        @NonNull
+        @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+        @SystemApi
+        public Builder setRttBurstSize(int burstSize) {
+            if (burstSize < MIN_RTT_BURST_SIZE || burstSize > MAX_RTT_BURST_SIZE) {
+                throw new IllegalArgumentException("RTT burst size out of range.");
+            }
+            mRttBurstSize = burstSize;
+            return this;
+        }
+
+        /**
+         * Sets the frequency of the channel in MHz.
+         * <p>
+         * Note: The frequency is used as a hint, and the underlying WiFi subsystem may use it, or
+         * select an alternate if its own connectivity scans have determined the frequency of the
+         * Peer/Publisher has changed.
+         * </p>
+         *
+         * @param frequency the frequency of the channel in MHz
+         * @return The builder to facilitate chaining
+         *         {@code builder.setXXX(..).setXXX(..)}.
+         * @hide
+         */
+        @NonNull
+        @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+        @SystemApi
+        public Builder setFrequencyMhz(@IntRange(from = 0) int frequency) {
+            mFrequencyMhz = frequency;
+            return this;
+        }
+
+        /**
+         * Sets the center frequency in MHz of the first segment of the channel.
+         * <p>
+         * Note: The frequency is used as a hint, and the underlying WiFi subsystem may use it, or
+         * select an alternate if its own connectivity scans have determined the frequency of the
+         * Peer/Publisher has changed.
+         * </p>
+         *
+         * @param centerFreq0 the center frequency in MHz of first channel segment
+         * @return The builder to facilitate chaining
+         *         {@code builder.setXXX(..).setXXX(..)}.
+         * @hide
+         */
+        @NonNull
+        @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+        @SystemApi
+        public Builder setCenterFreq0Mhz(@IntRange(from = 0) int centerFreq0) {
+            mCenterFrequency0Mhz = centerFreq0;
+            return this;
+        }
+
+        /**
+         * Sets the center frequency in MHz of the second segment of the channel, if used.
+         * <p>
+         * Note: The frequency is used as a hint, and the underlying WiFi subsystem may use it, or
+         * select an alternate if its own connectivity scans have determined the frequency of the
+         * Peer/Publisher has changed.
+         * </p>
+         *
+         * @param centerFreq1 the center frequency in MHz of second channel segment
+         * @return The builder to facilitate chaining
+         *         {@code builder.setXXX(..).setXXX(..)}.
+         * @hide
+         */
+        @NonNull
+        @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+        @SystemApi
+        public Builder setCenterFreq1Mhz(@IntRange(from = 0) int centerFreq1) {
+            mCenterFrequency1Mhz = centerFreq1;
+            return this;
+        }
+
+        /**
+         * Sets the preamble encoding for the protocol.
+         * <p>
+         * Note: The preamble is used as a hint, and the underlying WiFi subsystem may use it, or
+         * select an alternate based on negotiation of Peer capability or concurrency management.
+         * </p>
+         *
+         * @param preamble the preamble encoding
+         * @return The builder to facilitate chaining
+         *         {@code builder.setXXX(..).setXXX(..)}.
+         * @hide
+         */
+        @NonNull
+        @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+        @SystemApi
+        public Builder setPreamble(@WifiAnnotations.PreambleType int preamble) {
+            mPreamble = ResponderConfig.translateFromScanResultToLocalPreamble(preamble);
+            return this;
+        }
+
+        /**
+         * Sets the channel bandwidth.
+         * <p>
+         * Note: The channel bandwidth is used as a hint, and the underlying WiFi subsystem may use
+         * it, or select an alternate based on negotiation of Peer capability or concurrency
+         * management.
+         * </p>
+         *
+         * @param channelWidth the bandwidth of the channel in MHz
+         * @return The builder to facilitate chaining
+         *         {@code builder.setXXX(..).setXXX(..)}.
+         * @hide
+         */
+        @NonNull
+        @FlaggedApi(FLAG_RANGING_RTT_ENABLED)
+        @SystemApi
+        public Builder setChannelWidth(@WifiAnnotations.ChannelWidth int channelWidth) {
+            mChannelWidth =
+                    ResponderConfig.translateFromScanResultToLocalChannelWidth(channelWidth);
+            return this;
+        }
+
+        /**
          * Build {@link SubscribeConfig} given the current requests made on the
          * builder.
          */
@@ -731,7 +1207,11 @@ public final class SubscribeConfig implements Parcelable {
             return new SubscribeConfig(mServiceName, mServiceSpecificInfo, mMatchFilter,
                     mSubscribeType, mTtlSec, mEnableTerminateNotification,
                     mMinDistanceMmSet, mMinDistanceMm, mMaxDistanceMmSet, mMaxDistanceMm,
-                    mEnableInstantMode, mBand, mPairingConfig, mIsSuspendable, mVendorData);
+                    mEnableInstantMode, mBand, mPairingConfig, mIsSuspendable, mVendorData,
+                    mPeriodicRangingInterval, mPeriodicRangingEnabled, mRttBurstSize,
+                    mFrequencyMhz, mCenterFrequency0Mhz, mCenterFrequency1Mhz, mPreamble,
+                    mChannelWidth);
+
         }
     }
 }
diff --git a/framework/java/android/net/wifi/aware/WifiAwareManager.java b/framework/java/android/net/wifi/aware/WifiAwareManager.java
index 2edf792b16..d74052c38f 100644
--- a/framework/java/android/net/wifi/aware/WifiAwareManager.java
+++ b/framework/java/android/net/wifi/aware/WifiAwareManager.java
@@ -45,6 +45,7 @@ import android.net.wifi.IIntegerListener;
 import android.net.wifi.IListListener;
 import android.net.wifi.OuiKeyedData;
 import android.net.wifi.WifiManager;
+import android.net.wifi.rtt.RangingResult;
 import android.net.wifi.util.HexEncoding;
 import android.os.Binder;
 import android.os.Build;
@@ -1227,6 +1228,11 @@ public class WifiAwareManager {
             }
         }
 
+        @Override
+        public void onRangingResultsReceived(List<RangingResult> rangingResults) {
+            mHandler.post(() -> mOriginalCallback.onRangingResultsReceived(rangingResults));
+        }
+
         /*
          * Proxies methods
          */
diff --git a/framework/java/android/net/wifi/rtt/RangingResult.java b/framework/java/android/net/wifi/rtt/RangingResult.java
index bf3c5e1338..604c879daa 100644
--- a/framework/java/android/net/wifi/rtt/RangingResult.java
+++ b/framework/java/android/net/wifi/rtt/RangingResult.java
@@ -33,6 +33,7 @@ import android.net.wifi.aware.PeerHandle;
 import android.os.Build;
 import android.os.Parcel;
 import android.os.Parcelable;
+import android.util.Log;
 
 import androidx.annotation.RequiresApi;
 
@@ -41,6 +42,7 @@ import com.android.wifi.flags.Flags;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
@@ -158,6 +160,47 @@ public final class RangingResult implements Parcelable {
         private long mPasnComebackAfterMillis = UNSPECIFIED;
 
         /**
+         * Constructs a Builder with default values (see {@link Builder}).
+         */
+        public Builder() {}
+
+        /**
+         * Constructs a Builder initialized from an existing {@link RangingResult} instance.
+         *
+         * @hide
+         */
+        public Builder(@NonNull RangingResult other) {
+            if (other == null) {
+                Log.e(TAG, "Cannot provide a null RangingResult");
+                return;
+            }
+
+            mStatus = other.mStatus;
+            mMac = other.mMac;
+            mPeerHandle = other.mPeerHandle;
+            mDistanceMm = other.mDistanceMm;
+            mDistanceStdDevMm = other.mDistanceStdDevMm;
+            mRssi = other.mRssi;
+            mNumAttemptedMeasurements = other.mNumAttemptedMeasurements;
+            mNumSuccessfulMeasurements = other.mNumSuccessfulMeasurements;
+            if (other.mLci != null) mLci = other.mLci.clone();
+            if (other.mLcr != null) mLcr = other.mLcr.clone();
+            mResponderLocation = new ResponderLocation(mLci, mLcr);
+            mTimestamp = other.mTimestamp;
+            mIs80211mcMeasurement = other.mIs80211mcMeasurement;
+            mFrequencyMHz = other.mFrequencyMHz;
+            mPacketBw = other.mPacketBw;
+            mIs80211azNtbMeasurement = other.mIs80211azNtbMeasurement;
+            mNtbMinMeasurementTime = other.mNtbMinMeasurementTime;
+            mNtbMaxMeasurementTime = other.mNtbMaxMeasurementTime;
+            mI2rTxLtfRepetitions = other.mI2rTxLtfRepetitions;
+            mR2iTxLtfRepetitions = other.mR2iTxLtfRepetitions;
+            mNumTxSpatialStreams = other.mNumTxSpatialStreams;
+            mNumRxSpatialStreams = other.mNumRxSpatialStreams;
+            mVendorData = new ArrayList<>(other.mVendorData);
+        }
+
+        /**
          * Sets the Range result status.
          *
          * @param status Ranging result status, if not set defaults to
diff --git a/framework/java/android/net/wifi/rtt/ResponderConfig.java b/framework/java/android/net/wifi/rtt/ResponderConfig.java
index a648e9eadc..a8fd2d5b5a 100644
--- a/framework/java/android/net/wifi/rtt/ResponderConfig.java
+++ b/framework/java/android/net/wifi/rtt/ResponderConfig.java
@@ -1125,7 +1125,7 @@ public final class ResponderConfig implements Parcelable {
      *
      * @hide
      */
-    static int translateFromScanResultToLocalChannelWidth(
+    public static int translateFromScanResultToLocalChannelWidth(
             @WifiAnnotations.ChannelWidth int scanResultChannelWidth) {
         switch (scanResultChannelWidth) {
             case ScanResult.CHANNEL_WIDTH_20MHZ:
@@ -1154,7 +1154,8 @@ public final class ResponderConfig implements Parcelable {
      *
      * @hide
      */
-    static int translateFromLocalToScanResultChannelWidth(@ChannelWidth int localChannelWidth) {
+    public static int translateFromLocalToScanResultChannelWidth(
+            @ChannelWidth int localChannelWidth) {
         switch (localChannelWidth) {
             case CHANNEL_WIDTH_20MHZ:
                 return ScanResult.CHANNEL_WIDTH_20MHZ;
@@ -1182,7 +1183,7 @@ public final class ResponderConfig implements Parcelable {
      *
      * @hide
      */
-    static int translateFromScanResultToLocalPreamble(
+    public static int translateFromScanResultToLocalPreamble(
             @WifiAnnotations.PreambleType int scanResultPreamble) {
         switch (scanResultPreamble) {
             case ScanResult.PREAMBLE_LEGACY:
@@ -1209,7 +1210,7 @@ public final class ResponderConfig implements Parcelable {
      *
      * @hide
      */
-    static int translateFromLocalToScanResultPreamble(@PreambleType int localPreamble) {
+    public static int translateFromLocalToScanResultPreamble(@PreambleType int localPreamble) {
         switch (localPreamble) {
             case PREAMBLE_LEGACY:
                 return ScanResult.PREAMBLE_LEGACY;
diff --git a/service/java/com/android/server/wifi/aware/Capabilities.java b/service/java/com/android/server/wifi/aware/Capabilities.java
index b47eca20d1..59c78aa2f6 100644
--- a/service/java/com/android/server/wifi/aware/Capabilities.java
+++ b/service/java/com/android/server/wifi/aware/Capabilities.java
@@ -50,6 +50,9 @@ public class Capabilities {
     public boolean isSuspensionSupported;
     public boolean is6gSupported;
     public boolean isHeSupported;
+    public boolean isPeriodicRangingSupported;
+    public int maxSupportedRangingPktBandWidth;
+    public int maxSupportedRxChains;
 
     /**
      * Converts the internal capabilities to a parcelable & potentially app-facing
@@ -75,6 +78,10 @@ public class Capabilities {
         bundle.putBoolean(Characteristics.KEY_SUPPORT_NAN_PAIRING, isNanPairingSupported);
         bundle.putBoolean(Characteristics.KEY_SUPPORT_SUSPENSION,
                 deviceConfigFacade.isAwareSuspensionEnabled() && isSuspensionSupported);
+        bundle.putBoolean(Characteristics.KEY_SUPPORT_PERIODIC_RANGING, isPeriodicRangingSupported);
+        bundle.putInt(Characteristics.KEY_MAX_SUPPORTED_RANGING_PKT_BANDWIDTH,
+                maxSupportedRangingPktBandWidth);
+        bundle.putInt(Characteristics.KEY_MAX_SUPPORTED_RX_CHAINS, maxSupportedRxChains);
         return new Characteristics(bundle);
     }
 
@@ -97,6 +104,9 @@ public class Capabilities {
         j.put("isSetClusterIdSupported", isSetClusterIdSupported);
         j.put("isNanPairingSupported", isNanPairingSupported);
         j.put("isSuspensionSupported", isSuspensionSupported);
+        j.put("isPeriodicRangingSupported", isPeriodicRangingSupported);
+        j.put("maxSupportedRangingPktBandWidth", maxSupportedRangingPktBandWidth);
+        j.put("maxSupportedRxChains", maxSupportedRxChains);
         return j;
     }
 
@@ -142,6 +152,12 @@ public class Capabilities {
                 + is6gSupported
                 + ", isHeSupported="
                 + isHeSupported
+                + ", isPeriodicRangingSupported="
+                + isPeriodicRangingSupported
+                + ", maxSupportedRangingPktBandWidth="
+                + maxSupportedRangingPktBandWidth
+                + ",maxSupportedRxChains="
+                + maxSupportedRxChains
                 + "]";
     }
 }
diff --git a/service/java/com/android/server/wifi/aware/WifiAwareDiscoverySessionState.java b/service/java/com/android/server/wifi/aware/WifiAwareDiscoverySessionState.java
index e5fdeed2ff..503e56a099 100644
--- a/service/java/com/android/server/wifi/aware/WifiAwareDiscoverySessionState.java
+++ b/service/java/com/android/server/wifi/aware/WifiAwareDiscoverySessionState.java
@@ -29,9 +29,11 @@ import android.net.wifi.OuiKeyedData;
 import android.net.wifi.WifiScanner;
 import android.net.wifi.aware.AwarePairingConfig;
 import android.net.wifi.aware.IWifiAwareDiscoverySessionCallback;
+import android.net.wifi.aware.PeerHandle;
 import android.net.wifi.aware.PublishConfig;
 import android.net.wifi.aware.SubscribeConfig;
 import android.net.wifi.aware.WifiAwareManager;
+import android.net.wifi.rtt.RangingResult;
 import android.net.wifi.util.HexEncoding;
 import android.os.RemoteException;
 import android.os.SystemClock;
@@ -42,6 +44,7 @@ import com.android.server.wifi.hal.WifiNanIface.NanStatusCode;
 
 import java.io.FileDescriptor;
 import java.io.PrintWriter;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
@@ -75,10 +78,12 @@ public class WifiAwareDiscoverySessionState {
         PeerInfo(int instanceId, byte[] mac) {
             mInstanceId = instanceId;
             mMac = mac;
+            mPeerHandle = new PeerHandle(instanceId);
         }
 
         int mInstanceId;
         byte[] mMac;
+        PeerHandle mPeerHandle;
 
         @Override
         public String toString() {
@@ -688,6 +693,29 @@ public class WifiAwareDiscoverySessionState {
     }
 
     /**
+     * Callback from HAL when ranging results are available
+     */
+    public void onRangingResultsReceived(List<RangingResult> rangingResults) {
+        List<RangingResult> validResults = new ArrayList<>();
+        try {
+            for (RangingResult rangingResult : rangingResults) {
+                PeerHandle peerHandle =
+                        getPeerHandleFromPeerMac(rangingResult.getMacAddress().toByteArray());
+                if (peerHandle == null) {
+                    Log.e(TAG, "Could not find Peer Handle for the ranging result");
+                    continue;
+                }
+                RangingResult result = new RangingResult.Builder(
+                        rangingResult).setPeerHandle(peerHandle).build();
+                validResults.add(result);
+            }
+            mCallback.onRangingResultsReceived(validResults);
+        } catch (RemoteException e) {
+            Log.w(TAG, "onRangingResultsReceived: RemoteException (FYI): " + e);
+        }
+    }
+
+    /**
      * Event that receive the bootstrapping request finished
      */
     public void onBootStrappingConfirmReceived(int peerId, boolean accept, int method) {
@@ -720,6 +748,19 @@ public class WifiAwareDiscoverySessionState {
     }
 
     /**
+     * Get the peerHandle assigned by the framework from the peer mac.
+     */
+    public PeerHandle getPeerHandleFromPeerMac(byte[] peerMac) {
+        for (int i = 0; i < mPeerInfoByRequestorInstanceId.size(); ++i) {
+            PeerInfo peerInfo = mPeerInfoByRequestorInstanceId.valueAt(i);
+            if (Arrays.equals(peerMac, peerInfo.mMac)) {
+                return peerInfo.mPeerHandle;
+            }
+        }
+        return null;
+    }
+
+    /**
      * Dump the internal state of the class.
      */
     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
diff --git a/service/java/com/android/server/wifi/aware/WifiAwareNativeCallback.java b/service/java/com/android/server/wifi/aware/WifiAwareNativeCallback.java
index d6f02bcd78..2f4b0827d2 100644
--- a/service/java/com/android/server/wifi/aware/WifiAwareNativeCallback.java
+++ b/service/java/com/android/server/wifi/aware/WifiAwareNativeCallback.java
@@ -21,6 +21,7 @@ import android.net.wifi.OuiKeyedData;
 import android.net.wifi.aware.AwarePairingConfig;
 import android.net.wifi.aware.IdentityChangedListener;
 import android.net.wifi.aware.WifiAwareChannelInfo;
+import android.net.wifi.rtt.RangingResult;
 import android.util.Log;
 import android.util.SparseArray;
 import android.util.SparseIntArray;
@@ -161,6 +162,11 @@ public class WifiAwareNativeCallback implements WifiNanIface.Callback,
     }
 
     @Override
+    public void notifyRangingResults(ArrayList<RangingResult> rangingResults, byte sessionId) {
+        mWifiAwareStateManager.onRangingResults(rangingResults, sessionId);
+    }
+
+    @Override
     public void notifyEnableResponse(short id, int status) {
         if (status == NanStatusCode.SUCCESS
                 || status == NanStatusCode.ALREADY_ENABLED) {
diff --git a/service/java/com/android/server/wifi/aware/WifiAwareStateManager.java b/service/java/com/android/server/wifi/aware/WifiAwareStateManager.java
index 98d83d76e1..19047477dc 100644
--- a/service/java/com/android/server/wifi/aware/WifiAwareStateManager.java
+++ b/service/java/com/android/server/wifi/aware/WifiAwareStateManager.java
@@ -89,6 +89,7 @@ import android.net.wifi.aware.WifiAwareChannelInfo;
 import android.net.wifi.aware.WifiAwareDataPathSecurityConfig;
 import android.net.wifi.aware.WifiAwareManager;
 import android.net.wifi.aware.WifiAwareNetworkSpecifier;
+import android.net.wifi.rtt.RangingResult;
 import android.net.wifi.util.HexEncoding;
 import android.os.Bundle;
 import android.os.Handler;
@@ -281,6 +282,7 @@ public class WifiAwareStateManager implements WifiAwareShellCommand.DelegatedShe
     private static final int NOTIFICATION_TYPE_ON_BOOTSTRAPPING_REQUEST = 316;
     private static final int NOTIFICATION_TYPE_ON_BOOTSTRAPPING_CONFIRM = 317;
     private static final int NOTIFICATION_TYPE_ON_SUSPENSION_MODE_CHANGED = 318;
+    private static final int NOTIFICATION_TYPE_RANGING_RESULTS = 319;
 
     private static final SparseArray<String> sSmToString = MessageUtils.findMessageNames(
             new Class[]{WifiAwareStateManager.class},
@@ -1719,6 +1721,18 @@ public class WifiAwareStateManager implements WifiAwareShellCommand.DelegatedShe
     }
 
     /**
+     * Place a callback request on the state machine queue: update vendor
+     * capabilities of the Aware stack.
+     */
+    public void onRangingResults(List<RangingResult> rangingResults, int sessionId) {
+        Message msg = mSm.obtainMessage(MESSAGE_TYPE_NOTIFICATION);
+        msg.arg1 = NOTIFICATION_TYPE_RANGING_RESULTS;
+        msg.obj = rangingResults;
+        msg.getData().putInt(MESSAGE_BUNDLE_KEY_SESSION_ID, sessionId);
+        mSm.sendMessage(msg);
+    }
+
+    /**
      * Places a callback request on the state machine queue: data-path interface creation command
      * completed.
      */
@@ -2820,6 +2834,11 @@ public class WifiAwareStateManager implements WifiAwareShellCommand.DelegatedShe
                     onSuspensionModeChangedLocal(isSuspended);
                     break;
                 }
+                case NOTIFICATION_TYPE_RANGING_RESULTS: {
+                    int sessionId = msg.getData().getInt(MESSAGE_BUNDLE_KEY_SESSION_ID);
+                    onRangingResultsReceivedLocal((List<RangingResult>) msg.obj, sessionId);
+                    break;
+                }
                 default:
                     Log.wtf(TAG, "processNotification: this isn't a NOTIFICATION -- msg=" + msg);
             }
@@ -5173,6 +5192,21 @@ public class WifiAwareStateManager implements WifiAwareShellCommand.DelegatedShe
         mAwareMetrics.recordEnableAware();
     }
 
+    private void onRangingResultsReceivedLocal(List<RangingResult> rangingResults,
+             int pubSubId) {
+        if (mVdbg) {
+            Log.v(TAG,
+                    "onRangingResultsReceivedNotification: pubSubId=" + pubSubId);
+        }
+        Pair<WifiAwareClientState, WifiAwareDiscoverySessionState> data =
+                getClientSessionForPubSubId(pubSubId);
+        if (data == null) {
+            Log.e(TAG, "onRangingResultsReceivedLocal: no session found for pubSubId=" + pubSubId);
+            return;
+        }
+        data.second.onRangingResultsReceived(rangingResults);
+    }
+
     private void onClusterChangeLocal(int clusterEventType, byte[] clusterId) {
         mClusterId = clusterId;
         mClusterEventType = clusterEventType;
diff --git a/service/java/com/android/server/wifi/hal/WifiNanIface.java b/service/java/com/android/server/wifi/hal/WifiNanIface.java
index 9fcf9e2038..8a2a8f8ec1 100644
--- a/service/java/com/android/server/wifi/hal/WifiNanIface.java
+++ b/service/java/com/android/server/wifi/hal/WifiNanIface.java
@@ -26,6 +26,7 @@ import android.net.wifi.aware.PublishConfig;
 import android.net.wifi.aware.SubscribeConfig;
 import android.net.wifi.aware.WifiAwareChannelInfo;
 import android.net.wifi.aware.WifiAwareDataPathSecurityConfig;
+import android.net.wifi.rtt.RangingResult;
 import android.util.Log;
 
 import com.android.internal.annotations.VisibleForTesting;
@@ -857,5 +858,13 @@ public class WifiNanIface implements WifiHal.WifiInterface {
          * the suspension mode
          */
         void eventSuspensionModeChanged(boolean isSuspended);
+
+        /**
+         * Invoked when ranging results are available.
+         * @param rangingResults Rtt results data.
+         * @param sessionId ID of an active publish or subscribe discovery session.
+         */
+        void notifyRangingResults(ArrayList<RangingResult> rangingResults, byte sessionId);
+
     }
 }
diff --git a/service/java/com/android/server/wifi/hal/WifiNanIfaceAidlImpl.java b/service/java/com/android/server/wifi/hal/WifiNanIfaceAidlImpl.java
index ecefe9bf33..4b329f2f18 100644
--- a/service/java/com/android/server/wifi/hal/WifiNanIfaceAidlImpl.java
+++ b/service/java/com/android/server/wifi/hal/WifiNanIfaceAidlImpl.java
@@ -55,6 +55,7 @@ import android.hardware.wifi.NanRespondToPairingIndicationRequest;
 import android.hardware.wifi.NanSubscribeRequest;
 import android.hardware.wifi.NanTransmitFollowupRequest;
 import android.hardware.wifi.NanTxType;
+import android.hardware.wifi.WifiChannelInfo;
 import android.net.MacAddress;
 import android.net.wifi.aware.AwarePairingConfig;
 import android.net.wifi.aware.ConfigRequest;
@@ -866,6 +867,7 @@ public class WifiNanIfaceAidlImpl implements IWifiNanIface {
         req.baseConfigs.enableSessionSuspendability = SdkLevel.isAtLeastU()
                 && publishConfig.isSuspendable();
 
+        req.rangingResultsRequired = publishConfig.mEnablePeriodicRangingResults;
         req.publishType = publishConfig.mPublishType;
         req.txType = NanTxType.BROADCAST;
         req.pairingConfig = createAidlPairingConfig(publishConfig.getPairingConfig());
@@ -953,6 +955,21 @@ public class WifiNanIfaceAidlImpl implements IWifiNanIface {
                     HalAidlUtil.frameworkToHalOuiKeyedDataList(subscribeConfig.getVendorData());
         }
 
+        if (subscribeConfig.mPeriodicRangingEnabled) {
+            req.baseConfigs.configRangingIndications |=
+                    NanRangingIndication.CONTINUOUS_INDICATION_MASK;
+            req.baseConfigs.rangingIntervalMs = subscribeConfig.mPeriodicRangingInterval;
+            req.baseConfigs.rttBurstSize = subscribeConfig.mRttBurstSize;
+            req.baseConfigs.preamble = WifiRttControllerAidlImpl
+                    .frameworkToHalResponderPreamble(subscribeConfig.mPreamble);
+            req.baseConfigs.channelInfo = new WifiChannelInfo();
+            req.baseConfigs.channelInfo.width = WifiRttControllerAidlImpl
+                    .frameworkToHalChannelWidth(subscribeConfig.mChannelWidth);
+            req.baseConfigs.channelInfo.centerFreq = subscribeConfig.mFrequencyMhz;
+            req.baseConfigs.channelInfo.centerFreq0 = subscribeConfig.mCenterFrequency0Mhz;
+            req.baseConfigs.channelInfo.centerFreq1 = subscribeConfig.mCenterFrequency1Mhz;
+        }
+
         return req;
     }
 
diff --git a/service/java/com/android/server/wifi/hal/WifiNanIfaceCallbackAidlImpl.java b/service/java/com/android/server/wifi/hal/WifiNanIfaceCallbackAidlImpl.java
index acc45b365e..125d9a37a6 100644
--- a/service/java/com/android/server/wifi/hal/WifiNanIfaceCallbackAidlImpl.java
+++ b/service/java/com/android/server/wifi/hal/WifiNanIfaceCallbackAidlImpl.java
@@ -48,14 +48,18 @@ import android.hardware.wifi.NanStatusCode;
 import android.hardware.wifi.NanSuspensionModeChangeInd;
 import android.hardware.wifi.NpkSecurityAssociation;
 import android.hardware.wifi.RttResult;
+import android.hardware.wifi.RttType;
 import android.net.MacAddress;
 import android.net.wifi.OuiKeyedData;
 import android.net.wifi.aware.AwarePairingConfig;
 import android.net.wifi.aware.Characteristics;
 import android.net.wifi.aware.WifiAwareChannelInfo;
+import android.net.wifi.rtt.RangingResult;
+import android.net.wifi.rtt.ResponderLocation;
 import android.net.wifi.util.HexEncoding;
 import android.util.Log;
 
+import com.android.modules.utils.build.SdkLevel;
 import com.android.server.wifi.aware.Capabilities;
 import com.android.server.wifi.aware.PairingConfigManager.PairingSecurityAssociationInfo;
 import com.android.server.wifi.hal.WifiNanIface.NanClusterEventType;
@@ -75,6 +79,11 @@ public class WifiNanIfaceCallbackAidlImpl extends IWifiNanIfaceEventCallback.Stu
 
     private boolean mVerboseLoggingEnabled;
     private final WifiNanIfaceAidlImpl mWifiNanIface;
+    private static final int SUPPORTED_RX_CHAINS_1 = 1;
+    private static final int SUPPORTED_RX_CHAINS_2 = 2;
+    private static final int SUPPORTED_RX_CHAINS_3 = 3;
+    private static final int SUPPORTED_RX_CHAINS_4 = 4;
+
 
     public WifiNanIfaceCallbackAidlImpl(WifiNanIfaceAidlImpl wifiNanIface) {
         mWifiNanIface = wifiNanIface;
@@ -313,6 +322,18 @@ public class WifiNanIfaceCallbackAidlImpl extends IWifiNanIfaceEventCallback.Stu
     }
 
     @Override
+    public void notifyRangingResults(RttResult[] results, byte sessionId) {
+        if (!checkFrameworkCallback()) return;
+        if (mVerboseLoggingEnabled) {
+            int numResults = results != null ? results.length : -1;
+            Log.v(TAG, "notifyRangingResults: number of ranging results: " + numResults
+                    + ", session_id=" + sessionId);
+        }
+        ArrayList<RangingResult> rangingResults = convertToFrameworkRangingResults(results);
+        mWifiNanIface.getFrameworkCallback().notifyRangingResults(rangingResults, sessionId);
+    }
+
+    @Override
     public void notifyTerminateDataPathResponse(char id, NanStatus status) {
         if (!checkFrameworkCallback()) return;
         if (mVerboseLoggingEnabled) {
@@ -684,9 +705,6 @@ public class WifiNanIfaceCallbackAidlImpl extends IWifiNanIfaceEventCallback.Stu
                 event.cookie);
     }
 
-    @Override
-    public void notifyRangingResults(RttResult[] results, byte discoverySessionId) { }
-
     private int convertAidlBootstrappingResponseCodeToFramework(int aidlCode) {
         switch (aidlCode) {
             case NanBootstrappingResponseCode.NAN_BOOTSTRAPPING_REQUEST_ACCEPT:
@@ -740,6 +758,11 @@ public class WifiNanIfaceCallbackAidlImpl extends IWifiNanIfaceEventCallback.Stu
         frameworkCapabilities.isSuspensionSupported = capabilities.supportsSuspension;
         frameworkCapabilities.is6gSupported = capabilities.supports6g;
         frameworkCapabilities.isHeSupported = capabilities.supportsHe;
+        frameworkCapabilities.isPeriodicRangingSupported = capabilities.supportsPeriodicRanging;
+        frameworkCapabilities.maxSupportedRangingPktBandWidth = WifiRttControllerAidlImpl
+                .halToFrameworkChannelBandwidth(capabilities.maxSupportedBandwidth);
+        frameworkCapabilities.maxSupportedRxChains =
+                toFrameworkChainsSupported(capabilities.maxNumRxChainsSupported);
         return frameworkCapabilities;
     }
 
@@ -775,6 +798,21 @@ public class WifiNanIfaceCallbackAidlImpl extends IWifiNanIfaceEventCallback.Stu
         return publicCipherSuites;
     }
 
+    private static int toFrameworkChainsSupported(int supportedRxChains) {
+        switch(supportedRxChains) {
+            case SUPPORTED_RX_CHAINS_1:
+                return Characteristics.SUPPORTED_RX_CHAINS_1;
+            case SUPPORTED_RX_CHAINS_2:
+                return Characteristics.SUPPORTED_RX_CHAINS_2;
+            case SUPPORTED_RX_CHAINS_3:
+                return Characteristics.SUPPORTED_RX_CHAINS_3;
+            case SUPPORTED_RX_CHAINS_4:
+                return Characteristics.SUPPORTED_RX_CHAINS_4;
+            default:
+                return Characteristics.SUPPORTED_RX_CHAINS_UNSPECIFIED;
+        }
+    }
+
     private static String statusString(NanStatus status) {
         if (status == null) {
             return "status=null";
@@ -812,4 +850,49 @@ public class WifiNanIfaceCallbackAidlImpl extends IWifiNanIfaceEventCallback.Stu
         }
         return true;
     }
+
+    private ArrayList<RangingResult> convertToFrameworkRangingResults(RttResult[] halResults) {
+        ArrayList<RangingResult> rangingResults = new ArrayList();
+        for (RttResult rttResult : halResults) {
+            if (rttResult == null) continue;
+            byte[] lci = rttResult.lci.data;
+            byte[] lcr = rttResult.lcr.data;
+            ResponderLocation responderLocation;
+            try {
+                responderLocation = new ResponderLocation(lci, lcr);
+                if (!responderLocation.isValid()) {
+                    responderLocation = null;
+                }
+            } catch (Exception e) {
+                responderLocation = null;
+                Log.e(TAG, "ResponderLocation: lci/lcr parser failed exception -- " + e);
+            }
+            if (rttResult.successNumber <= 1 && rttResult.distanceSdInMm != 0) {
+                if (mVerboseLoggingEnabled) {
+                    Log.w(TAG, "postProcessResults: non-zero distance stdev with 0||1 num "
+                            + "samples!? result=" + rttResult);
+                }
+                rttResult.distanceSdInMm = 0;
+            }
+            RangingResult.Builder resultBuilder = new RangingResult.Builder()
+                    .setStatus(WifiRttControllerAidlImpl.halToFrameworkRttStatus(rttResult.status))
+                    .setMacAddress(MacAddress.fromBytes(rttResult.addr))
+                    .setDistanceMm(rttResult.distanceInMm)
+                    .setDistanceStdDevMm(rttResult.distanceSdInMm)
+                    .setRssi(rttResult.rssi / -2)
+                    .setNumAttemptedMeasurements(rttResult.numberPerBurstPeer)
+                    .setNumSuccessfulMeasurements(rttResult.successNumber)
+                    .setUnverifiedResponderLocation(responderLocation)
+                    .setRangingTimestampMillis(
+                            rttResult.timeStampInUs / WifiRttController.CONVERSION_US_TO_MS)
+                    .set80211mcMeasurement(rttResult.type == RttType.TWO_SIDED_11MC);
+            if (SdkLevel.isAtLeastV() && WifiHalAidlImpl.isServiceVersionAtLeast(2)
+                    && rttResult.vendorData != null) {
+                resultBuilder.setVendorData(
+                        HalAidlUtil.halToFrameworkOuiKeyedDataList(rttResult.vendorData));
+            }
+            rangingResults.add(resultBuilder.build());
+        }
+        return rangingResults;
+    }
 }
diff --git a/service/java/com/android/server/wifi/hal/WifiRttControllerAidlImpl.java b/service/java/com/android/server/wifi/hal/WifiRttControllerAidlImpl.java
index ba32e3f93b..51346df253 100644
--- a/service/java/com/android/server/wifi/hal/WifiRttControllerAidlImpl.java
+++ b/service/java/com/android/server/wifi/hal/WifiRttControllerAidlImpl.java
@@ -312,7 +312,10 @@ public class WifiRttControllerAidlImpl implements IWifiRttController {
         return rangingResults;
     }
 
-    private static @WifiAnnotations.ChannelWidth int halToFrameworkChannelBandwidth(
+    /**
+     *  AIDL Hal to framework mapping for Channel width
+     */
+    public static @WifiAnnotations.ChannelWidth int halToFrameworkChannelBandwidth(
             @RttBw int packetBw) {
         switch (packetBw) {
             case RttBw.BW_20MHZ:
@@ -330,7 +333,10 @@ public class WifiRttControllerAidlImpl implements IWifiRttController {
         }
     }
 
-    private static @WifiRttController.FrameworkRttStatus int halToFrameworkRttStatus(
+    /**
+     *  AIDL Hal to framework mapping for RTT status
+     */
+    public static @WifiRttController.FrameworkRttStatus int halToFrameworkRttStatus(
             int halStatus) {
         switch (halStatus) {
             case RttStatus.SUCCESS:
@@ -575,7 +581,10 @@ public class WifiRttControllerAidlImpl implements IWifiRttController {
         }
     }
 
-    private static int frameworkToHalChannelWidth(int responderChannelWidth)
+    /**
+     *  Framework to AIDL Hal mapping for Channel Width
+     */
+    public static int frameworkToHalChannelWidth(int responderChannelWidth)
             throws IllegalArgumentException {
         switch (responderChannelWidth) {
             case ResponderConfig.CHANNEL_WIDTH_20MHZ:
@@ -616,7 +625,10 @@ public class WifiRttControllerAidlImpl implements IWifiRttController {
         }
     }
 
-    private static int frameworkToHalResponderPreamble(int responderPreamble)
+    /**
+     *  Framework to AIDL Hal mapping for Preamble
+     */
+    public static int frameworkToHalResponderPreamble(int responderPreamble)
             throws IllegalArgumentException {
         switch (responderPreamble) {
             case ResponderConfig.PREAMBLE_LEGACY:
@@ -627,6 +639,8 @@ public class WifiRttControllerAidlImpl implements IWifiRttController {
                 return RttPreamble.VHT;
             case ResponderConfig.PREAMBLE_HE:
                 return RttPreamble.HE;
+            case ResponderConfig.PREAMBLE_EHT:
+                return RttPreamble.EHT;
             default:
                 throw new IllegalArgumentException(
                         "frameworkToHalResponderPreamble: bad " + responderPreamble);
diff --git a/service/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareServiceImplTest.java b/service/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareServiceImplTest.java
index 8342171c42..0e06d031a7 100644
--- a/service/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareServiceImplTest.java
+++ b/service/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareServiceImplTest.java
@@ -43,6 +43,7 @@ import android.Manifest;
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.net.wifi.OuiKeyedData;
+import android.net.wifi.ScanResult;
 import android.net.wifi.WifiScanner;
 import android.net.wifi.aware.Characteristics;
 import android.net.wifi.aware.ConfigRequest;
@@ -1064,7 +1065,7 @@ public class WifiAwareServiceImplTest extends WifiBaseTest {
         // constructed configs.
         PublishConfig publishConfig = new PublishConfig(serviceName.getBytes(), ssi, matchFilter,
                 PublishConfig.PUBLISH_TYPE_UNSOLICITED, 0, true, false, false,
-                WifiScanner.WIFI_BAND_24_GHZ, null, null, false, Collections.emptyList());
+                WifiScanner.WIFI_BAND_24_GHZ, null, null, false, Collections.emptyList(), false);
         int clientId = doConnect();
         IWifiAwareDiscoverySessionCallback mockCallback = mock(
                 IWifiAwareDiscoverySessionCallback.class);
@@ -1081,7 +1082,9 @@ public class WifiAwareServiceImplTest extends WifiBaseTest {
         // constructed configs.
         SubscribeConfig subscribeConfig = new SubscribeConfig(serviceName.getBytes(), ssi,
                 matchFilter, SubscribeConfig.SUBSCRIBE_TYPE_PASSIVE, 0, true, false, 0, false, 0,
-                false, WifiScanner.WIFI_BAND_24_GHZ, null, false, Collections.emptyList());
+                false, WifiScanner.WIFI_BAND_24_GHZ, null, false, Collections.emptyList(),
+                SubscribeConfig.PERIODIC_RANGING_INTERVAL_512TU, false, 2, 2437, 0, 0,
+                ScanResult.PREAMBLE_HT, 0);
         int clientId = doConnect();
         IWifiAwareDiscoverySessionCallback mockCallback = mock(
                 IWifiAwareDiscoverySessionCallback.class);