1157 lines
43 KiB
Java
1157 lines
43 KiB
Java
/*
|
|
* Copyright (C) 2017 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package android.net.wifi.rtt;
|
|
|
|
import static android.net.wifi.ScanResult.InformationElement.EID_EXTENSION_PRESENT;
|
|
import static android.net.wifi.ScanResult.InformationElement.EID_EXT_EHT_CAPABILITIES;
|
|
import static android.net.wifi.ScanResult.InformationElement.EID_EXT_HE_CAPABILITIES;
|
|
import static android.net.wifi.ScanResult.InformationElement.EID_HT_CAPABILITIES;
|
|
import static android.net.wifi.ScanResult.InformationElement.EID_VHT_CAPABILITIES;
|
|
|
|
import android.annotation.FlaggedApi;
|
|
import android.annotation.IntDef;
|
|
import android.annotation.IntRange;
|
|
import android.annotation.NonNull;
|
|
import android.annotation.Nullable;
|
|
import android.annotation.SystemApi;
|
|
import android.net.MacAddress;
|
|
import android.net.wifi.ScanResult;
|
|
import android.net.wifi.WifiAnnotations;
|
|
import android.net.wifi.aware.PeerHandle;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
import android.util.Log;
|
|
|
|
import com.android.wifi.flags.Flags;
|
|
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.util.Objects;
|
|
|
|
/**
|
|
* Defines the configuration of an IEEE 802.11mc Responder. The Responder may be an Access Point
|
|
* (AP), a Wi-Fi Aware device, or a manually configured Responder.
|
|
* <p>
|
|
* A Responder configuration may be constructed from a {@link ScanResult} or manually (with the
|
|
* data obtained out-of-band from a peer).
|
|
*/
|
|
public final class ResponderConfig implements Parcelable {
|
|
private static final String TAG = "ResponderConfig";
|
|
private static final int AWARE_BAND_2_DISCOVERY_CHANNEL = 2437;
|
|
|
|
/** @hide */
|
|
@IntDef({RESPONDER_AP, RESPONDER_STA, RESPONDER_P2P_GO, RESPONDER_P2P_CLIENT, RESPONDER_AWARE})
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface ResponderType {
|
|
}
|
|
|
|
/**
|
|
* Responder is an access point(AP).
|
|
*/
|
|
|
|
public static final int RESPONDER_AP = 0;
|
|
|
|
/**
|
|
* Responder is a client device(STA).
|
|
*/
|
|
public static final int RESPONDER_STA = 1;
|
|
|
|
/**
|
|
* Responder is a Wi-Fi Direct Group Owner (GO).
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final int RESPONDER_P2P_GO = 2;
|
|
|
|
/**
|
|
* Responder is a Wi-Fi Direct Group Client.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final int RESPONDER_P2P_CLIENT = 3;
|
|
|
|
/**
|
|
* Responder is a Wi-Fi Aware device.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final int RESPONDER_AWARE = 4;
|
|
|
|
/** @hide */
|
|
@IntDef({
|
|
CHANNEL_WIDTH_20MHZ, CHANNEL_WIDTH_40MHZ, CHANNEL_WIDTH_80MHZ, CHANNEL_WIDTH_160MHZ,
|
|
CHANNEL_WIDTH_80MHZ_PLUS_MHZ, CHANNEL_WIDTH_320MHZ})
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface ChannelWidth {
|
|
}
|
|
|
|
|
|
/**
|
|
* Channel bandwidth is 20 MHZ
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final int CHANNEL_WIDTH_20MHZ = 0;
|
|
|
|
/**
|
|
* Channel bandwidth is 40 MHZ
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final int CHANNEL_WIDTH_40MHZ = 1;
|
|
|
|
/**
|
|
* Channel bandwidth is 80 MHZ
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final int CHANNEL_WIDTH_80MHZ = 2;
|
|
|
|
/**
|
|
* Channel bandwidth is 160 MHZ
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final int CHANNEL_WIDTH_160MHZ = 3;
|
|
|
|
/**
|
|
* Channel bandwidth is 160 MHZ, but 80MHZ + 80MHZ
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final int CHANNEL_WIDTH_80MHZ_PLUS_MHZ = 4;
|
|
|
|
/**
|
|
* Channel bandwidth is 320 MHZ
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final int CHANNEL_WIDTH_320MHZ = 5;
|
|
|
|
/** @hide */
|
|
@IntDef({PREAMBLE_LEGACY, PREAMBLE_HT, PREAMBLE_VHT, PREAMBLE_HE, PREAMBLE_EHT})
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface PreambleType {
|
|
}
|
|
|
|
/**
|
|
* Preamble type: Legacy.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final int PREAMBLE_LEGACY = 0;
|
|
|
|
/**
|
|
* Preamble type: HT.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final int PREAMBLE_HT = 1;
|
|
|
|
/**
|
|
* Preamble type: VHT.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final int PREAMBLE_VHT = 2;
|
|
|
|
/**
|
|
* Preamble type: HE.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final int PREAMBLE_HE = 3;
|
|
|
|
/**
|
|
* Preamble type: EHT.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final int PREAMBLE_EHT = 4;
|
|
|
|
private static final long DEFAULT_NTB_MIN_TIME_BETWEEN_MEASUREMENTS_MICROS = 250000;
|
|
private static final long DEFAULT_NTB_MAX_TIME_BETWEEN_MEASUREMENTS_MICROS = 15000000;
|
|
|
|
/**
|
|
* The MAC address of the Responder. Will be null if a Wi-Fi Aware peer identifier (the
|
|
* peerHandle field) ise used to identify the Responder.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
@Nullable public final MacAddress macAddress;
|
|
|
|
/**
|
|
* The peer identifier of a Wi-Fi Aware Responder. Will be null if a MAC Address (the macAddress
|
|
* field) is used to identify the Responder.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
@Nullable public final PeerHandle peerHandle;
|
|
|
|
/**
|
|
* The device type of the Responder.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public final int responderType;
|
|
|
|
/**
|
|
* Indicates whether the Responder device supports IEEE 802.11mc.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public final boolean supports80211mc;
|
|
|
|
/**
|
|
* Indicates whether the Responder device supports IEEE 802.11az non-trigger based ranging.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
@FlaggedApi(Flags.FLAG_ANDROID_V_WIFI_API)
|
|
public final boolean supports80211azNtb;
|
|
|
|
/**
|
|
* Responder channel bandwidth, specified using {@link ChannelWidth}.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public final int channelWidth;
|
|
|
|
/**
|
|
* The primary 20 MHz frequency (in MHz) of the channel of the Responder.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public final int frequency;
|
|
|
|
/**
|
|
* Not used if the {@link #channelWidth} is 20 MHz. If the Responder uses 40, 80, 160 or
|
|
* 320 MHz, this is the center frequency (in MHz), if the Responder uses 80 + 80 MHz,
|
|
* this is the center frequency of the first segment (in MHz).
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public final int centerFreq0;
|
|
|
|
/**
|
|
* Only used if the {@link #channelWidth} is 80 + 80 MHz. If the Responder uses 80 + 80 MHz,
|
|
* this is the center frequency of the second segment (in MHz).
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public final int centerFreq1;
|
|
|
|
/**
|
|
* The preamble used by the Responder, specified using {@link PreambleType}.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public final int preamble;
|
|
|
|
private long mNtbMinMeasurementTime = DEFAULT_NTB_MIN_TIME_BETWEEN_MEASUREMENTS_MICROS;
|
|
private long mNtbMaxMeasurementTime = DEFAULT_NTB_MAX_TIME_BETWEEN_MEASUREMENTS_MICROS;
|
|
|
|
/**
|
|
* Constructs Responder configuration from the builder
|
|
* @param builder See {@link Builder}
|
|
* @hide
|
|
*/
|
|
public ResponderConfig(Builder builder) {
|
|
if (builder.mMacAddress == null && builder.mPeerHandle == null) {
|
|
throw new IllegalArgumentException(
|
|
"Invalid ResponderConfig - must specify a MAC address or Peer handle");
|
|
}
|
|
this.macAddress = builder.mMacAddress;
|
|
this.peerHandle = builder.mPeerHandle;
|
|
this.responderType = builder.mResponderType;
|
|
this.supports80211mc = builder.mSupports80211Mc;
|
|
this.supports80211azNtb = builder.mSupports80211azNtb;
|
|
this.channelWidth = builder.mChannelWidth;
|
|
this.frequency = builder.mFrequency;
|
|
this.centerFreq0 = builder.mCenterFreq0;
|
|
this.centerFreq1 = builder.mCenterFreq1;
|
|
this.preamble = builder.mPreamble;
|
|
this.mNtbMinMeasurementTime = builder.mNtbMinMeasurementTime;
|
|
this.mNtbMaxMeasurementTime = builder.mNtbMaxMeasurementTime;
|
|
}
|
|
|
|
/**
|
|
* Constructs Responder configuration, using a MAC address to identify the Responder.
|
|
*
|
|
* @param macAddress The MAC address of the Responder.
|
|
* @param responderType The type of the responder device, specified using
|
|
* {@link ResponderType}.
|
|
* For an access point (AP) use {@code RESPONDER_AP}.
|
|
* @param supports80211mc Indicates whether the responder supports IEEE 802.11mc.
|
|
* @param channelWidth Responder channel bandwidth, specified using {@link ChannelWidth}.
|
|
* @param frequency The primary 20 MHz frequency (in MHz) of the channel of the Responder.
|
|
* @param centerFreq0 Not used if the {@code channelWidth} is 20 MHz. If the Responder uses
|
|
* 40, 80, 160 or 320 MHz, this is the center frequency (in MHz), if the
|
|
* Responder uses 80 + 80 MHz, this is the center frequency of the first
|
|
* segment (in MHz).
|
|
* @param centerFreq1 Only used if the {@code channelWidth} is 80 + 80 MHz. If the
|
|
* Responder
|
|
* uses 80 + 80 MHz, this is the center frequency of the second segment
|
|
* (in
|
|
* MHz).
|
|
* @param preamble The preamble used by the Responder, specified using
|
|
* {@link PreambleType}.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public ResponderConfig(@NonNull MacAddress macAddress, @ResponderType int responderType,
|
|
boolean supports80211mc, @ChannelWidth int channelWidth, int frequency, int centerFreq0,
|
|
int centerFreq1, @PreambleType int preamble) {
|
|
if (macAddress == null) {
|
|
throw new IllegalArgumentException(
|
|
"Invalid ResponderConfig - must specify a MAC address");
|
|
}
|
|
this.macAddress = macAddress;
|
|
this.peerHandle = null;
|
|
this.responderType = responderType;
|
|
this.supports80211mc = supports80211mc;
|
|
this.channelWidth = channelWidth;
|
|
this.frequency = frequency;
|
|
this.centerFreq0 = centerFreq0;
|
|
this.centerFreq1 = centerFreq1;
|
|
this.preamble = preamble;
|
|
this.supports80211azNtb = false;
|
|
this.mNtbMinMeasurementTime = DEFAULT_NTB_MIN_TIME_BETWEEN_MEASUREMENTS_MICROS;
|
|
this.mNtbMaxMeasurementTime = DEFAULT_NTB_MAX_TIME_BETWEEN_MEASUREMENTS_MICROS;
|
|
}
|
|
|
|
/**
|
|
* Constructs Responder configuration, using a Wi-Fi Aware PeerHandle to identify the Responder.
|
|
*
|
|
* @param peerHandle The Wi-Fi Aware peer identifier of the Responder.
|
|
* @param responderType The type of the responder device, specified using
|
|
* {@link ResponderType}.
|
|
* @param supports80211mc Indicates whether the responder supports IEEE 802.11mc.
|
|
* @param channelWidth Responder channel bandwidth, specified using {@link ChannelWidth}.
|
|
* @param frequency The primary 20 MHz frequency (in MHz) of the channel of the Responder.
|
|
* @param centerFreq0 Not used if the {@code channelWidth} is 20 MHz. If the Responder uses
|
|
* 40, 80, 160, or 320 MHz, this is the center frequency (in MHz), if the
|
|
* Responder uses 80 + 80 MHz, this is the center frequency of the first
|
|
* segment (in MHz).
|
|
* @param centerFreq1 Only used if the {@code channelWidth} is 80 + 80 MHz. If the
|
|
* Responder
|
|
* uses 80 + 80 MHz, this is the center frequency of the second segment
|
|
* (in
|
|
* MHz).
|
|
* @param preamble The preamble used by the Responder, specified using
|
|
* {@link PreambleType}.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public ResponderConfig(@NonNull PeerHandle peerHandle, @ResponderType int responderType,
|
|
boolean supports80211mc, @ChannelWidth int channelWidth, int frequency, int centerFreq0,
|
|
int centerFreq1, @PreambleType int preamble) {
|
|
this.macAddress = null;
|
|
this.peerHandle = peerHandle;
|
|
this.responderType = responderType;
|
|
this.supports80211mc = supports80211mc;
|
|
this.channelWidth = channelWidth;
|
|
this.frequency = frequency;
|
|
this.centerFreq0 = centerFreq0;
|
|
this.centerFreq1 = centerFreq1;
|
|
this.preamble = preamble;
|
|
this.supports80211azNtb = false;
|
|
this.mNtbMinMeasurementTime = DEFAULT_NTB_MIN_TIME_BETWEEN_MEASUREMENTS_MICROS;
|
|
this.mNtbMaxMeasurementTime = DEFAULT_NTB_MAX_TIME_BETWEEN_MEASUREMENTS_MICROS;
|
|
}
|
|
|
|
/**
|
|
* Constructs Responder configuration. This is a constructor which specifies both
|
|
* a MAC address and a Wi-Fi PeerHandle to identify the Responder. For an RTT RangingRequest
|
|
* the Wi-Fi Aware peer identifier can be constructed using an Identifier set to zero.
|
|
*
|
|
* @param macAddress The MAC address of the Responder.
|
|
* @param peerHandle The Wi-Fi Aware peer identifier of the Responder.
|
|
* @param responderType The type of the responder device, specified using
|
|
* {@link ResponderType}.
|
|
* @param supports80211mc Indicates whether the responder supports IEEE 802.11mc.
|
|
* @param channelWidth Responder channel bandwidth, specified using {@link ChannelWidth}.
|
|
* @param frequency The primary 20 MHz frequency (in MHz) of the channel of the Responder.
|
|
* @param centerFreq0 Not used if the {@code channelWidth} is 20 MHz. If the Responder uses
|
|
* 40, 80, 160 or 320 MHz, this is the center frequency (in MHz), if the
|
|
* Responder uses 80 + 80 MHz, this is the center frequency of the first
|
|
* segment (in MHz).
|
|
* @param centerFreq1 Only used if the {@code channelWidth} is 80 + 80 MHz. If the
|
|
* Responder
|
|
* uses 80 + 80 MHz, this is the center frequency of the second segment
|
|
* (in
|
|
* MHz).
|
|
* @param preamble The preamble used by the Responder, specified using
|
|
* {@link PreambleType}.
|
|
*
|
|
* @hide
|
|
*/
|
|
public ResponderConfig(@NonNull MacAddress macAddress, @NonNull PeerHandle peerHandle,
|
|
@ResponderType int responderType, boolean supports80211mc,
|
|
@ChannelWidth int channelWidth, int frequency, int centerFreq0, int centerFreq1,
|
|
@PreambleType int preamble) {
|
|
this.macAddress = macAddress;
|
|
this.peerHandle = peerHandle;
|
|
this.responderType = responderType;
|
|
this.supports80211mc = supports80211mc;
|
|
this.channelWidth = channelWidth;
|
|
this.frequency = frequency;
|
|
this.centerFreq0 = centerFreq0;
|
|
this.centerFreq1 = centerFreq1;
|
|
this.preamble = preamble;
|
|
this.supports80211azNtb = false;
|
|
this.mNtbMinMeasurementTime = DEFAULT_NTB_MIN_TIME_BETWEEN_MEASUREMENTS_MICROS;
|
|
this.mNtbMaxMeasurementTime = DEFAULT_NTB_MAX_TIME_BETWEEN_MEASUREMENTS_MICROS;
|
|
}
|
|
|
|
/**
|
|
* Creates a Responder configuration from a {@link ScanResult} corresponding to an Access
|
|
* Point (AP), which can be obtained from {@link android.net.wifi.WifiManager#getScanResults()}.
|
|
*/
|
|
@NonNull
|
|
public static ResponderConfig fromScanResult(@NonNull ScanResult scanResult) {
|
|
MacAddress macAddress = MacAddress.fromString(scanResult.BSSID);
|
|
int responderType = RESPONDER_AP;
|
|
boolean supports80211mc = scanResult.is80211mcResponder();
|
|
boolean supports80211azNtbRanging = scanResult.is80211azNtbResponder();
|
|
int channelWidth = scanResult.channelWidth;
|
|
int frequency = scanResult.frequency;
|
|
int centerFreq0 = scanResult.centerFreq0;
|
|
int centerFreq1 = scanResult.centerFreq1;
|
|
|
|
int preamble;
|
|
if (scanResult.informationElements != null && scanResult.informationElements.length != 0) {
|
|
boolean htCapabilitiesPresent = false;
|
|
boolean vhtCapabilitiesPresent = false;
|
|
boolean heCapabilitiesPresent = false;
|
|
boolean ehtCapabilitiesPresent = false;
|
|
|
|
for (ScanResult.InformationElement ie : scanResult.informationElements) {
|
|
if (ie.id == EID_HT_CAPABILITIES) {
|
|
htCapabilitiesPresent = true;
|
|
} else if (ie.id == EID_VHT_CAPABILITIES) {
|
|
vhtCapabilitiesPresent = true;
|
|
} else if (ie.id == EID_EXTENSION_PRESENT && ie.idExt == EID_EXT_HE_CAPABILITIES) {
|
|
heCapabilitiesPresent = true;
|
|
} else if (ie.id == EID_EXTENSION_PRESENT && ie.idExt == EID_EXT_EHT_CAPABILITIES) {
|
|
ehtCapabilitiesPresent = true;
|
|
}
|
|
}
|
|
|
|
if (ehtCapabilitiesPresent && ScanResult.is6GHz(frequency)) {
|
|
preamble = ScanResult.PREAMBLE_EHT;
|
|
} else if (heCapabilitiesPresent && ScanResult.is6GHz(frequency)) {
|
|
preamble = ScanResult.PREAMBLE_HE;
|
|
} else if (vhtCapabilitiesPresent) {
|
|
preamble = ScanResult.PREAMBLE_VHT;
|
|
} else if (htCapabilitiesPresent) {
|
|
preamble = ScanResult.PREAMBLE_HT;
|
|
} else {
|
|
preamble = ScanResult.PREAMBLE_LEGACY;
|
|
}
|
|
} else {
|
|
Log.e(TAG, "Scan Results do not contain IEs - using backup method to select preamble");
|
|
if (channelWidth == ScanResult.CHANNEL_WIDTH_320MHZ) {
|
|
preamble = ScanResult.PREAMBLE_EHT;
|
|
} else if (channelWidth == ScanResult.CHANNEL_WIDTH_80MHZ
|
|
|| channelWidth == ScanResult.CHANNEL_WIDTH_160MHZ) {
|
|
preamble = ScanResult.PREAMBLE_VHT;
|
|
} else {
|
|
preamble = ScanResult.PREAMBLE_HT;
|
|
}
|
|
}
|
|
|
|
return new ResponderConfig.Builder()
|
|
.setMacAddress(macAddress)
|
|
.setResponderType(responderType)
|
|
.set80211mcSupported(supports80211mc)
|
|
.set80211azNtbSupported(supports80211azNtbRanging)
|
|
.setChannelWidth(channelWidth)
|
|
.setFrequencyMhz(frequency)
|
|
.setCenterFreq0Mhz(centerFreq0)
|
|
.setCenterFreq1Mhz(centerFreq1)
|
|
.setPreamble(preamble)
|
|
.build();
|
|
}
|
|
|
|
/**
|
|
* Creates a Responder configuration from a MAC address corresponding to a Wi-Fi Aware
|
|
* Responder. The Responder parameters are set to defaults.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
@NonNull
|
|
public static ResponderConfig fromWifiAwarePeerMacAddressWithDefaults(
|
|
@NonNull MacAddress macAddress) {
|
|
/* Note: the parameters are those of the Aware discovery channel (channel 6). A Responder
|
|
* is expected to be brought up and available to negotiate a maximum accuracy channel
|
|
* (i.e. Band 5 @ 80MHz). A Responder is brought up on the peer by starting an Aware
|
|
* Unsolicited Publisher with Ranging enabled.
|
|
*/
|
|
return new ResponderConfig.Builder()
|
|
.setMacAddress(macAddress)
|
|
.setResponderType(RESPONDER_AWARE)
|
|
.build();
|
|
}
|
|
|
|
/**
|
|
* Creates a Responder configuration from a {@link PeerHandle} corresponding to a Wi-Fi Aware
|
|
* Responder. The Responder parameters are set to defaults.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
@NonNull
|
|
public static ResponderConfig fromWifiAwarePeerHandleWithDefaults(
|
|
@NonNull PeerHandle peerHandle) {
|
|
/* Note: the parameters are those of the Aware discovery channel (channel 6). A Responder
|
|
* is expected to be brought up and available to negotiate a maximum accuracy channel
|
|
* (i.e. Band 5 @ 80MHz). A Responder is brought up on the peer by starting an Aware
|
|
* Unsolicited Publisher with Ranging enabled.
|
|
*/
|
|
return new ResponderConfig.Builder()
|
|
.setPeerHandle(peerHandle)
|
|
.setResponderType(RESPONDER_AWARE)
|
|
.build();
|
|
}
|
|
|
|
private static boolean isResponderTypeSupported(@ResponderType int responderType) {
|
|
switch (responderType) {
|
|
case RESPONDER_AP:
|
|
case RESPONDER_STA:
|
|
case RESPONDER_AWARE:
|
|
break;
|
|
case RESPONDER_P2P_GO:
|
|
case RESPONDER_P2P_CLIENT:
|
|
default:
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Check whether the Responder configuration is valid.
|
|
*
|
|
* @return true if valid, false otherwise.
|
|
*
|
|
* @hide
|
|
*/
|
|
public boolean isValid(boolean awareSupported) {
|
|
if (!isResponderTypeSupported(responderType)) return false;
|
|
if (macAddress == null && peerHandle == null || macAddress != null && peerHandle != null) {
|
|
return false;
|
|
}
|
|
if (!awareSupported && responderType == RESPONDER_AWARE) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @return the MAC address of the responder
|
|
*/
|
|
@Nullable
|
|
public MacAddress getMacAddress() {
|
|
return macAddress;
|
|
}
|
|
|
|
/**
|
|
* @return the peer handle of the responder
|
|
*
|
|
* @hide
|
|
*/
|
|
@Nullable
|
|
public PeerHandle getPeerHandle() {
|
|
return peerHandle;
|
|
}
|
|
|
|
/**
|
|
* @return true if the Responder supports the 802.11mc protocol, false otherwise.
|
|
*/
|
|
public boolean is80211mcSupported() {
|
|
return supports80211mc;
|
|
}
|
|
|
|
/**
|
|
* @return true if the Responder supports the 802.11az non-trigger based ranging protocol,
|
|
* false otherwise.
|
|
*/
|
|
@FlaggedApi(Flags.FLAG_ANDROID_V_WIFI_API)
|
|
public boolean is80211azNtbSupported() {
|
|
return supports80211azNtb;
|
|
}
|
|
|
|
/**
|
|
* AP 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}.
|
|
*
|
|
* @return the bandwidth repsentation of the Wi-Fi channel
|
|
*/
|
|
public @WifiAnnotations.ChannelWidth int getChannelWidth() {
|
|
return translateFromLocalToScanResultChannelWidth(channelWidth);
|
|
}
|
|
|
|
/**
|
|
* @return the frequency in MHz of the Wi-Fi channel
|
|
*/
|
|
@IntRange(from = 0)
|
|
public int getFrequencyMhz() {
|
|
return frequency;
|
|
}
|
|
|
|
/**
|
|
* If the Access Point (AP) bandwidth is 20 MHz, 0 MHz is returned.
|
|
* If the AP use 40, 80 or 160 MHz, this is the center frequency (in MHz).
|
|
* if the AP uses 80 + 80 MHz, this is the center frequency of the first segment (in MHz).
|
|
*
|
|
* @return the center frequency in MHz of the first channel segment
|
|
*/
|
|
@IntRange(from = 0)
|
|
public int getCenterFreq0Mhz() {
|
|
return centerFreq0;
|
|
}
|
|
|
|
/**
|
|
* If the Access Point (AP) bandwidth is 80 + 80 MHz, this param is not used and returns 0.
|
|
* If the AP uses 80 + 80 MHz, this is the center frequency of the second segment in MHz.
|
|
*
|
|
* @return the center frequency in MHz of the second channel segment (if used)
|
|
*/
|
|
@IntRange(from = 0)
|
|
public int getCenterFreq1Mhz() {
|
|
return centerFreq1;
|
|
}
|
|
|
|
/**
|
|
* Get the preamble type of the channel.
|
|
*
|
|
* @return the preamble used for this channel
|
|
*/
|
|
public @WifiAnnotations.PreambleType int getPreamble() {
|
|
return translateFromLocalToScanResultPreamble(preamble);
|
|
}
|
|
|
|
/**
|
|
* Get responder type.
|
|
* @see Builder#setResponderType(int)
|
|
* @return The type of this responder
|
|
*/
|
|
public @ResponderType int getResponderType() {
|
|
return responderType;
|
|
}
|
|
|
|
/**
|
|
* Gets the minimum time between IEEE 802.11az non-trigger based ranging measurements in
|
|
* microseconds for the responder.
|
|
*
|
|
* @hide
|
|
*/
|
|
public long getNtbMinTimeBetweenMeasurementsMicros() {
|
|
return mNtbMinMeasurementTime;
|
|
}
|
|
|
|
/**
|
|
* Gets the maximum time between IEEE 802.11az non-trigger based ranging measurements in
|
|
* microseconds for the responder.
|
|
*
|
|
* @hide
|
|
*/
|
|
public long getNtbMaxTimeBetweenMeasurementsMicros() {
|
|
return mNtbMaxMeasurementTime;
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public void setNtbMinTimeBetweenMeasurementsMicros(long ntbMinMeasurementTime) {
|
|
this.mNtbMinMeasurementTime = ntbMinMeasurementTime;
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public void setNtbMaxTimeBetweenMeasurementsMicros(long ntbMaxMeasurementTime) {
|
|
this.mNtbMaxMeasurementTime = ntbMaxMeasurementTime;
|
|
}
|
|
|
|
/**
|
|
* Builder class used to construct {@link ResponderConfig} objects.
|
|
*/
|
|
public static final class Builder {
|
|
private MacAddress mMacAddress;
|
|
private PeerHandle mPeerHandle;
|
|
private @ResponderType int mResponderType = RESPONDER_AP;
|
|
private boolean mSupports80211Mc = true;
|
|
private boolean mSupports80211azNtb = false;
|
|
private @ChannelWidth int mChannelWidth = CHANNEL_WIDTH_20MHZ;
|
|
private int mFrequency = 0;
|
|
private int mCenterFreq0 = 0;
|
|
private int mCenterFreq1 = 0;
|
|
private @PreambleType int mPreamble = PREAMBLE_LEGACY;
|
|
private long mNtbMinMeasurementTime = DEFAULT_NTB_MIN_TIME_BETWEEN_MEASUREMENTS_MICROS;
|
|
private long mNtbMaxMeasurementTime = DEFAULT_NTB_MAX_TIME_BETWEEN_MEASUREMENTS_MICROS;
|
|
|
|
/**
|
|
* Sets the Responder MAC Address.
|
|
*
|
|
* @param macAddress the phyical address of the responder
|
|
* @return the builder to facilitate chaining
|
|
* {@code builder.setXXX(..).setXXX(..)}.
|
|
*/
|
|
@NonNull
|
|
public Builder setMacAddress(@NonNull MacAddress macAddress) {
|
|
this.mMacAddress = macAddress;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the Responder Peer handle.
|
|
*
|
|
* @param peerHandle Peer handle of the resposnde
|
|
* @return the builder to facilitate chaining
|
|
* {@code builder.setXXX(..).setXXX(..)}.
|
|
* @hide
|
|
*/
|
|
@NonNull
|
|
public Builder setPeerHandle(@NonNull PeerHandle peerHandle) {
|
|
this.mPeerHandle = peerHandle;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets an indication the access point can to respond to the two-sided Wi-Fi RTT protocol,
|
|
* but, if false, indicates only one-sided Wi-Fi RTT is possible.
|
|
*
|
|
* @param supports80211mc the ability to support the Wi-Fi RTT protocol
|
|
* @return the builder to facilitate chaining
|
|
* {@code builder.setXXX(..).setXXX(..)}.
|
|
*/
|
|
@NonNull
|
|
public Builder set80211mcSupported(boolean supports80211mc) {
|
|
this.mSupports80211Mc = supports80211mc;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets an indication the access point can to respond to the IEEE 802.11az non-trigger
|
|
* based ranging protocol, but, if false, indicates only IEEE 802.11mc or one-sided Wi-Fi
|
|
* RTT is possible.
|
|
*
|
|
* @param supports80211azNtb the ability to support the IEEE 802.11az non-trigger based
|
|
* ranging protocol
|
|
* @return the builder to facilitate chaining
|
|
* {@code builder.setXXX(..).setXXX(..)}.
|
|
*/
|
|
@FlaggedApi(Flags.FLAG_ANDROID_V_WIFI_API)
|
|
@NonNull
|
|
public Builder set80211azNtbSupported(boolean supports80211azNtb) {
|
|
this.mSupports80211azNtb = supports80211azNtb;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the channel bandwidth in MHz.
|
|
*
|
|
* @param channelWidth the bandwidth of the channel in MHz
|
|
* @return the builder to facilitate chaining
|
|
* {@code builder.setXXX(..).setXXX(..)}.
|
|
*/
|
|
@NonNull
|
|
public Builder setChannelWidth(@WifiAnnotations.ChannelWidth int channelWidth) {
|
|
this.mChannelWidth = translateFromScanResultToLocalChannelWidth(channelWidth);
|
|
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
|
|
* access point has changed.
|
|
* </p>
|
|
*
|
|
* @param frequency the frequency of the channel in MHz
|
|
* @return the builder to facilitate chaining
|
|
* {@code builder.setXXX(..).setXXX(..)}.
|
|
*/
|
|
@NonNull
|
|
public Builder setFrequencyMhz(@IntRange(from = 0) int frequency) {
|
|
this.mFrequency = 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
|
|
* access point has changed.
|
|
* </p>
|
|
*
|
|
* @param centerFreq0 the center frequency in MHz of first channel segment
|
|
* @return the builder to facilitate chaining
|
|
* {@code builder.setXXX(..).setXXX(..)}.
|
|
*/
|
|
@NonNull
|
|
public Builder setCenterFreq0Mhz(@IntRange(from = 0) int centerFreq0) {
|
|
this.mCenterFreq0 = 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
|
|
* access point has changed.
|
|
* </p>
|
|
*
|
|
* @param centerFreq1 the center frequency in MHz of second channel segment
|
|
* @return the builder to facilitate chaining
|
|
* {@code builder.setXXX(..).setXXX(..)}.
|
|
*/
|
|
@NonNull
|
|
public Builder setCenterFreq1Mhz(@IntRange(from = 0) int centerFreq1) {
|
|
this.mCenterFreq1 = centerFreq1;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the preamble encoding for the protocol.
|
|
*
|
|
* @param preamble the preamble encoding
|
|
* @return the builder to facilitate chaining
|
|
* {@code builder.setXXX(..).setXXX(..)}.
|
|
*/
|
|
@NonNull
|
|
public Builder setPreamble(@WifiAnnotations.PreambleType int preamble) {
|
|
this.mPreamble = translateFromScanResultToLocalPreamble(preamble);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the responder type, can be {@link #RESPONDER_AP} or {@link #RESPONDER_STA} or
|
|
* {@link #RESPONDER_AWARE}
|
|
*
|
|
* @param responderType the type of the responder, if not set defaults to
|
|
* {@link #RESPONDER_AP}
|
|
* @return the builder to facilitate chaining {@code builder.setXXX(..).setXXX(..)}.
|
|
*/
|
|
@NonNull
|
|
public Builder setResponderType(@ResponderType int responderType) {
|
|
if (!isResponderTypeSupported(responderType)) {
|
|
throw new IllegalArgumentException("invalid responder type " + responderType);
|
|
}
|
|
mResponderType = responderType;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the minimum time between IEEE 802.11az non-trigger based ranging measurements in
|
|
* microseconds for the responder.
|
|
*
|
|
* Note: This should be a multiple of 100 microseconds as per IEEE 802.11 az standard.
|
|
*
|
|
* @param ntbMinMeasurementTime Minimum time between non-trigger based IEEE 802.11az
|
|
* ranging measurements in units of 100 microseconds. Range of
|
|
* values (0, 419430400).
|
|
* @hide
|
|
*/
|
|
public Builder setNtbMinTimeBetweenMeasurementsMicros(long ntbMinMeasurementTime) {
|
|
if (mNtbMinMeasurementTime == 0 || mNtbMinMeasurementTime >= 419430400) {
|
|
throw new IllegalArgumentException(
|
|
"Should be a non-zero number less than 419430400 microseconds");
|
|
}
|
|
if (mNtbMinMeasurementTime % 100 != 0) {
|
|
throw new IllegalArgumentException("Should be a multiple of 100 microseconds");
|
|
}
|
|
mNtbMinMeasurementTime = ntbMinMeasurementTime;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the maximum time between IEEE 802.11az non-trigger based ranging measurements in
|
|
* microseconds for the responder.
|
|
*
|
|
* Note: This should be a multiple of 10000 microseconds (10 milliseconds) as per
|
|
* IEEE 802.11 az standard.
|
|
*
|
|
* @param ntbMaxMeasurementTime Maximum time between non-trigger based IEEE 802.11az
|
|
* ranging measurements in units of 10000 microseconds. Range
|
|
* of values (0, 5242880000).
|
|
* @hide
|
|
*/
|
|
public Builder setNtbMaxTimeBetweenMeasurementsMicros(long ntbMaxMeasurementTime) {
|
|
if (mNtbMaxMeasurementTime % 10000 != 0) {
|
|
throw new IllegalArgumentException("Should be a multiple of 10000 microseconds");
|
|
}
|
|
if (mNtbMaxMeasurementTime == 0 || mNtbMaxMeasurementTime >= 5242880000L) {
|
|
throw new IllegalArgumentException(
|
|
"Should be a non-zero number less than 5242880000 microseconds");
|
|
}
|
|
mNtbMaxMeasurementTime = ntbMaxMeasurementTime;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Build {@link ResponderConfig} given the current configurations made on the builder.
|
|
* @return an instance of {@link ResponderConfig}
|
|
*/
|
|
@NonNull
|
|
public ResponderConfig build() {
|
|
if ((mMacAddress == null && mPeerHandle == null)
|
|
|| (mMacAddress != null && mPeerHandle != null)) {
|
|
throw new IllegalArgumentException(
|
|
"Invalid ResponderConfig - must specify a MAC address or peer handle but "
|
|
+ "not both");
|
|
}
|
|
// For Aware, use supported default values
|
|
if (mResponderType == RESPONDER_AWARE) {
|
|
mSupports80211Mc = true;
|
|
mFrequency = AWARE_BAND_2_DISCOVERY_CHANNEL;
|
|
mChannelWidth = CHANNEL_WIDTH_20MHZ;
|
|
mPreamble = PREAMBLE_HT;
|
|
}
|
|
return new ResponderConfig(this);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(@NonNull Parcel dest, int flags) {
|
|
if (macAddress == null) {
|
|
dest.writeBoolean(false);
|
|
} else {
|
|
dest.writeBoolean(true);
|
|
macAddress.writeToParcel(dest, flags);
|
|
}
|
|
if (peerHandle == null) {
|
|
dest.writeBoolean(false);
|
|
} else {
|
|
dest.writeBoolean(true);
|
|
dest.writeInt(peerHandle.peerId);
|
|
}
|
|
dest.writeInt(responderType);
|
|
dest.writeBoolean(supports80211mc);
|
|
dest.writeBoolean(supports80211azNtb);
|
|
dest.writeInt(channelWidth);
|
|
dest.writeInt(frequency);
|
|
dest.writeInt(centerFreq0);
|
|
dest.writeInt(centerFreq1);
|
|
dest.writeInt(preamble);
|
|
dest.writeLong(mNtbMinMeasurementTime);
|
|
dest.writeLong(mNtbMaxMeasurementTime);
|
|
}
|
|
|
|
public static final @android.annotation.NonNull Creator<ResponderConfig> CREATOR = new Creator<ResponderConfig>() {
|
|
@Override
|
|
public ResponderConfig[] newArray(int size) {
|
|
return new ResponderConfig[size];
|
|
}
|
|
|
|
@Override
|
|
public ResponderConfig createFromParcel(Parcel in) {
|
|
boolean macAddressPresent = in.readBoolean();
|
|
MacAddress macAddress = null;
|
|
if (macAddressPresent) {
|
|
macAddress = MacAddress.CREATOR.createFromParcel(in);
|
|
}
|
|
boolean peerHandlePresent = in.readBoolean();
|
|
PeerHandle peerHandle = null;
|
|
if (peerHandlePresent) {
|
|
peerHandle = new PeerHandle(in.readInt());
|
|
}
|
|
|
|
return new ResponderConfig.Builder()
|
|
.setMacAddress(macAddress)
|
|
.setPeerHandle(peerHandle)
|
|
.setResponderType(in.readInt())
|
|
.set80211mcSupported(in.readBoolean())
|
|
.set80211azNtbSupported(in.readBoolean())
|
|
.setChannelWidth(in.readInt())
|
|
.setFrequencyMhz(in.readInt())
|
|
.setCenterFreq0Mhz(in.readInt())
|
|
.setCenterFreq1Mhz(in.readInt())
|
|
.setPreamble(in.readInt())
|
|
.setNtbMinTimeBetweenMeasurementsMicros(in.readLong())
|
|
.setNtbMaxTimeBetweenMeasurementsMicros(in.readLong())
|
|
.build();
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public boolean equals(@Nullable Object o) {
|
|
if (this == o) {
|
|
return true;
|
|
}
|
|
|
|
if (!(o instanceof ResponderConfig)) {
|
|
return false;
|
|
}
|
|
|
|
ResponderConfig lhs = (ResponderConfig) o;
|
|
|
|
return Objects.equals(macAddress, lhs.macAddress) && Objects.equals(peerHandle,
|
|
lhs.peerHandle) && responderType == lhs.responderType
|
|
&& supports80211mc == lhs.supports80211mc && channelWidth == lhs.channelWidth
|
|
&& frequency == lhs.frequency && centerFreq0 == lhs.centerFreq0
|
|
&& centerFreq1 == lhs.centerFreq1 && preamble == lhs.preamble
|
|
&& supports80211azNtb == lhs.supports80211azNtb
|
|
&& mNtbMinMeasurementTime == lhs.mNtbMinMeasurementTime
|
|
&& mNtbMaxMeasurementTime == lhs.mNtbMaxMeasurementTime;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(macAddress, peerHandle, responderType, supports80211mc, channelWidth,
|
|
frequency, centerFreq0, centerFreq1, preamble, supports80211azNtb,
|
|
mNtbMinMeasurementTime, mNtbMaxMeasurementTime);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return new StringBuffer("ResponderConfig: macAddress=").append(macAddress)
|
|
.append(", peerHandle=").append(peerHandle == null ? "<null>" : peerHandle.peerId)
|
|
.append(", responderType=").append(responderType)
|
|
.append(", supports80211mc=").append(supports80211mc)
|
|
.append(", channelWidth=").append(channelWidth)
|
|
.append(", frequency=").append(frequency)
|
|
.append(", centerFreq0=").append(centerFreq0)
|
|
.append(", centerFreq1=").append(centerFreq1)
|
|
.append(", preamble=").append(preamble)
|
|
.append(", supports80211azNtb=").append(supports80211azNtb)
|
|
.append(", mNtbMinMeasurementTime ").append(mNtbMinMeasurementTime)
|
|
.append(", mNtbMaxMeasurementTime ").append(mNtbMaxMeasurementTime)
|
|
.toString();
|
|
}
|
|
|
|
/**
|
|
* Translate an SDK channel width encoding to a local channel width encoding
|
|
*
|
|
* @param scanResultChannelWidth the {@link ScanResult} defined channel width encoding
|
|
* @return the translated channel width encoding
|
|
*
|
|
* @hide
|
|
*/
|
|
static int translateFromScanResultToLocalChannelWidth(
|
|
@WifiAnnotations.ChannelWidth int scanResultChannelWidth) {
|
|
switch (scanResultChannelWidth) {
|
|
case ScanResult.CHANNEL_WIDTH_20MHZ:
|
|
return CHANNEL_WIDTH_20MHZ;
|
|
case ScanResult.CHANNEL_WIDTH_40MHZ:
|
|
return CHANNEL_WIDTH_40MHZ;
|
|
case ScanResult.CHANNEL_WIDTH_80MHZ:
|
|
return CHANNEL_WIDTH_80MHZ;
|
|
case ScanResult.CHANNEL_WIDTH_160MHZ:
|
|
return CHANNEL_WIDTH_160MHZ;
|
|
case ScanResult.CHANNEL_WIDTH_80MHZ_PLUS_MHZ:
|
|
return CHANNEL_WIDTH_80MHZ_PLUS_MHZ;
|
|
case ScanResult.CHANNEL_WIDTH_320MHZ:
|
|
return CHANNEL_WIDTH_320MHZ;
|
|
default:
|
|
throw new IllegalArgumentException(
|
|
"translateFromScanResultChannelWidth: bad " + scanResultChannelWidth);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Translate the local channel width encoding to the SDK channel width encoding.
|
|
*
|
|
* @param localChannelWidth the locally defined channel width encoding
|
|
* @return the translated channel width encoding
|
|
*
|
|
* @hide
|
|
*/
|
|
static int translateFromLocalToScanResultChannelWidth(@ChannelWidth int localChannelWidth) {
|
|
switch (localChannelWidth) {
|
|
case CHANNEL_WIDTH_20MHZ:
|
|
return ScanResult.CHANNEL_WIDTH_20MHZ;
|
|
case CHANNEL_WIDTH_40MHZ:
|
|
return ScanResult.CHANNEL_WIDTH_40MHZ;
|
|
case CHANNEL_WIDTH_80MHZ:
|
|
return ScanResult.CHANNEL_WIDTH_80MHZ;
|
|
case CHANNEL_WIDTH_160MHZ:
|
|
return ScanResult.CHANNEL_WIDTH_160MHZ;
|
|
case CHANNEL_WIDTH_80MHZ_PLUS_MHZ:
|
|
return ScanResult.CHANNEL_WIDTH_80MHZ_PLUS_MHZ;
|
|
case CHANNEL_WIDTH_320MHZ:
|
|
return ScanResult.CHANNEL_WIDTH_320MHZ;
|
|
default:
|
|
throw new IllegalArgumentException(
|
|
"translateFromLocalChannelWidth: bad " + localChannelWidth);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Translate the {@link ScanResult} preamble encoding to the local preamble encoding.
|
|
*
|
|
* @param scanResultPreamble the channel width supplied
|
|
* @return the local encoding of the Preamble
|
|
*
|
|
* @hide
|
|
*/
|
|
static int translateFromScanResultToLocalPreamble(
|
|
@WifiAnnotations.PreambleType int scanResultPreamble) {
|
|
switch (scanResultPreamble) {
|
|
case ScanResult.PREAMBLE_LEGACY:
|
|
return PREAMBLE_LEGACY;
|
|
case ScanResult.PREAMBLE_HT:
|
|
return PREAMBLE_HT;
|
|
case ScanResult.PREAMBLE_VHT:
|
|
return PREAMBLE_VHT;
|
|
case ScanResult.PREAMBLE_HE:
|
|
return PREAMBLE_HE;
|
|
case ScanResult.PREAMBLE_EHT:
|
|
return PREAMBLE_EHT;
|
|
default:
|
|
throw new IllegalArgumentException(
|
|
"translateFromScanResultPreamble: bad " + scanResultPreamble);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Translate the local preamble encoding to the {@link ScanResult} preamble encoding.
|
|
*
|
|
* @param localPreamble the local preamble encoding
|
|
* @return the {@link ScanResult} encoding of the Preamble
|
|
*
|
|
* @hide
|
|
*/
|
|
static int translateFromLocalToScanResultPreamble(@PreambleType int localPreamble) {
|
|
switch (localPreamble) {
|
|
case PREAMBLE_LEGACY:
|
|
return ScanResult.PREAMBLE_LEGACY;
|
|
case PREAMBLE_HT:
|
|
return ScanResult.PREAMBLE_HT;
|
|
case PREAMBLE_VHT:
|
|
return ScanResult.PREAMBLE_VHT;
|
|
case PREAMBLE_HE:
|
|
return ScanResult.PREAMBLE_HE;
|
|
case PREAMBLE_EHT:
|
|
return ScanResult.PREAMBLE_EHT;
|
|
default:
|
|
throw new IllegalArgumentException(
|
|
"translateFromLocalPreamble: bad " + localPreamble);
|
|
}
|
|
}
|
|
}
|