diff options
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); |