android.net.wifi.RttManager Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-all Show documentation
Show all versions of android-all Show documentation
A library jar that provides APIs for Applications written for the Google Android Platform.
package android.net.wifi;
import android.annotation.SystemApi;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.os.Messenger;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.RemoteException;
import android.util.Log;
import android.util.SparseArray;
import com.android.internal.util.AsyncChannel;
import com.android.internal.util.Protocol;
import java.util.concurrent.CountDownLatch;
/** @hide */
@SystemApi
public class RttManager {
private static final boolean DBG = true;
private static final String TAG = "RttManager";
/** @deprecated It is Not supported anymore. */
@Deprecated
public static final int RTT_TYPE_UNSPECIFIED = 0;
public static final int RTT_TYPE_ONE_SIDED = 1;
public static final int RTT_TYPE_TWO_SIDED = 2;
/** @deprecated It is not supported anymore. */
@Deprecated
public static final int RTT_TYPE_11_V = 2;
/** @deprecated It is not supported anymore. */
@Deprecated
public static final int RTT_TYPE_11_MC = 4;
/** @deprecated It is not supported anymore. */
@Deprecated
public static final int RTT_PEER_TYPE_UNSPECIFIED = 0;
public static final int RTT_PEER_TYPE_AP = 1;
public static final int RTT_PEER_TYPE_STA = 2; /* requires NAN */
public static final int RTT_PEER_P2P_GO = 3;
public static final int RTT_PEER_P2P_CLIENT = 4;
public static final int RTT_PEER_NAN = 5;
/**
* @deprecated It is not supported anymore.
* Use {@link android.net.wifi.RttManager#RTT_BW_20_SUPPORT} API.
*/
@Deprecated
public static final int RTT_CHANNEL_WIDTH_20 = 0;
/**
* @deprecated It is not supported anymore.
* Use {@link android.net.wifi.RttManager#RTT_BW_40_SUPPORT} API.
*/
@Deprecated
public static final int RTT_CHANNEL_WIDTH_40 = 1;
/**
* @deprecated It is not supported anymore.
* Use {@link android.net.wifi.RttManager#RTT_BW_80_SUPPORT} API.
*/
@Deprecated
public static final int RTT_CHANNEL_WIDTH_80 = 2;
/**@deprecated It is not supported anymore.
* Use {@link android.net.wifi.RttManager#RTT_BW_160_SUPPORT} API.
*/
@Deprecated
public static final int RTT_CHANNEL_WIDTH_160 = 3;
/**@deprecated not supported anymore*/
@Deprecated
public static final int RTT_CHANNEL_WIDTH_80P80 = 4;
/**@deprecated It is not supported anymore.
* Use {@link android.net.wifi.RttManager#RTT_BW_5_SUPPORT} API.
*/
@Deprecated
public static final int RTT_CHANNEL_WIDTH_5 = 5;
/**@deprecated It is not supported anymore.
* Use {@link android.net.wifi.RttManager#RTT_BW_10_SUPPORT} API.
*/
@Deprecated
public static final int RTT_CHANNEL_WIDTH_10 = 6;
/** @deprecated channel info must be specified. */
@Deprecated
public static final int RTT_CHANNEL_WIDTH_UNSPECIFIED = -1;
public static final int RTT_STATUS_SUCCESS = 0;
/** General failure*/
public static final int RTT_STATUS_FAILURE = 1;
/** Destination does not respond to RTT request*/
public static final int RTT_STATUS_FAIL_NO_RSP = 2;
/** RTT request is rejected by the destination. Double side RTT only*/
public static final int RTT_STATUS_FAIL_REJECTED = 3;
/** */
public static final int RTT_STATUS_FAIL_NOT_SCHEDULED_YET = 4;
/** Timing measurement timeout*/
public static final int RTT_STATUS_FAIL_TM_TIMEOUT = 5;
/** Destination is on a different channel from the RTT Request*/
public static final int RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL = 6;
/** This type of Ranging is not support by Hardware*/
public static final int RTT_STATUS_FAIL_NO_CAPABILITY = 7;
/** Request abort fro uncertain reason*/
public static final int RTT_STATUS_ABORTED = 8;
/** The T1-T4 or TOD/TOA Timestamp is illegal*/
public static final int RTT_STATUS_FAIL_INVALID_TS = 9;
/** 11mc protocol level failed, eg, unrecognized FTMR/FTM frame*/
public static final int RTT_STATUS_FAIL_PROTOCOL = 10;
/** Request can not be scheduled by hardware*/
public static final int RTT_STATUS_FAIL_SCHEDULE = 11;
/** destination is busy now, you can try after a specified time from destination*/
public static final int RTT_STATUS_FAIL_BUSY_TRY_LATER = 12;
/** Bad Request argument*/
public static final int RTT_STATUS_INVALID_REQ = 13;
/** Wifi is not enabled*/
public static final int RTT_STATUS_NO_WIFI = 14;
/** Responder overrides param info, cannot range with new params 2-side RTT only*/
public static final int RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE = 15;
public static final int REASON_UNSPECIFIED = -1;
public static final int REASON_NOT_AVAILABLE = -2;
public static final int REASON_INVALID_LISTENER = -3;
public static final int REASON_INVALID_REQUEST = -4;
/** Do not have required permission */
public static final int REASON_PERMISSION_DENIED = -5;
public static final String DESCRIPTION_KEY = "android.net.wifi.RttManager.Description";
/**
* RTT BW supported bit mask, used as RTT param bandWidth too
*/
public static final int RTT_BW_5_SUPPORT = 0x01;
public static final int RTT_BW_10_SUPPORT = 0x02;
public static final int RTT_BW_20_SUPPORT = 0x04;
public static final int RTT_BW_40_SUPPORT = 0x08;
public static final int RTT_BW_80_SUPPORT = 0x10;
public static final int RTT_BW_160_SUPPORT = 0x20;
/**
* RTT Preamble Support bit mask
*/
public static final int PREAMBLE_LEGACY = 0x01;
public static final int PREAMBLE_HT = 0x02;
public static final int PREAMBLE_VHT = 0x04;
/** @deprecated Use the new {@link android.net.wifi.RttManager.RttCapabilities} API */
@Deprecated
public class Capabilities {
public int supportedType;
public int supportedPeerType;
}
/** @deprecated Use the new {@link android.net.wifi.RttManager#getRttCapabilities()} API.*/
@Deprecated
public Capabilities getCapabilities() {
return new Capabilities();
}
/**
* This class describe the RTT capability of the Hardware
*/
public static class RttCapabilities implements Parcelable {
/** @deprecated It is not supported*/
@Deprecated
public boolean supportedType;
/** @deprecated It is not supported*/
@Deprecated
public boolean supportedPeerType;
//1-sided rtt measurement is supported
public boolean oneSidedRttSupported;
//11mc 2-sided rtt measurement is supported
public boolean twoSided11McRttSupported;
//location configuration information supported
public boolean lciSupported;
//location civic records supported
public boolean lcrSupported;
//preamble supported, see bit mask definition above
public int preambleSupported;
//RTT bandwidth supported
public int bwSupported;
@Override
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append("oneSidedRtt ").
append(oneSidedRttSupported ? "is Supported. " : "is not supported. ").
append("twoSided11McRtt ").
append(twoSided11McRttSupported ? "is Supported. " : "is not supported. ").
append("lci ").
append(lciSupported ? "is Supported. " : "is not supported. ").
append("lcr ").
append(lcrSupported ? "is Supported. " : "is not supported. ");
if ((preambleSupported & PREAMBLE_LEGACY) != 0) {
sb.append("Legacy ");
}
if ((preambleSupported & PREAMBLE_HT) != 0) {
sb.append("HT ");
}
if ((preambleSupported & PREAMBLE_VHT) != 0) {
sb.append("VHT ");
}
sb.append("is supported. \n");
if ((bwSupported & RTT_BW_5_SUPPORT) != 0) {
sb.append("5 MHz ");
}
if ((bwSupported & RTT_BW_10_SUPPORT) != 0) {
sb.append("10 MHz ");
}
if ((bwSupported & RTT_BW_20_SUPPORT) != 0) {
sb.append("20 MHz ");
}
if ((bwSupported & RTT_BW_40_SUPPORT) != 0) {
sb.append("40 MHz ");
}
if ((bwSupported & RTT_BW_80_SUPPORT) != 0) {
sb.append("80 MHz ");
}
if ((bwSupported & RTT_BW_160_SUPPORT) != 0) {
sb.append("160 MHz ");
}
sb.append("is supported.");
return sb.toString();
}
/** Implement the Parcelable interface {@hide} */
@Override
public int describeContents() {
return 0;
}
/** Implement the Parcelable interface {@hide} */
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(oneSidedRttSupported ? 1 : 0);
dest.writeInt(twoSided11McRttSupported ? 1 : 0);
dest.writeInt(lciSupported ? 1 : 0);
dest.writeInt(lcrSupported ? 1 : 0);
dest.writeInt(preambleSupported);
dest.writeInt(bwSupported);
}
/** Implement the Parcelable interface {@hide} */
public static final Creator CREATOR =
new Creator() {
public RttCapabilities createFromParcel(Parcel in) {
RttCapabilities capabilities = new RttCapabilities();
capabilities.oneSidedRttSupported = in.readInt() == 1 ? true : false;
capabilities.twoSided11McRttSupported = in.readInt() == 1 ? true : false;
capabilities.lciSupported = in.readInt() == 1 ? true : false;
capabilities.lcrSupported = in.readInt() == 1 ? true : false;
capabilities.preambleSupported = in.readInt();
capabilities.bwSupported = in.readInt();
return capabilities;
}
/** Implement the Parcelable interface {@hide} */
@Override
public RttCapabilities[] newArray(int size) {
return new RttCapabilities[size];
}
};
}
public RttCapabilities getRttCapabilities() {
synchronized (sCapabilitiesLock) {
if (mRttCapabilities == null) {
try {
mRttCapabilities = mService.getRttCapabilities();
} catch (RemoteException e) {
Log.e(TAG, "Can not get RTT Capabilities");
}
}
return mRttCapabilities;
}
}
/** specifies parameters for RTT request */
public static class RttParams {
/**
* type of destination device being ranged
* currently only support RTT_PEER_TYPE_AP
* Range:RTT_PEER_TYPE_xxxx Default value:RTT_PEER_TYPE_AP
*/
public int deviceType;
/**
* type of RTT measurement method. Need check scan result and RttCapabilities first
* Range: RTT_TYPE_ONE_SIDED or RTT_TYPE_TWO_SIDED
* Default value: RTT_TYPE_ONE_SIDED
*/
public int requestType;
/**
* mac address of the device being ranged
* Default value: null
*/
public String bssid;
/**
* The primary control channel over which the client is
* communicating with the AP.Same as ScanResult.frequency
* Default value: 0
*/
public int frequency;
/**
* channel width of the destination AP. Same as ScanResult.channelWidth
* Default value: 0
*/
public int channelWidth;
/**
* Not used if the AP bandwidth is 20 MHz
* If the AP use 40, 80 or 160 MHz, this is the center frequency
* if the AP use 80 + 80 MHz, this is the center frequency of the first segment
* same as ScanResult.centerFreq0
* Default value: 0
*/
public int centerFreq0;
/**
* Only used if the AP bandwidth is 80 + 80 MHz
* if the AP use 80 + 80 MHz, this is the center frequency of the second segment
* same as ScanResult.centerFreq1
* Default value: 0
*/
public int centerFreq1;
/**
* number of samples to be taken
* @deprecated Use the new {@link android.net.wifi.RttManager.RttParams#numSamplesPerBurst}
*/
@Deprecated
public int num_samples;
/**
* number of retries if a sample fails
* @deprecated
* Use {@link android.net.wifi.RttManager.RttParams#numRetriesPerMeasurementFrame} API.
*/
@Deprecated
public int num_retries;
/** Number of burst in exp , 2^x. 0 means single shot measurement, range 0-15
* Currently only single shot is supported
* Default value: 0
*/
public int numberBurst;
/**
* valid only if numberBurst > 1, interval between burst(100ms).
* Range : 0-31, 0--means no specific
* Default value: 0
*/
public int interval;
/**
* number of samples to be taken in one burst
* Range: 1-31
* Default value: 8
*/
public int numSamplesPerBurst;
/** number of retries for each measurement frame if a sample fails
* Only used by single side RTT,
* Range 0 - 3 Default value: 0
*/
public int numRetriesPerMeasurementFrame;
/**
* number of retries for FTMR frame (control frame) if it fails.
* Only used by 80211MC double side RTT
* Range: 0-3 Default Value : 0
*/
public int numRetriesPerFTMR;
/**
* Request LCI information, only available when choose double side RTT measurement
* need check RttCapabilties first.
* Default value: false
* */
public boolean LCIRequest;
/**
* Request LCR information, only available when choose double side RTT measurement
* need check RttCapabilties first.
* Default value: false
* */
public boolean LCRRequest;
/**
* Timeout for each burst, (250 * 2^x) us,
* Range 1-11 and 15. 15 means no control Default value: 15
* */
public int burstTimeout;
/** preamble used for RTT measurement
* Range: PREAMBLE_LEGACY, PREAMBLE_HT, PREAMBLE_VHT
* Default value: PREAMBLE_HT
*/
public int preamble;
/** bandWidth used for RTT measurement.User need verify the highest BW the destination
* support (from scan result etc) before set this value. Wider channels result usually give
* better accuracy. However, the frame loss can increase too.
* should be one of RTT_BW_5_SUPPORT to RTT_BW_160_SUPPORT. However, need check
* RttCapabilities firstto verify HW support this bandwidth.
* Default value:RTT_BW_20_SUPPORT
*/
public int bandwidth;
public RttParams() {
//provide initial value for RttParams
deviceType = RTT_PEER_TYPE_AP;
requestType = RTT_TYPE_ONE_SIDED;
numberBurst = 0;
numSamplesPerBurst = 8;
numRetriesPerMeasurementFrame = 0;
numRetriesPerFTMR = 0;
burstTimeout = 15;
preamble = PREAMBLE_HT;
bandwidth = RTT_BW_20_SUPPORT;
}
}
/** pseudo-private class used to parcel arguments */
public static class ParcelableRttParams implements Parcelable {
public RttParams mParams[];
ParcelableRttParams(RttParams[] params) {
mParams = params;
}
/** Implement the Parcelable interface {@hide} */
public int describeContents() {
return 0;
}
/** Implement the Parcelable interface {@hide} */
public void writeToParcel(Parcel dest, int flags) {
if (mParams != null) {
dest.writeInt(mParams.length);
for (RttParams params : mParams) {
dest.writeInt(params.deviceType);
dest.writeInt(params.requestType);
dest.writeString(params.bssid);
dest.writeInt(params.channelWidth);
dest.writeInt(params.frequency);
dest.writeInt(params.centerFreq0);
dest.writeInt(params.centerFreq1);
dest.writeInt(params.numberBurst);
dest.writeInt(params.interval);
dest.writeInt(params.numSamplesPerBurst);
dest.writeInt(params.numRetriesPerMeasurementFrame);
dest.writeInt(params.numRetriesPerFTMR);
dest.writeInt(params.LCIRequest ? 1 : 0);
dest.writeInt(params.LCRRequest ? 1 : 0);
dest.writeInt(params.burstTimeout);
dest.writeInt(params.preamble);
dest.writeInt(params.bandwidth);
}
} else {
dest.writeInt(0);
}
}
/** Implement the Parcelable interface {@hide} */
public static final Creator CREATOR =
new Creator() {
public ParcelableRttParams createFromParcel(Parcel in) {
int num = in.readInt();
if (num == 0) {
return new ParcelableRttParams(null);
}
RttParams params[] = new RttParams[num];
for (int i = 0; i < num; i++) {
params[i] = new RttParams();
params[i].deviceType = in.readInt();
params[i].requestType = in.readInt();
params[i].bssid = in.readString();
params[i].channelWidth = in.readInt();
params[i].frequency = in.readInt();
params[i].centerFreq0 = in.readInt();
params[i].centerFreq1 = in.readInt();
params[i].numberBurst = in.readInt();
params[i].interval = in.readInt();
params[i].numSamplesPerBurst = in.readInt();
params[i].numRetriesPerMeasurementFrame = in.readInt();
params[i].numRetriesPerFTMR = in.readInt();
params[i].LCIRequest = in.readInt() == 1 ? true : false;
params[i].LCRRequest = in.readInt() == 1 ? true : false;
params[i].burstTimeout = in.readInt();
params[i].preamble = in.readInt();
params[i].bandwidth = in.readInt();
}
ParcelableRttParams parcelableParams = new ParcelableRttParams(params);
return parcelableParams;
}
public ParcelableRttParams[] newArray(int size) {
return new ParcelableRttParams[size];
}
};
}
public static class WifiInformationElement {
/** Information Element ID 0xFF means element is invalid. */
public byte id;
public byte[] data;
}
/** specifies RTT results */
public static class RttResult {
/** mac address of the device being ranged. */
public String bssid;
/** # of burst for this measurement. */
public int burstNumber;
/** total number of measurement frames attempted in this measurement. */
public int measurementFrameNumber;
/** total successful number of measurement frames in this measurement. */
public int successMeasurementFrameNumber;
/**
* Maximum number of frames per burst supported by peer. Two side RTT only
* Valid only if less than request
*/
public int frameNumberPerBurstPeer;
/** status of the request */
public int status;
/**
* type of the request used
* @deprecated Use {@link android.net.wifi.RttManager.RttResult#measurementType}
*/
@Deprecated
public int requestType;
/** RTT measurement method type used, should be one of RTT_TYPE_ONE_SIDED or
* RTT_TYPE_TWO_SIDED.
*/
public int measurementType;
/**
* only valid when status == RTT_STATUS_FAIL_BUSY_TRY_LATER
* please retry RTT measurement after this duration since peer indicate busy at ths moment
* Unit S Range:1-31
*/
public int retryAfterDuration;
/** timestamp of completion, in microsecond since boot. */
public long ts;
/** average RSSI observed, unit of 0.5 dB. */
public int rssi;
/**
* RSSI spread (i.e. max - min)
* @deprecated Use {@link android.net.wifi.RttManager.RttResult#rssiSpread} API.
*/
@Deprecated
public int rssi_spread;
/**RSSI spread (i.e. max - min), unit of 0.5 dB. */
public int rssiSpread;
/**
* average transmit rate
* @deprecated Use {@link android.net.wifi.RttManager.RttResult#txRate} API.
*/
@Deprecated
public int tx_rate;
/** average transmit rate. Unit (100kbps). */
public int txRate;
/** average receiving rate Unit (100kbps). */
public int rxRate;
/**
* average round trip time in nano second
* @deprecated Use {@link android.net.wifi.RttManager.RttResult#rtt} API.
*/
@Deprecated
public long rtt_ns;
/** average round trip time in 0.1 nano second. */
public long rtt;
/**
* standard deviation observed in round trip time
* @deprecated Use {@link android.net.wifi.RttManager.RttResult#rttStandardDeviation} API.
*/
@Deprecated
public long rtt_sd_ns;
/** standard deviation of RTT in 0.1 ns. */
public long rttStandardDeviation;
/**
* spread (i.e. max - min) round trip time
* @deprecated Use {@link android.net.wifi.RttManager.RttResult#rttSpread} API.
*/
@Deprecated
public long rtt_spread_ns;
/** spread (i.e. max - min) RTT in 0.1 ns. */
public long rttSpread;
/**
* average distance in centimeter, computed based on rtt_ns
* @deprecated use {@link android.net.wifi.RttManager.RttResult#distance} API.
*/
@Deprecated
public int distance_cm;
/** average distance in cm, computed based on rtt. */
public int distance;
/**
* standard deviation observed in distance
* @deprecated
* Use {@link .android.net.wifi.RttManager.RttResult#distanceStandardDeviation} API.
*/
@Deprecated
public int distance_sd_cm;
/** standard deviation observed in distance in cm. */
public int distanceStandardDeviation;
/**
* spread (i.e. max - min) distance
* @deprecate Use {@link android.net.wifi.RttManager.RttResult#distanceSpread} API.
*/
@Deprecated
public int distance_spread_cm;
/** spread (i.e. max - min) distance in cm. */
public int distanceSpread;
/** the duration of this measurement burst, unit ms. */
public int burstDuration;
/** Burst number supported by peer after negotiation, 2side RTT only*/
public int negotiatedBurstNum;
/** LCI information Element, only available for double side RTT. */
public WifiInformationElement LCI;
/** LCR information Element, only available to double side RTT. */
public WifiInformationElement LCR;
}
/** pseudo-private class used to parcel results. */
public static class ParcelableRttResults implements Parcelable {
public RttResult mResults[];
public ParcelableRttResults(RttResult[] results) {
mResults = results;
}
/** Implement the Parcelable interface {@hide} */
public int describeContents() {
return 0;
}
/** Implement the Parcelable interface {@hide} */
public void writeToParcel(Parcel dest, int flags) {
if (mResults != null) {
dest.writeInt(mResults.length);
for (RttResult result : mResults) {
dest.writeString(result.bssid);
dest.writeInt(result.burstNumber);
dest.writeInt(result.measurementFrameNumber);
dest.writeInt(result.successMeasurementFrameNumber);
dest.writeInt(result.frameNumberPerBurstPeer);
dest.writeInt(result.status);
dest.writeInt(result.measurementType);
dest.writeInt(result.retryAfterDuration);
dest.writeLong(result.ts);
dest.writeInt(result.rssi);
dest.writeInt(result.rssiSpread);
dest.writeInt(result.txRate);
dest.writeLong(result.rtt);
dest.writeLong(result.rttStandardDeviation);
dest.writeLong(result.rttSpread);
dest.writeInt(result.distance);
dest.writeInt(result.distanceStandardDeviation);
dest.writeInt(result.distanceSpread);
dest.writeInt(result.burstDuration);
dest.writeInt(result.negotiatedBurstNum);
dest.writeByte(result.LCI.id);
if (result.LCI.id != (byte) 0xFF) {
dest.writeByte((byte)result.LCI.data.length);
dest.writeByteArray(result.LCI.data);
}
dest.writeByte(result.LCR.id);
if (result.LCR.id != (byte) 0xFF) {
dest.writeInt((byte) result.LCR.data.length);
dest.writeByte(result.LCR.id);
}
}
} else {
dest.writeInt(0);
}
}
/** Implement the Parcelable interface {@hide} */
public static final Creator CREATOR =
new Creator() {
public ParcelableRttResults createFromParcel(Parcel in) {
int num = in.readInt();
if (num == 0) {
return new ParcelableRttResults(null);
}
RttResult results[] = new RttResult[num];
for (int i = 0; i < num; i++) {
results[i] = new RttResult();
results[i].bssid = in.readString();
results[i].burstNumber = in.readInt();
results[i].measurementFrameNumber = in.readInt();
results[i].successMeasurementFrameNumber = in.readInt();
results[i].frameNumberPerBurstPeer = in.readInt();
results[i].status = in.readInt();
results[i].measurementType = in.readInt();
results[i].retryAfterDuration = in.readInt();
results[i].ts = in.readLong();
results[i].rssi = in.readInt();
results[i].rssiSpread = in.readInt();
results[i].txRate = in.readInt();
results[i].rtt = in.readLong();
results[i].rttStandardDeviation = in.readLong();
results[i].rttSpread = in.readLong();
results[i].distance = in.readInt();
results[i].distanceStandardDeviation = in.readInt();
results[i].distanceSpread = in.readInt();
results[i].burstDuration = in.readInt();
results[i].negotiatedBurstNum = in.readInt();
results[i].LCI = new WifiInformationElement();
results[i].LCI.id = in.readByte();
if (results[i].LCI.id != (byte) 0xFF) {
byte length = in.readByte();
results[i].LCI.data = new byte[length];
in.readByteArray(results[i].LCI.data);
}
results[i].LCR = new WifiInformationElement();
results[i].LCR.id = in.readByte();
if (results[i].LCR.id != (byte) 0xFF) {
byte length = in.readByte();
results[i].LCR.data = new byte[length];
in.readByteArray(results[i].LCR.data);
}
}
ParcelableRttResults parcelableResults = new ParcelableRttResults(results);
return parcelableResults;
}
public ParcelableRttResults[] newArray(int size) {
return new ParcelableRttResults[size];
}
};
}
public static interface RttListener {
public void onSuccess(RttResult[] results);
public void onFailure(int reason, String description);
public void onAborted();
}
private boolean rttParamSanity(RttParams params, int index) {
if (mRttCapabilities == null) {
if(getRttCapabilities() == null) {
Log.e(TAG, "Can not get RTT capabilities");
throw new IllegalStateException("RTT chip is not working");
}
}
if (params.deviceType != RTT_PEER_TYPE_AP) {
return false;
} else if (params.requestType != RTT_TYPE_ONE_SIDED && params.requestType !=
RTT_TYPE_TWO_SIDED) {
Log.e(TAG, "Request " + index + ": Illegal Request Type: " + params.requestType);
return false;
} else if (params.requestType == RTT_TYPE_ONE_SIDED &&
!mRttCapabilities.oneSidedRttSupported) {
Log.e(TAG, "Request " + index + ": One side RTT is not supported");
return false;
} else if (params.requestType == RTT_TYPE_TWO_SIDED &&
!mRttCapabilities.twoSided11McRttSupported) {
Log.e(TAG, "Request " + index + ": two side RTT is not supported");
return false;
} else if(params.bssid == null || params.bssid.isEmpty()) {
Log.e(TAG,"No BSSID in params");
return false;
} else if ( params.numberBurst != 0 ) {
Log.e(TAG, "Request " + index + ": Illegal number of burst: " + params.numberBurst);
return false;
} else if (params.numSamplesPerBurst <= 0 || params.numSamplesPerBurst > 31) {
Log.e(TAG, "Request " + index + ": Illegal sample number per burst: " +
params.numSamplesPerBurst);
return false;
} else if (params.numRetriesPerMeasurementFrame < 0 ||
params.numRetriesPerMeasurementFrame > 3) {
Log.e(TAG, "Request " + index + ": Illegal measurement frame retry number:" +
params.numRetriesPerMeasurementFrame);
return false;
} else if(params.numRetriesPerFTMR < 0 ||
params.numRetriesPerFTMR > 3) {
Log.e(TAG, "Request " + index + ": Illegal FTMR frame retry number:" +
params.numRetriesPerFTMR);
return false;
} else if (params.LCIRequest && !mRttCapabilities.lciSupported) {
Log.e(TAG, "Request " + index + ": LCI is not supported");
return false;
} else if (params.LCRRequest && !mRttCapabilities.lcrSupported) {
Log.e(TAG, "Request " + index + ": LCR is not supported");
return false;
} else if (params.burstTimeout < 1 ||
(params.burstTimeout > 11 && params.burstTimeout != 15)){
Log.e(TAG, "Request " + index + ": Illegal burst timeout: " + params.burstTimeout);
return false;
} else if ((params.preamble & mRttCapabilities.preambleSupported) == 0) {
Log.e(TAG, "Request " + index + ": Do not support this preamble: " + params.preamble);
return false;
} else if ((params.bandwidth & mRttCapabilities.bwSupported) == 0) {
Log.e(TAG, "Request " + index + ": Do not support this bandwidth: " + params.bandwidth);
return false;
}
return true;
}
/**
* Request to start an RTT ranging
*
* @param params -- RTT request Parameters
* @param listener -- Call back to inform RTT result
* @exception throw IllegalArgumentException when params are illegal
* throw IllegalStateException when RttCapabilities do not exist
*/
public void startRanging(RttParams[] params, RttListener listener) {
int index = 0;
for(RttParams rttParam : params) {
if (!rttParamSanity(rttParam, index)) {
throw new IllegalArgumentException("RTT Request Parameter Illegal");
}
index++;
}
validateChannel();
ParcelableRttParams parcelableParams = new ParcelableRttParams(params);
Log.i(TAG, "Send RTT request to RTT Service");
sAsyncChannel.sendMessage(CMD_OP_START_RANGING,
0, putListener(listener), parcelableParams);
}
public void stopRanging(RttListener listener) {
validateChannel();
sAsyncChannel.sendMessage(CMD_OP_STOP_RANGING, 0, removeListener(listener));
}
/* private methods */
public static final int BASE = Protocol.BASE_WIFI_RTT_MANAGER;
public static final int CMD_OP_START_RANGING = BASE + 0;
public static final int CMD_OP_STOP_RANGING = BASE + 1;
public static final int CMD_OP_FAILED = BASE + 2;
public static final int CMD_OP_SUCCEEDED = BASE + 3;
public static final int CMD_OP_ABORTED = BASE + 4;
private Context mContext;
private IRttManager mService;
private RttCapabilities mRttCapabilities;
private static final int INVALID_KEY = 0;
private static int sListenerKey = 1;
private static final SparseArray sListenerMap = new SparseArray();
private static final Object sListenerMapLock = new Object();
private static final Object sCapabilitiesLock = new Object();
private static AsyncChannel sAsyncChannel;
private static CountDownLatch sConnected;
private static final Object sThreadRefLock = new Object();
private static int sThreadRefCount;
private static HandlerThread sHandlerThread;
/**
* Create a new WifiScanner instance.
* Applications will almost always want to use
* {@link android.content.Context#getSystemService Context.getSystemService()} to retrieve
* the standard {@link android.content.Context#WIFI_RTT_SERVICE Context.WIFI_RTT_SERVICE}.
* @param context the application context
* @param service the Binder interface
* @hide
*/
public RttManager(Context context, IRttManager service) {
mContext = context;
mService = service;
init();
}
private void init() {
synchronized (sThreadRefLock) {
if (++sThreadRefCount == 1) {
Messenger messenger = null;
try {
Log.d(TAG, "Get the messenger from " + mService);
messenger = mService.getMessenger();
} catch (RemoteException e) {
/* do nothing */
} catch (SecurityException e) {
/* do nothing */
}
if (messenger == null) {
sAsyncChannel = null;
return;
}
sHandlerThread = new HandlerThread("RttManager");
sAsyncChannel = new AsyncChannel();
sConnected = new CountDownLatch(1);
sHandlerThread.start();
Handler handler = new ServiceHandler(sHandlerThread.getLooper());
sAsyncChannel.connect(mContext, handler, messenger);
try {
sConnected.await();
} catch (InterruptedException e) {
Log.e(TAG, "interrupted wait at init");
}
}
}
}
private void validateChannel() {
if (sAsyncChannel == null) throw new IllegalStateException(
"No permission to access and change wifi or a bad initialization");
}
private static int putListener(Object listener) {
if (listener == null) return INVALID_KEY;
int key;
synchronized (sListenerMapLock) {
do {
key = sListenerKey++;
} while (key == INVALID_KEY);
sListenerMap.put(key, listener);
}
return key;
}
private static Object getListener(int key) {
if (key == INVALID_KEY) return null;
synchronized (sListenerMapLock) {
Object listener = sListenerMap.get(key);
return listener;
}
}
private static int getListenerKey(Object listener) {
if (listener == null) return INVALID_KEY;
synchronized (sListenerMapLock) {
int index = sListenerMap.indexOfValue(listener);
if (index == -1) {
return INVALID_KEY;
} else {
return sListenerMap.keyAt(index);
}
}
}
private static Object removeListener(int key) {
if (key == INVALID_KEY) return null;
synchronized (sListenerMapLock) {
Object listener = sListenerMap.get(key);
sListenerMap.remove(key);
return listener;
}
}
private static int removeListener(Object listener) {
int key = getListenerKey(listener);
if (key == INVALID_KEY) return key;
synchronized (sListenerMapLock) {
sListenerMap.remove(key);
return key;
}
}
private static class ServiceHandler extends Handler {
ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
Log.i(TAG, "RTT manager get message: " + msg.what);
switch (msg.what) {
case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED:
if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) {
sAsyncChannel.sendMessage(AsyncChannel.CMD_CHANNEL_FULL_CONNECTION);
} else {
Log.e(TAG, "Failed to set up channel connection");
// This will cause all further async API calls on the WifiManager
// to fail and throw an exception
sAsyncChannel = null;
}
sConnected.countDown();
return;
case AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED:
return;
case AsyncChannel.CMD_CHANNEL_DISCONNECTED:
Log.e(TAG, "Channel connection lost");
// This will cause all further async API calls on the WifiManager
// to fail and throw an exception
sAsyncChannel = null;
getLooper().quit();
return;
}
Object listener = getListener(msg.arg2);
if (listener == null) {
Log.e(TAG, "invalid listener key = " + msg.arg2 );
return;
} else {
Log.i(TAG, "listener key = " + msg.arg2);
}
switch (msg.what) {
/* ActionListeners grouped together */
case CMD_OP_SUCCEEDED :
reportSuccess(listener, msg);
removeListener(msg.arg2);
break;
case CMD_OP_FAILED :
reportFailure(listener, msg);
removeListener(msg.arg2);
break;
case CMD_OP_ABORTED :
((RttListener) listener).onAborted();
removeListener(msg.arg2);
break;
default:
if (DBG) Log.d(TAG, "Ignoring message " + msg.what);
return;
}
}
void reportSuccess(Object listener, Message msg) {
RttListener rttListener = (RttListener) listener;
ParcelableRttResults parcelableResults = (ParcelableRttResults) msg.obj;
((RttListener) listener).onSuccess(parcelableResults.mResults);
}
void reportFailure(Object listener, Message msg) {
RttListener rttListener = (RttListener) listener;
Bundle bundle = (Bundle) msg.obj;
((RttListener) listener).onFailure(msg.arg1, bundle.getString(DESCRIPTION_KEY));
}
}
}