---
title: "Afficher la progression de l'utilisateur avec une animation Lottie"
description: "Affichez la progression de chaque utilisateur, par exemple une série quotidienne, sous forme d'animation Lottie sur un écran de flow."
---

> **AI agents**: to search Adapty docs faster and with fewer tokens, install the Adapty skills: `npx adapty skills install --yes`

Suivez cette recette pour afficher la progression de l'utilisateur sous forme d'animation Lottie — par exemple, un anneau qui se remplit pour indiquer sa série quotidienne. Votre application affiche l'animation en tant que vue Lottie native dans un [élément personnalisé](flow-custom-elements).

<DocVideo id="custom-element-lottie-demo.mp4" width="300px" alt="Le flow terminé : l'utilisateur appuie sur See my streak, et sur l'écran suivant, l'anneau se remplit jusqu'à 4 jours sur 7." />

## Avant de commencer \{#before-you-start\}

<Tabs groupId="current-os" queryString>
<TabItem value="kotlin" label="Kotlin" default>

- Mettez à jour votre application avec le SDK Android Adapty 4.4 ou version ultérieure. Les versions antérieures du SDK affichent le [contenu de secours](flow-custom-elements#set-fallback-content) pour chaque élément personnalisé.
- Configurez votre application pour [récupérer](android-get-pb-paywalls) et [afficher](android-present-paywalls) les flows.
- Configurez Jetpack Compose dans le module de votre application. La vue d'animation de cette recette est un composable.
- Ajoutez Lottie pour Jetpack Compose à votre application avec Gradle, depuis `com.airbnb.android:lottie-compose`.

</TabItem>
<TabItem value="java" label="Java">

- Mettez à jour votre application avec le SDK Android d'Adapty 4.4 ou version ultérieure. Les versions antérieures du SDK affichent le [contenu de secours](flow-custom-elements#set-fallback-content) pour chaque élément personnalisé.
- Configurez votre application pour [récupérer](android-get-pb-paywalls) et [afficher](android-present-paywalls) les flows.
- Ajoutez Lottie à votre application avec Gradle, depuis `com.airbnb.android:lottie`.

</TabItem>
</Tabs>

Préparez une animation Lottie au format `.json`, ou téléchargez l'exemple [`streak_ring.json`](https://raw.githubusercontent.com/adaptyteam/adapty-docs/refs/heads/main/Downloads/streak_ring.json). L'application lit l'animation depuis le début et l'arrête proportionnellement à la progression, par exemple à mi-chemin pour 50 %. Pour afficher la progression exacte, l'animation doit respecter les conditions suivantes :

- Aucune progression sur la première image, et une progression complète sur la dernière image.
- Une vitesse constante, sans accélération ni décélération. Si l'animation démarre lentement puis accélère, elle affiche moins de la moitié de la progression à mi-chemin.

## 1. Ajouter l'élément personnalisé à l'écran \{#1-add-the-custom-element-to-the-screen\}

Dans le Flow & Paywall Builder, [ajoutez un élément personnalisé](flow-custom-elements#add-and-configure) à un écran de flow et configurez-le pour l'animation :

- **Type** : `lottie_animation`.
- **ID** : `streak_ring`. Dans cette recette, l'ID est aussi le nom du fichier d'animation.
- **Height** : Conservez la hauteur **Fixed** par défaut. L'animation s'adapte à la taille de l'élément personnalisé.

À l'intérieur de l'élément personnalisé, ajoutez une [**Image**](custom-media#image) avec une image fixe de l'anneau. Les utilisateurs la voient comme [contenu de secours](flow-custom-elements#set-fallback-content) lorsque leur version de votre application ne prend pas en charge l'animation.

## 2. Ajoutez le fichier d'animation à votre application \{#2-add-the-animation-file-to-your-app\}

Placez le fichier d'animation dans `src/main/assets`, le dossier `assets` de votre module d'application. Conservez-le à la racine de ce dossier, sans le placer dans un sous-dossier.

Le nom du fichier sans `.json` doit correspondre à l'ID de l'élément personnalisé, par exemple `streak_ring.json` pour `streak_ring`.

## 3. Créer la vue d'animation \{#create-the-animation-view\}

Créez un modèle pour le streak et une vue qui joue l'animation. Votre application met à jour le modèle quand le streak change. La vue lit le modèle, donc l'anneau affiche le streak actuel à l'ouverture de l'écran :

<Tabs groupId="current-os" queryString>
<TabItem value="kotlin" label="Kotlin" default>

```kotlin showLineNumbers title="Kotlin"

// the streak that your app keeps up to date
class StreakStore {
    val currentStreak = MutableStateFlow(0) // days in a row
}

@Composable
fun StreakRing(animationFile: String, streakStore: StreakStore) {
    val composition by rememberLottieComposition(LottieCompositionSpec.Asset(animationFile))
    val streak by streakStore.currentStreak.collectAsState()

    // 7 days fill the ring: from 0 for an empty ring to 1 for a full one
    val progress = minOf(streak / 7f, 1f)

    LottieAnimation(
        composition = composition,
        modifier = Modifier.fillMaxSize(), // scale the animation to fit the custom element
        clipSpec = LottieClipSpec.Progress(0f, progress),
    )
}
```

`clipSpec = LottieClipSpec.Progress(0f, progress)` remplit l'anneau une fois, du vide jusqu'à `progress`. Si votre application conserve déjà la série dans un `StateFlow`, utilisez ce `StateFlow` à la place de `StreakStore`.

</TabItem>
<TabItem value="java" label="Java">

```java showLineNumbers title="Java"

// the streak that your app keeps up to date
public class StreakStore {
    public final MutableLiveData<Integer> currentStreak = new MutableLiveData<>(0); // days in a row
}

public class StreakRingView extends LottieAnimationView {
    private final StreakStore streakStore;

    private final Observer<Integer> streakObserver = streak -> {
        // 7 days fill the ring: from 0 for an empty ring to 1 for a full one
        float progress = Math.min(streak / 7f, 1f);
        setMinAndMaxProgress(0f, progress);
        playAnimation();
    };

    public StreakRingView(Context context, String animationFile, StreakStore streakStore) {
        super(context);
        this.streakStore = streakStore;
        setAnimation(animationFile);
    }

    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        streakStore.currentStreak.observeForever(streakObserver);
    }

    @Override
    protected void onDetachedFromWindow() {
        streakStore.currentStreak.removeObserver(streakObserver);
        super.onDetachedFromWindow();
    }
}
```

`setMinAndMaxProgress(0f, progress)` et `playAnimation()` remplissent l'anneau une fois, de zéro jusqu'à `progress`. Si votre application conserve déjà la série dans un `LiveData`, utilisez ce `LiveData` à la place de `StreakStore`.

</TabItem>
</Tabs>

## 4. Associer l'animation à l'élément personnalisé \{#match-the-animation-to-the-custom-element\}

Dans votre [resolver global](android-flow-custom-elements#display-views-in-every-flow), ajoutez une propriété pour le modèle de série. Ensuite, retournez la vue d'animation pour le Type `lottie_animation` et l'ID `streak_ring`. Les lignes surlignées indiquent ce qu'il faut ajouter ou modifier. Si votre application n'a pas encore de [resolver](android-flow-custom-elements#write-a-resolver-to-match-custom-elements-and-views) global, copiez l'intégralité du code :

<Tabs groupId="current-os" queryString>
<TabItem value="kotlin" label="Kotlin" default>

```kotlin showLineNumbers title="Kotlin" {8,22-28}

class CustomElementsResolver(
    context: Context,
    private val streakStore: StreakStore,
) : AdaptyCustomElementsResolver {
    // the animation files in the assets folder, listed once
    private val animationFiles: Set<String> = try {
        context.assets.list("").orEmpty().toSet()
    } catch (e: IOException) {
        emptySet() // no list of files: every Lottie element shows the fallback
    }

    override fun resolve(type: String, id: String): AdaptyCustomElementContent? =
        when (type) {
            "lottie_animation" -> {
                // the ID names the animation file, such as streak_ring.json
                val file = "$id.json"
                when {
                    file !in animationFiles -> null // no file for this ID: show the fallback
                    id == "streak_ring" ->
                        AdaptyCustomElementContent.compose { StreakRing(file, streakStore) }
                    // the other animations of your resolver
                    else -> null
                }
            }
            // the other Types of your resolver
            else -> null
        }
}
```

Si le dossier `assets` ne contient aucun fichier pour l'ID, le resolver renvoie `null` et les utilisateurs voient le fallback. Si votre resolver renvoie déjà une [vue pour chaque fichier d'animation](android-flow-custom-elements#write-a-resolver-to-match-custom-elements-and-views), renvoyez cette vue au lieu de `null` quand l'ID n'est pas `streak_ring`. Ainsi, les animations de vos autres éléments personnalisés `lottie_animation` restent visibles.

</TabItem>
<TabItem value="java" label="Java">

```java showLineNumbers title="Java" {10,14-15,34-40}

public class CustomElementsResolver implements AdaptyCustomElementsResolver {
    private final StreakStore streakStore;
    // the animation files in the assets folder, listed once
    private final Set<String> animationFiles = new HashSet<>();

    public CustomElementsResolver(Context context, StreakStore streakStore) {
        this.streakStore = streakStore;
        try {
            String[] files = context.getAssets().list("");
            if (files != null) {
                animationFiles.addAll(Arrays.asList(files));
            }
        } catch (IOException e) {
            // no list of files: every Lottie element shows the fallback
        }
    }

    @Override
    public AdaptyCustomElementContent resolve(String type, String id) {
        if (type.equals("lottie_animation")) {
            // the ID names the animation file, such as streak_ring.json
            String file = id + ".json";
            if (!animationFiles.contains(file)) {
                return null; // no file for this ID: show the fallback
            }
            if (id.equals("streak_ring")) {
                return AdaptyCustomElementContent.view(
                        (context, elementContext) -> new StreakRingView(context, file, streakStore)
                );
            }
            // the other animations of your resolver
            return null;
        }
        // the other Types of your resolver
        return null;
    }
}
```

Si le dossier `assets` ne contient aucun fichier pour cet ID, le resolver retourne `null` et les utilisateurs voient le fallback. Si votre resolver retourne déjà une [vue pour chaque fichier d'animation](android-flow-custom-elements#write-a-resolver-to-match-custom-elements-and-views), retournez cette vue au lieu de `null` lorsque l'ID n'est pas `streak_ring`. Ainsi, les utilisateurs voient toujours les animations de vos autres éléments personnalisés `lottie_animation`.

</TabItem>
</Tabs>

Créez le resolver avec le modèle de streak, puis définissez-le comme resolver global de l'application. Appelez `AdaptyUI.setCustomElementsResolver` une seule fois, par exemple au lancement de l'application :

<Tabs groupId="current-os" queryString>
<TabItem value="kotlin" label="Kotlin" default>

```kotlin showLineNumbers title="Kotlin"

class App : Application() {
    // the streak model that your app updates
    val streakStore = StreakStore()

    // keep this instance: a resolver for one flow can reuse it
    // lazy: the context isn't attached yet while App is constructed
    val customElementsResolver by lazy { CustomElementsResolver(this, streakStore) }

    override fun onCreate() {
        super.onCreate()
        AdaptyUI.setCustomElementsResolver(customElementsResolver)
    }
}
```

</TabItem>
<TabItem value="java" label="Java">

```java showLineNumbers title="Java"

public class App extends Application {
    // the streak model that your app updates
    private final StreakStore streakStore = new StreakStore();
    // keep this instance: a resolver for one flow can reuse it
    private CustomElementsResolver customElementsResolver;

    @Override
    public void onCreate() {
        super.onCreate();
        customElementsResolver = new CustomElementsResolver(this, streakStore);
        AdaptyUI.setCustomElementsResolver(customElementsResolver);
    }

    public StreakStore getStreakStore() {
        return streakStore;
    }

    public CustomElementsResolver getCustomElementsResolver() {
        return customElementsResolver;
    }
}
```

</TabItem>
</Tabs>

## 5. Tester sur un appareil \{#test-on-a-device\}

Le Flow & Paywall Builder ne peut pas exécuter le code de votre application, donc son canvas affiche uniquement le fallback. Pour prévisualiser l'animation :

1. [Publiez le flow](builder-save-publish). Pour voir la dernière version publiée plutôt qu'une version en cache, enregistrez l'appareil comme [appareil de test](test-devices).
2. Lancez un build de votre application incluant le resolver. Définissez le streak à 0 jour, ouvrez l'écran et vérifiez que l'anneau reste vide. Recommencez avec 4 et 7 jours, et vérifiez que l'anneau se remplit jusqu'à chaque valeur.

Pour tester le fallback, supprimez le fichier d'animation du build, puis rouvrez l'écran.

Pour savoir pourquoi le paywall de secours s'affiche à la place de l'animation, suivez les instructions dans la section [Tester sur un appareil](android-flow-custom-elements#test-on-a-device) du guide Android.