Home | History | Annotate | Download | only in accessibility 
      1 /*
      2  * Copyright (C) 2013 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.settings.accessibility;
     18 
     19 import android.content.ContentResolver;
     20 import android.content.Context;
     21 import android.content.res.Resources;
     22 import android.graphics.Point;
     23 import android.media.AudioManager;
     24 import android.media.MediaPlayer;
     25 import android.media.MediaPlayer.OnPreparedListener;
     26 import android.net.Uri;
     27 import android.os.Bundle;
     28 import android.provider.Settings;
     29 import android.support.v7.preference.Preference;
     30 import android.support.v7.preference.PreferenceScreen;
     31 import android.support.v7.preference.PreferenceViewHolder;
     32 import android.view.Display;
     33 import android.view.ViewTreeObserver.OnGlobalLayoutListener;
     34 import android.view.WindowManager;
     35 import android.widget.ImageView;
     36 import android.widget.RelativeLayout.LayoutParams;
     37 import android.widget.Switch;
     38 import android.widget.VideoView;
     39 
     40 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
     41 import com.android.settings.R;
     42 import com.android.settings.widget.SwitchBar;
     43 
     44 public class ToggleScreenMagnificationPreferenceFragment extends
     45         ToggleFeaturePreferenceFragment implements SwitchBar.OnSwitchChangeListener {
     46 
     47     protected class VideoPreference extends Preference {
     48         private ImageView mVideoBackgroundView;
     49         private OnGlobalLayoutListener mLayoutListener;
     50 
     51         public VideoPreference(Context context) {
     52             super(context);
     53         }
     54 
     55         @Override
     56         public void onBindViewHolder(PreferenceViewHolder view) {
     57             super.onBindViewHolder(view);
     58             Resources res = getPrefContext().getResources();
     59             final int backgroundAssetWidth = res.getDimensionPixelSize(
     60                     R.dimen.screen_magnification_video_background_width);
     61             final int videoAssetWidth = res
     62                     .getDimensionPixelSize(R.dimen.screen_magnification_video_width);
     63             final int videoAssetHeight = res
     64                     .getDimensionPixelSize(R.dimen.screen_magnification_video_height);
     65             final int videoAssetMarginTop = res.getDimensionPixelSize(
     66                     R.dimen.screen_magnification_video_margin_top);
     67             view.setDividerAllowedAbove(false);
     68             view.setDividerAllowedBelow(false);
     69             mVideoBackgroundView = (ImageView) view.findViewById(R.id.video_background);
     70             final VideoView videoView = (VideoView) view.findViewById(R.id.video);
     71 
     72             // Loop the video.
     73             videoView.setOnPreparedListener(new OnPreparedListener() {
     74                 @Override
     75                 public void onPrepared(MediaPlayer mediaPlayer) {
     76                     mediaPlayer.setLooping(true);
     77                 }
     78             });
     79 
     80             // Make sure the VideoView does not request audio focus.
     81             videoView.setAudioFocusRequest(AudioManager.AUDIOFOCUS_NONE);
     82 
     83             // Resolve and set the video content
     84             Bundle args = getArguments();
     85             if ((args != null) && args.containsKey(
     86                     AccessibilitySettings.EXTRA_VIDEO_RAW_RESOURCE_ID)) {
     87                 videoView.setVideoURI(Uri.parse(String.format("%s://%s/%s",
     88                         ContentResolver.SCHEME_ANDROID_RESOURCE,
     89                         getPrefContext().getPackageName(),
     90                         args.getInt(AccessibilitySettings.EXTRA_VIDEO_RAW_RESOURCE_ID))));
     91             }
     92 
     93             // Make sure video controls (e.g. for pausing) are not displayed.
     94             videoView.setMediaController(null);
     95 
     96             // LayoutListener for adjusting the position of the VideoView on the background image.
     97             mLayoutListener = new OnGlobalLayoutListener() {
     98                 @Override
     99                 public void onGlobalLayout() {
    100                     final int backgroundViewWidth = mVideoBackgroundView.getWidth();
    101 
    102                     LayoutParams videoLp = (LayoutParams) videoView.getLayoutParams();
    103                     videoLp.width = videoAssetWidth * backgroundViewWidth / backgroundAssetWidth;
    104                     videoLp.height = videoAssetHeight * backgroundViewWidth / backgroundAssetWidth;
    105                     videoLp.setMargins(0,
    106                             videoAssetMarginTop * backgroundViewWidth / backgroundAssetWidth, 0, 0);
    107                     videoView.setLayoutParams(videoLp);
    108                     videoView.invalidate();
    109                     videoView.start();
    110                     mVideoBackgroundView.getViewTreeObserver()
    111                             .removeOnGlobalLayoutListener(mLayoutListener);
    112                 }
    113             };
    114 
    115             mVideoBackgroundView.getViewTreeObserver().addOnGlobalLayoutListener(mLayoutListener);
    116         }
    117 
    118         @Override
    119         protected void onPrepareForRemoval() {
    120             mVideoBackgroundView.getViewTreeObserver()
    121                     .removeOnGlobalLayoutListener(mLayoutListener);
    122         }
    123     }
    124 
    125     protected VideoPreference mVideoPreference;
    126     protected Preference mConfigWarningPreference;
    127 
    128     private boolean mLaunchFromSuw = false;
    129     private boolean mInitialSetting = false;
    130 
    131     @Override
    132     public void onCreate(Bundle savedInstanceState) {
    133         super.onCreate(savedInstanceState);
    134 
    135         mVideoPreference = new VideoPreference(getPrefContext());
    136         mVideoPreference.setSelectable(false);
    137         mVideoPreference.setPersistent(false);
    138         mVideoPreference.setLayoutResource(R.layout.magnification_video_preference);
    139 
    140         mConfigWarningPreference = new Preference(getPrefContext());
    141         mConfigWarningPreference.setSelectable(false);
    142         mConfigWarningPreference.setPersistent(false);
    143         mConfigWarningPreference.setVisible(false);
    144         mConfigWarningPreference.setIcon(R.drawable.ic_warning_24dp);
    145 
    146         final PreferenceScreen preferenceScreen = getPreferenceManager().getPreferenceScreen();
    147         preferenceScreen.setOrderingAsAdded(false);
    148         mVideoPreference.setOrder(0);
    149         mConfigWarningPreference.setOrder(2);
    150         preferenceScreen.addPreference(mVideoPreference);
    151         preferenceScreen.addPreference(mConfigWarningPreference);
    152     }
    153 
    154     @Override
    155     public void onResume() {
    156         super.onResume();
    157 
    158         VideoView videoView = (VideoView) getView().findViewById(R.id.video);
    159         if (videoView != null) {
    160             videoView.start();
    161         }
    162 
    163         updateConfigurationWarningIfNeeded();
    164     }
    165 
    166     @Override
    167     public int getMetricsCategory() {
    168         // TODO: Distinguish between magnification modes
    169         return MetricsEvent.ACCESSIBILITY_TOGGLE_SCREEN_MAGNIFICATION;
    170     }
    171 
    172     @Override
    173     public void onSwitchChanged(Switch switchView, boolean isChecked) {
    174         onPreferenceToggled(mPreferenceKey, isChecked);
    175     }
    176 
    177     @Override
    178     protected void onPreferenceToggled(String preferenceKey, boolean enabled) {
    179         Settings.Secure.putInt(getContentResolver(), preferenceKey, enabled ? 1 : 0);
    180         updateConfigurationWarningIfNeeded();
    181     }
    182 
    183     @Override
    184     protected void onInstallSwitchBarToggleSwitch() {
    185         super.onInstallSwitchBarToggleSwitch();
    186 
    187         mSwitchBar.setCheckedInternal(
    188                 Settings.Secure.getInt(getContentResolver(), mPreferenceKey, 0) == 1);
    189         mSwitchBar.addOnSwitchChangeListener(this);
    190     }
    191 
    192     @Override
    193     protected void onRemoveSwitchBarToggleSwitch() {
    194         super.onRemoveSwitchBarToggleSwitch();
    195         mSwitchBar.removeOnSwitchChangeListener(this);
    196     }
    197 
    198     @Override
    199     protected void onProcessArguments(Bundle arguments) {
    200         super.onProcessArguments(arguments);
    201         if (arguments == null) {
    202             return;
    203         }
    204 
    205         if (arguments.containsKey(AccessibilitySettings.EXTRA_VIDEO_RAW_RESOURCE_ID)) {
    206             mVideoPreference.setVisible(true);
    207             final int resId = arguments.getInt(
    208                     AccessibilitySettings.EXTRA_VIDEO_RAW_RESOURCE_ID);
    209         } else {
    210             mVideoPreference.setVisible(false);
    211         }
    212 
    213         if (arguments.containsKey(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW)) {
    214             mLaunchFromSuw = arguments.getBoolean(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW);
    215         }
    216 
    217         if (arguments.containsKey(AccessibilitySettings.EXTRA_CHECKED)) {
    218             mInitialSetting = arguments.getBoolean(AccessibilitySettings.EXTRA_CHECKED);
    219         }
    220     }
    221 
    222     private void updateConfigurationWarningIfNeeded() {
    223         final CharSequence warningMessage =
    224                 MagnificationPreferenceFragment.getConfigurationWarningStringForSecureSettingsKey(
    225                         mPreferenceKey, getPrefContext());
    226         if (warningMessage != null) {
    227             mConfigWarningPreference.setSummary(warningMessage);
    228         }
    229         mConfigWarningPreference.setVisible(warningMessage != null);
    230     }
    231 
    232     private static int getScreenWidth(Context context) {
    233         WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    234         Display display = wm.getDefaultDisplay();
    235         Point size = new Point();
    236         display.getSize(size);
    237         return size.x;
    238     }
    239 }
    240