PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Updates to Magnification Settings"

Browse Source
This commit is contained in:
Casey Burkhardt
2017-03-24 19:35:19 +00:00
committed by Android (Google) Code Review
parent dedc8f18df 9c7143c3e4
commit 6075d46e85
10 changed files with 320 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/com/android/settings/accessibility/AccessibilitySettings.java
View File

@@ -121,6 +121,8 @@ public class AccessibilitySettings extends SettingsPreferenceFragment implements
static final String EXTRA_SETTINGS_TITLE = "settings_title";
static final String EXTRA_COMPONENT_NAME = "component_name";
static final String EXTRA_SETTINGS_COMPONENT_NAME = "settings_component_name";
static final String EXTRA_VIDEO_RAW_RESOURCE_ID = "video_resource";
static final String EXTRA_LAUNCHED_FROM_SUW = "from_suw";
// Timeout before we update the services if packages are added/removed
// since the AccessibilityManagerService has to do that processing first
@@ -350,9 +352,6 @@ public class AccessibilitySettings extends SettingsPreferenceFragment implements
} else if (mToggleMasterMonoPreference == preference) {
handleToggleMasterMonoPreferenceClick();
return true;
} else if (mDisplayMagnificationPreferenceScreen == preference) {
handleDisplayMagnificationPreferenceScreenClick();
return true;
}
return super.onPreferenceTreeClick(preference);
}
@@ -387,17 +386,6 @@ public class AccessibilitySettings extends SettingsPreferenceFragment implements
mToggleMasterMonoPreference.isChecked() ? 1 : 0, UserHandle.USER_CURRENT);
}
private void handleDisplayMagnificationPreferenceScreenClick() {
Bundle extras = mDisplayMagnificationPreferenceScreen.getExtras();
extras.putString(EXTRA_TITLE, getString(
R.string.accessibility_screen_magnification_title));
extras.putCharSequence(EXTRA_SUMMARY, getActivity().getResources().getText(
R.string.accessibility_screen_magnification_summary));
extras.putBoolean(EXTRA_CHECKED, Settings.Secure.getInt(getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 0) == 1);
super.onPreferenceTreeClick(mDisplayMagnificationPreferenceScreen);
}
private void initializeAllPreferences() {
for (int i = 0; i < CATEGORIES.length; i++) {
PreferenceCategory prefCategory = (PreferenceCategory) findPreference(CATEGORIES[i]);
@@ -656,8 +644,6 @@ public class AccessibilitySettings extends SettingsPreferenceFragment implements
updateFeatureSummary(Settings.Secure.ACCESSIBILITY_CAPTIONING_ENABLED,
mCaptioningPreferenceScreen);
updateFeatureSummary(Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED,
mDisplayMagnificationPreferenceScreen);
updateFeatureSummary(Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED,
mDisplayDaltonizerPreferenceScreen);

8
src/com/android/settings/accessibility/AccessibilitySettingsForSetupWizard.java
View File

@@ -96,13 +96,7 @@ public class AccessibilitySettingsForSetupWizard extends SettingsPreferenceFragm
public boolean onPreferenceTreeClick(Preference preference) {
if (mDisplayMagnificationPreference == preference) {
Bundle extras = mDisplayMagnificationPreference.getExtras();
extras.putString(AccessibilitySettings.EXTRA_TITLE,
getString(R.string.accessibility_screen_magnification_title));
extras.putCharSequence(AccessibilitySettings.EXTRA_SUMMARY,
getText(R.string.accessibility_screen_magnification_summary));
extras.putBoolean(AccessibilitySettings.EXTRA_CHECKED,
Settings.Secure.getInt(getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 0) == 1);
extras.putBoolean(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW, true);
}
return super.onPreferenceTreeClick(preference);

173
src/com/android/settings/accessibility/MagnificationPreferenceFragment.java Normal file
View File

@@ -0,0 +1,173 @@
/*
* Copyright (C) 2017 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.accessibility;
import android.content.ContentResolver;
import android.content.Context;
import android.os.Bundle;
import android.provider.SearchIndexableResource;
import android.provider.Settings;
import android.support.v7.preference.Preference;
import android.view.View;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.settings.R;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.search.BaseSearchIndexProvider;
import com.android.settings.search.Indexable;
import java.util.Arrays;
import java.util.List;
public final class MagnificationPreferenceFragment extends SettingsPreferenceFragment implements
Indexable {
// Settings App preference keys
private static final String MAGNIFICATION_GESTURES_PREFERENCE_SCREEN_KEY =
"screen_magnification_gestures_preference_screen";
private static final String MAGNIFICATION_NAVBAR_PREFERENCE_SCREEN_KEY =
"screen_magnification_navbar_preference_screen";
private Preference mMagnificationGesturesPreference;
private Preference mMagnificationNavbarPreference;
private boolean mLaunchedFromSuw = false;
@Override
public void onCreatePreferences(Bundle bundle, String s) {
addPreferencesFromResource(R.xml.accessibility_magnification_settings);
mMagnificationGesturesPreference = findPreference(
MAGNIFICATION_GESTURES_PREFERENCE_SCREEN_KEY);
mMagnificationNavbarPreference = findPreference(MAGNIFICATION_NAVBAR_PREFERENCE_SCREEN_KEY);
}
@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
final Bundle args = getArguments();
if ((args != null) && args.containsKey(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW)) {
mLaunchedFromSuw = args.getBoolean(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW);
}
}
@Override
public void onResume() {
super.onResume();
getActivity().setTitle(R.string.accessibility_screen_magnification_title);
updateFeatureSummary(Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED,
mMagnificationGesturesPreference);
updateFeatureSummary(Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED,
mMagnificationNavbarPreference);
}
@Override
public int getMetricsCategory() {
return MetricsEvent.ACCESSIBILITY_SCREEN_MAGNIFICATION_SETTINGS;
}
@Override
public boolean onPreferenceTreeClick(Preference preference) {
if (mLaunchedFromSuw) {
// If invoked from SUW, redirect to fragment instrumented for Vision Settings metrics
preference.setFragment(
ToggleScreenMagnificationPreferenceFragmentForSetupWizard.class.getName());
}
if (mMagnificationGesturesPreference == preference) {
handleMagnificationGesturesPreferenceScreenClick();
super.onPreferenceTreeClick(mMagnificationGesturesPreference);
return true;
} else if (mMagnificationNavbarPreference == preference) {
handleMagnificationNavbarPreferenceScreenClick();
super.onPreferenceTreeClick(mMagnificationNavbarPreference);
return true;
}
return super.onPreferenceTreeClick(preference);
}
private void updateFeatureSummary(String prefKey, Preference pref) {
if (!mLaunchedFromSuw) {
final boolean enabled = Settings.Secure.getInt(getContentResolver(), prefKey, 0) == 1;
pref.setSummary(enabled ? R.string.accessibility_feature_state_on
: R.string.accessibility_feature_state_off);
} else {
if (Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED.equals(prefKey)) {
pref.setSummary(R.string.accessibility_screen_magnification_short_summary);
} else if (Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED.equals(
prefKey)) {
pref.setSummary(R.string.accessibility_screen_magnification_navbar_short_summary);
}
}
}
private void handleMagnificationGesturesPreferenceScreenClick() {
Bundle extras = mMagnificationGesturesPreference.getExtras();
extras.putString(AccessibilitySettings.EXTRA_PREFERENCE_KEY,
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED);
extras.putString(AccessibilitySettings.EXTRA_TITLE, getString(
R.string.accessibility_screen_magnification_gestures_title));
extras.putCharSequence(AccessibilitySettings.EXTRA_SUMMARY,
getActivity().getResources().getText(
R.string.accessibility_screen_magnification_summary));
extras.putBoolean(AccessibilitySettings.EXTRA_CHECKED,
Settings.Secure.getInt(getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 0) == 1);
extras.putInt(AccessibilitySettings.EXTRA_VIDEO_RAW_RESOURCE_ID,
R.raw.accessibility_screen_magnification);
extras.putBoolean(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW, mLaunchedFromSuw);
}
private void handleMagnificationNavbarPreferenceScreenClick() {
Bundle extras = mMagnificationNavbarPreference.getExtras();
extras.putString(AccessibilitySettings.EXTRA_PREFERENCE_KEY,
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED);
extras.putString(AccessibilitySettings.EXTRA_TITLE, getString(
R.string.accessibility_screen_magnification_navbar_title));
extras.putCharSequence(AccessibilitySettings.EXTRA_SUMMARY,
getActivity().getResources().getText(
R.string.accessibility_screen_magnification_navbar_summary));
extras.putBoolean(AccessibilitySettings.EXTRA_CHECKED,
Settings.Secure.getInt(getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED, 0)
== 1);
extras.putBoolean(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW, mLaunchedFromSuw);
}
static int getConfigurationWarningStringResourceForSecureSettingsKey(String key,
ContentResolver resolver) {
if (Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED.equals(key)) {
if (Settings.Secure.getInt(resolver,
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED, 0) == 1) {
// TODO(b/34720082): Only report a config warning when nav-bar is not mapped to mag
return R.string.accessibility_screen_magnification_navbar_configuration_warning;
}
}
return -1;
}
public static final Indexable.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.accessibility_magnification_settings;
return Arrays.asList(sir);
}
};
}

140
src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragment.java
View File

@@ -20,29 +20,28 @@ import android.content.ContentResolver;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Point;
import android.os.Bundle;
import android.provider.Settings;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnPreparedListener;
import android.net.Uri;
import android.os.Bundle;
import android.provider.Settings;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;
import android.support.v7.preference.PreferenceViewHolder;
import android.view.Display;
import android.view.ViewTreeObserver;
import android.view.ViewTreeObserver.OnGlobalLayoutListener;
import android.view.WindowManager;
import android.widget.ImageView;
import android.widget.MediaController;
import android.widget.RelativeLayout.LayoutParams;
import android.widget.Switch;
import android.widget.VideoView;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.settings.R;
import com.android.settings.widget.ToggleSwitch;
import com.android.settings.widget.ToggleSwitch.OnBeforeCheckedChangeListener;
import com.android.settings.widget.SwitchBar;
public class ToggleScreenMagnificationPreferenceFragment extends ToggleFeaturePreferenceFragment {
public class ToggleScreenMagnificationPreferenceFragment extends
ToggleFeaturePreferenceFragment implements SwitchBar.OnSwitchChangeListener {
protected class VideoPreference extends Preference {
private ImageView mVideoBackgroundView;
@@ -77,10 +76,15 @@ public class ToggleScreenMagnificationPreferenceFragment extends ToggleFeaturePr
}
});
videoView.setVideoURI(Uri.parse(String.format("%s://%s/%s",
ContentResolver.SCHEME_ANDROID_RESOURCE,
getPrefContext().getPackageName(),
R.raw.accessibility_screen_magnification)));
// Resolve and set the video content
Bundle args = getArguments();
if ((args != null) && args.containsKey(
AccessibilitySettings.EXTRA_VIDEO_RAW_RESOURCE_ID)) {
videoView.setVideoURI(Uri.parse(String.format("%s://%s/%s",
ContentResolver.SCHEME_ANDROID_RESOURCE,
getPrefContext().getPackageName(),
args.getInt(AccessibilitySettings.EXTRA_VIDEO_RAW_RESOURCE_ID))));
}
// Make sure video controls (e.g. for pausing) are not displayed.
videoView.setMediaController(null);
@@ -112,6 +116,10 @@ public class ToggleScreenMagnificationPreferenceFragment extends ToggleFeaturePr
}
protected VideoPreference mVideoPreference;
protected Preference mConfigWarningPreference;
private boolean mLaunchFromSuw = false;
private boolean mInitialSetting = false;
@Override
public void onCreate(Bundle savedInstanceState) {
@@ -122,66 +130,100 @@ public class ToggleScreenMagnificationPreferenceFragment extends ToggleFeaturePr
mVideoPreference.setPersistent(false);
mVideoPreference.setLayoutResource(R.layout.magnification_video_preference);
mConfigWarningPreference = new Preference(getPrefContext());
mConfigWarningPreference.setSelectable(false);
mConfigWarningPreference.setPersistent(false);
mConfigWarningPreference.setVisible(false);
mConfigWarningPreference.setIcon(R.drawable.ic_warning_24dp);
final PreferenceScreen preferenceScreen = getPreferenceManager().getPreferenceScreen();
preferenceScreen.setOrderingAsAdded(false);
mVideoPreference.setOrder(0);
mSummaryPreference.setOrder(1);
mConfigWarningPreference.setOrder(2);
preferenceScreen.addPreference(mVideoPreference);
}
@Override
protected void onPreferenceToggled(String preferenceKey, boolean enabled) {
// Do nothing.
}
@Override
protected void onInstallSwitchBarToggleSwitch() {
super.onInstallSwitchBarToggleSwitch();
mToggleSwitch.setOnBeforeCheckedChangeListener(new OnBeforeCheckedChangeListener() {
@Override
public boolean onBeforeCheckedChanged(ToggleSwitch toggleSwitch, boolean checked) {
mSwitchBar.setCheckedInternal(checked);
getArguments().putBoolean(AccessibilitySettings.EXTRA_CHECKED, checked);
onPreferenceToggled(mPreferenceKey, checked);
return false;
}
});
preferenceScreen.addPreference(mConfigWarningPreference);
}
@Override
public void onResume() {
super.onResume();
// Temporarily enable Magnification on this screen if it's disabled.
if (Settings.Secure.getInt(getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 0) == 0) {
setMagnificationEnabled(1);
}
VideoView videoView = (VideoView) getView().findViewById(R.id.video);
if (videoView != null) {
videoView.start();
}
}
@Override
public void onPause() {
super.onPause();
if (!mToggleSwitch.isChecked()) {
setMagnificationEnabled(0);
}
}
private void setMagnificationEnabled(int enabled) {
Settings.Secure.putInt(getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, enabled);
updateConfigurationWarningIfNeeded();
}
@Override
public int getMetricsCategory() {
// TODO: Distinguish between magnification modes
return MetricsEvent.ACCESSIBILITY_TOGGLE_SCREEN_MAGNIFICATION;
}
@Override
public void onSwitchChanged(Switch switchView, boolean isChecked) {
onPreferenceToggled(mPreferenceKey, isChecked);
}
@Override
protected void onPreferenceToggled(String preferenceKey, boolean enabled) {
Settings.Secure.putInt(getContentResolver(), preferenceKey, enabled ? 1 : 0);
updateConfigurationWarningIfNeeded();
}
@Override
protected void onInstallSwitchBarToggleSwitch() {
super.onInstallSwitchBarToggleSwitch();
mSwitchBar.setCheckedInternal(
Settings.Secure.getInt(getContentResolver(), mPreferenceKey, 0) == 1);
mSwitchBar.addOnSwitchChangeListener(this);
}
@Override
protected void onRemoveSwitchBarToggleSwitch() {
super.onRemoveSwitchBarToggleSwitch();
mSwitchBar.removeOnSwitchChangeListener(this);
}
@Override
protected void onProcessArguments(Bundle arguments) {
super.onProcessArguments(arguments);
if (arguments == null) {
return;
}
if (arguments.containsKey(AccessibilitySettings.EXTRA_VIDEO_RAW_RESOURCE_ID)) {
mVideoPreference.setVisible(true);
final int resId = arguments.getInt(
AccessibilitySettings.EXTRA_VIDEO_RAW_RESOURCE_ID);
} else {
mVideoPreference.setVisible(false);
}
if (arguments.containsKey(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW)) {
mLaunchFromSuw = arguments.getBoolean(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW);
}
if (arguments.containsKey(AccessibilitySettings.EXTRA_CHECKED)) {
mInitialSetting = arguments.getBoolean(AccessibilitySettings.EXTRA_CHECKED);
}
}
private void updateConfigurationWarningIfNeeded() {
final int warningRes =
MagnificationPreferenceFragment
.getConfigurationWarningStringResourceForSecureSettingsKey(
mPreferenceKey, getContentResolver());
if (warningRes != -1) {
mConfigWarningPreference.setSummary(warningRes);
}
mConfigWarningPreference.setVisible(warningRes != -1);
}
private static int getScreenWidth(Context context) {
WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
Display display = wm.getDefaultDisplay();

21
src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragmentForSetupWizard.java
View File

@@ -24,14 +24,6 @@ import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
public class ToggleScreenMagnificationPreferenceFragmentForSetupWizard
extends ToggleScreenMagnificationPreferenceFragment {
private boolean mToggleSwitchWasInitiallyChecked;
@Override
protected void onProcessArguments(Bundle arguments) {
super.onProcessArguments(arguments);
mToggleSwitchWasInitiallyChecked = mToggleSwitch.isChecked();
}
@Override
public int getMetricsCategory() {
return MetricsEvent.SUW_ACCESSIBILITY_TOGGLE_SCREEN_MAGNIFICATION;
@@ -40,12 +32,15 @@ public class ToggleScreenMagnificationPreferenceFragmentForSetupWizard
@Override
public void onStop() {
// Log the final choice in value if it's different from the previous value.
if (mToggleSwitch.isChecked() != mToggleSwitchWasInitiallyChecked) {
mMetricsFeatureProvider.action(getContext(),
MetricsEvent.SUW_ACCESSIBILITY_TOGGLE_SCREEN_MAGNIFICATION,
mToggleSwitch.isChecked());
Bundle args = getArguments();
if ((args != null) && args.containsKey(AccessibilitySettings.EXTRA_CHECKED)) {
if (mToggleSwitch.isChecked() != args.getBoolean(AccessibilitySettings.EXTRA_CHECKED)) {
// TODO: Distinguish between magnification modes
mMetricsFeatureProvider.action(getContext(),
MetricsEvent.SUW_ACCESSIBILITY_TOGGLE_SCREEN_MAGNIFICATION,
mToggleSwitch.isChecked());
}
}
super.onStop();
}
}