Share
Le dur labeur n’est pas terminé simplement parce que votre application a accumulé une tonne de téléchargements et de critiques positives sur le Google Play Store. Votre utilisateur mobile typique a douzaines des applications installées sur leur appareil, et avec les nouvelles applications publiées tout le temps, vous devrez travailler dur pour retenir l'intérêt de votre public!
Garder les utilisateurs revenant à votre application est crucial créer une base d’utilisateurs stable et fidèle. De plus, si vous avez monétisé votre application, le temps que les utilisateurs passent dans votre application influe directement sur le montant de vos gains. Considérez chaque seconde supplémentaire comme une autre opportunité d'afficher une annonce ou d'inciter l'utilisateur à dépenser de l'argent supplémentaire. -app achat!
À l'I / O de cette année, Google a présenté des tranches, une nouvelle fonctionnalité qui promet de ramener les utilisateurs à votre application en leur fournissant les fonctionnalités et le contenu de celle-ci au moment exact où ils sont le plus utiles.
Avec les tranches en passe de devenir un outil important pour fidéliser votre public, le moment est propice pour acquérir une expérience pratique de cette fonctionnalité Android émergente. À la fin de cet article, vous aurez créé une gamme de tranches, allant d’une simple tranche qui lance une activité lorsque vous êtes exploité à des tranches plus complexes composées d’icônes, d’images, de grilles et de plusieurs SliceActions.
Semblables aux widgets, les slices sont des extraits de contenu qui apparaissent en dehors du contexte de l'application, ce qui augmente la visibilité de votre application et vous offre davantage d'opportunités pour engager votre public..
Les tranches ont le potentiel d'accroître considérablement la visibilité de votre application. Google a promis d'ajouter la prise en charge des tranches aux zones où de nombreux utilisateurs d'Android passaient beaucoup de temps, y compris la recherche Google et l'Assistant Google. Comme elles font partie d'Android Jetpack, les tranches sont compatibles avec Android 4.4 et les versions ultérieures, ce qui signifie que vos tranches peuvent potentiellement atteindre 95% de tous les utilisateurs d'Android..
Les tranches ont donc beaucoup à offrir, mais comment fonctionnent-elles??
À l'heure actuelle, si vous effectuez une recherche dans l'application Google, Google peut suggérer une application pertinente installée sur votre appareil. Par exemple, si vous avez installé Facebook pour mobile, tapez Facebook fera apparaître un lien direct vers l'application Facebook.
Les tranches poussent cette application encore plus loin, en se concentrant sur des tâches spécifiques que l'utilisateur peut souhaiter exécuter dans les applications qu'il a déjà installées..
Prenons un exemple: imaginez que vous avez installé une application de réservation d’hôtel qui vous permet de rechercher un hôtel et de réserver une chambre. Quand vous tapez Hôtels à Londres Dans Google, vous rencontrez les résultats de recherche habituels, plus une tranche de l’application Book A Hotel. Cette tranche recommande un hôtel à Londres et affiche des informations telles que le nom et l'adresse de l'hôtel, plus une SliceAction, sous la forme d'un bouton qui vous permet de réserver une salle directement à partir de l'interface utilisateur de la tranche.
Pour l'utilisateur, cette tranche a fourni un accès facile aux informations et fonctionnalités dont ils avaient besoin à ce moment précis. Pour le développeur, cette tranche leur a permis d’obtenir leur application devant un utilisateur exactement au moment où il avait le plus de chances de le réengager avec succès..
Commençons par créer une simple tranche qui, une fois engagée, lancera l'application Activité principale.
Cette technique simple permet de démarrer n'importe quelle tâche directement à partir de l'interface utilisateur d'une tranche. Dans notre exemple Book A Hotel, nous pourrions simplement associer le bouton à l'application correspondante. BookRoomActivité, ce qui constituerait un moyen simple mais efficace de réduire le nombre d'écrans sur lesquels l'utilisateur doit naviguer pour mener à bien cette tâche particulière..
Pour commencer, créez un nouveau projet Android. Vous pouvez utiliser les paramètres de votre choix, mais assurez-vous de sélectionner le Inclure le support Kotlin case à cocher à l'invite.
Une fois votre projet créé, ouvrez son fichier build.gradle et ajoutez le fichier tranche de base et constructeur de tranches dépendances:
dépendances implémentation 'androidx.appcompat: appcompat: 1.0.0-alpha3' implémentation 'androidx.slice: slice-core: 1.0.0-alpha3' implémentation 'androidx.slice: slice-builders: 1.0.0-alpha3' implémentation ' androidx.constraintlayout: constraintlayout: 1.1.0 'implémentation "org.jetbrains.kotlin: kotlin-stdlib-jdk7: $ kotlin_version"
Ensuite, nous devons créer un fournisseur de tranche, qui est le composant responsable de l'affichage du contenu de votre application en dehors du contexte de l'application.
Vous créez un fournisseur de tranche à l'aide du modèle de fournisseur de tranche d'Android Studio:
Accentsconagua
MySliceProvider classe, et vous devriez voir le code généré automatiquement suivant: import android.content.ContentResolver import android.content.Intent import android.net.Uri import androidx.slice.Slice import androidx.slice.SliceProvider import androidx.slice.builders.ListBuilder, classe MySliceProvider: SliceProvider: SliceProvider () : Boolean return true substitue fun onMapIntentToUri (intention: intention?): Uri var uriBuilder: Uri.Builder = Uri.Builder (). Scheme (ContentResolver.SCHEME_CONTENT) si (intent == null) renvoie uriBuilder.build () val data = intent.data if (data! = null && data.path! = null) val path = data.path.replace ("/", "") uriBuilder = uriBuilder.path (chemin) val context = context if (context! = null) uriBuilder = uriBuilder.authority (context.getPackageName ()) renvoie uriBuilder.build () // Construit la tranche // Redéfinit l'amusement onBindSlice (sliceUri: Uri): Slice? val context = getContext ()?: return null return if (sliceUri.path == "/") // Personnaliser la tranche // ListBuilder (context, sliceUri) .addRow it.setTitle ("URI trouvé.") .build () else ListBuilder (context, sliceUri) .addRow it.setTitle ("URI introuvable.") .build () // S'abonner à une source de données, si nécessaire // remplacer fun onSlicePinned (sliceUri: Uri?) // Évitez les fuites de mémoire en vous désabonnant de la source de données et en supprimant tout observateur // remplacez fun onSliceUnpinned (sliceUri: Uri?) Si vous créez votre fournisseur de tranche à l'aide de Nouveau > Autre > Fournisseur de tranche, alors Android Studio ajoutera également le fournisseur nécessaire à votre manifeste:
Cette entrée garantit que votre tranche peut être découverte par d'autres applications..
Jusqu'à présent, nous n'avons utilisé que le code généré automatiquement par Android Studio, mais votre projet peut déjà refuser de compiler!
Les bogues, les fonctionnalités manquantes et les comportements étranges font tout simplement partie du plaisir de travailler avec les premières versions. Au moment de la rédaction de ce document, la génération d’un fournisseur de tranches ajoutait parfois, de manière inexplicable, un nouvel ensemble de dépendances à votre projet build.gradle fichier.
implémentation 'androidx.slice: slices-core: 1.0.0-alpha1' implémentation 'androidx.slice: slices-builders: 1.0.0-alpha1'
Non seulement ces dépendances sont-elles inutiles, elles sont faux. Bien que ce soit facile à manquer, comparez:
implémentation 'androidx.slice: slices-core: 1.0.0-alpha3'
Avec le correct:
implémentation 'androidx.slice: slice-core: 1.0.0-alpha1'
Un célibataire ou Individual s peut faire la différence entre une application qui fonctionne et un projet qui refuse de compiler. Il est probable que ce bogue sera corrigé avant la publication officielle des tranches, mais si Android Studio commence à se plaindre des dépendances non résolues, vérifiez votre build.gradle fichier pour voir si cela est arrivé dans votre projet.
SliceActions, et découper des tranchesPour transformer le code passe-partout du fournisseur de la tranche en une tranche fonctionnelle, nous devons apporter plusieurs modifications:
Chaque tranche a un URI unique, et c'est le travail du fournisseur de tranche de fournir le mappage entre cet URI et la tranche correspondante..
Les applications capables d'afficher une tranche sont appelées applications hôtes. Chaque fois qu'un hôte doit afficher une tranche, il envoie une demande de liaison au fournisseur de tranche avec l'URI de la tranche qu'il recherche. Votre fournisseur de tranche vérifiera ensuite l’URI et renverra la tranche appropriée..
Dans l'extrait suivant, le onBindSlice la méthode vérifie la / myURI chemin et en retournant une tranche qui affiche un Bonjour le monde message.
class MySliceProvider: SliceProvider () substitue l'amusement onCreateSliceProvider (): Boolean retourne vrai écrase l'amusement onBindSlice (sliceUri: Uri): Slice? return if (sliceUri.path == "/ myURI") ListBuilder (contexte, sliceUri, ListBuilder.INFINITY) .addRow it.setTitle ("Hello World") .build () autre …Pendant que tu pourrait créez une tranche qui affiche simplement certaines informations; si vous voulez que votre tranche soit interactive, vous devez en créer une ou plusieurs. SliceActions.
UNE SliceAction peut consister en un titre, une icône et un En attente d'intention. Vous pouvez aussi marquer SliceActions comme actions primaires, qui déclenchent chaque fois que l'utilisateur appuie n'importe où sur la rangée de cette tranche.
Vous définissez la disposition d'une tranche en implémentant un ListBuilder, l'ajout d'une ligne, puis l'ajout d'éléments à cette ligne. Par exemple, ici j'utilise ListBuilder et ajouter une rangée pour créer une tranche composée d'un titre et d'un sous-titre:
import android.net.Uri import androidx.slice.Slice import androidx.slice.SliceProvider import androidx.slice.builders.ListBuilder import androidx.slice.builders.ListBuilder.INFINITY, classe MySliceProvider: SliceProvider (SliceProvider () return true remplace l'amusement onBindSlice (sliceUri: Uri): Slice? val chemin = sliceUri.path quand (chemin) "/ launchMainActivity" -> retour createSlice (sliceUri) return null fun createSlice (sliceUri: Uri): Slice retour ListBuilder (contexte, sliceUri, INFINITY) .addRow it .apply setTitle ("Ceci est un titre") setSubtitle ("Ceci est un sous-titre") .build ()Vous pouvez afficher un mélange de différents types de contenu dans la même ligne, tels que du texte, des actions et des icônes..
Appliquons maintenant tout cela à notre projet et créons une tranche qui lance notre application. Activité principale quand on tape.
Ouvrez le MySliceProvider classe et ajoutez ce qui suit:
import android.app.PendingIntent import android.content.Intent import android.net.Uri import androidx.core.graphics.drawable.IconCompat import androidx.slice.Slice import androidx.slice.SliceProvider import androidx.slice.builders.ListBuilder import etroidx .slice.builders.SliceAction // Étendre à partir de SliceProvider // Classe MySliceProvider: SliceProvider () // Initialise votre fournisseur de tranche // Remplacez fun surCreateSliceProvider (): Boolean return true // Créez la tranche // Redéfinissez votre plaisir surBindSlice ( sliceUri: Uri): Slice? // Vérifier le chemin de l'URI // val chemin = sliceUri.path quand (chemin) // Définit l'URI de la tranche; J'utilise 'launchMainActivity' // "/ launchMainActivity" -> return createSlice (sliceUri) return null fun createSlice (sliceUri: Uri): Slice val activityAction = createActivityAction () // Créer le ListBuilder, que nous allons utiliser pour ajouter des lignes à notre tranche // val listBuilder = ListBuilder (contexte !!, sliceUri, ListBuilder.INFINITY) // Construit les lignes à l'aide de RowBuilder // val RowBuilder = ListBuilder.RowBuilder (listBuilder) // Définit le texte du titre // .setTitle ("Open MainActivity.") // Définit l'action principale de la ligne // .setPrimaryAction (activityAction) // Ajoute la ligne au ListBuilder // listBuilder.addRow (rowBuilder) // Construit la liste // retourne listBuilder.build () fun createActivityAction (): SliceAction val intent = Intention (contexte, MainActivity :: class.java) retourne SliceAction (PendingIntent.getActivity (context, 0, intent, 0), IconCompat.createWithResource (context !!, R. drawable.ic_home), "Open MainActivity")Si vous voulez tester vos tranches, vous aurez besoin d'au moins une application capable d'afficher des tranches..
Les tranches feraient leurs débuts dans la recherche Google plus tard cette année, mais au moment de la rédaction de cet article, cette fonctionnalité n'était pas encore disponible. Actuellement, le seul moyen de tester les tranches consiste à installer l'application Slice Viewer de Google, conçue pour émuler la manière dont les tranches apparaîtront dans la recherche Google..
Pour installer Slice Viewer sur un périphérique virtuel Android (AVD):
Pour installer Slice Viewer sur un smartphone ou une tablette physique:
CD) de sorte que l'invite de commande ou le terminal pointe vers votre dossier Android / sdk / platform-tools. Par exemple, voici ma commande:cd / Utilisateurs / jessicathornsby / Bibliothèque / Android / sdk / platform-tools
adb installer commande pour pousser l'APK sur votre appareil Android:./ adb installe slice-viewer.apk
Ensuite, vous devrez créer une configuration d'exécution qui transmette l'URI unique de votre tranche à votre périphérique AVD ou Android..
La première fois que Slice Viewer tente d'afficher votre tranche, il demande l'autorisation d'accéder à l'URI unique de votre tranche. Robinet Permettre et naviguer dans le dialogue des autorisations, et votre tranche devrait apparaître à l'écran.
Pour interagir avec le SliceAction, clique le Ouvrir MainActivity bouton, et la tranche répondra en lançant le programme de votre application Activité principale.
SliceAction Pourquoi vous limiter à un SliceAction, quand tu peux avoir plusieurs SliceActions? Dans cette section, nous allons mettre en œuvre deux SliceActions, où chaque action lance un différent Activité. Je vais aussi présenter quelques nouveaux éléments de l'interface utilisateur, en ajoutant un sous-titre et des articles finaux à notre part.
Passons à la configuration et créons une seconde Activité que notre deuxième SliceAction peut créer un lien vers.
Tout d'abord, sélectionnez Nouveau > Fichier / classe Kotlin depuis la barre d’outils Android Studio. Dans la boîte de dialogue Nouveau fichier, ouvrez le Gentil liste déroulante et sélectionnez Classe. Nommez cette classe Deuxième activité, puis cliquez sur D'accord.
Maintenant, ouvrez votre Deuxième activité classe et ajouter ce qui suit:
import androidx.appcompat.app.AppCompatActivity import android.os.Bundle, classe SecondActivity: AppCompatActivity () redéfinit fun sur la création (saveInstanceState: Bundle?) super.onCréer (savedInstanceState) setContentView (R.layout.activity_second)
Ensuite, sélectionnez Nouveau > Fichier de ressources Android depuis la barre d’outils Android Studio. Dans la fenêtre suivante, ouvrez le Type de ressource liste déroulante et sélectionnez Disposition. Nommez ce fichier activité_seconde, et cliquez D'accord.
Maintenant, ouvrez ce fichier de mise en page et ajoutez le code suivant:
http://schemas.android.com/apk/res/android "xmlns: app =" http://schemas.android.com/apk/res-auto "xmlns: tools =" http://schemas.android. com / tools "android: layout_width =" match_parent "android: layout_height =" match_parent "tools: context =". MainActivity ">
Ouvrez le manifeste de votre projet et déclarez-le. Deuxième activité:
Les éléments finaux peuvent être un horodatage, une image ou un SliceAction, mais comme leur nom l'indique, elles apparaissent toujours à la fin d'une ligne. Vous pouvez ajouter plusieurs éléments finaux à une seule ligne. Toutefois, en fonction de l'espace disponible, rien ne garantit que tous vos éléments finaux seront affichés par l'utilisateur..
Nous allons créer notre SliceActions sous forme d'icônes, vous devrez donc ajouter deux nouveaux éléments dessinables à votre projet:
Répétez les étapes ci-dessus pour créer une icône pour votre Lancer SecondActivity action de tranche. Pour mon deuxième point final, j'utilise le appel icône et le nommer ic_call.
Nous sommes maintenant prêts à ajouter une seconde SliceAction au MySliceProvider classe:
import android.app.PendingIntent import android.content.Intent import android.net.Uri import androidx.core.graphics.drawable.IconCompat import androidx.slice.Slice import androidx.slice.SliceProvider import androidx.slice.builders.ListBuilder import etroidx .slice.builders.SliceAction, classe MySliceProvider: SliceProvider () ignore le plaisir surCreateSliceProvider (): Boolean retourne vrai remplace le plaisir surBindSlice (sliceUri: Uri): Slice? val chemin = sliceUri.path quand (chemin) "/ launchMainActivity" -> retour createSlice (sliceUri) return null fun createSlice (sliceUri: Uri): Slice val activityAction = createActivityAction () IconCompat.createWithResource (contexte !!) , R.drawable.ic_home) .toIcon () val activityAction2 = createSecondActivityAction () IconCompat.createWithResource (context !!, R.drawable.ic_call) .toIcon () // Construit le constructeur parent // val listBuilder = ListBuilder (contexte!). !, sliceUri) // Construit le générateur pour la ligne // val myRow = ListBuilder.RowBuilder (listBuilder) .setTitle ("Launch MainActivity.") .setSubtitle ("Ceci est un sous-titre") // Ajoute les actions que nous ' ll utilisera comme éléments finaux // myRow.addEndItem (activityAction) myRow.addEndItem (activityAction2) // Ajoute la ligne au générateur parent // listBuilder.addRow (myRow) // Construit la tranche // renvoie listBuilder.build () fun createActivityAction (): SliceAction val intent = Intention (contexte, MainActivity :: class.java) retourne SliceAction (PendingIntent.getActivity ( context, 0, intention, 0), IconCompat.createWithResource (context !!, R.drawable.ic_home) .toIcon (), "Launch MainActivity") fun createSecondActivityAction (): SliceAction valeur intentionnelle = Intent (contexte, SecondActivity: : class.java) retourne SliceAction (PendingIntent.getActivity (contexte, 0, intention, 0), IconCompat.createWithResource (contexte !!, R.drawable.ic_call) .toIcon (), "Launch SecondActivity")Puisque nous n’avons pas changé l’URI, nous n’avons pas besoin de créer une nouvelle configuration d’exécution, ce qui signifie que tester cette tranche est aussi simple que de sélectionner Courir > sliceconfig depuis la barre d'outils Android Studio.
Vous pouvez télécharger ce projet à partir du tutoriel GitHub repo.
Jusqu'à présent, nous avons construit toutes nos tranches en utilisant uniquement des lignes, mais vous pouvez également créer des tranches en utilisant la grille lignes et cellules.
Dans cette dernière section, nous allons créer une tranche composée d'un titre, d'un sous-titre et d'une seule ligne divisée en trois cellules. Chaque cellule aura son propre titre, un corps de texte et une image, et chacune effectuera une action unique en appuyant dessus..
Pour disposer votre tranche dans une grille, vous devez:
ListBuilder.ListBuilder, en utilisant addGridRow. addCell. Chaque ligne peut afficher un maximum de cinq cellules.Vous pouvez ensuite ajouter du contenu à chaque cellule, tel que:
addTitleText.ajouter du texte.ajouter une image. Chaque image de cellule doit avoir l'un des attributs suivants: GRAND_IMAGE, SMALL_IMAGE, ou ICON_IMAGE. SliceAction. Pour que cet exemple reste simple, appuyer sur chaque cellule chargera simplement un article dans le navigateur par défaut du périphérique. Toutefois, si vous préférez une expérience de tranches plus authentique, vous pouvez modifier le setContentIntent code. Je vais inclure des images dans ma grille, vous devrez donc en ajouter au moins une pour votre projet. J'utilise le logo Kotlin, mais vous pouvez saisir n'importe quelle image et la déposer dans votre projet. Drawable dossier.
Maintenant, vous êtes prêt à ouvrir le MySliceProvider classe et construit ta grille:
import android.app.PendingIntent import android.content.Context import android.content.Intent import android.net.Uri import androidx.core.graphics.drawable.IconCompat import androidx.slice.Slice import androidx.slice.SliceProvider import etroidx.slice .builders.ListBuilder, classe MySliceProvider: SliceProvider () substitue à l'amusement onCreateSliceProvider (): Boolean retourne vrai à l'amusement à onBindSlice (sliceUri: Uri): Slice? val path = sliceUri.path quand (path) "/ launchMainActivity" -> return createSliceWithGridRow (sliceUri) return null fun createSliceWithGridRow (sliceUri: Uri): Slice return ListBuilder (contexte, sliceUri, ListBuilder.INFINITY). it.apply setTitle ("Vous voulez commencer à apprendre Kotlin pour Android?") setSubtitle ("Découvrez ces articles!") // Ajoutez une ligne de grille au générateur de liste // .addGridRow it.apply / / Ajouter une cellule à la ligne // addCell it.apply // Ajouter du contenu à votre cellule // addTitleText ("Java vs. Kotlin") addText ("Partie 1") addImage (IconCompat.createWithResource (context, R. drawable.kotlin), ListBuilder.LARGE_IMAGE) // Spécifie l'intention à déclencher chaque fois que l'utilisateur interagit avec cette cellule // .setContentIntent (loadArticlePendingIntent (context, "https://code.tutsplus.com/articles/java-vs-) kotlin-devrait-vous-utilisez-kotlin-pour-développement-Android…) addCell it.apply addTitleText ("Coding in Kotlin") addText ("Part 2") addImage (IconCompat.createWithResourc e (contexte, R.drawable.kotlin), ListBuilder.LARGE_IMAGE) .setContentIntent (loadArticlePendingIntent (context, "https://code.tutsplus.com/tutorials/start-developing-android-apps-with-kotlin-part-1) --cms-27827? _ga =…) addCell it.apply addTitleText ("Lambdas & NPE") addText ("Part 3") addImage (IconCompat.createWithResource (context, R.drawable.kotlin), ListBuilder. LARGE_IMAGE) .setContentIntent (loadArticlePendingIntent (context, "https://code.tutsplus.com/articles/coding-functional-android-apps-in-kotlin-lambdas-null-safety-more…) .build ( ) private fun loadArticlePendingIntent (contexte: Context, url: String) = PendingIntent.getActivity (contexte, 0, Intent (Intent.ACTION_VIEW) .apply data = Uri.parse (url), 0)Vous pouvez trouver le code complet de ce projet dans notre rapport GitHub.
Exécutez cette application sur votre AVD ou votre appareil Android physique et essayez d'interagir avec chaque élément de la grille. Chaque cellule doit être liée à un article différent.
La manière dont le contenu de votre tranche est affiché peut varier en fonction de la mode l'application hôte est configurée pour. Pour vous assurer que vos tranches ont une belle apparence et fonctionnent correctement quelle que soit l'application d'hébergement, vous devez tester vos tranches dans les différents modes..
Puisque notre tranche de grille a beaucoup plus de contenu que les tranches précédentes, il est le meilleur candidat pour illustrer les différences entre ces différents modes de tranche..
Pour tester votre tranche, cliquez sur la petite icône située dans le coin supérieur droit de la visionneuse de tranche, puis parcourez les modes suivants:
Dans ce format, Android affiche autant de lignes que possible dans l'espace disponible. C'est le mode que Slice Viewer utilise par défaut.
Dans ce mode, votre tranche est représentée par une icône et une étiquette..
S'il y a un en-tête principal associé à votre SliceAction, alors cela sera utilisé comme icône de votre tranche. S'il n'y a pas d'icône disponible, alors Android affichera l'action principale associée à la première ligne de votre tranche, qui dans ce cas correspond à notre dessin Kotlin..
Pour modifier l'icône affichée en mode raccourci, ajoutez un deuxième dessin à votre projet, puis mettez à jour la section suivante du fournisseur de tranche:
.addGridRow it.apply addCell it.apply addTitleText ("Java vs. Kotlin")) addText ("Part 1") // Référence le nouveau dessinable // addImage (IconCompat.createWithResource (context, R.drawable.androidlogo) , ListBuilder.LARGE_IMAGE)Le mode Small a une hauteur restreinte et affiche soit un seul SliceItem ou une collection limitée d'éléments sous la forme d'une seule ligne de contenu. Si votre tranche a un en-tête, alors il sera affiché, ce qui est exactement ce qui se passe avec notre tranche.
Changer le titre ou le sous-titre affectera le contenu affiché en petit mode.
fun createSliceWithGridRow (sliceUri: Uri): Slice return ListBuilder (contexte, sliceUri, ListBuilder.INFINITY) .setHeader it.apply setTitle ("Ceci est le titre") setSubtitle ("Ceci est le sous-titre")Si votre tranche ne contient pas d'en-tête, la première ligne de la tranche sera affichée à la place..
Une fois que vous avez appris à implémenter une nouvelle fonctionnalité, l'étape suivante consiste à apprendre à fournir les mê
