*/
package com.android.settings.wifi.details;
+import android.app.Fragment;
+import android.content.BroadcastReceiver;
import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
import android.graphics.drawable.Drawable;
import android.net.ConnectivityManager;
import android.net.IpPrefix;
import com.android.settings.core.PreferenceController;
import com.android.settings.core.lifecycle.Lifecycle;
import com.android.settings.core.lifecycle.LifecycleObserver;
+import com.android.settings.core.lifecycle.events.OnPause;
import com.android.settings.core.lifecycle.events.OnResume;
import com.android.settings.wifi.WifiDetailPreference;
import com.android.settingslib.wifi.AccessPoint;
* {@link WifiNetworkDetailsFragment}.
*/
public class WifiDetailPreferenceController extends PreferenceController implements
- LifecycleObserver, OnResume {
+ LifecycleObserver, OnPause, OnResume {
private static final String TAG = "WifiDetailsPrefCtrl";
+ private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
@VisibleForTesting
static final String KEY_CONNECTION_DETAIL_PREF = "connection_detail";
static final String KEY_IPV6_ADDRESS_CATEGORY = "ipv6_details_category";
private AccessPoint mAccessPoint;
+ private final ConnectivityManager mConnectivityManager;
+ private final Fragment mFragment;
private NetworkInfo mNetworkInfo;
private Context mPrefContext;
private int mRssi;
private String[] mSignalStr;
- private WifiConfiguration mWifiConfig;
+ private final WifiConfiguration mWifiConfig;
private WifiInfo mWifiInfo;
private final WifiManager mWifiManager;
- private final ConnectivityManager mConnectivityManager;
// Preferences - in order of appearance
private Preference mConnectionDetailPref;
private WifiDetailPreference mDnsPref;
private PreferenceCategory mIpv6AddressCategory;
- public WifiDetailPreferenceController(AccessPoint accessPoint, Context context,
- Lifecycle lifecycle, WifiManager wifiManager, ConnectivityManager connectivityManager) {
+ private final IntentFilter mFilter;
+ private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ switch (intent.getAction()) {
+ case WifiManager.NETWORK_STATE_CHANGED_ACTION:
+ case WifiManager.RSSI_CHANGED_ACTION:
+ updateInfo();
+ }
+ }
+ };
+
+ public WifiDetailPreferenceController(
+ AccessPoint accessPoint,
+ ConnectivityManager connectivityManager,
+ Context context,
+ Fragment fragment,
+ Lifecycle lifecycle,
+ WifiManager wifiManager) {
super(context);
mAccessPoint = accessPoint;
+ mConnectivityManager = connectivityManager;
+ mFragment = fragment;
mNetworkInfo = accessPoint.getNetworkInfo();
mRssi = accessPoint.getRssi();
mSignalStr = context.getResources().getStringArray(R.array.wifi_signal);
mWifiConfig = accessPoint.getConfig();
mWifiManager = wifiManager;
- mConnectivityManager = connectivityManager;
- mWifiInfo = wifiManager.getConnectionInfo();
+
+ mFilter = new IntentFilter();
+ mFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
+ mFilter.addAction(WifiManager.RSSI_CHANGED_ACTION);
lifecycle.addObserver(this);
}
@Override
public void onResume() {
- mWifiInfo = mWifiManager.getConnectionInfo();
+ updateInfo();
- refreshFromWifiInfo();
- setIpText();
+ mContext.registerReceiver(mReceiver, mFilter);
+ }
+
+ @Override
+ public void onPause() {
+ mContext.unregisterReceiver(mReceiver);
}
- private void refreshFromWifiInfo() {
- if (mWifiInfo == null) {
+ private void updateInfo() {
+ mNetworkInfo = mConnectivityManager.getNetworkInfo(mWifiManager.getCurrentNetwork());
+ mWifiInfo = mWifiManager.getConnectionInfo();
+ if (mNetworkInfo == null || mWifiInfo == null) {
+ exitActivity();
return;
}
- mAccessPoint.update(mWifiConfig, mWifiInfo, mNetworkInfo);
- int iconSignalLevel = WifiManager.calculateSignalLevel(
- mWifiInfo.getRssi(), WifiManager.RSSI_LEVELS);
- Drawable wifiIcon = NetworkBadging.getWifiIcon(
- iconSignalLevel, NetworkBadging.BADGING_NONE, mContext.getTheme()).mutate();
+ refreshNetworkState();
- // Connected Header Pref
- mConnectionDetailPref.setIcon(wifiIcon);
- mConnectionDetailPref.setTitle(mAccessPoint.getSettingsSummary());
+ // Update Connection Header icon and Signal Strength Preference
+ mRssi = mWifiInfo.getRssi();
+ refreshRssiViews();
// MAC Address Pref
mMacAddressPref.setDetailText(mWifiInfo.getMacAddress());
- // Signal Strength Pref
- Drawable wifiIconDark = wifiIcon.getConstantState().newDrawable().mutate();
- wifiIconDark.setTint(mContext.getResources().getColor(
- R.color.wifi_details_icon_color, mContext.getTheme()));
- mSignalStrengthPref.setIcon(wifiIconDark);
-
- int summarySignalLevel = mAccessPoint.getLevel();
- mSignalStrengthPref.setDetailText(mSignalStr[summarySignalLevel]);
-
// Link Speed Pref
int linkSpeedMbps = mWifiInfo.getLinkSpeed();
mLinkSpeedPref.setVisible(linkSpeedMbps >= 0);
Log.e(TAG, "Unexpected frequency " + frequency);
}
mFrequencyPref.setDetailText(band);
+
+ setIpText();
+ }
+
+ private void exitActivity() {
+ if (DEBUG) {
+ Log.d(TAG, "Exiting the WifiNetworkDetailsPage");
+ }
+ mFragment.getActivity().finish();
+ }
+
+ private void refreshNetworkState() {
+ mAccessPoint.update(mWifiConfig, mWifiInfo, mNetworkInfo);
+ mConnectionDetailPref.setTitle(mAccessPoint.getSettingsSummary());
+ }
+
+ private void refreshRssiViews() {
+ int iconSignalLevel = WifiManager.calculateSignalLevel(
+ mRssi, WifiManager.RSSI_LEVELS);
+ Drawable wifiIcon = NetworkBadging.getWifiIcon(
+ iconSignalLevel, NetworkBadging.BADGING_NONE, mContext.getTheme()).mutate();
+
+ mConnectionDetailPref.setIcon(wifiIcon);
+
+ Drawable wifiIconDark = wifiIcon.getConstantState().newDrawable().mutate();
+ wifiIconDark.setTint(mContext.getResources().getColor(
+ R.color.wifi_details_icon_color, mContext.getTheme()));
+ mSignalStrengthPref.setIcon(wifiIconDark);
+
+ int summarySignalLevel = mAccessPoint.getLevel();
+ mSignalStrengthPref.setDetailText(mSignalStr[summarySignalLevel]);
}
private void setIpText() {
mWifiManager.forget(mWifiConfig.networkId, null /* action listener */);
}
}
+ mFragment.getActivity().finish();
}
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import android.app.Activity;
import android.content.Context;
+import android.content.Intent;
import android.graphics.drawable.Drawable;
import android.net.ConnectivityManager;
import android.net.IpPrefix;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
import org.robolectric.RuntimeEnvironment;
-import org.robolectric.annotation.Config;
-import org.robolectric.annotation.Implementation;
-import org.robolectric.annotation.Implements;
import java.net.InetAddress;
import java.net.UnknownHostException;
private PreferenceScreen mockScreen;
@Mock private AccessPoint mockAccessPoint;
- @Mock private WifiManager mockWifiManager;
+ @Mock private Activity mockActivity;
@Mock private ConnectivityManager mockConnectivityManager;
+ @Mock private Network mockNetwork;
@Mock private NetworkInfo mockNetworkInfo;
@Mock private WifiConfiguration mockWifiConfig;
@Mock private WifiInfo mockWifiInfo;
- @Mock private Network mockNetwork;
+ @Mock private WifiNetworkDetailsFragment mockFragment;
+ @Mock private WifiManager mockWifiManager;
@Mock private Preference mockConnectionDetailPref;
@Mock private WifiDetailPreference mockSignalStrengthPref;
when(mockAccessPoint.getRssi()).thenReturn(RSSI);
when(mockAccessPoint.getSecurityString(false)).thenReturn(SECURITY);
+ when(mockConnectivityManager.getNetworkInfo(any(Network.class)))
+ .thenReturn(mockNetworkInfo);
+
when(mockWifiInfo.getLinkSpeed()).thenReturn(LINK_SPEED);
when(mockWifiInfo.getRssi()).thenReturn(RSSI);
when(mockWifiInfo.getMacAddress()).thenReturn(MAC_ADDRESS);
mLinkProperties = new LinkProperties();
when(mockConnectivityManager.getLinkProperties(mockNetwork)).thenReturn(mLinkProperties);
- mController = new WifiDetailPreferenceController(
- mockAccessPoint, mContext, mLifecycle, mockWifiManager, mockConnectivityManager);
+ when(mockFragment.getActivity()).thenReturn(mockActivity);
+
+ mController = newWifiDetailPreferenceController();
setupMockedPreferenceScreen();
}
+ private WifiDetailPreferenceController newWifiDetailPreferenceController() {
+ return new WifiDetailPreferenceController(
+ mockAccessPoint,
+ mockConnectivityManager,
+ mContext,
+ mockFragment,
+ mLifecycle,
+ mockWifiManager);
+ }
+
private void setupMockedPreferenceScreen() {
when(mockScreen.findPreference(WifiDetailPreferenceController.KEY_CONNECTION_DETAIL_PREF))
.thenReturn(mockConnectionDetailPref);
}
@Test
- public void latestWifiInfoAndConfig_shouldBeFetchedOnResume() {
+ public void latestWifiInfo_shouldBeFetchedOnResume() {
mController.onResume();
- // Once in construction, once in onResume
- verify(mockWifiManager, times(2)).getConnectionInfo();
+ verify(mockWifiManager, times(1)).getConnectionInfo();
+ }
+
+ @Test
+ public void latestNetworkInfo_shouldBeFetchedOnResume() {
+ mController.onResume();
+
+ verify(mockConnectivityManager, times(1)).getNetworkInfo(any(Network.class));
}
@Test
@Test
public void canForgetNetwork_noNetwork() {
when(mockAccessPoint.getConfig()).thenReturn(null);
-
- mController = new WifiDetailPreferenceController(
- mockAccessPoint, mContext, mLifecycle, mockWifiManager, mockConnectivityManager);
+ mController = newWifiDetailPreferenceController();
+ mController.displayPreference(mockScreen);
+ mController.onResume();
assertThat(mController.canForgetNetwork()).isFalse();
}
public void canForgetNetwork_ephemeral() {
when(mockWifiInfo.isEphemeral()).thenReturn(true);
when(mockAccessPoint.getConfig()).thenReturn(null);
-
- mController = new WifiDetailPreferenceController(
- mockAccessPoint, mContext, mLifecycle, mockWifiManager, mockConnectivityManager);
+ mController = newWifiDetailPreferenceController();
+ mController.displayPreference(mockScreen);
+ mController.onResume();
assertThat(mController.canForgetNetwork()).isTrue();
}
@Test
public void forgetNetwork_ephemeral() {
String ssid = "ssid";
-
when(mockWifiInfo.isEphemeral()).thenReturn(true);
when(mockWifiInfo.getSSID()).thenReturn(ssid);
+ mController.onResume();
+
mController.forgetNetwork();
verify(mockWifiManager).disableEphemeralNetwork(ssid);
verify(mockWifiManager).forget(mockWifiConfig.networkId, null);
}
+
+ @Test
+ public void networkStateChangedIntent_shouldRefetchInfo() {
+ mController.onResume();
+ verify(mockConnectivityManager, times(1)).getNetworkInfo(any(Network.class));
+ verify(mockWifiManager, times(1)).getConnectionInfo();
+
+ mContext.sendBroadcast(new Intent(WifiManager.NETWORK_STATE_CHANGED_ACTION));
+
+ verify(mockConnectivityManager, times(2)).getNetworkInfo(any(Network.class));
+ verify(mockWifiManager, times(2)).getConnectionInfo();
+ }
+
+ @Test
+ public void rssiChangedIntent_shouldRefetchInfo() {
+ mController.onResume();
+ verify(mockConnectivityManager, times(1)).getNetworkInfo(any(Network.class));
+ verify(mockWifiManager, times(1)).getConnectionInfo();
+
+ mContext.sendBroadcast(new Intent(WifiManager.RSSI_CHANGED_ACTION));
+
+ verify(mockConnectivityManager, times(2)).getNetworkInfo(any(Network.class));
+ verify(mockWifiManager, times(2)).getConnectionInfo();
+ }
+
+ @Test
+ public void networkDisconnectdState_shouldFinishActivity() {
+ mController.onResume();
+
+ when(mockConnectivityManager.getNetworkInfo(any(Network.class))).thenReturn(null);
+ mContext.sendBroadcast(new Intent(WifiManager.NETWORK_STATE_CHANGED_ACTION));
+
+ verify(mockActivity).finish();
+ }
}