| /* |
| * Copyright (C) 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.networkrecommendation.wakeup; |
| |
| import static com.android.networkrecommendation.Constants.TAG; |
| |
| import android.content.BroadcastReceiver; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.database.ContentObserver; |
| import android.net.wifi.ScanResult; |
| import android.net.wifi.WifiConfiguration; |
| import android.net.wifi.WifiManager; |
| import android.os.Handler; |
| import android.os.PowerManager; |
| import android.os.UserManager; |
| import android.provider.Settings; |
| import android.support.annotation.VisibleForTesting; |
| import android.text.TextUtils; |
| import android.util.ArrayMap; |
| import android.util.ArraySet; |
| import com.android.networkrecommendation.config.G; |
| import com.android.networkrecommendation.config.Preferences; |
| import com.android.networkrecommendation.config.WideAreaNetworks; |
| import com.android.networkrecommendation.scoring.util.HashUtil; |
| import com.android.networkrecommendation.util.Blog; |
| import com.android.networkrecommendation.util.RoboCompatUtil; |
| import com.android.networkrecommendation.util.WifiConfigurationUtil; |
| import java.io.FileDescriptor; |
| import java.io.PrintWriter; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.concurrent.atomic.AtomicBoolean; |
| |
| /** |
| * Handles enabling Wi-Fi for the Wi-Fi Wakeup feature. |
| * |
| * <p>This class enables Wi-Fi when the user is near a network that would would autojoined if Wi-Fi |
| * were enabled. When a user disables Wi-Fi, Wi-Fi Wakeup will not enable Wi-Fi until the user's |
| * context has changed. For saved networks, this context change is defined by the user leaving the |
| * range of the saved SSIDs that were in range when the user disabled Wi-Fi. |
| * |
| * @hide |
| */ |
| public class WifiWakeupController { |
| /** Number of scans to ensure that a previously in range AP is now out of range. */ |
| private static final int NUM_SCANS_TO_CONFIRM_AP_LOSS = 3; |
| |
| private final Context mContext; |
| private final ContentResolver mContentResolver; |
| private final WifiManager mWifiManager; |
| private final PowerManager mPowerManager; |
| private final UserManager mUserManager; |
| private final WifiWakeupNetworkSelector mWifiWakeupNetworkSelector; |
| private final Handler mHandler; |
| private final WifiWakeupHelper mWifiWakeupHelper; |
| private final AtomicBoolean mStarted; |
| @VisibleForTesting final ContentObserver mContentObserver; |
| |
| private final Map<String, WifiConfiguration> mSavedNetworks = new ArrayMap<>(); |
| private final Set<String> mSavedSsidsInLastScan = new ArraySet<>(); |
| private final Set<String> mSavedSsids = new ArraySet<>(); |
| private final Map<String, Integer> mSavedSsidsOnDisable = new ArrayMap<>(); |
| private final SavedNetworkCounts mSavedNetworkCounts = new SavedNetworkCounts(); |
| private int mWifiState; |
| private int mWifiApState; |
| private boolean mWifiWakeupEnabled; |
| private boolean mAirplaneModeEnabled; |
| private boolean mAutopilotEnabledWifi; |
| private boolean mPowerSaverModeOn; |
| private boolean mWifiConfigRestricted; |
| |
| public WifiWakeupController( |
| Context context, |
| ContentResolver contentResolver, |
| Handler handler, |
| WifiManager wifiManager, |
| PowerManager powerManager, |
| UserManager userManager, |
| WifiWakeupNetworkSelector wifiWakeupNetworkSelector, |
| WifiWakeupHelper wifiWakeupHelper) { |
| mContext = context; |
| mContentResolver = contentResolver; |
| mHandler = handler; |
| mWifiWakeupHelper = wifiWakeupHelper; |
| mStarted = new AtomicBoolean(false); |
| mWifiManager = wifiManager; |
| mPowerManager = powerManager; |
| mUserManager = userManager; |
| mWifiWakeupNetworkSelector = wifiWakeupNetworkSelector; |
| mContentObserver = |
| new ContentObserver(mHandler) { |
| @Override |
| public void onChange(boolean selfChange) { |
| mWifiWakeupEnabled = |
| Settings.Global.getInt( |
| mContentResolver, |
| Settings.Global.WIFI_WAKEUP_ENABLED, |
| 0) |
| == 1; |
| mAirplaneModeEnabled = |
| Settings.Global.getInt( |
| mContentResolver, |
| Settings.Global.AIRPLANE_MODE_ON, |
| 0) |
| == 1; |
| Blog.d( |
| TAG, |
| "onChange: [mWifiWakeupEnabled=%b,mAirplaneModeEnabled=%b]", |
| mWifiWakeupEnabled, |
| mAirplaneModeEnabled); |
| } |
| }; |
| } |
| |
| private final BroadcastReceiver mBroadcastReceiver = |
| new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| try { |
| if (WifiManager.WIFI_AP_STATE_CHANGED_ACTION.equals(intent.getAction())) { |
| handleWifiApStateChanged(); |
| } else if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals( |
| intent.getAction())) { |
| handleWifiStateChanged(false); |
| } else if (WifiManager.SCAN_RESULTS_AVAILABLE_ACTION.equals( |
| intent.getAction())) { |
| handleScanResultsAvailable(); |
| } else if (WifiManager.CONFIGURED_NETWORKS_CHANGED_ACTION.equals( |
| intent.getAction())) { |
| handleConfiguredNetworksChanged(); |
| } else if (PowerManager.ACTION_POWER_SAVE_MODE_CHANGED.equals( |
| intent.getAction())) { |
| handlePowerSaverModeChanged(); |
| } else if (RoboCompatUtil.ACTION_USER_RESTRICTIONS_CHANGED.equals( |
| intent.getAction())) { |
| handleUserRestrictionsChanged(); |
| } |
| } catch (RuntimeException re) { |
| // TODO(b/35044022) Remove try/catch after a couple of releases when we are confident |
| // this is not going to throw. |
| Blog.e(TAG, re, "RuntimeException in broadcast receiver."); |
| } |
| } |
| }; |
| |
| /** Starts {@link WifiWakeupController}. */ |
| public void start() { |
| if (!mStarted.compareAndSet(false, true)) { |
| return; |
| } |
| Blog.d(TAG, "Starting WifiWakeupController."); |
| |
| IntentFilter filter = new IntentFilter(); |
| filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION); |
| filter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION); |
| filter.addAction(WifiManager.CONFIGURED_NETWORKS_CHANGED_ACTION); |
| filter.addAction(WifiManager.WIFI_AP_STATE_CHANGED_ACTION); |
| filter.addAction(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED); |
| filter.addAction(RoboCompatUtil.ACTION_USER_RESTRICTIONS_CHANGED); |
| // TODO(b/33695273): conditionally register this receiver based on wifi enabled setting |
| mContext.registerReceiver(mBroadcastReceiver, filter, null, mHandler); |
| mContentResolver.registerContentObserver( |
| Settings.Global.getUriFor(Settings.Global.WIFI_WAKEUP_ENABLED), |
| true, |
| mContentObserver); |
| mContentResolver.registerContentObserver( |
| Settings.Global.getUriFor(Settings.Global.AIRPLANE_MODE_ON), |
| true, |
| mContentObserver); |
| mContentObserver.onChange(true); |
| handlePowerSaverModeChanged(); |
| handleUserRestrictionsChanged(); |
| handleWifiApStateChanged(); |
| handleConfiguredNetworksChanged(); |
| handleWifiStateChanged(true); |
| handleScanResultsAvailable(); |
| } |
| |
| /** Stops {@link WifiWakeupController}. */ |
| public void stop() { |
| if (!mStarted.compareAndSet(true, false)) { |
| return; |
| } |
| Blog.d(TAG, "Stopping WifiWakeupController."); |
| mContext.unregisterReceiver(mBroadcastReceiver); |
| mContentResolver.unregisterContentObserver(mContentObserver); |
| } |
| |
| private void handlePowerSaverModeChanged() { |
| mPowerSaverModeOn = mPowerManager.isPowerSaveMode(); |
| Blog.v(TAG, "handlePowerSaverModeChanged: %b", mPowerSaverModeOn); |
| } |
| |
| private void handleWifiApStateChanged() { |
| mWifiApState = mWifiManager.getWifiApState(); |
| Blog.v(TAG, "handleWifiApStateChanged: %d", mWifiApState); |
| } |
| |
| private void handleUserRestrictionsChanged() { |
| mWifiConfigRestricted = mUserManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_WIFI); |
| Blog.v(TAG, "handleUserRestrictionsChanged: %b", mWifiConfigRestricted); |
| } |
| |
| private void handleConfiguredNetworksChanged() { |
| List<WifiConfiguration> wifiConfigurations = mWifiManager.getConfiguredNetworks(); |
| if (wifiConfigurations == null) { |
| return; |
| } |
| Blog.v(TAG, "handleConfiguredNetworksChanged: %d", wifiConfigurations.size()); |
| |
| mSavedNetworkCounts.clear(); |
| mSavedNetworkCounts.total = wifiConfigurations.size(); |
| mSavedNetworks.clear(); |
| mSavedSsids.clear(); |
| for (int i = 0; i < wifiConfigurations.size(); i++) { |
| WifiConfiguration wifiConfiguration = wifiConfigurations.get(i); |
| if (wifiConfiguration.status != WifiConfiguration.Status.ENABLED |
| && wifiConfiguration.status != WifiConfiguration.Status.CURRENT) { |
| continue; // Ignore networks that are not connected or enabled. |
| } |
| mSavedNetworkCounts.enabled++; |
| if (RoboCompatUtil.getInstance().hasNoInternetAccess(wifiConfiguration)) { |
| mSavedNetworkCounts.noInternetAccess++; |
| continue; // Ignore networks that do not have verified internet access. |
| } |
| if (RoboCompatUtil.getInstance().isNoInternetAccessExpected(wifiConfiguration)) { |
| mSavedNetworkCounts.noInternetAccessExpected++; |
| continue; // Ignore networks that are expected not to have internet access. |
| } |
| String ssid = WifiConfigurationUtil.removeDoubleQuotes(wifiConfiguration); |
| if (TextUtils.isEmpty(ssid)) { |
| continue; |
| } |
| if (WideAreaNetworks.contains(ssid)) { |
| mSavedNetworkCounts.blacklisted++; |
| continue; // Ignore wide area networks. |
| } |
| mSavedNetworks.put(ssid, wifiConfiguration); |
| mSavedSsids.add(ssid); |
| |
| if (WifiConfigurationUtil.isConfigForOpenNetwork(wifiConfiguration)) { |
| mSavedNetworkCounts.open++; |
| } |
| if (RoboCompatUtil.getInstance().useExternalScores(wifiConfiguration)) { |
| mSavedNetworkCounts.useExternalScores++; |
| } |
| } |
| mSavedSsidsInLastScan.retainAll(mSavedSsids); |
| } |
| |
| private void handleWifiStateChanged(boolean calledOnStart) { |
| mWifiState = mWifiManager.getWifiState(); |
| Blog.v(TAG, "handleWifiStateChanged: %d", mWifiState); |
| |
| switch (mWifiState) { |
| case WifiManager.WIFI_STATE_ENABLED: |
| mSavedSsidsOnDisable.clear(); |
| if (!mAutopilotEnabledWifi) {} |
| break; |
| case WifiManager.WIFI_STATE_DISABLED: |
| if (calledOnStart) { |
| readDisabledSsidsFromSharedPreferences(); |
| } else { |
| for (String ssid : mSavedSsidsInLastScan) { |
| mSavedSsidsOnDisable.put(ssid, NUM_SCANS_TO_CONFIRM_AP_LOSS); |
| } |
| writeDisabledSsidsToSharedPreferences(); |
| } |
| Blog.d(TAG, "Disabled ssid set: %s", mSavedSsidsOnDisable); |
| |
| mAutopilotEnabledWifi = false; |
| break; |
| default: // Only handle ENABLED and DISABLED states |
| } |
| } |
| |
| private void readDisabledSsidsFromSharedPreferences() { |
| Set<String> ssidsOnDisable = Preferences.savedSsidsOnDisable.get(); |
| for (String ssid : mSavedSsids) { |
| if (ssidsOnDisable.contains(HashUtil.getSsidHash(ssid))) { |
| mSavedSsidsOnDisable.put(ssid, NUM_SCANS_TO_CONFIRM_AP_LOSS); |
| } |
| } |
| } |
| |
| private void writeDisabledSsidsToSharedPreferences() { |
| Set<String> ssids = new ArraySet<>(); |
| for (String ssid : mSavedSsidsOnDisable.keySet()) { |
| ssids.add(HashUtil.getSsidHash(ssid)); |
| } |
| Preferences.savedSsidsOnDisable.put(ssids); |
| } |
| |
| private void handleScanResultsAvailable() { |
| if (!mWifiWakeupEnabled || mWifiConfigRestricted) { |
| return; |
| } |
| List<ScanResult> scanResults = mWifiManager.getScanResults(); |
| if (scanResults == null) { |
| return; |
| } |
| Blog.v(TAG, "handleScanResultsAvailable: %d", scanResults.size()); |
| |
| mSavedSsidsInLastScan.clear(); |
| for (int i = 0; i < scanResults.size(); i++) { |
| String ssid = scanResults.get(i).SSID; |
| if (mSavedSsids.contains(ssid)) { |
| mSavedSsidsInLastScan.add(ssid); |
| } |
| } |
| |
| if (mAirplaneModeEnabled |
| || mWifiState != WifiManager.WIFI_STATE_DISABLED |
| || mWifiApState != WifiManager.WIFI_AP_STATE_DISABLED |
| || mPowerSaverModeOn) { |
| return; |
| } |
| |
| // Update mSavedSsidsOnDisable to remove ssids that the user has moved away from. |
| for (Map.Entry<String, Integer> entry : mSavedSsidsOnDisable.entrySet()) { |
| if (mSavedSsidsInLastScan.contains(entry.getKey())) { |
| mSavedSsidsOnDisable.put(entry.getKey(), NUM_SCANS_TO_CONFIRM_AP_LOSS); |
| } else { |
| if (entry.getValue() > 1) { |
| mSavedSsidsOnDisable.put(entry.getKey(), entry.getValue() - 1); |
| } else { |
| mSavedSsidsOnDisable.remove(entry.getKey()); |
| } |
| } |
| } |
| |
| if (!mSavedSsidsOnDisable.isEmpty()) { |
| Blog.d( |
| TAG, |
| "Scan results contain ssids from the disabled set: %s", |
| mSavedSsidsOnDisable); |
| return; |
| } |
| |
| if (mSavedSsidsInLastScan.isEmpty()) { |
| Blog.v(TAG, "Scan results do not contain any saved ssids."); |
| return; |
| } |
| |
| WifiConfiguration selectedNetwork = |
| mWifiWakeupNetworkSelector.selectNetwork(mSavedNetworks, scanResults); |
| if (selectedNetwork != null) { |
| Blog.d( |
| TAG, |
| "Enabling wifi for ssid: %s", |
| Blog.pii(selectedNetwork.SSID, G.Netrec.enableSensitiveLogging.get())); |
| |
| mAutopilotEnabledWifi = true; |
| mWifiManager.setWifiEnabled(true /* enabled */); |
| mWifiWakeupHelper.startWifiSession(selectedNetwork); |
| } |
| } |
| |
| public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { |
| pw.println("mStarted " + mStarted.get()); |
| pw.println("mWifiWakeupEnabled: " + mWifiWakeupEnabled); |
| pw.println("mSavedSsids: " + mSavedSsids); |
| pw.println("mSavedSsidsInLastScan: " + mSavedSsidsInLastScan); |
| pw.println("mSavedSsidsOnDisable: " + mSavedSsidsOnDisable); |
| } |
| |
| /** Class to track counts for saved networks for logging. */ |
| private static class SavedNetworkCounts { |
| int total; |
| int open; |
| int enabled; |
| int noInternetAccess; |
| int noInternetAccessExpected; |
| int useExternalScores; |
| int blacklisted; |
| |
| void clear() { |
| total = 0; |
| open = 0; |
| enabled = 0; |
| noInternetAccess = 0; |
| noInternetAccessExpected = 0; |
| useExternalScores = 0; |
| blacklisted = 0; |
| } |
| } |
| } |
