diff options
Diffstat (limited to 'libs')
7 files changed, 849 insertions, 44 deletions
diff --git a/libs/WifiTrackerLib/Android.bp b/libs/WifiTrackerLib/Android.bp index 501a956d2..412f182dd 100644 --- a/libs/WifiTrackerLib/Android.bp +++ b/libs/WifiTrackerLib/Android.bp @@ -1,4 +1,9 @@ android_library { name: "WifiTrackerLib", srcs: ["src/**/*.java"], + static_libs: [ + "androidx.preference_preference", + ], + + min_sdk_version: "21", } diff --git a/libs/WifiTrackerLib/src/com/android/wifitrackerlib/ScanResultUpdater.java b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/ScanResultUpdater.java index 6df4f266c..addab0c08 100644 --- a/libs/WifiTrackerLib/src/com/android/wifitrackerlib/ScanResultUpdater.java +++ b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/ScanResultUpdater.java @@ -17,8 +17,8 @@ package com.android.wifitrackerlib; import android.net.wifi.ScanResult; -import android.os.SystemClock; +import java.time.Clock; import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -30,22 +30,26 @@ import java.util.List; */ public class ScanResultUpdater { private HashMap<String, ScanResult> mScanResultsByBssid = new HashMap<>(); - private long mMaxScanAgeMillis; - private Object mLock = new Object(); + private final long mMaxScanAgeMillis; + private final Object mLock = new Object(); + private final Clock mClock; /** * Creates a ScanResultUpdater with no max scan age. + * + * @param clock Elapsed real time Clock to compare with ScanResult timestamps. */ - public ScanResultUpdater() { - this(Long.MAX_VALUE); + public ScanResultUpdater(Clock clock) { + this(clock, Long.MAX_VALUE); } /** * Creates a ScanResultUpdater with a max scan age in milliseconds. Scans older than this limit * will be pruned upon update/retrieval to keep the size of the scan list down. */ - public ScanResultUpdater(long maxScanAgeMillis) { + public ScanResultUpdater(Clock clock, long maxScanAgeMillis) { mMaxScanAgeMillis = maxScanAgeMillis; + mClock = clock; } /** @@ -83,7 +87,7 @@ public class ScanResultUpdater { synchronized (mLock) { List<ScanResult> ageFilteredResults = new ArrayList<>(); for (ScanResult result : mScanResultsByBssid.values()) { - if (SystemClock.elapsedRealtime() - result.timestamp <= maxScanAgeMillis) { + if (mClock.millis() - result.timestamp <= maxScanAgeMillis) { ageFilteredResults.add(result); } } @@ -94,7 +98,7 @@ public class ScanResultUpdater { private void evictOldScans() { synchronized (mLock) { mScanResultsByBssid.entrySet().removeIf((entry) -> - SystemClock.elapsedRealtime() - entry.getValue().timestamp > mMaxScanAgeMillis); + mClock.millis() - entry.getValue().timestamp > mMaxScanAgeMillis); } } } diff --git a/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiEntry.java b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiEntry.java new file mode 100644 index 000000000..3742e42e4 --- /dev/null +++ b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiEntry.java @@ -0,0 +1,375 @@ +/* + * Copyright (C) 2019 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.wifitrackerlib; + +import androidx.annotation.IntDef; +import androidx.annotation.NonNull; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.util.List; + +/** + * Abstract base class for an entry representing a Wi-Fi network in a Wi-Fi picker. + * + * Clients implementing a Wi-Fi picker should receive WifiEntry objects from WifiTracker2, and rely + * on the given API for all user-displayable information and actions on the represented network. + */ +public abstract class WifiEntry implements Comparable<WifiEntry> { + @Retention(RetentionPolicy.SOURCE) + @IntDef(value = { + SECURITY_NONE, + SECURITY_WEP, + SECURITY_PSK, + SECURITY_EAP, + SECURITY_OWE, + SECURITY_SAE, + SECURITY_EAP_SUITE_B, + SECURITY_PSK_SAE_TRANSITION, + SECURITY_OWE_TRANSITION, + SECURITY_MAX_VAL + }) + + public @interface Security {} + + public static final int SECURITY_NONE = 0; + public static final int SECURITY_WEP = 1; + public static final int SECURITY_PSK = 2; + public static final int SECURITY_EAP = 3; + public static final int SECURITY_OWE = 4; + public static final int SECURITY_SAE = 5; + public static final int SECURITY_EAP_SUITE_B = 6; + public static final int SECURITY_PSK_SAE_TRANSITION = 7; + public static final int SECURITY_OWE_TRANSITION = 8; + public static final int SECURITY_MAX_VAL = 9; // Has to be the last + + @Retention(RetentionPolicy.SOURCE) + @IntDef(value = { + CONNECTED_STATE_DISCONNECTED, + CONNECTED_STATE_CONNECTED, + CONNECTED_STATE_CONNECTING + }) + + public @interface ConnectedState {} + + public static final int CONNECTED_STATE_DISCONNECTED = 0; + public static final int CONNECTED_STATE_CONNECTING = 1; + public static final int CONNECTED_STATE_CONNECTED = 2; + + // Wi-Fi signal levels for displaying signal strength. + public static final int WIFI_LEVEL_MIN = 0; + public static final int WIFI_LEVEL_MAX = 4; + public static final int WIFI_LEVEL_UNREACHABLE = -1; + + @Retention(RetentionPolicy.SOURCE) + @IntDef(value = { + METERED_CHOICE_AUTO, + METERED_CHOICE_METERED, + METERED_CHOICE_UNMETERED, + METERED_CHOICE_UNKNOWN + }) + + public @interface MeteredChoice {} + + // User's choice whether to treat a network as metered. + public static final int METERED_CHOICE_AUTO = 0; + public static final int METERED_CHOICE_METERED = 1; + public static final int METERED_CHOICE_UNMETERED = 2; + public static final int METERED_CHOICE_UNKNOWN = 3; + + @Retention(RetentionPolicy.SOURCE) + @IntDef(value = { + PRIVACY_DEVICE_MAC, + PRIVACY_RANDOMIZED_MAC, + PRIVACY_UNKNOWN + }) + + public @interface Privacy {} + + public static final int PRIVACY_DEVICE_MAC = 0; + public static final int PRIVACY_RANDOMIZED_MAC = 1; + public static final int PRIVACY_UNKNOWN = 2; + + @Retention(RetentionPolicy.SOURCE) + @IntDef(value = { + FREQUENCY_2_4_GHZ, + FREQUENCY_5_GHZ, + FREQUENCY_6_GHZ, + FREQUENCY_UNKNOWN + }) + + public @interface Frequency {} + + public static final int FREQUENCY_2_4_GHZ = 2_400; + public static final int FREQUENCY_5_GHZ = 5_000; + public static final int FREQUENCY_6_GHZ = 6_000; + public static final int FREQUENCY_UNKNOWN = -1; + + // Callback associated with this WifiEntry. Subclasses should call its methods appropriately. + protected WifiEntryCallback mListener; + + // Info available for all WifiEntries // + + /** The unique key defining a WifiEntry */ + public abstract String getKey(); + + /** Returns connection state of the network defined by the CONNECTED_STATE constants */ + @ConnectedState + public abstract int getConnectedState(); + + /** Returns the display title. This is most commonly the SSID of a network. */ + public abstract String getTitle(); + + /** Returns the display summary */ + public abstract String getSummary(); + + /** + * Returns the signal strength level within [WIFI_LEVEL_MIN, WIFI_LEVEL_MAX]. + * A value of WIFI_LEVEL_UNREACHABLE indicates an out of range network. + */ + public abstract int getLevel(); + + /** Returns the security type defined by the SECURITY constants */ + @Security + public abstract int getSecurity(); + + /** + * Indicates when a network is metered or the user marked the network as metered. + */ + public abstract boolean isMetered(); + + /** + * Returns the ConnectedInfo object pertaining to an active connection. + * + * Returns null if getConnectedState() != CONNECTED_STATE_CONNECTED. + */ + public abstract ConnectedInfo getConnectedInfo(); + + /** + * Info associated with the active connection. + */ + public static class ConnectedInfo { + @Frequency + public int frequencyMhz; + public List<String> dnsServers; + public int linkSpeedMbps; + public String ipAddress; + public List<String> ipv6Addresses; + public String gateway; + public String subnetMask; + } + + // User actions on a network + + /** Returns whether the entry should show a connect option */ + public abstract boolean canConnect(); + /** Connects to the network */ + public abstract void connect(); + + /** Returns whether the entry should show a disconnect option */ + public abstract boolean canDisconnect(); + /** Disconnects from the network */ + public abstract void disconnect(); + + /** Returns whether the entry should show a forget option */ + public abstract boolean canForget(); + /** Forgets the network */ + public abstract void forget(); + + // Modifiable settings + + /** Returns whether the entry should show a password input */ + public abstract boolean canSetPassword(); + /** Sets the user's password to a network */ + public abstract void setPassword(@NonNull String password); + + /** + * Returns the user's choice whether to treat a network as metered, + * defined by the METERED_CHOICE constants + */ + @MeteredChoice + public abstract int getMeteredChoice(); + /** Returns whether the entry should let the user choose the metered treatment of a network */ + public abstract boolean canSetMeteredChoice(); + /** + * Sets the user's choice for treating a network as metered, + * defined by the METERED_CHOICE constants + */ + public abstract void setMeteredChoice(@MeteredChoice int meteredChoice); + + /** Returns whether the entry should let the user choose the MAC randomization setting */ + public abstract boolean canSetPrivacy(); + /** Returns the MAC randomization setting defined by the PRIVACY constants */ + @Privacy + public abstract int getPrivacy(); + /** Sets the user's choice for MAC randomization defined by the PRIVACY constants */ + public abstract void setPrivacy(@Privacy int privacy); + + /** Returns whether the network has auto-join enabled */ + public abstract boolean isAutoJoinEnabled(); + /** Returns whether the user can enable/disable auto-join */ + public abstract boolean canSetAutoJoinEnabled(); + /** Sets whether a network will be auto-joined or not */ + public abstract void setAutoJoinEnabled(boolean enabled); + + /** Returns the ProxySettings for the network */ + public abstract ProxySettings getProxySettings(); + /** Returns whether the user can modify the ProxySettings for the network */ + public abstract boolean canSetProxySettings(); + /** Sets the ProxySettinsg for the network */ + public abstract void setProxySettings(@NonNull ProxySettings proxySettings); + + /** Returns the IpSettings for the network */ + public abstract IpSettings getIpSettings(); + /** Returns whether the user can set the IpSettings for the network */ + public abstract boolean canSetIpSettings(); + /** Sets the IpSettings for the network */ + public abstract void setIpSettings(@NonNull IpSettings ipSettings); + + /** + * Data class used for proxy settings + */ + public static class ProxySettings { + @Retention(RetentionPolicy.SOURCE) + @IntDef(value = { + TYPE_NONE, + TYPE_MANUAL, + TYPE_PROXY_AUTOCONFIG + }) + + public @interface Type {} + + public static final int TYPE_NONE = 0; + public static final int TYPE_MANUAL = 1; + public static final int TYPE_PROXY_AUTOCONFIG = 2; + + @Type + public int type; + public String hostname; + public String port; + public String bypassAddresses; + public String pacUrl; + } + + /** + * Data class used for IP settings + */ + public static class IpSettings { + @Retention(RetentionPolicy.SOURCE) + @IntDef(value = { + TYPE_DCHP, + TYPE_STATIC + }) + + public @interface Type {} + + public static final int TYPE_DCHP = 0; + public static final int TYPE_STATIC = 1; + + @Type + public int type; + public String ipAddress; + public String gateway; + public int prefixLength; + public String dns1; + public String dns2; + } + + /** + * Sets the callback listener for WifiEntryCallback methods. + * Subsequent calls will overwrite the previous listener. + */ + public void setListener(WifiEntryCallback listener) { + mListener = listener; + } + + /** + * Listener for changes to the state of the WifiEntry or the result of actions on the WifiEntry. + */ + public interface WifiEntryCallback { + @Retention(RetentionPolicy.SOURCE) + @IntDef(value = { + CONNECT_STATUS_SUCCESS, + CONNECT_STATUS_FAILURE_NO_PASSWORD, + CONNECT_STATUS_FAILURE_UNKNOWN + }) + + public @interface ConnectStatus {} + + int CONNECT_STATUS_SUCCESS = 0; + int CONNECT_STATUS_FAILURE_NO_PASSWORD = 1; + int CONNECT_STATUS_FAILURE_UNKNOWN = 2; + + @Retention(RetentionPolicy.SOURCE) + @IntDef(value = { + CONNECT_STATUS_SUCCESS, + CONNECT_STATUS_FAILURE_UNKNOWN + }) + + public @interface DisconnectStatus {} + + int DISCONNECT_STATUS_SUCCESS = 0; + int DISCONNECT_STATUS_FAILURE_UNKNOWN = 1; + + @Retention(RetentionPolicy.SOURCE) + @IntDef(value = { + FORGET_STATUS_SUCCESS, + FORGET_STATUS_FAILURE_UNKNOWN + }) + + public @interface ForgetStatus {} + + int FORGET_STATUS_SUCCESS = 0; + int FORGET_STATUS_FAILURE_UNKNOWN = 1; + + /** + * Indicates the state of the WifiEntry has changed and clients may retrieve updates through + * the WifiEntry getter methods. + */ + void onUpdated(); + + /** + * Result of the connect request indicated by the CONNECT_STATUS constants. + */ + void onConnectResult(@ConnectStatus int status); + + /** + * Result of the disconnect request indicated by the DISCONNECT_STATUS constants. + */ + void onDisconnectResult(@DisconnectStatus int status); + + /** + * Result of the forget request indicated by the FORGET_STATUS constants. + */ + void onForgetResult(@ForgetStatus int status); + } + + // TODO (b/70983952) Come up with a sorting scheme that does the right thing. + @Override + public int compareTo(@NonNull WifiEntry other) { + if (getLevel() > other.getLevel()) return -1; + if (getLevel() < other.getLevel()) return 1; + + return getTitle().compareTo(other.getTitle()); + } + + @Override + public boolean equals(Object other) { + if (!(other instanceof WifiEntry)) return false; + return getKey().equals(((WifiEntry) other).getKey()); + } +} diff --git a/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiTracker2.java b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiTracker2.java new file mode 100644 index 000000000..947b26409 --- /dev/null +++ b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiTracker2.java @@ -0,0 +1,272 @@ +/* + * Copyright (C) 2019 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.wifitrackerlib; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.net.ConnectivityManager; +import android.net.NetworkScoreManager; +import android.net.wifi.WifiManager; +import android.os.Handler; +import android.util.Log; + +import androidx.annotation.GuardedBy; +import androidx.annotation.MainThread; +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.annotation.WorkerThread; +import androidx.lifecycle.Lifecycle; +import androidx.lifecycle.LifecycleObserver; +import androidx.lifecycle.OnLifecycleEvent; + +import java.time.Clock; +import java.util.ArrayList; +import java.util.List; + +/** + * Keeps track of the state of Wi-Fi and supplies {@link WifiEntry} for use in Wi-Fi picker lists. + * + * Clients should use WifiTracker2/WifiEntry for all information regarding Wi-Fi. + */ +public class WifiTracker2 implements LifecycleObserver { + + private static final String TAG = "WifiTracker2"; + + public static boolean sVerboseLogging; + + private static boolean isVerboseLoggingEnabled() { + return WifiTracker2.sVerboseLogging || Log.isLoggable(TAG, Log.VERBOSE); + } + + private final Context mContext; + private final WifiManager mWifiManager; + private final ConnectivityManager mConnectivityManager; + private final NetworkScoreManager mNetworkScoreManager; + private final Handler mMainHandler; + private final Handler mWorkerHandler; + private final long mMaxScanAgeMillis; + private final long mScanIntervalMillis; + private final WifiTrackerCallback mListener; + private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { + /** + * TODO (b/70983952): Add the rest of the broadcast handling. + * WifiManager.SCAN_RESULTS_AVAILABLE_ACTION); + * WifiManager.CONFIGURED_NETWORKS_CHANGED_ACTION); + * WifiManager.LINK_CONFIGURATION_CHANGED_ACTION); + * WifiManager.NETWORK_STATE_CHANGED_ACTION); + * WifiManager.RSSI_CHANGED_ACTION); + */ + @Override + @WorkerThread + public void onReceive(Context context, Intent intent) { + String action = intent.getAction(); + + if (isVerboseLoggingEnabled()) { + Log.i(TAG, "Received broadcast: " + action); + } + + if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(action)) { + updateWifiState(); + } + } + }; + + private final ScanResultUpdater mScanResultUpdater; + + // Lock object for mWifiEntries + private final Object mLock = new Object(); + + private int mWifiState; + @GuardedBy("mLock") + private final List<WifiEntry> mWifiEntries; + + /** + * Constructor for WifiTracker2. + * + * @param lifecycle Lifecycle this is tied to for lifecycle callbacks. + * @param context Context to retrieve WifiManager and resource strings. + * @param wifiManager Provides all Wi-Fi info. + * @param connectivityManager Provides network info. + * @param networkScoreManager Provides network scores for network badging. + * @param mainHandler Handler for processing listener callbacks. + * @param workerHandler Handler for processing all broadcasts and running the Scanner. + * @param clock Clock used for evaluating the age of scans + * @param maxScanAgeMillis Max age for tracked WifiEntries. + * @param scanIntervalMillis Interval between initiating scans. + * @param listener WifiTrackerCallback listening on changes to WifiTracker2 data. + */ + public WifiTracker2(@NonNull Lifecycle lifecycle, @NonNull Context context, + @NonNull WifiManager wifiManager, + @NonNull ConnectivityManager connectivityManager, + @NonNull NetworkScoreManager networkScoreManager, + @NonNull Handler mainHandler, + @NonNull Handler workerHandler, + @NonNull Clock clock, + long maxScanAgeMillis, + long scanIntervalMillis, + @Nullable WifiTrackerCallback listener) { + lifecycle.addObserver(this); + mContext = context; + mWifiManager = wifiManager; + mConnectivityManager = connectivityManager; + mNetworkScoreManager = networkScoreManager; + mMainHandler = mainHandler; + mWorkerHandler = workerHandler; + mMaxScanAgeMillis = maxScanAgeMillis; + mScanIntervalMillis = scanIntervalMillis; + mListener = listener; + + mScanResultUpdater = new ScanResultUpdater(clock, maxScanAgeMillis * 2); + + mWifiState = WifiManager.WIFI_STATE_DISABLED; + mWifiEntries = new ArrayList<>(); + + sVerboseLogging = mWifiManager.getVerboseLoggingLevel() > 0; + } + + /** + * Registers the broadcast receiver and network callbacks and starts the scanning mechanism. + */ + @OnLifecycleEvent(Lifecycle.Event.ON_START) + @MainThread + public void onStart() { + // TODO (b/70983952): Register score cache and receivers for network callbacks. + // TODO (b/70983952): Resume scanner here. + IntentFilter filter = new IntentFilter(); + filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION); + filter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION); + mContext.registerReceiver(mBroadcastReceiver, filter, + /* broadcastPermission */ null, mWorkerHandler); + + // Populate data now so we don't have to wait for the next broadcast. + mWorkerHandler.post(() -> { + updateWifiState(); + // TODO (b/70983952): Update other info (eg ScanResults) driven by broadcasts here. + }); + } + + /** + * Unregisters the broadcast receiver, network callbacks, and pauses the scanning mechanism. + */ + @OnLifecycleEvent(Lifecycle.Event.ON_STOP) + @MainThread + public void onStop() { + // TODO (b/70983952): Unregister score cache and receivers for network callbacks. + // TODO (b/70983952): Pause scanner here. + mContext.unregisterReceiver(mBroadcastReceiver); + } + + /** + * Returns the state of Wi-Fi as one of the following values. + * + * <li>{@link WifiManager#WIFI_STATE_DISABLED}</li> + * <li>{@link WifiManager#WIFI_STATE_ENABLED}</li> + * <li>{@link WifiManager#WIFI_STATE_DISABLING}</li> + * <li>{@link WifiManager#WIFI_STATE_ENABLING}</li> + * <li>{@link WifiManager#WIFI_STATE_UNKNOWN}</li> + */ + public int getWifiState() { + return mWifiState; + } + + /** + * Returns the WifiEntry representing the current connection. + */ + public @Nullable WifiEntry getConnectedWifiEntry() { + // TODO (b/70983952): Fill in this method. + return null; + } + + /** + * Returns a list of in-range WifiEntries. + * + * The currently connected entry is omitted and may be accessed through + * {@link #getConnectedWifiEntry()} + */ + public @NonNull List<WifiEntry> getWifiEntries() { + return mWifiEntries; + } + + /** + * Returns a list of WifiEntries representing saved networks. + */ + public @NonNull List<WifiEntry> getSavedWifiEntries() { + // TODO (b/70983952): Fill in this method. + return new ArrayList<>(); + } + + /** + * Returns a list of WifiEntries representing network subscriptions. + */ + public @NonNull List<WifiEntry> getSubscriptionEntries() { + // TODO (b/70983952): Fill in this method. + return new ArrayList<>(); + } + + /** + * Updates mWifiState and notifies the listener. + */ + @WorkerThread + private void updateWifiState() { + mWifiState = mWifiManager.getWifiState(); + notifyOnWifiStateChanged(); + } + + /** + * Posts onWifiEntryChanged callback on the main thread. + */ + private void notifyOnWifiEntriesChanged() { + if (mListener != null) { + mMainHandler.post(mListener::onWifiEntriesChanged); + } + } + + /** + * Posts onWifiStateChanged callback on the main thread. + */ + private void notifyOnWifiStateChanged() { + if (mListener != null) { + mMainHandler.post(mListener::onWifiStateChanged); + } + } + + /** + * Listener for changes to the Wi-Fi state or lists of WifiEntries. + * + * These callbacks must be run on the MainThread. + * + * TODO (b/70983952): Investigate need for callbacks for saved/subscription entry updates. + */ + public interface WifiTrackerCallback { + /** + * Called when there are changes to + * {@link #getConnectedWifiEntry()} + * {@link #getWifiEntries()} + */ + @MainThread + void onWifiEntriesChanged(); + + /** + * Called when the state of Wi-Fi has changed. The new value can be read through + * {@link #getWifiState()} + */ + @MainThread + void onWifiStateChanged(); + } +} diff --git a/libs/WifiTrackerLib/tests/Android.bp b/libs/WifiTrackerLib/tests/Android.bp index e8f854893..97eefb7a2 100644 --- a/libs/WifiTrackerLib/tests/Android.bp +++ b/libs/WifiTrackerLib/tests/Android.bp @@ -19,9 +19,17 @@ android_test { static_libs: [ "android-support-test", "androidx.test.rules", + "frameworks-base-testutils", + "mockito-target-minus-junit4", + "truth-prebuilt", "WifiTrackerLib", ], + libs: [ + "android.test.mock", + "Robolectric_all-target", + ], + platform_apis: true, test_suites: ["device-tests"], diff --git a/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/ScanResultUpdaterTest.java b/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/ScanResultUpdaterTest.java index 39d6bf3f8..b92a764d7 100644 --- a/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/ScanResultUpdaterTest.java +++ b/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/ScanResultUpdaterTest.java @@ -16,16 +16,19 @@ package com.android.wifitrackerlib; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.equalTo; +import static com.google.common.truth.Truth.assertThat; + import static org.junit.Assert.fail; +import static org.mockito.Mockito.when; import android.net.wifi.ScanResult; -import android.os.SystemClock; +import org.junit.Before; import org.junit.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import java.time.Clock; import java.util.Arrays; import java.util.List; @@ -33,6 +36,16 @@ public class ScanResultUpdaterTest { private static final String BSSID_1 = "11:11:11:11:11:11"; private static final String BSSID_2 = "22:22:22:22:22:22"; private static final String BSSID_3 = "33:33:33:33:33:33"; + private static final long NOW_MILLIS = 123_456_789; + + @Mock private Clock mMockClock; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + when(mMockClock.millis()).thenReturn(NOW_MILLIS); + } private static ScanResult buildScanResult(String bssid, long timestampMs) { return new ScanResult( @@ -58,20 +71,17 @@ public class ScanResultUpdaterTest { BSSID_1, 20); // Add initial scan result. List should have 1 scan. - ScanResultUpdater sru = new ScanResultUpdater(); + ScanResultUpdater sru = new ScanResultUpdater(mMockClock); sru.update(Arrays.asList(oldResult)); - assertThat(sru.getScanResults().size(), equalTo(1)); - assertThat(sru.getScanResults().get(0), equalTo(oldResult)); + assertThat(sru.getScanResults()).containsExactly(oldResult); // Add new scan result. Old scan result should be replaced. sru.update(Arrays.asList(newResult)); - assertThat(sru.getScanResults().size(), equalTo(1)); - assertThat(sru.getScanResults().get(0), equalTo(newResult)); + assertThat(sru.getScanResults()).containsExactly(newResult); // Add old scan result back. New scan result should still remain. sru.update(Arrays.asList(oldResult)); - assertThat(sru.getScanResults().size(), equalTo(1)); - assertThat(sru.getScanResults().get(0), equalTo(newResult)); + assertThat(sru.getScanResults()).containsExactly(newResult); } /** @@ -79,21 +89,17 @@ public class ScanResultUpdaterTest { */ @Test public void testGetScanResults_filtersOldScans() { - long now = SystemClock.elapsedRealtime(); long maxScanAge = 15_000; - ScanResult oldResult = buildScanResult( - BSSID_1, now - (maxScanAge + 1)); - ScanResult newResult = buildScanResult( - BSSID_2, now); + ScanResult oldResult = buildScanResult(BSSID_1, NOW_MILLIS - (maxScanAge + 1)); + ScanResult newResult = buildScanResult(BSSID_2, NOW_MILLIS); // Add a new scan result and an out-of-date scan result. - ScanResultUpdater sru = new ScanResultUpdater(); + ScanResultUpdater sru = new ScanResultUpdater(mMockClock); sru.update(Arrays.asList(newResult, oldResult)); // New scan result should remain and out-of-date scan result should not be returned. - assertThat(sru.getScanResults(maxScanAge).size(), equalTo(1)); - assertThat(sru.getScanResults(maxScanAge).get(0), equalTo(newResult)); + assertThat(sru.getScanResults(maxScanAge)).containsExactly(newResult); } /** @@ -102,7 +108,7 @@ public class ScanResultUpdaterTest { */ @Test public void testGetScanResults_invalidMaxScanAgeMillis_throwsException() { - ScanResultUpdater sru = new ScanResultUpdater(15_000); + ScanResultUpdater sru = new ScanResultUpdater(mMockClock, 15_000); try { sru.getScanResults(20_000); fail("Should have thrown exception for maxScanAgeMillis too large."); @@ -116,19 +122,17 @@ public class ScanResultUpdaterTest { */ @Test public void testConstructor_maxScanAge_filtersOldScans() { - ScanResultUpdater sru = new ScanResultUpdater(15_000); - long now = SystemClock.elapsedRealtime(); + ScanResultUpdater sru = new ScanResultUpdater(mMockClock, 15_000); - ScanResult scan1 = buildScanResult(BSSID_1, now - 10_000); - ScanResult scan2 = buildScanResult(BSSID_2, now - 12_000); - ScanResult scan3 = buildScanResult(BSSID_3, now - 20_000); + ScanResult scan1 = buildScanResult(BSSID_1, NOW_MILLIS - 10_000); + ScanResult scan2 = buildScanResult(BSSID_2, NOW_MILLIS - 15_000); + ScanResult scan3 = buildScanResult(BSSID_3, NOW_MILLIS - 20_000); sru.update(Arrays.asList(scan1, scan2, scan3)); List<ScanResult> scanResults = sru.getScanResults(); - assertThat(scanResults.size(), equalTo(2)); - assertThat(scanResults, contains(scan1, scan2)); + assertThat(scanResults).containsExactly(scan1, scan2); } /** @@ -137,23 +141,20 @@ public class ScanResultUpdaterTest { */ @Test public void testGetScanResults_overridesConstructorMaxScanAge() { - ScanResultUpdater sru = new ScanResultUpdater(15_000); - long now = SystemClock.elapsedRealtime(); + ScanResultUpdater sru = new ScanResultUpdater(mMockClock, 15_000); - ScanResult scan1 = buildScanResult(BSSID_1, now - 10_000); - ScanResult scan2 = buildScanResult(BSSID_2, now - 12_000); - ScanResult scan3 = buildScanResult(BSSID_3, now - 20_000); + ScanResult scan1 = buildScanResult(BSSID_1, NOW_MILLIS - 10_000); + ScanResult scan2 = buildScanResult(BSSID_2, NOW_MILLIS - 15_000); + ScanResult scan3 = buildScanResult(BSSID_3, NOW_MILLIS - 20_000); sru.update(Arrays.asList(scan1, scan2, scan3)); // Aged getScanResults should override the constructor max scan age. List<ScanResult> scanResults = sru.getScanResults(11_000); - assertThat(scanResults.size(), equalTo(1)); - assertThat(scanResults, contains(scan1)); + assertThat(scanResults).containsExactly(scan1); // Non-aged getScanResults should revert to the constructor max scan age. scanResults = sru.getScanResults(); - assertThat(scanResults.size(), equalTo(2)); - assertThat(scanResults, contains(scan1, scan2)); + assertThat(scanResults).containsExactly(scan1, scan2); } } diff --git a/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/WifiTracker2Test.java b/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/WifiTracker2Test.java new file mode 100644 index 000000000..410f18277 --- /dev/null +++ b/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/WifiTracker2Test.java @@ -0,0 +1,140 @@ +/* + * Copyright (C) 2019 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.wifitrackerlib; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.atLeastOnce; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.net.ConnectivityManager; +import android.net.NetworkScoreManager; +import android.net.wifi.WifiManager; +import android.os.Handler; +import android.os.test.TestLooper; + +import androidx.lifecycle.Lifecycle; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.time.Clock; + +public class WifiTracker2Test { + + @Mock private Lifecycle mMockLifecycle; + @Mock private Context mMockContext; + @Mock private WifiManager mMockWifiManager; + @Mock private ConnectivityManager mMockConnectivityManager; + @Mock private NetworkScoreManager mMockNetworkScoreManager; + @Mock private Clock mMockClock; + @Mock private WifiTracker2.WifiTrackerCallback mMockWifiTrackerCallback; + + private TestLooper mTestLooper = new TestLooper(); + + private final ArgumentCaptor<BroadcastReceiver> mBroadcastReceiverCaptor = + ArgumentCaptor.forClass(BroadcastReceiver.class); + + private WifiTracker2 createTestWifiTracker2() { + final Handler testHandler = new Handler(mTestLooper.getLooper()); + + return new WifiTracker2(mMockLifecycle, mMockContext, + mMockWifiManager, + mMockConnectivityManager, + mMockNetworkScoreManager, + testHandler, + testHandler, + mMockClock, + 15_000, + 10_000, + mMockWifiTrackerCallback); + } + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + } + + /** + * Tests that receiving a wifi state change broadcast updates getWifiState(). + */ + @Test + public void testWifiStateChangeBroadcast_updatesWifiState() { + WifiTracker2 wifiTracker2 = createTestWifiTracker2(); + wifiTracker2.onStart(); + verify(mMockContext).registerReceiver(mBroadcastReceiverCaptor.capture(), + any(), any(), any()); + + when(mMockWifiManager.getWifiState()).thenReturn(WifiManager.WIFI_STATE_DISABLED); + mBroadcastReceiverCaptor.getValue().onReceive(mMockContext, + new Intent(WifiManager.WIFI_STATE_CHANGED_ACTION)); + + assertThat(wifiTracker2.getWifiState()).isEqualTo(WifiManager.WIFI_STATE_DISABLED); + + when(mMockWifiManager.getWifiState()).thenReturn(WifiManager.WIFI_STATE_ENABLED); + mBroadcastReceiverCaptor.getValue().onReceive(mMockContext, + new Intent(WifiManager.WIFI_STATE_CHANGED_ACTION)); + + assertThat(wifiTracker2.getWifiState()).isEqualTo(WifiManager.WIFI_STATE_ENABLED); + + } + + /** + * Tests that receiving a wifi state change broadcast notifies the listener. + */ + @Test + public void testWifiStateChangeBroadcast_NotifiesListener() { + WifiTracker2 wifiTracker2 = createTestWifiTracker2(); + wifiTracker2.onStart(); + verify(mMockContext).registerReceiver(mBroadcastReceiverCaptor.capture(), + any(), any(), any()); + + mBroadcastReceiverCaptor.getValue().onReceive(mMockContext, + new Intent(WifiManager.WIFI_STATE_CHANGED_ACTION)); + mTestLooper.dispatchAll(); + + verify(mMockWifiTrackerCallback, atLeastOnce()).onWifiStateChanged(); + } + + /** + * Tests that the wifi state is set correctly after onStart, even if no broadcast was received. + */ + @Test + public void testOnStart_setsWifiState() { + WifiTracker2 wifiTracker2 = createTestWifiTracker2(); + when(mMockWifiManager.getWifiState()).thenReturn(WifiManager.WIFI_STATE_DISABLED); + wifiTracker2.onStart(); + mTestLooper.dispatchAll(); + + assertThat(wifiTracker2.getWifiState()).isEqualTo(WifiManager.WIFI_STATE_DISABLED); + + wifiTracker2.onStop(); + when(mMockWifiManager.getWifiState()).thenReturn(WifiManager.WIFI_STATE_ENABLED); + wifiTracker2.onStart(); + mTestLooper.dispatchAll(); + + assertThat(wifiTracker2.getWifiState()).isEqualTo(WifiManager.WIFI_STATE_ENABLED); + } +} |