/*
|
* Copyright 2017 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
package com.android.server.wifi;
|
|
import android.text.format.DateUtils;
|
import android.util.ArrayMap;
|
import android.util.Log;
|
|
import com.android.internal.annotations.VisibleForTesting;
|
|
import java.io.FileDescriptor;
|
import java.io.PrintWriter;
|
import java.util.Collection;
|
import java.util.Iterator;
|
import java.util.Map;
|
import java.util.Set;
|
|
/**
|
* A lock to determine whether Wifi Wake can re-enable Wifi.
|
*
|
* <p>Wakeuplock manages a list of networks to determine whether the device's location has changed.
|
*/
|
public class WakeupLock {
|
|
private static final String TAG = WakeupLock.class.getSimpleName();
|
|
@VisibleForTesting
|
static final int CONSECUTIVE_MISSED_SCANS_REQUIRED_TO_EVICT = 5;
|
@VisibleForTesting
|
static final long MAX_LOCK_TIME_MILLIS = 10 * DateUtils.MINUTE_IN_MILLIS;
|
|
private final WifiConfigManager mWifiConfigManager;
|
private final Map<ScanResultMatchInfo, Integer> mLockedNetworks = new ArrayMap<>();
|
private final WifiWakeMetrics mWifiWakeMetrics;
|
private final Clock mClock;
|
|
private boolean mVerboseLoggingEnabled;
|
private long mLockTimestamp;
|
private boolean mIsInitialized;
|
private int mNumScans;
|
|
public WakeupLock(WifiConfigManager wifiConfigManager, WifiWakeMetrics wifiWakeMetrics,
|
Clock clock) {
|
mWifiConfigManager = wifiConfigManager;
|
mWifiWakeMetrics = wifiWakeMetrics;
|
mClock = clock;
|
}
|
|
/**
|
* Sets the WakeupLock with the given {@link ScanResultMatchInfo} list.
|
*
|
* <p>This saves the wakeup lock to the store and begins the initialization process.
|
*
|
* @param scanResultList list of ScanResultMatchInfos to start the lock with
|
*/
|
public void setLock(Collection<ScanResultMatchInfo> scanResultList) {
|
mLockTimestamp = mClock.getElapsedSinceBootMillis();
|
mIsInitialized = false;
|
mNumScans = 0;
|
|
mLockedNetworks.clear();
|
for (ScanResultMatchInfo scanResultMatchInfo : scanResultList) {
|
mLockedNetworks.put(scanResultMatchInfo, CONSECUTIVE_MISSED_SCANS_REQUIRED_TO_EVICT);
|
}
|
|
Log.d(TAG, "Lock set. Number of networks: " + mLockedNetworks.size());
|
|
mWifiConfigManager.saveToStore(false /* forceWrite */);
|
}
|
|
/**
|
* Maybe sets the WakeupLock as initialized based on total scans handled.
|
*
|
* @param numScans total number of elapsed scans in the current WifiWake session
|
*/
|
private void maybeSetInitializedByScans(int numScans) {
|
if (mIsInitialized) {
|
return;
|
}
|
boolean shouldBeInitialized = numScans >= CONSECUTIVE_MISSED_SCANS_REQUIRED_TO_EVICT;
|
if (shouldBeInitialized) {
|
mIsInitialized = true;
|
|
Log.d(TAG, "Lock initialized by handled scans. Scans: " + numScans);
|
if (mVerboseLoggingEnabled) {
|
Log.d(TAG, "State of lock: " + mLockedNetworks);
|
}
|
|
// log initialize event
|
mWifiWakeMetrics.recordInitializeEvent(mNumScans, mLockedNetworks.size());
|
}
|
}
|
|
/**
|
* Maybe sets the WakeupLock as initialized based on elapsed time.
|
*
|
* @param timestampMillis current timestamp
|
*/
|
private void maybeSetInitializedByTimeout(long timestampMillis) {
|
if (mIsInitialized) {
|
return;
|
}
|
long elapsedTime = timestampMillis - mLockTimestamp;
|
boolean shouldBeInitialized = elapsedTime > MAX_LOCK_TIME_MILLIS;
|
|
if (shouldBeInitialized) {
|
mIsInitialized = true;
|
|
Log.d(TAG, "Lock initialized by timeout. Elapsed time: " + elapsedTime);
|
if (mNumScans == 0) {
|
Log.w(TAG, "Lock initialized with 0 handled scans!");
|
}
|
if (mVerboseLoggingEnabled) {
|
Log.d(TAG, "State of lock: " + mLockedNetworks);
|
}
|
|
// log initialize event
|
mWifiWakeMetrics.recordInitializeEvent(mNumScans, mLockedNetworks.size());
|
}
|
}
|
|
/** Returns whether the lock has been fully initialized. */
|
public boolean isInitialized() {
|
return mIsInitialized;
|
}
|
|
/**
|
* Adds the given networks to the lock.
|
*
|
* <p>This is called during the initialization step.
|
*
|
* @param networkList The list of networks to be added
|
*/
|
private void addToLock(Collection<ScanResultMatchInfo> networkList) {
|
if (mVerboseLoggingEnabled) {
|
Log.d(TAG, "Initializing lock with networks: " + networkList);
|
}
|
|
boolean hasChanged = false;
|
|
for (ScanResultMatchInfo network : networkList) {
|
if (!mLockedNetworks.containsKey(network)) {
|
mLockedNetworks.put(network, CONSECUTIVE_MISSED_SCANS_REQUIRED_TO_EVICT);
|
hasChanged = true;
|
}
|
}
|
|
if (hasChanged) {
|
mWifiConfigManager.saveToStore(false /* forceWrite */);
|
}
|
|
// Set initialized if the lock has handled enough scans, and log the event
|
maybeSetInitializedByScans(mNumScans);
|
}
|
|
/**
|
* Removes networks from the lock if not present in the given {@link ScanResultMatchInfo} list.
|
*
|
* <p>If a network in the lock is not present in the list, reduce the number of scans
|
* required to evict by one. Remove any entries in the list with 0 scans required to evict. If
|
* any entries in the lock are removed, the store is updated.
|
*
|
* @param networkList list of present ScanResultMatchInfos to update the lock with
|
*/
|
private void removeFromLock(Collection<ScanResultMatchInfo> networkList) {
|
if (mVerboseLoggingEnabled) {
|
Log.d(TAG, "Filtering lock with networks: " + networkList);
|
}
|
|
boolean hasChanged = false;
|
Iterator<Map.Entry<ScanResultMatchInfo, Integer>> it =
|
mLockedNetworks.entrySet().iterator();
|
while (it.hasNext()) {
|
Map.Entry<ScanResultMatchInfo, Integer> entry = it.next();
|
|
// if present in scan list, reset to max
|
if (networkList.contains(entry.getKey())) {
|
if (mVerboseLoggingEnabled) {
|
Log.d(TAG, "Found network in lock: " + entry.getKey().networkSsid);
|
}
|
entry.setValue(CONSECUTIVE_MISSED_SCANS_REQUIRED_TO_EVICT);
|
continue;
|
}
|
|
// decrement and remove if necessary
|
entry.setValue(entry.getValue() - 1);
|
if (entry.getValue() <= 0) {
|
Log.d(TAG, "Removed network from lock: " + entry.getKey().networkSsid);
|
it.remove();
|
hasChanged = true;
|
}
|
}
|
|
if (hasChanged) {
|
mWifiConfigManager.saveToStore(false /* forceWrite */);
|
}
|
|
if (isUnlocked()) {
|
Log.d(TAG, "Lock emptied. Recording unlock event.");
|
mWifiWakeMetrics.recordUnlockEvent(mNumScans);
|
}
|
}
|
|
/**
|
* Updates the lock with the given {@link ScanResultMatchInfo} list.
|
*
|
* <p>Based on the current initialization state of the lock, either adds or removes networks
|
* from the lock.
|
*
|
* <p>The lock is initialized after {@link #CONSECUTIVE_MISSED_SCANS_REQUIRED_TO_EVICT}
|
* scans have been handled, or after {@link #MAX_LOCK_TIME_MILLIS} milliseconds have elapsed
|
* since {@link #setLock(Collection)}.
|
*
|
* @param networkList list of present ScanResultMatchInfos to update the lock with
|
*/
|
public void update(Collection<ScanResultMatchInfo> networkList) {
|
// update is no-op if already unlocked
|
if (isUnlocked()) {
|
return;
|
}
|
// Before checking handling the scan, we check to see whether we've exceeded the maximum
|
// time allowed for initialization. If so, we set initialized and treat this scan as a
|
// "removeFromLock()" instead of an "addToLock()".
|
maybeSetInitializedByTimeout(mClock.getElapsedSinceBootMillis());
|
|
mNumScans++;
|
|
// add or remove networks based on initialized status
|
if (mIsInitialized) {
|
removeFromLock(networkList);
|
} else {
|
addToLock(networkList);
|
}
|
}
|
|
/** Returns whether the WakeupLock is unlocked */
|
public boolean isUnlocked() {
|
return mIsInitialized && mLockedNetworks.isEmpty();
|
}
|
|
/** Returns the data source for the WakeupLock config store data. */
|
public WakeupConfigStoreData.DataSource<Set<ScanResultMatchInfo>> getDataSource() {
|
return new WakeupLockDataSource();
|
}
|
|
/** Dumps wakeup lock contents. */
|
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
|
pw.println("WakeupLock: ");
|
pw.println("mNumScans: " + mNumScans);
|
pw.println("mIsInitialized: " + mIsInitialized);
|
pw.println("Locked networks: " + mLockedNetworks.size());
|
for (Map.Entry<ScanResultMatchInfo, Integer> entry : mLockedNetworks.entrySet()) {
|
pw.println(entry.getKey() + ", scans to evict: " + entry.getValue());
|
}
|
}
|
|
/** Set whether verbose logging is enabled. */
|
public void enableVerboseLogging(boolean enabled) {
|
mVerboseLoggingEnabled = enabled;
|
}
|
|
private class WakeupLockDataSource
|
implements WakeupConfigStoreData.DataSource<Set<ScanResultMatchInfo>> {
|
|
@Override
|
public Set<ScanResultMatchInfo> getData() {
|
return mLockedNetworks.keySet();
|
}
|
|
@Override
|
public void setData(Set<ScanResultMatchInfo> data) {
|
mLockedNetworks.clear();
|
for (ScanResultMatchInfo network : data) {
|
mLockedNetworks.put(network, CONSECUTIVE_MISSED_SCANS_REQUIRED_TO_EVICT);
|
}
|
// lock is considered initialized if loaded from store
|
mIsInitialized = true;
|
}
|
}
|
}
|
