| /* |
| * Copyright (C) 2021 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 com.android.server.wifi; |
| |
| import static com.android.server.wifi.hotspot2.anqp.Constants.ANQPElementType.ANQP3GPPNetwork; |
| import static com.android.server.wifi.hotspot2.anqp.Constants.ANQPElementType.ANQPDomName; |
| import static com.android.server.wifi.hotspot2.anqp.Constants.ANQPElementType.ANQPIPAddrAvailability; |
| import static com.android.server.wifi.hotspot2.anqp.Constants.ANQPElementType.ANQPNAIRealm; |
| import static com.android.server.wifi.hotspot2.anqp.Constants.ANQPElementType.ANQPRoamingConsortium; |
| import static com.android.server.wifi.hotspot2.anqp.Constants.ANQPElementType.ANQPVenueName; |
| import static com.android.server.wifi.hotspot2.anqp.Constants.ANQPElementType.ANQPVenueUrl; |
| import static com.android.server.wifi.hotspot2.anqp.Constants.ANQPElementType.HSConnCapability; |
| import static com.android.server.wifi.hotspot2.anqp.Constants.ANQPElementType.HSFriendlyName; |
| import static com.android.server.wifi.hotspot2.anqp.Constants.ANQPElementType.HSOSUProviders; |
| import static com.android.server.wifi.hotspot2.anqp.Constants.ANQPElementType.HSWANMetrics; |
| |
| import android.annotation.NonNull; |
| import android.content.Context; |
| import android.hardware.wifi.supplicant.AnqpData; |
| import android.hardware.wifi.supplicant.AssociationRejectionData; |
| import android.hardware.wifi.supplicant.AuxiliarySupplicantEventCode; |
| import android.hardware.wifi.supplicant.BssTmData; |
| import android.hardware.wifi.supplicant.BssTmDataFlagsMask; |
| import android.hardware.wifi.supplicant.BssTmStatusCode; |
| import android.hardware.wifi.supplicant.BssidChangeReason; |
| import android.hardware.wifi.supplicant.DppAkm; |
| import android.hardware.wifi.supplicant.DppConnectionKeys; |
| import android.hardware.wifi.supplicant.DppEventType; |
| import android.hardware.wifi.supplicant.DppFailureCode; |
| import android.hardware.wifi.supplicant.DppProgressCode; |
| import android.hardware.wifi.supplicant.Hs20AnqpData; |
| import android.hardware.wifi.supplicant.ISupplicantStaIfaceCallback; |
| import android.hardware.wifi.supplicant.MboAssocDisallowedReasonCode; |
| import android.hardware.wifi.supplicant.MboCellularDataConnectionPrefValue; |
| import android.hardware.wifi.supplicant.MboTransitionReasonCode; |
| import android.hardware.wifi.supplicant.QosPolicyData; |
| import android.hardware.wifi.supplicant.StaIfaceCallbackState; |
| import android.hardware.wifi.supplicant.StaIfaceReasonCode; |
| import android.hardware.wifi.supplicant.StaIfaceStatusCode; |
| import android.hardware.wifi.supplicant.WpsConfigError; |
| import android.hardware.wifi.supplicant.WpsErrorIndication; |
| import android.net.MacAddress; |
| import android.net.wifi.SecurityParams; |
| import android.net.wifi.SupplicantState; |
| import android.net.wifi.WifiConfiguration; |
| import android.net.wifi.WifiManager; |
| import android.net.wifi.WifiSsid; |
| import android.os.Process; |
| import android.util.Log; |
| |
| import com.android.server.wifi.SupplicantStaIfaceHal.QosPolicyRequest; |
| import com.android.server.wifi.SupplicantStaIfaceHal.SupplicantEventCode; |
| import com.android.server.wifi.hotspot2.AnqpEvent; |
| import com.android.server.wifi.hotspot2.IconEvent; |
| import com.android.server.wifi.hotspot2.WnmData; |
| import com.android.server.wifi.hotspot2.anqp.ANQPElement; |
| import com.android.server.wifi.hotspot2.anqp.ANQPParser; |
| import com.android.server.wifi.hotspot2.anqp.Constants; |
| import com.android.server.wifi.util.NativeUtil; |
| |
| import java.io.IOException; |
| import java.nio.BufferUnderflowException; |
| import java.nio.ByteBuffer; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| class SupplicantStaIfaceCallbackAidlImpl extends ISupplicantStaIfaceCallback.Stub { |
| private static final String TAG = "SupplicantStaIfaceCallbackAidlImpl"; |
| private final SupplicantStaIfaceHalAidlImpl mStaIfaceHal; |
| private final String mIfaceName; |
| private final Context mContext; |
| private final WifiMonitor mWifiMonitor; |
| private final Object mLock; |
| // Used to help check for PSK password mismatch & EAP connection failure. |
| private int mStateBeforeDisconnect = StaIfaceCallbackState.INACTIVE; |
| private String mCurrentSsid = null; |
| |
| SupplicantStaIfaceCallbackAidlImpl(@NonNull SupplicantStaIfaceHalAidlImpl staIfaceHal, |
| @NonNull String ifaceName, @NonNull Object lock, |
| @NonNull Context context, @NonNull WifiMonitor wifiMonitor) { |
| mStaIfaceHal = staIfaceHal; |
| mIfaceName = ifaceName; |
| mLock = lock; |
| mContext = context; |
| mWifiMonitor = wifiMonitor; |
| } |
| |
| @Override |
| public void onNetworkAdded(int id) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onNetworkAdded id=" + id); |
| } |
| } |
| |
| @Override |
| public void onNetworkRemoved(int id) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onNetworkRemoved id=" + id); |
| // Reset state since network has been removed. |
| mStateBeforeDisconnect = StaIfaceCallbackState.INACTIVE; |
| } |
| } |
| |
| /** |
| * Converts the supplicant state received from AIDL to the equivalent framework state. |
| */ |
| protected static SupplicantState supplicantAidlStateToFrameworkState(int state) { |
| switch (state) { |
| case StaIfaceCallbackState.DISCONNECTED: |
| return SupplicantState.DISCONNECTED; |
| case StaIfaceCallbackState.IFACE_DISABLED: |
| return SupplicantState.INTERFACE_DISABLED; |
| case StaIfaceCallbackState.INACTIVE: |
| return SupplicantState.INACTIVE; |
| case StaIfaceCallbackState.SCANNING: |
| return SupplicantState.SCANNING; |
| case StaIfaceCallbackState.AUTHENTICATING: |
| return SupplicantState.AUTHENTICATING; |
| case StaIfaceCallbackState.ASSOCIATING: |
| return SupplicantState.ASSOCIATING; |
| case StaIfaceCallbackState.ASSOCIATED: |
| return SupplicantState.ASSOCIATED; |
| case StaIfaceCallbackState.FOURWAY_HANDSHAKE: |
| return SupplicantState.FOUR_WAY_HANDSHAKE; |
| case StaIfaceCallbackState.GROUP_HANDSHAKE: |
| return SupplicantState.GROUP_HANDSHAKE; |
| case StaIfaceCallbackState.COMPLETED: |
| return SupplicantState.COMPLETED; |
| default: |
| throw new IllegalArgumentException("Invalid state: " + state); |
| } |
| } |
| |
| @Override |
| public void onStateChanged(int newState, byte[/* 6 */] bssid, int id, |
| byte[] ssid, boolean filsHlpSent) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onStateChanged"); |
| SupplicantState newSupplicantState = |
| supplicantAidlStateToFrameworkState(newState); |
| WifiSsid wifiSsid = WifiSsid.fromBytes(ssid); |
| String bssidStr = NativeUtil.macAddressFromByteArray(bssid); |
| if (newState != StaIfaceCallbackState.DISCONNECTED) { |
| // onStateChanged(DISCONNECTED) may come before onDisconnected(), so add this |
| // cache to track the state before the disconnect. |
| mStateBeforeDisconnect = newState; |
| } |
| |
| if (newState == StaIfaceCallbackState.ASSOCIATING |
| || newState == StaIfaceCallbackState.ASSOCIATED |
| || newState == StaIfaceCallbackState.COMPLETED) { |
| mStaIfaceHal.updateOnLinkedNetworkRoaming(mIfaceName, id, false); |
| } |
| |
| if (newState == StaIfaceCallbackState.COMPLETED) { |
| mWifiMonitor.broadcastNetworkConnectionEvent( |
| mIfaceName, mStaIfaceHal.getCurrentNetworkId(mIfaceName), filsHlpSent, |
| wifiSsid, bssidStr); |
| } else if (newState == StaIfaceCallbackState.ASSOCIATING) { |
| mCurrentSsid = NativeUtil.encodeSsid(NativeUtil.byteArrayToArrayList(ssid)); |
| } |
| mWifiMonitor.broadcastSupplicantStateChangeEvent( |
| mIfaceName, mStaIfaceHal.getCurrentNetworkId(mIfaceName), wifiSsid, |
| bssidStr, newSupplicantState); |
| } |
| } |
| |
| /** |
| * Parses the provided payload into an ANQP element. |
| * |
| * @param infoID Element type. |
| * @param payload Raw payload bytes. |
| * @return AnqpElement instance on success, null on failure. |
| */ |
| private ANQPElement parseAnqpElement(Constants.ANQPElementType infoID, byte[] payload) { |
| synchronized (mLock) { |
| try { |
| return Constants.getANQPElementID(infoID) != null |
| ? ANQPParser.parseElement(infoID, ByteBuffer.wrap(payload)) |
| : ANQPParser.parseHS20Element(infoID, ByteBuffer.wrap(payload)); |
| } catch (IOException | BufferUnderflowException e) { |
| Log.e(TAG, "Failed parsing ANQP element payload: " + infoID, e); |
| return null; |
| } |
| } |
| } |
| |
| /** |
| * Parse the ANQP element data and add to the provided elements map if successful. |
| * |
| * @param elementsMap Map to add the parsed out element to. |
| * @param infoID Element type. |
| * @param payload Raw payload bytes. |
| */ |
| private void addAnqpElementToMap(Map<Constants.ANQPElementType, ANQPElement> elementsMap, |
| Constants.ANQPElementType infoID, byte[] payload) { |
| synchronized (mLock) { |
| if (payload == null || payload.length == 0) { |
| return; |
| } |
| ANQPElement element = parseAnqpElement(infoID, payload); |
| if (element != null) { |
| elementsMap.put(infoID, element); |
| } |
| } |
| } |
| |
| @Override |
| public void onAnqpQueryDone(byte[/* 6 */] bssid, AnqpData data, Hs20AnqpData hs20Data) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onAnqpQueryDone"); |
| Map<Constants.ANQPElementType, ANQPElement> elementsMap = new HashMap<>(); |
| addAnqpElementToMap(elementsMap, ANQPVenueName, data.venueName); |
| addAnqpElementToMap(elementsMap, ANQPRoamingConsortium, data.roamingConsortium); |
| addAnqpElementToMap(elementsMap, ANQPIPAddrAvailability, data.ipAddrTypeAvailability); |
| addAnqpElementToMap(elementsMap, ANQPNAIRealm, data.naiRealm); |
| addAnqpElementToMap(elementsMap, ANQP3GPPNetwork, data.anqp3gppCellularNetwork); |
| addAnqpElementToMap(elementsMap, ANQPDomName, data.domainName); |
| addAnqpElementToMap(elementsMap, ANQPVenueUrl, data.venueUrl); |
| addAnqpElementToMap(elementsMap, HSFriendlyName, hs20Data.operatorFriendlyName); |
| addAnqpElementToMap(elementsMap, HSWANMetrics, hs20Data.wanMetrics); |
| addAnqpElementToMap(elementsMap, HSConnCapability, hs20Data.connectionCapability); |
| addAnqpElementToMap(elementsMap, HSOSUProviders, hs20Data.osuProvidersList); |
| mWifiMonitor.broadcastAnqpDoneEvent( |
| mIfaceName, new AnqpEvent(NativeUtil.macAddressToLong(bssid), elementsMap)); |
| } |
| } |
| |
| @Override |
| public void onHs20IconQueryDone(byte[/* 6 */] bssid, String fileName, byte[] data) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onHs20IconQueryDone"); |
| mWifiMonitor.broadcastIconDoneEvent( |
| mIfaceName, |
| new IconEvent(NativeUtil.macAddressToLong(bssid), fileName, data.length, data)); |
| } |
| } |
| |
| @Override |
| public void onHs20SubscriptionRemediation(byte[/* 6 */] bssid, byte osuMethod, String url) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onHs20SubscriptionRemediation"); |
| mWifiMonitor.broadcastWnmEvent( |
| mIfaceName, |
| WnmData.createRemediationEvent(NativeUtil.macAddressToLong(bssid), url, |
| osuMethod)); |
| } |
| } |
| |
| @Override |
| public void onHs20DeauthImminentNotice(byte[/* 6 */] bssid, int reasonCode, |
| int reAuthDelayInSec, String url) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onHs20DeauthImminentNotice"); |
| mWifiMonitor.broadcastWnmEvent( |
| mIfaceName, |
| WnmData.createDeauthImminentEvent(NativeUtil.macAddressToLong(bssid), url, |
| reasonCode == WnmData.ESS, reAuthDelayInSec)); |
| } |
| } |
| |
| @Override |
| public void onDisconnected(byte[/* 6 */] bssid, boolean locallyGenerated, int reasonCode) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onDisconnected"); |
| if (mStaIfaceHal.isVerboseLoggingEnabled()) { |
| Log.e(TAG, "onDisconnected state=" + mStateBeforeDisconnect |
| + " locallyGenerated=" + locallyGenerated |
| + " reasonCode=" + reasonCode); |
| } |
| WifiConfiguration curConfiguration = |
| mStaIfaceHal.getCurrentNetworkLocalConfig(mIfaceName); |
| if (curConfiguration != null) { |
| if (mStateBeforeDisconnect == StaIfaceCallbackState.FOURWAY_HANDSHAKE |
| && WifiConfigurationUtil.isConfigForPskNetwork(curConfiguration) |
| && (!locallyGenerated || reasonCode |
| != StaIfaceReasonCode.IE_IN_4WAY_DIFFERS)) { |
| mWifiMonitor.broadcastAuthenticationFailureEvent( |
| mIfaceName, WifiManager.ERROR_AUTH_FAILURE_WRONG_PSWD, -1, |
| mCurrentSsid, MacAddress.fromBytes(bssid)); |
| } else if (mStateBeforeDisconnect == StaIfaceCallbackState.ASSOCIATED |
| && WifiConfigurationUtil.isConfigForEapNetwork(curConfiguration)) { |
| mWifiMonitor.broadcastAuthenticationFailureEvent( |
| mIfaceName, WifiManager.ERROR_AUTH_FAILURE_EAP_FAILURE, -1, |
| mCurrentSsid, MacAddress.fromBytes(bssid)); |
| } |
| } |
| mWifiMonitor.broadcastNetworkDisconnectionEvent( |
| mIfaceName, locallyGenerated, halToFrameworkReasonCode(reasonCode), |
| mCurrentSsid, NativeUtil.macAddressFromByteArray(bssid)); |
| } |
| } |
| |
| private void handleAssocRejectEvent(AssocRejectEventInfo assocRejectInfo) { |
| boolean isWrongPwd = false; |
| WifiConfiguration curConfiguration = mStaIfaceHal.getCurrentNetworkLocalConfig(mIfaceName); |
| if (curConfiguration != null) { |
| if (!assocRejectInfo.timedOut) { |
| Log.d(TAG, "flush PMK cache due to association rejection for config id " |
| + curConfiguration.networkId + "."); |
| mStaIfaceHal.removePmkCacheEntry(curConfiguration.networkId); |
| } |
| // Special handling for WPA3-Personal networks. If the password is |
| // incorrect, the AP will send association rejection, with status code 1 |
| // (unspecified failure). In SAE networks, the password authentication |
| // is not related to the 4-way handshake. In this case, we will send an |
| // authentication failure event up. |
| if (assocRejectInfo.statusCode |
| == SupplicantStaIfaceHal.StaIfaceStatusCode.UNSPECIFIED_FAILURE) { |
| // Network Selection status is guaranteed to be initialized |
| SecurityParams params = curConfiguration.getNetworkSelectionStatus() |
| .getCandidateSecurityParams(); |
| if (params != null |
| && params.getSecurityType() == WifiConfiguration.SECURITY_TYPE_SAE) { |
| // If this is ever connected, the password should be correct. |
| isWrongPwd = !curConfiguration.getNetworkSelectionStatus().hasEverConnected(); |
| if (isWrongPwd) { |
| mStaIfaceHal.logCallback("SAE incorrect password"); |
| } else { |
| mStaIfaceHal.logCallback("SAE association rejection"); |
| } |
| } |
| } else if (assocRejectInfo.statusCode |
| == SupplicantStaIfaceHal.StaIfaceStatusCode.CHALLENGE_FAIL |
| && WifiConfigurationUtil.isConfigForWepNetwork(curConfiguration)) { |
| mStaIfaceHal.logCallback("WEP incorrect password"); |
| isWrongPwd = true; |
| } |
| } |
| |
| if (isWrongPwd) { |
| MacAddress bssidAsMacAddress; |
| try { |
| bssidAsMacAddress = MacAddress.fromString(assocRejectInfo.bssid); |
| } catch (IllegalArgumentException e) { |
| Log.e(TAG, "Invalid bssid obtained from supplicant " + assocRejectInfo.bssid); |
| bssidAsMacAddress = WifiManager.ALL_ZEROS_MAC_ADDRESS; |
| } |
| mWifiMonitor.broadcastAuthenticationFailureEvent( |
| mIfaceName, WifiManager.ERROR_AUTH_FAILURE_WRONG_PSWD, -1, |
| mCurrentSsid, bssidAsMacAddress); |
| } |
| mWifiMonitor.broadcastAssociationRejectionEvent(mIfaceName, assocRejectInfo); |
| mStateBeforeDisconnect = StaIfaceCallbackState.INACTIVE; |
| } |
| |
| @Override |
| public void onAssociationRejected(AssociationRejectionData assocRejectData) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onAssociationRejected"); |
| assocRejectData.statusCode = halToFrameworkStatusCode(assocRejectData.statusCode); |
| assocRejectData.mboAssocDisallowedReason = halToFrameworkMboAssocDisallowedReasonCode( |
| assocRejectData.mboAssocDisallowedReason); |
| AssocRejectEventInfo assocRejectInfo = new AssocRejectEventInfo(assocRejectData); |
| handleAssocRejectEvent(assocRejectInfo); |
| } |
| } |
| |
| @Override |
| public void onAuthenticationTimeout(byte[/* 6 */] bssid) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onAuthenticationTimeout"); |
| mWifiMonitor.broadcastAuthenticationFailureEvent( |
| mIfaceName, WifiManager.ERROR_AUTH_FAILURE_TIMEOUT, -1, |
| mCurrentSsid, MacAddress.fromBytes(bssid)); |
| } |
| } |
| |
| @Override |
| public void onBssidChanged(byte reason, byte[/* 6 */] bssid) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onBssidChanged"); |
| if (reason == BssidChangeReason.ASSOC_START) { |
| mWifiMonitor.broadcastTargetBssidEvent( |
| mIfaceName, NativeUtil.macAddressFromByteArray(bssid)); |
| } else if (reason == BssidChangeReason.ASSOC_COMPLETE) { |
| mWifiMonitor.broadcastAssociatedBssidEvent( |
| mIfaceName, NativeUtil.macAddressFromByteArray(bssid)); |
| } |
| } |
| } |
| |
| @Override |
| public void onEapFailure(byte[/* 6 */] bssid, int errorCode) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onEapFailure"); |
| try { |
| mWifiMonitor.broadcastAuthenticationFailureEvent( |
| mIfaceName, WifiManager.ERROR_AUTH_FAILURE_EAP_FAILURE, errorCode, |
| mCurrentSsid, MacAddress.fromBytes(bssid)); |
| } catch (IllegalArgumentException e) { |
| Log.i(TAG, "Invalid bssid received"); |
| } |
| } |
| } |
| |
| @Override |
| public void onWpsEventSuccess() { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onWpsEventSuccess"); |
| mWifiMonitor.broadcastWpsSuccessEvent(mIfaceName); |
| } |
| } |
| |
| @Override |
| public void onWpsEventFail(byte[/* 6 */] bssid, int configError, int errorInd) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onWpsEventFail"); |
| if (configError == WpsConfigError.MSG_TIMEOUT |
| && errorInd == WpsErrorIndication.NO_ERROR) { |
| mWifiMonitor.broadcastWpsTimeoutEvent(mIfaceName); |
| } else { |
| mWifiMonitor.broadcastWpsFailEvent(mIfaceName, configError, errorInd); |
| } |
| } |
| } |
| |
| @Override |
| public void onWpsEventPbcOverlap() { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onWpsEventPbcOverlap"); |
| mWifiMonitor.broadcastWpsOverlapEvent(mIfaceName); |
| } |
| } |
| |
| @Override |
| public void onExtRadioWorkStart(int id) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onExtRadioWorkStart"); |
| } |
| } |
| |
| @Override |
| public void onExtRadioWorkTimeout(int id) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onExtRadioWorkTimeout"); |
| } |
| } |
| |
| @Override |
| public void onDppSuccessConfigReceived(byte[] ssid, String password, |
| byte[] psk, int securityAkm, DppConnectionKeys keys) { |
| if (mStaIfaceHal.getDppCallback() == null) { |
| Log.e(TAG, "onDppSuccessConfigReceived callback is null"); |
| return; |
| } |
| |
| WifiConfiguration newWifiConfiguration = new WifiConfiguration(); |
| |
| // Set up SSID |
| WifiSsid wifiSsid = WifiSsid.fromBytes(ssid); |
| newWifiConfiguration.SSID = wifiSsid.toString(); |
| |
| // Set up password or PSK |
| if (password != null) { |
| newWifiConfiguration.preSharedKey = "\"" + password + "\""; |
| } else if (psk != null) { |
| newWifiConfiguration.preSharedKey = Arrays.toString(psk); |
| } |
| |
| // Set up key management: SAE or PSK or DPP |
| if (securityAkm == DppAkm.SAE) { |
| newWifiConfiguration.setSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE); |
| } else if (securityAkm == DppAkm.PSK_SAE || securityAkm == DppAkm.PSK) { |
| newWifiConfiguration.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); |
| } else if (securityAkm == DppAkm.DPP) { |
| newWifiConfiguration.setSecurityParams(WifiConfiguration.SECURITY_TYPE_DPP); |
| } else { |
| // No other AKMs are currently supported |
| onDppFailure(DppFailureCode.NOT_SUPPORTED, null, null, null); |
| return; |
| } |
| |
| // Set DPP connection Keys for SECURITY_TYPE_DPP |
| if (keys != null && securityAkm == DppAkm.DPP) { |
| newWifiConfiguration.setDppConnectionKeys(keys.connector, keys.cSign, |
| keys.netAccessKey); |
| } |
| |
| // Set up default values |
| newWifiConfiguration.creatorName = mContext.getPackageManager() |
| .getNameForUid(Process.WIFI_UID); |
| newWifiConfiguration.status = WifiConfiguration.Status.ENABLED; |
| |
| mStaIfaceHal.getDppCallback().onSuccessConfigReceived(newWifiConfiguration); |
| } |
| |
| @Override |
| public void onDppSuccessConfigSent() { |
| if (mStaIfaceHal.getDppCallback() != null) { |
| mStaIfaceHal.getDppCallback().onSuccess( |
| SupplicantStaIfaceHal.DppEventType.CONFIGURATION_SENT); |
| } else { |
| Log.e(TAG, "onSuccessConfigSent callback is null"); |
| } |
| } |
| |
| @Override |
| public void onDppProgress(int code) { |
| if (mStaIfaceHal.getDppCallback() != null) { |
| mStaIfaceHal.getDppCallback().onProgress(halToFrameworkDppProgressCode(code)); |
| } else { |
| Log.e(TAG, "onDppProgress callback is null"); |
| } |
| } |
| |
| @Override |
| public void onDppFailure(int code, String ssid, String channelList, char[] bandList) { |
| if (mStaIfaceHal.getDppCallback() != null) { |
| int[] bandListArray = null; |
| |
| // Convert char array to int array |
| if (bandList != null) { |
| bandListArray = new int[bandList.length]; |
| |
| for (int i = 0; i < bandList.length; i++) { |
| bandListArray[i] = bandList[i]; |
| } |
| } |
| mStaIfaceHal.getDppCallback().onFailure( |
| halToFrameworkDppFailureCode(code), ssid, channelList, bandListArray); |
| } else { |
| Log.e(TAG, "onDppFailure callback is null"); |
| } |
| } |
| |
| @Override |
| public void onPmkCacheAdded(long expirationTimeInSec, byte[] serializedEntry) { |
| WifiConfiguration curConfig = mStaIfaceHal.getCurrentNetworkLocalConfig(mIfaceName); |
| if (curConfig == null) { |
| return; |
| } |
| |
| SecurityParams params = curConfig.getNetworkSelectionStatus().getCandidateSecurityParams(); |
| if (params == null || params.isSecurityType(WifiConfiguration.SECURITY_TYPE_PSK) |
| || params.isSecurityType(WifiConfiguration.SECURITY_TYPE_DPP)) { |
| return; |
| } |
| |
| mStaIfaceHal.addPmkCacheEntry(mIfaceName, curConfig.networkId, expirationTimeInSec, |
| NativeUtil.byteArrayToArrayList(serializedEntry)); |
| mStaIfaceHal.logCallback( |
| "onPmkCacheAdded: update pmk cache for config id " |
| + curConfig.networkId + " on " + mIfaceName); |
| } |
| |
| @Override |
| public void onDppSuccess(int code) { |
| if (mStaIfaceHal.getDppCallback() != null) { |
| mStaIfaceHal.getDppCallback().onSuccess(halToFrameworkDppEventType(code)); |
| } else { |
| Log.e(TAG, "onDppSuccess callback is null"); |
| } |
| } |
| |
| private @MboOceConstants.BtmResponseStatus int halToFrameworkBtmResponseStatus(int status) { |
| switch (status) { |
| case BssTmStatusCode.ACCEPT: |
| return MboOceConstants.BTM_RESPONSE_STATUS_ACCEPT; |
| case BssTmStatusCode.REJECT_UNSPECIFIED: |
| return MboOceConstants.BTM_RESPONSE_STATUS_REJECT_UNSPECIFIED; |
| case BssTmStatusCode.REJECT_INSUFFICIENT_BEACON: |
| return MboOceConstants.BTM_RESPONSE_STATUS_REJECT_INSUFFICIENT_BEACON; |
| case BssTmStatusCode.REJECT_INSUFFICIENT_CAPABITY: |
| return MboOceConstants.BTM_RESPONSE_STATUS_REJECT_INSUFFICIENT_CAPABITY; |
| case BssTmStatusCode.REJECT_BSS_TERMINATION_UNDESIRED: |
| return MboOceConstants.BTM_RESPONSE_STATUS_REJECT_BSS_TERMINATION_UNDESIRED; |
| case BssTmStatusCode.REJECT_BSS_TERMINATION_DELAY_REQUEST: |
| return MboOceConstants.BTM_RESPONSE_STATUS_REJECT_BSS_TERMINATION_DELAY_REQUEST; |
| case BssTmStatusCode.REJECT_STA_CANDIDATE_LIST_PROVIDED: |
| return MboOceConstants.BTM_RESPONSE_STATUS_REJECT_STA_CANDIDATE_LIST_PROVIDED; |
| case BssTmStatusCode.REJECT_NO_SUITABLE_CANDIDATES: |
| return MboOceConstants.BTM_RESPONSE_STATUS_REJECT_NO_SUITABLE_CANDIDATES; |
| case BssTmStatusCode.REJECT_LEAVING_ESS: |
| return MboOceConstants.BTM_RESPONSE_STATUS_REJECT_LEAVING_ESS; |
| default: |
| return MboOceConstants.BTM_RESPONSE_STATUS_REJECT_RESERVED; |
| } |
| } |
| |
| private int halToFrameworkBssTmDataFlagsMask(int flags) { |
| int tmDataflags = 0; |
| if ((flags & BssTmDataFlagsMask.WNM_MODE_PREFERRED_CANDIDATE_LIST_INCLUDED) != 0) { |
| tmDataflags |= MboOceConstants.BTM_DATA_FLAG_PREFERRED_CANDIDATE_LIST_INCLUDED; |
| } |
| if ((flags & BssTmDataFlagsMask.WNM_MODE_ABRIDGED) != 0) { |
| tmDataflags |= MboOceConstants.BTM_DATA_FLAG_MODE_ABRIDGED; |
| } |
| if ((flags & BssTmDataFlagsMask.WNM_MODE_DISASSOCIATION_IMMINENT) != 0) { |
| tmDataflags |= MboOceConstants.BTM_DATA_FLAG_DISASSOCIATION_IMMINENT; |
| } |
| if ((flags & BssTmDataFlagsMask.WNM_MODE_BSS_TERMINATION_INCLUDED) != 0) { |
| tmDataflags |= MboOceConstants.BTM_DATA_FLAG_BSS_TERMINATION_INCLUDED; |
| } |
| if ((flags & BssTmDataFlagsMask.WNM_MODE_ESS_DISASSOCIATION_IMMINENT) != 0) { |
| tmDataflags |= MboOceConstants.BTM_DATA_FLAG_ESS_DISASSOCIATION_IMMINENT; |
| } |
| if ((flags & BssTmDataFlagsMask.MBO_TRANSITION_REASON_CODE_INCLUDED) != 0) { |
| tmDataflags |= MboOceConstants.BTM_DATA_FLAG_MBO_TRANSITION_REASON_CODE_INCLUDED; |
| } |
| if ((flags & BssTmDataFlagsMask.MBO_ASSOC_RETRY_DELAY_INCLUDED) != 0) { |
| tmDataflags |= MboOceConstants.BTM_DATA_FLAG_MBO_ASSOC_RETRY_DELAY_INCLUDED; |
| } |
| if ((flags & BssTmDataFlagsMask.MBO_CELLULAR_DATA_CONNECTION_PREFERENCE_INCLUDED) != 0) { |
| tmDataflags |= |
| MboOceConstants.BTM_DATA_FLAG_MBO_CELL_DATA_CONNECTION_PREFERENCE_INCLUDED; |
| } |
| return tmDataflags; |
| } |
| |
| private @MboOceConstants.MboTransitionReason int halToFrameworkMboTransitionReason( |
| int reason) { |
| switch (reason) { |
| case MboTransitionReasonCode.UNSPECIFIED: |
| return MboOceConstants.MBO_TRANSITION_REASON_UNSPECIFIED; |
| case MboTransitionReasonCode.EXCESSIVE_FRAME_LOSS: |
| return MboOceConstants.MBO_TRANSITION_REASON_EXCESSIVE_FRAME_LOSS; |
| case MboTransitionReasonCode.EXCESSIVE_TRAFFIC_DELAY: |
| return MboOceConstants.MBO_TRANSITION_REASON_EXCESSIVE_TRAFFIC_DELAY; |
| case MboTransitionReasonCode.INSUFFICIENT_BANDWIDTH: |
| return MboOceConstants.MBO_TRANSITION_REASON_INSUFFICIENT_BANDWIDTH; |
| case MboTransitionReasonCode.LOAD_BALANCING: |
| return MboOceConstants.MBO_TRANSITION_REASON_LOAD_BALANCING; |
| case MboTransitionReasonCode.LOW_RSSI: |
| return MboOceConstants.MBO_TRANSITION_REASON_LOW_RSSI; |
| case MboTransitionReasonCode.RX_EXCESSIVE_RETRIES: |
| return MboOceConstants.MBO_TRANSITION_REASON_RX_EXCESSIVE_RETRIES; |
| case MboTransitionReasonCode.HIGH_INTERFERENCE: |
| return MboOceConstants.MBO_TRANSITION_REASON_HIGH_INTERFERENCE; |
| case MboTransitionReasonCode.GRAY_ZONE: |
| return MboOceConstants.MBO_TRANSITION_REASON_GRAY_ZONE; |
| default: |
| return MboOceConstants.MBO_TRANSITION_REASON_RESERVED; |
| } |
| } |
| |
| private @MboOceConstants.MboTransitionReason int |
| halToFrameworkMboCellularDataConnectionPreference(int cellPref) { |
| switch (cellPref) { |
| case MboCellularDataConnectionPrefValue.EXCLUDED: |
| return MboOceConstants.MBO_CELLULAR_DATA_CONNECTION_EXCLUDED; |
| case MboCellularDataConnectionPrefValue.NOT_PREFERRED: |
| return MboOceConstants.MBO_CELLULAR_DATA_CONNECTION_NOT_PREFERRED; |
| case MboCellularDataConnectionPrefValue.PREFERRED: |
| return MboOceConstants.MBO_CELLULAR_DATA_CONNECTION_PREFERRED; |
| default: |
| return MboOceConstants.MBO_CELLULAR_DATA_CONNECTION_RESERVED; |
| } |
| } |
| |
| private int halToFrameworkDppEventType(int eventType) { |
| switch(eventType) { |
| case DppEventType.CONFIGURATION_SENT: |
| return SupplicantStaIfaceHal.DppEventType.CONFIGURATION_SENT; |
| case DppEventType.CONFIGURATION_APPLIED: |
| return SupplicantStaIfaceHal.DppEventType.CONFIGURATION_APPLIED; |
| default: |
| Log.e(TAG, "Invalid DppEventType received"); |
| return -1; |
| } |
| } |
| |
| private int halToFrameworkDppProgressCode(int progressCode) { |
| switch(progressCode) { |
| case DppProgressCode.AUTHENTICATION_SUCCESS: |
| return SupplicantStaIfaceHal.DppProgressCode.AUTHENTICATION_SUCCESS; |
| case DppProgressCode.RESPONSE_PENDING: |
| return SupplicantStaIfaceHal.DppProgressCode.RESPONSE_PENDING; |
| case DppProgressCode.CONFIGURATION_SENT_WAITING_RESPONSE: |
| return SupplicantStaIfaceHal.DppProgressCode.CONFIGURATION_SENT_WAITING_RESPONSE; |
| case DppProgressCode.CONFIGURATION_ACCEPTED: |
| return SupplicantStaIfaceHal.DppProgressCode.CONFIGURATION_ACCEPTED; |
| default: |
| Log.e(TAG, "Invalid DppProgressCode received"); |
| return -1; |
| } |
| } |
| |
| private int halToFrameworkDppFailureCode(int failureCode) { |
| switch(failureCode) { |
| case DppFailureCode.INVALID_URI: |
| return SupplicantStaIfaceHal.DppFailureCode.INVALID_URI; |
| case DppFailureCode.AUTHENTICATION: |
| return SupplicantStaIfaceHal.DppFailureCode.AUTHENTICATION; |
| case DppFailureCode.NOT_COMPATIBLE: |
| return SupplicantStaIfaceHal.DppFailureCode.NOT_COMPATIBLE; |
| case DppFailureCode.CONFIGURATION: |
| return SupplicantStaIfaceHal.DppFailureCode.CONFIGURATION; |
| case DppFailureCode.BUSY: |
| return SupplicantStaIfaceHal.DppFailureCode.BUSY; |
| case DppFailureCode.TIMEOUT: |
| return SupplicantStaIfaceHal.DppFailureCode.TIMEOUT; |
| case DppFailureCode.FAILURE: |
| return SupplicantStaIfaceHal.DppFailureCode.FAILURE; |
| case DppFailureCode.NOT_SUPPORTED: |
| return SupplicantStaIfaceHal.DppFailureCode.NOT_SUPPORTED; |
| case DppFailureCode.CONFIGURATION_REJECTED: |
| return SupplicantStaIfaceHal.DppFailureCode.CONFIGURATION_REJECTED; |
| case DppFailureCode.CANNOT_FIND_NETWORK: |
| return SupplicantStaIfaceHal.DppFailureCode.CANNOT_FIND_NETWORK; |
| case DppFailureCode.ENROLLEE_AUTHENTICATION: |
| return SupplicantStaIfaceHal.DppFailureCode.ENROLLEE_AUTHENTICATION; |
| case DppFailureCode.URI_GENERATION: |
| return SupplicantStaIfaceHal.DppFailureCode.URI_GENERATION; |
| default: |
| Log.e(TAG, "Invalid DppFailureCode received"); |
| return -1; |
| } |
| } |
| |
| private byte halToFrameworkMboAssocDisallowedReasonCode(byte reasonCode) { |
| switch (reasonCode) { |
| case MboAssocDisallowedReasonCode.RESERVED: |
| return SupplicantStaIfaceHal.MboAssocDisallowedReasonCode.RESERVED; |
| case MboAssocDisallowedReasonCode.UNSPECIFIED: |
| return SupplicantStaIfaceHal.MboAssocDisallowedReasonCode.UNSPECIFIED; |
| case MboAssocDisallowedReasonCode.MAX_NUM_STA_ASSOCIATED: |
| return SupplicantStaIfaceHal.MboAssocDisallowedReasonCode.MAX_NUM_STA_ASSOCIATED; |
| case MboAssocDisallowedReasonCode.AIR_INTERFACE_OVERLOADED: |
| return SupplicantStaIfaceHal.MboAssocDisallowedReasonCode.AIR_INTERFACE_OVERLOADED; |
| case MboAssocDisallowedReasonCode.AUTH_SERVER_OVERLOADED: |
| return SupplicantStaIfaceHal.MboAssocDisallowedReasonCode.AUTH_SERVER_OVERLOADED; |
| case MboAssocDisallowedReasonCode.INSUFFICIENT_RSSI: |
| return SupplicantStaIfaceHal.MboAssocDisallowedReasonCode.INSUFFICIENT_RSSI; |
| default: |
| Log.e(TAG, "Invalid MboAssocDisallowedReasonCode received"); |
| return -1; |
| } |
| } |
| |
| private int halToFrameworkReasonCode(int reason) { |
| switch (reason) { |
| case StaIfaceReasonCode.UNSPECIFIED: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.UNSPECIFIED; |
| case StaIfaceReasonCode.PREV_AUTH_NOT_VALID: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.PREV_AUTH_NOT_VALID; |
| case StaIfaceReasonCode.DEAUTH_LEAVING: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.DEAUTH_LEAVING; |
| case StaIfaceReasonCode.DISASSOC_DUE_TO_INACTIVITY: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.DISASSOC_DUE_TO_INACTIVITY; |
| case StaIfaceReasonCode.DISASSOC_AP_BUSY: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.DISASSOC_AP_BUSY; |
| case StaIfaceReasonCode.CLASS2_FRAME_FROM_NONAUTH_STA: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.CLASS2_FRAME_FROM_NONAUTH_STA; |
| case StaIfaceReasonCode.CLASS3_FRAME_FROM_NONASSOC_STA: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.CLASS3_FRAME_FROM_NONASSOC_STA; |
| case StaIfaceReasonCode.DISASSOC_STA_HAS_LEFT: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.DISASSOC_STA_HAS_LEFT; |
| case StaIfaceReasonCode.STA_REQ_ASSOC_WITHOUT_AUTH: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.STA_REQ_ASSOC_WITHOUT_AUTH; |
| case StaIfaceReasonCode.PWR_CAPABILITY_NOT_VALID: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.PWR_CAPABILITY_NOT_VALID; |
| case StaIfaceReasonCode.SUPPORTED_CHANNEL_NOT_VALID: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.SUPPORTED_CHANNEL_NOT_VALID; |
| case StaIfaceReasonCode.BSS_TRANSITION_DISASSOC: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.BSS_TRANSITION_DISASSOC; |
| case StaIfaceReasonCode.INVALID_IE: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.INVALID_IE; |
| case StaIfaceReasonCode.MICHAEL_MIC_FAILURE: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MICHAEL_MIC_FAILURE; |
| case StaIfaceReasonCode.FOURWAY_HANDSHAKE_TIMEOUT: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.FOURWAY_HANDSHAKE_TIMEOUT; |
| case StaIfaceReasonCode.GROUP_KEY_UPDATE_TIMEOUT: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.GROUP_KEY_UPDATE_TIMEOUT; |
| case StaIfaceReasonCode.IE_IN_4WAY_DIFFERS: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.IE_IN_4WAY_DIFFERS; |
| case StaIfaceReasonCode.GROUP_CIPHER_NOT_VALID: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.GROUP_CIPHER_NOT_VALID; |
| case StaIfaceReasonCode.PAIRWISE_CIPHER_NOT_VALID: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.PAIRWISE_CIPHER_NOT_VALID; |
| case StaIfaceReasonCode.AKMP_NOT_VALID: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.AKMP_NOT_VALID; |
| case StaIfaceReasonCode.UNSUPPORTED_RSN_IE_VERSION: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.UNSUPPORTED_RSN_IE_VERSION; |
| case StaIfaceReasonCode.INVALID_RSN_IE_CAPAB: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.INVALID_RSN_IE_CAPAB; |
| case StaIfaceReasonCode.IEEE_802_1X_AUTH_FAILED: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.IEEE_802_1X_AUTH_FAILED; |
| case StaIfaceReasonCode.CIPHER_SUITE_REJECTED: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.CIPHER_SUITE_REJECTED; |
| case StaIfaceReasonCode.TDLS_TEARDOWN_UNREACHABLE: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.TDLS_TEARDOWN_UNREACHABLE; |
| case StaIfaceReasonCode.TDLS_TEARDOWN_UNSPECIFIED: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.TDLS_TEARDOWN_UNSPECIFIED; |
| case StaIfaceReasonCode.SSP_REQUESTED_DISASSOC: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.SSP_REQUESTED_DISASSOC; |
| case StaIfaceReasonCode.NO_SSP_ROAMING_AGREEMENT: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.NO_SSP_ROAMING_AGREEMENT; |
| case StaIfaceReasonCode.BAD_CIPHER_OR_AKM: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.BAD_CIPHER_OR_AKM; |
| case StaIfaceReasonCode.NOT_AUTHORIZED_THIS_LOCATION: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.NOT_AUTHORIZED_THIS_LOCATION; |
| case StaIfaceReasonCode.SERVICE_CHANGE_PRECLUDES_TS: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.SERVICE_CHANGE_PRECLUDES_TS; |
| case StaIfaceReasonCode.UNSPECIFIED_QOS_REASON: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.UNSPECIFIED_QOS_REASON; |
| case StaIfaceReasonCode.NOT_ENOUGH_BANDWIDTH: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.NOT_ENOUGH_BANDWIDTH; |
| case StaIfaceReasonCode.DISASSOC_LOW_ACK: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.DISASSOC_LOW_ACK; |
| case StaIfaceReasonCode.EXCEEDED_TXOP: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.EXCEEDED_TXOP; |
| case StaIfaceReasonCode.STA_LEAVING: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.STA_LEAVING; |
| case StaIfaceReasonCode.END_TS_BA_DLS: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.END_TS_BA_DLS; |
| case StaIfaceReasonCode.UNKNOWN_TS_BA: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.UNKNOWN_TS_BA; |
| case StaIfaceReasonCode.TIMEOUT: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.TIMEOUT; |
| case StaIfaceReasonCode.PEERKEY_MISMATCH: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.PEERKEY_MISMATCH; |
| case StaIfaceReasonCode.AUTHORIZED_ACCESS_LIMIT_REACHED: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.AUTHORIZED_ACCESS_LIMIT_REACHED; |
| case StaIfaceReasonCode.EXTERNAL_SERVICE_REQUIREMENTS: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.EXTERNAL_SERVICE_REQUIREMENTS; |
| case StaIfaceReasonCode.INVALID_FT_ACTION_FRAME_COUNT: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.INVALID_FT_ACTION_FRAME_COUNT; |
| case StaIfaceReasonCode.INVALID_PMKID: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.INVALID_PMKID; |
| case StaIfaceReasonCode.INVALID_MDE: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.INVALID_MDE; |
| case StaIfaceReasonCode.INVALID_FTE: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.INVALID_FTE; |
| case StaIfaceReasonCode.MESH_PEERING_CANCELLED: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MESH_PEERING_CANCELLED; |
| case StaIfaceReasonCode.MESH_MAX_PEERS: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MESH_MAX_PEERS; |
| case StaIfaceReasonCode.MESH_CONFIG_POLICY_VIOLATION: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MESH_CONFIG_POLICY_VIOLATION; |
| case StaIfaceReasonCode.MESH_CLOSE_RCVD: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MESH_CLOSE_RCVD; |
| case StaIfaceReasonCode.MESH_MAX_RETRIES: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MESH_MAX_RETRIES; |
| case StaIfaceReasonCode.MESH_CONFIRM_TIMEOUT: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MESH_CONFIRM_TIMEOUT; |
| case StaIfaceReasonCode.MESH_INVALID_GTK: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MESH_INVALID_GTK; |
| case StaIfaceReasonCode.MESH_INCONSISTENT_PARAMS: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MESH_INCONSISTENT_PARAMS; |
| case StaIfaceReasonCode.MESH_INVALID_SECURITY_CAP: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MESH_INVALID_SECURITY_CAP; |
| case StaIfaceReasonCode.MESH_PATH_ERROR_NO_PROXY_INFO: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MESH_PATH_ERROR_NO_PROXY_INFO; |
| case StaIfaceReasonCode.MESH_PATH_ERROR_NO_FORWARDING_INFO: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MESH_PATH_ERROR_NO_FORWARDING_INFO; |
| case StaIfaceReasonCode.MESH_PATH_ERROR_DEST_UNREACHABLE: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MESH_PATH_ERROR_DEST_UNREACHABLE; |
| case StaIfaceReasonCode.MAC_ADDRESS_ALREADY_EXISTS_IN_MBSS: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MAC_ADDRESS_ALREADY_EXISTS_IN_MBSS; |
| case StaIfaceReasonCode.MESH_CHANNEL_SWITCH_REGULATORY_REQ: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MESH_CHANNEL_SWITCH_REGULATORY_REQ; |
| case StaIfaceReasonCode.MESH_CHANNEL_SWITCH_UNSPECIFIED: |
| return SupplicantStaIfaceHal.StaIfaceReasonCode.MESH_CHANNEL_SWITCH_UNSPECIFIED; |
| default: |
| Log.e(TAG, "Invalid reason code received"); |
| return -1; |
| } |
| } |
| |
| protected static int halToFrameworkStatusCode(int reason) { |
| switch (reason) { |
| case StaIfaceStatusCode.SUCCESS: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.SUCCESS; |
| case StaIfaceStatusCode.UNSPECIFIED_FAILURE: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.UNSPECIFIED_FAILURE; |
| case StaIfaceStatusCode.TDLS_WAKEUP_ALTERNATE: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.TDLS_WAKEUP_ALTERNATE; |
| case StaIfaceStatusCode.TDLS_WAKEUP_REJECT: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.TDLS_WAKEUP_REJECT; |
| case StaIfaceStatusCode.SECURITY_DISABLED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.SECURITY_DISABLED; |
| case StaIfaceStatusCode.UNACCEPTABLE_LIFETIME: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.UNACCEPTABLE_LIFETIME; |
| case StaIfaceStatusCode.NOT_IN_SAME_BSS: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.NOT_IN_SAME_BSS; |
| case StaIfaceStatusCode.CAPS_UNSUPPORTED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.CAPS_UNSUPPORTED; |
| case StaIfaceStatusCode.REASSOC_NO_ASSOC: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.REASSOC_NO_ASSOC; |
| case StaIfaceStatusCode.ASSOC_DENIED_UNSPEC: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.ASSOC_DENIED_UNSPEC; |
| case StaIfaceStatusCode.NOT_SUPPORTED_AUTH_ALG: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.NOT_SUPPORTED_AUTH_ALG; |
| case StaIfaceStatusCode.UNKNOWN_AUTH_TRANSACTION: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.UNKNOWN_AUTH_TRANSACTION; |
| case StaIfaceStatusCode.CHALLENGE_FAIL: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.CHALLENGE_FAIL; |
| case StaIfaceStatusCode.AUTH_TIMEOUT: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.AUTH_TIMEOUT; |
| case StaIfaceStatusCode.AP_UNABLE_TO_HANDLE_NEW_STA: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.AP_UNABLE_TO_HANDLE_NEW_STA; |
| case StaIfaceStatusCode.ASSOC_DENIED_RATES: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.ASSOC_DENIED_RATES; |
| case StaIfaceStatusCode.ASSOC_DENIED_NOSHORT: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.ASSOC_DENIED_NOSHORT; |
| case StaIfaceStatusCode.SPEC_MGMT_REQUIRED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.SPEC_MGMT_REQUIRED; |
| case StaIfaceStatusCode.PWR_CAPABILITY_NOT_VALID: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.PWR_CAPABILITY_NOT_VALID; |
| case StaIfaceStatusCode.SUPPORTED_CHANNEL_NOT_VALID: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.SUPPORTED_CHANNEL_NOT_VALID; |
| case StaIfaceStatusCode.ASSOC_DENIED_NO_SHORT_SLOT_TIME: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.ASSOC_DENIED_NO_SHORT_SLOT_TIME; |
| case StaIfaceStatusCode.ASSOC_DENIED_NO_HT: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.ASSOC_DENIED_NO_HT; |
| case StaIfaceStatusCode.R0KH_UNREACHABLE: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.R0KH_UNREACHABLE; |
| case StaIfaceStatusCode.ASSOC_DENIED_NO_PCO: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.ASSOC_DENIED_NO_PCO; |
| case StaIfaceStatusCode.ASSOC_REJECTED_TEMPORARILY: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.ASSOC_REJECTED_TEMPORARILY; |
| case StaIfaceStatusCode.ROBUST_MGMT_FRAME_POLICY_VIOLATION: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.ROBUST_MGMT_FRAME_POLICY_VIOLATION; |
| case StaIfaceStatusCode.UNSPECIFIED_QOS_FAILURE: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.UNSPECIFIED_QOS_FAILURE; |
| case StaIfaceStatusCode.DENIED_INSUFFICIENT_BANDWIDTH: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.DENIED_INSUFFICIENT_BANDWIDTH; |
| case StaIfaceStatusCode.DENIED_POOR_CHANNEL_CONDITIONS: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.DENIED_POOR_CHANNEL_CONDITIONS; |
| case StaIfaceStatusCode.DENIED_QOS_NOT_SUPPORTED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.DENIED_QOS_NOT_SUPPORTED; |
| case StaIfaceStatusCode.REQUEST_DECLINED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.REQUEST_DECLINED; |
| case StaIfaceStatusCode.INVALID_PARAMETERS: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.INVALID_PARAMETERS; |
| case StaIfaceStatusCode.REJECTED_WITH_SUGGESTED_CHANGES: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.REJECTED_WITH_SUGGESTED_CHANGES; |
| case StaIfaceStatusCode.INVALID_IE: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.INVALID_IE; |
| case StaIfaceStatusCode.GROUP_CIPHER_NOT_VALID: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.GROUP_CIPHER_NOT_VALID; |
| case StaIfaceStatusCode.PAIRWISE_CIPHER_NOT_VALID: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.PAIRWISE_CIPHER_NOT_VALID; |
| case StaIfaceStatusCode.AKMP_NOT_VALID: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.AKMP_NOT_VALID; |
| case StaIfaceStatusCode.UNSUPPORTED_RSN_IE_VERSION: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.UNSUPPORTED_RSN_IE_VERSION; |
| case StaIfaceStatusCode.INVALID_RSN_IE_CAPAB: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.INVALID_RSN_IE_CAPAB; |
| case StaIfaceStatusCode.CIPHER_REJECTED_PER_POLICY: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.CIPHER_REJECTED_PER_POLICY; |
| case StaIfaceStatusCode.TS_NOT_CREATED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.TS_NOT_CREATED; |
| case StaIfaceStatusCode.DIRECT_LINK_NOT_ALLOWED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.DIRECT_LINK_NOT_ALLOWED; |
| case StaIfaceStatusCode.DEST_STA_NOT_PRESENT: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.DEST_STA_NOT_PRESENT; |
| case StaIfaceStatusCode.DEST_STA_NOT_QOS_STA: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.DEST_STA_NOT_QOS_STA; |
| case StaIfaceStatusCode.ASSOC_DENIED_LISTEN_INT_TOO_LARGE: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.ASSOC_DENIED_LISTEN_INT_TOO_LARGE; |
| case StaIfaceStatusCode.INVALID_FT_ACTION_FRAME_COUNT: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.INVALID_FT_ACTION_FRAME_COUNT; |
| case StaIfaceStatusCode.INVALID_PMKID: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.INVALID_PMKID; |
| case StaIfaceStatusCode.INVALID_MDIE: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.INVALID_MDIE; |
| case StaIfaceStatusCode.INVALID_FTIE: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.INVALID_FTIE; |
| case StaIfaceStatusCode.REQUESTED_TCLAS_NOT_SUPPORTED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.REQUESTED_TCLAS_NOT_SUPPORTED; |
| case StaIfaceStatusCode.INSUFFICIENT_TCLAS_PROCESSING_RESOURCES: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode |
| .INSUFFICIENT_TCLAS_PROCESSING_RESOURCES; |
| case StaIfaceStatusCode.TRY_ANOTHER_BSS: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.TRY_ANOTHER_BSS; |
| case StaIfaceStatusCode.GAS_ADV_PROTO_NOT_SUPPORTED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.GAS_ADV_PROTO_NOT_SUPPORTED; |
| case StaIfaceStatusCode.NO_OUTSTANDING_GAS_REQ: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.NO_OUTSTANDING_GAS_REQ; |
| case StaIfaceStatusCode.GAS_RESP_NOT_RECEIVED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.GAS_RESP_NOT_RECEIVED; |
| case StaIfaceStatusCode.STA_TIMED_OUT_WAITING_FOR_GAS_RESP: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.STA_TIMED_OUT_WAITING_FOR_GAS_RESP; |
| case StaIfaceStatusCode.GAS_RESP_LARGER_THAN_LIMIT: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.GAS_RESP_LARGER_THAN_LIMIT; |
| case StaIfaceStatusCode.REQ_REFUSED_HOME: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.REQ_REFUSED_HOME; |
| case StaIfaceStatusCode.ADV_SRV_UNREACHABLE: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.ADV_SRV_UNREACHABLE; |
| case StaIfaceStatusCode.REQ_REFUSED_SSPN: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.REQ_REFUSED_SSPN; |
| case StaIfaceStatusCode.REQ_REFUSED_UNAUTH_ACCESS: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.REQ_REFUSED_UNAUTH_ACCESS; |
| case StaIfaceStatusCode.INVALID_RSNIE: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.INVALID_RSNIE; |
| case StaIfaceStatusCode.U_APSD_COEX_NOT_SUPPORTED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.U_APSD_COEX_NOT_SUPPORTED; |
| case StaIfaceStatusCode.U_APSD_COEX_MODE_NOT_SUPPORTED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.U_APSD_COEX_MODE_NOT_SUPPORTED; |
| case StaIfaceStatusCode.BAD_INTERVAL_WITH_U_APSD_COEX: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.BAD_INTERVAL_WITH_U_APSD_COEX; |
| case StaIfaceStatusCode.ANTI_CLOGGING_TOKEN_REQ: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.ANTI_CLOGGING_TOKEN_REQ; |
| case StaIfaceStatusCode.FINITE_CYCLIC_GROUP_NOT_SUPPORTED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.FINITE_CYCLIC_GROUP_NOT_SUPPORTED; |
| case StaIfaceStatusCode.CANNOT_FIND_ALT_TBTT: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.CANNOT_FIND_ALT_TBTT; |
| case StaIfaceStatusCode.TRANSMISSION_FAILURE: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.TRANSMISSION_FAILURE; |
| case StaIfaceStatusCode.REQ_TCLAS_NOT_SUPPORTED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.REQ_TCLAS_NOT_SUPPORTED; |
| case StaIfaceStatusCode.TCLAS_RESOURCES_EXCHAUSTED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.TCLAS_RESOURCES_EXCHAUSTED; |
| case StaIfaceStatusCode.REJECTED_WITH_SUGGESTED_BSS_TRANSITION: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode |
| .REJECTED_WITH_SUGGESTED_BSS_TRANSITION; |
| case StaIfaceStatusCode.REJECT_WITH_SCHEDULE: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.REJECT_WITH_SCHEDULE; |
| case StaIfaceStatusCode.REJECT_NO_WAKEUP_SPECIFIED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.REJECT_NO_WAKEUP_SPECIFIED; |
| case StaIfaceStatusCode.SUCCESS_POWER_SAVE_MODE: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.SUCCESS_POWER_SAVE_MODE; |
| case StaIfaceStatusCode.PENDING_ADMITTING_FST_SESSION: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.PENDING_ADMITTING_FST_SESSION; |
| case StaIfaceStatusCode.PERFORMING_FST_NOW: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.PERFORMING_FST_NOW; |
| case StaIfaceStatusCode.PENDING_GAP_IN_BA_WINDOW: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.PENDING_GAP_IN_BA_WINDOW; |
| case StaIfaceStatusCode.REJECT_U_PID_SETTING: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.REJECT_U_PID_SETTING; |
| case StaIfaceStatusCode.REFUSED_EXTERNAL_REASON: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.REFUSED_EXTERNAL_REASON; |
| case StaIfaceStatusCode.REFUSED_AP_OUT_OF_MEMORY: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.REFUSED_AP_OUT_OF_MEMORY; |
| case StaIfaceStatusCode.REJECTED_EMERGENCY_SERVICE_NOT_SUPPORTED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode |
| .REJECTED_EMERGENCY_SERVICE_NOT_SUPPORTED; |
| case StaIfaceStatusCode.QUERY_RESP_OUTSTANDING: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.QUERY_RESP_OUTSTANDING; |
| case StaIfaceStatusCode.REJECT_DSE_BAND: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.REJECT_DSE_BAND; |
| case StaIfaceStatusCode.TCLAS_PROCESSING_TERMINATED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.TCLAS_PROCESSING_TERMINATED; |
| case StaIfaceStatusCode.TS_SCHEDULE_CONFLICT: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.TS_SCHEDULE_CONFLICT; |
| case StaIfaceStatusCode.DENIED_WITH_SUGGESTED_BAND_AND_CHANNEL: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode |
| .DENIED_WITH_SUGGESTED_BAND_AND_CHANNEL; |
| case StaIfaceStatusCode.MCCAOP_RESERVATION_CONFLICT: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.MCCAOP_RESERVATION_CONFLICT; |
| case StaIfaceStatusCode.MAF_LIMIT_EXCEEDED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.MAF_LIMIT_EXCEEDED; |
| case StaIfaceStatusCode.MCCA_TRACK_LIMIT_EXCEEDED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.MCCA_TRACK_LIMIT_EXCEEDED; |
| case StaIfaceStatusCode.DENIED_DUE_TO_SPECTRUM_MANAGEMENT: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.DENIED_DUE_TO_SPECTRUM_MANAGEMENT; |
| case StaIfaceStatusCode.ASSOC_DENIED_NO_VHT: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.ASSOC_DENIED_NO_VHT; |
| case StaIfaceStatusCode.ENABLEMENT_DENIED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.ENABLEMENT_DENIED; |
| case StaIfaceStatusCode.RESTRICTION_FROM_AUTHORIZED_GDB: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.RESTRICTION_FROM_AUTHORIZED_GDB; |
| case StaIfaceStatusCode.AUTHORIZATION_DEENABLED: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.AUTHORIZATION_DEENABLED; |
| case StaIfaceStatusCode.FILS_AUTHENTICATION_FAILURE: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.FILS_AUTHENTICATION_FAILURE; |
| case StaIfaceStatusCode.UNKNOWN_AUTHENTICATION_SERVER: |
| return SupplicantStaIfaceHal.StaIfaceStatusCode.UNKNOWN_AUTHENTICATION_SERVER; |
| default: |
| Log.e(TAG, "Invalid status code received"); |
| return -1; |
| } |
| } |
| |
| private static @SupplicantEventCode int halAuxiliaryEventToFrameworkSupplicantEventCode( |
| int eventCode) { |
| switch (eventCode) { |
| case AuxiliarySupplicantEventCode.EAP_METHOD_SELECTED: |
| return SupplicantStaIfaceHal.SUPPLICANT_EVENT_EAP_METHOD_SELECTED; |
| case AuxiliarySupplicantEventCode.SSID_TEMP_DISABLED: |
| return SupplicantStaIfaceHal.SUPPLICANT_EVENT_SSID_TEMP_DISABLED; |
| case AuxiliarySupplicantEventCode.OPEN_SSL_FAILURE: |
| return SupplicantStaIfaceHal.SUPPLICANT_EVENT_OPEN_SSL_FAILURE; |
| default: |
| Log.e(TAG, "Invalid auxiliary event code received"); |
| return -1; |
| } |
| } |
| |
| @Override |
| public void onBssTmHandlingDone(BssTmData tmData) { |
| MboOceController.BtmFrameData btmFrmData = new MboOceController.BtmFrameData(); |
| |
| btmFrmData.mStatus = halToFrameworkBtmResponseStatus(tmData.status); |
| btmFrmData.mBssTmDataFlagsMask = halToFrameworkBssTmDataFlagsMask(tmData.flags); |
| btmFrmData.mBlockListDurationMs = tmData.assocRetryDelayMs; |
| if ((tmData.flags & BssTmDataFlagsMask.MBO_TRANSITION_REASON_CODE_INCLUDED) != 0) { |
| btmFrmData.mTransitionReason = halToFrameworkMboTransitionReason( |
| tmData.mboTransitionReason); |
| } |
| if ((tmData.flags |
| & BssTmDataFlagsMask.MBO_CELLULAR_DATA_CONNECTION_PREFERENCE_INCLUDED) != 0) { |
| btmFrmData.mCellPreference = |
| halToFrameworkMboCellularDataConnectionPreference(tmData.mboCellPreference); |
| } |
| mStaIfaceHal.logCallback( |
| "onBssTmHandlingDone: Handle BTM handling event"); |
| mWifiMonitor.broadcastBssTmHandlingDoneEvent(mIfaceName, btmFrmData); |
| } |
| |
| @Override |
| public void onHs20TermsAndConditionsAcceptanceRequestedNotification(byte[/* 6 */] bssid, |
| String url) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onHs20TermsAndConditionsAcceptanceRequestedNotification"); |
| mWifiMonitor.broadcastWnmEvent(mIfaceName, |
| WnmData.createTermsAndConditionsAccetanceRequiredEvent( |
| NativeUtil.macAddressToLong(bssid), url)); |
| } |
| } |
| |
| @Override |
| public void onNetworkNotFound(byte[] ssid) { |
| mStaIfaceHal.logCallback("onNetworkNotFoundNotification"); |
| mWifiMonitor.broadcastNetworkNotFoundEvent(mIfaceName, |
| NativeUtil.encodeSsid(NativeUtil.byteArrayToArrayList(ssid))); |
| } |
| |
| @Override |
| public void onQosPolicyReset() { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onQosPolicyReset"); |
| mWifiMonitor.broadcastQosPolicyResetEvent(mIfaceName); |
| } |
| } |
| |
| @Override |
| public void onQosPolicyRequest(int qosPolicyRequestId, QosPolicyData[] qosPolicyData) { |
| synchronized (mLock) { |
| mStaIfaceHal.logCallback("onQosPolicyRequest"); |
| // Convert QoS policies from HAL to framework representation. |
| List<QosPolicyRequest> frameworkQosPolicies = new ArrayList(); |
| if (qosPolicyData != null) { |
| for (QosPolicyData halPolicy : qosPolicyData) { |
| frameworkQosPolicies.add( |
| SupplicantStaIfaceHalAidlImpl.halToFrameworkQosPolicy(halPolicy)); |
| } |
| } |
| mWifiMonitor.broadcastQosPolicyRequestEvent(mIfaceName, qosPolicyRequestId, |
| frameworkQosPolicies); |
| } |
| } |
| |
| @Override |
| public void onAuxiliarySupplicantEvent(int eventCode, byte[] bssid, |
| String reasonString) { |
| synchronized (mLock) { |
| @SupplicantEventCode int supplicantEventCode = |
| halAuxiliaryEventToFrameworkSupplicantEventCode(eventCode); |
| mStaIfaceHal.logCallback("onAuxiliarySupplicantEvent event=" + supplicantEventCode); |
| if (supplicantEventCode != -1) { |
| try { |
| mWifiMonitor.broadcastAuxiliarySupplicantEvent(mIfaceName, supplicantEventCode, |
| MacAddress.fromBytes(bssid), reasonString); |
| } catch (IllegalArgumentException e) { |
| Log.i(TAG, "Invalid bssid received"); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public String getInterfaceHash() { |
| return ISupplicantStaIfaceCallback.HASH; |
| } |
| |
| @Override |
| public int getInterfaceVersion() { |
| return ISupplicantStaIfaceCallback.VERSION; |
| } |
| } |
