Preparation task for Settings Fragment Migration (464da581) · Commits · e / os / android_frameworks_base

packages/SettingsLib/src/com/android/settingslib/CustomDialogPreferenceCompat.java

0 → 100644

+129 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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.settingslib;

		import android.app.Dialog;
		import android.content.Context;
		import android.content.DialogInterface;
		import android.os.Bundle;
		import android.util.AttributeSet;
		import android.view.View;

		import androidx.appcompat.app.AlertDialog;
		import androidx.preference.DialogPreference;
		import androidx.preference.PreferenceDialogFragmentCompat;

		public class CustomDialogPreferenceCompat extends DialogPreference {

		private CustomPreferenceDialogFragment mFragment;
		private DialogInterface.OnShowListener mOnShowListener;

		public CustomDialogPreferenceCompat(Context context, AttributeSet attrs, int defStyleAttr,
		int defStyleRes) {
		super(context, attrs, defStyleAttr, defStyleRes);
		}

		public CustomDialogPreferenceCompat(Context context, AttributeSet attrs, int defStyleAttr) {
		super(context, attrs, defStyleAttr);
		}

		public CustomDialogPreferenceCompat(Context context, AttributeSet attrs) {
		super(context, attrs);
		}

		public CustomDialogPreferenceCompat(Context context) {
		super(context);
		}

		public boolean isDialogOpen() {
		return getDialog() != null && getDialog().isShowing();
		}

		public Dialog getDialog() {
		return mFragment != null ? mFragment.getDialog() : null;
		}

		public void setOnShowListener(DialogInterface.OnShowListener listner) {
		mOnShowListener = listner;
		}

		protected void onPrepareDialogBuilder(AlertDialog.Builder builder,
		DialogInterface.OnClickListener listener) {
		}

		protected void onDialogClosed(boolean positiveResult) {
		}

		protected void onClick(DialogInterface dialog, int which) {
		}

		protected void onBindDialogView(View view) {
		}

		private void setFragment(CustomPreferenceDialogFragment fragment) {
		mFragment = fragment;
		}

		private DialogInterface.OnShowListener getOnShowListener() {
		return mOnShowListener;
		}

		public static class CustomPreferenceDialogFragment extends PreferenceDialogFragmentCompat {

		public static CustomPreferenceDialogFragment newInstance(String key) {
		final CustomPreferenceDialogFragment fragment = new CustomPreferenceDialogFragment();
		final Bundle b = new Bundle(1);
		b.putString(ARG_KEY, key);
		fragment.setArguments(b);
		return fragment;
		}

		private CustomDialogPreferenceCompat getCustomizablePreference() {
		return (CustomDialogPreferenceCompat) getPreference();
		}

		@Override
		protected void onPrepareDialogBuilder(AlertDialog.Builder builder) {
		super.onPrepareDialogBuilder(builder);
		getCustomizablePreference().setFragment(this);
		getCustomizablePreference().onPrepareDialogBuilder(builder, this);
		}

		@Override
		public void onDialogClosed(boolean positiveResult) {
		getCustomizablePreference().onDialogClosed(positiveResult);
		}

		@Override
		protected void onBindDialogView(View view) {
		super.onBindDialogView(view);
		getCustomizablePreference().onBindDialogView(view);
		}

		@Override
		public Dialog onCreateDialog(Bundle savedInstanceState) {
		final Dialog dialog = super.onCreateDialog(savedInstanceState);
		dialog.setOnShowListener(getCustomizablePreference().getOnShowListener());
		return dialog;
		}

		@Override
		public void onClick(DialogInterface dialog, int which) {
		super.onClick(dialog, which);
		getCustomizablePreference().onClick(dialog, which);
		}
		}
		}

packages/SettingsLib/src/com/android/settingslib/CustomEditTextPreferenceCompat.java

0 → 100644

+136 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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.settingslib;

		import static android.text.InputType.TYPE_CLASS_TEXT;
		import static android.text.InputType.TYPE_TEXT_FLAG_CAP_SENTENCES;

		import android.app.Dialog;
		import android.content.Context;
		import android.content.DialogInterface;
		import android.os.Bundle;
		import android.util.AttributeSet;
		import android.view.View;
		import android.widget.EditText;

		import androidx.annotation.CallSuper;
		import androidx.appcompat.app.AlertDialog;
		import androidx.preference.EditTextPreference;
		import androidx.preference.EditTextPreferenceDialogFragmentCompat;

		public class CustomEditTextPreferenceCompat extends EditTextPreference {

		private CustomPreferenceDialogFragment mFragment;

		public CustomEditTextPreferenceCompat(Context context, AttributeSet attrs, int defStyleAttr,
		int defStyleRes) {
		super(context, attrs, defStyleAttr, defStyleRes);
		}

		public CustomEditTextPreferenceCompat(Context context, AttributeSet attrs, int defStyleAttr) {
		super(context, attrs, defStyleAttr);
		}

		public CustomEditTextPreferenceCompat(Context context, AttributeSet attrs) {
		super(context, attrs);
		}

		public CustomEditTextPreferenceCompat(Context context) {
		super(context);
		}

		public EditText getEditText() {
		if (mFragment != null) {
		final Dialog dialog = mFragment.getDialog();
		if (dialog != null) {
		return (EditText) dialog.findViewById(android.R.id.edit);
		}
		}
		return null;
		}

		public boolean isDialogOpen() {
		return getDialog() != null && getDialog().isShowing();
		}

		public Dialog getDialog() {
		return mFragment != null ? mFragment.getDialog() : null;
		}

		protected void onPrepareDialogBuilder(AlertDialog.Builder builder,
		DialogInterface.OnClickListener listener) {
		}

		protected void onDialogClosed(boolean positiveResult) {
		}

		protected void onClick(DialogInterface dialog, int which) {
		}

		@CallSuper
		protected void onBindDialogView(View view) {
		final EditText editText = view.findViewById(android.R.id.edit);
		if (editText != null) {
		editText.setInputType(TYPE_CLASS_TEXT \| TYPE_TEXT_FLAG_CAP_SENTENCES);
		editText.requestFocus();
		}
		}

		private void setFragment(CustomPreferenceDialogFragment fragment) {
		mFragment = fragment;
		}

		public static class CustomPreferenceDialogFragment extends
		EditTextPreferenceDialogFragmentCompat {

		public static CustomPreferenceDialogFragment newInstance(String key) {
		final CustomPreferenceDialogFragment fragment = new CustomPreferenceDialogFragment();
		final Bundle b = new Bundle(1);
		b.putString(ARG_KEY, key);
		fragment.setArguments(b);
		return fragment;
		}

		private CustomEditTextPreferenceCompat getCustomizablePreference() {
		return (CustomEditTextPreferenceCompat) getPreference();
		}

		@Override
		protected void onBindDialogView(View view) {
		super.onBindDialogView(view);
		getCustomizablePreference().onBindDialogView(view);
		}

		@Override
		protected void onPrepareDialogBuilder(AlertDialog.Builder builder) {
		super.onPrepareDialogBuilder(builder);
		getCustomizablePreference().setFragment(this);
		getCustomizablePreference().onPrepareDialogBuilder(builder, this);
		}

		@Override
		public void onDialogClosed(boolean positiveResult) {
		super.onDialogClosed(positiveResult);
		getCustomizablePreference().onDialogClosed(positiveResult);
		}

		@Override
		public void onClick(DialogInterface dialog, int which) {
		super.onClick(dialog, which);
		getCustomizablePreference().onClick(dialog, which);
		}
		}
		}

packages/SettingsLib/src/com/android/settingslib/inputmethod/InputMethodAndSubtypeEnablerManagerCompat.java

0 → 100644

+265 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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.settingslib.inputmethod;

		import android.content.Context;
		import android.content.pm.PackageManager;
		import android.content.res.Configuration;
		import android.text.TextUtils;
		import android.view.inputmethod.InputMethodInfo;
		import android.view.inputmethod.InputMethodManager;
		import android.view.inputmethod.InputMethodSubtype;

		import com.android.settingslib.R;

		import java.text.Collator;
		import java.util.ArrayList;
		import java.util.HashMap;
		import java.util.List;

		import androidx.preference.Preference;
		import androidx.preference.PreferenceCategory;
		import androidx.preference.PreferenceFragmentCompat;
		import androidx.preference.PreferenceScreen;
		import androidx.preference.TwoStatePreference;

		public class InputMethodAndSubtypeEnablerManagerCompat implements
		Preference.OnPreferenceChangeListener {

		private final PreferenceFragmentCompat mFragment;

		private boolean mHaveHardKeyboard;
		private final HashMap<String, List<Preference>> mInputMethodAndSubtypePrefsMap =
		new HashMap<>();
		private final HashMap<String, TwoStatePreference> mAutoSelectionPrefsMap = new HashMap<>();
		private InputMethodManager mImm;
		// TODO: Change mInputMethodInfoList to Map
		private List<InputMethodInfo> mInputMethodInfoList;
		private final Collator mCollator = Collator.getInstance();

		public InputMethodAndSubtypeEnablerManagerCompat(PreferenceFragmentCompat fragment) {
		mFragment = fragment;
		mImm = fragment.getContext().getSystemService(InputMethodManager.class);

		mInputMethodInfoList = mImm.getInputMethodList();
		}

		public void init(PreferenceFragmentCompat fragment, String targetImi, PreferenceScreen root) {
		final Configuration config = fragment.getResources().getConfiguration();
		mHaveHardKeyboard = (config.keyboard == Configuration.KEYBOARD_QWERTY);

		for (final InputMethodInfo imi : mInputMethodInfoList) {
		// Add subtype preferences of this IME when it is specified or no IME is specified.
		if (imi.getId().equals(targetImi) \|\| TextUtils.isEmpty(targetImi)) {
		addInputMethodSubtypePreferences(fragment, imi, root);
		}
		}
		}

		public void refresh(Context context, PreferenceFragmentCompat fragment) {
		// Refresh internal states in mInputMethodSettingValues to keep the latest
		// "InputMethodInfo"s and "InputMethodSubtype"s
		InputMethodSettingValuesWrapper
		.getInstance(context).refreshAllInputMethodAndSubtypes();
		InputMethodAndSubtypeUtilCompat.loadInputMethodSubtypeList(fragment,
		context.getContentResolver(), mInputMethodInfoList, mInputMethodAndSubtypePrefsMap);
		updateAutoSelectionPreferences();
		}

		public void save(Context context, PreferenceFragmentCompat fragment) {
		InputMethodAndSubtypeUtilCompat.saveInputMethodSubtypeList(fragment,
		context.getContentResolver(), mInputMethodInfoList, mHaveHardKeyboard);
		}

		@Override
		public boolean onPreferenceChange(final Preference pref, final Object newValue) {
		if (!(newValue instanceof Boolean)) {
		return true; // Invoke default behavior.
		}
		final boolean isChecking = (Boolean) newValue;
		for (final String imiId : mAutoSelectionPrefsMap.keySet()) {
		// An auto select subtype preference is changing.
		if (mAutoSelectionPrefsMap.get(imiId) == pref) {
		final TwoStatePreference autoSelectionPref = (TwoStatePreference) pref;
		autoSelectionPref.setChecked(isChecking);
		// Enable or disable subtypes depending on the auto selection preference.
		setAutoSelectionSubtypesEnabled(imiId, autoSelectionPref.isChecked());
		return false;
		}
		}
		// A subtype preference is changing.
		if (pref instanceof InputMethodSubtypePreference) {
		final InputMethodSubtypePreference subtypePref = (InputMethodSubtypePreference) pref;
		subtypePref.setChecked(isChecking);
		if (!subtypePref.isChecked()) {
		// It takes care of the case where no subtypes are explicitly enabled then the auto
		// selection preference is going to be checked.
		updateAutoSelectionPreferences();
		}
		return false;
		}
		return true; // Invoke default behavior.
		}

		private void addInputMethodSubtypePreferences(PreferenceFragmentCompat fragment,
		InputMethodInfo imi, final PreferenceScreen root) {
		Context prefContext = fragment.getPreferenceManager().getContext();

		final int subtypeCount = imi.getSubtypeCount();
		if (subtypeCount <= 1) {
		return;
		}
		final String imiId = imi.getId();
		final PreferenceCategory keyboardSettingsCategory =
		new PreferenceCategory(prefContext);
		root.addPreference(keyboardSettingsCategory);
		final PackageManager pm = prefContext.getPackageManager();
		final CharSequence label = imi.loadLabel(pm);

		keyboardSettingsCategory.setTitle(label);
		keyboardSettingsCategory.setKey(imiId);
		// TODO: Use toggle Preference if images are ready.
		final TwoStatePreference autoSelectionPref =
		new SwitchWithNoTextPreference(prefContext);
		mAutoSelectionPrefsMap.put(imiId, autoSelectionPref);
		keyboardSettingsCategory.addPreference(autoSelectionPref);
		autoSelectionPref.setOnPreferenceChangeListener(this);

		final PreferenceCategory activeInputMethodsCategory =
		new PreferenceCategory(prefContext);
		activeInputMethodsCategory.setTitle(R.string.active_input_method_subtypes);
		root.addPreference(activeInputMethodsCategory);

		CharSequence autoSubtypeLabel = null;
		final ArrayList<Preference> subtypePreferences = new ArrayList<>();
		for (int index = 0; index < subtypeCount; ++index) {
		final InputMethodSubtype subtype = imi.getSubtypeAt(index);
		if (subtype.overridesImplicitlyEnabledSubtype()) {
		if (autoSubtypeLabel == null) {
		autoSubtypeLabel = InputMethodAndSubtypeUtil.getSubtypeLocaleNameAsSentence(
		subtype, prefContext, imi);
		}
		} else {
		final Preference subtypePref = new InputMethodSubtypePreference(
		prefContext, subtype, imi);
		subtypePreferences.add(subtypePref);
		}
		}
		subtypePreferences.sort((lhs, rhs) -> {
		if (lhs instanceof InputMethodSubtypePreference) {
		return ((InputMethodSubtypePreference) lhs).compareTo(rhs, mCollator);
		}
		return lhs.compareTo(rhs);
		});
		for (final Preference pref : subtypePreferences) {
		activeInputMethodsCategory.addPreference(pref);
		pref.setOnPreferenceChangeListener(this);
		InputMethodAndSubtypeUtil.removeUnnecessaryNonPersistentPreference(pref);
		}
		mInputMethodAndSubtypePrefsMap.put(imiId, subtypePreferences);
		if (TextUtils.isEmpty(autoSubtypeLabel)) {
		autoSelectionPref.setTitle(
		R.string.use_system_language_to_select_input_method_subtypes);
		} else {
		autoSelectionPref.setTitle(autoSubtypeLabel);
		}
		}

		private boolean isNoSubtypesExplicitlySelected(final String imiId) {
		final List<Preference> subtypePrefs = mInputMethodAndSubtypePrefsMap.get(imiId);
		for (final Preference pref : subtypePrefs) {
		if (pref instanceof TwoStatePreference && ((TwoStatePreference) pref).isChecked()) {
		return false;
		}
		}
		return true;
		}

		private void setAutoSelectionSubtypesEnabled(final String imiId,
		final boolean autoSelectionEnabled) {
		final TwoStatePreference autoSelectionPref = mAutoSelectionPrefsMap.get(imiId);
		if (autoSelectionPref == null) {
		return;
		}
		autoSelectionPref.setChecked(autoSelectionEnabled);
		final List<Preference> subtypePrefs = mInputMethodAndSubtypePrefsMap.get(imiId);
		for (final Preference pref : subtypePrefs) {
		if (pref instanceof TwoStatePreference) {
		// When autoSelectionEnabled is true, all subtype prefs need to be disabled with
		// implicitly checked subtypes. In case of false, all subtype prefs need to be
		// enabled.
		pref.setEnabled(!autoSelectionEnabled);
		if (autoSelectionEnabled) {
		((TwoStatePreference) pref).setChecked(false);
		}
		}
		}
		if (autoSelectionEnabled) {
		InputMethodAndSubtypeUtilCompat.saveInputMethodSubtypeList(
		mFragment, mFragment.getContext().getContentResolver(),
		mInputMethodInfoList, mHaveHardKeyboard);
		updateImplicitlyEnabledSubtypes(imiId);
		}
		}

		private void updateImplicitlyEnabledSubtypes(final String targetImiId) {
		// When targetImiId is null, apply to all subtypes of all IMEs
		for (final InputMethodInfo imi : mInputMethodInfoList) {
		final String imiId = imi.getId();
		final TwoStatePreference autoSelectionPref = mAutoSelectionPrefsMap.get(imiId);
		// No need to update implicitly enabled subtypes when the user has unchecked the
		// "subtype auto selection".
		if (autoSelectionPref == null \|\| !autoSelectionPref.isChecked()) {
		continue;
		}
		if (imiId.equals(targetImiId) \|\| targetImiId == null) {
		updateImplicitlyEnabledSubtypesOf(imi);
		}
		}
		}

		private void updateImplicitlyEnabledSubtypesOf(final InputMethodInfo imi) {
		final String imiId = imi.getId();
		final List<Preference> subtypePrefs = mInputMethodAndSubtypePrefsMap.get(imiId);
		final List<InputMethodSubtype> implicitlyEnabledSubtypes =
		mImm.getEnabledInputMethodSubtypeList(imi, true);
		if (subtypePrefs == null \|\| implicitlyEnabledSubtypes == null) {
		return;
		}
		for (final Preference pref : subtypePrefs) {
		if (!(pref instanceof TwoStatePreference)) {
		continue;
		}
		final TwoStatePreference subtypePref = (TwoStatePreference) pref;
		subtypePref.setChecked(false);
		for (final InputMethodSubtype subtype : implicitlyEnabledSubtypes) {
		final String implicitlyEnabledSubtypePrefKey = imiId + subtype.hashCode();
		if (subtypePref.getKey().equals(implicitlyEnabledSubtypePrefKey)) {
		subtypePref.setChecked(true);
		break;
		}
		}
		}
		}

		private void updateAutoSelectionPreferences() {
		for (final String imiId : mInputMethodAndSubtypePrefsMap.keySet()) {
		setAutoSelectionSubtypesEnabled(imiId, isNoSubtypesExplicitlySelected(imiId));
		}
		updateImplicitlyEnabledSubtypes(null /* targetImiId / / check */);
		}
		}

packages/SettingsLib/src/com/android/settingslib/inputmethod/InputMethodAndSubtypeUtilCompat.java

0 → 100644

+436 −0

File added.

Preview size limit exceeded, changes collapsed.

packages/SettingsLib/src/com/android/settingslib/license/LicenseHtmlLoaderCompat.java

0 → 100644

+111 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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.settingslib.license;

		import android.content.Context;
		import android.util.Log;

		import com.android.settingslib.utils.AsyncLoaderCompat;

		import java.io.File;
		import java.util.ArrayList;
		import java.util.List;

		import androidx.annotation.VisibleForTesting;

		/**
		* LicenseHtmlLoader is a loader which loads a license html file from default license xml files.
		*/
		public class LicenseHtmlLoaderCompat extends AsyncLoaderCompat<File> {
		private static final String TAG = "LicenseHtmlLoaderCompat";

		private static final String[] DEFAULT_LICENSE_XML_PATHS = {
		"/system/etc/NOTICE.xml.gz",
		"/vendor/etc/NOTICE.xml.gz",
		"/odm/etc/NOTICE.xml.gz",
		"/oem/etc/NOTICE.xml.gz"};
		private static final String NOTICE_HTML_FILE_NAME = "NOTICE.html";

		private Context mContext;

		public LicenseHtmlLoaderCompat(Context context) {
		super(context);
		mContext = context;
		}

		@Override
		public File loadInBackground() {
		return generateHtmlFromDefaultXmlFiles();
		}

		@Override
		protected void onDiscardResult(File f) {
		}

		private File generateHtmlFromDefaultXmlFiles() {
		final List<File> xmlFiles = getVaildXmlFiles();
		if (xmlFiles.isEmpty()) {
		Log.e(TAG, "No notice file exists.");
		return null;
		}

		File cachedHtmlFile = getCachedHtmlFile();
		if (!isCachedHtmlFileOutdated(xmlFiles, cachedHtmlFile)
		\|\| generateHtmlFile(xmlFiles, cachedHtmlFile)) {
		return cachedHtmlFile;
		}

		return null;
		}

		@VisibleForTesting
		List<File> getVaildXmlFiles() {
		final List<File> xmlFiles = new ArrayList();
		for (final String xmlPath : DEFAULT_LICENSE_XML_PATHS) {
		File file = new File(xmlPath);
		if (file.exists() && file.length() != 0) {
		xmlFiles.add(file);
		}
		}
		return xmlFiles;
		}

		@VisibleForTesting
		File getCachedHtmlFile() {
		return new File(mContext.getCacheDir(), NOTICE_HTML_FILE_NAME);
		}

		@VisibleForTesting
		boolean isCachedHtmlFileOutdated(List<File> xmlFiles, File cachedHtmlFile) {
		boolean outdated = true;
		if (cachedHtmlFile.exists() && cachedHtmlFile.length() != 0) {
		outdated = false;
		for (File file : xmlFiles) {
		if (cachedHtmlFile.lastModified() < file.lastModified()) {
		outdated = true;
		break;
		}
		}
		}
		return outdated;
		}

		@VisibleForTesting
		boolean generateHtmlFile(List<File> xmlFiles, File htmlFile) {
		return LicenseHtmlGeneratorFromXml.generateHtml(xmlFiles, htmlFile);
		}
		}