Contenu
- Quels sont les widgets pour Android?
- Mon projet a-t-il vraiment besoin d'un widget d'application?
- Les widgets pour Android peuvent améliorer l'expérience utilisateur
- Plus puissant que les raccourcis d'application
- Créer un widget Android pour générer un engagement à long terme
- Création d'un widget d'application de collection
- Construire la disposition de votre widget
- Remplir le widget de collection
- AppWidgetProvider: Configuration de votre widget
- Créer l'adaptateur
- Définir les méthodes de cycle de vie du widget
- Récupérer du nouveau contenu avec onUpdate
- onEnabled: Effectuer la configuration initiale
- Nettoyage, avec onDisabled
- Le AppWidgetProvider terminé
- Le fichier AppWidgetProviderInfo
- 1. android: previewImage
- 2. Android: widgetCatégorie
- 3. android: initialLayout
- 4. android: resizeMode = "horizontal | vertical"
- 5. android: minHeight et android: minWidth
- 6. android: updatePeriodMillis
- Le AppWidgetProviderInfo terminé
- Ne pas encombrer l'écran d'accueil de l'utilisateur!
- Envoi de données au widget
- Enregistrement de votre widget dans le manifeste
- Mettez votre widget à l'épreuve
- Création d'une image d'aperçu du widget Android
- Widgets personnalisables: Ajout d'une activité de configuration
- Créer l'activité de configuration
- Tester votre projet
- Emballer
Depuis les débuts de l'OS, les widgets pour Android permettent aux utilisateurs d'interagir avec leurs applications préférées dans le confort de leur écran d'accueil. Alors, comment créez-vous un widget Android?
Pour le développeur, les widgets confèrent à votre application une présence précieuse sur l’écran d’accueil de l’utilisateur. Au lieu d'être cachés dans le tiroir de l'application, les utilisateurs se verront rappeler votre application. A chaque fois ils jettent un coup d’œil sur leur écran d’accueil, tout en obtenant un aperçu du contenu le plus intéressant et utile de votre application.
Les widgets confèrent à votre application une présence précieuse sur l'écran d'accueil de l'utilisateur.
Dans cet article, je vais vous montrer comment offrir une meilleure expérience utilisateur tout en encourageant les utilisateurs à dialoguer avec votre application en créant un widget Android! À la fin de cet article, vous aurez créé un widget de collection à défilement qui affiche un ensemble complet de données sur l’écran d’accueil de l’utilisateur.
Pour vous assurer de fournir le type de widget que les utilisateurs ont vouloir Pour les placer sur leur écran d’accueil, nous allons également créer une activité de configuration, qui permettra aux utilisateurs de personnaliser le contenu, l’apparence et les fonctionnalités du widget. Enfin, je montrerai comment vous pouvez encourager les gens à utiliser votre widget en créant une image d'aperçu du widget qui présente le meilleur de ce que votre widget peut offrir.
Lisez aussi: Développer pour les appareils pliables: Ce que vous devez savoir
Quels sont les widgets pour Android?
Un widget d’application est une application miniature et légère qui réside sur l’écran d’accueil de l’utilisateur.
Les widgets pour Android peuvent fournir une gamme de contenu, mais entrent généralement dans l'une des catégories suivantes:
- Widget d'information. Il s'agit d'un widget sans défilement qui affiche certaines informations, telles que les prévisions météorologiques du jour ou la date et l'heure.
- Widgets de collection. Il s'agit d'un widget à défilement qui affiche un ensemble de données associées, formatées en tant que ListView, GridView, StackView ou AdapterViewFlipper. Les widgets de collection sont généralement sauvegardés par une source de données, telle qu'une base de données ou un tableau.
- Widgets de contrôle. Ces widgets agissent comme une télécommande permettant aux utilisateurs d’interagir avec votre application, sans pour autant avoir à le mettre au premier plan. Les applications qui lisent des fichiers multimédias, tels que des podcasts ou de la musique, disposent souvent de widgets de contrôle permettant à l'utilisateur de déclencher des actions Lecture, Pause et Saut directement à partir de leur écran d'accueil.
- Widgets hybrides. Parfois, vous pourrez offrir une meilleure expérience utilisateur en combinant des éléments de plusieurs catégories. Par exemple, si vous développez un widget de contrôle pour une application musicale, vous pouvez fournir les contrôles Lecture, Pause et Ignorer, mais vous pouvez également décider d’afficher certaines informations, telles que le titre et l’artiste de la chanson. Si vous décidez de mélanger et assortir, alors ne vous laissez pas emporter! Les widgets offrent généralement la meilleure expérience utilisateur lorsqu'ils permettent d'accéder facilement à une petite quantité d'informations pertinentes en temps opportun ou à quelques fonctionnalités couramment utilisées. Pour que vos widgets hybrides restent légers, il est recommandé d’identifier la catégorie principale de votre widget, de la développer en fonction de cette catégorie et puis ajoutez quelques éléments de la catégorie secondaire du widget.
Mon projet a-t-il vraiment besoin d'un widget d'application?
Il existe plusieurs raisons pour lesquelles vous devriez envisager d’ajouter un widget d’application à votre projet Android.
Les widgets pour Android peuvent améliorer l'expérience utilisateur
En règle générale, moins il y a d'étapes de navigation nécessaires pour mener à bien une tâche, meilleure est l'expérience utilisateur.
En fournissant un widget d'application, vous pouvez supprimer plusieurs étapes de navigation des flux les plus couramment utilisés de votre application. Dans le meilleur des cas, vos utilisateurs pourront obtenir les informations dont ils ont besoin simplement en jetant un coup d'œil sur leur écran d'accueil ou effectuer la tâche souhaitée en appuyant simplement sur un bouton de votre widget de contrôle.
Plus puissant que les raccourcis d'application
Les widgets d'applications répondent souvent aux événements onClick en lançant le niveau supérieur de l'application associée, similaire à un raccourci d'application. Toutefois, les widgets peuvent également fournir un accès direct à des activités spécifiques au sein d’une application. Par exemple, appuyer sur la notification Nouvelle réception d’un widget peut lancer l’application associée avec la nouvelle déjà ouverte.
En intégrant plusieurs liens dans la présentation de votre widget, vous pouvez fournir un accès en un clic à toutes les activités les plus importantes de votre application, en supprimant encore plus d'étapes de navigation de vos flux les plus utilisés.
En intégrant plusieurs liens dans la présentation de votre widget, vous pouvez fournir un accès en un clic à toutes les activités les plus importantes de votre application.
Notez que les widgets répondent uniquement aux événements onClick, ce qui empêche les utilisateurs d’interagir accidentellement avec votre widget lorsqu’ils balayent l’écran d’accueil. La seule exception est lorsque l’utilisateur tente de supprimer votre widget en le faisant glisser vers l’action Supprimer de son écran d’accueil, car dans ce scénario, votre widget répondra à un geste de balayage vertical.
Cette interaction est gérée par le système Android. Vous n'avez donc pas à vous soucier de la mise en œuvre manuelle de la prise en charge du balayage vertical dans votre widget.
Créer un widget Android pour générer un engagement à long terme
Convaincre les gens de télécharger votre application n’est que la première étape de la création d’une application Android réussie. Il est fort probable que si vous saisissez votre propre smartphone ou tablette Android et que vous glissiez dans le tiroir des applications, vous découvrirez plusieurs applications que vous n'avez pas utilisées depuis des jours, des semaines, voire des mois!
Lire aussi:Premiers pas avec le SDK Facebook pour Android
Une fois que votre application est correctement installée sur le périphérique de l'utilisateur, vous devrez travailler dur pour les garder engagés et profiter de votre application. Donner à votre application une présence sur l’écran d’accueil peut être un outil puissant pour favoriser un engagement à long terme, tout simplement parce que cela vous rappelle constamment que votre application existe!
Un widget bien conçu peut également servir de publicité permanente pour votre application. Chaque fois que l'utilisateur regarde son écran d'accueil, votre widget a la possibilité de l'encourager activement à renouer avec votre application, en leur présentant tout le contenu le plus intéressant et le plus utile de votre application.
Création d'un widget d'application de collection
Dans ce didacticiel, nous allons construire un widget de collection qui affiche un tableau sous forme de liste déroulante.
Pour vous aider à suivre le cycle de vie du widget d'application, ce widget déclenche également différents toasts lorsqu'il se déplace dans les différents états du cycle de vie. Vers la fin de ce didacticiel, nous allons améliorer notre widget avec une image d'aperçu personnalisée à afficher dans le sélecteur de widgets d'Android et une activité de configuration, qui permettra aux utilisateurs de personnaliser le widget avant de le placer sur leur écran d'accueil.
Créez un nouveau projet Android avec les paramètres de votre choix et commençons!
Construire la disposition de votre widget
Commençons par définir l’interface utilisateur du widget.
Les widgets d'application sont affichés dans un processus à l'extérieur votre application, vous ne pouvez donc utiliser que les dispositions et les vues prises en charge par RemoteViews.
Lors de la création de votre mise en page, vous êtes limité aux éléments suivants:
- Horloge analogique
- Bouton
- Chronomètre
- FrameLayout
- Disposition de la grille
- ImageButton
- ImageView
- LinearLayout
- Barre de progression
- Disposition relative
- Affichage
- ViewStub
- AdapterViewFlipper
- GridView
- ListView
- StackView
- ViewFlipper
Notez que les sous-classes des classes et vues ci-dessus sont ne pas prise en charge.
Créez un nouveau fichier de ressources de présentation nommé list_widget.xml. Comme nous allons afficher nos données à l’aide d’un ListView, cette mise en page sert principalement de conteneur Ensuite, nous devons créer un fournisseur de données pour notre ListView. Créez une nouvelle classe Java nommée DataProvider.java et ajoutez les éléments suivants: importer android.content.Context; importer android.content.Intent; importer android.widget.RemoteViews; importer android.widget.RemoteViewsService; importer java.util.ArrayList; importer java.util.List; importer statique android.R.id.text1; importer android.R.layout.simple_list_item_1 statique; Classe publique DataProvider implémente RemoteViewsService.RemoteViewsFactory {List Pour créer un widget Android, vous devez créer plusieurs fichiers. Notre premier fichier spécifique au widget est un AppWidgetProvider, qui est un BroadcastReceiver dans lequel vous définissez les différentes méthodes de cycle de vie du widget, telles que la méthode appelée lors de la création initiale de votre widget et la méthode appelée lors de sa suppression ultérieure. Créez une nouvelle classe Java (Fichier> Nouveau> Classe Java) nommée CollectionWidget. Pour commencer, tous les fichiers du fournisseur de widgets doivent être issus de la classe AppWidgetProvider. Nous devons ensuite charger le fichier de ressources de présentation list_widget.xml dans un objet RemoteViews et informer le gestionnaire AppWidgetManager de l’objet RemoteViews mis à jour: Classe publique CollectionWidget includes AppWidgetProvider {static void updateAppWidget (Contexte contextuel, AppWidgetManager appWidgetManager, int appWidgetId) {// Instancie l'objet RemoteViews // RemoteViews views = new RemoteViews (context.getPackageName (), R.layout.list_widget); setRemoteAdapter (contexte, vues); // Demande que AppWidgetManager mette à jour le widget d'application // appWidgetManager.updateAppWidget (appWidgetId, views); } Puisque nous affichons nos données dans un ListView, nous devons définir une méthode setRemoteAdapter () dans notre AppWidgetProvider. SetRemoteAdapter () équivaut à appeler AbsListView.setRemoteViewsAdapter () mais est conçu pour être utilisé dans les widgets d'application. Dans cette méthode, nous devons définir l’ID de AdapterView (R.id.widget_list) et l’intention du service qui fournira les données à notre RemoteViewsAdapter - nous allons créer cette classe WidgetService prochainement. void statique privé setRemoteAdapter (contexte de contexte, vues @NonNull Final RemoteViews) {views.setRemoteAdapter (R.id.widget_list, nouvelle intention (contexte, WidgetService.class)); }} Dans notre AppWidgetProvider, nous devons également définir les méthodes de cycle de vie du widget suivantes: La méthode du cycle de vie du widget onUpdate () permet de mettre à jour les vues de votre widget avec les nouvelles informations. Cette méthode s'appelle à chaque fois: C'est également à cet endroit que vous enregistrerez tous les gestionnaires d'événements que votre widget devrait utiliser. Lors de la mise à jour d'un widget Android, il est important de noter que les utilisateurs peuvent créer plusieurs instances du même widget. Par exemple, votre widget est peut-être personnalisable et l'utilisateur décide de créer plusieurs "versions" qui affichent des informations différentes ou permettent d'accéder à des fonctionnalités uniques. Lorsque vous appelez onUpdate (), vous devez spécifier si vous mettez à jour toutes les instances de ce widget ou uniquement une instance spécifique. Si vous souhaitez mettre à jour chaque instance, vous pouvez utiliser appWidgetIds, qui est un tableau d'ID identifiant chaque instance du périphérique. Dans l'extrait suivant, je mets à jour chaque instance: @Override public void onUpdate (contexte de contexte, AppWidgetManager appWidgetManager, int appWidgetIds) {pour (int appWidgetId: appWidgetIds) {// met à jour toutes les instances de ce widget // updateAppWidget (contexte, appWidgetIager, appWidgetId); } super.onUpdate (contexte, appWidgetManager, appWidgetIds); } Notez que pour que le code reste simple, cette méthode onUpdate () n’apporte actuellement aucune modification au widget. La méthode de cycle de vie onEnabled () est appelée en réponse à ACTION_APPWIDGET_ENABLED, qui est envoyée lorsqu'une instance de votre widget est ajoutée à l'écran d'accueil pour première temps. Si l'utilisateur crée deux instances de votre widget, onEnabled () sera appelé pour la première instance, mais ne pas pour le second. La méthode de cycle de vie onEnabled () est l'endroit où vous devez effectuer toute configuration requise pour toutes les instances de votre widget, telle que la création de la base de données qui alimentera les informations de votre widget. Je vais afficher un toast afin que vous puissiez voir exactement quand cette méthode de cycle de vie est appelée: @Override public void onEnabled (contexte de contexte) {Toast.makeText (contexte, "onEnabled appelé", Toast.LENGTH_LONG) .show (); } Notez que si l'utilisateur supprime toutes les instances de votre widget, puis crée une nouvelle instance, celle-ci est classée comme première instance et la méthode de cycle de vie onEnabled () est appelée à nouveau. La méthode onDisabled () est appelée en réponse à ACTION_APPWIDGET_DISABLED, qui est déclenchée lorsque l'utilisateur supprime le dernier instance de votre widget. Cette méthode du cycle de vie du widget est l'endroit où vous devez nettoyer toutes les ressources que vous avez créées dans la méthode onEnabled (), par exemple en supprimant la base de données créée dans onEnabled (). Pour que notre code reste simple, je vais simplement afficher un toast chaque fois que cette méthode est déclenchée: @Override public void onDisabled (contexte de contexte) {Toast.makeText (contexte, "onDisabled appelé", Toast.LENGTH_LONG) .show (); } Votre fichier CollectionWidget devrait maintenant ressembler à ceci: importer android.appwidget.AppWidgetManager; importer android.appwidget.AppWidgetProvider; importer android.content.Context; import androidx.annotation.NonNull; importer android.content.Intent; importer android.widget.RemoteViews; importer android.widget.Toast; // Étendre à partir de la classe AppWidgetProvider // classe publique CollectionWidget étend AppWidgetProvider {statique void updateAppWidget (Contexte contextuel, AppWidgetManager, gestionnaire AppWidgetManager, int appWidgetId) {// Chargement du fichier de ressources de présentation dans un objet RemoteViews // Vues RemoteViews = new RemoteViews (context. getPackageName (), R.layout.list_widget); setRemoteAdapter (contexte, vues); // Informe AppWidgetManager de l'objet RemoteViews // appWidgetManager.updateAppWidget (appWidgetId, views); } @Override public void onUpdate (contexte de contexte, AppWidgetManager appWidgetManager, int appWidgetIds) {pour (int appWidgetId: appWidgetIds) {updateAppWidget (context, appWidgetManager, appWidgetId); } super.onUpdate (contexte, appWidgetManager, appWidgetIds); } @Override public void onEnabled (contexte de contexte) {Toast.makeText (contexte, "onEnabled appelé", Toast.LENGTH_LONG) .show (); } @Override public void onDisabled (contexte de contexte) {Toast.makeText (contexte, "onDisabled appelé", Toast.LENGTH_LONG) .show (); } void statique privé setRemoteAdapter (contexte de contexte, vues @NonNull Final RemoteViews) {views.setRemoteAdapter (R.id.widget_list, nouvelle intention (contexte, WidgetService.class)); }} Votre widget d’application nécessite également un fichier AppWidgetProviderInfo, qui définit plusieurs propriétés importantes, y compris les dimensions minimales de votre widget et la fréquence à laquelle il doit être mis à jour. Le fichier AppWidgetProviderInfo est stocké dans le dossier res / xml de votre projet. Si votre projet ne contient pas déjà ce dossier, vous devrez le créer: Ensuite, créez un fichier collection_widget_info, que nous utiliserons comme notre AppWidgetProviderInfo: Dans notre fichier AppWidgetProviderInfo, nous devons définir les propriétés suivantes: Il s’agit du dessin que représente votre widget d’application dans le sélecteur de widgets de l’appareil.Remplir le widget de collection
AppWidgetProvider: Configuration de votre widget
Créer l'adaptateur
Définir les méthodes de cycle de vie du widget
Récupérer du nouveau contenu avec onUpdate
onEnabled: Effectuer la configuration initiale
Nettoyage, avec onDisabled
Le AppWidgetProvider terminé
Le fichier AppWidgetProviderInfo
1. android: previewImage
Si vous ne fournissez pas une image de prévisualisation, Android utilisera à la place l'icône de votre application. Pour encourager les utilisateurs à sélectionner votre widget dans le sélecteur de widgets, vous devez fournir un dessin indiquant ce à quoi votre widget ressemblera une fois qu’il est correctement configuré sur son écran d’accueil.
Le moyen le plus simple de créer une image d’aperçu consiste à utiliser l’application Widget Preview incluse dans l’émulateur Android. Cette application vous permet de configurer votre widget, puis de générer une image, que vous pouvez ensuite utiliser dans votre projet Android.
Nous allons créer cette image une fois que nous aurons fini de créer notre widget. Par conséquent, j’utiliserai pour l’instant la ressource mipmap / ic_launcher générée automatiquement comme image d’aperçu temporaire.
2. Android: widgetCatégorie
Les widgets d'application doivent être placés dans un hôte de widget d'application, qui correspond généralement à l'écran d'accueil Android d'origine, mais peut également être un lanceur tiers, tel que Evie Launcher ou Nova Launcher.
Entre les niveaux 17 et 20 de l’API, il était possible de placer des widgets d’application sur l’écran d’accueil. ou lockscreen, mais la prise en charge de lockscreen était obsolète dans l’API de niveau 21.
Vous pouvez spécifier si votre widget d'application peut être placé sur l'écran d'accueil, le lockscreen (qu'Android appelle le «protège-clavier») ou les deux, à l'aide de l'attribut android: widgetCategory. Comme il n’est pas possible de placer des widgets sur le lockscreen dans les versions les plus récentes d’Android, nous ne viserons que l’écran d’accueil.
Pour préserver la confidentialité de l'utilisateur, votre widget ne doit afficher aucune information sensible ou privée lorsqu'il est placé sur l'écran de verrouillage.
Si vous donnez aux utilisateurs la possibilité de placer votre widget sur l'écran de verrouillage, toute personne qui jettera un coup d'œil sur son appareil pourrait potentiellement voir votre widget et tout son contenu. Pour aider à préserver la confidentialité de l'utilisateur, votre widget ne doit afficher aucune information sensible ou privée lorsqu'il est placé sur l'écran de verrouillage. Si votre widget contient des données personnelles, vous pouvez envisager de fournir des dispositions distinctes pour l'écran d'accueil et l'écran verrouillé.
3. android: initialLayout
Il s’agit du fichier de ressources de présentation que votre widget doit utiliser lorsqu’il est placé sur l’écran d’accueil, qui est pour notre projet list_widget.xml.
4. android: resizeMode = "horizontal | vertical"
L'attribut android: resizeMode vous permet de spécifier si votre widget peut être redimensionné horizontalement, verticalement ou le long des deux axes.
Pour vous assurer que votre widget s'affiche et fonctionne correctement sur plusieurs écrans, il est recommandé d'autoriser le redimensionnement horizontal de votre widget. et verticalement, sauf si vous avez une raison particulière de ne pas le faire.
5. android: minHeight et android: minWidth
Si votre widget est redimensionnable, vous devez vous assurer que l'utilisateur ne le réduit pas au point de le rendre inutilisable. Vous pouvez utiliser les attributs minHeight et minWidth pour définir le plus petit format de votre application lorsque celle-ci est redimensionnée par l'utilisateur.
Ces valeurs représentent également la taille initiale de votre widget. Par conséquent, si votre widget n’est pas redimensionnable, minHeight et minWidth définiront le dimensionnement permanent du widget.
6. android: updatePeriodMillis
C'est également dans AppWidgetProviderInfo que vous spécifiez la fréquence à laquelle votre widget doit demander de nouvelles informations.
Le plus petit intervalle de mise à jour pris en charge est une fois toutes les 1800 000 millisecondes (30 minutes). Même si vous déclarez un intervalle de mise à jour plus court, votre widget ne sera toujours mis à jour qu'une fois par demi-heure.
Si vous souhaitez afficher les dernières informations aussi rapidement que possible, le système volonté réveillez un périphérique en veille afin de récupérer de nouvelles informations. Des mises à jour fréquentes peuvent brûler la batterie d’un appareil, en particulier lorsque celui-ci est laissé inactif pendant une période assez longue, par exemple toute la nuit. Offrir la meilleure expérience utilisateur possible, c'est trouver un équilibre entre limiter la consommation de la batterie et fournir de nouvelles informations dans un délai raisonnable.
Vous devez également prendre en compte le type de contenu affiché par votre widget.
Vous devez également prendre en compte le type de contenu que vos widgets pour Android vont afficher. Par exemple, un widget météo peut uniquement avoir besoin de récupérer une prévision mise à jour une fois par jour, tandis qu'une application affichant des informations de dernière minute devra se mettre à jour plus fréquemment.
Pour trouver cet équilibre parfait, vous devrez peut-être tester votre widget sur une plage de fréquences de mise à jour et en mesurer l'impact sur la durée de vie de la batterie et l'actualité du contenu de votre widget. Si vous avez un groupe de testeurs volontaires, vous pouvez même configurer des tests A / B pour voir si certaines fréquences de mise à jour sont reçues de manière plus positive que d’autres.
A lire également: AndroidManifest.xml tout ce que vous devez savoir
Enfin, une fois que vous avez identifié l'intervalle de mise à jour parfait, vous pouvez utiliser un intervalle plus court pour développer et tester votre application. Par exemple, vous pouvez utiliser la fréquence de mise à jour la plus courte possible (android: updatePeriodMillis = "1800000") lorsque vous testez le déclenchement correct de la méthode onUpdate () de votre application, puis modifier cette valeur avant de publier votre application au grand public.
Le AppWidgetProviderInfo terminé
Le fichier final collection_widget_info.xml devrait ressembler à ceci:
Ne pas encombrer l'écran d'accueil de l'utilisateur!
Pour que l'écran d'accueil ne semble jamais encombré, nous allons ajouter des marges de remplissage et des marges à notre widget. Si votre projet ne contient pas déjà un fichier dimens.xml, vous devrez en créer un:
- Cliquez sur le dossier de valeurs de votre projet en maintenant la touche Contrôle enfoncée.
- Sélectionnez Nouveau> Fichier de ressources de valeurs.
- Donnez à ce fichier le nom dimens.
- Cliquez sur OK.
Ouvrez votre fichier dimens.xml et définissez les valeurs de marge et de remplissage suivantes:
Envoi de données au widget
Ensuite, nous devons créer un service de widget, qui sera responsable de l’envoi des données de notre collection au widget.
Créez une nouvelle classe Java (Nouveau> Classe Java) nommée WidgetService et ajoutez les éléments suivants:
importer android.content.Intent; importer android.widget.RemoteViewsService; Classe publique WidgetService étend RemoteViewsService {@Override public RemoteViewsFactory onGetViewFactory (Intentity) {retournera un nouveau fournisseur de données (this, intent); }}
Enregistrement de votre widget dans le manifeste
Nous devons maintenant apporter quelques modifications au manifeste de notre projet.
Pour commencer, ouvrez le manifeste et enregistrez votre widget en tant que BroadcastReceiver. Nous devons également ajouter un filtre d'intention pour l'action android.appwidget.action.APPWIDGET_UPDATE:
Ensuite, vous devez spécifier le fournisseur de widget d'application:
Enfin, nous devons déclarer le service qui enverra des données à notre widget, qui est dans ce cas la classe WidgetService. Ce service nécessite l'autorisation android.permission.BIND_REMOTEVIEWS:
Mettez votre widget à l'épreuve
Si vous suivez ce didacticiel, vous disposez maintenant d’un widget de collecte complet qui affiche un ensemble de données sur l’écran d’accueil de l’utilisateur.
S'il s'agissait d'un projet Android réel, vous développeriez généralement les méthodes de cycle de vie, en particulier la méthode onUpdate (), mais c'est tout ce dont nous avons besoin pour créer un widget que vous pouvez installer et tester sur votre appareil Android:
- Installez ce projet sur un smartphone, une tablette ou un AVD Android compatible (Android Virtual Device).
- Appuyez longuement sur une section vide de l'écran d'accueil et sélectionnez Widgets lorsque vous y êtes invité. cela lance le sélecteur de widgets.
- Faites glisser le sélecteur de widgets jusqu'à ce que vous trouviez le widget d'application que vous venez de créer.
- Appuyez longuement sur ce widget pour l'ajouter à votre écran d'accueil.
- Comme il s’agit de la première instance de ce widget particulier, la méthode onEnabled () doit s’exécuter et vous verrez apparaître un toast «onEnabled appelé».
- Redimensionnez votre widget. Si vous définissez une taille minimale prise en charge, vérifiez que vous ne pouvez pas réduire le widget au-delà de cette valeur.
- Vérifiez que le ListView défile, comme prévu.
- Ensuite, vous devriez vérifier la méthode onDisabled () en supprimant votre widget. Appuyez longuement sur le widget, puis sélectionnez Supprimer de l'écran d'accueil. Comme il s’agit de la dernière instance de ce widget particulier, la méthode onDisabled () doit s’exécuter et vous verrez apparaître un toast «onDisabled appelé».
C’est tout ce dont vous avez besoin pour créer un widget d’application Android fonctionnel, mais quelques ajouts peuvent souvent améliorer l’expérience utilisateur. Dans les sections suivantes, nous encouragerons les utilisateurs à choisir ce widget dans le sélecteur de widgets en créant une image d’aperçu qui présente le widget à son meilleur. Je vais également vous montrer comment créer un widget entièrement personnalisable en ajoutant une activité de configuration à votre projet.
Création d'une image d'aperçu du widget Android
Si vous saisissez votre appareil Android et faites glisser votre doigt dans le sélecteur de widgets, vous verrez que chaque widget est représenté par une image, ce qui montre généralement à quoi ce widget aura l'air une fois configuré sur l'écran d'accueil de l'utilisateur.
Pour encourager les utilisateurs à sélectionner votre widget, vous devez fournir une image d'aperçu mettant en évidence toutes les informations et fonctionnalités utiles offertes par votre widget.
Vous pouvez créer rapidement et facilement une image d’aperçu à l’aide de l’application Widget Preview incluse dans l’émulateur Android.
Notez que l'aperçu de widget n'est pas inclus dans les dernières images du système Android. Vous devez donc créer un AVD à l'aide de Nougat (API de niveau 25) ou une version antérieure:
- Installez votre application sur un AVD exécutant l’API 25 ou inférieure.
- Ouvrez le tiroir de l'application AVD et lancez l'application Widget Preview.
- L’aperçu du widget affiche une liste de toutes les applications actuellement installées sur cet AVD; sélectionnez votre application dans la liste.
- Votre widget sera maintenant affiché sur un arrière-plan vide. Passez du temps à redimensionner et à peaufiner votre widget jusqu'à ce qu'il affiche le meilleur de ce que votre widget peut offrir.
- Une fois que vous êtes satisfait de l'apparence et du contenu de votre widget, sélectionnez Prendre un instantané.
- Pour récupérer votre instantané, revenez dans Android Studio et sélectionnez Afficher> Fenêtres d'outils> Explorateur de fichiers de périphérique dans la barre d'outils. Ceci lance l’Explorateur de fichiers de périphériques d’Android Studio.
- Dans l'explorateur de fichiers du périphérique, accédez à sdcard / Download. Vous devriez trouver votre image de prévisualisation enregistrée au format suivant: _ori_.png
- Faites glisser cette image hors d'Android Studio et déposez-la dans un endroit facilement accessible, tel que votre bureau.
- Donnez à ce fichier image un nom descriptif.
- Glissez et déposez le fichier dans le dossier pouvant être dessiné de votre projet.
- Ouvrez votre AppWidgetProviderInfo, qui pour ce projet est collection_widget_info.xml.
- Recherchez la ligne android: previewImage = ”@ @ mipmap / ic_launcher” et mettez-la à jour pour référencer votre image d'aperçu.
Votre widget va maintenant utiliser cette nouvelle ressource image comme image d'aperçu:
- Installez le projet mis à jour sur votre appareil Android physique ou AVD.
- Appuyez longuement sur une section vide de l'écran d'accueil.
- Appuyez sur Widgets pour lancer le sélecteur de widgets.
- Faites défiler jusqu'à votre widget; il devrait maintenant utiliser l'image de prévisualisation mise à jour.
Widgets personnalisables: Ajout d'une activité de configuration
Une activité de configuration démarre automatiquement lorsque l'utilisateur place chaque instance de votre widget sur son écran d'accueil.
Il est possible que vous souhaitiez ajouter une activité de configuration à votre projet pour plusieurs raisons.
Les widgets offrent généralement la meilleure expérience utilisateur lorsqu'ils fournissent un accès aux informations ou fonctionnalités les plus importantes pour chaque utilisateur.
Premièrement, certains widgets nécessitent une configuration initiale. Par exemple, un widget qui affiche des alertes de trafic doit peut-être connaître l'adresse de domicile de l'utilisateur, son lieu de travail et l'heure à laquelle il se déplace. Sans un moyen d'entrer ces informations, votre widget pourrait être complètement inutile!
En outre, les widgets offrent généralement la meilleure expérience utilisateur lorsqu'ils fournissent un accès aux informations ou fonctionnalités les plus importantes pour chaque utilisateur. En ajoutant une activité de configuration à votre projet, vous pouvez donner aux utilisateurs la liberté de choisir et de choisir exactement ce qui est inclus dans votre widget.
Même des personnalisations relativement simples, telles que la modification de l'arrière-plan ou de la police d'un widget, peuvent avoir un impact positif sur l'expérience utilisateur. Après tout, personne ne va apprécier un widget qui entre en conflit visuel avec le reste de son écran d'accueil!
Personne ne va apprécier un widget qui entre en conflit visuel avec le reste de son écran d’accueil!
Vous pouvez également parfois avoir une longue liste de contenu que vous souhaitez inclure dans votre widget et vous avez du mal à limiter vos options. Une activité de configuration peut être un moyen de tirer parti de toutes vos idées, sans créant un widget encombré, déroutant. N'oubliez pas que la configuration d'un widget ne doit pas sembler être une corvée. Par conséquent, si vous fournissez une activité de configuration, il est recommandé de vous limiter à trois options de configuration.
Ajoutons une activité de configuration à notre projet!
Tout d'abord, notre configuration Activity a besoin d'une mise en page. Créez donc un nouveau fichier de ressources de mise en page nommé config_activity.xml.
Je vais ajouter les boutons suivants à cette présentation:
- Un bouton de configuration. Dans un projet réel, ce bouton modifierait le widget d'une certaine manière, par exemple en ajoutant ou supprimant du contenu, ou en modifiant la fréquence de mise à jour du widget. Pour vous aider à garder notre code simple, cliquez sur ce bouton pour afficher simplement un toast d'options de configuration.
- Un bouton de configuration. Une fois que l'utilisateur est satisfait de la configuration de son widget, appuyez sur ce bouton pour placer le widget nouvellement configuré sur son écran d'accueil.
Voici mon fichier config_activity.xml complété:
Créer l'activité de configuration
Maintenant, nous devons créer notre activité de configuration.
Pour commencer, créez une nouvelle classe Java appelée ConfigActivity. Dans cette activité, nous allons extraire l'ID de widget d'application à partir de l'intention qui a lancé l'activité de configuration. Si cette intention n’a pas d’ID de widget, nous devrons appeler la méthode finish ():
Intention intention = getIntent (); Extras de paquet = intent.getExtras (); if (extras! = null) {appWidgetId = extras.getInt (AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {finish (); }
Ensuite, nous devons créer une intention de retour, transmettre l’appWidgetId d’origine et définir les résultats de la configuration. Activité:
Intent resultValue = new Intent (); resultValue.putExtra (AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); setResult (RESULT_OK, resultValue); terminer(); }}}
Si vous fournissez une activité de configuration, la diffusion ACTION_APPWIDGET_UPDATE ne sera pas envoyée automatiquement au lancement de la configuration, ce qui signifie que la méthode onUpdate () habitude être appelé lorsque l'utilisateur crée une instance de votre widget.
Pour vous assurer que votre widget est créé avec des informations et du contenu à jour, votre activité de configuration doit déclencher la première demande onUpdate ().
Voici le fichier ConfigActivity terminé:
importer android.app.Activity; importer android.appwidget.AppWidgetManager; importer android.os.Bundle; importer android.widget.Button; importer android.content.Intent; importer android.view.View; importer android.view.View.OnClickListener; importer android.widget.Toast; Classe publique ConfigActivity étend l'activité {@Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.config_activity); setResult (RESULT_CANCELED); Configuration du bouton = (Bouton) findViewById (R.id.setupWidget); setupWidget.setOnClickListener (new OnClickListener () {@Override public void onClick (Affichage v) {handleSetupWidget ();}}); Bouton configButton = (Bouton) findViewById (R.id.configButton); configButton.setOnClickListener (new OnClickListener () {@Override public void onClick (Affichage v) {handleConfigWidget ();}}); } void privé handleSetupWidget () {showAppWidget (); } private void handleConfigWidget () {Toast.makeText (ConfigActivity.this, "Options de configuration", Toast.LENGTH_LONG) .show (); } int appWidgetId; void privé showAppWidget () {appWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; Intention intention = getIntent (); Extras de paquet = intent.getExtras (); if (extras! = null) {appWidgetId = extras.getInt (AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {finish (); } // A FAIRE: Effectuer la configuration // Intent resultValue = new Intent (); resultValue.putExtra (AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); setResult (RESULT_OK, resultValue); terminer(); }}}
Une fois que vous avez créé une activité de configuration, vous devez déclarer cette activité dans le manifeste et indiquer qu’elle accepte l’action APPWIDGET_CONFIGURE:
Enfin, comme une activité de configuration est référencée en dehors de la portée du package, nous devons déclarer cette activité dans notre application AppWidgetProviderInfo, qui est dans ce cas le fichier collection_widget_info.xml:
android: configure = "com.jessicathornsby.collectionwidget.ConfigActivity">
Tester votre projet
Il est maintenant temps de mettre votre projet fini à l'épreuve:
- Installez votre projet mis à jour sur un périphérique Android physique ou AVD.
- Supprimez toutes les instances précédentes de votre widget pour vous assurer de travailler avec la toute dernière version.
- Appuyez longuement sur une zone vide de l'écran d'accueil et sélectionnez Widgets lorsque vous y êtes invité.
- Trouvez votre widget dans le sélecteur de widgets et appuyez longuement pour le sélectionner.
- Déposez le widget sur votre écran d'accueil. L'activité de configuration devrait se lancer automatiquement.
- Cliquez sur le bouton Effectuer une configuration et un message indiquant les options de configuration doit apparaître pour confirmer que cette interaction a bien été enregistrée.
- Imaginez que vous avez peaufiné les paramètres du widget et que vous êtes maintenant prêt à le placer sur votre écran d'accueil; appuyez sur le bouton Créer le widget pour que ce widget soit créé avec succès.
Vous pouvez télécharger le projet de widget de collection terminé à partir de GitHub.
Emballer
Dans cet article, nous avons créé un widget de collection à défilement qui affiche un ensemble de données sur l’écran d’accueil de l’utilisateur.
Si vous souhaitez continuer à utiliser ce projet, essayez d’ajouter votre propre code à la méthode onUpdate () afin de créer un widget qui met à jour de nouvelles informations selon l’intervalle défini dans votre fichier AppWidgetProviderInfo (collection_widget_info).
Si vous créez un widget Android, assurez-vous de partager vos créations dans les commentaires ci-dessous!
