1 /* 2 * Copyright 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 18 19 20 package com.example.android.batchstepsensor.cardstream; 21 22 import android.animation.Animator; 23 import android.animation.AnimatorListenerAdapter; 24 import android.animation.ObjectAnimator; 25 import android.app.Activity; 26 import android.graphics.Color; 27 import android.view.LayoutInflater; 28 import android.view.View; 29 import android.view.ViewGroup; 30 import android.widget.Button; 31 import android.widget.ProgressBar; 32 import android.widget.TextView; 33 34 import com.example.android.batchstepsensor.R; 35 36 import java.util.ArrayList; 37 38 /** 39 * A Card contains a description and has a visual state. Optionally a card also contains a title, 40 * progress indicator and zero or more actions. It is constructed through the {@link Builder}. 41 */ 42 public class Card { 43 44 public static final int ACTION_POSITIVE = 1; 45 public static final int ACTION_NEGATIVE = 2; 46 public static final int ACTION_NEUTRAL = 3; 47 48 public static final int PROGRESS_TYPE_NO_PROGRESS = 0; 49 public static final int PROGRESS_TYPE_NORMAL = 1; 50 public static final int PROGRESS_TYPE_INDETERMIN ATE = 2; 51 public static final int PROGRESS_TYPE_LABEL = 3; 52 53 private OnCardClickListener mClickListener; 54 55 56 // The card model contains a reference to its desired layout (for extensibility), title, 57 // description, zero to many action buttons, and zero or 1 progress indicators. 58 private int mLayoutId = R.layout.card; 59 60 /** 61 * Tag that uniquely identifies this card. 62 */ 63 private String mTag = null; 64 65 private String mTitle = null; 66 private String mDescription = null; 67 68 private View mCardView = null; 69 private View mOverlayView = null; 70 private TextView mTitleView = null; 71 private TextView mDescView = null; 72 private View mActionAreaView = null; 73 74 private Animator mOngoingAnimator = null; 75 76 /** 77 * Visual state, either {@link #CARD_STATE_NORMAL}, {@link #CARD_STATE_FOCUSED} or 78 * {@link #CARD_STATE_INACTIVE}. 79 */ 80 private int mCardState = CARD_STATE_NORMAL; 81 public static final int CARD_STATE_NORMAL = 1; 82 public static final int CARD_STATE_FOCUSED = 2; 83 public static final int CARD_STATE_INACTIVE = 3; 84 85 /** 86 * Represent actions that can be taken from the card. Stylistically the developer can 87 * designate the action as positive, negative (ok/cancel, for instance), or neutral. 88 * This "type" can be used as a UI hint. 89 * @see com.example.android.sensors.batchstepsensor.Card.CardAction 90 */ 91 private ArrayList<CardAction> mCardActions = new ArrayList<CardAction>(); 92 93 /** 94 * Some cards will have a sense of "progress" which should be associated with, but separated 95 * from its "parent" card. To push for simplicity in samples, Cards are designed to have 96 * a maximum of one progress indicator per Card. 97 */ 98 private CardProgress mCardProgress = null; 99 100 public Card() { 101 } 102 103 public String getTag() { 104 return mTag; 105 } 106 107 public View getView() { 108 return mCardView; 109 } 110 111 112 public Card setDescription(String desc) { 113 if (mDescView != null) { 114 mDescription = desc; 115 mDescView.setText(desc); 116 } 117 return this; 118 } 119 120 public Card setTitle(String title) { 121 if (mTitleView != null) { 122 mTitle = title; 123 mTitleView.setText(title); 124 } 125 return this; 126 } 127 128 129 /** 130 * Return the UI state, either {@link #CARD_STATE_NORMAL}, {@link #CARD_STATE_FOCUSED} 131 * or {@link #CARD_STATE_INACTIVE}. 132 */ 133 public int getState() { 134 return mCardState; 135 } 136 137 /** 138 * Set the UI state. The parameter describes the state and must be either 139 * {@link #CARD_STATE_NORMAL}, {@link #CARD_STATE_FOCUSED} or {@link #CARD_STATE_INACTIVE}. 140 * Note: This method must be called from the UI Thread. 141 * @param state 142 * @return The card itself, allows for chaining of calls 143 */ 144 public Card setState(int state) { 145 mCardState = state; 146 if (null != mOverlayView) { 147 if (null != mOngoingAnimator) { 148 mOngoingAnimator.end(); 149 mOngoingAnimator = null; 150 } 151 switch (state) { 152 case CARD_STATE_NORMAL: { 153 mOverlayView.setVisibility(View.GONE); 154 mOverlayView.setAlpha(1.f); 155 break; 156 } 157 case CARD_STATE_FOCUSED: { 158 mOverlayView.setVisibility(View.VISIBLE); 159 mOverlayView.setBackgroundResource(R.drawable.card_overlay_focused); 160 ObjectAnimator animator = ObjectAnimator.ofFloat(mOverlayView, "alpha", 0.f); 161 animator.setRepeatMode(ObjectAnimator.REVERSE); 162 animator.setRepeatCount(ObjectAnimator.INFINITE); 163 animator.setDuration(1000); 164 animator.start(); 165 mOngoingAnimator = animator; 166 break; 167 } 168 case CARD_STATE_INACTIVE: { 169 mOverlayView.setVisibility(View.VISIBLE); 170 mOverlayView.setAlpha(1.f); 171 mOverlayView.setBackgroundColor(Color.argb(0xaa, 0xcc, 0xcc, 0xcc)); 172 break; 173 } 174 } 175 } 176 return this; 177 } 178 179 /** 180 * Set the type of progress indicator. 181 * The progress type can only be changed if the Card was initially build with a progress 182 * indicator. 183 * See {@link Builder#setProgressType(int)}. 184 * Must be a value of either {@link #PROGRESS_TYPE_NORMAL}, 185 * {@link #PROGRESS_TYPE_INDETERMINATE}, {@link #PROGRESS_TYPE_LABEL} or 186 * {@link #PROGRESS_TYPE_NO_PROGRESS}. 187 * @param progressType 188 * @return The card itself, allows for chaining of calls 189 */ 190 public Card setProgressType(int progressType) { 191 if (mCardProgress == null) { 192 mCardProgress = new CardProgress(); 193 } 194 mCardProgress.setProgressType(progressType); 195 return this; 196 } 197 198 /** 199 * Return the progress indicator type. A value of either {@link #PROGRESS_TYPE_NORMAL}, 200 * {@link #PROGRESS_TYPE_INDETERMINATE}, {@link #PROGRESS_TYPE_LABEL}. Otherwise if no progress 201 * indicator is enabled, {@link #PROGRESS_TYPE_NO_PROGRESS} is returned. 202 * @return 203 */ 204 public int getProgressType() { 205 if (mCardProgress == null) { 206 return PROGRESS_TYPE_NO_PROGRESS; 207 } 208 return mCardProgress.progressType; 209 } 210 211 /** 212 * Set the progress to the specified value. Only applicable if the card has a 213 * {@link #PROGRESS_TYPE_NORMAL} progress type. 214 * @param progress 215 * @return 216 * @see #setMaxProgress(int) 217 */ 218 public Card setProgress(int progress) { 219 if (mCardProgress != null) { 220 mCardProgress.setProgress(progress); 221 } 222 return this; 223 } 224 225 /** 226 * Set the range of the progress to 0...max. Only applicable if the card has a 227 * {@link #PROGRESS_TYPE_NORMAL} progress type. 228 * @return 229 */ 230 public Card setMaxProgress(int max){ 231 if (mCardProgress != null) { 232 mCardProgress.setMax(max); 233 } 234 return this; 235 } 236 237 /** 238 * Set the label text for the progress if the card has a progress type of 239 * {@link #PROGRESS_TYPE_NORMAL}, {@link #PROGRESS_TYPE_INDETERMINATE} or 240 * {@link #PROGRESS_TYPE_LABEL} 241 * @param text 242 * @return 243 */ 244 public Card setProgressLabel(String text) { 245 if (mCardProgress != null) { 246 mCardProgress.setProgressLabel(text); 247 } 248 return this; 249 } 250 251 /** 252 * Toggle the visibility of the progress section of the card. Only applicable if 253 * the card has a progress type of 254 * {@link #PROGRESS_TYPE_NORMAL}, {@link #PROGRESS_TYPE_INDETERMINATE} or 255 * {@link #PROGRESS_TYPE_LABEL}. 256 * @param isVisible 257 * @return 258 */ 259 public Card setProgressVisibility(boolean isVisible) { 260 if (mCardProgress.progressView == null) { 261 return this; // Card does not have progress 262 } 263 mCardProgress.progressView.setVisibility(isVisible ? View.VISIBLE : View.GONE); 264 265 return this; 266 } 267 268 /** 269 * Adds an action to this card during build time. 270 * 271 * @param label 272 * @param id 273 * @param type 274 */ 275 private void addAction(String label, int id, int type) { 276 CardAction cardAction = new CardAction(); 277 cardAction.label = label; 278 cardAction.id = id; 279 cardAction.type = type; 280 mCardActions.add(cardAction); 281 } 282 283 /** 284 * Toggles the visibility of a card action. 285 * @param actionId 286 * @param isVisible 287 * @return 288 */ 289 public Card setActionVisibility(int actionId, boolean isVisible) { 290 int visibilityFlag = isVisible ? View.VISIBLE : View.GONE; 291 for (CardAction action : mCardActions) { 292 if (action.id == actionId && action.actionView != null) { 293 action.actionView.setVisibility(visibilityFlag); 294 } 295 } 296 return this; 297 } 298 299 /** 300 * Toggles visibility of the action area of this Card through an animation. 301 * @param isVisible 302 * @return 303 */ 304 public Card setActionAreaVisibility(boolean isVisible) { 305 if (mActionAreaView == null) { 306 return this; // Card does not have an action area 307 } 308 309 if (isVisible) { 310 // Show the action area 311 mActionAreaView.setVisibility(View.VISIBLE); 312 mActionAreaView.setPivotY(0.f); 313 mActionAreaView.setPivotX(mCardView.getWidth() / 2.f); 314 mActionAreaView.setAlpha(0.5f); 315 mActionAreaView.setRotationX(-90.f); 316 mActionAreaView.animate().rotationX(0.f).alpha(1.f).setDuration(400); 317 } else { 318 // Hide the action area 319 mActionAreaView.setPivotY(0.f); 320 mActionAreaView.setPivotX(mCardView.getWidth() / 2.f); 321 mActionAreaView.animate().rotationX(-90.f).alpha(0.f).setDuration(400).setListener( 322 new AnimatorListenerAdapter() { 323 @Override 324 public void onAnimationEnd(Animator animation) { 325 mActionAreaView.setVisibility(View.GONE); 326 } 327 }); 328 } 329 return this; 330 } 331 332 333 /** 334 * Creates a shallow clone of the card. Shallow means all values are present, but no views. 335 * This is useful for saving/restoring in the case of configuration changes, like screen 336 * rotation. 337 * 338 * @return A shallow clone of the card instance 339 */ 340 public Card createShallowClone() { 341 Card cloneCard = new Card(); 342 343 // Outer card values 344 cloneCard.mTitle = mTitle; 345 cloneCard.mDescription = mDescription; 346 cloneCard.mTag = mTag; 347 cloneCard.mLayoutId = mLayoutId; 348 cloneCard.mCardState = mCardState; 349 350 // Progress 351 if (mCardProgress != null) { 352 cloneCard.mCardProgress = mCardProgress.createShallowClone(); 353 } 354 355 // Actions 356 for (CardAction action : mCardActions) { 357 cloneCard.mCardActions.add(action.createShallowClone()); 358 } 359 360 return cloneCard; 361 } 362 363 364 /** 365 * Prepare the card to be stored for configuration change. 366 */ 367 public void prepareForConfigurationChange() { 368 // Null out views. 369 mCardView = null; 370 for (CardAction action : mCardActions) { 371 action.actionView = null; 372 } 373 mCardProgress.progressView = null; 374 } 375 376 /** 377 * Creates a new {@link #Card}. 378 */ 379 public static class Builder { 380 private Card mCard; 381 382 /** 383 * Instantiate the builder with data from a shallow clone. 384 * @param listener 385 * @param card 386 * @see Card#createShallowClone() 387 */ 388 protected Builder(OnCardClickListener listener, Card card) { 389 mCard = card; 390 mCard.mClickListener = listener; 391 } 392 393 /** 394 * Instantiate the builder with the tag of the card. 395 * @param listener 396 * @param tag 397 */ 398 public Builder(OnCardClickListener listener, String tag) { 399 mCard = new Card(); 400 mCard.mTag = tag; 401 mCard.mClickListener = listener; 402 } 403 404 public Builder setTitle(String title) { 405 mCard.mTitle = title; 406 return this; 407 } 408 409 public Builder setDescription(String desc) { 410 mCard.mDescription = desc; 411 return this; 412 } 413 414 /** 415 * Add an action. 416 * The type describes how this action will be displayed. Accepted values are 417 * {@link #ACTION_NEUTRAL}, {@link #ACTION_POSITIVE} or {@link #ACTION_NEGATIVE}. 418 * 419 * @param label The text to display for this action 420 * @param id Identifier for this action, supplied in the click listener 421 * @param type UI style of action 422 * @return 423 */ 424 public Builder addAction(String label, int id, int type) { 425 mCard.addAction(label, id, type); 426 return this; 427 } 428 429 /** 430 * Override the default layout. 431 * The referenced layout file has to contain the same identifiers as defined in the default 432 * layout configuration. 433 * @param layout 434 * @return 435 * @see R.layout.card 436 */ 437 public Builder setLayout(int layout) { 438 mCard.mLayoutId = layout; 439 return this; 440 } 441 442 /** 443 * Set the type of progress bar to display. 444 * Accepted values are: 445 * <ul> 446 * <li>{@link #PROGRESS_TYPE_NO_PROGRESS} disables the progress indicator</li> 447 * <li>{@link #PROGRESS_TYPE_NORMAL} 448 * displays a standard, linear progress indicator.</li> 449 * <li>{@link #PROGRESS_TYPE_INDETERMINATE} displays an indeterminate (infite) progress 450 * indicator.</li> 451 * <li>{@link #PROGRESS_TYPE_LABEL} only displays a label text in the progress area 452 * of the card.</li> 453 * </ul> 454 * 455 * @param progressType 456 * @return 457 */ 458 public Builder setProgressType(int progressType) { 459 mCard.setProgressType(progressType); 460 return this; 461 } 462 463 public Builder setProgressLabel(String label) { 464 // ensure the progress layout has been initialized, use 'no progress' by default 465 if (mCard.mCardProgress == null) { 466 mCard.setProgressType(PROGRESS_TYPE_NO_PROGRESS); 467 } 468 mCard.mCardProgress.label = label; 469 return this; 470 } 471 472 public Builder setProgressMaxValue(int maxValue) { 473 // ensure the progress layout has been initialized, use 'no progress' by default 474 if (mCard.mCardProgress == null) { 475 mCard.setProgressType(PROGRESS_TYPE_NO_PROGRESS); 476 } 477 mCard.mCardProgress.maxValue = maxValue; 478 return this; 479 } 480 481 public Builder setStatus(int status) { 482 mCard.setState(status); 483 return this; 484 } 485 486 public Card build(Activity activity) { 487 LayoutInflater inflater = activity.getLayoutInflater(); 488 // Inflating the card. 489 ViewGroup cardView = (ViewGroup) inflater.inflate(mCard.mLayoutId, 490 (ViewGroup) activity.findViewById(R.id.card_stream), false); 491 492 // Check that the layout contains a TextView with the card_title id 493 View viewTitle = cardView.findViewById(R.id.card_title); 494 if (mCard.mTitle != null && viewTitle != null) { 495 mCard.mTitleView = (TextView) viewTitle; 496 mCard.mTitleView.setText(mCard.mTitle); 497 } else if (viewTitle != null) { 498 viewTitle.setVisibility(View.GONE); 499 } 500 501 // Check that the layout contains a TextView with the card_content id 502 View viewDesc = cardView.findViewById(R.id.card_content); 503 if (mCard.mDescription != null && viewDesc != null) { 504 mCard.mDescView = (TextView) viewDesc; 505 mCard.mDescView.setText(mCard.mDescription); 506 } else if (viewDesc != null) { 507 cardView.findViewById(R.id.card_content).setVisibility(View.GONE); 508 } 509 510 511 ViewGroup actionArea = (ViewGroup) cardView.findViewById(R.id.card_actionarea); 512 513 // Inflate Progress 514 initializeProgressView(inflater, actionArea); 515 516 // Inflate all action views. 517 initializeActionViews(inflater, cardView, actionArea); 518 519 mCard.mCardView = cardView; 520 mCard.mOverlayView = cardView.findViewById(R.id.card_overlay); 521 522 return mCard; 523 } 524 525 /** 526 * Initialize data from the given card. 527 * @param card 528 * @return 529 * @see Card#createShallowClone() 530 */ 531 public Builder cloneFromCard(Card card) { 532 mCard = card.createShallowClone(); 533 return this; 534 } 535 536 /** 537 * Build the action views by inflating the appropriate layouts and setting the text and 538 * values. 539 * @param inflater 540 * @param cardView 541 * @param actionArea 542 */ 543 private void initializeActionViews(LayoutInflater inflater, ViewGroup cardView, 544 ViewGroup actionArea) { 545 if (!mCard.mCardActions.isEmpty()) { 546 // Set action area to visible only when actions are visible 547 actionArea.setVisibility(View.VISIBLE); 548 mCard.mActionAreaView = actionArea; 549 } 550 551 // Inflate all card actions 552 for (final CardAction action : mCard.mCardActions) { 553 554 int useActionLayout = 0; 555 switch (action.type) { 556 case Card.ACTION_POSITIVE: 557 useActionLayout = R.layout.card_button_positive; 558 break; 559 case Card.ACTION_NEGATIVE: 560 useActionLayout = R.layout.card_button_negative; 561 break; 562 case Card.ACTION_NEUTRAL: 563 default: 564 useActionLayout = R.layout.card_button_neutral; 565 break; 566 } 567 568 action.actionView = inflater.inflate(useActionLayout, actionArea, false); 569 Button actionButton = (Button) action.actionView.findViewById(R.id.card_button); 570 571 actionButton.setText(action.label); 572 actionButton.setOnClickListener(new View.OnClickListener() { 573 @Override 574 public void onClick(View v) { 575 mCard.mClickListener.onCardClick(action.id, mCard.mTag); 576 } 577 }); 578 actionArea.addView(action.actionView); 579 } 580 } 581 582 /** 583 * Build the progress view into the given ViewGroup. 584 * 585 * @param inflater 586 * @param actionArea 587 */ 588 private void initializeProgressView(LayoutInflater inflater, ViewGroup actionArea) { 589 590 // Only inflate progress layout if a progress type other than NO_PROGRESS was set. 591 if (mCard.mCardProgress != null) { 592 //Setup progress card. 593 View progressView = inflater.inflate(R.layout.card_progress, actionArea, false); 594 ProgressBar progressBar = 595 (ProgressBar) progressView.findViewById(R.id.card_progress); 596 ((TextView) progressView.findViewById(R.id.card_progress_text)) 597 .setText(mCard.mCardProgress.label); 598 progressBar.setMax(mCard.mCardProgress.maxValue); 599 progressBar.setProgress(0); 600 mCard.mCardProgress.progressView = progressView; 601 mCard.mCardProgress.setProgressType(mCard.getProgressType()); 602 actionArea.addView(progressView); 603 } 604 } 605 } 606 607 /** 608 * Represents a clickable action, accessible from the bottom of the card. 609 * Fields include the label, an ID to specify the action that was performed in the callback, 610 * an action type (positive, negative, neutral), and the callback. 611 */ 612 public class CardAction { 613 614 public String label; 615 public int id; 616 public int type; 617 public View actionView; 618 619 public CardAction createShallowClone() { 620 CardAction actionClone = new CardAction(); 621 actionClone.label = label; 622 actionClone.id = id; 623 actionClone.type = type; 624 return actionClone; 625 // Not the view. Never the view (don't want to hold view references for 626 // onConfigurationChange. 627 } 628 629 } 630 631 /** 632 * Describes the progress of a {@link Card}. 633 * Three types of progress are supported: 634 * <ul><li>{@link Card#PROGRESS_TYPE_NORMAL: Standard progress bar with label text</li> 635 * <li>{@link Card#PROGRESS_TYPE_INDETERMINATE}: Indeterminate progress bar with label txt</li> 636 * <li>{@link Card#PROGRESS_TYPE_LABEL}: Label only, no progresss bar</li> 637 * </ul> 638 */ 639 public class CardProgress { 640 private int progressType = Card.PROGRESS_TYPE_NO_PROGRESS; 641 private String label = ""; 642 private int currProgress = 0; 643 private int maxValue = 100; 644 645 public View progressView = null; 646 private ProgressBar progressBar = null; 647 private TextView progressLabel = null; 648 649 public CardProgress createShallowClone() { 650 CardProgress progressClone = new CardProgress(); 651 progressClone.label = label; 652 progressClone.currProgress = currProgress; 653 progressClone.maxValue = maxValue; 654 progressClone.progressType = progressType; 655 return progressClone; 656 } 657 658 /** 659 * Set the progress. Only useful for the type {@link #PROGRESS_TYPE_NORMAL}. 660 * @param progress 661 * @see android.widget.ProgressBar#setProgress(int) 662 */ 663 public void setProgress(int progress) { 664 currProgress = progress; 665 final ProgressBar bar = getProgressBar(); 666 if (bar != null) { 667 bar.setProgress(currProgress); 668 bar.invalidate(); 669 } 670 } 671 672 /** 673 * Set the range of the progress to 0...max. 674 * Only useful for the type {@link #PROGRESS_TYPE_NORMAL}. 675 * @param max 676 * @see android.widget.ProgressBar#setMax(int) 677 */ 678 public void setMax(int max) { 679 maxValue = max; 680 final ProgressBar bar = getProgressBar(); 681 if (bar != null) { 682 bar.setMax(maxValue); 683 } 684 } 685 686 /** 687 * Set the label text that appears near the progress indicator. 688 * @param text 689 */ 690 public void setProgressLabel(String text) { 691 label = text; 692 final TextView labelView = getProgressLabel(); 693 if (labelView != null) { 694 labelView.setText(text); 695 } 696 } 697 698 /** 699 * Set how progress is displayed. The parameter must be one of three supported types: 700 * <ul><li>{@link Card#PROGRESS_TYPE_NORMAL: Standard progress bar with label text</li> 701 * <li>{@link Card#PROGRESS_TYPE_INDETERMINATE}: 702 * Indeterminate progress bar with label txt</li> 703 * <li>{@link Card#PROGRESS_TYPE_LABEL}: Label only, no progresss bar</li> 704 * @param type 705 */ 706 public void setProgressType(int type) { 707 progressType = type; 708 if (progressView != null) { 709 switch (type) { 710 case PROGRESS_TYPE_NO_PROGRESS: { 711 progressView.setVisibility(View.GONE); 712 break; 713 } 714 case PROGRESS_TYPE_NORMAL: { 715 progressView.setVisibility(View.VISIBLE); 716 getProgressBar().setIndeterminate(false); 717 break; 718 } 719 case PROGRESS_TYPE_INDETERMINATE: { 720 progressView.setVisibility(View.VISIBLE); 721 getProgressBar().setIndeterminate(true); 722 break; 723 } 724 } 725 } 726 } 727 728 private TextView getProgressLabel() { 729 if (progressLabel != null) { 730 return progressLabel; 731 } else if (progressView != null) { 732 progressLabel = (TextView) progressView.findViewById(R.id.card_progress_text); 733 return progressLabel; 734 } else { 735 return null; 736 } 737 } 738 739 private ProgressBar getProgressBar() { 740 if (progressBar != null) { 741 return progressBar; 742 } else if (progressView != null) { 743 progressBar = (ProgressBar) progressView.findViewById(R.id.card_progress); 744 return progressBar; 745 } else { 746 return null; 747 } 748 } 749 750 } 751 } 752