Benutzerdefiniert android AccelerateDecelerateInterpolator

Question

Ich versuche AccelerateDecelerateInterpolator zu verwenden und es anzupassen. Ich kann sehen, dass Interpolatoren wie DecelerateInterpolator ein "Faktor" -Feld haben, so dass Sie sein Verhalten ändern können. aber AccelerateDecelerateInterpolator hat nicht. Wenn ich AccelerateDecelerateInterpolator benutze, merke ich fast gar nicht, dass der Interpolator irgendetwas macht. Die Animation sieht sehr linear aus. Also, gibt es eine Möglichkeit, den AccelerateDecelerateInterpolator zu faktorisieren oder in irgendeiner Weise zu ändern? Danke

Answer 1

können Sie Standard-Beschleunigungsfunktion mit Ihrem eigenen Interpolator implementieren. Zum Beispiel wäre dies die Implementierung für die easeInOutQuint:

public class MVAccelerateDecelerateInterpolator implements Interpolator { 

    // easeInOutQuint 
    public float getInterpolation(float t) { 
     float x = t*2.0f; 
     if (t<0.5f) return 0.5f*x*x*x*x*x; 
     x = (t-0.5f)*2-1; 
     return 0.5f*x*x*x*x*x+1; 
    } 
} 

Answer 2

Ich habe versucht, meinen eigenen TimeInterpolator als benutzerdefinierte AccelerateDecelerateInterpolator zu definieren. Ich bin nicht sehr glücklich mit dem Ergebnis, aber es könnte ein paar Ideen geben. Es gibt auch eine Art Faktor im Code: 0.05f. Überprüfen Sie es heraus:

TimeInterpolator interpolator = new TimeInterpolator() { 
     @Override 
     public float getInterpolation(float input) { 
      return input + 0.05f * (float) Math.sin(2 * Math.PI * input); 
     } 
    }; 

Hier ist raffiniertere Lösung. Tangente ist wahrscheinlich eine bessere Funktion für den Job, als Sinus. Diese Lösung beschleunigt am Anfang und am Ende. Es gibt auch einen Faktor, um die Beschleunigung zu bestimmen.

TimeInterpolator interpolator = new TimeInterpolator() { 
     private final float mFactor = 1.1f; // less than pi/2 
     private float  oldRetVal; 
     private float  oldInputVal; 
     private double  initValue = Math.tan(-mFactor); 
     private double  endValue = 2 * Math.tan(mFactor); 

     @Override 
     public float getInterpolation(float input) { 
      if (oldInputVal != input) { 
       oldInputVal = input; 
       oldRetVal = (float) ((Math.tan(mFactor * (2 * input - 1)) - initValue)/endValue); 
      } 
      return oldRetVal; 
     } 
    }; 

Answer 3

Android hat PathInterpolatorCompat zum v4 Support-Bibliothek hinzugefügt. Jetzt mit diesem: https://gist.github.com/ebabel/8ff41cad01e9ce1dd9ce können Sie ein easeInOutQuint, easeInOutQuart oder ein easeInOutExpo mit Leichtigkeit angeben!

public static void expand(final View v) { 
     v.measure(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT); 
     final int targetHeight = v.getMeasuredHeight(); 

     if (v.getHeight() != targetHeight) { 
      // Older versions of android (pre API 21) cancel animations for views with a height of 0 so use 1 instead. 
      v.getLayoutParams().height = 1; 
      v.setVisibility(View.VISIBLE); 


      Animation a = new Animation() { 
       @Override 
       protected void applyTransformation(float interpolatedTime, Transformation t) { 
        v.getLayoutParams().height = interpolatedTime == 1 
          ? ViewGroup.LayoutParams.WRAP_CONTENT 
          : (int) (targetHeight * interpolatedTime); 
        v.requestLayout(); 
       } 

       @Override 
       public boolean willChangeBounds() { 
        return true; 
       } 
      }; 

      a.setInterpolator(EasingsConstants.easeInOutQuart); 
      a.setDuration(computeDurationFromHeight(v)); 
      v.startAnimation(a); 
     } else { 
      Log.d("AnimationUtil", "expand Already expanded "); 
     } 
    } 

/** 
* 1dp/ms * multiplier 
*/ 
private static int computeDurationFromHeight(View v) { 
    return (int) (v.getMeasuredHeight()/v.getContext().getResources().getDisplayMetrics().density) * DURATION_MULTIPLIER; 
} 

Und vergessen Sie nicht Ihre build.gradle:

compile "com.android.support:support-v4:22.2.0"