/**
   * Animate change of color
   *
   * @param event Event to process
   */
  public void startAnimateColorChange(@NonNull final DecoEvent event) {
    cancelAnimation();
    event.notifyStartListener();
    mVisible = true;

    mDrawMode = event.getEventType();
    mPercentComplete = 0f;

    final boolean changeColors = event.isColorSet();
    if (changeColors) {
      mColorAnimate = new ColorAnimate(mSeriesItem.getColor(), event.getColor());
      mSeriesItem.setColor(event.getColor());
    } else {
      Log.w(TAG, "Must set new color to start CHANGE_COLOR event");
      return;
    }

    final float maxValue = 1.0f;
    mValueAnimator = ValueAnimator.ofFloat(0, maxValue);

    mValueAnimator.setDuration(event.getEffectDuration());
    if (event.getInterpolator() != null) {
      mValueAnimator.setInterpolator(event.getInterpolator());
    } else {
      mValueAnimator.setInterpolator(new LinearInterpolator());
    }

    mValueAnimator.addUpdateListener(
        new ValueAnimator.AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator valueAnimator) {
            mPercentComplete = Float.valueOf(valueAnimator.getAnimatedValue().toString());

            for (SeriesItem.SeriesItemListener seriesItemListener : mSeriesItem.getListeners()) {
              seriesItemListener.onSeriesItemDisplayProgress(mPercentComplete);
            }
          }
        });

    mValueAnimator.addListener(
        new AnimatorListenerAdapter() {
          @Override
          public void onAnimationEnd(Animator animation) {
            event.notifyEndListener();
          }
        });

    mValueAnimator.start();
  }
  @Override
  public void createAnimation() {
    float startX = getWidth() / 6;
    float startY = getWidth() / 6;
    for (int i = 0; i < 2; i++) {
      final int index = i;
      ValueAnimator translateXAnim =
          ValueAnimator.ofFloat(startX, getWidth() - startX, startX, getWidth() - startX, startX);
      if (i == 1) {
        translateXAnim =
            ValueAnimator.ofFloat(
                getWidth() - startX, startX, getWidth() - startX, startX, getWidth() - startX);
      }
      ValueAnimator translateYAnim =
          ValueAnimator.ofFloat(startY, startY, getHeight() - startY, getHeight() - startY, startY);
      if (i == 1) {
        translateYAnim =
            ValueAnimator.ofFloat(
                getHeight() - startY, getHeight() - startY, startY, startY, getHeight() - startY);
      }

      translateXAnim.setDuration(2000);
      translateXAnim.setInterpolator(new LinearInterpolator());
      translateXAnim.setRepeatCount(-1);
      translateXAnim.addUpdateListener(
          new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
              translateX[index] = (float) animation.getAnimatedValue();
              postInvalidate();
            }
          });
      translateXAnim.start();

      translateYAnim.setDuration(2000);
      translateYAnim.setInterpolator(new LinearInterpolator());
      translateYAnim.setRepeatCount(-1);
      translateYAnim.addUpdateListener(
          new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
              translateY[index] = (float) animation.getAnimatedValue();
              postInvalidate();
            }
          });
      translateYAnim.start();
    }
  }
    public void start() {
      initpaints();
      fadeAndScaleAnimator.setInterpolator(new OvershootInterpolator(1.15f));
      fadeAndScaleAnimator.start();
      fadeAndScaleAnimator.addUpdateListener(
          new ValueAnimator.AnimatorUpdateListener() {

            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
              invalidate();
              if (animation.getAnimatedFraction() > .8f && !hasfired) {
                hasfired = true;
                rotationAnimator.start();
              }
            }
          });
      rotationAnimator.setInterpolator(new DecelerateInterpolator());

      rotationAnimator.addUpdateListener(
          new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
              invalidate();
            }
          });
    }
  public void duang() {
    mStatus = Status.STATUS_DOWN;
    ValueAnimator valueAnimator = ValueAnimator.ofInt(mMaxArcHeight, 0);
    valueAnimator.addUpdateListener(
        new ValueAnimator.AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator animation) {
            mArcHeight = (int) animation.getAnimatedValue();
            invalidate();
          }
        });
    valueAnimator.addListener(
        new SimpleAnimationListener() {

          @Override
          public void onAnimationEnd(Animator animation) {
            if (mAnimationListener != null) {
              mAnimationListener.onEnd();
            }
          }
        });
    valueAnimator.setDuration(500);
    valueAnimator.setInterpolator(new OvershootInterpolator(5f));
    valueAnimator.start();
  }
  public void show() {
    mStatus = Status.STATUS_SMOOTH_UP;

    if (mAnimationListener != null) {
      mAnimationListener.onStart();
      this.postDelayed(
          new Runnable() {
            @Override
            public void run() {

              mAnimationListener.onContentShow();
            }
          },
          600);
    }

    ValueAnimator valueAnimator = ValueAnimator.ofInt(0, mMaxArcHeight);
    valueAnimator.addUpdateListener(
        new ValueAnimator.AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator animation) {
            int value = (int) animation.getAnimatedValue();
            mArcHeight = value;

            if (value == mMaxArcHeight) {
              duang();
            }
            invalidate();
          }
        });
    valueAnimator.setDuration(800);
    valueAnimator.setInterpolator(new AccelerateInterpolator());
    valueAnimator.start();
  }
  public void animateSubjectOut(final SubjectCard materia) {
    final List<View> toBeAnimated = new ArrayList<View>();
    boolean after = false;
    for (SubjectCard mtr : mSubjectCards) {
      if (after) toBeAnimated.add(mtr);
      if (mtr == materia) after = true;
    }
    toBeAnimated.add(mAddButton);
    final int numberToBeAnimated = toBeAnimated.size();

    int maxScroll = mScrollView.getChildAt(0).getHeight() - mScrollView.getHeight(),
        materiaHeight = materia.getHeight();
    final int initScroll = mScrollView.getScrollY(),
        scrollBy =
            ((maxScroll < initScroll + materiaHeight)
                    ? Math.max(maxScroll - materiaHeight, 0)
                    : initScroll)
                - initScroll;
    ValueAnimator listAnimator = ValueAnimator.ofFloat(0, -materiaHeight);
    listAnimator.setInterpolator(new DecelerateInterpolator(3.2f));
    listAnimator.addUpdateListener(
        new ValueAnimator.AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator animation) {
            float value = (Float) animation.getAnimatedValue();
            for (int i = 0; i < numberToBeAnimated; i++)
              ViewHelper.setTranslationY(toBeAnimated.get(i), value);
            ViewHelper.setScrollY(
                mScrollView, (int) (initScroll + scrollBy * animation.getAnimatedFraction()));
          }
        });
    listAnimator.addListener(
        new AnimatorListenerAdapter() {
          @Override
          public void onAnimationEnd(Animator animation) {
            mSubjectCards.remove(materia);
            mSubjectsLayout.removeView(materia);
            mSqlHelper.remove(materia.getData().getSqlID());
            updateTotal();
            mScrollView.setVerticalScrollBarEnabled(true);
            mScrollView.setOnTouchListener(null);
            for (View mtr : toBeAnimated) ViewHelper.setTranslationY(mtr, 0);
          }
        });
    listAnimator.setDuration(700);
    mScrollView.setVerticalScrollBarEnabled(false);
    mScrollView.setOnTouchListener(
        new View.OnTouchListener() {
          @Override
          public boolean onTouch(View v, MotionEvent event) {
            return true;
          }
        }); // disable user scrolling during the animation

    if (ViewHelper.getTranslationX(materia) == 0) materia.swipeRight(0, 0);
    listAnimator.setStartDelay(500);
    listAnimator.start();
  }
 /** 开始绘制动画 */
 private void startAnim(int value) {
   ValueAnimator valueAnimator = ObjectAnimator.ofInt(value);
   valueAnimator.setDuration(1000);
   valueAnimator.setInterpolator(new LinearInterpolator());
   valueAnimator.addUpdateListener(
       new ValueAnimator.AnimatorUpdateListener() {
         @Override
         public void onAnimationUpdate(ValueAnimator valueAnimator) {
           mDegress = Integer.valueOf(valueAnimator.getAnimatedValue().toString());
           invalidate();
         }
       });
   valueAnimator.start();
 }
  @Override
  public void createAnimation() {
    long[] delays = new long[] {0, 200, 400};
    for (int i = 0; i < 3; i++) {
      final int index = i;
      ValueAnimator scaleAnim = ValueAnimator.ofFloat(0, 1);
      scaleAnim.setInterpolator(new LinearInterpolator());
      scaleAnim.setDuration(1000);
      scaleAnim.setRepeatCount(-1);
      scaleAnim.addUpdateListener(
          new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
              scaleFloats[index] = (float) animation.getAnimatedValue();
              postInvalidate();
            }
          });
      scaleAnim.setStartDelay(delays[i]);
      scaleAnim.start();

      ValueAnimator alphaAnim = ValueAnimator.ofInt(0, 255);
      scaleAnim.setInterpolator(new LinearInterpolator());
      alphaAnim.setDuration(1000);
      alphaAnim.setRepeatCount(-1);
      alphaAnim.addUpdateListener(
          new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
              alphaInts[index] = (int) animation.getAnimatedValue();
              postInvalidate();
            }
          });
      scaleAnim.setStartDelay(delays[i]);
      alphaAnim.start();
    }
  }
  /**
   * Execute an Animation effect by starting the Value Animator
   *
   * @param event Event to process effect
   * @throws IllegalStateException No effect set in event
   */
  public void startAnimateEffect(@NonNull final DecoEvent event) throws IllegalStateException {
    if (event.getEffectType() == null) {
      throw new IllegalStateException("Unable to execute null effect type");
    }

    // All effects run from 0.0 .. 1.0f in duration
    final float maxValue = 1.0f;

    cancelAnimation();
    event.notifyStartListener();

    mVisible = true;
    mDrawMode = event.getEventType();
    mEffect = new DecoDrawEffect(event.getEffectType(), mPaint, event.getDisplayText());
    mEffect.setRotationCount(event.getEffectRotations());

    mPercentComplete = 0f;

    mValueAnimator = ValueAnimator.ofFloat(0, maxValue);
    mValueAnimator.setDuration(event.getEffectDuration());
    Interpolator interpolator =
        (event.getInterpolator() != null) ? event.getInterpolator() : new LinearInterpolator();
    mValueAnimator.setInterpolator(interpolator);

    mValueAnimator.addUpdateListener(
        new ValueAnimator.AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator valueAnimator) {
            mPercentComplete = Float.valueOf(valueAnimator.getAnimatedValue().toString());
            for (SeriesItem.SeriesItemListener seriesItemListener : mSeriesItem.getListeners()) {
              seriesItemListener.onSeriesItemDisplayProgress(mPercentComplete);
            }
          }
        });

    mValueAnimator.addListener(
        new AnimatorListenerAdapter() {
          @Override
          public void onAnimationEnd(Animator animation) {
            event.notifyEndListener();
            mDrawMode = DecoEvent.EventType.EVENT_MOVE;
            mVisible = mEffect.postExecuteVisibility();
            mEffect = null;
          }
        });

    mValueAnimator.start();
  }
  /**
   * Creates a new animation whose parameters come from the specified context and attributes set.
   *
   * @param res The resources
   * @param attrs The set of attributes holding the animation parameters
   * @param anim Null if this is a ValueAnimator, otherwise this is an ObjectAnimator
   */
  private static ValueAnimator loadAnimator(
      Context c,
      Resources res,
      Resources.Theme theme,
      AttributeSet attrs,
      ValueAnimator anim,
      float pathErrorScale)
      throws Resources.NotFoundException {

    TypedArray arrayAnimator = null;
    TypedArray arrayObjectAnimator = null;

    if (theme != null) {
      arrayAnimator = theme.obtainStyledAttributes(attrs, R.styleable.Animator, 0, 0);
    } else {
      arrayAnimator = res.obtainAttributes(attrs, R.styleable.Animator);
    }

    // If anim is not null, then it is an object animator.
    if (anim != null) {
      if (theme != null) {
        arrayObjectAnimator =
            theme.obtainStyledAttributes(attrs, R.styleable.PropertyAnimator, 0, 0);
      } else {
        arrayObjectAnimator = res.obtainAttributes(attrs, R.styleable.PropertyAnimator);
      }
    }

    if (anim == null) {
      anim = new ValueAnimator();
    }

    parseAnimatorFromTypeArray(anim, arrayAnimator, arrayObjectAnimator);

    final int resId = arrayAnimator.getResourceId(R.styleable.Animator_android_interpolator, 0);
    if (resId > 0) {
      anim.setInterpolator(AnimationUtils.loadInterpolator(c, resId));
    }

    arrayAnimator.recycle();
    if (arrayObjectAnimator != null) {
      arrayObjectAnimator.recycle();
    }

    return anim;
  }
  private void handleActionUp() {
    if (isOutOfRange) {
      // When user drag it back, we should call onReset().
      if (GeometryUtil.getDistanceBetween2Points(mDragCenter, mInitCenter) < resetDistance) {
        if (mListener != null) mListener.onReset(isOutOfRange);
        return;
      }

      // Otherwise
      disappeared();
    } else {

      // 手指抬起时,弹回动画
      mAnim = ValueAnimator.ofFloat(1.0f);
      mAnim.setInterpolator(new OvershootInterpolator(4.0f));

      final PointF startPoint = new PointF(mDragCenter.x, mDragCenter.y);
      final PointF endPoint = new PointF(mStickCenter.x, mStickCenter.y);
      mAnim.addUpdateListener(
          new AnimatorUpdateListener() {

            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
              float fraction = animation.getAnimatedFraction();
              PointF pointByPercent =
                  GeometryUtil.getPointByPercent(startPoint, endPoint, fraction);
              updateDragCenter((float) pointByPercent.x, (float) pointByPercent.y);
            }
          });
      mAnim.addListener(
          new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
              if (mListener != null) mListener.onReset(isOutOfRange);
            }
          });
      if (GeometryUtil.getDistanceBetween2Points(startPoint, endPoint) < 10) {
        mAnim.setDuration(10);
      } else {
        mAnim.setDuration(500);
      }
      mAnim.start();
    }
  }
 private void startSendingAnimation(final RevealView.RevealAnimationListener listener) {
   final int width = mFab.getLeft();
   final int height = mFab.getTop();
   ValueAnimator valueAnimator = new ValueAnimator();
   valueAnimator.setDuration(Const.DURATION / 2);
   valueAnimator.setObjectValues(new PointF(0, 0));
   valueAnimator.setInterpolator(new DecelerateInterpolator());
   valueAnimator.setEvaluator(
       new TypeEvaluator<PointF>() {
         @Override
         public PointF evaluate(float fraction, PointF startValue, PointF endValue) {
           PointF point = new PointF();
           point.x = (width) * (1 - fraction / 2);
           point.y = (height) - 0.85f * (height) * (fraction / 2) * (fraction / 2);
           return point;
         }
       });
   valueAnimator.start();
   valueAnimator.addUpdateListener(
       new ValueAnimator.AnimatorUpdateListener() {
         @Override
         public void onAnimationUpdate(ValueAnimator animation) {
           PointF point = (PointF) animation.getAnimatedValue();
           mFab.setX(point.x);
           mFab.setY(point.y);
         }
       });
   valueAnimator.addListener(
       new AnimatorListenerAdapter() {
         @Override
         public void onAnimationEnd(Animator animation) {
           super.onAnimationEnd(animation);
           mRevealView.reveal(
               (int) mFab.getX() + mFab.getWidth() / 2,
               (int) mFab.getY() + mFab.getHeight() / 2,
               getThemeColor(),
               Const.RADIUS,
               Const.DURATION,
               listener);
         }
       });
 }
Beispiel #13
0
  public void show(final View view) {
    pushedView = view;
    if (this.getParent() != null) return;
    synchronized (Snackbar.class) {
      if (!next.contains(this)) next.add(this);
      if (next.indexOf(this) == 0) {
        View decor = ((Activity) getContext()).getWindow().getDecorView();
        ((ViewGroup) decor.findViewById(android.R.id.content))
            .addView(
                this, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);

        ViewHelper.setAlpha(content, 0);
        AnimUtils.flyIn(content, null);
        if (view != null) {
          ValueAnimator animator = ValueAnimator.ofFloat(0, -1);
          animator.setDuration(200);
          animator.setInterpolator(new DecelerateInterpolator());
          animator.addUpdateListener(
              new ValueAnimator.AnimatorUpdateListener() {
                @Override
                public void onAnimationUpdate(ValueAnimator valueAnimator) {
                  MarginLayoutParams lp = (MarginLayoutParams) content.getLayoutParams();
                  Log.e(
                      "snackbar " + Snackbar.this.hashCode(),
                      ""
                          + ((content.getHeight() + lp.bottomMargin)
                              * (Float) valueAnimator.getAnimatedValue()));
                  ViewHelper.setTranslationY(
                      view,
                      (content.getHeight() + lp.bottomMargin)
                          * (Float) valueAnimator.getAnimatedValue());
                  if (pushedView.getParent() != null)
                    ((View) pushedView.getParent()).postInvalidate();
                }
              });
          animator.start();
        }
        if (duration != INFINITE) handler.postDelayed(hideRunnable, duration);
      }
    }
  }
  /**
   * Kick off an animation to hide or show the arc. This results in an animation where both the
   * width of the line used for the arc and the transparency of the arc is altered over the duration
   * provided
   *
   * @param event Event to process
   * @param showArc True to show the arc, false to hide
   */
  public void startAnimateHideShow(@NonNull final DecoEvent event, final boolean showArc) {
    cancelAnimation();
    event.notifyStartListener();

    mDrawMode = event.getEventType();
    mPercentComplete = showArc ? 1.0f : 0f;
    mVisible = true;

    final float maxValue = 1.0f;
    mValueAnimator = ValueAnimator.ofFloat(0, maxValue);

    mValueAnimator.setDuration(event.getEffectDuration());
    mValueAnimator.setInterpolator(new LinearInterpolator());

    mValueAnimator.addUpdateListener(
        new ValueAnimator.AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator valueAnimator) {

            float current = Float.valueOf(valueAnimator.getAnimatedValue().toString());
            mPercentComplete = showArc ? (maxValue - current) : current;

            for (SeriesItem.SeriesItemListener seriesItemListener : mSeriesItem.getListeners()) {
              seriesItemListener.onSeriesItemDisplayProgress(mPercentComplete);
            }
          }
        });

    mValueAnimator.addListener(
        new AnimatorListenerAdapter() {
          @Override
          public void onAnimationEnd(Animator animation) {
            if (event.getEventType() != DecoEvent.EventType.EVENT_EFFECT) {
              event.notifyEndListener();
            }
          }
        });

    mValueAnimator.start();
  }
  @Override
  public boolean onTouchEvent(MotionEvent ev) {
    if (ev.getAction() == MotionEvent.ACTION_UP) {
      // 需要将ImageView的高度缓慢恢复到最初高度
      ValueAnimator animator = ValueAnimator.ofInt(imageView.getHeight(), orignalHeight);
      animator.addUpdateListener(
          new AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animator) {
              // 获取动画的值,设置给imageview
              int animatedValue = (Integer) animator.getAnimatedValue();

              imageView.getLayoutParams().height = animatedValue;
              imageView.requestLayout(); // 使ImageView的布局参数生效
            }
          });
      animator.setInterpolator(new OvershootInterpolator(5)); // 弹性的插值器
      animator.setDuration(350);
      animator.start();
    }
    return super.onTouchEvent(ev);
  }
Beispiel #16
0
 public void hide() {
   synchronized (Snackbar.class) {
     if (getParent() == null) return;
     handler.removeCallbacks(hideRunnable);
     if (onDismissedListener != null) onDismissedListener.onDismissed();
     AnimUtils.flyOut(
         content,
         new AnimatorListenerAdapter() {
           @Override
           public void onAnimationEnd(Animator animator) {
             hideInternal();
           }
         });
     if (pushedView != null) {
       ValueAnimator animator = ValueAnimator.ofFloat(-1, 0);
       animator.setDuration(200);
       animator.setInterpolator(new DecelerateInterpolator());
       animator.addUpdateListener(
           new ValueAnimator.AnimatorUpdateListener() {
             @Override
             public void onAnimationUpdate(ValueAnimator valueAnimator) {
               MarginLayoutParams lp = (MarginLayoutParams) content.getLayoutParams();
               Log.e(
                   "snackbar " + Snackbar.this.hashCode(),
                   ""
                       + ((content.getHeight() + lp.bottomMargin)
                           * (Float) valueAnimator.getAnimatedValue()));
               ViewHelper.setTranslationY(
                   pushedView,
                   (content.getHeight() + lp.bottomMargin)
                       * (Float) valueAnimator.getAnimatedValue());
               if (pushedView.getParent() != null)
                 ((View) pushedView.getParent()).postInvalidate();
             }
           });
       animator.start();
     }
   }
 }
 /** 回滚状态动画 */
 private void startRollBackAnimation(long duration) {
   ValueAnimator rollBackAnim = ValueAnimator.ofFloat(curRadius, originRadius);
   rollBackAnim.addUpdateListener(
       new ValueAnimator.AnimatorUpdateListener() {
         @Override
         public void onAnimationUpdate(ValueAnimator animation) {
           float value = (float) animation.getAnimatedValue();
           curRadius = (int) value;
           postInvalidate();
         }
       });
   rollBackAnim.setInterpolator(new BounceInterpolator()); // 反弹效果
   rollBackAnim.addListener(
       new AnimatorListenerAdapter() {
         @Override
         public void onAnimationEnd(Animator animation) {
           super.onAnimationEnd(animation);
           DraggableFlagView.this.clearAnimation();
         }
       });
   rollBackAnim.setDuration(duration);
   rollBackAnim.start();
 }
Beispiel #18
0
  @Override
  public boolean onTouchEvent(MotionEvent event) {
    float v = (value - min) / (max - min);
    float v2 = (value2 - min) / (max - min);

    if (event.getAction() == MotionEvent.ACTION_DOWN) {
      int thumbX =
          (int)
              (v * (getWidth() - getPaddingLeft() - getPaddingRight() - thumbRadius * 2)
                  + getPaddingLeft()
                  + thumbRadius);
      int thumbX2 =
          (int)
              (v2 * (getWidth() - getPaddingLeft() - getPaddingRight() - thumbRadius2 * 2)
                  + getPaddingLeft()
                  + thumbRadius2);
      if (Math.abs(event.getX() - thumbX) < Math.abs(event.getX() - thumbX2)) {
        draggedThumb = 1;
        if (radiusAnimator != null) radiusAnimator.end();
        radiusAnimator = ValueAnimator.ofFloat(thumbRadius, THUMB_RADIUS_DRAGGED);
        radiusAnimator.setDuration(200);
        radiusAnimator.setInterpolator(interpolator);
        radiusAnimator.addUpdateListener(
            new ValueAnimator.AnimatorUpdateListener() {
              @Override
              public void onAnimationUpdate(ValueAnimator animation) {
                thumbRadius = (float) animation.getAnimatedValue();
                postInvalidate();
              }
            });
        radiusAnimator.start();
      } else {
        draggedThumb = 2;
        if (radiusAnimator != null) radiusAnimator.end();
        radiusAnimator = ValueAnimator.ofFloat(thumbRadius2, THUMB_RADIUS_DRAGGED);
        radiusAnimator.setDuration(200);
        radiusAnimator.setInterpolator(interpolator);
        radiusAnimator.addUpdateListener(
            new ValueAnimator.AnimatorUpdateListener() {
              @Override
              public void onAnimationUpdate(ValueAnimator animation) {
                thumbRadius2 = (float) animation.getAnimatedValue();
                postInvalidate();
              }
            });
        radiusAnimator.start();
      }
      ViewParent parent = getParent();
      if (parent != null) parent.requestDisallowInterceptTouchEvent(true);
    } else if (event.getAction() == MotionEvent.ACTION_CANCEL
        || event.getAction() == MotionEvent.ACTION_UP) {
      if (draggedThumb == 1) {
        if (style == Style.Discrete) {
          float val = (float) Math.floor((value - min + step / 2) / step) * step + min;
          if (valueAnimator != null) valueAnimator.cancel();
          valueAnimator = ValueAnimator.ofFloat(value, val);
          valueAnimator.setDuration(200);
          valueAnimator.setInterpolator(interpolator);
          valueAnimator.addUpdateListener(
              new ValueAnimator.AnimatorUpdateListener() {
                @Override
                public void onAnimationUpdate(ValueAnimator animation) {
                  value = (float) animation.getAnimatedValue();
                  int thumbX =
                      (int)
                          ((value - min)
                                  / (max - min)
                                  * (getWidth() - getPaddingLeft() - getPaddingRight())
                              + getPaddingLeft());
                  int thumbY = getHeight() / 2;
                  int radius = rippleDrawable.getRadius();
                  rippleDrawable.setBounds(
                      thumbX - radius, thumbY - radius, thumbX + radius, thumbY + radius);
                  postInvalidate();
                }
              });
          valueAnimator.start();
        }
        if (radiusAnimator != null) radiusAnimator.end();
        radiusAnimator = ValueAnimator.ofFloat(thumbRadius, THUMB_RADIUS);
        radiusAnimator.setDuration(200);
        radiusAnimator.setInterpolator(interpolator);
        radiusAnimator.addUpdateListener(
            new ValueAnimator.AnimatorUpdateListener() {
              @Override
              public void onAnimationUpdate(ValueAnimator animation) {
                thumbRadius = (float) animation.getAnimatedValue();
                postInvalidate();
              }
            });
        radiusAnimator.start();
      } else {
        if (style == Style.Discrete) {
          float val2 = (float) Math.floor((value2 - min + step / 2) / step) * step + min;
          if (valueAnimator != null) valueAnimator.cancel();
          valueAnimator = ValueAnimator.ofFloat(value2, val2);
          valueAnimator.setDuration(200);
          valueAnimator.setInterpolator(interpolator);
          valueAnimator.addUpdateListener(
              new ValueAnimator.AnimatorUpdateListener() {
                @Override
                public void onAnimationUpdate(ValueAnimator animation) {
                  value2 = (float) animation.getAnimatedValue();
                  int thumbX =
                      (int)
                          ((value2 - min)
                                  / (max - min)
                                  * (getWidth() - getPaddingLeft() - getPaddingRight())
                              + getPaddingLeft());
                  int thumbY = getHeight() / 2;
                  int radius = rippleDrawable.getRadius();
                  rippleDrawable.setBounds(
                      thumbX - radius, thumbY - radius, thumbX + radius, thumbY + radius);
                  postInvalidate();
                }
              });
          valueAnimator.start();
        }
        if (radiusAnimator != null) radiusAnimator.end();
        radiusAnimator = ValueAnimator.ofFloat(thumbRadius2, THUMB_RADIUS);
        radiusAnimator.setDuration(200);
        radiusAnimator.setInterpolator(interpolator);
        radiusAnimator.addUpdateListener(
            new ValueAnimator.AnimatorUpdateListener() {
              @Override
              public void onAnimationUpdate(ValueAnimator animation) {
                thumbRadius2 = (float) animation.getAnimatedValue();
                postInvalidate();
              }
            });
        radiusAnimator.start();
      }
      draggedThumb = -1;
      ViewParent parent = getParent();
      if (parent != null) parent.requestDisallowInterceptTouchEvent(false);
    }

    if (draggedThumb == 1) {
      v = (event.getX() - getPaddingLeft()) / (getWidth() - getPaddingLeft() - getPaddingRight());
      v = Math.max(0, Math.min(v, 1));
    } else if (draggedThumb == 2) {
      v2 = (event.getX() - getPaddingLeft()) / (getWidth() - getPaddingLeft() - getPaddingRight());
      v2 = Math.max(0, Math.min(v2, 1));
    }

    if (v > v2) {
      draggedThumb = 3 - draggedThumb;
      float t = v;
      v = v2;
      v2 = t;
    }
    float newValue = v * (max - min) + min;
    float newValue2 = v2 * (max - min) + min;

    if (rippleDrawable != null) {
      rippleDrawable.setHotspot(event.getX(), event.getY());
      int thumbY = getHeight() / 2;
      int radius = rippleDrawable.getRadius();
      if (draggedThumb == 1) {
        int thumbX =
            (int) (v * (getWidth() - getPaddingLeft() - getPaddingRight()) + getPaddingLeft());
        rippleDrawable.setBounds(
            thumbX - radius, thumbY - radius, thumbX + radius, thumbY + radius);
      } else if (draggedThumb == 2) {
        int thumbX2 =
            (int) (v2 * (getWidth() - getPaddingLeft() - getPaddingRight()) + getPaddingLeft());
        rippleDrawable.setBounds(
            thumbX2 - radius, thumbY - radius, thumbX2 + radius, thumbY + radius);
      }
    }

    postInvalidate();
    if (newValue != value && onValueChangedListener != null) {
      if (style == Style.Discrete) {
        int sv = stepValue(newValue);
        int sv2 = stepValue(newValue2);
        if (stepValue(value) != sv || stepValue(value2) != sv2)
          onValueChangedListener.onValueChanged(this, sv, sv2);
      } else {
        onValueChangedListener.onValueChanged(this, newValue, newValue2);
      }
      value = newValue;
    }
    super.onTouchEvent(event);
    return true;
  }
  /** Create the animation of filling the chart by using a valueAnimator to adjust values */
  public void startAnimateMove(@NonNull final DecoEvent event) {
    mIsPaused = false;
    mDrawMode = event.getEventType();
    mVisible = true;

    cancelAnimation();
    mEventCurrent = event;

    final boolean changeColors = event.isColorSet();
    if (changeColors) {
      mColorAnimate = new ColorAnimate(mSeriesItem.getColor(), event.getColor());
      mSeriesItem.setColor(event.getColor());
    }
    float position = event.getEndPosition();

    event.notifyStartListener();

    mPositionStart = mPositionCurrentEnd;
    mPositionEnd = position;

    long animationDuration = event.getEffectDuration();

    if ((animationDuration == 0) || (Math.abs(mPositionEnd - mPositionStart) < 0.01)) {
      cancelAnimation();
      mPositionCurrentEnd = mPositionEnd;
      mEventCurrent = null;
      mPercentComplete = 1.0f;
      for (SeriesItem.SeriesItemListener seriesItemListener : mSeriesItem.getListeners()) {
        seriesItemListener.onSeriesItemAnimationProgress(1.0f, mPositionEnd);
      }
      event.notifyEndListener();
      return;
    }

    if (animationDuration < 0) {
      /**
       * If an animation duration is not set we calculate it using a formula of the proportion of a
       * revolution multiplied by the default time for a full revolution. This ensures that the
       * speed of the move is consistent for all ranges
       */
      animationDuration =
          (Math.abs(
              (int)
                  (mSeriesItem.getSpinDuration()
                      * ((mPositionStart - mPositionEnd) / mSeriesItem.getMaxValue()))));
    }

    mValueAnimator = ValueAnimator.ofFloat(mPositionStart, position);
    mValueAnimator.setDuration(animationDuration);

    /**
     * Note: When setting the Interpolator the default is {@link
     * android.view.animation.AccelerateDecelerateInterpolator}
     *
     * <p>However, if you call setInterpolator(null) then the default is not used, rather: {@link
     * LinearInterpolator}
     */
    if (event.getInterpolator() != null) {
      mValueAnimator.setInterpolator(event.getInterpolator());
    } else {
      if (mSeriesItem.getInterpolator() != null) {
        mValueAnimator.setInterpolator(mSeriesItem.getInterpolator());
      }
    }

    mValueAnimator.addUpdateListener(
        new ValueAnimator.AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator valueAnimator) {
            float current = Float.valueOf(valueAnimator.getAnimatedValue().toString());
            mPercentComplete = (current - mPositionStart) / (mPositionEnd - mPositionStart);
            mPositionCurrentEnd = current;

            /**
             * Notify the listeners of position update. This will be the OrbView itself and possibly
             * the user who is using a listener to update the progress in an alternative manner, ie.
             * displaying text progress %
             */
            for (SeriesItem.SeriesItemListener seriesItemListener : mSeriesItem.getListeners()) {
              seriesItemListener.onSeriesItemAnimationProgress(
                  mPercentComplete, mPositionCurrentEnd);
            }
          }
        });

    mValueAnimator.addListener(
        new AnimatorListenerAdapter() {
          @Override
          public void onAnimationEnd(Animator animation) {
            if (changeColors) {
              mColorAnimate = null;
            }

            event.notifyEndListener();
          }
        });

    mValueAnimator.start();
  }
  @Override
  public List<Animator> createAnimation() {
    List<Animator> animators = new ArrayList<>();
    float startT = getWidth() / 11;
    ValueAnimator translationAnim = ValueAnimator.ofFloat(getWidth() - startT, getWidth() / 2);
    translationAnim.setDuration(650);
    translationAnim.setInterpolator(new LinearInterpolator());
    translationAnim.setRepeatCount(-1);
    translationAnim.addUpdateListener(
        new ValueAnimator.AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator animation) {
            translateX = (float) animation.getAnimatedValue();
            postInvalidate();
          }
        });
    translationAnim.start();

    ValueAnimator alphaAnim = ValueAnimator.ofInt(255, 122);
    alphaAnim.setDuration(650);
    alphaAnim.setRepeatCount(-1);
    alphaAnim.addUpdateListener(
        new ValueAnimator.AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator animation) {
            alpha = (int) animation.getAnimatedValue();
            postInvalidate();
          }
        });
    alphaAnim.start();

    ValueAnimator rotateAnim1 = ValueAnimator.ofFloat(0, 45, 0);
    rotateAnim1.setDuration(650);
    rotateAnim1.setRepeatCount(-1);
    rotateAnim1.addUpdateListener(
        new ValueAnimator.AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator animation) {
            degrees1 = (float) animation.getAnimatedValue();
            postInvalidate();
          }
        });
    rotateAnim1.start();

    ValueAnimator rotateAnim2 = ValueAnimator.ofFloat(0, -45, 0);
    rotateAnim2.setDuration(650);
    rotateAnim2.setRepeatCount(-1);
    rotateAnim2.addUpdateListener(
        new ValueAnimator.AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator animation) {
            degrees2 = (float) animation.getAnimatedValue();
            postInvalidate();
          }
        });
    rotateAnim2.start();

    animators.add(translationAnim);
    animators.add(alphaAnim);
    animators.add(rotateAnim1);
    animators.add(rotateAnim2);
    return animators;
  }
Beispiel #21
0
  @Override
  public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
    boolean hit = e2.getY() > content.getTop() && getParent() != null;

    if (hit && swipeToDismiss && animator == null) {
      swipe = e2.getX() - e1.getX();
      ViewHelper.setTranslationX(content, swipe);
      ViewHelper.setAlpha(content, Math.max(0, 1 - 2 * Math.abs(swipe) / content.getWidth()));
      postInvalidate();
      if (Math.abs(swipe) > content.getWidth() / 4) {
        handler.removeCallbacks(hideRunnable);
        animator = ObjectAnimator.ofFloat(swipe, content.getWidth() / 2.0f * Math.signum(swipe));
        animator.setDuration(200);
        animator.addUpdateListener(
            new ValueAnimator.AnimatorUpdateListener() {
              @Override
              public void onAnimationUpdate(ValueAnimator valueAnimator) {
                float s = (Float) valueAnimator.getAnimatedValue();
                ViewHelper.setTranslationX(content, s);
                float alpha =
                    Math.max(
                        0,
                        1
                            - 2
                                * Math.abs((Float) valueAnimator.getAnimatedValue())
                                / content.getWidth());
                ViewHelper.setAlpha(content, alpha);
                postInvalidate();
              }
            });
        animator.start();
        animator.addListener(
            new AnimatorListenerAdapter() {
              @Override
              public void onAnimationEnd(Animator animation) {
                hideInternal();
                animator = null;
              }
            });
        if (pushedView != null) {
          ValueAnimator animator = ValueAnimator.ofFloat(-1, 0);
          animator.setDuration(200);
          animator.setInterpolator(new DecelerateInterpolator());
          animator.addUpdateListener(
              new ValueAnimator.AnimatorUpdateListener() {
                @Override
                public void onAnimationUpdate(ValueAnimator valueAnimator) {
                  MarginLayoutParams lp = (MarginLayoutParams) content.getLayoutParams();
                  Log.e(
                      "snackbar " + Snackbar.this.hashCode(),
                      ""
                          + ((content.getHeight() + lp.bottomMargin)
                              * (Float) valueAnimator.getAnimatedValue()));
                  ViewHelper.setTranslationY(
                      pushedView,
                      (content.getHeight() + lp.bottomMargin)
                          * (Float) valueAnimator.getAnimatedValue());
                  if (pushedView.getParent() != null)
                    ((View) pushedView.getParent()).postInvalidate();
                }
              });
          animator.start();
        }
      }
      return true;
    }
    return false;
  }