dotLottie Android Player API Reference

DotLottieAnimation Composable Function API

This page documents all parameters and methods for the Android player API, including the DotLottieAnimation composable, XML attributes, Widget class, Controller, EventListener interface, and all supporting types.

Parameters

Functionality

• Loading Animations: The DotLottieAnimation composable function supports loading animations from various sources, including URLs, asset files, raw resources, or raw data using the DotLottieSource type. At least one source must be provided (either via the source parameter or the controller).

• Playback Control: The function integrates with DotLottieController for controlling animation playback, including play, pause, and stop functionalities. The autoplay and loop parameters provide initial playback behavior.

• Customization: Parameters such as speed, playMode, useFrameInterpolation, marker, and segment allow for customization of the animation playback, including its speed, direction, smoothness, and specific parts to play.

• Event Handling: The eventListeners parameter allows developers to attach multiple event listeners to handle various animation events, such as loading errors or completion, using the DotLottieEventListener interface.

• Theming: The themeId parameter allows applying pre-defined themes packed within a .lottie file.

• Layout: The layout parameter controls how the animation fits and aligns within the composable's bounds.

• State Machine: The stateMachineId parameter allows a state machine to be loaded automatically when the animation loads.

Example Usage

import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.foundation.background
import com.lottiefiles.dotlottie.core.util.DotLottieSource
import com.dotlottie.dlplayer.Mode
import com.lottiefiles.dotlottie.core.widget.DotLottieController
import com.lottiefiles.dotlottie.core.model.DotLottieEventListener

DotLottieAnimation(
    modifier = Modifier.background(Color.LightGray),
    source = DotLottieSource.Url("https://lottie.host/294b684d-d6b4-4116-ab35-85ef566d4379/VkGHcqcMUI.lottie"),
    autoplay = true,
    loop = true,
    speed = 1.5f,
    playMode = Mode.FORWARD,
)

DotLottieAnimation XML Attributes

The DotLottieAnimation class utilizes a set of XML attributes for configuration within layout XML files. These attributes allow for the customization of animation properties directly from XML. Below is a table summarizing the available XML attributes and their functionalities:

These XML attributes provide a convenient way to configure DotLottieAnimation properties directly within layout files, offering flexibility in setting up animations without the need for additional code.

DotLottieAnimation Widget Class API Reference

This reference details the properties, methods, and events available in the com.lottiefiles.dotlottie.core.widget.DotLottieAnimation class (used with XML layouts), providing a comprehensive guide for developers to effectively utilize this class in their Android applications.

Properties

Methods

Events

The DotLottieAnimation class uses the DotLottieEventListener interface to notify about various animation events. Implementations of this interface can listen for the events defined in the DotLottieEventListener Interface section below (e.g., onPlay(), onPause(), onFrame(frame: Float), etc.).

DotLottieController Class

The DotLottieController class provides a comprehensive interface for managing the playback and configuration of dotLottie animations within Jetpack Compose.

Properties

Methods

Note: Both the Widget and the Controller expose freeze() / unFreeze(). The Widget implementation toggles the drawable's freeze flag directly; the Controller implementation calls pause() / play() and updates the playback state accordingly.

Event Handling

The DotLottieController class allows for the registration of event listeners that implement the DotLottieEventListener Interface interface. These listeners can respond to various animation events.

DotLottieEventListener Interface

The DotLottieEventListener interface defines a set of callback methods that respond to various animation events. Implementing this interface allows for handling animation lifecycle events, playback state changes, and rendering updates.

Methods

StateMachineEventListener Interface

The StateMachineEventListener interface defines callbacks for state machine events:

DotLottieSource

The DotLottieSource sealed class represents the different animation sources:

Event Sealed Class (State Machine)

The Event sealed class represents events that can be posted to a state machine:

sealed class Event(val type: Int) {
    data class PointerDown(val x: Float, val y: Float) : Event(0)
    data class PointerUp(val x: Float, val y: Float) : Event(1)
    data class PointerMove(val x: Float, val y: Float) : Event(2)
    data class PointerEnter(val x: Float, val y: Float) : Event(3)
    data class PointerExit(val x: Float, val y: Float) : Event(4)
    data class Click(val x: Float, val y: Float) : Event(5)
    object OnComplete : Event(6)
    object OnLoopComplete : Event(7)
}

DotLottiePlayerState Enum

Represents the current state of the player:

Fit Enum

Controls how the animation scales within its container:

LayoutUtil.Alignment Enum

Predefined alignment positions for the animation within its container:

Layout Data Class

The Layout data class configures the fit and alignment of the animation. Use createDefaultLayout() for the default configuration (Contain fit, centered alignment).

OpenUrlPolicy Data Class

Configures URL opening behavior for state machines:

Marker Data Class

Represents a named marker in the animation:

Manifest Data Class

Represents the dotLottie manifest from a .lottie file:

Manifest.Animation

Manifest.Theme

Manifest.StateMachine

Config.Builder

The Config.Builder class constructs an animation configuration for loading with the Widget's load(config) method:

val config = Config.Builder()
    .autoplay(true)
    .speed(1f)
    .loop(true)
    .source(DotLottieSource.Url("https://example.com/animation.lottie"))
    .useFrameInterpolation(true)
    .playMode(Mode.FORWARD)
    .build()
dotLottieAnimationView.load(config)