Picker.java revision 0f96ae4965103bade4bebe7776b2ee35cd603112
1/* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except 5 * in compliance with the License. You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software distributed under the License 10 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express 11 * or implied. See the License for the specific language governing permissions and limitations under 12 * the License. 13 */ 14 15package android.support.v17.leanback.widget.picker; 16 17import android.content.Context; 18import android.graphics.Rect; 19import android.support.v17.leanback.R; 20import android.support.v17.leanback.widget.OnChildViewHolderSelectedListener; 21import android.support.v17.leanback.widget.VerticalGridView; 22import android.support.v7.widget.RecyclerView; 23import android.util.AttributeSet; 24import android.util.TypedValue; 25import android.view.KeyEvent; 26import android.view.LayoutInflater; 27import android.view.View; 28import android.view.ViewGroup; 29import android.view.animation.AccelerateInterpolator; 30import android.view.animation.DecelerateInterpolator; 31import android.view.animation.Interpolator; 32import android.widget.FrameLayout; 33import android.widget.TextView; 34 35import java.util.ArrayList; 36import java.util.List; 37 38/** 39 * Picker is a widget showing multiple customized {@link PickerColumn}s. The PickerColumns are 40 * initialized in {@link #setColumns(List)}. Call {@link #setColumnAt(int, PickerColumn)} if the 41 * column value range or labels change. Call {@link #setColumnValue(int, int, boolean)} to update 42 * the current value of PickerColumn. 43 * <p> 44 * Picker has two states and will change height: 45 * <li>{@link #isActivated()} is true: Picker shows typically three items vertically (see 46 * {@link #getActivatedVisibleItemCount()}}. Columns other than {@link #getSelectedColumn()} still 47 * shows one item if the Picker is focused. On a touch screen device, the Picker will not get focus 48 * so it always show three items on all columns. On a non-touch device (a TV), the Picker will show 49 * three items only on currently activated column. If the Picker has focus, it will intercept DPAD 50 * directions and select activated column. 51 * <li>{@link #isActivated()} is false: Picker shows one item vertically (see 52 * {@link #getVisibleItemCount()}) on all columns. The size of Picker shrinks. 53 */ 54public class Picker extends FrameLayout { 55 56 public interface PickerValueListener { 57 public void onValueChanged(Picker picker, int column); 58 } 59 60 private ViewGroup mRootView; 61 private ViewGroup mPickerView; 62 private final List<VerticalGridView> mColumnViews = new ArrayList<VerticalGridView>(); 63 private ArrayList<PickerColumn> mColumns; 64 65 private float mUnfocusedAlpha; 66 private float mFocusedAlpha; 67 private float mVisibleColumnAlpha; 68 private float mInvisibleColumnAlpha; 69 private int mAlphaAnimDuration; 70 private Interpolator mDecelerateInterpolator; 71 private Interpolator mAccelerateInterpolator; 72 private ArrayList<PickerValueListener> mListeners; 73 private float mVisibleItemsActivated = 3; 74 private float mVisibleItems = 1; 75 private int mSelectedColumn = 0; 76 77 private CharSequence mSeparator; 78 private int mPickerItemLayoutId = R.layout.lb_picker_item; 79 private int mPickerItemTextViewId = 0; 80 81 /** 82 * Gets separator string between columns. 83 */ 84 public final CharSequence getSeparator() { 85 return mSeparator; 86 } 87 88 /** 89 * Sets separator String between Picker columns. 90 * @param seperator Separator String between Picker columns. 91 */ 92 public final void setSeparator(CharSequence seperator) { 93 mSeparator = seperator; 94 } 95 96 /** 97 * Classes extending {@link Picker} can choose to override this method to 98 * supply the {@link Picker}'s item's layout id 99 */ 100 public final int getPickerItemLayoutId() { 101 return mPickerItemLayoutId; 102 } 103 104 /** 105 * Returns the {@link Picker}'s item's {@link TextView}'s id from within the 106 * layout provided by {@link Picker#getPickerItemLayoutId()} or 0 if the 107 * layout provided by {@link Picker#getPickerItemLayoutId()} is a {link 108 * TextView}. 109 */ 110 public final int getPickerItemTextViewId() { 111 return mPickerItemTextViewId; 112 } 113 114 /** 115 * Sets the {@link Picker}'s item's {@link TextView}'s id from within the 116 * layout provided by {@link Picker#getPickerItemLayoutId()} or 0 if the 117 * layout provided by {@link Picker#getPickerItemLayoutId()} is a {link 118 * TextView}. 119 * @param textViewId View id of TextView inside a Picker item, or 0 if the Picker item is a 120 * TextView. 121 */ 122 public final void setPickerItemTextViewId(int textViewId) { 123 mPickerItemTextViewId = textViewId; 124 } 125 126 /** 127 * Creates a Picker widget. 128 * @param context 129 * @param attrs 130 * @param defStyleAttr 131 */ 132 public Picker(Context context, AttributeSet attrs, int defStyleAttr) { 133 super(context, attrs, defStyleAttr); 134 // Make it enabled and clickable to receive Click event. 135 setEnabled(true); 136 137 mFocusedAlpha = 1f; //getFloat(R.dimen.list_item_selected_title_text_alpha); 138 mUnfocusedAlpha = 1f; //getFloat(R.dimen.list_item_unselected_text_alpha); 139 mVisibleColumnAlpha = 0.5f; //getFloat(R.dimen.picker_item_visible_column_item_alpha); 140 mInvisibleColumnAlpha = 0f; //getFloat(R.dimen.picker_item_invisible_column_item_alpha); 141 142 mAlphaAnimDuration = 200; // mContext.getResources().getInteger(R.integer.dialog_animation_duration); 143 144 mDecelerateInterpolator = new DecelerateInterpolator(2.5F); 145 mAccelerateInterpolator = new AccelerateInterpolator(2.5F); 146 147 LayoutInflater inflater = LayoutInflater.from(getContext()); 148 mRootView = (ViewGroup) inflater.inflate(R.layout.lb_picker, this, true); 149 mPickerView = (ViewGroup) mRootView.findViewById(R.id.picker); 150 151 } 152 153 /** 154 * Get nth PickerColumn. 155 * @param colIndex Index of PickerColumn. 156 * @return PickerColumn at colIndex or null if {@link #setColumns(List)} is not called yet. 157 */ 158 public PickerColumn getColumnAt(int colIndex) { 159 if (mColumns == null) { 160 return null; 161 } 162 return mColumns.get(colIndex); 163 } 164 165 /** 166 * Get number of PickerColumns. 167 * @return Number of PickerColumns or 0 if {@link #setColumns(List)} is not called yet. 168 */ 169 public int getColumnsCount() { 170 if (mColumns == null) { 171 return 0; 172 } 173 return mColumns.size(); 174 } 175 176 /** 177 * Set columns and create Views. 178 * @param columns PickerColumns to be shown in the Picker. 179 */ 180 public void setColumns(List<PickerColumn> columns) { 181 mColumnViews.clear(); 182 mPickerView.removeAllViews(); 183 mColumns = new ArrayList<PickerColumn>(columns); 184 if (mSelectedColumn > mColumns.size() - 1) { 185 mSelectedColumn = mColumns.size() - 1; 186 } 187 LayoutInflater inflater = LayoutInflater.from(getContext()); 188 int totalCol = getColumnsCount(); 189 for (int i = 0; i < totalCol; i++) { 190 final int colIndex = i; 191 final VerticalGridView columnView = (VerticalGridView) inflater.inflate( 192 R.layout.lb_picker_column, mPickerView, false); 193 // we dont want VerticalGridView to receive focus. 194 updateColumnSize(columnView); 195 // always center aligned, not aligning selected item on top/bottom edge. 196 columnView.setWindowAlignment(VerticalGridView.WINDOW_ALIGN_NO_EDGE); 197 // Width is dynamic, so has fixed size is false. 198 columnView.setHasFixedSize(false); 199 mColumnViews.add(columnView); 200 201 // add view to root 202 mPickerView.addView(columnView); 203 204 // add a separator if not the last element 205 if (i != totalCol - 1 && getSeparator() != null) { 206 TextView separator = (TextView) inflater.inflate( 207 R.layout.lb_picker_separator, mPickerView, false); 208 separator.setText(getSeparator()); 209 mPickerView.addView(separator); 210 } 211 212 columnView.setAdapter(new PickerScrollArrayAdapter(getContext(), 213 getPickerItemLayoutId(), getPickerItemTextViewId(), colIndex)); 214 columnView.setOnChildViewHolderSelectedListener(mColumnChangeListener); 215 } 216 } 217 218 /** 219 * When column labels change or column range changes, call this function to re-populate the 220 * selection list. 221 * @param columnIndex Index of column to update. 222 * @param column New column to update. 223 */ 224 public void setColumnAt(int columnIndex, PickerColumn column) { 225 mColumns.set(columnIndex, column); 226 VerticalGridView columnView = mColumnViews.get(columnIndex); 227 PickerScrollArrayAdapter adapter = (PickerScrollArrayAdapter) columnView.getAdapter(); 228 if (adapter != null && !columnView.isComputingLayout()) { 229 adapter.notifyDataSetChanged(); 230 } 231 } 232 233 /** 234 * Manually set current value of a column. The function will update UI and notify listeners. 235 * @param columnIndex Index of column to update. 236 * @param value New value of the column. 237 * @param runAnimation True to scroll to the value or false otherwise. 238 */ 239 public void setColumnValue(int columnIndex, int value, boolean runAnimation) { 240 PickerColumn column = mColumns.get(columnIndex); 241 if (column.getCurrentValue() != value) { 242 column.setCurrentValue(value); 243 notifyValueChanged(columnIndex); 244 VerticalGridView columnView = mColumnViews.get(columnIndex); 245 if (columnView != null) { 246 int position = value - mColumns.get(columnIndex).getMinValue(); 247 if (runAnimation) { 248 columnView.setSelectedPositionSmooth(position); 249 } else { 250 columnView.setSelectedPosition(position); 251 } 252 } 253 } 254 } 255 256 private void notifyValueChanged(int columnIndex) { 257 if (mListeners != null) { 258 for (int i = mListeners.size() - 1; i >= 0; i--) { 259 mListeners.get(i).onValueChanged(this, columnIndex); 260 } 261 } 262 } 263 264 /** 265 * Register a callback to be invoked when the picker's value has changed. 266 * @param listener The callback to ad 267 */ 268 public void addOnValueChangedListener(PickerValueListener listener) { 269 if (mListeners == null) { 270 mListeners = new ArrayList<Picker.PickerValueListener>(); 271 } 272 mListeners.add(listener); 273 } 274 275 /** 276 * Remove a previously installed value changed callback 277 * @param listener The callback to remove. 278 */ 279 public void removeOnValueChangedListener(PickerValueListener listener) { 280 if (mListeners != null) { 281 mListeners.remove(listener); 282 } 283 } 284 285 private void updateColumnAlpha(int colIndex, boolean animate) { 286 VerticalGridView column = mColumnViews.get(colIndex); 287 288 int selected = column.getSelectedPosition(); 289 View item; 290 291 for (int i = 0; i < column.getAdapter().getItemCount(); i++) { 292 item = column.getLayoutManager().findViewByPosition(i); 293 if (item != null) { 294 setOrAnimateAlpha(item, (selected == i), colIndex, animate); 295 } 296 } 297 } 298 299 private void setOrAnimateAlpha(View view, boolean selected, int colIndex, 300 boolean animate) { 301 boolean columnShownAsActivated = colIndex == mSelectedColumn || !hasFocus(); 302 if (selected) { 303 // set alpha for main item (selected) in the column 304 if (columnShownAsActivated) { 305 setOrAnimateAlpha(view, animate, mFocusedAlpha, -1, mDecelerateInterpolator); 306 } else { 307 setOrAnimateAlpha(view, animate, mUnfocusedAlpha, -1, mDecelerateInterpolator); 308 } 309 } else { 310 // set alpha for remaining items in the column 311 if (columnShownAsActivated) { 312 setOrAnimateAlpha(view, animate, mVisibleColumnAlpha, -1, mDecelerateInterpolator); 313 } else { 314 setOrAnimateAlpha(view, animate, mInvisibleColumnAlpha, -1, 315 mDecelerateInterpolator); 316 } 317 } 318 } 319 320 private void setOrAnimateAlpha(View view, boolean animate, float destAlpha, float startAlpha, 321 Interpolator interpolator) { 322 view.animate().cancel(); 323 if (!animate) { 324 view.setAlpha(destAlpha); 325 } else { 326 if (startAlpha >= 0.0f) { 327 // set a start alpha 328 view.setAlpha(startAlpha); 329 } 330 view.animate().alpha(destAlpha) 331 .setDuration(mAlphaAnimDuration).setInterpolator(interpolator) 332 .start(); 333 } 334 } 335 336 /** 337 * Classes extending {@link Picker} can override this function to supply the 338 * behavior when a list has been scrolled. Subclass may call {@link #setColumnValue(int, int, 339 * boolean)} and or {@link #setColumnAt(int,PickerColumn)}. Subclass should not directly call 340 * {@link PickerColumn#setCurrentValue(int)} which does not update internal state or notify 341 * listeners. 342 * @param columnIndex index of which column was changed. 343 * @param newValue A new value desired to be set on the column. 344 */ 345 public void onColumnValueChanged(int columnIndex, int newValue) { 346 PickerColumn column = mColumns.get(columnIndex); 347 if (column.getCurrentValue() != newValue) { 348 column.setCurrentValue(newValue); 349 notifyValueChanged(columnIndex); 350 } 351 } 352 353 private float getFloat(int resourceId) { 354 TypedValue buffer = new TypedValue(); 355 getContext().getResources().getValue(resourceId, buffer, true); 356 return buffer.getFloat(); 357 } 358 359 static class ViewHolder extends RecyclerView.ViewHolder { 360 final TextView textView; 361 362 ViewHolder(View v, TextView textView) { 363 super(v); 364 this.textView = textView; 365 } 366 } 367 368 class PickerScrollArrayAdapter extends RecyclerView.Adapter<ViewHolder> { 369 370 private final int mResource; 371 private final int mColIndex; 372 private final int mTextViewResourceId; 373 private PickerColumn mData; 374 375 PickerScrollArrayAdapter(Context context, int resource, int textViewResourceId, 376 int colIndex) { 377 mResource = resource; 378 mColIndex = colIndex; 379 mTextViewResourceId = textViewResourceId; 380 mData = mColumns.get(mColIndex); 381 } 382 383 @Override 384 public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) { 385 LayoutInflater inflater = LayoutInflater.from(parent.getContext()); 386 View v = inflater.inflate(mResource, parent, false); 387 TextView textView; 388 if (mTextViewResourceId != 0) { 389 textView = (TextView) v.findViewById(mTextViewResourceId); 390 } else { 391 textView = (TextView) v; 392 } 393 ViewHolder vh = new ViewHolder(v, textView); 394 return vh; 395 } 396 397 @Override 398 public void onBindViewHolder(ViewHolder holder, int position) { 399 if (holder.textView != null && mData != null) { 400 holder.textView.setText(mData.getEntryAt(mData.getMinValue() + position)); 401 } 402 setOrAnimateAlpha(holder.itemView, 403 (mColumnViews.get(mColIndex).getSelectedPosition() == position), 404 mColIndex, false); 405 } 406 407 @Override 408 public void onViewAttachedToWindow(ViewHolder holder) { 409 holder.itemView.setFocusable(isActivated()); 410 } 411 412 public void setData(PickerColumn data) { 413 mData = data; 414 notifyDataSetChanged(); 415 } 416 417 @Override 418 public int getItemCount() { 419 return mData == null ? 0 : mData.getItemCount(); 420 } 421 } 422 423 private final OnChildViewHolderSelectedListener mColumnChangeListener = new 424 OnChildViewHolderSelectedListener() { 425 426 @Override 427 public void onChildViewHolderSelected(RecyclerView parent, RecyclerView.ViewHolder child, 428 int position, int subposition) { 429 PickerScrollArrayAdapter pickerScrollArrayAdapter = (PickerScrollArrayAdapter) parent 430 .getAdapter(); 431 432 int colIndex = mColumnViews.indexOf(parent); 433 updateColumnAlpha(colIndex, true); 434 if (child != null) { 435 int newValue = mColumns.get(colIndex).getMinValue() + position; 436 onColumnValueChanged(colIndex, newValue); 437 } 438 } 439 440 }; 441 442 @Override 443 public boolean dispatchKeyEvent(android.view.KeyEvent event) { 444 if (isActivated()) { 445 final int keyCode = event.getKeyCode(); 446 switch (keyCode) { 447 case KeyEvent.KEYCODE_DPAD_CENTER: 448 case KeyEvent.KEYCODE_ENTER: 449 if (event.getAction() == KeyEvent.ACTION_UP) { 450 performClick(); 451 } 452 break; 453 default: 454 return super.dispatchKeyEvent(event); 455 } 456 return true; 457 } 458 return super.dispatchKeyEvent(event); 459 } 460 461 @Override 462 protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) { 463 int column = getSelectedColumn(); 464 if (column < mColumnViews.size()) { 465 return mColumnViews.get(column).requestFocus(direction, previouslyFocusedRect); 466 } 467 return false; 468 } 469 470 /** 471 * Classes extending {@link Picker} can choose to override this method to 472 * supply the {@link Picker}'s column's single item height in pixels. 473 */ 474 protected int getPickerItemHeightPixels() { 475 return getContext().getResources().getDimensionPixelSize(R.dimen.picker_item_height); 476 } 477 478 private void updateColumnSize() { 479 for (int i = 0; i < getColumnsCount(); i++) { 480 updateColumnSize(mColumnViews.get(i)); 481 } 482 } 483 484 private void updateColumnSize(VerticalGridView columnView) { 485 ViewGroup.LayoutParams lp = columnView.getLayoutParams(); 486 lp.height = (int) (getPickerItemHeightPixels() * (isActivated() ? 487 getActivatedVisibleItemCount() : getVisibleItemCount())); 488 columnView.setLayoutParams(lp); 489 } 490 491 private void updateItemFocusable() { 492 final boolean activated = isActivated(); 493 for (int i = 0; i < getColumnsCount(); i++) { 494 VerticalGridView grid = mColumnViews.get(i); 495 for (int j = 0; j < grid.getChildCount(); j++) { 496 View view = grid.getChildAt(j); 497 view.setFocusable(activated); 498 } 499 } 500 } 501 /** 502 * Returns number of visible items showing in a column when it's activated. The default value 503 * is 3. 504 * @return Number of visible items showing in a column when it's activated. 505 */ 506 public float getActivatedVisibleItemCount() { 507 return mVisibleItemsActivated; 508 } 509 510 /** 511 * Changes number of visible items showing in a column when it's activated. The default value 512 * is 3. 513 * @param visiblePickerItems Number of visible items showing in a column when it's activated. 514 */ 515 public void setActivatedVisibleItemCount(float visiblePickerItems) { 516 if (visiblePickerItems <= 0) { 517 throw new IllegalArgumentException(); 518 } 519 if (mVisibleItemsActivated != visiblePickerItems) { 520 mVisibleItemsActivated = visiblePickerItems; 521 if (isActivated()) { 522 updateColumnSize(); 523 } 524 } 525 } 526 527 /** 528 * Returns number of visible items showing in a column when it's not activated. The default 529 * value is 1. 530 * @return Number of visible items showing in a column when it's not activated. 531 */ 532 public float getVisibleItemCount() { 533 return 1; 534 } 535 536 /** 537 * Changes number of visible items showing in a column when it's not activated. The default 538 * value is 1. 539 * @param pickerItems Number of visible items showing in a column when it's not activated. 540 */ 541 public void setVisibleItemCount(float pickerItems) { 542 if (pickerItems <= 0) { 543 throw new IllegalArgumentException(); 544 } 545 if (mVisibleItems != pickerItems) { 546 mVisibleItems = pickerItems; 547 if (!isActivated()) { 548 updateColumnSize(); 549 } 550 } 551 } 552 553 @Override 554 public void setActivated(boolean activated) { 555 if (activated != isActivated()) { 556 super.setActivated(activated); 557 updateColumnSize(); 558 updateItemFocusable(); 559 } else { 560 super.setActivated(activated); 561 } 562 } 563 564 @Override 565 public void requestChildFocus(View child, View focused) { 566 super.requestChildFocus(child, focused); 567 for (int i = 0; i < mColumnViews.size(); i++) { 568 if (mColumnViews.get(i).hasFocus()) { 569 setSelectedColumn(i); 570 } 571 } 572 } 573 574 /** 575 * Change current selected column. Picker shows multiple items on selected column if Picker has 576 * focus. Picker shows multiple items on all column if Picker has no focus (e.g. a Touchscreen 577 * screen). 578 * @param columnIndex Index of column to activate. 579 */ 580 public void setSelectedColumn(int columnIndex) { 581 if (mSelectedColumn != columnIndex) { 582 mSelectedColumn = columnIndex; 583 for (int i = 0; i < mColumnViews.size(); i++) { 584 updateColumnAlpha(i, true); 585 } 586 } 587 } 588 589 /** 590 * Get current activated column index. 591 * @return Current activated column index. 592 */ 593 public int getSelectedColumn() { 594 return mSelectedColumn; 595 } 596 597} 598