1 /* 2 * Copyright (C) 2007 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 android.preference; 18 19 import java.util.ArrayList; 20 import java.util.Collections; 21 import java.util.List; 22 23 import android.os.Handler; 24 import android.preference.Preference.OnPreferenceChangeInternalListener; 25 import android.view.View; 26 import android.view.ViewGroup; 27 import android.widget.Adapter; 28 import android.widget.BaseAdapter; 29 import android.widget.ListView; 30 31 /** 32 * An adapter that returns the {@link Preference} contained in this group. 33 * In most cases, this adapter should be the base class for any custom 34 * adapters from {@link Preference#getAdapter()}. 35 * <p> 36 * This adapter obeys the 37 * {@link Preference}'s adapter rule (the 38 * {@link Adapter#getView(int, View, ViewGroup)} should be used instead of 39 * {@link Preference#getView(ViewGroup)} if a {@link Preference} has an 40 * adapter via {@link Preference#getAdapter()}). 41 * <p> 42 * This adapter also propagates data change/invalidated notifications upward. 43 * <p> 44 * This adapter does not include this {@link PreferenceGroup} in the returned 45 * adapter, use {@link PreferenceCategoryAdapter} instead. 46 * 47 * @see PreferenceCategoryAdapter 48 */ 49 class PreferenceGroupAdapter extends BaseAdapter implements OnPreferenceChangeInternalListener { 50 51 private static final String TAG = "PreferenceGroupAdapter"; 52 53 /** 54 * The group that we are providing data from. 55 */ 56 private PreferenceGroup mPreferenceGroup; 57 58 /** 59 * Maps a position into this adapter -> {@link Preference}. These 60 * {@link Preference}s don't have to be direct children of this 61 * {@link PreferenceGroup}, they can be grand children or younger) 62 */ 63 private List<Preference> mPreferenceList; 64 65 /** 66 * List of unique Preference and its subclasses' names. This is used to find 67 * out how many types of views this adapter can return. Once the count is 68 * returned, this cannot be modified (since the ListView only checks the 69 * count once--when the adapter is being set). We will not recycle views for 70 * Preference subclasses seen after the count has been returned. 71 */ 72 private ArrayList<PreferenceLayout> mPreferenceLayouts; 73 74 private PreferenceLayout mTempPreferenceLayout = new PreferenceLayout(); 75 76 /** 77 * Blocks the mPreferenceClassNames from being changed anymore. 78 */ 79 private boolean mHasReturnedViewTypeCount = false; 80 81 private volatile boolean mIsSyncing = false; 82 83 private Handler mHandler = new Handler(); 84 85 private Runnable mSyncRunnable = new Runnable() { 86 public void run() { 87 syncMyPreferences(); 88 } 89 }; 90 91 private static class PreferenceLayout implements Comparable<PreferenceLayout> { 92 private int resId; 93 private int widgetResId; 94 private String name; 95 96 public int compareTo(PreferenceLayout other) { 97 int compareNames = name.compareTo(other.name); 98 if (compareNames == 0) { 99 if (resId == other.resId) { 100 if (widgetResId == other.widgetResId) { 101 return 0; 102 } else { 103 return widgetResId - other.widgetResId; 104 } 105 } else { 106 return resId - other.resId; 107 } 108 } else { 109 return compareNames; 110 } 111 } 112 } 113 114 public PreferenceGroupAdapter(PreferenceGroup preferenceGroup) { 115 mPreferenceGroup = preferenceGroup; 116 // If this group gets or loses any children, let us know 117 mPreferenceGroup.setOnPreferenceChangeInternalListener(this); 118 119 mPreferenceList = new ArrayList<Preference>(); 120 mPreferenceLayouts = new ArrayList<PreferenceLayout>(); 121 122 syncMyPreferences(); 123 } 124 125 private void syncMyPreferences() { 126 synchronized(this) { 127 if (mIsSyncing) { 128 return; 129 } 130 131 mIsSyncing = true; 132 } 133 134 List<Preference> newPreferenceList = new ArrayList<Preference>(mPreferenceList.size()); 135 flattenPreferenceGroup(newPreferenceList, mPreferenceGroup); 136 mPreferenceList = newPreferenceList; 137 138 notifyDataSetChanged(); 139 140 synchronized(this) { 141 mIsSyncing = false; 142 notifyAll(); 143 } 144 } 145 146 private void flattenPreferenceGroup(List<Preference> preferences, PreferenceGroup group) { 147 // TODO: shouldn't always? 148 group.sortPreferences(); 149 150 final int groupSize = group.getPreferenceCount(); 151 for (int i = 0; i < groupSize; i++) { 152 final Preference preference = group.getPreference(i); 153 154 preferences.add(preference); 155 156 if (!mHasReturnedViewTypeCount && preference.canRecycleLayout()) { 157 addPreferenceClassName(preference); 158 } 159 160 if (preference instanceof PreferenceGroup) { 161 final PreferenceGroup preferenceAsGroup = (PreferenceGroup) preference; 162 if (preferenceAsGroup.isOnSameScreenAsChildren()) { 163 flattenPreferenceGroup(preferences, preferenceAsGroup); 164 } 165 } 166 167 preference.setOnPreferenceChangeInternalListener(this); 168 } 169 } 170 171 /** 172 * Creates a string that includes the preference name, layout id and widget layout id. 173 * If a particular preference type uses 2 different resources, they will be treated as 174 * different view types. 175 */ 176 private PreferenceLayout createPreferenceLayout(Preference preference, PreferenceLayout in) { 177 PreferenceLayout pl = in != null? in : new PreferenceLayout(); 178 pl.name = preference.getClass().getName(); 179 pl.resId = preference.getLayoutResource(); 180 pl.widgetResId = preference.getWidgetLayoutResource(); 181 return pl; 182 } 183 184 private void addPreferenceClassName(Preference preference) { 185 final PreferenceLayout pl = createPreferenceLayout(preference, null); 186 int insertPos = Collections.binarySearch(mPreferenceLayouts, pl); 187 188 // Only insert if it doesn't exist (when it is negative). 189 if (insertPos < 0) { 190 // Convert to insert index 191 insertPos = insertPos * -1 - 1; 192 mPreferenceLayouts.add(insertPos, pl); 193 } 194 } 195 196 public int getCount() { 197 return mPreferenceList.size(); 198 } 199 200 public Preference getItem(int position) { 201 if (position < 0 || position >= getCount()) return null; 202 return mPreferenceList.get(position); 203 } 204 205 public long getItemId(int position) { 206 if (position < 0 || position >= getCount()) return ListView.INVALID_ROW_ID; 207 return this.getItem(position).getId(); 208 } 209 210 public View getView(int position, View convertView, ViewGroup parent) { 211 final Preference preference = this.getItem(position); 212 // Build a PreferenceLayout to compare with known ones that are cacheable. 213 mTempPreferenceLayout = createPreferenceLayout(preference, mTempPreferenceLayout); 214 215 // If it's not one of the cached ones, set the convertView to null so that 216 // the layout gets re-created by the Preference. 217 if (Collections.binarySearch(mPreferenceLayouts, mTempPreferenceLayout) < 0) { 218 convertView = null; 219 } 220 221 return preference.getView(convertView, parent); 222 } 223 224 @Override 225 public boolean isEnabled(int position) { 226 if (position < 0 || position >= getCount()) return true; 227 return this.getItem(position).isSelectable(); 228 } 229 230 @Override 231 public boolean areAllItemsEnabled() { 232 // There should always be a preference group, and these groups are always 233 // disabled 234 return false; 235 } 236 237 public void onPreferenceChange(Preference preference) { 238 notifyDataSetChanged(); 239 } 240 241 public void onPreferenceHierarchyChange(Preference preference) { 242 mHandler.removeCallbacks(mSyncRunnable); 243 mHandler.post(mSyncRunnable); 244 } 245 246 @Override 247 public boolean hasStableIds() { 248 return true; 249 } 250 251 @Override 252 public int getItemViewType(int position) { 253 if (!mHasReturnedViewTypeCount) { 254 mHasReturnedViewTypeCount = true; 255 } 256 257 final Preference preference = this.getItem(position); 258 if (!preference.canRecycleLayout()) { 259 return IGNORE_ITEM_VIEW_TYPE; 260 } 261 262 mTempPreferenceLayout = createPreferenceLayout(preference, mTempPreferenceLayout); 263 264 int viewType = Collections.binarySearch(mPreferenceLayouts, mTempPreferenceLayout); 265 if (viewType < 0) { 266 // This is a class that was seen after we returned the count, so 267 // don't recycle it. 268 return IGNORE_ITEM_VIEW_TYPE; 269 } else { 270 return viewType; 271 } 272 } 273 274 @Override 275 public int getViewTypeCount() { 276 if (!mHasReturnedViewTypeCount) { 277 mHasReturnedViewTypeCount = true; 278 } 279 280 return Math.max(1, mPreferenceLayouts.size()); 281 } 282 283 } 284