ValueAnimator<\/code>—and more precisely, in our case, its subclass ObjectAnimator<\/code>. Both let you construct animations over a range of normal scalar types like float or int for any property. Their true power, however, lies in the fact that they can animate properties of any object type with the right configuration (more on that in the next section).<\/p>\nIn addition, an often-overlooked fact is that animation timing behavior is not set in stone. Indeed, each of the animation APIs on Android can optionally take an ITimeInterpolator<\/code> which defines the “time shape” of the animations. For instance, the following are the respective time shapes of two of the default interpolators used in the framework, LinearInterpolator<\/code> and AccelerateDecelerateInterpolator<\/code>:<\/p>\n![\"Linear](\"\/wp-content\/uploads\/sites\/44\/2019\/04\/linear-300x197.png\")
<\/a>![\"Accelerate\/Decelerate](\"\/wp-content\/uploads\/sites\/44\/2019\/04\/acceleratedecelerate-300x197.png\")
<\/a><\/p>\nCreating your own time interpolator is also very easy. You simply have to inplement the ITimeInterpolator<\/code> interface which has only one method: GetInterpolation(float)<\/code>. The argument passed to that method is the current step of the animation, which is a value between 0<\/strong> (the start of your animation) and 1.0<\/strong> (its end). You are generally supposed to return a value in that range too, but adjacent values are also supported and are being translated to an overshoot or an undershoot effect.<\/p>\nAdditionaly, the formula you are using to compute your final value can be as complex as you want as long as it doesn’t impede the rendering loop (remember, for animations to be buttery smooth you want to aim for 60 FPS). For instance, imagining I needed a time interpolator to represent the fall of an object (a typical quadratic equation<\/a>), I could do it like this:<\/p>\n\nclass QuadraticTimeInterpolator : Java.Lang.Object, ITimeInterpolator\n{\n\tpublic float GetInterpolation (float input)\n\t{\n\t\treturn input * input; \/\/ or (float)Math.Pow (input, 2)\n\t}\n}\n<\/pre>\nWhich corresponds to the following shape:<\/p>\n
![\"Quadratic](\"\/wp-content\/uploads\/sites\/44\/2019\/04\/power2-300x197.png\")
<\/a><\/p>\nSo why is this useful?<\/p>\n
Although you can generally use the default interpolator (AccelerateDecelerateInterpolator<\/code>), if your animations are supposed to model a real-life phenomenon (like my example of an object falling) then you should strive to find the equation that faithfully reproduces the physical behavior your users expect<\/a>.<\/p>\nPractical example<\/h3>\n
Let’s now see a practical example of the two features I mentioned about property animation: customized time interpolator<\/strong> and animating over non-scalar values<\/strong>. For our experiment we are going to use Google Maps v2 API<\/a> and try to add a bit of spice to Marker<\/code> objects—which, by default, can’t be animated with the existing API.<\/p>\nThe idea is to create a dropping effect for the pin:<\/p>\n
![\"Linear](\"\/wp-content\/uploads\/sites\/44\/2019\/04\/linear.png\")
<\/a>![\"Accelerate\/Decelerate](\"\/wp-content\/uploads\/sites\/44\/2019\/04\/acceleratedecelerate.png\")
<\/a><\/p>\n