summaryrefslogtreecommitdiffstats
path: root/src/com/android/settings
diff options
context:
space:
mode:
Diffstat (limited to 'src/com/android/settings')
-rw-r--r--src/com/android/settings/ChooseLockPassword.java63
-rw-r--r--src/com/android/settings/ChooseLockPattern.java58
-rw-r--r--src/com/android/settings/DisplaySettings.java31
-rw-r--r--src/com/android/settings/deviceinfo/UsbBackend.java154
-rw-r--r--src/com/android/settings/deviceinfo/UsbModeChooserActivity.java144
5 files changed, 341 insertions, 109 deletions
diff --git a/src/com/android/settings/ChooseLockPassword.java b/src/com/android/settings/ChooseLockPassword.java
index 64aaaca..cb924cb 100644
--- a/src/com/android/settings/ChooseLockPassword.java
+++ b/src/com/android/settings/ChooseLockPassword.java
@@ -128,6 +128,7 @@ public class ChooseLockPassword extends SettingsActivity {
private static final String KEY_CURRENT_PASSWORD = "current_password";
private String mCurrentPassword;
+ private String mChosenPassword;
private boolean mHasChallenge;
private long mChallenge;
private TextView mPasswordEntry;
@@ -145,7 +146,6 @@ public class ChooseLockPassword extends SettingsActivity {
private int mRequestedQuality = DevicePolicyManager.PASSWORD_QUALITY_NUMERIC;
private ChooseLockSettingsHelper mChooseLockSettingsHelper;
private Stage mUiStage = Stage.Introduction;
- private boolean mDone = false;
private TextView mHeaderText;
private String mFirstPin;
private KeyboardView mKeyboardView;
@@ -302,7 +302,6 @@ public class ChooseLockPassword extends SettingsActivity {
mCurrentPassword = savedInstanceState.getString(KEY_CURRENT_PASSWORD);
}
}
- mDone = false;
if (activity instanceof SettingsActivity) {
final SettingsActivity sa = (SettingsActivity) activity;
int id = mIsAlphaMode ? R.string.lockpassword_choose_your_password_header
@@ -478,37 +477,54 @@ public class ChooseLockPassword extends SettingsActivity {
return null;
}
- public void handleNext() {
- if (mDone) return;
+ private class SaveChosenPasswordAndFinish extends AsyncTask<Void, Void, Void> {
+ boolean mWasSecureBefore;
+
+ @Override
+ public void onPreExecute() {
+ mWasSecureBefore = mLockPatternUtils.isSecure(UserHandle.myUserId());
+ final boolean required = getActivity().getIntent().getBooleanExtra(
+ EncryptionInterstitial.EXTRA_REQUIRE_PASSWORD, true);
+ mLockPatternUtils.setCredentialRequiredToDecrypt(required);
+ }
+
+ @Override
+ public Void doInBackground(Void... v) {
+ mLockPatternUtils.saveLockPassword(mChosenPassword, mCurrentPassword, mRequestedQuality,
+ UserHandle.myUserId());
+ return null;
+ }
- final String pin = mPasswordEntry.getText().toString();
- if (TextUtils.isEmpty(pin)) {
+ @Override
+ public void onPostExecute(Void v) {
+ if (mHasChallenge) {
+ startVerifyPassword(mChosenPassword, mWasSecureBefore);
+ return;
+ } else {
+ getActivity().setResult(RESULT_FINISHED);
+ }
+ finishConfirmStage(mWasSecureBefore);
+ }
+ }
+
+
+ public void handleNext() {
+ mChosenPassword = mPasswordEntry.getText().toString();
+ if (TextUtils.isEmpty(mChosenPassword)) {
return;
}
String errorMsg = null;
if (mUiStage == Stage.Introduction) {
- errorMsg = validatePassword(pin);
+ errorMsg = validatePassword(mChosenPassword);
if (errorMsg == null) {
- mFirstPin = pin;
+ mFirstPin = mChosenPassword;
mPasswordEntry.setText("");
updateStage(Stage.NeedToConfirm);
}
} else if (mUiStage == Stage.NeedToConfirm) {
- if (mFirstPin.equals(pin)) {
- boolean wasSecureBefore = mLockPatternUtils.isSecure(UserHandle.myUserId());
- final boolean required = getActivity().getIntent().getBooleanExtra(
- EncryptionInterstitial.EXTRA_REQUIRE_PASSWORD, true);
- mLockPatternUtils.setCredentialRequiredToDecrypt(required);
- mLockPatternUtils.saveLockPassword(pin, mCurrentPassword, mRequestedQuality,
- UserHandle.myUserId());
-
- if (mHasChallenge) {
- startVerifyPassword(pin, wasSecureBefore);
- return;
- } else {
- getActivity().setResult(RESULT_FINISHED);
- }
- finishConfirmStage(wasSecureBefore);
+ if (mFirstPin.equals(mChosenPassword)) {
+ setNextEnabled(false);
+ new SaveChosenPasswordAndFinish().execute();
} else {
CharSequence tmp = mPasswordEntry.getText();
if (tmp != null) {
@@ -557,7 +573,6 @@ public class ChooseLockPassword extends SettingsActivity {
private void finishConfirmStage(boolean wasSecureBefore) {
getActivity().finish();
- mDone = true;
if (!wasSecureBefore) {
Intent intent = getRedactionInterstitialIntent(getActivity());
if (intent != null) {
diff --git a/src/com/android/settings/ChooseLockPattern.java b/src/com/android/settings/ChooseLockPattern.java
index 087a23e..026fd46 100644
--- a/src/com/android/settings/ChooseLockPattern.java
+++ b/src/com/android/settings/ChooseLockPattern.java
@@ -346,7 +346,6 @@ public class ChooseLockPattern extends SettingsActivity {
}
private Stage mUiStage = Stage.Introduction;
- private boolean mDone = false;
private Runnable mClearPatternRunnable = new Runnable() {
public void run() {
@@ -435,7 +434,6 @@ public class ChooseLockPattern extends SettingsActivity {
}
updateStage(Stage.values()[savedInstanceState.getInt(KEY_UI_STAGE)]);
}
- mDone = false;
}
@Override
@@ -483,7 +481,7 @@ public class ChooseLockPattern extends SettingsActivity {
throw new IllegalStateException("expected ui stage " + Stage.ChoiceConfirmed
+ " when button is " + RightButtonMode.Confirm);
}
- saveChosenPatternAndFinish();
+ new SaveChosenPatternAndFinish().execute();
} else if (mUiStage.rightMode == RightButtonMode.Ok) {
if (mUiStage != Stage.HelpScreen) {
throw new IllegalStateException("Help screen is only mode with ok button, "
@@ -623,34 +621,49 @@ public class ChooseLockPattern extends SettingsActivity {
mLockPatternView.postDelayed(mClearPatternRunnable, WRONG_PATTERN_CLEAR_TIMEOUT_MS);
}
- private void saveChosenPatternAndFinish() {
- if (mDone) return;
- LockPatternUtils utils = mChooseLockSettingsHelper.utils();
- final boolean lockVirgin = !utils.isPatternEverChosen(UserHandle.myUserId());
+ private class SaveChosenPatternAndFinish extends AsyncTask<Void,Void,Void> {
+ boolean mLockVirgin;
+ LockPatternUtils mUtils;
+ boolean mWasSecureBefore;
- boolean wasSecureBefore = utils.isSecure(UserHandle.myUserId());
+ @Override
+ protected void onPreExecute(){
+ setRightButtonEnabled(false);
+ mUtils = mChooseLockSettingsHelper.utils();
+ mLockVirgin = !mUtils.isPatternEverChosen(UserHandle.myUserId());
- final boolean required = getActivity().getIntent().getBooleanExtra(
+ mWasSecureBefore = mUtils.isSecure(UserHandle.myUserId());
+
+ final boolean required = getActivity().getIntent().getBooleanExtra(
EncryptionInterstitial.EXTRA_REQUIRE_PASSWORD, true);
- utils.setCredentialRequiredToDecrypt(required);
- utils.saveLockPattern(mChosenPattern, mCurrentPattern, UserHandle.myUserId());
+ mUtils.setCredentialRequiredToDecrypt(required);
+ }
- if (lockVirgin) {
- utils.setVisiblePatternEnabled(true, UserHandle.myUserId());
+ @Override
+ protected Void doInBackground(Void... params){
+ mUtils.saveLockPattern(mChosenPattern, mCurrentPattern, UserHandle.myUserId());
+ return null;
}
- if (mHasChallenge) {
- startVerifyPattern(utils, wasSecureBefore);
- } else {
- if (!wasSecureBefore) {
- Intent intent = getRedactionInterstitialIntent(getActivity());
- if (intent != null) {
- startActivity(intent);
+ @Override
+ protected void onPostExecute(Void param) {
+ if (mLockVirgin) {
+ mUtils.setVisiblePatternEnabled(true, UserHandle.myUserId());
+ }
+
+ if (mHasChallenge) {
+ startVerifyPattern(mUtils, mWasSecureBefore);
+ } else {
+ if (!mWasSecureBefore) {
+ Intent intent = getRedactionInterstitialIntent(getActivity());
+ if (intent != null) {
+ startActivity(intent);
+ }
}
+ getActivity().setResult(RESULT_FINISHED);
+ doFinish();
}
- getActivity().setResult(RESULT_FINISHED);
- doFinish();
}
}
@@ -693,7 +706,6 @@ public class ChooseLockPattern extends SettingsActivity {
private void doFinish() {
getActivity().finish();
- mDone = true;
}
}
}
diff --git a/src/com/android/settings/DisplaySettings.java b/src/com/android/settings/DisplaySettings.java
index eef3c6b..d2daac8 100644
--- a/src/com/android/settings/DisplaySettings.java
+++ b/src/com/android/settings/DisplaySettings.java
@@ -22,6 +22,7 @@ import com.android.settings.DropDownPreference.Callback;
import com.android.settings.search.BaseSearchIndexProvider;
import com.android.settings.search.Indexable;
+import static android.provider.Settings.Secure.CAMERA_GESTURE_DISABLED;
import static android.provider.Settings.Secure.DOUBLE_TAP_TO_WAKE;
import static android.provider.Settings.Secure.DOZE_ENABLED;
import static android.provider.Settings.Secure.WAKE_GESTURE_ENABLED;
@@ -74,6 +75,7 @@ public class DisplaySettings extends SettingsPreferenceFragment implements
private static final String KEY_AUTO_BRIGHTNESS = "auto_brightness";
private static final String KEY_AUTO_ROTATE = "auto_rotate";
private static final String KEY_NIGHT_MODE = "night_mode";
+ private static final String KEY_CAMERA_GESTURE = "camera_gesture";
private static final int DLG_GLOBAL_CHANGE_WARNING = 1;
@@ -88,6 +90,7 @@ public class DisplaySettings extends SettingsPreferenceFragment implements
private SwitchPreference mDozePreference;
private SwitchPreference mTapToWakePreference;
private SwitchPreference mAutoBrightnessPreference;
+ private SwitchPreference mCameraGesturePreference;
@Override
protected int getMetricsCategory() {
@@ -149,6 +152,13 @@ public class DisplaySettings extends SettingsPreferenceFragment implements
removePreference(KEY_TAP_TO_WAKE);
}
+ if (isCameraGestureAvailable(getResources())) {
+ mCameraGesturePreference = (SwitchPreference) findPreference(KEY_CAMERA_GESTURE);
+ mCameraGesturePreference.setOnPreferenceChangeListener(this);
+ } else {
+ removePreference(KEY_CAMERA_GESTURE);
+ }
+
if (RotationPolicy.isRotationLockToggleVisible(activity)) {
DropDownPreference rotatePreference =
(DropDownPreference) findPreference(KEY_AUTO_ROTATE);
@@ -224,6 +234,13 @@ public class DisplaySettings extends SettingsPreferenceFragment implements
return res.getBoolean(com.android.internal.R.bool.config_automatic_brightness_available);
}
+ private static boolean isCameraGestureAvailable(Resources res) {
+ boolean configSet = res.getInteger(
+ com.android.internal.R.integer.config_cameraLaunchGestureSensorType) != -1;
+ return configSet &&
+ !SystemProperties.getBoolean("gesture.disable_camera_launch", false);
+ }
+
private void updateTimeoutPreferenceDescription(long currentTimeout) {
ListPreference preference = mScreenTimeoutPreference;
String summary;
@@ -370,6 +387,12 @@ public class DisplaySettings extends SettingsPreferenceFragment implements
int value = Settings.Secure.getInt(getContentResolver(), DOUBLE_TAP_TO_WAKE, 0);
mTapToWakePreference.setChecked(value != 0);
}
+
+ // Update camera gesture if it is available.
+ if (mCameraGesturePreference != null) {
+ int value = Settings.Secure.getInt(getContentResolver(), CAMERA_GESTURE_DISABLED, 0);
+ mCameraGesturePreference.setChecked(value == 0);
+ }
}
private void updateScreenSaverSummary() {
@@ -425,6 +448,11 @@ public class DisplaySettings extends SettingsPreferenceFragment implements
boolean value = (Boolean) objValue;
Settings.Secure.putInt(getContentResolver(), DOUBLE_TAP_TO_WAKE, value ? 1 : 0);
}
+ if (preference == mCameraGesturePreference) {
+ boolean value = (Boolean) objValue;
+ Settings.Secure.putInt(getContentResolver(), CAMERA_GESTURE_DISABLED,
+ value ? 0 : 1 /* Backwards because setting is for disabling */);
+ }
if (preference == mNightModePreference) {
try {
final int value = Integer.parseInt((String) objValue);
@@ -493,6 +521,9 @@ public class DisplaySettings extends SettingsPreferenceFragment implements
if (!isTapToWakeAvailable(context.getResources())) {
result.add(KEY_TAP_TO_WAKE);
}
+ if (!isCameraGestureAvailable(context.getResources())) {
+ result.add(KEY_CAMERA_GESTURE);
+ }
return result;
}
};
diff --git a/src/com/android/settings/deviceinfo/UsbBackend.java b/src/com/android/settings/deviceinfo/UsbBackend.java
new file mode 100644
index 0000000..c44f2eb
--- /dev/null
+++ b/src/com/android/settings/deviceinfo/UsbBackend.java
@@ -0,0 +1,154 @@
+/*
+ * 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 | (mPortStatus.getCurrentDataRole() == UsbPort.DATA_ROLE_DEVICE
+ ? getUsbDataMode() : MODE_DATA_NONE);
+ }
+ 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_MTP;
+ } 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;
}
}
generated by cgit v1.1 at 2024-08-02 08:15:54 +0000