Merge changes Ifb5507cb,Ide044cf9

* changes:
  Update BT header using BT metadata
  Add layout for advanced BT detail header

tests/robotests/src/com/android/settings/bluetooth/AdvancedBluetoothDetailsHeaderControllerTest.java

@@ -0,0 +1,127 @@
+/*
+ * 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.settings.bluetooth;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.when;
+
+import android.bluetooth.BluetoothDevice;
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.view.LayoutInflater;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import com.android.settings.R;
+import com.android.settings.core.BasePreferenceController;
+import com.android.settings.fuelgauge.BatteryMeterView;
+import com.android.settings.testutils.shadow.ShadowEntityHeaderController;
+import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.widget.LayoutPreference;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(shadows = ShadowEntityHeaderController.class)
+public class AdvancedBluetoothDetailsHeaderControllerTest{
+    private static final int BATTERY_LEVEL_MAIN = 30;
+    private static final int BATTERY_LEVEL_LEFT = 25;
+    private static final int BATTERY_LEVEL_RIGHT = 45;
+
+    private Context mContext;
+
+    @Mock
+    private BluetoothDevice mBluetoothDevice;
+    @Mock
+    private CachedBluetoothDevice mCachedDevice;
+    private AdvancedBluetoothDetailsHeaderController mController;
+    private LayoutPreference mLayoutPreference;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+
+        mContext = RuntimeEnvironment.application;
+        mController = new AdvancedBluetoothDetailsHeaderController(mContext, "pref_Key");
+        mController.init(mCachedDevice);
+        mLayoutPreference = new LayoutPreference(mContext,
+                LayoutInflater.from(mContext).inflate(R.layout.advanced_bt_entity_header, null));
+        mController.mLayoutPreference = mLayoutPreference;
+        when(mCachedDevice.getDevice()).thenReturn(mBluetoothDevice);
+    }
+
+    @Test
+    public void createBatteryIcon_hasCorrectInfo() {
+        final Drawable drawable = mController.createBtBatteryIcon(mContext, BATTERY_LEVEL_MAIN);
+        assertThat(drawable).isInstanceOf(BatteryMeterView.BatteryMeterDrawable.class);
+
+        final BatteryMeterView.BatteryMeterDrawable iconDrawable =
+                (BatteryMeterView.BatteryMeterDrawable) drawable;
+        assertThat(iconDrawable.getBatteryLevel()).isEqualTo(BATTERY_LEVEL_MAIN);
+    }
+
+    @Test
+    public void refresh_updateCorrectInfo() {
+        when(mBluetoothDevice.getMetadata(
+                BluetoothDevice.METADATA_UNTHETHERED_LEFT_BATTERY)).thenReturn(
+                String.valueOf(BATTERY_LEVEL_LEFT));
+        when(mBluetoothDevice.getMetadata(
+                BluetoothDevice.METADATA_UNTHETHERED_RIGHT_BATTERY)).thenReturn(
+                String.valueOf(BATTERY_LEVEL_RIGHT));
+        when(mBluetoothDevice.getMetadata(
+                BluetoothDevice.METADATA_UNTHETHERED_CASE_BATTERY)).thenReturn(
+                String.valueOf(BATTERY_LEVEL_MAIN));
+        mController.refresh();
+
+        assertBatteryLevel(mLayoutPreference.findViewById(R.id.layout_left), BATTERY_LEVEL_LEFT);
+        assertBatteryLevel(mLayoutPreference.findViewById(R.id.layout_right), BATTERY_LEVEL_RIGHT);
+        assertBatteryLevel(mLayoutPreference.findViewById(R.id.layout_middle), BATTERY_LEVEL_MAIN);
+    }
+
+    @Test
+    public void getAvailabilityStatus_unthetheredHeadset_returnAvailable() {
+        when(mBluetoothDevice.getMetadata(BluetoothDevice.METADATA_IS_UNTHETHERED_HEADSET))
+                .thenReturn("true");
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(
+                BasePreferenceController.AVAILABLE);
+    }
+
+    @Test
+    public void getAvailabilityStatus_notUnthetheredHeadset_returnUnavailable() {
+        when(mBluetoothDevice.getMetadata(BluetoothDevice.METADATA_IS_UNTHETHERED_HEADSET))
+                .thenReturn("false");
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(
+                BasePreferenceController.CONDITIONALLY_UNAVAILABLE);
+    }
+
+    private void assertBatteryLevel(LinearLayout linearLayout, int batteryLevel) {
+        final TextView textView = linearLayout.findViewById(R.id.bt_battery_summary);
+        assertThat(textView.getText().toString()).isEqualTo(
+                com.android.settings.Utils.formatPercentage(batteryLevel));
+    }
+
+}

tests/robotests/src/com/android/settings/bluetooth/BluetoothDetailsHeaderControllerTest.java

@@ -50,7 +50,6 @@ import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
 
 @RunWith(RobolectricTestRunner.class)
-
 @Config(shadows = ShadowEntityHeaderController.class)
 public class BluetoothDetailsHeaderControllerTest extends BluetoothDetailsControllerTestBase {
 

tests/robotests/src/com/android/settings/bluetooth/UtilsTest.java

@@ -15,6 +15,8 @@
  */
 package com.android.settings.bluetooth;
 
+import static com.google.common.truth.Truth.assertThat;
+
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
@@ -22,6 +24,7 @@ import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import android.bluetooth.BluetoothDevice;
 import android.content.Context;
 
 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
@@ -40,23 +43,68 @@ import org.robolectric.RobolectricTestRunner;
 @RunWith(RobolectricTestRunner.class)
 public class UtilsTest {
 
+    private static final String STRING_METADATA = "string_metadata";
+    private static final String BOOL_METADATA = "true";
+    private static final String INT_METADATA = "25";
+
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
+    @Mock
+    private BluetoothDevice mBluetoothDevice;
 
     private MetricsFeatureProvider mMetricsFeatureProvider;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
+
         mMetricsFeatureProvider = FakeFeatureFactory.setupForTest().getMetricsFeatureProvider();
     }
 
     @Test
-    public void testShowConnectingError_shouldLogBluetoothConnectError() {
+    public void showConnectingError_shouldLogBluetoothConnectError() {
         when(mContext.getString(anyInt(), anyString())).thenReturn("testMessage");
         Utils.showConnectingError(mContext, "testName", mock(LocalBluetoothManager.class));
 
         verify(mMetricsFeatureProvider).visible(eq(mContext), anyInt(),
                 eq(MetricsEvent.ACTION_SETTINGS_BLUETOOTH_CONNECT_ERROR));
     }
+
+    @Test
+    public void getStringMetaData_hasMetaData_getCorrectMetaData() {
+        when(mBluetoothDevice.getMetadata(
+                BluetoothDevice.METADATA_UNTHETHERED_LEFT_ICON)).thenReturn(STRING_METADATA);
+
+        assertThat(Utils.getStringMetaData(mBluetoothDevice,
+                BluetoothDevice.METADATA_UNTHETHERED_LEFT_ICON)).isEqualTo(STRING_METADATA);
+    }
+
+    @Test
+    public void getIntMetaData_hasMetaData_getCorrectMetaData() {
+        when(mBluetoothDevice.getMetadata(
+            BluetoothDevice.METADATA_UNTHETHERED_LEFT_BATTERY)).thenReturn(INT_METADATA);
+
+        assertThat(Utils.getIntMetaData(mBluetoothDevice,
+            BluetoothDevice.METADATA_UNTHETHERED_LEFT_BATTERY))
+            .isEqualTo(Integer.parseInt(INT_METADATA));
+    }
+
+    @Test
+    public void getIntMetaData_invalidMetaData_getErrorCode() {
+        when(mBluetoothDevice.getMetadata(
+                BluetoothDevice.METADATA_UNTHETHERED_LEFT_BATTERY)).thenReturn(STRING_METADATA);
+
+        assertThat(Utils.getIntMetaData(mBluetoothDevice,
+                BluetoothDevice.METADATA_UNTHETHERED_LEFT_ICON)).isEqualTo(Utils.META_INT_ERROR);
+    }
+
+    @Test
+    public void getBooleanMetaData_hasMetaData_getCorrectMetaData() {
+        when(mBluetoothDevice.getMetadata(
+                BluetoothDevice.METADATA_IS_UNTHETHERED_HEADSET)).thenReturn(BOOL_METADATA);
+
+        assertThat(Utils.getBooleanMetaData(mBluetoothDevice,
+                BluetoothDevice.METADATA_IS_UNTHETHERED_HEADSET)).isEqualTo(true);
+    }
+
 }