---
title: "Vérifier le statut d'abonnement dans le SDK Android"
description: "Suivez et gérez le statut d'abonnement des utilisateurs dans Adapty pour améliorer la rétention client dans votre application Android."
---
Avec Adapty, suivre le statut d'abonnement est simple. Inutile d'insérer manuellement des identifiants de produits dans votre code. Il suffit de vérifier l'existence d'un [niveau d'accès](access-level) actif pour confirmer le statut d'abonnement d'un utilisateur.
Avant de commencer à vérifier le statut d'abonnement, configurez les [Real-time Developer Notifications (RTDN)](enable-real-time-developer-notifications-rtdn).
## Niveau d'accès et objet AdaptyProfile \{#access-level-and-the-adaptyprofile-object\}
Les niveaux d'accès sont des propriétés de l'objet [AdaptyProfile](https://android.adapty.io/adapty/com.adapty.models/-adapty-profile/). Nous recommandons de récupérer le profil au démarrage de l'application, par exemple lors de l'[identification d'un utilisateur](android-identifying-users#setting-customer-user-id-on-configuration), puis de le mettre à jour à chaque changement. Vous pouvez ainsi utiliser l'objet profil sans avoir à le redemander constamment.
Pour être notifié des mises à jour du profil, écoutez les changements comme décrit dans la section [Écouter les mises à jour du profil, y compris les niveaux d'accès](android-listen-subscription-changes) ci-dessous.
:::tip
Vous souhaitez voir un exemple concret d'intégration du SDK Adapty dans une application mobile ? Consultez nos [exemples d'applications](sample-apps), qui illustrent la configuration complète, notamment l'affichage des paywalls, les achats et d'autres fonctionnalités de base.
:::
## Récupérer le niveau d'accès depuis le serveur \{#retrieving-the-access-level-from-the-server\}
Pour obtenir le niveau d'accès depuis le serveur, utilisez la méthode `.getProfile()` :
```kotlin showLineNumbers
Adapty.getProfile { result ->
when (result) {
is AdaptyResult.Success -> {
val profile = result.value
// check the access
}
is AdaptyResult.Error -> {
val error = result.error
// handle the error
}
}
}
```
```java showLineNumbers
Adapty.getProfile(result -> {
if (result instanceof AdaptyResult.Success) {
AdaptyProfile profile = ((AdaptyResult.Success) result).getValue();
// check the access
} else if (result instanceof AdaptyResult.Error) {
AdaptyError error = ((AdaptyResult.Error) result).getError();
// handle the error
}
});
```
Paramètres de la réponse :
| Paramètre | Description |
| --------- | ------------------------------------------------------------ |
| Profile | Un objet [AdaptyProfile](https://android.adapty.io/adapty/com.adapty.models/-adapty-profile/). En général, il suffit de vérifier le statut du niveau d'accès du profil pour déterminer si l'utilisateur bénéficie d'un accès premium à l'application.
La méthode `.getProfile` fournit le résultat le plus récent, car elle interroge toujours l'API. Si, pour une raison quelconque (par exemple, absence de connexion internet), le SDK Adapty ne parvient pas à récupérer les informations depuis le serveur, les données en cache sont renvoyées. Il est également important de noter que le SDK Adapty met régulièrement à jour le cache `AdaptyProfile` afin de maintenir ces informations aussi récentes que possible.
|
La méthode `.getProfile()` vous fournit le profil utilisateur à partir duquel vous pouvez obtenir le statut du niveau d'accès. Une application peut avoir plusieurs niveaux d'accès. Par exemple, si vous avez une application d'actualités et vendez des abonnements à différentes thématiques indépendamment, vous pouvez créer les niveaux d'accès « sports » et « science ». La plupart du temps, cependant, un seul niveau d'accès suffit — dans ce cas, utilisez simplement le niveau d'accès par défaut « premium ».
Voici un exemple de vérification du niveau d'accès « premium » par défaut :
```kotlin showLineNumbers
Adapty.getProfile { result ->
when (result) {
is AdaptyResult.Success -> {
val profile = result.value
if (profile.accessLevels["premium"]?.isActive == true) {
// grant access to premium features
}
}
is AdaptyResult.Error -> {
val error = result.error
// handle the error
}
}
}
```
```java showLineNumbers
Adapty.getProfile(result -> {
if (result instanceof AdaptyResult.Success) {
AdaptyProfile profile = ((AdaptyResult.Success) result).getValue();
AdaptyProfile.AccessLevel premium = profile.getAccessLevels().get("premium");
if (premium != null && premium.isActive()) {
// grant access to premium features
}
} else if (result instanceof AdaptyResult.Error) {
AdaptyError error = ((AdaptyResult.Error) result).getError();
// handle the error
}
});
```
### Écouter les mises à jour du statut d'abonnement \{#listening-for-subscription-status-updates\}
Chaque fois que l'abonnement d'un utilisateur change, Adapty déclenche un événement.
Pour recevoir les messages d'Adapty, une configuration supplémentaire est nécessaire :
```kotlin showLineNumbers
Adapty.setOnProfileUpdatedListener { profile ->
// handle any changes to subscription state
}
```
```java showLineNumbers t
Adapty.setOnProfileUpdatedListener(profile -> {
// handle any changes to subscription state
});
```
Adapty déclenche également un événement au démarrage de l'application. Dans ce cas, le statut d'abonnement mis en cache est transmis.
### Cache du statut d'abonnement \{#subscription-status-cache\}
Le cache intégré au SDK Adapty stocke le statut d'abonnement du profil. Ainsi, même si le serveur est indisponible, les données en cache restent accessibles pour fournir des informations sur le statut d'abonnement du profil.
Il est cependant important de noter que les données ne peuvent pas être demandées directement depuis le cache. Le SDK interroge périodiquement le serveur toutes les minutes pour vérifier s'il y a des mises à jour ou des changements liés au profil. Le cas échéant, les modifications — comme de nouvelles transactions ou d'autres mises à jour — sont transmises aux données en cache afin de les maintenir synchronisées avec le serveur.