diff options
author | Ricardo Cerqueira <ricardo@cyngn.com> | 2015-11-05 02:00:43 +0000 |
---|---|---|
committer | Ricardo Cerqueira <ricardo@cyngn.com> | 2015-11-05 15:44:26 +0000 |
commit | 90852d4675c9b7df6faf036efb7fe73b5f816293 (patch) | |
tree | 18ea2755ab5ea68669a7951d5a07daadc4870b0a /src/com/android/settings/deviceinfo | |
parent | 3dbac3fff036f5a464f6322200c59f9934ebf610 (diff) | |
parent | 310423e73156dab1c7c8f50dc67fdbc326cd37f7 (diff) | |
download | packages_apps_Settings-90852d4675c9b7df6faf036efb7fe73b5f816293.zip packages_apps_Settings-90852d4675c9b7df6faf036efb7fe73b5f816293.tar.gz packages_apps_Settings-90852d4675c9b7df6faf036efb7fe73b5f816293.tar.bz2 |
Merge tag 'android-6.0.0_r26' into HEAD
Android 6.0.0 release 26
Conflicts:
res/values-fr/strings.xml
res/values-it/strings.xml
res/values-ja/strings.xml
res/values-nl/strings.xml
res/values-pl/strings.xml
res/values-ro/strings.xml
res/values-ru/strings.xml
res/values-zh-rCN/strings.xml
res/values/bools.xml
res/values/strings.xml
res/xml/development_prefs.xml
src/com/android/settings/DevelopmentSettings.java
src/com/android/settings/DeviceInfoSettings.java
src/com/android/settings/DisplaySettings.java
Change-Id: I9fd9e793cf6097d950f8a1e30771c8bdf5067906
Diffstat (limited to 'src/com/android/settings/deviceinfo')
-rw-r--r-- | src/com/android/settings/deviceinfo/UsbBackend.java | 153 | ||||
-rw-r--r-- | src/com/android/settings/deviceinfo/UsbModeChooserActivity.java | 144 |
2 files changed, 235 insertions, 62 deletions
diff --git a/src/com/android/settings/deviceinfo/UsbBackend.java b/src/com/android/settings/deviceinfo/UsbBackend.java new file mode 100644 index 0000000..210e0a0 --- /dev/null +++ b/src/com/android/settings/deviceinfo/UsbBackend.java @@ -0,0 +1,153 @@ +/* + * 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.deviceinfo; + +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.hardware.usb.UsbManager; +import android.hardware.usb.UsbPort; +import android.hardware.usb.UsbPortStatus; +import android.os.UserManager; + +public class UsbBackend { + + private static final int MODE_POWER_MASK = 0x01; + public static final int MODE_POWER_SINK = 0x00; + public static final int MODE_POWER_SOURCE = 0x01; + + private static final int MODE_DATA_MASK = 0x03 << 1; + public static final int MODE_DATA_NONE = 0x00 << 1; + public static final int MODE_DATA_MTP = 0x01 << 1; + public static final int MODE_DATA_PTP = 0x02 << 1; + public static final int MODE_DATA_MIDI = 0x03 << 1; + + private final boolean mRestricted; + + private UserManager mUserManager; + private UsbManager mUsbManager; + private UsbPort mPort; + private UsbPortStatus mPortStatus; + + private boolean mIsUnlocked; + + public UsbBackend(Context context) { + Intent intent = context.registerReceiver(null, + new IntentFilter(UsbManager.ACTION_USB_STATE)); + mIsUnlocked = intent.getBooleanExtra(UsbManager.USB_DATA_UNLOCKED, false); + + mUserManager = UserManager.get(context); + mUsbManager = context.getSystemService(UsbManager.class); + + mRestricted = mUserManager.hasUserRestriction(UserManager.DISALLOW_USB_FILE_TRANSFER); + UsbPort[] ports = mUsbManager.getPorts(); + // For now look for a connected port, in the future we should identify port in the + // notification and pick based on that. + final int N = ports.length; + for (int i = 0; i < N; i++) { + UsbPortStatus status = mUsbManager.getPortStatus(ports[i]); + if (status.isConnected()) { + mPort = ports[i]; + mPortStatus = status; + break; + } + } + } + + public int getCurrentMode() { + if (mPort != null) { + int power = mPortStatus.getCurrentPowerRole() == UsbPort.POWER_ROLE_SOURCE + ? MODE_POWER_SOURCE : MODE_POWER_SINK; + return power | getUsbDataMode(); + } + return MODE_POWER_SINK | getUsbDataMode(); + } + + public int getUsbDataMode() { + if (!mIsUnlocked) { + return MODE_DATA_NONE; + } else if (mUsbManager.isFunctionEnabled(UsbManager.USB_FUNCTION_MTP)) { + return MODE_DATA_MTP; + } else if (mUsbManager.isFunctionEnabled(UsbManager.USB_FUNCTION_PTP)) { + return MODE_DATA_PTP; + } else if (mUsbManager.isFunctionEnabled(UsbManager.USB_FUNCTION_MIDI)) { + return MODE_DATA_MIDI; + } + return MODE_DATA_NONE; // ... + } + + private void setUsbFunction(int mode) { + switch (mode) { + case MODE_DATA_MTP: + mUsbManager.setCurrentFunction(UsbManager.USB_FUNCTION_MTP); + mUsbManager.setUsbDataUnlocked(true); + break; + case MODE_DATA_PTP: + mUsbManager.setCurrentFunction(UsbManager.USB_FUNCTION_PTP); + mUsbManager.setUsbDataUnlocked(true); + break; + case MODE_DATA_MIDI: + mUsbManager.setCurrentFunction(UsbManager.USB_FUNCTION_MIDI); + mUsbManager.setUsbDataUnlocked(true); + break; + default: + mUsbManager.setCurrentFunction(null); + mUsbManager.setUsbDataUnlocked(false); + break; + } + } + + public void setMode(int mode) { + if (mPort != null) { + int powerRole = modeToPower(mode); + // If we aren't using any data modes and we support host mode, then go to host mode + // so maybe? the other device can provide data if it wants, otherwise go into device + // mode because we have no choice. + int dataRole = (mode & MODE_DATA_MASK) == MODE_DATA_NONE + && mPortStatus.isRoleCombinationSupported(powerRole, UsbPort.DATA_ROLE_HOST) + ? UsbPort.DATA_ROLE_HOST : UsbPort.DATA_ROLE_DEVICE; + mUsbManager.setPortRoles(mPort, powerRole, dataRole); + } + setUsbFunction(mode & MODE_DATA_MASK); + } + + private int modeToPower(int mode) { + return (mode & MODE_POWER_MASK) == MODE_POWER_SOURCE + ? UsbPort.POWER_ROLE_SOURCE : UsbPort.POWER_ROLE_SINK; + } + + public boolean isModeSupported(int mode) { + if (mRestricted && (mode & MODE_DATA_MASK) != MODE_DATA_NONE + && (mode & MODE_DATA_MASK) != MODE_DATA_MIDI) { + // No USB data modes are supported. + return false; + } + if (mPort != null) { + int power = modeToPower(mode); + if ((mode & MODE_DATA_MASK) != 0) { + // We have a port and data, need to be in device mode. + return mPortStatus.isRoleCombinationSupported(power, + UsbPort.DATA_ROLE_DEVICE); + } else { + // No data needed, we can do this power mode in either device or host. + return mPortStatus.isRoleCombinationSupported(power, UsbPort.DATA_ROLE_DEVICE) + || mPortStatus.isRoleCombinationSupported(power, UsbPort.DATA_ROLE_HOST); + } + } + // No port, support sink modes only. + return (mode & MODE_POWER_MASK) != MODE_POWER_SOURCE; + } +}
\ No newline at end of file diff --git a/src/com/android/settings/deviceinfo/UsbModeChooserActivity.java b/src/com/android/settings/deviceinfo/UsbModeChooserActivity.java index 4bdabd5..77fc388 100644 --- a/src/com/android/settings/deviceinfo/UsbModeChooserActivity.java +++ b/src/com/android/settings/deviceinfo/UsbModeChooserActivity.java @@ -20,13 +20,14 @@ import android.annotation.Nullable; import android.app.Activity; import android.app.ActivityManager; import android.app.AlertDialog; -import android.content.Context; import android.content.DialogInterface; -import android.content.Intent; -import android.content.IntentFilter; -import android.hardware.usb.UsbManager; import android.os.Bundle; -import android.os.UserManager; +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; @@ -36,83 +37,102 @@ import com.android.settings.R; */ public class UsbModeChooserActivity extends Activity { - private UsbManager mUsbManager; - private String[] mFunctions; - private boolean mIsUnlocked; + 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; @Override protected void onCreate(@Nullable Bundle savedInstanceState) { - Intent i = getBaseContext().registerReceiver(null, new IntentFilter(UsbManager.ACTION_USB_STATE)); - mIsUnlocked = i.getBooleanExtra(UsbManager.USB_DATA_UNLOCKED, false); super.onCreate(savedInstanceState); - mUsbManager = (UsbManager) getSystemService(Context.USB_SERVICE); - boolean isFileTransferRestricted = ((UserManager) getSystemService(Context.USER_SERVICE)) - .hasUserRestriction(UserManager.DISALLOW_USB_FILE_TRANSFER); - CharSequence[] items; - if (isFileTransferRestricted) { - items = new CharSequence[] { getText(R.string.usb_use_charging_only), getText(R.string.usb_use_MIDI)}; - mFunctions = new String[] { null, UsbManager.USB_FUNCTION_MIDI }; - } else { - items = new CharSequence[] { - getText(R.string.usb_use_charging_only), getText(R.string.usb_use_file_transfers), - getText(R.string.usb_use_photo_transfers), getText(R.string.usb_use_MIDI)}; - mFunctions = new String[] { null, UsbManager.USB_FUNCTION_MTP, - UsbManager.USB_FUNCTION_PTP, UsbManager.USB_FUNCTION_MIDI }; - } - final AlertDialog levelDialog; - AlertDialog.Builder builder = new AlertDialog.Builder(this); - builder.setTitle(R.string.usb_use); + mLayoutInflater = LayoutInflater.from(this); - builder.setSingleChoiceItems(items, getCurrentFunction(), - new DialogInterface.OnClickListener() { + 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) { - if (!ActivityManager.isUserAMonkey()) { - setCurrentFunction(which); - } - dialog.dismiss(); - UsbModeChooserActivity.this.finish(); + finish(); } - }); - builder.setOnDismissListener(new DialogInterface.OnDismissListener() { - @Override - public void onDismiss(DialogInterface dialog) { - UsbModeChooserActivity.this.finish(); + }).create(); + mDialog.show(); + + LinearLayout container = (LinearLayout) mDialog.findViewById(R.id.container); + + mBackend = new UsbBackend(this); + int current = mBackend.getCurrentMode(); + for (int i = 0; i < DEFAULT_MODES.length; i++) { + if (mBackend.isModeSupported(DEFAULT_MODES[i])) { + inflateOption(DEFAULT_MODES[i], current == DEFAULT_MODES[i], container); } - }); - builder.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() { + } + } + + private void inflateOption(final int mode, boolean selected, LinearLayout container) { + View v = mLayoutInflater.inflate(R.layout.radio_with_summary, container, false); + + ((TextView) v.findViewById(android.R.id.title)).setText(getTitle(mode)); + ((TextView) v.findViewById(android.R.id.summary)).setText(getSummary(mode)); + + v.setOnClickListener(new OnClickListener() { @Override - public void onClick(DialogInterface dialog, int which) { - UsbModeChooserActivity.this.finish(); + public void onClick(View v) { + if (!ActivityManager.isUserAMonkey()) { + mBackend.setMode(mode); + } + mDialog.dismiss(); + finish(); } }); - levelDialog = builder.create(); - levelDialog.show(); + ((Checkable) v).setChecked(selected); + container.addView(v); } - private int getCurrentFunction() { - if (!mIsUnlocked) { - return 0; - } - - for (int i = 1; i < mFunctions.length; i++) { - if (mUsbManager.isFunctionEnabled(mFunctions[i])) { - return i; - } + private static int getSummary(int mode) { + switch (mode) { + case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_NONE: + return R.string.usb_use_charging_only_desc; + case UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_NONE: + return R.string.usb_use_power_only_desc; + case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_MTP: + return R.string.usb_use_file_transfers_desc; + case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_PTP: + return R.string.usb_use_photo_transfers_desc; + case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_MIDI: + return R.string.usb_use_MIDI_desc; } return 0; } - private void setCurrentFunction(int which) { - if (which == 0) { - mUsbManager.setCurrentFunction(null); - mUsbManager.setUsbDataUnlocked(false); - return; + private 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; } - - mUsbManager.setCurrentFunction(mFunctions[which]); - mUsbManager.setUsbDataUnlocked(true); + return 0; } } |