Gérer les modifications de configuration

Certaines configurations d'appareil peuvent changer pendant l'exécution de l'application. Voici quelques exemples :

• Taille d'affichage de l'application
• Orientation de l'écran
• Taille et épaisseur de la police
• Paramètres régionaux
• Mode sombre ou mode clair
• Disponibilité du clavier

La plupart de ces modifications de configuration sont dues à une interaction de l'utilisateur. Par exemple, la rotation ou le pliage de l'appareil modifie l'espace disponible pour votre application. De même, la modification des paramètres de l'appareil, tels que la taille de la police, la langue ou le thème préféré, modifie leurs valeurs respectives dans l' Configuration objet.

Ces paramètres nécessitent généralement des modifications suffisamment importantes de l'interface utilisateur de votre application pour que la plate-forme Android dispose d'un mécanisme spécialement conçu pour les gérer. Ce mécanisme est la recréation d'Activity.

Recréation d'activité

Le système recrée une Activity lorsqu'une modification de configuration se produit. Pour ce faire, il appelle onDestroy et détruit l'instance Activity existante. Il crée ensuite une nouvelle instance à l'aide de onCreate, et cette nouvelle instance Activity est initialisée avec la nouvelle configuration mise à jour. Cela signifie également que le système recrée l'interface utilisateur avec la nouvelle configuration.

En règle générale, l'Activity sert d'hôte aux composables. Lorsque l'Activity est recréée, Compose recrée également votre interface utilisateur à l'aide des nouvelles valeurs de configuration.

Le comportement de recréation aide votre application à s'adapter aux nouvelles configurations en la rechargeant automatiquement avec d'autres ressources correspondant à la nouvelle configuration de l'appareil.

Exemple de recréation

Prenons l'exemple d'un composable qui affiche un titre statique à l'aide d'une ressource de chaîne :

// In the res/values/strings.xml file
// <string name="compose">Jetpack Compose</string>

// In your Compose code
Text(
    text = stringResource(R.string.compose)
)
ResourcesSnippets.kt

Lorsque l'Activity est créée, le composable Text lit la configuration actuelle (par exemple, la langue) et résout la ressource de chaîne appropriée.

Si la langue change, le système recrée l'activité. Dans ce cas, Compose recrée l'interface utilisateur. Étant donné que stringResource lit la configuration actuelle, le titre est automatiquement mis à jour avec la valeur localisée correcte.

La recréation efface également tout état conservé sous forme de champs dans l'Activity.

Pour conserver l'état de votre interface utilisateur en cas de modifications de configuration, utilisez les modèles de gestion d'état recommandés. Utilisez ViewModel pour les données et la logique métier, et rememberSaveable pour l'état au niveau de l'interface utilisateur. Grâce à ces mécanismes, votre état survit à la recréation de l'Activity, tandis que l'interface utilisateur est mise à jour pour refléter la nouvelle configuration.

Pour en savoir plus sur l'enregistrement de l'état dans Compose, consultez Enregistrer l'état de l'UI dans Compose.

Attentes des utilisateurs

L'utilisateur d'une application s'attend à ce que l'état soit conservé. Si un utilisateur remplit un formulaire et ouvre une autre application en mode multifenêtre pour consulter des informations, l'expérience utilisateur est mauvaise s'il revient à un formulaire effacé ou à un autre endroit de l'application. En tant que développeur, vous devez offrir une expérience utilisateur cohérente lors des modifications de configuration et de la recréation d'activité.

Pour vérifier si l'état est conservé dans votre application, vous pouvez effectuer des actions qui entraînent des modifications de configuration lorsque l'application est au premier plan et lorsqu'elle est en arrière-plan. Il peut s'agir des actions suivantes :

• Faire pivoter l'appareil
• Activer le mode multifenêtre
• Redimensionner l'application en mode multifenêtre ou dans une fenêtre de format libre
• Plier un appareil pliable avec plusieurs écrans
• Modifier le thème du système, par exemple en passant du mode sombre au mode clair
• Modifier la taille de la police
• Modifier la langue du système ou de l'application
• Connecter ou déconnecter un clavier matériel
• Connecter ou déconnecter une station d'accueil

Vous pouvez adopter plusieurs approches pour conserver l'état pertinent lors de la recréation d'Activity. Le choix dépend du type d'état que vous souhaitez conserver :

• Persistance locale pour gérer l'arrêt du processus pour des données complexes ou volumineuses. Le stockage local persistant inclut des bases de données ou DataStore.
• Objets conservés tels que les instances ViewModel pour gérer l'état lié à l'interface utilisateur en mémoire pendant que l'utilisateur utilise activement l'application.
• rememberSaveable pour conserver l'état transitoire de l'interface utilisateur lors des modifications de configuration et de l'arrêt du processus initié par le système. Cela est approprié pour l'état qui dépend de l'entrée utilisateur, de la position de défilement ou de la navigation, mais qui n'appartient pas à un ViewModel.

Pour en savoir plus sur les API de chacun de ces éléments en détail, et sur le moment où il convient de les utiliser, consultez Enregistrer les états de l'interface utilisateur.

Limiter la recréation d'activité

Vous pouvez empêcher la recréation automatique d'activité pour certaines modifications de configuration. Dans les applications modernes qui utilisent uniquement Compose, votre interface utilisateur est recomposée de toute façon, mais il est recommandé de gérer directement la modification de configuration.

Par défaut, une modification de configuration force le système à détruire et à recréer l'activité, y compris l'interface utilisateur et tous les objets dérivés de l'activité. Si vous déclarez que votre activité gère elle-même la modification de configuration, le système l'empêche. Au lieu de cela, seul l'objet Configuration est mis à jour, et Compose recompose votre interface utilisateur avec les nouvelles valeurs.

La gestion directe des modifications de configuration dans Compose présente plusieurs avantages :

• Amélioration des performances : la recomposition de l'interface utilisateur est moins coûteuse qu'un cycle complet de recréation d'activité, en particulier pour les modifications mineures.
• Animations fluides : en évitant le redémarrage d'une activité, vous pouvez exécuter des animations continues lors des modifications de configuration, telles que des transitions de mise en page fluides lors de la rotation de l'appareil.
• Conservation de l'état : la conservation de l'instance d'activité réduit le risque de perte d'état transitoire de l'interface utilisateur lors d'un événement tel que la rotation de l'écran. Notez que vous devez toujours gérer la conservation de l'état en cas d'arrêt du processus initié par le système.

Pour désactiver la recréation d'activité pour des modifications de configuration spécifiques, ajoutez le type de configuration à android:configChanges dans l'entrée <activity> de votre fichier AndroidManifest.xml. Les valeurs possibles figurent dans la documentation de l'attribut android:configChanges.

Le code de fichier manifeste suivant désactive la recréation de Activity pour MyActivity lorsque l'orientation de l'écran et la disponibilité du clavier changent :

<activity
    android:name=".MyActivity"
    android:configChanges="orientation|screenSize|screenLayout|keyboardHidden"
    android:label="@string/app_name">

Réagir aux modifications de configuration

Jetpack Compose permet à votre application de réagir plus facilement aux modifications de configuration. Toutefois, si vous désactivez la recréation d'Activity pour toutes les modifications de configuration où cela est possible, votre application doit toujours gérer correctement les modifications de configuration.

L'objet Configuration est disponible dans la hiérarchie de l'interface utilisateur Compose avec le LocalConfiguration local de composition. Chaque fois qu'il change, les fonctions composables qui lisent LocalConfiguration.current sont recomposées. Pour en savoir plus sur le fonctionnement des locaux de composition, consultez Données à champ d'application local avec CompositionLocal.

@Composable
fun DateText(year: Int, dayOfYear: Int) {
    val dateTimeFormatter = DateTimeFormatter.ofPattern(
        "MMM dd",
        ConfigurationCompat.getLocales(LocalConfiguration.current)[0]
    )
    Text(
        dateTimeFormatter.format(LocalDate.ofYearDay(year, dayOfYear))
    )
}