LottieAnimationView (lottie API)

java.lang.Object
- AppCompatImageView
- - com.airbnb.lottie.LottieAnimationView

```
public class LottieAnimationView
extends AppCompatImageView
```
This view will load, deserialize, and display an After Effects animation exported with bodymovin (https://github.com/bodymovin/bodymovin).
You may set the animation in one of two ways: 1) Attrs: R.styleable#LottieAnimationView_lottie_fileName 2) Programmatically: setAnimation(String) setAnimation(JsonReader, String) setAnimationFromJson(String, String) setAnimationFromUrl(String) setComposition(LottieComposition)
You can set a default cache strategy with R.attr#lottie_cacheStrategy.
You can manually set the progress of the animation with setProgress(float) or R.attr#lottie_progress

See Also:

Full Documentation

Constructor Summary

Constructors
Constructor and Description
`LottieAnimationView(android.content.Context context)`
`LottieAnimationView(android.content.Context context, android.util.AttributeSet attrs)`
`LottieAnimationView(android.content.Context context, android.util.AttributeSet attrs, int defStyleAttr)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addAnimatorListener(android.animation.Animator.AnimatorListener listener)`
`void`	`addAnimatorUpdateListener(android.animation.ValueAnimator.AnimatorUpdateListener updateListener)`
`boolean`	`addLottieOnCompositionLoadedListener(LottieOnCompositionLoadedListener lottieOnCompositionLoadedListener)`
`<T> void`	`addValueCallback(KeyPath keyPath, T property, LottieValueCallback<T> callback)` Add a property callback for the specified `KeyPath`.
`<T> void`	`addValueCallback(KeyPath keyPath, T property, SimpleLottieValueCallback<T> callback)` Overload of `addValueCallback(KeyPath, Object, LottieValueCallback)` that takes an interface.
`void`	`buildDrawingCache(boolean autoScale)` If rendering via software, Android will fail to generate a bitmap if the view is too large.
`void`	`cancelAnimation()`
`void`	`enableMergePathsForKitKatAndAbove(boolean enable)` Enable this to get merge path support for devices running KitKat (19) and above.
`LottieComposition`	`getComposition()`
`long`	`getDuration()`
`int`	`getFrame()` Get the currently rendered frame.
`java.lang.String`	`getImageAssetsFolder()`
`float`	`getMaxFrame()` Returns the maximum frame set by `setMaxFrame(int)` or `setMaxProgress(float)`
`float`	`getMinFrame()` Returns the minimum frame set by `setMinFrame(int)` or `setMinProgress(float)`
`PerformanceTracker`	`getPerformanceTracker()`
`float`	`getProgress()`
`int`	`getRepeatCount()` Defines how many times the animation should repeat.
`int`	`getRepeatMode()` Defines what this animation should do when it reaches the end.
`float`	`getScale()`
`float`	`getSpeed()` Returns the current playback speed.
`boolean`	`hasMasks()` Returns whether or not any layers in this composition has masks.
`boolean`	`hasMatte()` Returns whether or not any layers in this composition has a matte layer.
`void`	`invalidateDrawable(android.graphics.drawable.Drawable dr)`
`boolean`	`isAnimating()`
`boolean`	`isMergePathsEnabledForKitKatAndAbove()` Returns whether merge paths are enabled for KitKat and above.
`void`	`loop(boolean loop)` Deprecated.
`protected void`	`onAttachedToWindow()`
`protected void`	`onDetachedFromWindow()`
`protected void`	`onRestoreInstanceState(android.os.Parcelable state)`
`protected android.os.Parcelable`	`onSaveInstanceState()`
`protected void`	`onVisibilityChanged(android.view.View changedView, int visibility)`
`void`	`pauseAnimation()`
`void`	`playAnimation()` Plays the animation from the beginning.
`void`	`removeAllAnimatorListeners()`
`void`	`removeAllLottieOnCompositionLoadedListener()`
`void`	`removeAllUpdateListeners()`
`void`	`removeAnimatorListener(android.animation.Animator.AnimatorListener listener)`
`boolean`	`removeLottieOnCompositionLoadedListener(LottieOnCompositionLoadedListener lottieOnCompositionLoadedListener)`
`void`	`removeUpdateListener(android.animation.ValueAnimator.AnimatorUpdateListener updateListener)`
`java.util.List<KeyPath>`	`resolveKeyPath(KeyPath keyPath)` Takes a `KeyPath`, potentially with wildcards or globstars and resolve it to a list of zero or more actual `Keypaths` that exist in the current animation.
`void`	`resumeAnimation()` Continues playing the animation from its current position.
`void`	`reverseAnimationSpeed()` Reverses the current animation speed.
`void`	`setAnimation(int rawRes)` Sets the animation from a file in the raw directory.
`void`	`setAnimation(android.util.JsonReader reader, java.lang.String cacheKey)` Sets the animation from a JSONReader.
`void`	`setAnimation(java.lang.String assetName)`
`void`	`setAnimationFromJson(java.lang.String jsonString)` Deprecated.
`void`	`setAnimationFromJson(java.lang.String jsonString, java.lang.String cacheKey)` Sets the animation from json string.
`void`	`setAnimationFromUrl(java.lang.String url)` Load a lottie animation from a url.
`void`	`setComposition(LottieComposition composition)` Sets a composition.
`void`	`setFontAssetDelegate(FontAssetDelegate assetDelegate)` Use this to manually set fonts.
`void`	`setFrame(int frame)` Sets the progress to the specified frame.
`void`	`setImageAssetDelegate(ImageAssetDelegate assetDelegate)` Use this if you can't bundle images with your app.
`void`	`setImageAssetsFolder(java.lang.String imageAssetsFolder)` If you use image assets, you must explicitly specify the folder in assets/ in which they are located because bodymovin uses the name filenames across all compositions (img_#).
`void`	`setImageBitmap(android.graphics.Bitmap bm)`
`void`	`setImageDrawable(android.graphics.drawable.Drawable drawable)`
`void`	`setImageResource(int resId)`
`void`	`setMaxFrame(int endFrame)` Sets the maximum frame that the animation will end at when playing or looping.
`void`	`setMaxFrame(java.lang.String markerName)` Sets the maximum frame to the start time + duration of the specified marker.
`void`	`setMaxProgress(float endProgress)` Sets the maximum progress that the animation will end at when playing or looping.
`void`	`setMinAndMaxFrame(int minFrame, int maxFrame)`
`void`	`setMinAndMaxFrame(java.lang.String markerName)` Sets the minimum and maximum frame to the start time and start time + duration of the specified marker.
`void`	`setMinAndMaxProgress(float minProgress, float maxProgress)`
`void`	`setMinFrame(int startFrame)` Sets the minimum frame that the animation will start from when playing or looping.
`void`	`setMinFrame(java.lang.String markerName)` Sets the minimum frame to the start time of the specified marker.
`void`	`setMinProgress(float startProgress)` Sets the minimum progress that the animation will start from when playing or looping.
`void`	`setPerformanceTrackingEnabled(boolean enabled)`
`void`	`setProgress(float progress)`
`void`	`setRenderMode(RenderMode renderMode)` Call this to set whether or not to render with hardware or software acceleration.
`void`	`setRepeatCount(int count)` Sets how many times the animation should be repeated.
`void`	`setRepeatMode(int mode)` Defines what this animation should do when it reaches the end.
`void`	`setScale(float scale)` Set the scale on the current composition.
`void`	`setSpeed(float speed)` Sets the playback speed.
`void`	`setTextDelegate(TextDelegate textDelegate)` Set this to replace animation text with custom text at runtime
`android.graphics.Bitmap`	`updateBitmap(java.lang.String id, android.graphics.Bitmap bitmap)` Allows you to modify or clear a bitmap that was loaded for an image either automatically through `setImageAssetsFolder(String)` or with an `ImageAssetDelegate`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - LottieAnimationView
```
public LottieAnimationView(android.content.Context context)
```
  - LottieAnimationView
```
public LottieAnimationView(android.content.Context context,
                           android.util.AttributeSet attrs)
```
  - LottieAnimationView
```
public LottieAnimationView(android.content.Context context,
                           android.util.AttributeSet attrs,
                           int defStyleAttr)
```
- Method Detail
  - setImageResource
```
public void setImageResource(int resId)
```
  - setImageDrawable
```
public void setImageDrawable(android.graphics.drawable.Drawable drawable)
```
  - setImageBitmap
```
public void setImageBitmap(android.graphics.Bitmap bm)
```
  - invalidateDrawable
```
public void invalidateDrawable(android.graphics.drawable.Drawable dr)
```
  - onSaveInstanceState
```
protected android.os.Parcelable onSaveInstanceState()
```
  - onRestoreInstanceState
```
protected void onRestoreInstanceState(android.os.Parcelable state)
```
  - onVisibilityChanged
```
protected void onVisibilityChanged(android.view.View changedView,
                                   int visibility)
```
  - onAttachedToWindow
```
protected void onAttachedToWindow()
```
  - onDetachedFromWindow
```
protected void onDetachedFromWindow()
```
  - enableMergePathsForKitKatAndAbove
```
public void enableMergePathsForKitKatAndAbove(boolean enable)
```
    Enable this to get merge path support for devices running KitKat (19) and above. Merge paths currently don't work if the the operand shape is entirely contained within the first shape. If you need to cut out one shape from another shape, use an even-odd fill type instead of using merge paths.
  - isMergePathsEnabledForKitKatAndAbove
```
public boolean isMergePathsEnabledForKitKatAndAbove()
```
    Returns whether merge paths are enabled for KitKat and above.
  - setAnimation
```
public void setAnimation(int rawRes)
```
    Sets the animation from a file in the raw directory. This will load and deserialize the file asynchronously.
  - setAnimation
```
public void setAnimation(java.lang.String assetName)
```
  - setAnimationFromJson
```
@Deprecated
public void setAnimationFromJson(java.lang.String jsonString)
```
    Deprecated.
    
    See Also:
    
    setAnimationFromJson(String, String)
  - setAnimationFromJson
```
public void setAnimationFromJson(java.lang.String jsonString,
                                 java.lang.String cacheKey)
```
    Sets the animation from json string. This is the ideal API to use when loading an animation over the network because you can use the raw response body here and a conversion to a JSONObject never has to be done.
  - setAnimation
```
public void setAnimation(android.util.JsonReader reader,
                         java.lang.String cacheKey)
```
    Sets the animation from a JSONReader. This will load and deserialize the file asynchronously.
    This is particularly useful for animations loaded from the network. You can fetch the bodymovin json from the network and pass it directly here.
  - setAnimationFromUrl
```
public void setAnimationFromUrl(java.lang.String url)
```
    Load a lottie animation from a url. The url can be a json file or a zip file. Use a zip file if you have images. Simply zip them together and lottie will unzip and link the images automatically. Under the hood, Lottie uses Java HttpURLConnection because it doesn't require any transitive networking dependencies. It will download the file to the application cache under a temporary name. If the file successfully parses to a composition, it will rename the temporary file to one that can be accessed immediately for subsequent requests. If the file does not parse to a composition, the temporary file will be deleted.
  - setComposition
```
public void setComposition(LottieComposition composition)
```
    Sets a composition. You can set a default cache strategy if this view was inflated with xml by using R.attr#lottie_cacheStrategy.
  - getComposition
```
public LottieComposition getComposition()
```
  - hasMasks
```
public boolean hasMasks()
```
    Returns whether or not any layers in this composition has masks.
  - hasMatte
```
public boolean hasMatte()
```
    Returns whether or not any layers in this composition has a matte layer.
  - playAnimation
```
public void playAnimation()
```
    Plays the animation from the beginning. If speed is < 0, it will start at the end and play towards the beginning
  - resumeAnimation
```
public void resumeAnimation()
```
    Continues playing the animation from its current position. If speed < 0, it will play backwards from the current position.
  - setMinFrame
```
public void setMinFrame(int startFrame)
```
    Sets the minimum frame that the animation will start from when playing or looping.
  - getMinFrame
```
public float getMinFrame()
```
    Returns the minimum frame set by setMinFrame(int) or setMinProgress(float)
  - setMinProgress
```
public void setMinProgress(float startProgress)
```
    Sets the minimum progress that the animation will start from when playing or looping.
  - setMaxFrame
```
public void setMaxFrame(int endFrame)
```
    Sets the maximum frame that the animation will end at when playing or looping.
  - getMaxFrame
```
public float getMaxFrame()
```
    Returns the maximum frame set by setMaxFrame(int) or setMaxProgress(float)
  - setMaxProgress
```
public void setMaxProgress(float endProgress)
```
    Sets the maximum progress that the animation will end at when playing or looping.
  - setMinFrame
```
public void setMinFrame(java.lang.String markerName)
```
    Sets the minimum frame to the start time of the specified marker.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the marker is not found.
  - setMaxFrame
```
public void setMaxFrame(java.lang.String markerName)
```
    Sets the maximum frame to the start time + duration of the specified marker.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the marker is not found.
  - setMinAndMaxFrame
```
public void setMinAndMaxFrame(java.lang.String markerName)
```
    Sets the minimum and maximum frame to the start time and start time + duration of the specified marker.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the marker is not found.
  - setMinAndMaxFrame
```
public void setMinAndMaxFrame(int minFrame,
                              int maxFrame)
```
    See Also:
    
    setMinFrame(int), setMaxFrame(int)
  - setMinAndMaxProgress
```
public void setMinAndMaxProgress(float minProgress,
                                 float maxProgress)
```
    See Also:
    
    setMinProgress(float), setMaxProgress(float)
  - reverseAnimationSpeed
```
public void reverseAnimationSpeed()
```
    Reverses the current animation speed. This does NOT play the animation.
    
    See Also:
    
    setSpeed(float), playAnimation(), resumeAnimation()
  - setSpeed
```
public void setSpeed(float speed)
```
    Sets the playback speed. If speed < 0, the animation will play backwards.
  - getSpeed
```
public float getSpeed()
```
    Returns the current playback speed. This will be < 0 if the animation is playing backwards.
  - addAnimatorUpdateListener
```
public void addAnimatorUpdateListener(android.animation.ValueAnimator.AnimatorUpdateListener updateListener)
```
  - removeUpdateListener
```
public void removeUpdateListener(android.animation.ValueAnimator.AnimatorUpdateListener updateListener)
```
  - removeAllUpdateListeners
```
public void removeAllUpdateListeners()
```
  - addAnimatorListener
```
public void addAnimatorListener(android.animation.Animator.AnimatorListener listener)
```
  - removeAnimatorListener
```
public void removeAnimatorListener(android.animation.Animator.AnimatorListener listener)
```
  - removeAllAnimatorListeners
```
public void removeAllAnimatorListeners()
```
  - loop
```
@Deprecated
public void loop(boolean loop)
```
    Deprecated.
    
    See Also:
    
    setRepeatCount(int)
  - setRepeatMode
```
public void setRepeatMode(int mode)
```
    Defines what this animation should do when it reaches the end. This setting is applied only when the repeat count is either greater than 0 or LottieDrawable.INFINITE. Defaults to LottieDrawable.RESTART.
    
    Parameters:
    
    mode - LottieDrawable.RESTART or LottieDrawable.REVERSE
  - getRepeatMode
```
public int getRepeatMode()
```
    Defines what this animation should do when it reaches the end.
    
    Returns:
    
    either one of LottieDrawable.REVERSE or LottieDrawable.RESTART
  - setRepeatCount
```
public void setRepeatCount(int count)
```
    Sets how many times the animation should be repeated. If the repeat count is 0, the animation is never repeated. If the repeat count is greater than 0 or LottieDrawable.INFINITE, the repeat mode will be taken into account. The repeat count is 0 by default.
    
    Parameters:
    
    count - the number of times the animation should be repeated
  - getRepeatCount
```
public int getRepeatCount()
```
    Defines how many times the animation should repeat. The default value is 0.
    
    Returns:
    
    the number of times the animation should repeat, or LottieDrawable.INFINITE
  - isAnimating
```
public boolean isAnimating()
```
  - setImageAssetsFolder
```
public void setImageAssetsFolder(java.lang.String imageAssetsFolder)
```
    If you use image assets, you must explicitly specify the folder in assets/ in which they are located because bodymovin uses the name filenames across all compositions (img_#). Do NOT rename the images themselves. If your images are located in src/main/assets/airbnb_loader/ then call `setImageAssetsFolder("airbnb_loader/");`. Be wary if you are using many images, however. Lottie is designed to work with vector shapes from After Effects. If your images look like they could be represented with vector shapes, see if it is possible to convert them to shape layers and re-export your animation. Check the documentation at http://airbnb.io/lottie for more information about importing shapes from Sketch or Illustrator to avoid this.
  - getImageAssetsFolder
```
public java.lang.String getImageAssetsFolder()
```
  - updateBitmap
```
public android.graphics.Bitmap updateBitmap(java.lang.String id,
                                            android.graphics.Bitmap bitmap)
```
    Allows you to modify or clear a bitmap that was loaded for an image either automatically through setImageAssetsFolder(String) or with an ImageAssetDelegate.
    
    Returns:
    
    the previous Bitmap or null.
  - setImageAssetDelegate
```
public void setImageAssetDelegate(ImageAssetDelegate assetDelegate)
```
    Use this if you can't bundle images with your app. This may be useful if you download the animations from the network or have the images saved to an SD Card. In that case, Lottie will defer the loading of the bitmap to this delegate. Be wary if you are using many images, however. Lottie is designed to work with vector shapes from After Effects. If your images look like they could be represented with vector shapes, see if it is possible to convert them to shape layers and re-export your animation. Check the documentation at http://airbnb.io/lottie for more information about importing shapes from Sketch or Illustrator to avoid this.
  - setFontAssetDelegate
```
public void setFontAssetDelegate(FontAssetDelegate assetDelegate)
```
    Use this to manually set fonts.
  - setTextDelegate
```
public void setTextDelegate(TextDelegate textDelegate)
```
    Set this to replace animation text with custom text at runtime
  - resolveKeyPath
```
public java.util.List<KeyPath> resolveKeyPath(KeyPath keyPath)
```
    Takes a KeyPath, potentially with wildcards or globstars and resolve it to a list of zero or more actual Keypaths that exist in the current animation. If you want to set value callbacks for any of these values, it is recommended to use the returned KeyPath objects because they will be internally resolved to their content and won't trigger a tree walk of the animation contents when applied.
  - addValueCallback
```
public <T> void addValueCallback(KeyPath keyPath,
                                 T property,
                                 LottieValueCallback<T> callback)
```
    Add a property callback for the specified KeyPath. This KeyPath can resolve to multiple contents. In that case, the callback's value will apply to all of them. Internally, this will check if the KeyPath has already been resolved with resolveKeyPath(KeyPath) and will resolve it if it hasn't.
  - addValueCallback
```
public <T> void addValueCallback(KeyPath keyPath,
                                 T property,
                                 SimpleLottieValueCallback<T> callback)
```
    Overload of addValueCallback(KeyPath, Object, LottieValueCallback) that takes an interface. This allows you to use a single abstract method code block in Kotlin such as: animationView.addValueCallback(yourKeyPath, LottieProperty.COLOR) { yourColor }
  - setScale
```
public void setScale(float scale)
```
    Set the scale on the current composition. The only cost of this function is re-rendering the current frame so you may call it frequent to scale something up or down. The smaller the animation is, the better the performance will be. You may find that scaling an animation down then rendering it in a larger ImageView and letting ImageView scale it back up with a scaleType such as centerInside will yield better performance with little perceivable quality loss. You can also use a fixed view width/height in conjunction with the normal ImageView scaleTypes centerCrop and centerInside.
  - getScale
```
public float getScale()
```
  - cancelAnimation
```
public void cancelAnimation()
```
  - pauseAnimation
```
public void pauseAnimation()
```
  - setFrame
```
public void setFrame(int frame)
```
    Sets the progress to the specified frame. If the composition isn't set yet, the progress will be set to the frame when it is.
  - getFrame
```
public int getFrame()
```
    Get the currently rendered frame.
  - setProgress
```
public void setProgress(float progress)
```
  - getProgress
```
public float getProgress()
```
  - getDuration
```
public long getDuration()
```
  - setPerformanceTrackingEnabled
```
public void setPerformanceTrackingEnabled(boolean enabled)
```
  - getPerformanceTracker
```
public PerformanceTracker getPerformanceTracker()
```
  - buildDrawingCache
```
public void buildDrawingCache(boolean autoScale)
```
    If rendering via software, Android will fail to generate a bitmap if the view is too large. Rather than displaying nothing, fallback on hardware acceleration which may incur a performance hit.
    
    See Also:
    
    setRenderMode(RenderMode), LottieDrawable.draw(android.graphics.Canvas)
  - setRenderMode
```
public void setRenderMode(RenderMode renderMode)
```
    Call this to set whether or not to render with hardware or software acceleration. Lottie defaults to Automatic which will use hardware acceleration unless: 1) There are dash paths and the device is pre-Pie. 2) There are more than 4 masks and mattes and the device is pre-Pie. Hardware acceleration is generally faster for those devices unless there are many large mattes and masks in which case there is a ton of GPU uploadTexture thrashing which makes it much slower. In most cases, hardware rendering will be faster, even if you have mattes and masks. However, if you have multiple mattes and masks (especially large ones) then you should test both render modes. You should also test on pre-Pie and Pie+ devices because the underlying rendering enginge changed significantly.
  - addLottieOnCompositionLoadedListener
```
public boolean addLottieOnCompositionLoadedListener(LottieOnCompositionLoadedListener lottieOnCompositionLoadedListener)
```
  - removeLottieOnCompositionLoadedListener
```
public boolean removeLottieOnCompositionLoadedListener(LottieOnCompositionLoadedListener lottieOnCompositionLoadedListener)
```
  - removeAllLottieOnCompositionLoadedListener
```
public void removeAllLottieOnCompositionLoadedListener()
```

Class LottieAnimationView

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

LottieAnimationView

LottieAnimationView

LottieAnimationView

Method Detail

setImageResource

setImageDrawable

setImageBitmap

invalidateDrawable

onSaveInstanceState

onRestoreInstanceState

onVisibilityChanged

onAttachedToWindow

onDetachedFromWindow

enableMergePathsForKitKatAndAbove

isMergePathsEnabledForKitKatAndAbove

setAnimation

setAnimation

setAnimationFromJson

setAnimationFromJson

setAnimation

setAnimationFromUrl

setComposition

getComposition

hasMasks

hasMatte

playAnimation

resumeAnimation

setMinFrame

getMinFrame

setMinProgress

setMaxFrame

getMaxFrame

setMaxProgress

setMinFrame

setMaxFrame

setMinAndMaxFrame

setMinAndMaxFrame

setMinAndMaxProgress

reverseAnimationSpeed

setSpeed

getSpeed

addAnimatorUpdateListener

removeUpdateListener

removeAllUpdateListeners

addAnimatorListener

removeAnimatorListener

removeAllAnimatorListeners

loop

setRepeatMode

getRepeatMode

setRepeatCount

getRepeatCount

isAnimating

setImageAssetsFolder

getImageAssetsFolder

updateBitmap

setImageAssetDelegate

setFontAssetDelegate

setTextDelegate

resolveKeyPath

addValueCallback

addValueCallback

setScale

getScale

cancelAnimation

pauseAnimation

setFrame

getFrame

setProgress

getProgress

getDuration

setPerformanceTrackingEnabled

getPerformanceTracker

buildDrawingCache

setRenderMode