Remove unused classes and tests.

Old usb pages have been replaced by UsbDetailsFragment
and UsbDefaultFragment. Old connected devices has
been replaced by new connected devices.

Bug: 70848054
Test: Passes
Change-Id: I538cbb88d4f878449a83da9a4a0381e74e840c6a
This commit is contained in:
Jerry Zhang
2018-02-23 14:43:58 -08:00
parent 247641c4b5
commit 40bd570352
18 changed files with 33 additions and 1244 deletions

View File

@@ -24,8 +24,6 @@ import com.android.settings.R;
import com.android.settings.bluetooth.BluetoothFilesPreferenceController;
import com.android.settings.bluetooth.BluetoothMasterSwitchPreferenceController;
import com.android.settings.bluetooth.BluetoothSwitchPreferenceController;
import com.android.settings.connecteddevice.usb.UsbBackend;
import com.android.settings.connecteddevice.usb.UsbModePreferenceController;
import com.android.settings.dashboard.DashboardFragment;
import com.android.settings.nfc.NfcPreferenceController;
import com.android.settings.print.PrintSettingPreferenceController;
@@ -75,8 +73,6 @@ public class AdvancedConnectedDeviceDashboardFragment extends DashboardFragment
final NfcPreferenceController nfcPreferenceController =
new NfcPreferenceController(context);
controllers.add(nfcPreferenceController);
controllers.add(new UsbModePreferenceController(
context, new UsbBackend(context), lifecycle));
final BluetoothSwitchPreferenceController bluetoothPreferenceController =
new BluetoothSwitchPreferenceController(context);
controllers.add(bluetoothPreferenceController);

View File

@@ -1,155 +0,0 @@
/*
* Copyright (C) 2016 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 android.app.Activity;
import android.content.Context;
import android.content.pm.PackageManager;
import android.provider.SearchIndexableResource;
import android.support.annotation.VisibleForTesting;
import com.android.internal.logging.nano.MetricsProto;
import com.android.settings.R;
import com.android.settings.bluetooth.BluetoothMasterSwitchPreferenceController;
import com.android.settings.bluetooth.Utils;
import com.android.settings.connecteddevice.usb.UsbBackend;
import com.android.settings.connecteddevice.usb.UsbModePreferenceController;
import com.android.settings.dashboard.DashboardFragment;
import com.android.settings.dashboard.SummaryLoader;
import com.android.settings.nfc.NfcPreferenceController;
import com.android.settings.search.BaseSearchIndexProvider;
import com.android.settingslib.core.AbstractPreferenceController;
import com.android.settingslib.core.lifecycle.Lifecycle;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* This is the previous {@link ConnectedDeviceDashboardFragment} in Android O, in Android P the
* main entry will be {@link ConnectedDeviceDashboardFragment}
*
* @deprecated
*/
@Deprecated
public class ConnectedDeviceDashboardFragmentOld extends DashboardFragment {
private static final String TAG = "ConnectedDeviceFrag2";
private UsbModePreferenceController mUsbPrefController;
@Override
public int getMetricsCategory() {
return MetricsProto.MetricsEvent.SETTINGS_CONNECTED_DEVICE_CATEGORY;
}
@Override
protected String getLogTag() {
return TAG;
}
@Override
public int getHelpResource() {
return R.string.help_url_connected_devices;
}
@Override
protected int getPreferenceScreenResId() {
return R.xml.connected_devices_old;
}
@Override
protected List<AbstractPreferenceController> createPreferenceControllers(Context context) {
final List<AbstractPreferenceController> controllers = new ArrayList<>();
final Lifecycle lifecycle = getLifecycle();
final NfcPreferenceController nfcPreferenceController =
new NfcPreferenceController(context);
lifecycle.addObserver(nfcPreferenceController);
controllers.add(nfcPreferenceController);
mUsbPrefController = new UsbModePreferenceController(context, new UsbBackend(context),
lifecycle);
controllers.add(mUsbPrefController);
final BluetoothMasterSwitchPreferenceController bluetoothPreferenceController =
new BluetoothMasterSwitchPreferenceController(
context, Utils.getLocalBtManager(context), this);
lifecycle.addObserver(bluetoothPreferenceController);
controllers.add(bluetoothPreferenceController);
return controllers;
}
@VisibleForTesting
static class SummaryProvider implements SummaryLoader.SummaryProvider {
private final Context mContext;
private final SummaryLoader mSummaryLoader;
private final NfcPreferenceController mNfcPreferenceController;
public SummaryProvider(Context context, SummaryLoader summaryLoader) {
mContext = context;
mSummaryLoader = summaryLoader;
mNfcPreferenceController = new NfcPreferenceController(context);
}
@Override
public void setListening(boolean listening) {
if (listening) {
if (mNfcPreferenceController.isAvailable()) {
mSummaryLoader.setSummary(this,
mContext.getString(R.string.connected_devices_dashboard_summary));
} else {
mSummaryLoader.setSummary(this, mContext.getString(
R.string.connected_devices_dashboard_no_nfc_summary));
}
}
}
}
public static final SummaryLoader.SummaryProviderFactory SUMMARY_PROVIDER_FACTORY
= new SummaryLoader.SummaryProviderFactory() {
@Override
public SummaryLoader.SummaryProvider createSummaryProvider(Activity activity,
SummaryLoader summaryLoader) {
return new SummaryProvider(activity, summaryLoader);
}
};
/**
* For Search.
*/
public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
new BaseSearchIndexProvider() {
@Override
public List<SearchIndexableResource> getXmlResourcesToIndex(
Context context, boolean enabled) {
final SearchIndexableResource sir = new SearchIndexableResource(context);
sir.xmlResId = R.xml.connected_devices_old;
return Arrays.asList(sir);
}
@Override
public List<String> getNonIndexableKeys(Context context) {
final List<String> keys = super.getNonIndexableKeys(context);
PackageManager pm = context.getPackageManager();
if (!pm.hasSystemFeature(PackageManager.FEATURE_NFC)) {
keys.add(NfcPreferenceController.KEY_TOGGLE_NFC);
keys.add(NfcPreferenceController.KEY_ANDROID_BEAM_SETTINGS);
}
keys.add(BluetoothMasterSwitchPreferenceController.KEY_TOGGLE_BLUETOOTH);
return keys;
}
};
}

View File

@@ -40,8 +40,7 @@ public class ConnectedUsbDeviceUpdater {
UsbConnectionBroadcastReceiver.UsbConnectionListener mUsbConnectionListener =
(connected, newMode) -> {
if (connected) {
mUsbPreference.setSummary(
UsbModePreferenceController.getSummary(mUsbBackend.getCurrentMode()));
mUsbPreference.setSummary(getSummary(mUsbBackend.getCurrentMode()));
mDevicePreferenceCallback.onDeviceAdded(mUsbPreference);
} else {
mDevicePreferenceCallback.onDeviceRemoved(mUsbPreference);
@@ -94,4 +93,31 @@ public class ConnectedUsbDeviceUpdater {
//TODO(b/70336520): Use an API to get data instead of sticky intent
mUsbReceiver.register();
}
public static int getSummary(int mode) {
switch (mode) {
case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_NONE:
return R.string.usb_summary_charging_only;
case UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_NONE:
return R.string.usb_summary_power_only;
case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_MTP:
return R.string.usb_summary_file_transfers;
case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_PTP:
return R.string.usb_summary_photo_transfers;
case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_MIDI:
return R.string.usb_summary_MIDI;
case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_TETHER:
return R.string.usb_summary_tether;
case UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_MTP:
return R.string.usb_summary_file_transfers_power;
case UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_PTP:
return R.string.usb_summary_photo_transfers_power;
case UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_MIDI:
return R.string.usb_summary_MIDI_power;
case UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_TETHER:
return R.string.usb_summary_tether_power;
default:
return R.string.usb_summary_charging_only;
}
}
}

View File

@@ -53,7 +53,7 @@ public class UsbDetailsHeaderController extends UsbDetailsController {
mHeaderController.setLabel(mContext.getString(R.string.usb_pref));
mHeaderController.setIcon(mContext.getDrawable(R.drawable.ic_usb));
mHeaderController.setSummary(
mContext.getString(UsbModePreferenceController.getSummary(newMode)));
mContext.getString(ConnectedUsbDeviceUpdater.getSummary(newMode)));
mHeaderController.done(mFragment.getActivity(), true /* rebindActions */);
}

View File

@@ -1,204 +0,0 @@
/*
* Copyright (C) 2015 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.usb;
import android.annotation.Nullable;
import android.app.Activity;
import android.app.ActivityManager;
import android.app.AlertDialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.drawable.Drawable;
import android.graphics.PorterDuff;
import android.hardware.usb.UsbManager;
import android.os.Bundle;
import android.os.UserHandle;
import android.os.UserManager;
import android.support.annotation.VisibleForTesting;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Checkable;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.android.settings.R;
import com.android.settingslib.RestrictedLockUtils;
import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;
/**
* UI for the USB chooser dialog.
*
*/
public class UsbModeChooserActivity extends Activity {
public static final int[] DEFAULT_MODES = {
UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_NONE,
UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_NONE,
UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_MTP,
UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_PTP,
UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_MIDI
};
private UsbBackend mBackend;
private AlertDialog mDialog;
private LayoutInflater mLayoutInflater;
private EnforcedAdmin mEnforcedAdmin;
private BroadcastReceiver mDisconnectedReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (UsbManager.ACTION_USB_STATE.equals(action)) {
boolean connected = intent.getBooleanExtra(UsbManager.USB_CONNECTED, false);
boolean hostConnected =
intent.getBooleanExtra(UsbManager.USB_HOST_CONNECTED, false);
if (!connected && !hostConnected) {
mDialog.dismiss();
}
}
}
};
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mLayoutInflater = LayoutInflater.from(this);
mDialog = new AlertDialog.Builder(this)
.setTitle(R.string.usb_use)
.setView(R.layout.usb_dialog_container)
.setOnDismissListener(new DialogInterface.OnDismissListener() {
@Override
public void onDismiss(DialogInterface dialog) {
finish();
}
})
.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
finish();
}
}).create();
mDialog.show();
LinearLayout container = (LinearLayout) mDialog.findViewById(R.id.container);
mEnforcedAdmin = RestrictedLockUtils.checkIfRestrictionEnforced(this,
UserManager.DISALLOW_USB_FILE_TRANSFER, UserHandle.myUserId());
mBackend = new UsbBackend(this);
int current = mBackend.getCurrentMode();
for (int i = 0; i < DEFAULT_MODES.length; i++) {
if (mBackend.isModeSupported(DEFAULT_MODES[i])
&& !mBackend.isModeDisallowedBySystem(DEFAULT_MODES[i])) {
inflateOption(DEFAULT_MODES[i], current == DEFAULT_MODES[i], container,
mBackend.isModeDisallowed(DEFAULT_MODES[i]));
}
}
}
@Override
public void onStart() {
super.onStart();
IntentFilter filter = new IntentFilter(UsbManager.ACTION_USB_STATE);
registerReceiver(mDisconnectedReceiver, filter);
}
@Override
protected void onStop() {
unregisterReceiver(mDisconnectedReceiver);
super.onStop();
}
private void inflateOption(final int mode, boolean selected, LinearLayout container,
final boolean disallowedByAdmin) {
View v = mLayoutInflater.inflate(R.layout.restricted_radio_with_summary, container, false);
TextView titleView = (TextView) v.findViewById(android.R.id.title);
titleView.setText(getTitle(mode));
TextView summaryView = (TextView) v.findViewById(android.R.id.summary);
updateSummary(summaryView, mode);
if (disallowedByAdmin) {
if (mEnforcedAdmin != null) {
setDisabledByAdmin(v, titleView, summaryView);
} else {
return;
}
}
v.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
if (disallowedByAdmin && mEnforcedAdmin != null) {
RestrictedLockUtils.sendShowAdminSupportDetailsIntent(
UsbModeChooserActivity.this, mEnforcedAdmin);
return;
}
if (!ActivityManager.isUserAMonkey()) {
mBackend.setMode(mode);
}
mDialog.dismiss();
finish();
}
});
((Checkable) v).setChecked(selected);
container.addView(v);
}
private void setDisabledByAdmin(View rootView, TextView titleView, TextView summaryView) {
if (mEnforcedAdmin != null) {
titleView.setEnabled(false);
summaryView.setEnabled(false);
rootView.findViewById(R.id.restricted_icon).setVisibility(View.VISIBLE);
Drawable[] compoundDrawables = titleView.getCompoundDrawablesRelative();
compoundDrawables[0 /* start */].mutate().setColorFilter(
getColor(R.color.disabled_text_color), PorterDuff.Mode.MULTIPLY);
}
}
@VisibleForTesting
static void updateSummary(TextView summaryView, int mode) {
if (mode == (UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_NONE)) {
summaryView.setText(R.string.usb_use_power_only_desc);
}
}
@VisibleForTesting
static int getTitle(int mode) {
switch (mode) {
case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_NONE:
return R.string.usb_use_charging_only;
case UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_NONE:
return R.string.usb_use_power_only;
case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_MTP:
return R.string.usb_use_file_transfers;
case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_PTP:
return R.string.usb_use_photo_transfers;
case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_MIDI:
return R.string.usb_use_MIDI;
}
return 0;
}
}

View File

@@ -1,122 +0,0 @@
/*
* Copyright (C) 2016 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.usb;
import android.content.Context;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;
import com.android.internal.annotations.VisibleForTesting;
import com.android.settings.R;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settingslib.core.AbstractPreferenceController;
import com.android.settingslib.core.lifecycle.Lifecycle;
import com.android.settingslib.core.lifecycle.LifecycleObserver;
import com.android.settingslib.core.lifecycle.events.OnPause;
import com.android.settingslib.core.lifecycle.events.OnResume;
public class UsbModePreferenceController extends AbstractPreferenceController
implements PreferenceControllerMixin, LifecycleObserver, OnResume, OnPause {
private static final String KEY_USB_MODE = "usb_mode";
private UsbBackend mUsbBackend;
@VisibleForTesting
UsbConnectionBroadcastReceiver mUsbReceiver;
private Preference mUsbPreference;
public UsbModePreferenceController(Context context, UsbBackend usbBackend,
Lifecycle lifecycle) {
super(context);
mUsbBackend = usbBackend;
mUsbReceiver = new UsbConnectionBroadcastReceiver(mContext, (connected, newMode) -> {
updateSummary(mUsbPreference, connected, newMode);
}, mUsbBackend);
if (lifecycle != null) {
lifecycle.addObserver(this);
}
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
mUsbPreference = screen.findPreference(KEY_USB_MODE);
}
@Override
public void updateState(Preference preference) {
updateSummary(preference, mUsbReceiver.isConnected(), mUsbBackend.getCurrentMode());
}
@Override
public boolean isAvailable() {
return true;
}
@Override
public String getPreferenceKey() {
return KEY_USB_MODE;
}
@Override
public void onPause() {
mUsbReceiver.unregister();
}
@Override
public void onResume() {
mUsbReceiver.register();
}
public static int getSummary(int mode) {
switch (mode) {
case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_NONE:
return R.string.usb_summary_charging_only;
case UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_NONE:
return R.string.usb_summary_power_only;
case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_MTP:
return R.string.usb_summary_file_transfers;
case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_PTP:
return R.string.usb_summary_photo_transfers;
case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_MIDI:
return R.string.usb_summary_MIDI;
case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_TETHER:
return R.string.usb_summary_tether;
case UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_MTP:
return R.string.usb_summary_file_transfers_power;
case UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_PTP:
return R.string.usb_summary_photo_transfers_power;
case UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_MIDI:
return R.string.usb_summary_MIDI_power;
case UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_TETHER:
return R.string.usb_summary_tether_power;
default:
return R.string.usb_summary_charging_only;
}
}
private void updateSummary(Preference preference, boolean connected, int mode) {
if (preference != null) {
if (connected) {
preference.setEnabled(true);
preference.setSummary(getSummary(mode));
} else {
preference.setSummary(R.string.disconnected);
preference.setEnabled(false);
}
}
}
}