Parametrize periodic single scanning schedule
In current implementation, the periodic single scanning schedule used
with screen-on is hardcoded to 20, 40, 80, 160.
In this commit the schedule for both connected and disconnected is
parametrized via the overlay file. This gives OEMs the option to apply
their preferred schedule.
Bug: 141844561
Bug: 140596420
Bug: 141160876
Test: atest com.android.wifi.server
Change-Id: I8c739e2ce22c484b80ab310a2e8b370c457d876e
diff --git a/service/java/com/android/server/wifi/WifiConnectivityManager.java b/service/java/com/android/server/wifi/WifiConnectivityManager.java
index b51c2ff..25d52bb 100644
--- a/service/java/com/android/server/wifi/WifiConnectivityManager.java
+++ b/service/java/com/android/server/wifi/WifiConnectivityManager.java
@@ -71,15 +71,6 @@
// it should comply to the minimum scan interval rule.
private static final boolean SCAN_IMMEDIATELY = true;
private static final boolean SCAN_ON_SCHEDULE = false;
- // Periodic scan interval in milli-seconds. This is the scan
- // performed when screen is on.
- @VisibleForTesting
- public static final int PERIODIC_SCAN_INTERVAL_MS = 20 * 1000; // 20 seconds
- // When screen is on and WiFi traffic is heavy, exponential backoff
- // connectivity scans are scheduled. This constant defines the maximum
- // scan interval in this scenario.
- @VisibleForTesting
- public static final int MAX_PERIODIC_SCAN_INTERVAL_MS = 160 * 1000; // 160 seconds
// Initial PNO scan interval in milliseconds when the device is moving. The scan interval backs
// off from this initial interval on subsequent scans. This scan is performed when screen is
// off and disconnected.
@@ -160,7 +151,6 @@
private int mSingleScanRestartCount = 0;
private int mTotalConnectivityAttemptsRateLimited = 0;
private String mLastConnectionAttemptBssid = null;
- private int mPeriodicSingleScanInterval = PERIODIC_SCAN_INTERVAL_MS;
private long mLastPeriodicSingleScanTimeStamp = RESET_TIME_STAMP;
private boolean mPnoScanStarted = false;
private boolean mPeriodicScanTimerSet = false;
@@ -180,6 +170,14 @@
private int mRssiScoreSlope;
private int mPnoScanIntervalMs;
+ // Scanning Schedules
+ // Default schedule used in case of invalid configuration
+ private static final int[] DEFAULT_SCANNING_SCHEDULE = {20, 40, 80, 160};
+ private final int[] mConnectedSingleScanSchedule;
+ private final int[] mDisconnectedSingleScanSchedule;
+ private int[] mCurrentSingleScanSchedule;
+ private int mCurrentSingleScanScheduleIndex;
+
private WifiChannelUtilization mWifiChannelUtilization;
// A helper to log debugging information in the local log buffer, which can
@@ -600,12 +598,15 @@
mUseSingleRadioChainScanResults = context.getResources().getBoolean(
R.bool.config_wifi_framework_use_single_radio_chain_scan_results_network_selection);
-
mFullScanMaxTxRate = context.getResources().getInteger(
R.integer.config_wifi_framework_max_tx_rate_for_full_scan);
mFullScanMaxRxRate = context.getResources().getInteger(
R.integer.config_wifi_framework_max_rx_rate_for_full_scan);
+ mConnectedSingleScanSchedule = initializeScanningSchedule(context, WIFI_STATE_CONNECTED);
+ mDisconnectedSingleScanSchedule = initializeScanningSchedule(context,
+ WIFI_STATE_DISCONNECTED);
+
mPnoScanIntervalMs = MOVING_PNO_SCAN_INTERVAL_MS;
localLog("PNO settings:"
@@ -623,6 +624,40 @@
mNetworkSelector.setWifiChannelUtilization(mWifiChannelUtilization);
}
+ /** Initialize single scanning schedules, and validate them */
+ private int[] initializeScanningSchedule(Context context, int state) {
+ int[] schedule;
+
+ if (state == WIFI_STATE_CONNECTED) {
+ schedule = context.getResources().getIntArray(
+ R.array.config_wifiConnectedScanIntervalScheduleSec);
+ } else if (state == WIFI_STATE_DISCONNECTED) {
+ schedule = context.getResources().getIntArray(
+ R.array.config_wifiDisconnectedScanIntervalScheduleSec);
+ } else {
+ schedule = null;
+ }
+
+ boolean invalidConfig = false;
+ if (schedule == null || schedule.length == 0) {
+ invalidConfig = true;
+ } else {
+ for (int val : schedule) {
+ if (val <= 0) {
+ invalidConfig = true;
+ break;
+ }
+ }
+ }
+ if (!invalidConfig) {
+ return schedule;
+ }
+
+ Log.e(TAG, "Configuration for wifi scanning schedule is mis-configured,"
+ + "using default schedule");
+ return DEFAULT_SCANNING_SCHEDULE;
+ }
+
/** Returns maximum PNO score, before any awards/bonuses. */
private int initialScoreMax() {
return mRssiScoreSlope * (Math.max(mScoringParams.getGoodRssi(ScoringParams.BAND2),
@@ -811,10 +846,11 @@
if (mLastPeriodicSingleScanTimeStamp != RESET_TIME_STAMP) {
long msSinceLastScan = currentTimeStamp - mLastPeriodicSingleScanTimeStamp;
- if (msSinceLastScan < PERIODIC_SCAN_INTERVAL_MS) {
+ if (msSinceLastScan < getScheduledSingleScanInterval(0)) {
localLog("Last periodic single scan started " + msSinceLastScan
+ "ms ago, defer this new scan request.");
- schedulePeriodicScanTimer(PERIODIC_SCAN_INTERVAL_MS - (int) msSinceLastScan);
+ schedulePeriodicScanTimer(
+ getScheduledSingleScanInterval(0) - (int) msSinceLastScan);
return;
}
}
@@ -841,16 +877,35 @@
if (isScanNeeded) {
mLastPeriodicSingleScanTimeStamp = currentTimeStamp;
startSingleScan(isFullBandScan, WIFI_WORK_SOURCE);
- schedulePeriodicScanTimer(mPeriodicSingleScanInterval);
+ schedulePeriodicScanTimer(
+ getScheduledSingleScanInterval(mCurrentSingleScanScheduleIndex));
// Set up the next scan interval in an exponential backoff fashion.
- mPeriodicSingleScanInterval *= 2;
- if (mPeriodicSingleScanInterval > MAX_PERIODIC_SCAN_INTERVAL_MS) {
- mPeriodicSingleScanInterval = MAX_PERIODIC_SCAN_INTERVAL_MS;
- }
+ incrementSingleScanningIndex();
} else {
// Since we already skipped this scan, keep the same scan interval for next scan.
- schedulePeriodicScanTimer(mPeriodicSingleScanInterval);
+ schedulePeriodicScanTimer(
+ getScheduledSingleScanInterval(mCurrentSingleScanScheduleIndex));
+ }
+ }
+
+ // Retrieve a value from single scanning schedule in ms
+ private int getScheduledSingleScanInterval(int index) {
+ if (mCurrentSingleScanSchedule != null && mCurrentSingleScanSchedule.length > index) {
+ return mCurrentSingleScanSchedule[index] * 1000;
+ } else {
+ Log.e(TAG, "Invalid attempt to get schedule interval value, "
+ + ((mCurrentSingleScanSchedule == null) ? "Schedule array is null"
+ : "invalid index"));
+ // Use a default value
+ return DEFAULT_SCANNING_SCHEDULE[0];
+ }
+ }
+
+ // Step up index for single scanning
+ private void incrementSingleScanningIndex() {
+ if (mCurrentSingleScanScheduleIndex < (mCurrentSingleScanSchedule.length - 1)) {
+ mCurrentSingleScanScheduleIndex++;
}
}
@@ -918,7 +973,7 @@
if (scanImmediately) {
resetLastPeriodicSingleScanTimeStamp();
}
- mPeriodicSingleScanInterval = PERIODIC_SCAN_INTERVAL_MS;
+ mCurrentSingleScanScheduleIndex = 0;
startPeriodicSingleScan();
}
@@ -1154,8 +1209,16 @@
if (mWifiState == WIFI_STATE_DISCONNECTED) {
mLastConnectionAttemptBssid = null;
scheduleWatchdogTimer();
+ // Switch to the disconnected scanning schedule
+ mCurrentSingleScanSchedule = mDisconnectedSingleScanSchedule;
startConnectivityScan(SCAN_IMMEDIATELY);
+ } else if (mWifiState == WIFI_STATE_CONNECTED) {
+ // Switch to connected single scanning schedule
+ mCurrentSingleScanSchedule = mConnectedSingleScanSchedule;
+ startConnectivityScan(SCAN_ON_SCHEDULE);
} else {
+ // Intermediate state, no applicable single scanning schedule
+ mCurrentSingleScanSchedule = null;
startConnectivityScan(SCAN_ON_SCHEDULE);
}
}
diff --git a/service/res/values/config.xml b/service/res/values/config.xml
index ff0befd..eb9928b 100644
--- a/service/res/values/config.xml
+++ b/service/res/values/config.xml
@@ -204,4 +204,20 @@
<item>-55</item> <!-- [-66, -55) 3 -->
<!-- [-55, +infinity) 4 -->
</integer-array>
+
+ <!-- Array describing scanning schedule in seconds when device is disconnected and screen is on -->
+ <integer-array translatable="false" name="config_wifiDisconnectedScanIntervalScheduleSec">
+ <item>20</item>
+ <item>40</item>
+ <item>80</item>
+ <item>160</item>
+ </integer-array>
+
+ <!-- Array describing scanning schedule in seconds when device is connected and screen is on -->
+ <integer-array translatable="false" name="config_wifiConnectedScanIntervalScheduleSec">
+ <item>20</item>
+ <item>40</item>
+ <item>80</item>
+ <item>160</item>
+ </integer-array>
</resources>
diff --git a/service/res/values/overlayable.xml b/service/res/values/overlayable.xml
index b7bcad2..8fc1410 100644
--- a/service/res/values/overlayable.xml
+++ b/service/res/values/overlayable.xml
@@ -78,6 +78,8 @@
<item type="bool" name="config_wifi_diagnostics_bugreport_enabled" />
<item type="bool" name="config_wifi_watchdog_enabled" />
<item type="array" name="config_wifiRssiLevelThresholds" />
+ <item type="array" name="config_wifiDisconnectedScanIntervalScheduleSec" />
+ <item type="array" name="config_wifiConnectedScanIntervalScheduleSec" />
<!-- Params from config.xml that can be overlayed -->
<!-- Params from strings.xml that can be overlayed -->
diff --git a/service/tests/wifitests/src/com/android/server/wifi/WifiConnectivityManagerTest.java b/service/tests/wifitests/src/com/android/server/wifi/WifiConnectivityManagerTest.java
index be78461..96e5b5d 100644
--- a/service/tests/wifitests/src/com/android/server/wifi/WifiConnectivityManagerTest.java
+++ b/service/tests/wifitests/src/com/android/server/wifi/WifiConnectivityManagerTest.java
@@ -162,7 +162,14 @@
private static final String INVALID_SCAN_RESULT_BSSID = "6c:f3:7f:ae:8c:f4";
private static final long CURRENT_SYSTEM_TIME_MS = 1000;
private static final int MAX_BSSID_BLACKLIST_SIZE = 16;
-
+ private static final int[] VALID_CONNECTED_SINGLE_SCAN_SCHEDULE = {10, 30, 50};
+ private static final int[] VALID_DISCONNECTED_SINGLE_SCAN_SCHEDULE = {25, 40, 60};
+ private static final int[] INVALID_SCHEDULE_EMPTY = {};
+ private static final int[] INVALID_SCHEDULE_NEGATIVE_VALUES = {10, -10, 20};
+ private static final int[] INVALID_SCHEDULE_ZERO_VALUES = {10, 0, 20};
+ private static final int MAX_SCAN_INTERVAL_IN_SCHEDULE = 60;
+ private static final int[] DEFAULT_SINGLE_SCAN_SCHEDULE = {20, 40, 80, 160};
+ private static final int MAX_SCAN_INTERVAL_IN_DEFAULT_SCHEDULE = 160;
Resources mockResource() {
Resources resource = mock(Resources.class);
@@ -180,6 +187,13 @@
R.integer.config_wifi_framework_max_tx_rate_for_full_scan)).thenReturn(8);
when(resource.getInteger(
R.integer.config_wifi_framework_max_rx_rate_for_full_scan)).thenReturn(16);
+ when(resource.getIntArray(
+ R.array.config_wifiConnectedScanIntervalScheduleSec))
+ .thenReturn(VALID_CONNECTED_SINGLE_SCAN_SCHEDULE);
+ when(resource.getIntArray(
+ R.array.config_wifiDisconnectedScanIntervalScheduleSec))
+ .thenReturn(VALID_DISCONNECTED_SINGLE_SCAN_SCHEDULE);
+
return resource;
}
@@ -761,23 +775,55 @@
}
/**
- * Verify that scan interval for screen on and wifi disconnected scenario
- * is in the exponential backoff fashion.
- *
- * Expected behavior: WifiConnectivityManager doubles periodic
- * scan interval.
+ * Verify that if configuration for single scan schedule is empty, default
+ * schedule is being used.
*/
@Test
- public void checkPeriodicScanIntervalWhenDisconnected() {
+ public void checkPeriodicScanIntervalWhenDisconnectedWithEmptySchedule() throws Exception {
+ when(mResource.getIntArray(R.array.config_wifiDisconnectedScanIntervalScheduleSec))
+ .thenReturn(INVALID_SCHEDULE_EMPTY);
+
+ checkWorkingWithDefaultSchedule();
+ }
+
+ /**
+ * Verify that if configuration for single scan schedule has zero values, default
+ * schedule is being used.
+ */
+ @Test
+ public void checkPeriodicScanIntervalWhenDisconnectedWithZeroValuesSchedule() {
+ when(mResource.getIntArray(R.array.config_wifiDisconnectedScanIntervalScheduleSec))
+ .thenReturn(INVALID_SCHEDULE_ZERO_VALUES);
+
+ checkWorkingWithDefaultSchedule();
+ }
+
+ /**
+ * Verify that if configuration for single scan schedule has negative values, default
+ * schedule is being used.
+ */
+ @Test
+ public void checkPeriodicScanIntervalWhenDisconnectedWithNegativeValuesSchedule() {
+ when(mResource.getIntArray(R.array.config_wifiDisconnectedScanIntervalScheduleSec))
+ .thenReturn(INVALID_SCHEDULE_NEGATIVE_VALUES);
+
+ checkWorkingWithDefaultSchedule();
+ }
+
+ private void checkWorkingWithDefaultSchedule() {
long currentTimeStamp = CURRENT_SYSTEM_TIME_MS;
when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
+ mWifiConnectivityManager = createConnectivityManager();
+ mWifiConnectivityManager.setTrustedConnectionAllowed(true);
+ mWifiConnectivityManager.setWifiEnabled(true);
+
// Set screen to ON
mWifiConnectivityManager.handleScreenStateChanged(true);
- // Wait for MAX_PERIODIC_SCAN_INTERVAL_MS so that any impact triggered
+ // Wait for max periodic scan interval so that any impact triggered
// by screen state change can settle
- currentTimeStamp += WifiConnectivityManager.MAX_PERIODIC_SCAN_INTERVAL_MS;
+ currentTimeStamp += MAX_SCAN_INTERVAL_IN_DEFAULT_SCHEDULE * 1000;
when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
// Set WiFi to disconnected state to trigger periodic scan
@@ -788,7 +834,7 @@
long firstIntervalMs = mAlarmManager
.getTriggerTimeMillis(WifiConnectivityManager.PERIODIC_SCAN_TIMER_TAG)
- currentTimeStamp;
- assertEquals(firstIntervalMs, WifiConnectivityManager.PERIODIC_SCAN_INTERVAL_MS);
+ assertEquals(DEFAULT_SINGLE_SCAN_SCHEDULE[0] * 1000, firstIntervalMs);
currentTimeStamp += firstIntervalMs;
when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
@@ -803,7 +849,7 @@
- currentTimeStamp;
// Verify the intervals are exponential back off
- assertEquals(firstIntervalMs * 2, secondIntervalMs);
+ assertEquals(DEFAULT_SINGLE_SCAN_SCHEDULE[1] * 1000, secondIntervalMs);
currentTimeStamp += secondIntervalMs;
when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
@@ -820,7 +866,72 @@
when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
}
- assertEquals(intervalMs, WifiConnectivityManager.MAX_PERIODIC_SCAN_INTERVAL_MS);
+ assertEquals(DEFAULT_SINGLE_SCAN_SCHEDULE[DEFAULT_SINGLE_SCAN_SCHEDULE.length - 1] * 1000,
+ intervalMs);
+ }
+
+ /**
+ * Verify that scan interval for screen on and wifi disconnected scenario
+ * is in the exponential backoff fashion.
+ *
+ * Expected behavior: WifiConnectivityManager doubles periodic
+ * scan interval.
+ */
+ @Test
+ public void checkPeriodicScanIntervalWhenDisconnected() {
+ long currentTimeStamp = CURRENT_SYSTEM_TIME_MS;
+ when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
+
+ // Set screen to ON
+ mWifiConnectivityManager.handleScreenStateChanged(true);
+
+ // Wait for max periodic scan interval so that any impact triggered
+ // by screen state change can settle
+ currentTimeStamp += MAX_SCAN_INTERVAL_IN_SCHEDULE * 1000;
+ when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
+
+ // Set WiFi to disconnected state to trigger periodic scan
+ mWifiConnectivityManager.handleConnectionStateChanged(
+ WifiConnectivityManager.WIFI_STATE_DISCONNECTED);
+
+ // Get the first periodic scan interval
+ long firstIntervalMs = mAlarmManager
+ .getTriggerTimeMillis(WifiConnectivityManager.PERIODIC_SCAN_TIMER_TAG)
+ - currentTimeStamp;
+ assertEquals(VALID_DISCONNECTED_SINGLE_SCAN_SCHEDULE[0] * 1000, firstIntervalMs);
+
+ currentTimeStamp += firstIntervalMs;
+ when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
+
+ // Now fire the first periodic scan alarm timer
+ mAlarmManager.dispatch(WifiConnectivityManager.PERIODIC_SCAN_TIMER_TAG);
+ mLooper.dispatchAll();
+
+ // Get the second periodic scan interval
+ long secondIntervalMs = mAlarmManager
+ .getTriggerTimeMillis(WifiConnectivityManager.PERIODIC_SCAN_TIMER_TAG)
+ - currentTimeStamp;
+
+ // Verify the intervals are exponential back off
+ assertEquals(VALID_DISCONNECTED_SINGLE_SCAN_SCHEDULE[1] * 1000, secondIntervalMs);
+
+ currentTimeStamp += secondIntervalMs;
+ when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
+
+ // Make sure we eventually stay at the maximum scan interval.
+ long intervalMs = 0;
+ for (int i = 0; i < 5; i++) {
+ mAlarmManager.dispatch(WifiConnectivityManager.PERIODIC_SCAN_TIMER_TAG);
+ mLooper.dispatchAll();
+ intervalMs = mAlarmManager
+ .getTriggerTimeMillis(WifiConnectivityManager.PERIODIC_SCAN_TIMER_TAG)
+ - currentTimeStamp;
+ currentTimeStamp += intervalMs;
+ when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
+ }
+
+ assertEquals(VALID_DISCONNECTED_SINGLE_SCAN_SCHEDULE[
+ VALID_DISCONNECTED_SINGLE_SCAN_SCHEDULE.length - 1] * 1000, intervalMs);
}
/**
@@ -838,9 +949,9 @@
// Set screen to ON
mWifiConnectivityManager.handleScreenStateChanged(true);
- // Wait for MAX_PERIODIC_SCAN_INTERVAL_MS so that any impact triggered
+ // Wait for max scanning interval so that any impact triggered
// by screen state change can settle
- currentTimeStamp += WifiConnectivityManager.MAX_PERIODIC_SCAN_INTERVAL_MS;
+ currentTimeStamp += MAX_SCAN_INTERVAL_IN_SCHEDULE * 1000;
when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
// Set WiFi to connected state to trigger periodic scan
@@ -851,7 +962,7 @@
long firstIntervalMs = mAlarmManager
.getTriggerTimeMillis(WifiConnectivityManager.PERIODIC_SCAN_TIMER_TAG)
- currentTimeStamp;
- assertEquals(firstIntervalMs, WifiConnectivityManager.PERIODIC_SCAN_INTERVAL_MS);
+ assertEquals(VALID_CONNECTED_SINGLE_SCAN_SCHEDULE[0] * 1000, firstIntervalMs);
currentTimeStamp += firstIntervalMs;
when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
@@ -866,7 +977,7 @@
- currentTimeStamp;
// Verify the intervals are exponential back off
- assertEquals(firstIntervalMs * 2, secondIntervalMs);
+ assertEquals(VALID_CONNECTED_SINGLE_SCAN_SCHEDULE[1] * 1000, secondIntervalMs);
currentTimeStamp += secondIntervalMs;
when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
@@ -883,7 +994,8 @@
when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
}
- assertEquals(intervalMs, WifiConnectivityManager.MAX_PERIODIC_SCAN_INTERVAL_MS);
+ assertEquals(VALID_CONNECTED_SINGLE_SCAN_SCHEDULE[
+ VALID_CONNECTED_SINGLE_SCAN_SCHEDULE.length - 1] * 1000, intervalMs);
}
/**
@@ -891,7 +1003,7 @@
* change event back to back to verify that the minium scan interval is enforced.
*
* Expected behavior: WifiConnectivityManager start the second periodic single
- * scan PERIODIC_SCAN_INTERVAL_MS after the first one.
+ * scan after the first one by first interval in connected scanning schedule.
*/
@Test
public void checkMinimumPeriodicScanIntervalWhenScreenOnAndConnected() {
@@ -901,9 +1013,9 @@
// Set screen to ON
mWifiConnectivityManager.handleScreenStateChanged(true);
- // Wait for MAX_PERIODIC_SCAN_INTERVAL_MS so that any impact triggered
+ // Wait for max scanning interval in schedule so that any impact triggered
// by screen state change can settle
- currentTimeStamp += WifiConnectivityManager.MAX_PERIODIC_SCAN_INTERVAL_MS;
+ currentTimeStamp += MAX_SCAN_INTERVAL_IN_SCHEDULE * 1000;
long scanForDisconnectedTimeStamp = currentTimeStamp;
when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
@@ -925,10 +1037,10 @@
long firstScanForConnectedTimeStamp = mAlarmManager
.getTriggerTimeMillis(WifiConnectivityManager.PERIODIC_SCAN_TIMER_TAG);
- // Verify that the first scan for connected state is scheduled PERIODIC_SCAN_INTERVAL_MS
- // after the scan for disconnected state
- assertEquals(firstScanForConnectedTimeStamp, scanForDisconnectedTimeStamp
- + WifiConnectivityManager.PERIODIC_SCAN_INTERVAL_MS);
+ // Verify that the first scan for connected state is scheduled after the scan for
+ // disconnected state by first interval in connected scanning schedule.
+ assertEquals(scanForDisconnectedTimeStamp + VALID_CONNECTED_SINGLE_SCAN_SCHEDULE[0] * 1000,
+ firstScanForConnectedTimeStamp);
}
/**
@@ -948,9 +1060,9 @@
// Set screen to ON
mWifiConnectivityManager.handleScreenStateChanged(true);
- // Wait for MAX_PERIODIC_SCAN_INTERVAL_MS so that any impact triggered
+ // Wait for maximum scanning interval in schedule so that any impact triggered
// by screen state change can settle
- currentTimeStamp += WifiConnectivityManager.MAX_PERIODIC_SCAN_INTERVAL_MS;
+ currentTimeStamp += MAX_SCAN_INTERVAL_IN_SCHEDULE * 1000;
long scanForConnectedTimeStamp = currentTimeStamp;
when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
@@ -973,10 +1085,11 @@
long secondScanForDisconnectedTimeStamp = mAlarmManager
.getTriggerTimeMillis(WifiConnectivityManager.PERIODIC_SCAN_TIMER_TAG);
- // Verify that the second scan is scheduled PERIODIC_SCAN_INTERVAL_MS after
- // entering DISCONNECTED state.
- assertEquals(secondScanForDisconnectedTimeStamp, enteringDisconnectedStateTimeStamp
- + WifiConnectivityManager.PERIODIC_SCAN_INTERVAL_MS);
+ // Verify that the second scan is scheduled after entering DISCONNECTED state by first
+ // interval in disconnected scanning schedule.
+ assertEquals(enteringDisconnectedStateTimeStamp
+ + VALID_DISCONNECTED_SINGLE_SCAN_SCHEDULE[0] * 1000,
+ secondScanForDisconnectedTimeStamp);
}
/**
@@ -995,9 +1108,9 @@
// Set screen to ON
mWifiConnectivityManager.handleScreenStateChanged(true);
- // Wait for MAX_PERIODIC_SCAN_INTERVAL_MS so that any impact triggered
+ // Wait for maximum interval in scanning schedule so that any impact triggered
// by screen state change can settle
- currentTimeStamp += WifiConnectivityManager.MAX_PERIODIC_SCAN_INTERVAL_MS;
+ currentTimeStamp += MAX_SCAN_INTERVAL_IN_SCHEDULE * 1000;
long firstScanTimeStamp = currentTimeStamp;
when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTimeStamp);
@@ -1146,7 +1259,7 @@
long firstIntervalMs = mAlarmManager
.getTriggerTimeMillis(WifiConnectivityManager.PERIODIC_SCAN_TIMER_TAG)
- currentTimeStamp;
- assertEquals(firstIntervalMs, WifiConnectivityManager.PERIODIC_SCAN_INTERVAL_MS);
+ assertEquals(VALID_CONNECTED_SINGLE_SCAN_SCHEDULE[0] * 1000, firstIntervalMs);
}
/**
