src/com/android/settings/RestrictedListPreference.java

   1 /*
   2  * Copyright (C) 2016 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;
  18
  19 import android.app.AlertDialog;
  20 import android.content.Context;
  21 import android.content.DialogInterface;
  22 import android.os.Bundle;
  23 import android.support.v14.preference.ListPreferenceDialogFragment;
  24 import android.support.v7.preference.PreferenceViewHolder;
  25 import android.util.AttributeSet;
  26 import android.view.View;
  27 import android.view.ViewGroup;
  28 import android.widget.AdapterView;
  29 import android.widget.ArrayAdapter;
  30 import android.widget.CheckedTextView;
  31 import android.widget.ImageView;
  32 import android.widget.ListAdapter;
  33 import android.widget.ListView;
  34
  35 import com.android.settingslib.RestrictedLockUtils;
  36 import com.android.settingslib.RestrictedPreferenceHelper;
  37
  38 import java.util.ArrayList;
  39 import java.util.List;
  40
  41 import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;
  42
  43 public class RestrictedListPreference extends CustomListPreference {
  44     private final RestrictedPreferenceHelper mHelper;
  45     private final List<RestrictedItem> mRestrictedItems = new ArrayList<>();
  46
  47     public RestrictedListPreference(Context context, AttributeSet attrs) {
  48         super(context, attrs);
  49         setWidgetLayoutResource(R.layout.restricted_icon);
  50         mHelper = new RestrictedPreferenceHelper(context, this, attrs);
  51     }
  52
  53     public RestrictedListPreference(Context context, AttributeSet attrs,
  54             int defStyleAttr, int defStyleRes) {
  55         super(context, attrs, defStyleAttr, defStyleRes);
  56         mHelper = new RestrictedPreferenceHelper(context, this, attrs);
  57     }
  58
  59     @Override
  60     public void onBindViewHolder(PreferenceViewHolder holder) {
  61         super.onBindViewHolder(holder);
  62         mHelper.onBindViewHolder(holder);
  63         final View restrictedIcon = holder.findViewById(R.id.restricted_icon);
  64         if (restrictedIcon != null) {
  65             restrictedIcon.setVisibility(isDisabledByAdmin() ? View.VISIBLE : View.GONE);
  66         }
  67     }
  68
  69     @Override
  70     public void performClick() {
  71         if (!mHelper.performClick()) {
  72             super.performClick();
  73         }
  74     }
  75
  76     @Override
  77     public void setEnabled(boolean enabled) {
  78         if (enabled && isDisabledByAdmin()) {
  79             mHelper.setDisabledByAdmin(null);
  80             return;
  81         }
  82         super.setEnabled(enabled);
  83     }
  84
  85     public void setDisabledByAdmin(EnforcedAdmin admin) {
  86         if (mHelper.setDisabledByAdmin(admin)) {
  87             notifyChanged();
  88         }
  89     }
  90
  91     public boolean isDisabledByAdmin() {
  92         return mHelper.isDisabledByAdmin();
  93     }
  94
  95     public boolean isRestrictedForEntry(CharSequence entry) {
  96         if (entry == null) {
  97             return false;
  98         }
  99         for (RestrictedItem item : mRestrictedItems) {
 100             if (entry.equals(item.entry)) {
 101                 return true;
 102             }
 103         }
 104         return false;
 105     }
 106
 107     public void addRestrictedItem(RestrictedItem item) {
 108         mRestrictedItems.add(item);
 109     }
 110
 111     public void clearRestrictedItems() {
 112         mRestrictedItems.clear();
 113     }
 114
 115     private RestrictedItem getRestrictedItemForEntryValue(CharSequence entryValue) {
 116         if (entryValue == null) {
 117             return null;
 118         }
 119         for (RestrictedItem item : mRestrictedItems) {
 120             if (entryValue.equals(item.entryValue)) {
 121                 return item;
 122             }
 123         }
 124         return null;
 125     }
 126
 127     protected ListAdapter createListAdapter() {
 128         return new RestrictedArrayAdapter(getContext(), getEntries(),
 129                 getSelectedValuePos());
 130     }
 131
 132     public int getSelectedValuePos() {
 133         final String selectedValue = getValue();
 134         final int selectedIndex =
 135                 (selectedValue == null) ? -1 : findIndexOfValue(selectedValue);
 136         return selectedIndex;
 137     }
 138
 139     @Override
 140     protected void onPrepareDialogBuilder(AlertDialog.Builder builder,
 141             DialogInterface.OnClickListener listener) {
 142         builder.setAdapter(createListAdapter(), listener);
 143     }
 144
 145
 146     public class RestrictedArrayAdapter extends ArrayAdapter<CharSequence> {
 147         private final int mSelectedIndex;
 148         public RestrictedArrayAdapter(Context context, CharSequence[] objects, int selectedIndex) {
 149             super(context, R.layout.restricted_dialog_singlechoice, R.id.text1, objects);
 150             mSelectedIndex = selectedIndex;
 151         }
 152
 153         @Override
 154         public View getView(int position, View convertView, ViewGroup parent) {
 155             View root = super.getView(position, convertView, parent);
 156             CharSequence entry = getItem(position);
 157             CheckedTextView text = (CheckedTextView) root.findViewById(R.id.text1);
 158             ImageView padlock = (ImageView) root.findViewById(R.id.restricted_lock_icon);
 159             if (isRestrictedForEntry(entry)) {
 160                 text.setEnabled(false);
 161                 text.setChecked(false);
 162                 padlock.setVisibility(View.VISIBLE);
 163             } else {
 164                 if (mSelectedIndex != -1) {
 165                     text.setChecked(position == mSelectedIndex);
 166                 }
 167                 if (!text.isEnabled()) {
 168                     text.setEnabled(true);
 169                 }
 170                 padlock.setVisibility(View.GONE);
 171             }
 172             return root;
 173         }
 174
 175         @Override
 176         public boolean hasStableIds() {
 177             return true;
 178         }
 179
 180         @Override
 181         public long getItemId(int position) {
 182             return position;
 183         }
 184     }
 185
 186     public static class RestrictedListPreferenceDialogFragment extends
 187             CustomListPreference.CustomListPreferenceDialogFragment {
 188         private int mLastCheckedPosition = AdapterView.INVALID_POSITION;
 189
 190         public static ListPreferenceDialogFragment newInstance(String key) {
 191             final ListPreferenceDialogFragment fragment
 192                     = new RestrictedListPreferenceDialogFragment();
 193             final Bundle b = new Bundle(1);
 194             b.putString(ARG_KEY, key);
 195             fragment.setArguments(b);
 196             return fragment;
 197         }
 198
 199         private RestrictedListPreference getCustomizablePreference() {
 200             return (RestrictedListPreference) getPreference();
 201         }
 202
 203         @Override
 204         protected DialogInterface.OnClickListener getOnItemClickListener() {
 205             return new DialogInterface.OnClickListener() {
 206                 public void onClick(DialogInterface dialog, int which) {
 207                     final RestrictedListPreference preference = getCustomizablePreference();
 208                     if (which < 0 || which >= preference.getEntryValues().length) {
 209                         return;
 210                     }
 211                     String entryValue = preference.getEntryValues()[which].toString();
 212                     RestrictedItem item = preference.getRestrictedItemForEntryValue(entryValue);
 213                     if (item != null) {
 214                         ListView listView = ((AlertDialog) dialog).getListView();
 215                         listView.setItemChecked(getLastCheckedPosition(), true);
 216                         RestrictedLockUtils.sendShowAdminSupportDetailsIntent(getContext(),
 217                                 item.enforcedAdmin);
 218                     } else {
 219                         setClickedDialogEntryIndex(which);
 220                     }
 221
 222                     if (getCustomizablePreference().isAutoClosePreference()) {
 223                         /*
 224                          * Clicking on an item simulates the positive button
 225                          * click, and dismisses the dialog.
 226                          */
 227                         RestrictedListPreferenceDialogFragment.this.onClick(dialog,
 228                                 DialogInterface.BUTTON_POSITIVE);
 229                         dialog.dismiss();
 230                     }
 231                 }
 232             };
 233         }
 234
 235         private int getLastCheckedPosition() {
 236             if (mLastCheckedPosition == AdapterView.INVALID_POSITION) {
 237                 mLastCheckedPosition = ((RestrictedListPreference) getCustomizablePreference())
 238                         .getSelectedValuePos();
 239             }
 240             return mLastCheckedPosition;
 241         }
 242
 243         private void setCheckedPosition(int checkedPosition) {
 244             mLastCheckedPosition = checkedPosition;
 245         }
 246
 247         @Override
 248         protected void setClickedDialogEntryIndex(int which) {
 249             super.setClickedDialogEntryIndex(which);
 250             mLastCheckedPosition = which;
 251         }
 252     }
 253
 254     public static class RestrictedItem {
 255         public final CharSequence entry;
 256         public final CharSequence entryValue;
 257         public final EnforcedAdmin enforcedAdmin;
 258
 259         public RestrictedItem(CharSequence entry, CharSequence entryValue,
 260                 EnforcedAdmin enforcedAdmin) {
 261             this.entry = entry;
 262             this.entryValue = entryValue;
 263             this.enforcedAdmin = enforcedAdmin;
 264         }
 265     }
 266 }