Add ConnectedUsbDeviceUpdater

The usb updater listens to usb update and notify
ConnectedDeviceGroupController to add/remove
preference.

This cl:
1. Add ConntectedusbDeviceUpdater
2. Extract the UsbConnectionBroadcastReceiver since it would be
used both in controller and updater.
3. Add tests

Bug: 69333961
Test: RunSettingsRoboTests

Change-Id: Ic3b045a6faa4eba57d9b0c089ea1656141cc0220

tests/robotests/src/com/android/settings/connecteddevice/ConnectedDeviceGroupControllerTest.java

@@ -37,6 +37,7 @@ import com.android.settingslib.core.lifecycle.Lifecycle;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.Answers;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RuntimeEnvironment;
@@ -45,13 +46,17 @@ import org.robolectric.annotation.Config;
 @RunWith(SettingsRobolectricTestRunner.class)
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
 public class ConnectedDeviceGroupControllerTest {
+    private static final String PREFERENCE_KEY_1 = "pref_key_1";
+
     @Mock
     private DashboardFragment mDashboardFragment;
     @Mock
     private ConnectedBluetoothDeviceUpdater mConnectedBluetoothDeviceUpdater;
     @Mock
-    private PreferenceScreen mPreferenceScreen;
+    private ConnectedUsbDeviceUpdater mConnectedUsbDeviceUpdater;
     @Mock
+    private PreferenceScreen mPreferenceScreen;
+    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private PreferenceManager mPreferenceManager;
 
     private PreferenceGroup mPreferenceGroup;
@@ -66,30 +71,33 @@ public class ConnectedDeviceGroupControllerTest {
 
         mContext = RuntimeEnvironment.application;
         mPreference = new Preference(mContext);
+        mPreference.setKey(PREFERENCE_KEY_1);
         mLifecycle = new Lifecycle(() -> mLifecycle);
         mPreferenceGroup = spy(new PreferenceScreen(mContext, null));
         doReturn(mPreferenceManager).when(mPreferenceGroup).getPreferenceManager();
         doReturn(mContext).when(mDashboardFragment).getContext();
 
         mConnectedDeviceGroupController = new ConnectedDeviceGroupController(mDashboardFragment,
-                mLifecycle, mConnectedBluetoothDeviceUpdater);
+                mLifecycle, mConnectedBluetoothDeviceUpdater, mConnectedUsbDeviceUpdater);
         mConnectedDeviceGroupController.mPreferenceGroup = mPreferenceGroup;
     }
 
     @Test
-    public void testOnDeviceAdded_firstAdd_becomeVisible() {
+    public void testOnDeviceAdded_firstAdd_becomeVisibleAndPreferenceAdded() {
         mConnectedDeviceGroupController.onDeviceAdded(mPreference);
 
         assertThat(mPreferenceGroup.isVisible()).isTrue();
+        assertThat(mPreferenceGroup.findPreference(PREFERENCE_KEY_1)).isEqualTo(mPreference);
     }
 
     @Test
-    public void testOnDeviceRemoved_lastRemove_becomeInvisible() {
+    public void testOnDeviceRemoved_lastRemove_becomeInvisibleAndPreferenceRemoved() {
         mPreferenceGroup.addPreference(mPreference);
 
         mConnectedDeviceGroupController.onDeviceRemoved(mPreference);
 
         assertThat(mPreferenceGroup.isVisible()).isFalse();
+        assertThat(mPreferenceGroup.getPreferenceCount()).isEqualTo(0);
     }
 
     @Test
@@ -117,9 +125,11 @@ public class ConnectedDeviceGroupControllerTest {
         // register the callback in onStart()
         mLifecycle.handleLifecycleEvent(android.arch.lifecycle.Lifecycle.Event.ON_START);
         verify(mConnectedBluetoothDeviceUpdater).registerCallback();
+        verify(mConnectedUsbDeviceUpdater).registerCallback();
 
         // unregister the callback in onStop()
         mLifecycle.handleLifecycleEvent(android.arch.lifecycle.Lifecycle.Event.ON_STOP);
         verify(mConnectedBluetoothDeviceUpdater).unregisterCallback();
+        verify(mConnectedUsbDeviceUpdater).unregisterCallback();
     }
 }

tests/robotests/src/com/android/settings/connecteddevice/ConnectedUsbDeviceUpdaterTest.java

@@ -0,0 +1,89 @@
+/*
+ * 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.settings.connecteddevice;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+import android.content.Context;
+
+import com.android.settings.R;
+import com.android.settings.TestConfig;
+import com.android.settings.deviceinfo.UsbBackend;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
+public class ConnectedUsbDeviceUpdaterTest {
+    private Context mContext;
+    private ConnectedUsbDeviceUpdater mDeviceUpdater;
+
+    @Mock
+    private UsbConnectionBroadcastReceiver mUsbReceiver;
+    @Mock
+    private DevicePreferenceCallback mDevicePreferenceCallback;
+    @Mock
+    private UsbBackend mUsbBackend;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+
+        mContext = RuntimeEnvironment.application;
+        mDeviceUpdater = new ConnectedUsbDeviceUpdater(mContext, mDevicePreferenceCallback,
+                mUsbBackend);
+        mDeviceUpdater.mUsbReceiver = mUsbReceiver;
+    }
+
+    @Test
+    public void testInitUsbPreference_preferenceInit() {
+        mDeviceUpdater.initUsbPreference(mContext);
+
+        assertThat(mDeviceUpdater.mUsbPreference.getTitle()).isEqualTo("USB");
+        assertThat(mDeviceUpdater.mUsbPreference.getIcon()).isEqualTo(mContext.getDrawable(
+                R.drawable.ic_usb));
+        assertThat(mDeviceUpdater.mUsbPreference.isSelectable()).isFalse();
+    }
+
+    @Test
+    public void testInitUsbPreference_usbConnected_preferenceAdded() {
+        doReturn(true).when(mUsbReceiver).isConnected();
+
+        mDeviceUpdater.initUsbPreference(mContext);
+
+        verify(mDevicePreferenceCallback).onDeviceAdded(mDeviceUpdater.mUsbPreference);
+    }
+
+    @Test
+    public void testInitUsbPreference_usbDisconnected_preferenceRemoved() {
+        doReturn(false).when(mUsbReceiver).isConnected();
+
+        mDeviceUpdater.initUsbPreference(mContext);
+
+        verify(mDevicePreferenceCallback).onDeviceRemoved(mDeviceUpdater.mUsbPreference);
+    }
+
+}

tests/robotests/src/com/android/settings/connecteddevice/UsbConnectionBroadcastReceiverTest.java

@@ -0,0 +1,126 @@
+/*
+ * 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.settings.connecteddevice;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.hardware.usb.UsbManager;
+
+import com.android.settings.TestConfig;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowApplication;
+
+import java.util.List;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
+public class UsbConnectionBroadcastReceiverTest {
+    private Context mContext;
+    private UsbConnectionBroadcastReceiver mReceiver;
+    private ShadowApplication mShadowApplication;
+
+    @Mock
+    private UsbConnectionBroadcastReceiver.UsbConnectionListener mListener;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+
+        mShadowApplication = ShadowApplication.getInstance();
+        mContext = RuntimeEnvironment.application;
+        mReceiver = new UsbConnectionBroadcastReceiver(mContext, mListener);
+    }
+
+    @Test
+    public void testOnReceive_usbConnected_invokeCallback() {
+        final Intent intent = new Intent();
+        intent.putExtra(UsbManager.USB_CONNECTED, true);
+
+        mReceiver.onReceive(mContext, intent);
+
+        verify(mListener).onUsbConnectionChanged(true);
+    }
+
+    @Test
+    public void testOnReceive_usbDisconnected_invokeCallback() {
+        final Intent intent = new Intent();
+        intent.putExtra(UsbManager.USB_CONNECTED, false);
+
+        mReceiver.onReceive(mContext, intent);
+
+        verify(mListener).onUsbConnectionChanged(false);
+    }
+
+    @Test
+    public void testRegister_invokeMethodTwice_registerOnce() {
+        mReceiver.register();
+        mReceiver.register();
+
+        final List<BroadcastReceiver> receivers = mShadowApplication.getReceiversForIntent(
+                new Intent(UsbManager.ACTION_USB_STATE));
+        assertHasOneUsbConnectionBroadcastReceiver(receivers);
+    }
+
+    @Test
+    public void testUnregister_invokeMethodTwice_unregisterOnce() {
+        mReceiver.register();
+        mReceiver.unregister();
+        mReceiver.unregister();
+
+        final List<BroadcastReceiver> receivers = mShadowApplication.getReceiversForIntent(
+                new Intent(UsbManager.ACTION_USB_STATE));
+        assertHasNoUsbConnectionBroadcastReceiver(receivers);
+    }
+
+    private void assertHasOneUsbConnectionBroadcastReceiver(List<BroadcastReceiver> receivers) {
+        boolean hasReceiver = false;
+        for (final BroadcastReceiver receiver : receivers) {
+            if (receiver instanceof UsbConnectionBroadcastReceiver) {
+                // If hasReceiver is true, then we're at the second copy of it so fail.
+                assertWithMessage(
+                        "Only one instance of UsbConnectionBroadcastReceiver should be "
+                                + "registered").that(
+                        hasReceiver).isFalse();
+                hasReceiver = true;
+            }
+        }
+        assertThat(hasReceiver).isTrue();
+    }
+
+    private void assertHasNoUsbConnectionBroadcastReceiver(List<BroadcastReceiver> receivers) {
+        for (final BroadcastReceiver receiver : receivers) {
+            assertThat(receiver instanceof UsbConnectionBroadcastReceiver).isFalse();
+        }
+    }
+}