diff options
28 files changed, 1032 insertions, 204 deletions
diff --git a/framework/java/android/net/wifi/IWifiManager.aidl b/framework/java/android/net/wifi/IWifiManager.aidl index 2382f94382..9e126e3c95 100644 --- a/framework/java/android/net/wifi/IWifiManager.aidl +++ b/framework/java/android/net/wifi/IWifiManager.aidl @@ -228,9 +228,10 @@ interface IWifiManager { boolean isMulticastEnabled(); - void acquireMulticastLock(IBinder binder, String tag); + void acquireMulticastLock( + IBinder binder, String lockTag, String attributionTag, String packageName); - void releaseMulticastLock(IBinder binder, String tag); + void releaseMulticastLock(IBinder binder, String lockTag); void updateInterfaceIpState(String ifaceName, int mode); diff --git a/framework/java/android/net/wifi/WifiManager.java b/framework/java/android/net/wifi/WifiManager.java index 0ebf06fa5d..c642e04dc8 100644 --- a/framework/java/android/net/wifi/WifiManager.java +++ b/framework/java/android/net/wifi/WifiManager.java @@ -8465,7 +8465,8 @@ public class WifiManager { synchronized (mBinder) { if (mRefCounted ? (++mRefCount == 1) : (!mHeld)) { try { - mService.acquireMulticastLock(mBinder, mTag); + mService.acquireMulticastLock(mBinder, mTag, + mContext.getAttributionTag(), mContext.getOpPackageName()); synchronized (WifiManager.this) { if (mActiveLockCount >= MAX_ACTIVE_LOCKS) { mService.releaseMulticastLock(mBinder, mTag); diff --git a/framework/java/android/net/wifi/rtt/PasnConfig.java b/framework/java/android/net/wifi/rtt/PasnConfig.java index 547d94bb67..291a963f5b 100644 --- a/framework/java/android/net/wifi/rtt/PasnConfig.java +++ b/framework/java/android/net/wifi/rtt/PasnConfig.java @@ -120,17 +120,14 @@ public final class PasnConfig implements Parcelable { static { sStringToAkm.put("None", AKM_NONE); - sStringToAkm.put("PASN-", AKM_PASN); - // Transition mode. e.g. "[RSN-SAE+SAE_EXT_KEY-CCMP]" - sStringToAkm.put("SAE+", AKM_SAE); - // SAE mode only. e.g. "[RSN-PSK+SAE-CCMP]" - sStringToAkm.put("SAE-", AKM_SAE); - sStringToAkm.put("EAP-FILS-SHA256-", AKM_FILS_EAP_SHA256); - sStringToAkm.put("EAP-FILS-SHA384-", AKM_FILS_EAP_SHA384); - sStringToAkm.put("FT/EAP-", AKM_FT_EAP_SHA256); - sStringToAkm.put("FT/PSK-", AKM_FT_PSK_SHA256); - sStringToAkm.put("EAP-FT-SHA384-", AKM_FT_EAP_SHA384); - sStringToAkm.put("FT/PSK-SHA384-", AKM_FT_PSK_SHA384); + sStringToAkm.put("PASN", AKM_PASN); + sStringToAkm.put("SAE", AKM_SAE); + sStringToAkm.put("EAP-FILS-SHA256", AKM_FILS_EAP_SHA256); + sStringToAkm.put("EAP-FILS-SHA384", AKM_FILS_EAP_SHA384); + sStringToAkm.put("FT/EAP", AKM_FT_EAP_SHA256); + sStringToAkm.put("FT/PSK", AKM_FT_PSK_SHA256); + sStringToAkm.put("EAP-FT-SHA384", AKM_FT_EAP_SHA384); + sStringToAkm.put("FT/PSK-SHA384", AKM_FT_PSK_SHA384); } /** @@ -174,10 +171,10 @@ public final class PasnConfig implements Parcelable { static { sStringToCipher.put("None", CIPHER_NONE); - sStringToCipher.put("-CCMP]", CIPHER_CCMP_128); - sStringToCipher.put("-CCMP-256]", CIPHER_CCMP_256); - sStringToCipher.put("-GCMP]", CIPHER_GCMP_128); - sStringToCipher.put("-GCMP-256]", CIPHER_GCMP_256); + sStringToCipher.put("CCMP-128", CIPHER_CCMP_128); + sStringToCipher.put("CCMP-256", CIPHER_CCMP_256); + sStringToCipher.put("GCMP-128", CIPHER_GCMP_128); + sStringToCipher.put("GCMP-256", CIPHER_GCMP_256); } @AkmType diff --git a/framework/tests/src/android/net/wifi/rtt/PasnConfigTest.java b/framework/tests/src/android/net/wifi/rtt/PasnConfigTest.java index a5e4798cad..d6a52be8c8 100644 --- a/framework/tests/src/android/net/wifi/rtt/PasnConfigTest.java +++ b/framework/tests/src/android/net/wifi/rtt/PasnConfigTest.java @@ -184,11 +184,13 @@ public class PasnConfigTest { assertEquals(PasnConfig.AKM_NONE, PasnConfig.getBaseAkmsFromCapabilities(null)); assertEquals(PasnConfig.AKM_NONE, PasnConfig.getBaseAkmsFromCapabilities("")); assertEquals(PasnConfig.AKM_SAE, - PasnConfig.getBaseAkmsFromCapabilities("[RSN-SAE+SAE_EXT_KEY-CCMP]")); + PasnConfig.getBaseAkmsFromCapabilities("[RSN-SAE+SAE_EXT_KEY-CCMP-128]")); assertEquals(PasnConfig.AKM_SAE, - PasnConfig.getBaseAkmsFromCapabilities("[RSN-PSK+SAE-CCMP]")); + PasnConfig.getBaseAkmsFromCapabilities("[RSN-PSK+SAE-CCMP-128]")); assertEquals(PasnConfig.AKM_FT_PSK_SHA256, - PasnConfig.getBaseAkmsFromCapabilities("[RSN-FT/PSK-CCMP]")); + PasnConfig.getBaseAkmsFromCapabilities("[RSN-FT/PSK-CCMP-128]")); + assertEquals(PasnConfig.AKM_SAE | PasnConfig.AKM_PASN, + PasnConfig.getBaseAkmsFromCapabilities("[RSN-PSK+SAE+PASN-CCMP-128]")); } /** @@ -199,13 +201,15 @@ public class PasnConfigTest { assertEquals(PasnConfig.CIPHER_NONE, PasnConfig.getCiphersFromCapabilities(null)); assertEquals(PasnConfig.CIPHER_NONE, PasnConfig.getCiphersFromCapabilities("")); assertEquals(PasnConfig.CIPHER_CCMP_128, - PasnConfig.getCiphersFromCapabilities("[RSN-SAE+SAE_EXT_KEY-CCMP]")); + PasnConfig.getCiphersFromCapabilities("[RSN-SAE+SAE_EXT_KEY-CCMP-128]")); assertEquals(PasnConfig.CIPHER_CCMP_256, PasnConfig.getCiphersFromCapabilities("[RSN-SAE+SAE_EXT_KEY-CCMP-256]")); assertEquals(PasnConfig.CIPHER_GCMP_128, - PasnConfig.getCiphersFromCapabilities("[RSN-SAE+SAE_EXT_KEY-GCMP]")); + PasnConfig.getCiphersFromCapabilities("[RSN-SAE+SAE_EXT_KEY-GCMP-128]")); assertEquals(PasnConfig.CIPHER_GCMP_256, PasnConfig.getCiphersFromCapabilities("[RSN-SAE+SAE_EXT_KEY-GCMP-256]")); + assertEquals(PasnConfig.CIPHER_GCMP_256 | PasnConfig.CIPHER_CCMP_128, + PasnConfig.getCiphersFromCapabilities("[RSN-SAE+SAE_EXT_KEY-GCMP-256+CCMP-128]")); } /** diff --git a/framework/tests/src/android/net/wifi/rtt/WifiRttManagerTest.java b/framework/tests/src/android/net/wifi/rtt/WifiRttManagerTest.java index 3426b76800..08d5f40385 100644 --- a/framework/tests/src/android/net/wifi/rtt/WifiRttManagerTest.java +++ b/framework/tests/src/android/net/wifi/rtt/WifiRttManagerTest.java @@ -864,7 +864,7 @@ public class WifiRttManagerTest { scanResult.setFlag( ScanResult.FLAG_80211az_NTB_RESPONDER | ScanResult.FLAG_SECURE_HE_LTF_SUPPORTED); scanResult.informationElements = ie; - scanResult.capabilities = "[RSN-PASN-SAE+SAE_EXT_KEY-GCMP]"; + scanResult.capabilities = "[RSN-PASN-SAE+SAE_EXT_KEY-GCMP-128]"; scanResult.setWifiSsid(WifiSsid.fromString("\"TEST_SSID\"")); RangingRequest.Builder builder = new RangingRequest.Builder(); diff --git a/service/java/com/android/server/wifi/ClientModeImpl.java b/service/java/com/android/server/wifi/ClientModeImpl.java index 9bcf627f9a..08e93bdf7f 100644 --- a/service/java/com/android/server/wifi/ClientModeImpl.java +++ b/service/java/com/android/server/wifi/ClientModeImpl.java @@ -3659,7 +3659,7 @@ public class ClientModeImpl extends StateMachine implements ClientMode { // Update link layer stats getWifiLinkLayerStats(); - if (mWifiP2pConnection.isConnected() && !mWifiP2pConnection.isP2pInWaitingState()) { + if (mWifiP2pConnection.isConnected() && !mWifiP2pConnection.isP2pInDisabledState()) { // P2P discovery breaks DHCP, so shut it down in order to get through this. // Once P2P service receives this message and processes it accordingly, it is supposed // to send arg2 (i.e. CMD_PRE_DHCP_ACTION_COMPLETE) in a new Message.what back to diff --git a/service/java/com/android/server/wifi/SarManager.java b/service/java/com/android/server/wifi/SarManager.java index a454dfe96c..9d6a992f57 100644 --- a/service/java/com/android/server/wifi/SarManager.java +++ b/service/java/com/android/server/wifi/SarManager.java @@ -72,7 +72,7 @@ public class SarManager { private static final String TAG = "WifiSarManager"; private boolean mVerboseLoggingEnabled = true; - private SarInfo mSarInfo; + private final SarInfo mSarInfo; /* Configuration for SAR support */ private boolean mSupportSarTxPowerLimit; @@ -106,6 +106,7 @@ public class SarManager { mAudioManager = mContext.getSystemService(AudioManager.class); mHandler = new Handler(looper); mPhoneStateListener = new WifiPhoneStateListener(looper); + mSarInfo = new SarInfo(); wifiDeviceStateChangeManager.registerStateChangeCallback( new WifiDeviceStateChangeManager.StateChangeCallback() { @Override @@ -121,9 +122,9 @@ public class SarManager { public void handleBootCompleted() { readSarConfigs(); if (mSupportSarTxPowerLimit) { - mSarInfo = new SarInfo(); setSarConfigsInInfo(); registerListeners(); + updateSarScenario(); } } @@ -302,11 +303,6 @@ public class SarManager { */ public void setClientWifiState(int state) { boolean newIsEnabled; - /* No action is taken if SAR is not supported */ - if (!mSupportSarTxPowerLimit) { - return; - } - if (state == WifiManager.WIFI_STATE_DISABLED) { newIsEnabled = false; } else if (state == WifiManager.WIFI_STATE_ENABLED) { @@ -328,10 +324,6 @@ public class SarManager { */ public void setSapWifiState(int state) { boolean newIsEnabled; - /* No action is taken if SAR is not supported */ - if (!mSupportSarTxPowerLimit) { - return; - } if (state == WifiManager.WIFI_AP_STATE_DISABLED) { newIsEnabled = false; @@ -354,10 +346,6 @@ public class SarManager { */ public void setScanOnlyWifiState(int state) { boolean newIsEnabled; - /* No action is taken if SAR is not supported */ - if (!mSupportSarTxPowerLimit) { - return; - } if (state == WifiManager.WIFI_STATE_DISABLED) { newIsEnabled = false; @@ -459,6 +447,10 @@ public class SarManager { * Update HAL with the new SAR scenario if needed. */ private void updateSarScenario() { + /* No action is taken if SAR is not supported */ + if (!mSupportSarTxPowerLimit) { + return; + } if (!mSarInfo.shouldReport()) { return; } diff --git a/service/java/com/android/server/wifi/WifiInjector.java b/service/java/com/android/server/wifi/WifiInjector.java index dcf4388095..7bc2604102 100644 --- a/service/java/com/android/server/wifi/WifiInjector.java +++ b/service/java/com/android/server/wifi/WifiInjector.java @@ -608,7 +608,7 @@ public class WifiInjector { mSelfRecovery = new SelfRecovery(mContext, mActiveModeWarden, mClock, mWifiNative, mWifiGlobals); mWifiMulticastLockManager = new WifiMulticastLockManager(mActiveModeWarden, mBatteryStats, - wifiLooper, mContext); + wifiLooper, mContext, mClock, mWifiMetrics, mWifiPermissionsUtil); mApplicationQosPolicyRequestHandler = new ApplicationQosPolicyRequestHandler( mActiveModeWarden, mWifiNative, mWifiHandlerThread, mDeviceConfigFacade, mContext); diff --git a/service/java/com/android/server/wifi/WifiLockManager.java b/service/java/com/android/server/wifi/WifiLockManager.java index d6f6742998..040aca88bc 100644 --- a/service/java/com/android/server/wifi/WifiLockManager.java +++ b/service/java/com/android/server/wifi/WifiLockManager.java @@ -678,7 +678,7 @@ public class WifiLockManager { switch(wifiLock.mMode) { case WifiManager.WIFI_MODE_FULL_HIGH_PERF: - mWifiMetrics.addWifiLockAcqSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, + mWifiMetrics.addWifiLockManagerAcqSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, uidsAndTags.first, uidsAndTags.second, mWifiPermissionsUtil.getWifiCallerType(wifiLock.getUid(), @@ -696,7 +696,7 @@ public class WifiLockManager { } break; case WifiManager.WIFI_MODE_FULL_LOW_LATENCY: - mWifiMetrics.addWifiLockAcqSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, + mWifiMetrics.addWifiLockManagerAcqSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, uidsAndTags.first, uidsAndTags.second, mWifiPermissionsUtil.getWifiCallerType(wifiLock.getUid(), @@ -732,7 +732,7 @@ public class WifiLockManager { return false; } uidsAndTags = WorkSourceUtil.getUidsAndTagsForWs(mHighPerfBlamedWorkSource); - mWifiMetrics.addWifiLockActiveSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, + mWifiMetrics.addWifiLockManagerActiveSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, uidsAndTags.first, uidsAndTags.second, mClock.getElapsedSinceBootMillis() - mCurrentSessionStartTimeMs, @@ -748,7 +748,7 @@ public class WifiLockManager { return false; } uidsAndTags = WorkSourceUtil.getUidsAndTagsForWs(mLowLatencyBlamedWorkSource); - mWifiMetrics.addWifiLockActiveSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, + mWifiMetrics.addWifiLockManagerActiveSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, uidsAndTags.first, uidsAndTags.second, mClock.getElapsedSinceBootMillis() - mCurrentSessionStartTimeMs, diff --git a/service/java/com/android/server/wifi/WifiMetrics.java b/service/java/com/android/server/wifi/WifiMetrics.java index 58b13fc2ea..52eac0d037 100644 --- a/service/java/com/android/server/wifi/WifiMetrics.java +++ b/service/java/com/android/server/wifi/WifiMetrics.java @@ -8914,8 +8914,11 @@ public class WifiMetrics { } } - /** Add a WifiLock acquisition session */ - public void addWifiLockAcqSession(int lockType, int[] attrUids, String[] attrTags, + /** + * Add a WifiLockManager acquisition session. This represents the session during which + * a single lock was held. + */ + public void addWifiLockManagerAcqSession(int lockType, int[] attrUids, String[] attrTags, int callerType, long duration, boolean isPowersaveDisableAllowed, boolean isAppExemptedFromScreenOn, boolean isAppExemptedFromForeground) { int lockMode; @@ -8933,6 +8936,27 @@ public class WifiMetrics { Log.e(TAG, "addWifiLockAcqSession: Invalid lock type: " + lockType); return; } + writeWifiLockAcqSession(lockMode, attrUids, attrTags, callerType, duration, + isPowersaveDisableAllowed, isAppExemptedFromScreenOn, isAppExemptedFromForeground); + } + + /** + * Add a MulticastLockManager acquisition session. This represents the session during which + * a single lock was held. + */ + public void addMulticastLockManagerAcqSession( + int uid, String attributionTag, int callerType, long duration) { + // Use a default value for the boolean parameters, since these fields + // don't apply to multicast locks. + writeWifiLockAcqSession( + WifiStatsLog.WIFI_LOCK_RELEASED__MODE__WIFI_MODE_MULTICAST_FILTERING_DISABLED, + new int[]{uid}, new String[]{attributionTag}, callerType, duration, + false, false, false); + } + + private void writeWifiLockAcqSession(int lockMode, int[] attrUids, String[] attrTags, + int callerType, long duration, boolean isPowersaveDisableAllowed, + boolean isAppExemptedFromScreenOn, boolean isAppExemptedFromForeground) { WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_RELEASED, attrUids, attrTags, @@ -8944,8 +8968,11 @@ public class WifiMetrics { isAppExemptedFromForeground); } - /** Add a WifiLock active session */ - public void addWifiLockActiveSession(int lockType, int[] attrUids, String[] attrTags, + /** + * Add a WifiLockManager active session. This represents the session during which + * low-latency mode was enabled. + */ + public void addWifiLockManagerActiveSession(int lockType, int[] attrUids, String[] attrTags, long duration, boolean isPowersaveDisableAllowed, boolean isAppExemptedFromScreenOn, boolean isAppExemptedFromForeground) { int lockMode; @@ -8968,6 +8995,25 @@ public class WifiMetrics { Log.e(TAG, "addWifiLockActiveSession: Invalid lock type: " + lockType); return; } + writeWifiLockActiveSession(lockMode, attrUids, attrTags, duration, + isPowersaveDisableAllowed, isAppExemptedFromScreenOn, isAppExemptedFromForeground); + } + + /** + * Add a MulticastLockManager active session. This represents the session during which + * multicast packet filtering was disabled. + */ + public void addMulticastLockManagerActiveSession(long duration) { + // Use a default value for the array and boolean parameters, + // since these fields don't apply to multicast locks + writeWifiLockActiveSession( + WifiStatsLog.WIFI_LOCK_DEACTIVATED__MODE__WIFI_MODE_MULTICAST_FILTERING_DISABLED, + new int[0], new String[0], duration, false, false, false); + } + + private void writeWifiLockActiveSession(int lockMode, int[] attrUids, String[] attrTags, + long duration, boolean isPowersaveDisableAllowed, + boolean isAppExemptedFromScreenOn, boolean isAppExemptedFromForeground) { WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_DEACTIVATED, attrUids, attrTags, diff --git a/service/java/com/android/server/wifi/WifiMulticastLockManager.java b/service/java/com/android/server/wifi/WifiMulticastLockManager.java index fa40fd7d3b..598bf5716d 100644 --- a/service/java/com/android/server/wifi/WifiMulticastLockManager.java +++ b/service/java/com/android/server/wifi/WifiMulticastLockManager.java @@ -29,6 +29,7 @@ import android.os.WorkSource; import android.util.Log; import com.android.server.wifi.proto.WifiStatsLog; +import com.android.server.wifi.util.WifiPermissionsUtil; import java.io.PrintWriter; import java.util.ArrayList; @@ -49,11 +50,16 @@ public class WifiMulticastLockManager { private final Map<Integer, Integer> mNumLocksPerInactiveOwner = new HashMap<>(); private int mMulticastEnabled = 0; private int mMulticastDisabled = 0; + private boolean mIsFilterDisableSessionActive = false; + private long mFilterDisableSessionStartTime; private final Handler mHandler; private final Object mLock = new Object(); private boolean mVerboseLoggingEnabled = false; private final BatteryStatsManager mBatteryStats; private final ActiveModeWarden mActiveModeWarden; + private final Clock mClock; + private final WifiMetrics mWifiMetrics; + private final WifiPermissionsUtil mWifiPermissionsUtil; /** Delegate for handling state change events for multicast filtering. */ public interface FilterController { @@ -68,10 +74,16 @@ public class WifiMulticastLockManager { ActiveModeWarden activeModeWarden, BatteryStatsManager batteryStats, Looper looper, - Context context) { + Context context, + Clock clock, + WifiMetrics wifiMetrics, + WifiPermissionsUtil wifiPermissionsUtil) { mBatteryStats = batteryStats; mActiveModeWarden = activeModeWarden; mHandler = new Handler(looper); + mClock = clock; + mWifiMetrics = wifiMetrics; + mWifiPermissionsUtil = wifiPermissionsUtil; mActiveModeWarden.registerPrimaryClientModeManagerChangedCallback( new PrimaryClientModeManagerChangedCallback()); @@ -89,11 +101,18 @@ public class WifiMulticastLockManager { String mTag; int mUid; IBinder mBinder; + String mAttributionTag; + String mPackageName; + long mAcquireTime; - Multicaster(int uid, IBinder binder, String tag) { + Multicaster(int uid, IBinder binder, String tag, String attributionTag, + String packageName) { mTag = tag; mUid = uid; mBinder = binder; + mAttributionTag = attributionTag; + mPackageName = packageName; + mAcquireTime = mClock.getElapsedSinceBootMillis(); try { mBinder.linkToDeath(this, 0); } catch (RemoteException e) { @@ -130,6 +149,18 @@ public class WifiMulticastLockManager { return mBinder; } + public String getAttributionTag() { + return mAttributionTag; + } + + public String getPackageName() { + return mPackageName; + } + + public long getAcquireTime() { + return mAcquireTime; + } + public String toString() { return "Multicaster{" + mTag + " uid=" + mUid + "}"; } @@ -206,25 +237,44 @@ public class WifiMulticastLockManager { public void startFilteringMulticastPackets() { synchronized (mLock) { if (!isMulticastEnabled()) { + if (mIsFilterDisableSessionActive) { + // Log the end of the filtering disabled session, + // since we're about to re-enable multicast packet filtering + mWifiMetrics.addMulticastLockManagerActiveSession( + mClock.getElapsedSinceBootMillis() - mFilterDisableSessionStartTime); + } mActiveModeWarden.getPrimaryClientModeManager() .getMcastLockManagerFilterController() .startFilteringMulticastPackets(); + mIsFilterDisableSessionActive = false; } } } private void stopFilteringMulticastPackets() { - mActiveModeWarden.getPrimaryClientModeManager() - .getMcastLockManagerFilterController() - .stopFilteringMulticastPackets(); + synchronized (mLock) { + if (!mIsFilterDisableSessionActive) { + // Mark the beginning of a filtering disabled session, + // since we're about to disable multicast packet filtering + mFilterDisableSessionStartTime = mClock.getElapsedSinceBootMillis(); + } + mActiveModeWarden.getPrimaryClientModeManager() + .getMcastLockManagerFilterController() + .stopFilteringMulticastPackets(); + mIsFilterDisableSessionActive = true; + } } /** * Acquire a multicast lock. + * @param uid uid of the calling application * @param binder a binder used to ensure caller is still alive - * @param tag string name of the caller. + * @param lockTag caller-provided tag to identify this lock + * @param attributionTag attribution tag of the calling application + * @param packageName package name of the calling application */ - public void acquireLock(int uid, IBinder binder, String tag) { + public void acquireLock(int uid, IBinder binder, String lockTag, String attributionTag, + String packageName) { synchronized (mLock) { mMulticastEnabled++; @@ -234,35 +284,33 @@ public class WifiMulticastLockManager { } int numLocksHeldByUid = mNumLocksPerActiveOwner.getOrDefault(uid, 0); mNumLocksPerActiveOwner.put(uid, numLocksHeldByUid + 1); - mMulticasters.add(new Multicaster(uid, binder, tag)); + mMulticasters.add(new Multicaster(uid, binder, lockTag, attributionTag, packageName)); // Note that we could call stopFilteringMulticastPackets only when // our new size == 1 (first call), but this function won't // be called often and by making the stopPacket call each // time we're less fragile and self-healing. - mActiveModeWarden.getPrimaryClientModeManager() - .getMcastLockManagerFilterController() - .stopFilteringMulticastPackets(); + stopFilteringMulticastPackets(); } final long ident = Binder.clearCallingIdentity(); mBatteryStats.reportWifiMulticastEnabled(new WorkSource(uid)); WifiStatsLog.write_non_chained( WifiStatsLog.WIFI_MULTICAST_LOCK_STATE_CHANGED, uid, null, - WifiStatsLog.WIFI_MULTICAST_LOCK_STATE_CHANGED__STATE__ON, tag); + WifiStatsLog.WIFI_MULTICAST_LOCK_STATE_CHANGED__STATE__ON, lockTag); Binder.restoreCallingIdentity(ident); } /** Releases a multicast lock */ - public void releaseLock(int uid, IBinder binder, String tag) { + public void releaseLock(int uid, IBinder binder, String lockTag) { synchronized (mLock) { mMulticastDisabled++; int size = mMulticasters.size(); for (int i = size - 1; i >= 0; i--) { Multicaster m = mMulticasters.get(i); - if ((m != null) && (m.getUid() == uid) && (m.getTag().equals(tag)) + if ((m != null) && (m.getUid() == uid) && (m.getTag().equals(lockTag)) && (m.getBinder() == binder)) { - removeMulticasterLocked(i, uid, tag); + removeMulticasterLocked(i, uid, lockTag); break; } } @@ -282,6 +330,10 @@ public class WifiMulticastLockManager { Multicaster removed = mMulticasters.remove(i); if (removed != null) { removed.unlinkDeathRecipient(); + mWifiMetrics.addMulticastLockManagerAcqSession( + uid, removed.getAttributionTag(), + mWifiPermissionsUtil.getWifiCallerType(uid, removed.getPackageName()), + mClock.getElapsedSinceBootMillis() - removed.getAcquireTime()); } if (mNumLocksPerActiveOwner.containsKey(uid)) { @@ -291,9 +343,7 @@ public class WifiMulticastLockManager { } if (!isMulticastEnabled()) { - mActiveModeWarden.getPrimaryClientModeManager() - .getMcastLockManagerFilterController() - .startFilteringMulticastPackets(); + startFilteringMulticastPackets(); } final long ident = Binder.clearCallingIdentity(); diff --git a/service/java/com/android/server/wifi/WifiNetworkFactory.java b/service/java/com/android/server/wifi/WifiNetworkFactory.java index f29eb75cf6..ec4a5ca353 100644 --- a/service/java/com/android/server/wifi/WifiNetworkFactory.java +++ b/service/java/com/android/server/wifi/WifiNetworkFactory.java @@ -1347,6 +1347,14 @@ public class WifiNetworkFactory extends NetworkFactory { // If there is no active request or if the user has already selected a network, // ignore screen state changes. if (mActiveSpecificNetworkRequest == null || !mIsPeriodicScanEnabled) return; + if (mSkipUserDialogue) { + // Allow App which bypass the user approval to fulfill the request during screen off. + return; + } + if (screenOn != mIsPeriodicScanPaused) { + // already at the expected state + return; + } // Pause periodic scans when the screen is off & resume when the screen is on. if (screenOn) { diff --git a/service/java/com/android/server/wifi/WifiP2pConnection.java b/service/java/com/android/server/wifi/WifiP2pConnection.java index 907ab0d197..f1c665dd01 100644 --- a/service/java/com/android/server/wifi/WifiP2pConnection.java +++ b/service/java/com/android/server/wifi/WifiP2pConnection.java @@ -45,8 +45,8 @@ public class WifiP2pConnection { private AsyncChannel mWifiP2pChannel; private boolean mTemporarilyDisconnectWifi = false; - /** Used to check if P2P state machine is in waitingState */ - private boolean mWaitingState = false; + /** Used to check if P2P state machine is in DisabledState */ + private boolean mDisabledState = false; public WifiP2pConnection(Context context, Looper looper, ActiveModeWarden activeModeWarden) { mContext = context; @@ -191,12 +191,12 @@ public class WifiP2pConnection { return mTemporarilyDisconnectWifi; } - public void setP2pInWaitingState(boolean inWaitingState) { - mWaitingState = inWaitingState; + public void setP2pInDisabledState(boolean inDisabledState) { + mDisabledState = inDisabledState; } - /** whether the P2P state machine is in waitingState for user response to create interface */ - public boolean isP2pInWaitingState() { - return mWaitingState; + /** whether the P2P state machine is in disabled state */ + public boolean isP2pInDisabledState() { + return mDisabledState; } } diff --git a/service/java/com/android/server/wifi/WifiServiceImpl.java b/service/java/com/android/server/wifi/WifiServiceImpl.java index ec20ffbd66..9055d857be 100644 --- a/service/java/com/android/server/wifi/WifiServiceImpl.java +++ b/service/java/com/android/server/wifi/WifiServiceImpl.java @@ -6171,19 +6171,20 @@ public class WifiServiceImpl extends IWifiManager.Stub { } @Override - public void acquireMulticastLock(IBinder binder, String tag) { + public void acquireMulticastLock(IBinder binder, String lockTag, String attributionTag, + String packageName) { enforceMulticastChangePermission(); int uid = Binder.getCallingUid(); - mLog.info("acquireMulticastLock uid=% tag=%").c(uid).c(tag).flush(); - mWifiMulticastLockManager.acquireLock(uid, binder, tag); + mLog.info("acquireMulticastLock uid=% lockTag=%").c(uid).c(lockTag).flush(); + mWifiMulticastLockManager.acquireLock(uid, binder, lockTag, attributionTag, packageName); } @Override - public void releaseMulticastLock(IBinder binder, String tag) { + public void releaseMulticastLock(IBinder binder, String lockTag) { enforceMulticastChangePermission(); int uid = Binder.getCallingUid(); - mLog.info("releaseMulticastLock uid=% tag=%").c(uid).c(tag).flush(); - mWifiMulticastLockManager.releaseLock(uid, binder, tag); + mLog.info("releaseMulticastLock uid=% lockTag=%").c(uid).c(lockTag).flush(); + mWifiMulticastLockManager.releaseLock(uid, binder, lockTag); } @Override diff --git a/service/java/com/android/server/wifi/aware/WifiAwareStateManager.java b/service/java/com/android/server/wifi/aware/WifiAwareStateManager.java index 19047477dc..3f4460ed8b 100644 --- a/service/java/com/android/server/wifi/aware/WifiAwareStateManager.java +++ b/service/java/com/android/server/wifi/aware/WifiAwareStateManager.java @@ -2661,8 +2661,8 @@ public class WifiAwareStateManager implements WifiAwareShellCommand.DelegatedShe onAwareDownLocal(); if (reason != NanStatusCode.SUCCESS) { sendAwareStateChangedBroadcast(false); + releaseAwareInterface(); } - releaseAwareInterface(); break; } case NOTIFICATION_TYPE_ON_MESSAGE_SEND_SUCCESS: { diff --git a/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicant.java b/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicant.java index 6310577077..1ac2ad8f64 100644 --- a/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicant.java +++ b/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicant.java @@ -18,6 +18,10 @@ package com.android.server.wifi.mainline_supplicant; import android.annotation.NonNull; import android.annotation.Nullable; +import android.net.MacAddress; +import android.net.wifi.usd.Config; +import android.net.wifi.usd.PublishConfig; +import android.net.wifi.usd.SubscribeConfig; import android.net.wifi.util.Environment; import android.os.IBinder; import android.os.RemoteException; @@ -25,13 +29,18 @@ import android.os.ServiceSpecificException; import android.system.wifi.mainline_supplicant.IMainlineSupplicant; import android.system.wifi.mainline_supplicant.IStaInterface; import android.system.wifi.mainline_supplicant.IStaInterfaceCallback; +import android.system.wifi.mainline_supplicant.UsdMessageInfo; +import android.system.wifi.mainline_supplicant.UsdServiceProtoType; import android.util.Log; import com.android.internal.annotations.VisibleForTesting; +import com.android.server.wifi.SupplicantStaIfaceHal; import com.android.server.wifi.WifiNative; import com.android.server.wifi.WifiThreadRunner; +import com.android.server.wifi.usd.UsdNativeManager; import com.android.wifi.flags.Flags; +import java.util.Arrays; import java.util.HashMap; import java.util.Map; import java.util.concurrent.CountDownLatch; @@ -47,6 +56,7 @@ public class MainlineSupplicant { private static final String TAG = "MainlineSupplicant"; private static final String MAINLINE_SUPPLICANT_SERVICE_NAME = "wifi_mainline_supplicant"; private static final long WAIT_FOR_DEATH_TIMEOUT_MS = 50L; + protected static final int DEFAULT_USD_FREQ_MHZ = 2437; private IMainlineSupplicant mIMainlineSupplicant; private final Object mLock = new Object(); @@ -57,6 +67,7 @@ public class MainlineSupplicant { private final boolean mIsServiceAvailable; private Map<String, IStaInterface> mActiveStaIfaces = new HashMap<>(); private Map<String, IStaInterfaceCallback> mStaIfaceCallbacks = new HashMap<>(); + private UsdNativeManager.UsdEventsCallback mUsdEventsCallback = null; public MainlineSupplicant(@NonNull WifiThreadRunner wifiThreadRunner) { mWifiThreadRunner = wifiThreadRunner; @@ -281,6 +292,22 @@ public class MainlineSupplicant { } /** + * Register a framework callback to receive USD events. + */ + public void registerUsdEventsCallback( + @NonNull UsdNativeManager.UsdEventsCallback usdEventsCallback) { + mUsdEventsCallback = usdEventsCallback; + } + + /** + * Get the registered USD events callback. Method should only be used + * by {@link MainlineSupplicantStaIfaceCallback}. + */ + protected @Nullable UsdNativeManager.UsdEventsCallback getUsdEventsCallback() { + return mUsdEventsCallback; + } + + /** * Stop the mainline supplicant process. */ public void stopService() { @@ -342,6 +369,324 @@ public class MainlineSupplicant { } } + private static byte frameworkToHalUsdTransmissionType( + @Config.TransmissionType int transmissionType) { + switch (transmissionType) { + case Config.TRANSMISSION_TYPE_MULTICAST: + return IStaInterface.UsdPublishTransmissionType.MULTICAST; + case Config.TRANSMISSION_TYPE_UNICAST: + default: + return IStaInterface.UsdPublishTransmissionType.UNICAST; + } + } + + private static byte frameworkToHalUsdProtoType( + @Config.ServiceProtoType int protoType) { + switch (protoType) { + case Config.SERVICE_PROTO_TYPE_GENERIC: + return UsdServiceProtoType.GENERIC; + case Config.SERVICE_PROTO_TYPE_CSA_MATTER: + return UsdServiceProtoType.CSA_MATTER; + default: + return UsdServiceProtoType.UNKNOWN; + } + } + + @VisibleForTesting + protected static IStaInterface.UsdPublishConfig frameworkToHalUsdPublishConfig( + PublishConfig frameworkConfig) { + IStaInterface.UsdPublishConfig aidlConfig = new IStaInterface.UsdPublishConfig(); + // USD publisher is always solicited and unsolicited + aidlConfig.publishType = IStaInterface.UsdPublishType.SOLICITED_AND_UNSOLICITED; + // FSD is always enabled for USD + aidlConfig.isFsd = true; + aidlConfig.transmissionType = frameworkToHalUsdTransmissionType( + frameworkConfig.getSolicitedTransmissionType()); + aidlConfig.announcementPeriodMillis = frameworkConfig.getAnnouncementPeriodMillis(); + aidlConfig.baseConfig = new IStaInterface.UsdBaseConfig(); + aidlConfig.baseConfig.ttlSec = frameworkConfig.getTtlSeconds(); + int[] freqs = frameworkConfig.getOperatingFrequenciesMhz(); + aidlConfig.baseConfig.defaultFreqMhz = (freqs == null || freqs.length == 0) + ? DEFAULT_USD_FREQ_MHZ : freqs[0]; + aidlConfig.baseConfig.freqsMhz = (freqs == null || freqs.length <= 1) + ? new int[0] : Arrays.copyOfRange(freqs, 1, freqs.length); + aidlConfig.baseConfig.serviceName = Arrays.toString(frameworkConfig.getServiceName()); + aidlConfig.baseConfig.serviceSpecificInfo = + frameworkConfig.getServiceSpecificInfo() != null + ? frameworkConfig.getServiceSpecificInfo() : new byte[0]; + aidlConfig.baseConfig.rxMatchFilter = frameworkConfig.getRxMatchFilterTlv() != null + ? frameworkConfig.getRxMatchFilterTlv() : new byte[0]; + aidlConfig.baseConfig.txMatchFilter = frameworkConfig.getTxMatchFilterTlv() != null + ? frameworkConfig.getTxMatchFilterTlv() : new byte[0]; + aidlConfig.baseConfig.serviceProtoType = frameworkToHalUsdProtoType( + frameworkConfig.getServiceProtoType()); + return aidlConfig; + } + + /** + * Start a USD publish operation. + * + * @param ifaceName Name of the interface + * @param cmdId An id for this command + * @param publishConfig Publish configuration + * @return true if successful, false otherwise + */ + public boolean startUsdPublish(@NonNull String ifaceName, int cmdId, + @NonNull PublishConfig publishConfig) { + synchronized (mLock) { + final String methodName = "startUsdPublish"; + if (ifaceName == null || publishConfig == null) { + return false; + } + IStaInterface iface = getStaIfaceOrLogError(ifaceName, methodName); + if (iface == null) { + return false; + } + try { + iface.startUsdPublish(cmdId, frameworkToHalUsdPublishConfig(publishConfig)); + return true; + } catch (ServiceSpecificException e) { + handleServiceSpecificException(e, methodName); + } catch (RemoteException e) { + handleRemoteException(e, methodName); + } + return false; + } + } + + private static byte frameworkToHalUsdSubscribeType( + @Config.SubscribeType int subscribeType) { + switch (subscribeType) { + case Config.SUBSCRIBE_TYPE_ACTIVE: + return IStaInterface.UsdSubscribeType.ACTIVE_MODE; + case Config.SUBSCRIBE_TYPE_PASSIVE: + default: + return IStaInterface.UsdSubscribeType.PASSIVE_MODE; + } + } + + @VisibleForTesting + protected static IStaInterface.UsdSubscribeConfig frameworkToHalUsdSubscribeConfig( + SubscribeConfig frameworkConfig) { + IStaInterface.UsdSubscribeConfig aidlConfig = new IStaInterface.UsdSubscribeConfig(); + aidlConfig.subscribeType = + frameworkToHalUsdSubscribeType(frameworkConfig.getSubscribeType()); + aidlConfig.queryPeriodMillis = frameworkConfig.getQueryPeriodMillis(); + aidlConfig.baseConfig = new IStaInterface.UsdBaseConfig(); + aidlConfig.baseConfig.ttlSec = frameworkConfig.getTtlSeconds(); + int[] freqs = frameworkConfig.getOperatingFrequenciesMhz(); + aidlConfig.baseConfig.defaultFreqMhz = (freqs == null || freqs.length == 0) + ? DEFAULT_USD_FREQ_MHZ : freqs[0]; + aidlConfig.baseConfig.freqsMhz = (freqs == null || freqs.length <= 1) + ? new int[0] : Arrays.copyOfRange(freqs, 1, freqs.length); + aidlConfig.baseConfig.serviceName = Arrays.toString(frameworkConfig.getServiceName()); + aidlConfig.baseConfig.serviceSpecificInfo = + frameworkConfig.getServiceSpecificInfo() != null + ? frameworkConfig.getServiceSpecificInfo() : new byte[0]; + aidlConfig.baseConfig.rxMatchFilter = frameworkConfig.getRxMatchFilterTlv() != null + ? frameworkConfig.getRxMatchFilterTlv() : new byte[0]; + aidlConfig.baseConfig.txMatchFilter = frameworkConfig.getTxMatchFilterTlv() != null + ? frameworkConfig.getTxMatchFilterTlv() : new byte[0]; + aidlConfig.baseConfig.serviceProtoType = frameworkToHalUsdProtoType( + frameworkConfig.getServiceProtoType()); + return aidlConfig; + } + + /** + * Start a USD subscribe operation. + * + * @param ifaceName Name of the interface + * @param cmdId An id for this command + * @param subscribeConfig Subscribe configuration + * @return true if successful, false otherwise + */ + public boolean startUsdSubscribe(@NonNull String ifaceName, int cmdId, + @NonNull SubscribeConfig subscribeConfig) { + synchronized (mLock) { + final String methodName = "startUsdSubscribe"; + if (ifaceName == null || subscribeConfig == null) { + return false; + } + IStaInterface iface = getStaIfaceOrLogError(ifaceName, methodName); + if (iface == null) { + return false; + } + try { + iface.startUsdSubscribe(cmdId, frameworkToHalUsdSubscribeConfig(subscribeConfig)); + return true; + } catch (ServiceSpecificException e) { + handleServiceSpecificException(e, methodName); + } catch (RemoteException e) { + handleRemoteException(e, methodName); + } + return false; + } + } + + /** + * Get the USD capabilities for the interface. + * + * @param ifaceName Name of the interface + * @return UsdCapabilities if available, otherwise null + */ + public @Nullable SupplicantStaIfaceHal.UsdCapabilitiesInternal getUsdCapabilities( + @NonNull String ifaceName) { + synchronized (mLock) { + final String methodName = "getUsdCapabilities"; + if (ifaceName == null) { + return null; + } + IStaInterface iface = getStaIfaceOrLogError(ifaceName, methodName); + if (iface == null) { + return null; + } + try { + IStaInterface.UsdCapabilities aidlCaps = iface.getUsdCapabilities(); + if (aidlCaps == null) { + Log.e(TAG, "Received null USD capabilities from the HAL"); + return null; + } + return new SupplicantStaIfaceHal.UsdCapabilitiesInternal( + aidlCaps.isUsdPublisherSupported, + aidlCaps.isUsdSubscriberSupported, + aidlCaps.maxLocalSsiLengthBytes, + aidlCaps.maxServiceNameLengthBytes, + aidlCaps.maxMatchFilterLengthBytes, + aidlCaps.maxNumPublishSessions, + aidlCaps.maxNumSubscribeSessions); + } catch (ServiceSpecificException e) { + handleServiceSpecificException(e, methodName); + } catch (RemoteException e) { + handleRemoteException(e, methodName); + } + return null; + } + } + + /** + * Update an ongoing USD publish operation. + * + * @param ifaceName Name of the interface + * @param publishId Publish id for this session + * @param ssi Service specific info + */ + public void updateUsdPublish(@NonNull String ifaceName, int publishId, + @NonNull byte[] ssi) { + synchronized (mLock) { + final String methodName = "updateUsdPublish"; + if (ifaceName == null || ssi == null) { + return; + } + IStaInterface iface = getStaIfaceOrLogError(ifaceName, methodName); + if (iface == null) { + return; + } + try { + iface.updateUsdPublish(publishId, ssi); + } catch (ServiceSpecificException e) { + handleServiceSpecificException(e, methodName); + } catch (RemoteException e) { + handleRemoteException(e, methodName); + } + } + } + + /** + * Cancel an ongoing USD publish session. + * + * @param ifaceName Name of the interface + * @param publishId Publish id for the session + */ + public void cancelUsdPublish(@NonNull String ifaceName, int publishId) { + synchronized (mLock) { + final String methodName = "cancelUsdPublish"; + if (ifaceName == null) { + return; + } + IStaInterface iface = getStaIfaceOrLogError(ifaceName, methodName); + if (iface == null) { + return; + } + try { + iface.cancelUsdPublish(publishId); + } catch (ServiceSpecificException e) { + handleServiceSpecificException(e, methodName); + } catch (RemoteException e) { + handleRemoteException(e, methodName); + } + } + } + + /** + * Cancel an ongoing USD subscribe session. + * + * @param ifaceName Name of the interface + * @param subscribeId Subscribe id for the session + */ + public void cancelUsdSubscribe(@NonNull String ifaceName, int subscribeId) { + synchronized (mLock) { + final String methodName = "cancelUsdSubscribe"; + if (ifaceName == null) { + return; + } + IStaInterface iface = getStaIfaceOrLogError(ifaceName, methodName); + if (iface == null) { + return; + } + try { + iface.cancelUsdSubscribe(subscribeId); + } catch (ServiceSpecificException e) { + handleServiceSpecificException(e, methodName); + } catch (RemoteException e) { + handleRemoteException(e, methodName); + } + } + } + + private static UsdMessageInfo createUsdMessageInfo(int ownId, int peerId, + MacAddress peerMacAddress, byte[] message) { + UsdMessageInfo messageInfo = new UsdMessageInfo(); + messageInfo.ownId = ownId; + messageInfo.peerId = peerId; + messageInfo.message = message; + messageInfo.peerMacAddress = peerMacAddress.toByteArray(); + return messageInfo; + } + + /** + * Send a message to an ongoing USD publish or subscribe session. + * + * @param ifaceName Name of the interface + * @param ownId Id for the session + * @param peerId Id for the peer session + * @param peerMacAddress Mac address of the peer session + * @param message Data to send + * @return true if successful, false otherwise + */ + public boolean sendUsdMessage(@NonNull String ifaceName, int ownId, int peerId, + @NonNull MacAddress peerMacAddress, @NonNull byte[] message) { + synchronized (mLock) { + final String methodName = "sendUsdMessage"; + if (ifaceName == null || peerMacAddress == null || message == null) { + return false; + } + IStaInterface iface = getStaIfaceOrLogError(ifaceName, methodName); + if (iface == null) { + return false; + } + try { + iface.sendUsdMessage( + createUsdMessageInfo(ownId, peerId, peerMacAddress, message)); + return true; + } catch (ServiceSpecificException e) { + handleServiceSpecificException(e, methodName); + } catch (RemoteException e) { + handleRemoteException(e, methodName); + } + return false; + } + } + private void handleServiceSpecificException(ServiceSpecificException e, String methodName) { Log.e(TAG, methodName + " encountered ServiceSpecificException " + e); } @@ -354,6 +699,17 @@ public class MainlineSupplicant { return true; } + private @Nullable IStaInterface getStaIfaceOrLogError(String ifaceName, String methodName) { + synchronized (mLock) { + if (!mActiveStaIfaces.containsKey(ifaceName)) { + Log.e(TAG, "Unable to call " + methodName + " since iface " + + ifaceName + " does not exist"); + return null; + } + return mActiveStaIfaces.get(ifaceName); + } + } + private void handleRemoteException(RemoteException e, String methodName) { synchronized (mLock) { Log.e(TAG, methodName + " encountered RemoteException " + e); diff --git a/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicantStaIfaceCallback.java b/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicantStaIfaceCallback.java index 20cda62861..4d6207357e 100644 --- a/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicantStaIfaceCallback.java +++ b/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicantStaIfaceCallback.java @@ -17,15 +17,26 @@ package com.android.server.wifi.mainline_supplicant; import android.annotation.NonNull; +import android.annotation.Nullable; +import android.annotation.SuppressLint; +import android.net.MacAddress; +import android.net.wifi.usd.Config; +import android.net.wifi.usd.SessionCallback; import android.system.wifi.mainline_supplicant.IStaInterfaceCallback; import android.system.wifi.mainline_supplicant.UsdMessageInfo; +import android.system.wifi.mainline_supplicant.UsdServiceProtoType; +import android.util.Log; import com.android.server.wifi.WifiThreadRunner; +import com.android.server.wifi.usd.UsdNativeManager; +import com.android.server.wifi.usd.UsdRequestManager; /** * Implementation of the mainline supplicant {@link IStaInterfaceCallback}. */ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.Stub { + private static final String TAG = "MainlineSupplicantStaIfaceCallback"; + private final MainlineSupplicant mMainlineSupplicant; private final String mIfaceName; private final WifiThreadRunner mWifiThreadRunner; @@ -45,7 +56,17 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St * @param publishId Identifier for the publish session. */ @Override - public void onUsdPublishStarted(int cmdId, int publishId) { } + public void onUsdPublishStarted(int cmdId, int publishId) { + mWifiThreadRunner.post(() -> { + UsdNativeManager.UsdEventsCallback usdCallback = + mMainlineSupplicant.getUsdEventsCallback(); + if (usdCallback == null) { + Log.e(TAG, "UsdEventsCallback callback is null"); + return; + } + usdCallback.onUsdPublishStarted(cmdId, publishId); + }); + } /** * Called in response to startUsdSubscribe to indicate that the subscribe session @@ -55,7 +76,30 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St * @param subscribeId Identifier for the subscribe session. */ @Override - public void onUsdSubscribeStarted(int cmdId, int subscribeId) { } + public void onUsdSubscribeStarted(int cmdId, int subscribeId) { + mWifiThreadRunner.post(() -> { + UsdNativeManager.UsdEventsCallback usdCallback = + mMainlineSupplicant.getUsdEventsCallback(); + if (usdCallback == null) { + Log.e(TAG, "UsdEventsCallback callback is null"); + return; + } + usdCallback.onUsdSubscribeStarted(cmdId, subscribeId); + }); + } + + @SuppressLint("NewApi") + private static @SessionCallback.FailureCode int + convertHalToFrameworkUsdConfigErrorCode(int errorCode) { + switch (errorCode) { + case UsdConfigErrorCode.FAILURE_TIMEOUT: + return SessionCallback.FAILURE_TIMEOUT; + case UsdConfigErrorCode.FAILURE_NOT_AVAILABLE: + return SessionCallback.FAILURE_NOT_AVAILABLE; + default: + return SessionCallback.FAILURE_UNKNOWN; + } + } /** * Called in response to startUsdPublish to indicate that the publish session @@ -64,7 +108,18 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St * @param cmdId Identifier for the original request. * @param errorCode Code indicating the failure reason. */ - @Override public void onUsdPublishConfigFailed(int cmdId, int errorCode) { } + @Override public void onUsdPublishConfigFailed(int cmdId, int errorCode) { + mWifiThreadRunner.post(() -> { + UsdNativeManager.UsdEventsCallback usdCallback = + mMainlineSupplicant.getUsdEventsCallback(); + if (usdCallback == null) { + Log.e(TAG, "UsdEventsCallback callback is null"); + return; + } + usdCallback.onUsdPublishConfigFailed(cmdId, + convertHalToFrameworkUsdConfigErrorCode(errorCode)); + }); + } /** * Called in response to startUsdSubscribe to indicate that the subscribe session @@ -74,7 +129,29 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St * @param errorCode Code indicating the failure reason. */ @Override - public void onUsdSubscribeConfigFailed(int cmdId, int errorCode) { } + public void onUsdSubscribeConfigFailed(int cmdId, int errorCode) { + mWifiThreadRunner.post(() -> { + UsdNativeManager.UsdEventsCallback usdCallback = + mMainlineSupplicant.getUsdEventsCallback(); + if (usdCallback == null) { + Log.e(TAG, "UsdEventsCallback callback is null"); + return; + } + usdCallback.onUsdSubscribeConfigFailed(cmdId, + convertHalToFrameworkUsdConfigErrorCode(errorCode)); + }); + } + + @SuppressLint("NewApi") + private static @SessionCallback.TerminationReasonCode int + convertHalToFrameworkUsdTerminateReasonCode(int reasonCode) { + switch (reasonCode) { + case UsdTerminateReasonCode.USER_REQUESTED: + return SessionCallback.TERMINATION_REASON_USER_INITIATED; + default: + return SessionCallback.TERMINATION_REASON_UNKNOWN; + } + } /** * Called in response to cancelUsdPublish to indicate that the session was cancelled @@ -84,7 +161,18 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St * @param reasonCode Code indicating the reason for the session cancellation. */ @Override - public void onUsdPublishTerminated(int publishId, int reasonCode) { } + public void onUsdPublishTerminated(int publishId, int reasonCode) { + mWifiThreadRunner.post(() -> { + UsdNativeManager.UsdEventsCallback usdCallback = + mMainlineSupplicant.getUsdEventsCallback(); + if (usdCallback == null) { + Log.e(TAG, "UsdEventsCallback callback is null"); + return; + } + usdCallback.onUsdPublishTerminated(publishId, + convertHalToFrameworkUsdTerminateReasonCode(reasonCode)); + }); + } /** * Called in response to cancelUsdSubscribe to indicate that the session was cancelled @@ -94,7 +182,59 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St * @param reasonCode Code indicating the reason for the session cancellation. */ @Override - public void onUsdSubscribeTerminated(int subscribeId, int reasonCode) { } + public void onUsdSubscribeTerminated(int subscribeId, int reasonCode) { + mWifiThreadRunner.post(() -> { + UsdNativeManager.UsdEventsCallback usdCallback = + mMainlineSupplicant.getUsdEventsCallback(); + if (usdCallback == null) { + Log.e(TAG, "UsdEventsCallback callback is null"); + return; + } + usdCallback.onUsdSubscribeTerminated(subscribeId, + convertHalToFrameworkUsdTerminateReasonCode(reasonCode)); + }); + } + + private static @Config.ServiceProtoType int + convertHalToFrameworkUsdProtocolType(int protocolType) { + switch (protocolType) { + case UsdServiceProtoType.CSA_MATTER: + return Config.SERVICE_PROTO_TYPE_CSA_MATTER; + default: + return Config.SERVICE_PROTO_TYPE_GENERIC; + } + } + + private static @Nullable MacAddress safeConvertMacAddress(byte[] macAddrBytes) { + if (macAddrBytes == null) return null; + try { + return MacAddress.fromBytes(macAddrBytes); + } catch (Exception e) { + return null; + } + } + + private static UsdRequestManager.UsdHalDiscoveryInfo + convertHalToFrameworkUsdDiscoveryInfo(UsdServiceDiscoveryInfo discoveryInfo) { + if (discoveryInfo.peerMacAddress == null + || discoveryInfo.serviceSpecificInfo == null + || discoveryInfo.matchFilter == null) { + Log.e(TAG, "USD discovery info contains a null parameter"); + return null; + } + MacAddress peerAddress = safeConvertMacAddress(discoveryInfo.peerMacAddress); + if (peerAddress == null) { + Log.e(TAG, "USD discovery info contains an invalid peer address"); + return null; + } + return new UsdRequestManager.UsdHalDiscoveryInfo(discoveryInfo.ownId, + discoveryInfo.peerId, + peerAddress, + discoveryInfo.serviceSpecificInfo, + convertHalToFrameworkUsdProtocolType(discoveryInfo.serviceProtoType), + discoveryInfo.isFsd, + discoveryInfo.matchFilter); + } /** * Indicates that the publisher sent a solicited publish message to the subscriber. @@ -102,7 +242,22 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St * @param info Instance of |UsdServiceDiscoveryInfo| containing information about the reply. */ @Override - public void onUsdPublishReplied(UsdServiceDiscoveryInfo info) { } + public void onUsdPublishReplied(UsdServiceDiscoveryInfo info) { + mWifiThreadRunner.post(() -> { + UsdNativeManager.UsdEventsCallback usdCallback = + mMainlineSupplicant.getUsdEventsCallback(); + if (usdCallback == null) { + Log.e(TAG, "UsdEventsCallback callback is null"); + return; + } + UsdRequestManager.UsdHalDiscoveryInfo convertedInfo = + convertHalToFrameworkUsdDiscoveryInfo(info); + if (convertedInfo == null) { + return; + } + usdCallback.onUsdPublishReplied(convertedInfo); + }); + } /** * Indicates that a publisher was discovered. Only called if this device is acting as a @@ -111,7 +266,22 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St * @param info Instance of |UsdServiceDiscoveryInfo| containing information about the service. */ @Override - public void onUsdServiceDiscovered(UsdServiceDiscoveryInfo info) { } + public void onUsdServiceDiscovered(UsdServiceDiscoveryInfo info) { + mWifiThreadRunner.post(() -> { + UsdNativeManager.UsdEventsCallback usdCallback = + mMainlineSupplicant.getUsdEventsCallback(); + if (usdCallback == null) { + Log.e(TAG, "UsdEventsCallback callback is null"); + return; + } + UsdRequestManager.UsdHalDiscoveryInfo convertedInfo = + convertHalToFrameworkUsdDiscoveryInfo(info); + if (convertedInfo == null) { + return; + } + usdCallback.onUsdServiceDiscovered(convertedInfo); + }); + } /** * Indicates that a message was received on an active USD link. @@ -119,5 +289,27 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St * @param messageInfo Information about the message that was received. */ @Override - public void onUsdMessageReceived(UsdMessageInfo messageInfo) { } + public void onUsdMessageReceived(UsdMessageInfo messageInfo) { + mWifiThreadRunner.post(() -> { + UsdNativeManager.UsdEventsCallback usdCallback = + mMainlineSupplicant.getUsdEventsCallback(); + if (usdCallback == null) { + Log.e(TAG, "UsdEventsCallback callback is null"); + return; + } + MacAddress peerAddress = safeConvertMacAddress(messageInfo.peerMacAddress); + if (peerAddress == null) { + Log.e(TAG, "USD message info contains an invalid peer address"); + return; + } + if (messageInfo.message == null) { + Log.e(TAG, "USD message info contains a null message"); + return; + } + usdCallback.onUsdMessageReceived(messageInfo.ownId, + messageInfo.peerId, + peerAddress, + messageInfo.message); + }); + } } diff --git a/service/java/com/android/server/wifi/p2p/WifiP2pServiceImpl.java b/service/java/com/android/server/wifi/p2p/WifiP2pServiceImpl.java index 450f3b4ec7..05a21be4a3 100644 --- a/service/java/com/android/server/wifi/p2p/WifiP2pServiceImpl.java +++ b/service/java/com/android/server/wifi/p2p/WifiP2pServiceImpl.java @@ -3026,12 +3026,12 @@ public class WifiP2pServiceImpl extends IWifiP2pManager.Stub { @Override public void enterImpl() { - + mWifiInjector.getWifiP2pConnection().setP2pInDisabledState(true); } @Override public void exitImpl() { - + mWifiInjector.getWifiP2pConnection().setP2pInDisabledState(false); } @Override @@ -3055,14 +3055,12 @@ public class WifiP2pServiceImpl extends IWifiP2pManager.Stub { Log.i(TAG, "No valid package name, ignore ENABLE_P2P"); break; } - mWifiInjector.getWifiP2pConnection().setP2pInWaitingState(true); int proceedWithOperation = mInterfaceConflictManager.manageInterfaceConflictForStateMachine( TAG, message, mP2pStateMachine, mWaitingState, mP2pDisabledState, HalDeviceManager.HDM_CREATE_IFACE_P2P, createRequestorWs(message.sendingUid, packageName), false /* bypassDialog */); - mWifiInjector.getWifiP2pConnection().setP2pInWaitingState(false); if (proceedWithOperation == InterfaceConflictManager.ICM_ABORT_COMMAND) { Log.e(TAG, "User refused to set up P2P"); updateThisDevice(WifiP2pDevice.UNAVAILABLE); @@ -3131,14 +3129,12 @@ public class WifiP2pServiceImpl extends IWifiP2pManager.Stub { Log.i(TAG, "No valid package name, do not set up the P2P interface"); return NOT_HANDLED; } - mWifiInjector.getWifiP2pConnection().setP2pInWaitingState(true); int proceedWithOperation = mInterfaceConflictManager.manageInterfaceConflictForStateMachine( TAG, message, mP2pStateMachine, mWaitingState, mP2pDisabledState, HalDeviceManager.HDM_CREATE_IFACE_P2P, createRequestorWs(message.sendingUid, packageName), false /* bypassDialog */); - mWifiInjector.getWifiP2pConnection().setP2pInWaitingState(false); if (proceedWithOperation == InterfaceConflictManager.ICM_ABORT_COMMAND) { Log.e(TAG, "User refused to set up P2P"); updateThisDevice(WifiP2pDevice.UNAVAILABLE); diff --git a/service/java/com/android/server/wifi/util/InformationElementUtil.java b/service/java/com/android/server/wifi/util/InformationElementUtil.java index f4fd25c168..9ac19d6283 100644 --- a/service/java/com/android/server/wifi/util/InformationElementUtil.java +++ b/service/java/com/android/server/wifi/util/InformationElementUtil.java @@ -2492,11 +2492,11 @@ public class InformationElementUtil { case ScanResult.CIPHER_NONE: return "None"; case ScanResult.CIPHER_CCMP: - return "CCMP"; + return "CCMP-128"; case ScanResult.CIPHER_CCMP_256: return "CCMP-256"; case ScanResult.CIPHER_GCMP_128: - return "GCMP"; + return "GCMP-128"; case ScanResult.CIPHER_GCMP_256: return "GCMP-256"; case ScanResult.CIPHER_TKIP: diff --git a/service/tests/wifitests/src/com/android/server/wifi/ClientModeImplTest.java b/service/tests/wifitests/src/com/android/server/wifi/ClientModeImplTest.java index 19f15a21a7..37ae9aa13e 100644 --- a/service/tests/wifitests/src/com/android/server/wifi/ClientModeImplTest.java +++ b/service/tests/wifitests/src/com/android/server/wifi/ClientModeImplTest.java @@ -11126,8 +11126,8 @@ public class ClientModeImplTest extends WifiBaseTest { } /** - * Verify that during DHCP process, 1. If P2P is in waiting state, clientModeImpl doesn't send a - * message to block P2P discovery. 2. If P2P is not in waiting state, clientModeImpl sends a + * Verify that during DHCP process, 1. If P2P is in disabled state, clientModeImpl doesn't send + * a message to block P2P discovery. 2. If P2P is not in disabled state, clientModeImpl sends a * message to block P2P discovery. 3. On DHCP completion, clientModeImpl sends a message to * unblock P2P discovery. */ @@ -11162,7 +11162,7 @@ public class ClientModeImplTest extends WifiBaseTest { assertEquals("L3ProvisioningState", getCurrentState().getName()); when(mWifiP2pConnection.isConnected()).thenReturn(true); - when(mWifiP2pConnection.isP2pInWaitingState()).thenReturn(true); + when(mWifiP2pConnection.isP2pInDisabledState()).thenReturn(true); mIpClientCallback.onPreDhcpAction(); mLooper.dispatchAll(); @@ -11170,7 +11170,7 @@ public class ClientModeImplTest extends WifiBaseTest { verify(mIpClient).completedPreDhcpAction(); when(mWifiP2pConnection.isConnected()).thenReturn(true); - when(mWifiP2pConnection.isP2pInWaitingState()).thenReturn(false); + when(mWifiP2pConnection.isP2pInDisabledState()).thenReturn(false); mIpClientCallback.onPreDhcpAction(); mLooper.dispatchAll(); diff --git a/service/tests/wifitests/src/com/android/server/wifi/SarManagerTest.java b/service/tests/wifitests/src/com/android/server/wifi/SarManagerTest.java index 867396da1d..fe582e3521 100644 --- a/service/tests/wifitests/src/com/android/server/wifi/SarManagerTest.java +++ b/service/tests/wifitests/src/com/android/server/wifi/SarManagerTest.java @@ -133,7 +133,6 @@ public class SarManagerTest extends WifiBaseTest { mWifiDeviceStateChangeManager); mSarMgr.handleBootCompleted(); - if (isSarEnabled) { /* Capture the PhoneStateListener */ ArgumentCaptor<PhoneStateListener> phoneStateListenerCaptor = @@ -573,4 +572,44 @@ public class SarManagerTest extends WifiBaseTest { assertTrue(mSarInfo.isWifiScanOnlyEnabled); assertFalse(mSarInfo.isWifiClientEnabled); } + + /** + * Test that for devices that support setting/resetting Tx Power limits, device sets wifi enable + * first then finish the boot up. Verify device will change the power scenario. + */ + @Test + public void testSarMgr_enabledTxPowerScenario_wifiOn_before_boot_completed_offHook() { + mResources.setBoolean( + R.bool.config_wifi_framework_enable_sar_tx_power_limit, true); + mResources.setBoolean( + R.bool.config_wifi_framework_enable_soft_ap_sar_tx_power_limit, + false); + + mSarMgr = new SarManager(mContext, mTelephonyManager, mLooper.getLooper(), mWifiNative, + mWifiDeviceStateChangeManager); + /* Enable logs from SarManager */ + enableDebugLogs(); + + InOrder inOrder = inOrder(mWifiNative); + // Enable wifi first, should be no change to the WifiNative + mSarMgr.setClientWifiState(WifiManager.WIFI_STATE_ENABLED); + inOrder.verify(mWifiNative, never()).selectTxPowerScenario(any()); + + mSarMgr.handleBootCompleted(); + ArgumentCaptor<PhoneStateListener> phoneStateListenerCaptor = + ArgumentCaptor.forClass(PhoneStateListener.class); + verify(mTelephonyManager).listen(phoneStateListenerCaptor.capture(), + eq(PhoneStateListener.LISTEN_CALL_STATE)); + mPhoneStateListener = phoneStateListenerCaptor.getValue(); + assertNotNull(mPhoneStateListener); + captureSarInfo(mWifiNative); + assertFalse(mSarInfo.isVoiceCall); + inOrder.verify(mWifiNative).selectTxPowerScenario(eq(mSarInfo)); + + /* Set phone state to OFFHOOK */ + mPhoneStateListener.onCallStateChanged(CALL_STATE_OFFHOOK, ""); + + inOrder.verify(mWifiNative).selectTxPowerScenario(eq(mSarInfo)); + assertTrue(mSarInfo.isVoiceCall); + } } diff --git a/service/tests/wifitests/src/com/android/server/wifi/WifiLockManagerTest.java b/service/tests/wifitests/src/com/android/server/wifi/WifiLockManagerTest.java index 4e5250d387..cbdf1e80e0 100644 --- a/service/tests/wifitests/src/com/android/server/wifi/WifiLockManagerTest.java +++ b/service/tests/wifitests/src/com/android/server/wifi/WifiLockManagerTest.java @@ -303,7 +303,7 @@ public class WifiLockManagerTest extends WifiBaseTest { acquireWifiLockSuccessful(WifiManager.WIFI_MODE_FULL_HIGH_PERF, "", mBinder, mWorkSource); releaseWifiLockSuccessful(mBinder); - verify(mWifiMetrics).addWifiLockAcqSession( + verify(mWifiMetrics).addWifiLockManagerAcqSession( eq(mDeviceConfigFacade.isHighPerfLockDeprecated() && SdkLevel.isAtLeastU() ? WifiManager.WIFI_MODE_FULL_LOW_LATENCY : WifiManager.WIFI_MODE_FULL_HIGH_PERF), eq(new int[]{DEFAULT_TEST_UID_1}), @@ -597,7 +597,7 @@ public class WifiLockManagerTest extends WifiBaseTest { mLooper.dispatchAll(); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, true); - verify(mWifiMetrics).addWifiLockActiveSession(eq(expectedMode), + verify(mWifiMetrics).addWifiLockManagerActiveSession(eq(expectedMode), eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); } @@ -632,7 +632,7 @@ public class WifiLockManagerTest extends WifiBaseTest { // Release the first lock releaseWifiLockSuccessful(mBinder); - verify(mWifiMetrics).addWifiLockAcqSession(eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), + verify(mWifiMetrics).addWifiLockManagerAcqSession(eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyInt(), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); @@ -646,15 +646,17 @@ public class WifiLockManagerTest extends WifiBaseTest { releaseWifiLockSuccessful(mBinder2); mLooper.moveTimeForward(DELAY_LOCK_RELEASE_MS + 1); mLooper.dispatchAll(); - verify(mWifiMetrics).addWifiLockActiveSession(eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), - eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyLong(), anyBoolean(), + verify(mWifiMetrics).addWifiLockManagerActiveSession( + eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), eq(new int[]{DEFAULT_TEST_UID_1}), + eq(new String[]{null}), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); assertEquals(WifiManager.WIFI_MODE_NO_LOCKS_HELD, mWifiLockManager.getStrongestLockMode()); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, true); - verify(mWifiMetrics).addWifiLockActiveSession(eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), - eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyLong(), anyBoolean(), + verify(mWifiMetrics).addWifiLockManagerActiveSession( + eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), eq(new int[]{DEFAULT_TEST_UID_1}), + eq(new String[]{null}), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); } @@ -782,7 +784,7 @@ public class WifiLockManagerTest extends WifiBaseTest { false); releaseWifiLockSuccessful(mBinder); - verify(mWifiMetrics).addWifiLockAcqSession(eq(expectedMode), + verify(mWifiMetrics).addWifiLockManagerAcqSession(eq(expectedMode), eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyInt(), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); assertEquals(WifiManager.WIFI_MODE_NO_LOCKS_HELD, @@ -791,7 +793,7 @@ public class WifiLockManagerTest extends WifiBaseTest { mLooper.dispatchAll(); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, true); - verify(mWifiMetrics, never()).addWifiLockActiveSession( + verify(mWifiMetrics, never()).addWifiLockManagerActiveSession( eq(expectedMode), eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); @@ -804,7 +806,7 @@ public class WifiLockManagerTest extends WifiBaseTest { mWifiLockManager.getStrongestLockMode()); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, true); - verify(mWifiMetrics).addWifiLockActiveSession(eq(expectedMode), + verify(mWifiMetrics).addWifiLockManagerActiveSession(eq(expectedMode), eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); } @@ -833,9 +835,9 @@ public class WifiLockManagerTest extends WifiBaseTest { mWifiLockManager.getStrongestLockMode()); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, true); - verify(mWifiMetrics).addWifiLockActiveSession(eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), - eq(new int[0]), eq(new String[0]), anyLong(), anyBoolean(), - anyBoolean(), anyBoolean()); + verify(mWifiMetrics).addWifiLockManagerActiveSession( + eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), eq(new int[0]), eq(new String[0]), + anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); } /** @@ -863,7 +865,7 @@ public class WifiLockManagerTest extends WifiBaseTest { eq(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK), anyBoolean()); releaseWifiLockSuccessful(mBinder); - verify(mWifiMetrics).addWifiLockAcqSession(eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), + verify(mWifiMetrics).addWifiLockManagerAcqSession(eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyInt(), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); assertEquals(WifiManager.WIFI_MODE_FULL_HIGH_PERF, @@ -876,8 +878,9 @@ public class WifiLockManagerTest extends WifiBaseTest { mWifiLockManager.getStrongestLockMode()); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, true); - verify(mWifiMetrics).addWifiLockActiveSession(eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), - eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyLong(), anyBoolean(), + verify(mWifiMetrics).addWifiLockManagerActiveSession( + eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), eq(new int[]{DEFAULT_TEST_UID_1}), + eq(new String[]{null}), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); } @@ -1101,8 +1104,9 @@ public class WifiLockManagerTest extends WifiBaseTest { inOrder.verify(mClientModeManager).setLowLatencyMode(false); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, true); - verify(mWifiMetrics).addWifiLockActiveSession(eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), - eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyLong(), anyBoolean(), + verify(mWifiMetrics).addWifiLockManagerActiveSession( + eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), eq(new int[]{DEFAULT_TEST_UID_1}), + eq(new String[]{null}), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); } @@ -1201,8 +1205,9 @@ public class WifiLockManagerTest extends WifiBaseTest { inOrder.verify(mClientModeManager).setLowLatencyMode(false); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, true); - verify(mWifiMetrics).addWifiLockActiveSession(eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), - eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyLong(), anyBoolean(), + verify(mWifiMetrics).addWifiLockManagerActiveSession( + eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), eq(new int[]{DEFAULT_TEST_UID_1}), + eq(new String[]{null}), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); } @@ -1245,8 +1250,9 @@ public class WifiLockManagerTest extends WifiBaseTest { inOrder.verify(mClientModeManager).setLowLatencyMode(false); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, true); - verify(mWifiMetrics).addWifiLockActiveSession(eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), - eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyLong(), anyBoolean(), + verify(mWifiMetrics).addWifiLockManagerActiveSession( + eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), eq(new int[]{DEFAULT_TEST_UID_1}), + eq(new String[]{null}), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); } @@ -1335,8 +1341,9 @@ public class WifiLockManagerTest extends WifiBaseTest { inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, true); - verify(mWifiMetrics).addWifiLockActiveSession(eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), - eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyLong(), anyBoolean(), + verify(mWifiMetrics).addWifiLockManagerActiveSession( + eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), eq(new int[]{DEFAULT_TEST_UID_1}), + eq(new String[]{null}), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); inOrder.verify(mClientModeManager).setLowLatencyMode(true); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, @@ -1375,9 +1382,9 @@ public class WifiLockManagerTest extends WifiBaseTest { inOrder.verify(mClientModeManager).setLowLatencyMode(false); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, true); - verify(mWifiMetrics).addWifiLockActiveSession(eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), - eq(new int[0]), eq(new String[0]), anyLong(), anyBoolean(), - anyBoolean(), anyBoolean()); + verify(mWifiMetrics).addWifiLockManagerActiveSession( + eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), eq(new int[0]), eq(new String[0]), + anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); } /** @@ -1463,8 +1470,9 @@ public class WifiLockManagerTest extends WifiBaseTest { inOrder.verify(mClientModeManager).setLowLatencyMode(false); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, true); - verify(mWifiMetrics).addWifiLockActiveSession(eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), - eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyLong(), anyBoolean(), + verify(mWifiMetrics).addWifiLockManagerActiveSession( + eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), eq(new int[]{DEFAULT_TEST_UID_1}), + eq(new String[]{null}), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); } @@ -1522,9 +1530,9 @@ public class WifiLockManagerTest extends WifiBaseTest { inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, true); - verify(mWifiMetrics).addWifiLockActiveSession(eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), - eq(new int[0]), eq(new String[0]), anyLong(), anyBoolean(), anyBoolean(), - anyBoolean()); + verify(mWifiMetrics).addWifiLockManagerActiveSession( + eq(WifiManager.WIFI_MODE_FULL_HIGH_PERF), eq(new int[0]), eq(new String[0]), + anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); inOrder.verify(mClientModeManager).setLowLatencyMode(true); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, false); @@ -1557,9 +1565,9 @@ public class WifiLockManagerTest extends WifiBaseTest { inOrder.verify(mClientModeManager).setLowLatencyMode(false); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, true); - verify(mWifiMetrics).addWifiLockActiveSession(eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), - eq(new int[0]), eq(new String[0]), anyLong(), anyBoolean(), anyBoolean(), - anyBoolean()); + verify(mWifiMetrics).addWifiLockManagerActiveSession( + eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), eq(new int[0]), eq(new String[0]), + anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); inOrder.verify(mClientModeManager).setPowerSave(ClientMode.POWER_SAVE_CLIENT_WIFI_LOCK, false); } @@ -1748,8 +1756,8 @@ public class WifiLockManagerTest extends WifiBaseTest { when(mClock.getElapsedSinceBootMillis()).thenReturn(deactivationTime); mWifiLockManager.updateWifiClientConnected(mClientModeManager, false); - verify(mWifiMetrics).addWifiLockActiveSession(eq(expectedMode), - eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), + verify(mWifiMetrics).addWifiLockManagerActiveSession( + eq(expectedMode), eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), eq(deactivationTime - activationTime), eq(true), eq(false), eq(false)); @@ -1757,7 +1765,7 @@ public class WifiLockManagerTest extends WifiBaseTest { when(mClock.getElapsedSinceBootMillis()).thenReturn(releaseTime); releaseWifiLockSuccessful_noBatteryStats(mBinder); - verify(mWifiMetrics).addWifiLockAcqSession(eq(expectedMode), + verify(mWifiMetrics).addWifiLockManagerAcqSession(eq(expectedMode), eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyInt(), eq(releaseTime - acquireTime), eq(true), eq(false), eq(false)); } @@ -1800,7 +1808,8 @@ public class WifiLockManagerTest extends WifiBaseTest { when(mClock.getElapsedSinceBootMillis()).thenReturn(deactivationTime); mWifiLockManager.updateWifiClientConnected(mClientModeManager, false); - verify(mWifiMetrics).addWifiLockActiveSession(eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), + verify(mWifiMetrics).addWifiLockManagerActiveSession( + eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), eq(deactivationTime - activationTime), eq(true), eq(false), eq(false)); @@ -1808,7 +1817,8 @@ public class WifiLockManagerTest extends WifiBaseTest { when(mClock.getElapsedSinceBootMillis()).thenReturn(releaseTime); releaseWifiLockSuccessful_noBatteryStats(mBinder); - verify(mWifiMetrics).addWifiLockAcqSession(eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), + verify(mWifiMetrics).addWifiLockManagerAcqSession( + eq(WifiManager.WIFI_MODE_FULL_LOW_LATENCY), eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyInt(), eq(releaseTime - acquireTime), eq(true), eq(false), eq(false)); @@ -1851,7 +1861,7 @@ public class WifiLockManagerTest extends WifiBaseTest { acquireWifiLockSuccessful(WifiManager.WIFI_MODE_FULL_HIGH_PERF, TEST_WIFI_LOCK_TAG, mBinder, mWorkSource); releaseWifiLockSuccessful(mBinder); - verify(mWifiMetrics).addWifiLockAcqSession(eq(expectedMode), + verify(mWifiMetrics).addWifiLockManagerAcqSession(eq(expectedMode), eq(new int[]{DEFAULT_TEST_UID_1}), eq(new String[]{null}), anyInt(), anyLong(), anyBoolean(), anyBoolean(), anyBoolean()); acquireWifiLockSuccessful(WifiManager.WIFI_MODE_FULL_HIGH_PERF, TEST_WIFI_LOCK_TAG, diff --git a/service/tests/wifitests/src/com/android/server/wifi/WifiMetricsTest.java b/service/tests/wifitests/src/com/android/server/wifi/WifiMetricsTest.java index 3d3a2e6924..1e9c381554 100644 --- a/service/tests/wifitests/src/com/android/server/wifi/WifiMetricsTest.java +++ b/service/tests/wifitests/src/com/android/server/wifi/WifiMetricsTest.java @@ -5530,7 +5530,7 @@ public class WifiMetricsTest extends WifiBaseTest { */ @Test public void testWifiLockActiveSession() throws Exception { - mWifiMetrics.addWifiLockActiveSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, + mWifiMetrics.addWifiLockManagerActiveSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, new int[]{TEST_UID}, new String[]{TEST_TAG}, 100000, true, false, false); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_DEACTIVATED, new int[]{TEST_UID}, @@ -5538,7 +5538,7 @@ public class WifiMetricsTest extends WifiBaseTest { WifiStatsLog.WIFI_LOCK_DEACTIVATED__MODE__WIFI_MODE_FULL_HIGH_PERF, 100000, true, false, false)); - mWifiMetrics.addWifiLockActiveSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, + mWifiMetrics.addWifiLockManagerActiveSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, new int[]{TEST_UID}, new String[]{TEST_TAG}, 10000, true, true, false); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_DEACTIVATED, new int[]{TEST_UID}, @@ -5546,7 +5546,7 @@ public class WifiMetricsTest extends WifiBaseTest { WifiStatsLog.WIFI_LOCK_DEACTIVATED__MODE__WIFI_MODE_FULL_HIGH_PERF, 10000, true, true, false)); - mWifiMetrics.addWifiLockActiveSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, + mWifiMetrics.addWifiLockManagerActiveSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, new int[]{TEST_UID}, new String[]{TEST_TAG}, 10000000, true, true, true); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_DEACTIVATED, new int[]{TEST_UID}, @@ -5554,7 +5554,7 @@ public class WifiMetricsTest extends WifiBaseTest { WifiStatsLog.WIFI_LOCK_DEACTIVATED__MODE__WIFI_MODE_FULL_HIGH_PERF, 10000000, true, true, true)); - mWifiMetrics.addWifiLockActiveSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, + mWifiMetrics.addWifiLockManagerActiveSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, new int[]{TEST_UID}, new String[]{TEST_TAG}, 1000, false, false, false); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_DEACTIVATED, new int[]{TEST_UID}, @@ -5562,7 +5562,7 @@ public class WifiMetricsTest extends WifiBaseTest { WifiStatsLog.WIFI_LOCK_DEACTIVATED__MODE__WIFI_MODE_FULL_HIGH_PERF, 1000, false, false, false)); - mWifiMetrics.addWifiLockActiveSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, + mWifiMetrics.addWifiLockManagerActiveSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, new int[]{TEST_UID}, new String[]{TEST_TAG}, 90000, false, false, false); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_DEACTIVATED, new int[]{TEST_UID}, @@ -5570,7 +5570,7 @@ public class WifiMetricsTest extends WifiBaseTest { WifiStatsLog.WIFI_LOCK_DEACTIVATED__MODE__WIFI_MODE_FULL_LOW_LATENCY, 90000, false, false, false)); - mWifiMetrics.addWifiLockActiveSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, + mWifiMetrics.addWifiLockManagerActiveSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, new int[]{TEST_UID}, new String[]{TEST_TAG}, 900000, true, false, false); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_DEACTIVATED, new int[]{TEST_UID}, @@ -5578,7 +5578,7 @@ public class WifiMetricsTest extends WifiBaseTest { WifiStatsLog.WIFI_LOCK_DEACTIVATED__MODE__WIFI_MODE_FULL_LOW_LATENCY, 900000, true, false, false)); - mWifiMetrics.addWifiLockActiveSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, + mWifiMetrics.addWifiLockManagerActiveSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, new int[]{TEST_UID}, new String[]{TEST_TAG}, 9000, true, true, false); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_DEACTIVATED, new int[]{TEST_UID}, @@ -5586,7 +5586,7 @@ public class WifiMetricsTest extends WifiBaseTest { WifiStatsLog.WIFI_LOCK_DEACTIVATED__MODE__WIFI_MODE_FULL_LOW_LATENCY, 9000, true, true, false)); - mWifiMetrics.addWifiLockActiveSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, + mWifiMetrics.addWifiLockManagerActiveSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, new int[]{TEST_UID}, new String[]{TEST_TAG}, 20000000, true, true, true); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_DEACTIVATED, new int[]{TEST_UID}, @@ -5624,8 +5624,8 @@ public class WifiMetricsTest extends WifiBaseTest { * Test the WifiLock acquisition session statistics */ @Test - public void testWifiLockAcqSession() throws Exception { - mWifiMetrics.addWifiLockAcqSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, + public void testWifiLockManagerAcqSession() throws Exception { + mWifiMetrics.addWifiLockManagerAcqSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, new int[]{TEST_UID}, new String[]{TEST_TAG}, 0, 100000, false, false, false); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_RELEASED, new int[]{TEST_UID}, @@ -5633,7 +5633,7 @@ public class WifiMetricsTest extends WifiBaseTest { WifiStatsLog.WIFI_LOCK_RELEASED__MODE__WIFI_MODE_FULL_HIGH_PERF, 100000, false, false, false)); - mWifiMetrics.addWifiLockAcqSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, + mWifiMetrics.addWifiLockManagerAcqSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, new int[]{TEST_UID}, new String[]{TEST_TAG}, 0, 10000, true, false, false); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_RELEASED, new int[]{TEST_UID}, @@ -5641,7 +5641,7 @@ public class WifiMetricsTest extends WifiBaseTest { WifiStatsLog.WIFI_LOCK_RELEASED__MODE__WIFI_MODE_FULL_HIGH_PERF, 10000, true, false, false)); - mWifiMetrics.addWifiLockAcqSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, + mWifiMetrics.addWifiLockManagerAcqSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, new int[]{TEST_UID}, new String[]{TEST_TAG}, 0, 10000000, true, true, false); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_RELEASED, new int[]{TEST_UID}, @@ -5649,7 +5649,7 @@ public class WifiMetricsTest extends WifiBaseTest { WifiStatsLog.WIFI_LOCK_RELEASED__MODE__WIFI_MODE_FULL_HIGH_PERF, 10000000, true, true, false)); - mWifiMetrics.addWifiLockAcqSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, + mWifiMetrics.addWifiLockManagerAcqSession(WifiManager.WIFI_MODE_FULL_HIGH_PERF, new int[]{TEST_UID}, new String[]{TEST_TAG}, 0, 1000, true, true, true); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_RELEASED, new int[]{TEST_UID}, @@ -5658,7 +5658,7 @@ public class WifiMetricsTest extends WifiBaseTest { true, true, true)); - mWifiMetrics.addWifiLockAcqSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, + mWifiMetrics.addWifiLockManagerAcqSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, new int[]{TEST_UID}, new String[]{TEST_TAG}, 0, 90000, false, false, false); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_RELEASED, new int[]{TEST_UID}, @@ -5666,7 +5666,7 @@ public class WifiMetricsTest extends WifiBaseTest { WifiStatsLog.WIFI_LOCK_RELEASED__MODE__WIFI_MODE_FULL_LOW_LATENCY, 90000, false, false, false)); - mWifiMetrics.addWifiLockAcqSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, + mWifiMetrics.addWifiLockManagerAcqSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, new int[]{TEST_UID}, new String[]{TEST_TAG}, 0, 900000, true, false, false); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_RELEASED, new int[]{TEST_UID}, @@ -5674,7 +5674,7 @@ public class WifiMetricsTest extends WifiBaseTest { WifiStatsLog.WIFI_LOCK_RELEASED__MODE__WIFI_MODE_FULL_LOW_LATENCY, 900000, true, false, false)); - mWifiMetrics.addWifiLockAcqSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, + mWifiMetrics.addWifiLockManagerAcqSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, new int[]{TEST_UID}, new String[]{TEST_TAG}, 0, 9000, true, true, false); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_RELEASED, new int[]{TEST_UID}, @@ -5682,7 +5682,7 @@ public class WifiMetricsTest extends WifiBaseTest { WifiStatsLog.WIFI_LOCK_RELEASED__MODE__WIFI_MODE_FULL_LOW_LATENCY, 9000, true, true, false)); - mWifiMetrics.addWifiLockAcqSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, + mWifiMetrics.addWifiLockManagerAcqSession(WifiManager.WIFI_MODE_FULL_LOW_LATENCY, new int[]{TEST_UID}, new String[]{TEST_TAG}, 0, 20000000, true, true, true); ExtendedMockito.verify( () -> WifiStatsLog.write(WifiStatsLog.WIFI_LOCK_RELEASED, new int[]{TEST_UID}, diff --git a/service/tests/wifitests/src/com/android/server/wifi/WifiMulticastLockManagerTest.java b/service/tests/wifitests/src/com/android/server/wifi/WifiMulticastLockManagerTest.java index f57f8c43b1..8ce4a8d191 100644 --- a/service/tests/wifitests/src/com/android/server/wifi/WifiMulticastLockManagerTest.java +++ b/service/tests/wifitests/src/com/android/server/wifi/WifiMulticastLockManagerTest.java @@ -34,6 +34,7 @@ import androidx.test.filters.SmallTest; import com.android.server.wifi.ActiveModeWarden.PrimaryClientModeManagerChangedCallback; import com.android.server.wifi.WifiMulticastLockManager.FilterController; +import com.android.server.wifi.util.WifiPermissionsUtil; import org.junit.Before; import org.junit.Test; @@ -52,6 +53,9 @@ public class WifiMulticastLockManagerTest extends WifiBaseTest { private static final String WL_1_TAG = "Wakelock-1"; private static final String WL_2_TAG = "Wakelock-2"; private static final int TEST_UID = 123; + private static final String TEST_ATTRIBUTION_TAG = "attribution-tag"; + private static final String TEST_PACKAGE_NAME = "package-name"; + private static final long START_TIME = 0; private TestLooper mLooper; @Mock ConcreteClientModeManager mClientModeManager; @@ -62,6 +66,9 @@ public class WifiMulticastLockManagerTest extends WifiBaseTest { @Mock ActiveModeWarden mActiveModeWarden; @Mock Context mContext; @Mock ActivityManager mActivityManager; + @Mock Clock mClock; + @Mock WifiMetrics mWifiMetrics; + @Mock WifiPermissionsUtil mWifiPermissionsUtil; @Captor ArgumentCaptor<PrimaryClientModeManagerChangedCallback> mPrimaryChangedCallbackCaptor; @Captor ArgumentCaptor<ActivityManager.OnUidImportanceListener> mUidImportanceListenerCaptor = ArgumentCaptor.forClass(ActivityManager.OnUidImportanceListener.class); @@ -86,7 +93,7 @@ public class WifiMulticastLockManagerTest extends WifiBaseTest { when(mActiveModeWarden.getPrimaryClientModeManager()).thenReturn(mClientModeManager); when(mContext.getSystemService(ActivityManager.class)).thenReturn(mActivityManager); mManager = new WifiMulticastLockManager(mActiveModeWarden, mBatteryStats, - mLooper.getLooper(), mContext); + mLooper.getLooper(), mContext, mClock, mWifiMetrics, mWifiPermissionsUtil); verify(mActiveModeWarden).registerPrimaryClientModeManagerChangedCallback( mPrimaryChangedCallbackCaptor.capture()); @@ -110,7 +117,7 @@ public class WifiMulticastLockManagerTest extends WifiBaseTest { @Test public void oneLock() throws RemoteException { IBinder binder = mock(IBinder.class); - mManager.acquireLock(TEST_UID, binder, WL_1_TAG); + mManager.acquireLock(TEST_UID, binder, WL_1_TAG, TEST_ATTRIBUTION_TAG, TEST_PACKAGE_NAME); assertTrue(mManager.isMulticastEnabled()); verify(mFilterController).stopFilteringMulticastPackets(); mManager.startFilteringMulticastPackets(); @@ -160,7 +167,7 @@ public class WifiMulticastLockManagerTest extends WifiBaseTest { assertTrue(mFilterController2.isFilteringStarted()); IBinder binder = mock(IBinder.class); - mManager.acquireLock(TEST_UID, binder, WL_1_TAG); + mManager.acquireLock(TEST_UID, binder, WL_1_TAG, TEST_ATTRIBUTION_TAG, TEST_PACKAGE_NAME); assertTrue(mManager.isMulticastEnabled()); // CMM1 filtering stopped assertFalse(mFilterController.isFilteringStarted()); @@ -195,7 +202,7 @@ public class WifiMulticastLockManagerTest extends WifiBaseTest { @Test public void oneLock_wrongName() throws RemoteException { IBinder binder = mock(IBinder.class); - mManager.acquireLock(TEST_UID, binder, WL_1_TAG); + mManager.acquireLock(TEST_UID, binder, WL_1_TAG, TEST_ATTRIBUTION_TAG, TEST_PACKAGE_NAME); assertTrue(mManager.isMulticastEnabled()); verify(mFilterController).stopFilteringMulticastPackets(); mManager.startFilteringMulticastPackets(); @@ -218,12 +225,12 @@ public class WifiMulticastLockManagerTest extends WifiBaseTest { InOrder inOrderHandler = inOrder(mFilterController); InOrder inOrderBatteryStats = inOrder(mBatteryStats); - mManager.acquireLock(TEST_UID, binder, WL_1_TAG); + mManager.acquireLock(TEST_UID, binder, WL_1_TAG, TEST_ATTRIBUTION_TAG, TEST_PACKAGE_NAME); inOrderHandler.verify(mFilterController).stopFilteringMulticastPackets(); inOrderBatteryStats.verify(mBatteryStats).reportWifiMulticastEnabled(any()); assertTrue(mManager.isMulticastEnabled()); - mManager.acquireLock(TEST_UID, binder, WL_2_TAG); + mManager.acquireLock(TEST_UID, binder, WL_2_TAG, TEST_ATTRIBUTION_TAG, TEST_PACKAGE_NAME); inOrderHandler.verify(mFilterController).stopFilteringMulticastPackets(); inOrderBatteryStats.verify(mBatteryStats).reportWifiMulticastEnabled(any()); assertTrue(mManager.isMulticastEnabled()); @@ -252,12 +259,12 @@ public class WifiMulticastLockManagerTest extends WifiBaseTest { InOrder inOrderHandler = inOrder(mFilterController); InOrder inOrderBatteryStats = inOrder(mBatteryStats); - mManager.acquireLock(TEST_UID, binder, WL_1_TAG); + mManager.acquireLock(TEST_UID, binder, WL_1_TAG, TEST_ATTRIBUTION_TAG, TEST_PACKAGE_NAME); inOrderHandler.verify(mFilterController).stopFilteringMulticastPackets(); inOrderBatteryStats.verify(mBatteryStats).reportWifiMulticastEnabled(any()); assertTrue(mManager.isMulticastEnabled()); - mManager.acquireLock(TEST_UID, binder, WL_2_TAG); + mManager.acquireLock(TEST_UID, binder, WL_2_TAG, TEST_ATTRIBUTION_TAG, TEST_PACKAGE_NAME); inOrderHandler.verify(mFilterController).stopFilteringMulticastPackets(); inOrderBatteryStats.verify(mBatteryStats).reportWifiMulticastEnabled(any()); assertTrue(mManager.isMulticastEnabled()); @@ -288,8 +295,8 @@ public class WifiMulticastLockManagerTest extends WifiBaseTest { IBinder binder2 = mock(IBinder.class); // Both acquired locks have the same tag - mManager.acquireLock(TEST_UID, binder1, WL_1_TAG); - mManager.acquireLock(TEST_UID, binder2, WL_1_TAG); + mManager.acquireLock(TEST_UID, binder1, WL_1_TAG, TEST_ATTRIBUTION_TAG, TEST_PACKAGE_NAME); + mManager.acquireLock(TEST_UID, binder2, WL_1_TAG, TEST_ATTRIBUTION_TAG, TEST_PACKAGE_NAME); assertTrue(mManager.isMulticastEnabled()); mManager.releaseLock(TEST_UID, binder1, WL_1_TAG); @@ -308,7 +315,7 @@ public class WifiMulticastLockManagerTest extends WifiBaseTest { @Test public void testSingleLockActiveStateChange() { IBinder binder = mock(IBinder.class); - mManager.acquireLock(TEST_UID, binder, WL_1_TAG); + mManager.acquireLock(TEST_UID, binder, WL_1_TAG, TEST_ATTRIBUTION_TAG, TEST_PACKAGE_NAME); assertTrue(mManager.isMulticastEnabled()); verify(mFilterController).stopFilteringMulticastPackets(); @@ -339,11 +346,15 @@ public class WifiMulticastLockManagerTest extends WifiBaseTest { public void testMultipleOwnersActiveStateChange() { int uid1 = TEST_UID; int uid2 = TEST_UID + 1; + String attributionTag1 = "attribution-tag-1"; + String attributionTag2 = "attribution-tag-2"; + String packageName1 = "package-name-1"; + String packageName2 = "package-name-2"; IBinder binder1 = mock(IBinder.class); IBinder binder2 = mock(IBinder.class); - mManager.acquireLock(uid1, binder1, WL_1_TAG); - mManager.acquireLock(uid2, binder2, WL_2_TAG); + mManager.acquireLock(uid1, binder1, WL_1_TAG, attributionTag1, packageName1); + mManager.acquireLock(uid2, binder2, WL_2_TAG, attributionTag2, packageName2); assertTrue(mManager.isMulticastEnabled()); verify(mFilterController, times(2)).stopFilteringMulticastPackets(); @@ -379,4 +390,86 @@ public class WifiMulticastLockManagerTest extends WifiBaseTest { assertFalse(mManager.isMulticastEnabled()); verify(mFilterController, times(2)).startFilteringMulticastPackets(); } + + /** + * Verify that an acquire session is logged in the metrics when a lock is released. + */ + @Test + public void testAcquireSessionMetrics() { + IBinder binder = mock(IBinder.class); + when(mClock.getElapsedSinceBootMillis()).thenReturn(START_TIME); + mManager.acquireLock(TEST_UID, binder, WL_1_TAG, TEST_ATTRIBUTION_TAG, TEST_PACKAGE_NAME); + + // Advance clock by 10 ms and release the lock + when(mClock.getElapsedSinceBootMillis()).thenReturn(START_TIME + 10); + mManager.releaseLock(TEST_UID, binder, WL_1_TAG); + verify(mWifiMetrics).addMulticastLockManagerAcqSession( + eq(TEST_UID), eq(TEST_ATTRIBUTION_TAG), anyInt(), eq(10L) /* duration */); + } + + /** + * Verify that an active session is logged when multicast filtering is re-enabled, + * and that an acquire session is logged when a multicast lock is released. + */ + @Test + public void testSingleLockActiveSessionMetrics() { + IBinder binder = mock(IBinder.class); + when(mClock.getElapsedSinceBootMillis()).thenReturn(START_TIME); + mManager.acquireLock(TEST_UID, binder, WL_1_TAG, TEST_ATTRIBUTION_TAG, TEST_PACKAGE_NAME); + + // Transition the UID to low importance at t=10 + // Since this is the only lock, this should re-enable packet filtering + when(mClock.getElapsedSinceBootMillis()).thenReturn(START_TIME + 10); + mUidImportanceListenerCaptor.getValue().onUidImportance( + TEST_UID, ActivityManager.RunningAppProcessInfo.IMPORTANCE_CACHED); + mLooper.dispatchAll(); + + // Release the lock at t=20 + when(mClock.getElapsedSinceBootMillis()).thenReturn(START_TIME + 20); + mManager.releaseLock(TEST_UID, binder, WL_1_TAG); + + // Verify that the active session was logged during the priority switch (t=10) + // and that the lock acquire session was logged during the lock release (t=20) + verify(mWifiMetrics).addMulticastLockManagerActiveSession(eq(10L)); + verify(mWifiMetrics).addMulticastLockManagerAcqSession( + eq(TEST_UID), eq(TEST_ATTRIBUTION_TAG), anyInt(), eq(20L)); + } + + /** + * See comment for {@link #testSingleLockActiveSessionMetrics()}. + * This case considers a multi-lock scenario. + */ + @Test + public void testMultiLockActiveSessionMetrics() { + int uid1 = TEST_UID; + int uid2 = TEST_UID + 1; + String attributionTag1 = "attribution-tag-1"; + String attributionTag2 = "attribution-tag-2"; + String packageName1 = "package-name-1"; + String packageName2 = "package-name-2"; + IBinder binder1 = mock(IBinder.class); + IBinder binder2 = mock(IBinder.class); + + when(mClock.getElapsedSinceBootMillis()).thenReturn(START_TIME); + mManager.acquireLock(uid1, binder1, WL_1_TAG, attributionTag1, packageName1); + mManager.acquireLock(uid2, binder2, WL_2_TAG, attributionTag2, packageName2); + + // Release lock 1 at t=10. Multicast filtering is still disabled. + when(mClock.getElapsedSinceBootMillis()).thenReturn(START_TIME + 10); + mManager.releaseLock(uid1, binder1, WL_1_TAG); + + // Release lock 2 at t=20. Multicast filtering should be re-enabled. + when(mClock.getElapsedSinceBootMillis()).thenReturn(START_TIME + 20); + mManager.releaseLock(uid2, binder2, WL_2_TAG); + + // An acquire session should have been logged when each lock was released + verify(mWifiMetrics).addMulticastLockManagerAcqSession( + eq(uid1), eq(attributionTag1), anyInt(), eq(10L)); + verify(mWifiMetrics).addMulticastLockManagerAcqSession( + eq(uid2), eq(attributionTag2), anyInt(), eq(20L)); + + // A single active session should have been logged when the final lock was released (t=20) + verify(mWifiMetrics, times(1)).addMulticastLockManagerActiveSession(anyLong()); + verify(mWifiMetrics).addMulticastLockManagerActiveSession(eq(20L)); + } } diff --git a/service/tests/wifitests/src/com/android/server/wifi/WifiNetworkFactoryTest.java b/service/tests/wifitests/src/com/android/server/wifi/WifiNetworkFactoryTest.java index 21aba31784..329a7a8ef0 100644 --- a/service/tests/wifitests/src/com/android/server/wifi/WifiNetworkFactoryTest.java +++ b/service/tests/wifitests/src/com/android/server/wifi/WifiNetworkFactoryTest.java @@ -3342,6 +3342,7 @@ public class WifiNetworkFactoryTest extends WifiBaseTest { WifiConfigurationTestUtil.createPskNetwork(), TEST_UID_1, TEST_PACKAGE_NAME_1, new int[0]); mWifiNetworkFactory.needNetworkFor(mNetworkRequest); + setScreenState(false); // Verify we did not trigger the UI for the second request. verify(mContext, never()).startActivityAsUser(any(), any()); diff --git a/service/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareStateManagerTest.java b/service/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareStateManagerTest.java index b5041c7a63..a4ebf7b185 100644 --- a/service/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareStateManagerTest.java +++ b/service/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareStateManagerTest.java @@ -3873,6 +3873,7 @@ public class WifiAwareStateManagerTest extends WifiBaseTest { validateCorrectAwareStatusChangeBroadcast(inOrder); inOrder.verify(mMockNative).disable(transactionId.capture()); mDut.onDisableResponse(transactionId.getValue(), NanStatusCode.SUCCESS); + mDut.onAwareDownNotification(NanStatusCode.SUCCESS); mMockLooper.dispatchAll(); assertFalse(mDut.isDeviceAttached()); collector.checkThat("usage disabled", mDut.isUsageEnabled(), equalTo(false)); diff --git a/service/tests/wifitests/src/com/android/server/wifi/mainline_supplicant/MainlineSupplicantTest.java b/service/tests/wifitests/src/com/android/server/wifi/mainline_supplicant/MainlineSupplicantTest.java index d1c25a5078..2312fc6c33 100644 --- a/service/tests/wifitests/src/com/android/server/wifi/mainline_supplicant/MainlineSupplicantTest.java +++ b/service/tests/wifitests/src/com/android/server/wifi/mainline_supplicant/MainlineSupplicantTest.java @@ -16,7 +16,9 @@ package com.android.server.wifi.mainline_supplicant; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; import static org.junit.Assume.assumeTrue; import static org.mockito.ArgumentMatchers.anyInt; @@ -27,6 +29,8 @@ import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.net.wifi.usd.PublishConfig; +import android.net.wifi.usd.SubscribeConfig; import android.net.wifi.util.Environment; import android.os.Handler; import android.os.IBinder; @@ -48,6 +52,7 @@ import org.mockito.MockitoAnnotations; */ public class MainlineSupplicantTest { private static final String IFACE_NAME = "wlan0"; + private static final String USD_SERVICE_NAME = "usd_service"; private @Mock IMainlineSupplicant mIMainlineSupplicantMock; private @Mock IBinder mIBinderMock; @@ -176,4 +181,37 @@ public class MainlineSupplicantTest { // Only the valid remove request should reach have reached the service verify(mIMainlineSupplicantMock, times(1)).removeStaInterface(anyString()); } + + private void verifyUsdBaseConfigDefaultValues(IStaInterface.UsdBaseConfig baseConfig) { + assertNotNull(baseConfig.serviceName); + assertNotNull(baseConfig.freqsMhz); + assertNotNull(baseConfig.serviceSpecificInfo); + assertNotNull(baseConfig.rxMatchFilter); + assertNotNull(baseConfig.txMatchFilter); + assertEquals(MainlineSupplicant.DEFAULT_USD_FREQ_MHZ, baseConfig.defaultFreqMhz); + } + + /** + * Verify that the proper default values are assigned during the + * USD Publish Config conversion. + */ + @Test + public void testUsdPublishConfigConversionDefaultValues() { + PublishConfig frameworkConfig = new PublishConfig.Builder(USD_SERVICE_NAME).build(); + IStaInterface.UsdPublishConfig aidlConfig = + MainlineSupplicant.frameworkToHalUsdPublishConfig(frameworkConfig); + verifyUsdBaseConfigDefaultValues(aidlConfig.baseConfig); + } + + /** + * Verify that the proper default values are assigned during the + * USD Subscribe Config conversion. + */ + @Test + public void testUsdSubscribeConfigConversionDefaultValues() { + SubscribeConfig frameworkConfig = new SubscribeConfig.Builder(USD_SERVICE_NAME).build(); + IStaInterface.UsdSubscribeConfig aidlConfig = + MainlineSupplicant.frameworkToHalUsdSubscribeConfig(frameworkConfig); + verifyUsdBaseConfigDefaultValues(aidlConfig.baseConfig); + } } diff --git a/service/tests/wifitests/src/com/android/server/wifi/util/InformationElementUtilTest.java b/service/tests/wifitests/src/com/android/server/wifi/util/InformationElementUtilTest.java index e45b9dbf0c..0c6dfe15ce 100644 --- a/service/tests/wifitests/src/com/android/server/wifi/util/InformationElementUtilTest.java +++ b/service/tests/wifitests/src/com/android/server/wifi/util/InformationElementUtilTest.java @@ -515,7 +515,7 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x01, (byte) 0x00, (byte) 0x00, (byte) 0x0F, (byte) 0xAC, (byte) 0x02, (byte) 0x00, (byte) 0x00 }; verifyCapabilityStringFromIeWithoutOweSupported(ie, - "[WPA2-PSK-CCMP+TKIP][RSN-PSK-CCMP+TKIP]"); + "[WPA2-PSK-CCMP-128+TKIP][RSN-PSK-CCMP-128+TKIP]"); } /** @@ -537,7 +537,7 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x00, (byte) 0x00 // RSN capabilities }; verifyCapabilityStringFromIeWithoutOweSupported(ie, - "[RSN-?-CCMP+TKIP]"); + "[RSN-?-CCMP-128+TKIP]"); } /** @@ -576,7 +576,7 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x00, (byte) 0x0F, (byte) 0xAC, (byte) 0x0c, }; verifyCapabilityStringFromIeWithoutOweSupported(ie, - "[WPA2-EAP/SHA1-CCMP+TKIP][RSN-EAP/SHA1-CCMP+TKIP][MFPR]"); + "[WPA2-EAP/SHA1-CCMP-128+TKIP][RSN-EAP/SHA1-CCMP-128+TKIP][MFPR]"); } /** @@ -608,8 +608,8 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x00, (byte) 0x0F, (byte) 0xAC, (byte) 0x0c, }; verifyCapabilityStringFromIeWithoutOweSupported(ie, - "[WPA2-EAP/SHA256-CCMP]" - + "[RSN-EAP/SHA256-CCMP][MFPR][MFPC]"); + "[WPA2-EAP/SHA256-CCMP-128]" + + "[RSN-EAP/SHA256-CCMP-128][MFPR][MFPC]"); } /** @@ -637,8 +637,8 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0xc0, (byte) 0x00, }; verifyCapabilityStringFromIeWithoutOweSupported(ie, - "[WPA2-EAP/SHA256-CCMP]" - + "[RSN-EAP/SHA256-CCMP][MFPR][MFPC]"); + "[WPA2-EAP/SHA256-CCMP-128]" + + "[RSN-EAP/SHA256-CCMP-128][MFPR][MFPC]"); } /** @@ -672,8 +672,8 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x00, (byte) 0x0F, (byte) 0xAC, (byte) 0x0c, }; verifyCapabilityStringFromIeWithoutOweSupported(ie, - "[WPA2-EAP/SHA1+EAP/SHA256-CCMP]" - + "[RSN-EAP/SHA1+EAP/SHA256-CCMP][MFPC]"); + "[WPA2-EAP/SHA1+EAP/SHA256-CCMP-128]" + + "[RSN-EAP/SHA1+EAP/SHA256-CCMP-128][MFPC]"); } /** @@ -703,7 +703,7 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x40, (byte) 0x00, }; verifyCapabilityStringFromIeWithoutOweSupported(ie, - "[WPA2-EAP/SHA1-CCMP+TKIP][RSN-EAP/SHA1-CCMP+TKIP][MFPR]"); + "[WPA2-EAP/SHA1-CCMP-128+TKIP][RSN-EAP/SHA1-CCMP-128+TKIP][MFPR]"); } /** @@ -736,7 +736,7 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x00, (byte) 0x50, (byte) 0xF2, (byte) 0x02, (byte) 0x01, (byte) 0x00, (byte) 0x00, (byte) 0x50, (byte) 0xF2, (byte) 0x02, (byte) 0x00, (byte) 0x00 }; - verifyCapabilityStringFromIeWithoutOweSupported(ie, "[WPA-PSK-CCMP+TKIP]"); + verifyCapabilityStringFromIeWithoutOweSupported(ie, "[WPA-PSK-CCMP-128+TKIP]"); } /** @@ -757,7 +757,7 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x01, (byte) 0x00, // AKM count (byte) 0x00, (byte) 0x50, (byte) 0x99, (byte) 0x99, // Unknown AKM (byte) 0x00, (byte) 0x00}; - verifyCapabilityStringFromIeWithoutOweSupported(ie, "[WPA-?-CCMP+TKIP]"); + verifyCapabilityStringFromIeWithoutOweSupported(ie, "[WPA-?-CCMP-128+TKIP]"); } /** @@ -805,7 +805,7 @@ public class InformationElementUtilTest extends WifiBaseTest { 0x1 << 4, false, false, - "[WPA-PSK-CCMP+TKIP][WPA2-PSK-CCMP+TKIP][RSN-PSK-CCMP+TKIP]", + "[WPA-PSK-CCMP-128+TKIP][WPA2-PSK-CCMP-128+TKIP][RSN-PSK-CCMP-128+TKIP]", null); } @@ -835,7 +835,7 @@ public class InformationElementUtilTest extends WifiBaseTest { // Padding (byte) 0x00, (byte) 0x00 }; verifyCapabilityStringFromIeWithOweSupported( - ieRsn, "[WPA2-PSK-CCMP][RSN-PSK+SAE-CCMP]", null); + ieRsn, "[WPA2-PSK-CCMP-128][RSN-PSK+SAE-CCMP-128]", null); } /** @@ -863,7 +863,7 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x00, (byte) 0x0F, (byte) 0xAC, (byte) 0x09, // Padding (byte) 0x00, (byte) 0x00 }; - verifyCapabilityStringFromIeWithOweSupported(ieRsn, "[RSN-SAE+FT/SAE-CCMP]", null); + verifyCapabilityStringFromIeWithOweSupported(ieRsn, "[RSN-SAE+FT/SAE-CCMP-128]", null); } /** @@ -891,7 +891,7 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x00, (byte) 0x0F, (byte) 0xAC, (byte) 0x18, // Padding (byte) 0x00, (byte) 0x00 }; - verifyCapabilityStringFromIeWithOweSupported(ieRsn, "[RSN-SAE+SAE_EXT_KEY-CCMP]", null); + verifyCapabilityStringFromIeWithOweSupported(ieRsn, "[RSN-SAE+SAE_EXT_KEY-CCMP-128]", null); } /** @@ -921,7 +921,7 @@ public class InformationElementUtilTest extends WifiBaseTest { // Padding (byte) 0x00, (byte) 0x00 }; verifyCapabilityStringFromIeWithOweSupported( - ieRsn, "[RSN-SAE_EXT_KEY+FT/SAE_EXT_KEY-CCMP]", null); + ieRsn, "[RSN-SAE_EXT_KEY+FT/SAE_EXT_KEY-CCMP-128]", null); } /** @@ -947,7 +947,7 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x00, (byte) 0x0F, (byte) 0xAC, (byte) 0x12, // Padding (byte) 0x00, (byte) 0x00 }; - verifyCapabilityStringFromIeWithOweSupported(ieRsn, "[RSN-OWE-CCMP]", null); + verifyCapabilityStringFromIeWithOweSupported(ieRsn, "[RSN-OWE-CCMP-128]", null); } /** @@ -963,7 +963,8 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x50, (byte) 0x6F, (byte) 0x9A, (byte) 0x1C, // OWE IE contains BSSID, SSID and channel of other BSS, but we don't parse it. (byte) 0x00, (byte) 0x000, (byte) 0x00, (byte) 0x00 }; - verifyCapabilityStringFromIe(ieOwe, 0x1 << 0, true, "[RSN-OWE_TRANSITION-CCMP][ESS]", null); + verifyCapabilityStringFromIe(ieOwe, 0x1 << 0, true, "[RSN-OWE_TRANSITION-CCMP-128][ESS]", + null); } /** @@ -1043,7 +1044,7 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x00, (byte) 0x0F, (byte) 0xAC, (byte) 0x0c, }; verifyCapabilityStringFromIeWithoutOweSupported(ieRsn, - "[RSN-EAP_SUITE_B_192-GCMP][MFPR]"); + "[RSN-EAP_SUITE_B_192-GCMP-128][MFPR]"); } /** @@ -1076,8 +1077,8 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x00, (byte) 0x00 }; verifyCapabilityStringFromIeWithOweSupported( ieRsn, - "[WPA2-EAP/SHA1+EAP/SHA256+EAP-FILS-SHA256-CCMP]" - + "[RSN-EAP/SHA1+EAP/SHA256+EAP-FILS-SHA256-CCMP]", + "[WPA2-EAP/SHA1+EAP/SHA256+EAP-FILS-SHA256-CCMP-128]" + + "[RSN-EAP/SHA1+EAP/SHA256+EAP-FILS-SHA256-CCMP-128]", null); } @@ -1111,8 +1112,8 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x00, (byte) 0x00 }; verifyCapabilityStringFromIeWithOweSupported( ieRsn, - "[WPA2-EAP/SHA1+EAP/SHA256+EAP-FILS-SHA384-CCMP]" - + "[RSN-EAP/SHA1+EAP/SHA256+EAP-FILS-SHA384-CCMP]", + "[WPA2-EAP/SHA1+EAP/SHA256+EAP-FILS-SHA384-CCMP-128]" + + "[RSN-EAP/SHA1+EAP/SHA256+EAP-FILS-SHA384-CCMP-128]", null); } @@ -1162,7 +1163,7 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x00 }; verifyCapabilityStringFromIeWithOweSupported( - ieRsn, "[RSN-SAE_EXT_KEY-CCMP]", unknownAkmMap); + ieRsn, "[RSN-SAE_EXT_KEY-CCMP-128]", unknownAkmMap); } /** @@ -1244,7 +1245,8 @@ public class InformationElementUtilTest extends WifiBaseTest { 0x1 << 4, true, true, - "[WPA2-PSK-CCMP][RSN-PSK-CCMP][RSN-SAE-CCMP][RSN-SAE_EXT_KEY-GCMP-256][MFPC][RSNO]", + "[WPA2-PSK-CCMP-128][RSN-PSK-CCMP-128][RSN-SAE-CCMP-128][RSN-SAE_EXT_KEY-GCMP-256" + + "][MFPC][RSNO]", null); } @@ -1306,7 +1308,7 @@ public class InformationElementUtilTest extends WifiBaseTest { 0x1 << 4, true, true, - "[RSN-SAE-CCMP][RSN-SAE_EXT_KEY-GCMP-256][MFPR][MFPC][RSNO]", + "[RSN-SAE-CCMP-128][RSN-SAE_EXT_KEY-GCMP-256][MFPR][MFPC][RSNO]", null); } @@ -1365,7 +1367,7 @@ public class InformationElementUtilTest extends WifiBaseTest { 0x1 << 4, true, false, - "[WPA2-PSK-CCMP][RSN-PSK-CCMP]", + "[WPA2-PSK-CCMP-128][RSN-PSK-CCMP-128]", null); } @@ -1412,7 +1414,7 @@ public class InformationElementUtilTest extends WifiBaseTest { ieWps.bytes = new byte[] { (byte) 0x00, (byte) 0x50, (byte) 0xF2, (byte) 0x04 }; InformationElement[] ies = new InformationElement[] { ieWpa, ieWps }; - verifyCapabilityStringFromIes(ies, 0x1 << 4, false, false, "[WPA-PSK-CCMP+TKIP][WPS]", + verifyCapabilityStringFromIes(ies, 0x1 << 4, false, false, "[WPA-PSK-CCMP-128+TKIP][WPS]", null); } @@ -2893,7 +2895,7 @@ public class InformationElementUtilTest extends WifiBaseTest { (byte) 0x40, (byte) 0x00, }; verifyCapabilityStringFromIeWithoutOweSupported(ie, - "[RSN-PASN+SAE-CCMP+GCMP-256][MFPR]"); + "[RSN-PASN+SAE-CCMP-128+GCMP-256][MFPR]"); } /** |