android:title="@string/bluetooth_device_advanced_title">
<com.android.settings.applications.LayoutPreference
+ android:key="bluetooth_device_header"
+ android:layout="@layout/settings_entity_header"
+ android:selectable="false"/>
+
+ <com.android.settings.applications.LayoutPreference
android:key="action_buttons"
android:layout="@layout/app_action_buttons"
android:selectable="false"/>
import android.support.v7.preference.PreferenceScreen;
import android.util.Pair;
+import com.android.settings.R;
import com.android.settings.applications.LayoutPreference;
import com.android.settings.widget.EntityHeaderController;
import com.android.settingslib.bluetooth.CachedBluetoothDevice;
* This class adds a header with device name and status (connected/disconnected, etc.).
*/
public class BluetoothDetailsHeaderController extends BluetoothDetailsController {
+ private static final String KEY_DEVICE_HEADER = "bluetooth_device_header";
private EntityHeaderController mHeaderController;
@Override
protected void init(PreferenceScreen screen) {
+ final LayoutPreference headerPreference =
+ (LayoutPreference) screen.findPreference(KEY_DEVICE_HEADER);
mHeaderController = EntityHeaderController.newInstance(mFragment.getActivity(), mFragment,
- null);
- LayoutPreference pref = mHeaderController.done(mFragment.getActivity(), mContext);
- screen.addPreference(pref);
+ headerPreference.findViewById(R.id.entity_header));
+ screen.addPreference(headerPreference);
}
protected void setHeaderProperties() {
@Override
public String getPreferenceKey() {
- return EntityHeaderController.PREF_KEY_APP_HEADER;
+ return KEY_DEVICE_HEADER;
}
}
protected void init(PreferenceScreen screen) {
mFooterPreference = mFooterPreferenceMixin.createFooterPreference();
mFooterPreference.setTitle(mContext.getString(
- R.string.bluetooth_device_mac_address, mCachedDevice.getDevice().getAddress()));
+ R.string.bluetooth_device_mac_address, mCachedDevice.getAddress()));
}
@Override
@VisibleForTesting
static int EDIT_DEVICE_NAME_ITEM_ID = Menu.FIRST;
+ /**
+ * An interface to let tests override the normal mechanism for looking up the
+ * CachedBluetoothDevice and LocalBluetoothManager, and substitute their own mocks instead.
+ * This is only needed in situations where you instantiate the fragment indirectly (eg via an
+ * intent) and can't use something like spying on an instance you construct directly via
+ * newInstance.
+ */
+ @VisibleForTesting
+ interface TestDataFactory {
+ CachedBluetoothDevice getDevice(String deviceAddress);
+ LocalBluetoothManager getManager(Context context);
+ }
+
+ @VisibleForTesting
+ static TestDataFactory sTestDataFactory;
+
private String mDeviceAddress;
private LocalBluetoothManager mManager;
private CachedBluetoothDevice mCachedDevice;
@VisibleForTesting
LocalBluetoothManager getLocalBluetoothManager(Context context) {
+ if (sTestDataFactory != null) {
+ return sTestDataFactory.getManager(context);
+ }
return Utils.getLocalBtManager(context);
}
@VisibleForTesting
CachedBluetoothDevice getCachedDevice(String deviceAddress) {
+ if (sTestDataFactory != null) {
+ return sTestDataFactory.getDevice(deviceAddress);
+ }
BluetoothDevice remoteDevice =
mManager.getBluetoothAdapter().getRemoteDevice(deviceAddress);
return mManager.getCachedDeviceManager().findDevice(remoteDevice);
--- /dev/null
+/*
+ * 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.bluetooth;
+
+import static org.mockito.Mockito.when;
+
+import android.app.Instrumentation;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.filters.SmallTest;
+import android.support.test.runner.AndroidJUnit4;
+import android.support.test.uiautomator.UiDevice;
+
+import com.android.settings.SettingsActivity;
+import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.bluetooth.LocalBluetoothManager;
+
+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;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class BluetoothDeviceDetailsRotationTest {
+ private Context mContext;
+ private UiDevice mUiDevice;
+ private Instrumentation mInstrumentation;
+
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+ private CachedBluetoothDevice mCachedDevice;
+
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+ private LocalBluetoothManager mBluetoothManager;
+
+ private String mDeviceAddress;
+
+ @Before
+ public void setUp() throws Exception {
+ MockitoAnnotations.initMocks(this);
+ mContext = InstrumentationRegistry.getTargetContext();
+ mUiDevice = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
+ mInstrumentation = InstrumentationRegistry.getInstrumentation();
+
+ mDeviceAddress = "AA:BB:CC:DD:EE:FF";
+ when(mCachedDevice.getAddress()).thenReturn(mDeviceAddress);
+ when(mCachedDevice.getName()).thenReturn("Mock Device");
+
+ BluetoothDeviceDetailsFragment.sTestDataFactory =
+ new BluetoothDeviceDetailsFragment.TestDataFactory() {
+ @Override
+ public CachedBluetoothDevice getDevice(String deviceAddress) {
+ return mCachedDevice;
+ }
+
+ @Override
+ public LocalBluetoothManager getManager(Context context) {
+ return mBluetoothManager;
+ }
+ };
+ }
+
+ @Test
+ public void rotation() {
+ Intent intent = new Intent("android.settings.BLUETOOTH_SETTINGS");
+ SettingsActivity activity = (SettingsActivity) mInstrumentation.startActivitySync(intent);
+ Bundle args = new Bundle(1);
+ args.putString(BluetoothDeviceDetailsFragment.KEY_DEVICE_ADDRESS, mDeviceAddress);
+ activity.startPreferencePanel(null, BluetoothDeviceDetailsFragment.class.getName(), args,
+ 0, null, null, 0);
+ try {
+ mUiDevice.setOrientationLeft();
+ mUiDevice.setOrientationNatural();
+ mUiDevice.setOrientationRight();
+ mUiDevice.setOrientationNatural();
+ } catch (RemoteException e) {
+ throw new RuntimeException(e);
+ }
+ }
+}
when(mCachedDevice.isConnected()).thenReturn(config.isConnected());
when(mCachedDevice.getConnectionSummary()).thenReturn(config.getConnectionSummary());
- mDevice = mBluetoothAdapter.getRemoteDevice(mDeviceConfig.getAddress());
+ mDevice = mBluetoothAdapter.getRemoteDevice(config.getAddress());
when(mCachedDevice.getDevice()).thenReturn(mDevice);
+ when(mCachedDevice.getAddress()).thenReturn(config.getAddress());
}
/**
import android.graphics.drawable.Drawable;
import android.support.v7.preference.Preference;
+import com.android.settings.R;
+import com.android.settings.applications.LayoutPreference;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.shadow.SettingsShadowBluetoothDevice;
import com.android.settings.testutils.shadow.ShadowEntityHeaderController;
import com.android.settings.widget.EntityHeaderController;
-import com.android.settingslib.R;
import com.android.settingslib.bluetooth.LocalBluetoothProfile;
import org.junit.After;
shadows={SettingsShadowBluetoothDevice.class, ShadowEntityHeaderController.class})
public class BluetoothDetailsHeaderControllerTest extends BluetoothDetailsControllerTestBase {
private BluetoothDetailsHeaderController mController;
- private Preference mPreference;
+ private LayoutPreference mPreference;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private EntityHeaderController mHeaderController;
ShadowEntityHeaderController.setUseMock(mHeaderController);
mController = new BluetoothDetailsHeaderController(mContext, mFragment, mCachedDevice,
mLifecycle);
- mPreference = new Preference(mContext);
+ mPreference = new LayoutPreference(mContext, R.layout.settings_entity_header);
mPreference.setKey(mController.getPreferenceKey());
mScreen.addPreference(mPreference);
setupDevice(mDeviceConfig);
verify(mHeaderController).setIcon(any(Drawable.class));
verify(mHeaderController).setIconContentDescription(any(String.class));
verify(mHeaderController).setSummary(any(String.class));
- verify(mHeaderController).done(mActivity, mContext);
verify(mHeaderController).done(mActivity, false);
}
doReturn(mLocalManager).when(mFragment).getLocalBluetoothManager(any());
doReturn(mCachedDevice).when(mFragment).getCachedDevice(any());
- when(mCachedDevice.getDevice().getAddress()).thenReturn(deviceAddress);
+ when(mCachedDevice.getAddress()).thenReturn(deviceAddress);
Bundle args = new Bundle();
args.putString(BluetoothDeviceDetailsFragment.KEY_DEVICE_ADDRESS, deviceAddress);
mFragment.setArguments(args);
FakeFeatureFactory.setupForTest(mContext);
String deviceAddress = "55:66:77:88:99:AA";
- when(mCachedDevice.getDevice().getAddress()).thenReturn(deviceAddress);
+ when(mCachedDevice.getAddress()).thenReturn(deviceAddress);
mFragment = spy(RemoteDeviceNameDialogFragment.newInstance(mCachedDevice));
doReturn(mCachedDevice).when(mFragment).getDevice(any());
}