24a2863751
Bug: 294279890 Test: StylusDevicesControllerTest Change-Id: I8e83fb3a8bb76469c4bf1b99df5524930ebad086
343 lines
13 KiB
Java
343 lines
13 KiB
Java
/*
|
|
* Copyright (C) 2022 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.stylus;
|
|
|
|
import android.app.Dialog;
|
|
import android.app.role.RoleManager;
|
|
import android.bluetooth.BluetoothDevice;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.pm.ApplicationInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.pm.UserInfo;
|
|
import android.os.Process;
|
|
import android.os.UserHandle;
|
|
import android.os.UserManager;
|
|
import android.provider.Settings;
|
|
import android.provider.Settings.Secure;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
import android.view.InputDevice;
|
|
import android.view.inputmethod.InputMethodInfo;
|
|
import android.view.inputmethod.InputMethodManager;
|
|
|
|
import androidx.annotation.Nullable;
|
|
import androidx.annotation.VisibleForTesting;
|
|
import androidx.preference.Preference;
|
|
import androidx.preference.PreferenceCategory;
|
|
import androidx.preference.PreferenceScreen;
|
|
import androidx.preference.SwitchPreference;
|
|
|
|
import com.android.settings.R;
|
|
import com.android.settings.dashboard.profileselector.ProfileSelectDialog;
|
|
import com.android.settings.dashboard.profileselector.UserAdapter;
|
|
import com.android.settingslib.PrimarySwitchPreference;
|
|
import com.android.settingslib.bluetooth.BluetoothUtils;
|
|
import com.android.settingslib.bluetooth.CachedBluetoothDevice;
|
|
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.OnResume;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* This class adds stylus preferences.
|
|
*/
|
|
public class StylusDevicesController extends AbstractPreferenceController implements
|
|
Preference.OnPreferenceClickListener, Preference.OnPreferenceChangeListener,
|
|
LifecycleObserver, OnResume {
|
|
|
|
@VisibleForTesting
|
|
static final String KEY_STYLUS = "device_stylus";
|
|
@VisibleForTesting
|
|
static final String KEY_HANDWRITING = "handwriting_switch";
|
|
@VisibleForTesting
|
|
static final String KEY_IGNORE_BUTTON = "ignore_button";
|
|
@VisibleForTesting
|
|
static final String KEY_DEFAULT_NOTES = "default_notes";
|
|
|
|
private static final String TAG = "StylusDevicesController";
|
|
|
|
@Nullable
|
|
private final InputDevice mInputDevice;
|
|
|
|
@Nullable
|
|
private final CachedBluetoothDevice mCachedBluetoothDevice;
|
|
|
|
@VisibleForTesting
|
|
PreferenceCategory mPreferencesContainer;
|
|
|
|
@VisibleForTesting
|
|
Dialog mDialog;
|
|
|
|
public StylusDevicesController(Context context, InputDevice inputDevice,
|
|
CachedBluetoothDevice cachedBluetoothDevice, Lifecycle lifecycle) {
|
|
super(context);
|
|
mInputDevice = inputDevice;
|
|
mCachedBluetoothDevice = cachedBluetoothDevice;
|
|
lifecycle.addObserver(this);
|
|
}
|
|
|
|
@Override
|
|
public boolean isAvailable() {
|
|
return isDeviceStylus(mInputDevice, mCachedBluetoothDevice);
|
|
}
|
|
|
|
@Nullable
|
|
private Preference createOrUpdateDefaultNotesPreference(@Nullable Preference preference) {
|
|
RoleManager rm = mContext.getSystemService(RoleManager.class);
|
|
if (rm == null || !rm.isRoleAvailable(RoleManager.ROLE_NOTES)) {
|
|
return null;
|
|
}
|
|
|
|
Preference pref = preference == null ? new Preference(mContext) : preference;
|
|
pref.setKey(KEY_DEFAULT_NOTES);
|
|
pref.setTitle(mContext.getString(R.string.stylus_default_notes_app));
|
|
pref.setIcon(R.drawable.ic_article);
|
|
pref.setOnPreferenceClickListener(this);
|
|
pref.setEnabled(true);
|
|
|
|
UserHandle user = getDefaultNoteTaskProfile();
|
|
List<String> roleHolders = rm.getRoleHoldersAsUser(RoleManager.ROLE_NOTES, user);
|
|
if (roleHolders.isEmpty()) {
|
|
pref.setSummary(R.string.default_app_none);
|
|
return pref;
|
|
}
|
|
|
|
String packageName = roleHolders.get(0);
|
|
PackageManager pm = mContext.getPackageManager();
|
|
String appName = packageName;
|
|
try {
|
|
ApplicationInfo ai = pm.getApplicationInfo(packageName,
|
|
PackageManager.ApplicationInfoFlags.of(0));
|
|
appName = ai == null ? "" : pm.getApplicationLabel(ai).toString();
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
Log.e(TAG, "Notes role package not found.");
|
|
}
|
|
|
|
if (mContext.getSystemService(UserManager.class).isManagedProfile(user.getIdentifier())) {
|
|
pref.setSummary(
|
|
mContext.getString(R.string.stylus_default_notes_summary_work, appName));
|
|
} else {
|
|
pref.setSummary(appName);
|
|
}
|
|
return pref;
|
|
}
|
|
|
|
private PrimarySwitchPreference createOrUpdateHandwritingPreference(
|
|
PrimarySwitchPreference preference) {
|
|
PrimarySwitchPreference pref = preference == null ? new PrimarySwitchPreference(mContext)
|
|
: preference;
|
|
pref.setKey(KEY_HANDWRITING);
|
|
pref.setTitle(mContext.getString(R.string.stylus_textfield_handwriting));
|
|
pref.setIcon(R.drawable.ic_text_fields_alt);
|
|
// Using a two-target preference, clicking will send an intent and change will toggle.
|
|
pref.setOnPreferenceChangeListener(this);
|
|
pref.setOnPreferenceClickListener(this);
|
|
pref.setChecked(Settings.Secure.getInt(mContext.getContentResolver(),
|
|
Settings.Secure.STYLUS_HANDWRITING_ENABLED,
|
|
Secure.STYLUS_HANDWRITING_DEFAULT_VALUE) == 1);
|
|
pref.setVisible(currentInputMethodSupportsHandwriting());
|
|
return pref;
|
|
}
|
|
|
|
private SwitchPreference createButtonPressPreference() {
|
|
SwitchPreference pref = new SwitchPreference(mContext);
|
|
pref.setKey(KEY_IGNORE_BUTTON);
|
|
pref.setTitle(mContext.getString(R.string.stylus_ignore_button));
|
|
pref.setIcon(R.drawable.ic_block);
|
|
pref.setOnPreferenceClickListener(this);
|
|
pref.setChecked(Settings.Secure.getInt(mContext.getContentResolver(),
|
|
Settings.Secure.STYLUS_BUTTONS_ENABLED, 1) == 0);
|
|
return pref;
|
|
}
|
|
|
|
@Override
|
|
public boolean onPreferenceClick(Preference preference) {
|
|
String key = preference.getKey();
|
|
switch (key) {
|
|
case KEY_DEFAULT_NOTES:
|
|
PackageManager pm = mContext.getPackageManager();
|
|
String packageName = pm.getPermissionControllerPackageName();
|
|
Intent intent = new Intent(Intent.ACTION_MANAGE_DEFAULT_APP).setPackage(
|
|
packageName).putExtra(Intent.EXTRA_ROLE_NAME, RoleManager.ROLE_NOTES);
|
|
|
|
List<UserHandle> users = getUserAndManagedProfiles();
|
|
if (users.size() <= 1) {
|
|
mContext.startActivity(intent);
|
|
} else {
|
|
createAndShowProfileSelectDialog(intent, users);
|
|
}
|
|
break;
|
|
case KEY_HANDWRITING:
|
|
InputMethodManager imm = mContext.getSystemService(InputMethodManager.class);
|
|
InputMethodInfo inputMethod = imm.getCurrentInputMethodInfo();
|
|
if (inputMethod == null) break;
|
|
Intent handwritingIntent =
|
|
inputMethod.createStylusHandwritingSettingsActivityIntent();
|
|
if (handwritingIntent != null) {
|
|
mContext.startActivity(handwritingIntent);
|
|
}
|
|
break;
|
|
case KEY_IGNORE_BUTTON:
|
|
Settings.Secure.putInt(mContext.getContentResolver(),
|
|
Secure.STYLUS_BUTTONS_ENABLED,
|
|
((SwitchPreference) preference).isChecked() ? 0 : 1);
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean onPreferenceChange(Preference preference, Object newValue) {
|
|
String key = preference.getKey();
|
|
switch (key) {
|
|
case KEY_HANDWRITING:
|
|
Settings.Secure.putInt(mContext.getContentResolver(),
|
|
Settings.Secure.STYLUS_HANDWRITING_ENABLED,
|
|
(boolean) newValue ? 1 : 0);
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public final void displayPreference(PreferenceScreen screen) {
|
|
mPreferencesContainer = (PreferenceCategory) screen.findPreference(getPreferenceKey());
|
|
super.displayPreference(screen);
|
|
|
|
refresh();
|
|
}
|
|
|
|
@Override
|
|
public String getPreferenceKey() {
|
|
return KEY_STYLUS;
|
|
}
|
|
|
|
@Override
|
|
public void onResume() {
|
|
refresh();
|
|
}
|
|
|
|
private void refresh() {
|
|
if (!isAvailable()) return;
|
|
|
|
Preference currNotesPref = mPreferencesContainer.findPreference(KEY_DEFAULT_NOTES);
|
|
Preference notesPref = createOrUpdateDefaultNotesPreference(currNotesPref);
|
|
if (currNotesPref == null && notesPref != null) {
|
|
mPreferencesContainer.addPreference(notesPref);
|
|
}
|
|
|
|
PrimarySwitchPreference currHandwritingPref = mPreferencesContainer.findPreference(
|
|
KEY_HANDWRITING);
|
|
Preference handwritingPref = createOrUpdateHandwritingPreference(currHandwritingPref);
|
|
if (currHandwritingPref == null) {
|
|
mPreferencesContainer.addPreference(handwritingPref);
|
|
}
|
|
|
|
Preference buttonPref = mPreferencesContainer.findPreference(KEY_IGNORE_BUTTON);
|
|
if (buttonPref == null) {
|
|
mPreferencesContainer.addPreference(createButtonPressPreference());
|
|
}
|
|
}
|
|
|
|
private boolean currentInputMethodSupportsHandwriting() {
|
|
InputMethodManager imm = mContext.getSystemService(InputMethodManager.class);
|
|
InputMethodInfo inputMethod = imm.getCurrentInputMethodInfo();
|
|
return inputMethod != null && inputMethod.supportsStylusHandwriting();
|
|
}
|
|
|
|
private List<UserHandle> getUserAndManagedProfiles() {
|
|
UserManager um = mContext.getSystemService(UserManager.class);
|
|
final List<UserHandle> userManagedProfiles = new ArrayList<>();
|
|
// Add the current user, then add all the associated managed profiles.
|
|
final UserHandle currentUser = Process.myUserHandle();
|
|
userManagedProfiles.add(currentUser);
|
|
|
|
final List<UserInfo> userInfos = um.getUsers();
|
|
for (UserInfo info : userInfos) {
|
|
int userId = info.id;
|
|
if (um.isManagedProfile(userId)
|
|
&& um.getProfileParent(userId).id == currentUser.getIdentifier()) {
|
|
userManagedProfiles.add(UserHandle.of(userId));
|
|
}
|
|
}
|
|
return userManagedProfiles;
|
|
}
|
|
|
|
private UserHandle getDefaultNoteTaskProfile() {
|
|
final int userId = Secure.getInt(
|
|
mContext.getContentResolver(),
|
|
Secure.DEFAULT_NOTE_TASK_PROFILE,
|
|
UserHandle.myUserId());
|
|
return UserHandle.of(userId);
|
|
}
|
|
|
|
@VisibleForTesting
|
|
UserAdapter.OnClickListener createProfileDialogClickCallback(
|
|
Intent intent, List<UserHandle> users) {
|
|
// TODO(b/281659827): improve UX flow for when activity is cancelled
|
|
return (int position) -> {
|
|
intent.putExtra(Intent.EXTRA_USER, users.get(position));
|
|
|
|
Secure.putInt(mContext.getContentResolver(),
|
|
Secure.DEFAULT_NOTE_TASK_PROFILE,
|
|
users.get(position).getIdentifier());
|
|
mContext.startActivity(intent);
|
|
|
|
mDialog.dismiss();
|
|
};
|
|
}
|
|
|
|
private void createAndShowProfileSelectDialog(Intent intent, List<UserHandle> users) {
|
|
mDialog = ProfileSelectDialog.createDialog(
|
|
mContext,
|
|
users,
|
|
createProfileDialogClickCallback(intent, users));
|
|
mDialog.show();
|
|
}
|
|
|
|
/**
|
|
* Identifies whether a device is a stylus using the associated {@link InputDevice} or
|
|
* {@link CachedBluetoothDevice}.
|
|
*
|
|
* InputDevices are only available when the device is USI or Bluetooth-connected, whereas
|
|
* CachedBluetoothDevices are available for Bluetooth devices when connected or paired,
|
|
* so to handle all cases, both are needed.
|
|
*
|
|
* @param inputDevice The associated input device of the stylus
|
|
* @param cachedBluetoothDevice The associated bluetooth device of the stylus
|
|
*/
|
|
public static boolean isDeviceStylus(@Nullable InputDevice inputDevice,
|
|
@Nullable CachedBluetoothDevice cachedBluetoothDevice) {
|
|
if (inputDevice != null && inputDevice.supportsSource(InputDevice.SOURCE_STYLUS)) {
|
|
return true;
|
|
}
|
|
|
|
if (cachedBluetoothDevice != null) {
|
|
BluetoothDevice bluetoothDevice = cachedBluetoothDevice.getDevice();
|
|
String deviceType = BluetoothUtils.getStringMetaData(bluetoothDevice,
|
|
BluetoothDevice.METADATA_DEVICE_TYPE);
|
|
return TextUtils.equals(deviceType, BluetoothDevice.DEVICE_TYPE_STYLUS);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|