Share
Les widgets d’application offrent à vos utilisateurs un accès facile aux fonctionnalités les plus fréquemment utilisées de votre application, tout en donnant à votre application une présence sur son écran d’accueil. En ajoutant un widget à votre projet, vous pouvez offrir une meilleure expérience utilisateur tout en encourageant les utilisateurs à rester actifs avec votre application. Chaque fois qu'ils consultent leur écran d'accueil, ils voient votre widget et affichent les informations les plus utiles et les plus utiles de votre application. contenu intéressant.
Dans cette série en trois parties, nous construisons un widget d’application qui a toutes les fonctionnalités que vous trouverez dans chaque Widget d'application Android.
Dans le premier article, nous avons créé un widget qui récupère et affiche les données et effectue une action unique en réponse à sur clic événements. Cependant, il manque toujours une fonctionnalité essentielle à notre widget: jamais mises à jour avec de nouvelles informations. Un widget qui n'a jamais rien de nouveau à offrir n'est pas très utile, nous allons donc donner à notre widget deux différentes façons de mettre à jour.
À la fin de cette série, nous aurons étendu notre widget pour extraire et afficher automatiquement les nouvelles données en fonction d'un calendrier., et en réponse à l'interaction de l'utilisateur.
Nous récupérons là où nous en étions, donc si vous n'avez pas une copie du widget que nous avons créé dans le premier message, vous pouvez le télécharger à partir de GitHub..
La première étape consiste à mettre à jour notre mise en page pour afficher certaines données qui changent avec le temps. Pour nous aider à savoir exactement quand notre widget reçoit chaque mise à jour, je vais lui demander de récupérer et d'afficher l'heure actuelle chaque fois qu'il effectue une mise à jour..
Je vais ajouter ce qui suit à la présentation du widget:
Accentsconagua
Affichage qui affiche un Dernière mise à jour étiquette.Affichage qui affichera l'heure de la dernière mise à jour.Pendant que nous travaillons sur le new_app_widget.xml fichier, je vais aussi ajouter le Affichage cela permettra finalement à l'utilisateur de déclencher une mise à jour manuellement:
// Ajouter un 'Tapez pour mettre à jour' TextView // // Ajoute un TextView qui affichera notre étiquette 'Dernière mise à jour' // // Ajoute le TextView qui affichera l'heure de la dernière mise à jour //
Ensuite, définissez les nouvelles ressources de chaîne que nous référençons dans notre mise en page:
Appuyez sur pour mettre à jour Dernière mise à jour % 1 $ s
le @ chaîne / heure semble différent de votre chaîne typique, car il s'agit simplement d'un espace réservé qui sera remplacé à l'exécution.
Cela nous donne la mise en page finie:
Comme il s’agit de la méthode la plus simple à implémenter, je vais commencer par mettre à jour notre widget automatiquement, au bout d’un certain laps de temps..
Lors de la création de ce type de programme de mise à jour automatique, 1 800 000 millisecondes (30 minutes) est le plus petit intervalle que vous pouvez utiliser. Même si vous définissez votre projet updatePeriodMillis à moins de 30 minutes, vous widget encore seulement mettre à jour une fois toutes les demi-heures.
Décider de la fréquence à laquelle votre widget doit être mis à jour n’est jamais simple. Les mises à jour fréquentes épuisent davantage la batterie de l'appareil, mais définissez ces mises à jour de manière à ce qu'elles soient trop éloignées l'une de l'autre pour que votre widget puisse afficher des informations obsolètes pour l'utilisateur..
Pour trouver une balance qui convient à votre projet particulier, vous devez tester votre widget sur une plage de fréquences de mise à jour et mesurer l'impact de chaque fréquence sur la durée de vie de la batterie, tout en contrôlant si le contenu du widget devient toujours trop obsolète..
Dans la mesure où la fréquence est trop fréquente est l’une de ces questions subjectives frustrantes pour lesquelles il n’ya pas de réponse «juste», il peut être utile d’obtenir un deuxième avis en organisant des tests utilisateur. Vous pouvez même configurer des tests A / B pour vérifier si certaines fréquences de mise à jour sont reçues de manière plus positive que d'autres..
Ouvrez votre projet AppWidgetProviderInfo fichier (res / xml / new_app_widget_info.xml) et vous verrez qu'il définit déjà un intervalle de mise à jour par défaut de 86400000 millisecondes (24 heures).
android: updatePeriodMillis = "86400000"
Il existe de nombreux widgets qui ne sont mis à jour qu'une fois toutes les 24 heures. Par exemple, un widget affichant les prévisions météo peut ne nécessiter que de récupérer les nouvelles informations une fois par jour. Toutefois, même si votre widget ne doit être mis à jour qu'une fois par jour, ce n'est pas idéal pour tester votre application. Personne ne veut attendre 24 heures juste pour voir si son onUpdate () La méthode se déclenche correctement. Par conséquent, vous utiliserez généralement l'intervalle le plus court possible lors du test initial, puis vous modifierez cette valeur ultérieurement, si nécessaire..
Pour faciliter le test de notre application, je vais utiliser le plus petit intervalle possible:
android: updatePeriodMillis = "1800000"
le onUpdate () méthode est responsable de la mise à jour de votre widget Des vues avec de nouvelles informations. Si vous ouvrez le fournisseur de widgets de votre projet (java / values / NewAppWidget.java) alors vous verrez qu'il contient déjà le contour d'un onUpdate () méthode:
@Override public void onUpdate (contexte contextuel, AppWidgetManager appWidgetManager, int [] appWidgetIds) // Il peut y avoir plusieurs widgets actifs, alors mettez-les tous à jour // pour (int appWidgetId: appWidgetIds) updateAppWidget (context, appWidgetManager, appWidgetId) ;
Que le widget soit mis à jour automatiquement ou en réponse à une interaction de l'utilisateur, le processus de mise à jour est exactement le même: le gestionnaire de widgets envoie une intention de diffusion avec le message. ACTION_APPWIDGET_UPDATE action, et la classe fournisseur de widgets répond en appelant le onUpdate () méthode, qui à son tour appelle le updateAppWidget () méthode d'assistance.
Une fois que nous avons mis à jour notre NewAppWidget.java classe pour récupérer et afficher l’heure actuelle, notre projet utilisera cette même section de code quelle que soit la onUpdate () la méthode est déclenchée:
importer android.appwidget.AppWidgetManager; importer android.appwidget.AppWidgetProvider; importer android.content.Context; importer android.widget.RemoteViews; importer android.app.PendingIntent; importer android.content.Intent; importer android.net.Uri; import java.text.DateFormat; importer java.util.Date; Classe publique NewAppWidget étend AppWidgetProvider statique void updateAppWidget (contexte contextuel, AppWidgetManager, gestionnaire appWidget, (int AppWidgetTID)) // Récupération de l'heure // String timeString = DateFormat.getTimeInstance (DateFormat.SHORT) .format (new Date ()); // Construction de l'objet RemoteViews // RemoteViews views = new RemoteViews (context.getPackageName (), R.layout.new_app_widget); views.setTextViewText (R.id.id_value, String.valueOf (appWidgetId)); // Récupère et affiche l'heure // views.setTextViewText (R.id.update_value, context.getResources (). GetString (R.string.time, timeString)); Intention Intention = nouvelle Intention (Intent.ACTION_VIEW, Uri.parse ("https://code.tutsplus.com/")); PendingIntent waitingIntent = PendingIntent.getActivity (context, 0, intent, 0); views.setOnClickPendingIntent (R.id.launch_url, waitingIntent); appWidgetManager.updateAppWidget (appWidgetId, vues); @Override public void onUpdate (contexte contextuel, AppWidgetManager appWidgetManager, int [] appWidgetIds) // Si plusieurs widgets sont actifs, mettez-les tous à jour // pour (int appWidgetId: appWidgetIds) updateAppWidget (context, appWidgetManager, appWidgetId); Le code ci-dessus pose un problème: si l'utilisateur appuie sur le bouton Affichage plusieurs fois au cours d'une minute, il n'y aura aucune indication visuelle de la mise à jour du widget, simplement parce qu'il n'y a pas de nouvelle heure d'affichage. Cela ne posera probablement pas de problèmes pour vos utilisateurs finaux, qui ont peu de chance de rester assis à la même table Affichage plusieurs fois par minute et en se demandant pourquoi le temps n'a pas changé. Cependant, cela peut poser un problème lors du test de votre application, car cela signifie que vous devrez attendre au moins 60 secondes entre le déclenchement de la onUpdate () méthode.
Pour s'assurer qu'il y a toujours une sorte de confirmation visuelle que le onUpdate () méthode a fonctionné avec succès, je vais afficher un toast chaque fois onUpdate () est appelé:
import android.widget.Toast;… @Override public void onUpdate (contexte de contexte, AppWidgetManager appWidgetManager, int [] appWidgetIds) pour (int appWidgetId: appWidgetIds) updateAppWidget (contexte, appWidgetManager, appWidgetId); Toast.makeText (contexte, "Le widget a été mis à jour!", Toast.LENGTH_SHORT) .show ();
Notre widget va maintenant se mettre à jour automatiquement toutes les demi-heures, mais qu'en est-il de la mise à jour en réponse à l'interaction de l'utilisateur?
Nous avons déjà beaucoup jeté les bases en ajoutant un Appuyez sur pour mettre à jour Affichage à notre mise en page et l'expansion de la NewAppWidget.java classe pour récupérer et afficher l'heure actuelle chaque fois que onUpdate () est appelé.
La seule chose à faire est de créer un Intention avec AppWidgetManager.ACTION_APPWIDGET_UPDATE, qui est une action qui informe le widget qu'il est temps de mettre à jour, puis appelle cette intention en réponse à l'utilisateur interagissant avec le Appuyez sur pour mettre à jour Affichage.
Voici le terminé NewAppWidget.java classe:
importer android.appwidget.AppWidgetManager; importer android.appwidget.AppWidgetProvider; importer android.content.Context; importer android.widget.RemoteViews; importer android.app.PendingIntent; importer android.content.Intent; importer android.net.Uri; import java.text.DateFormat; importer java.util.Date; importer android.widget.Toast; Classe publique NewAppWidget étend AppWidgetProvider statique void updateAppWidget (contexte contextuel, AppWidgetManager, gestionnaire appWidgetManager, int appWidgetId) // Récupération de l'heure actuelle // String timeString = DateFormat.getTimeInstance (DateFormat.SHORT) .format (new Date ()); Vues RemoteViews = new RemoteViews (context.getPackageName (), R.layout.new_app_widget); views.setTextViewText (R.id.id_value, String.valueOf (appWidgetId)); views.setTextViewText (R.id.update_value, context.getResources (). getString (R.string.time, timeString)); // Créer une intention avec l'action AppWidgetManager.ACTION_APPWIDGET_UPDATE // Intent intentUpdate = new Intent (context, NewAppWidget.class); intentUpdate.setAction (AppWidgetManager.ACTION_APPWIDGET_UPDATE); // Met à jour l'instance de widget actuelle uniquement, en créant un tableau contenant l'ID unique du widget // int [] idArray = new int [] appWidgetId; intentUpdate.putExtra (AppWidgetManager.EXTRA_APPWIDGET_IDS, idArray); // Enveloppe l'intention en tant que PendingIntent, en utilisant PendingIntent.getBroadcast () // PendingIntent waitingUpdate = PendingIntent.getBroadcast (context, appWidgetId, intentUpdate, PendingIntent.FLAG_UPDATE_CURRENT); // Envoie l'intention en attente en réponse à l'utilisateur en tapant sur TextView 'Update' // views.setOnClickPendingIntent (R.id.update, waitingUpdate); Intention Intention = nouvelle Intention (Intent.ACTION_VIEW, Uri.parse ("https://code.tutsplus.com/")); PendingIntent waitingIntent = PendingIntent.getActivity (context, 0, intent, 0); views.setOnClickPendingIntent (R.id.launch_url, waitingIntent); // Demande que AppWidgetManager mette à jour le widget d'application // appWidgetManager.updateAppWidget (appWidgetId, views); @Override public void onUpdate (contexte de contexte, AppWidgetManager appWidgetManager, int [] appWidgetIds) pour (int appWidgetId: appWidgetIds) updateAppWidget (context, appWidgetManager, appWidgetId); Toast.makeText (contexte, "Le widget a été mis à jour!", Toast.LENGTH_SHORT) .show (); Pouvoir mettre à jour un widget à la demande peut s'avérer inestimable lors du test de votre projet, car cela signifie que vous ne devez jamais attendre que l'intervalle de mise à jour s'écoule. Même si vous n'incluez pas cette fonctionnalité dans votre application finie, vous souhaiterez peut-être ajouter une Appuyez sur pour mettre à jour bouton, juste pour vous simplifier la vie lorsque vous testez votre projet.
Notre widget ressemble maintenant complètement différent du widget généré automatiquement par Android Studio pour nous, mais il utilise encore l'image d'aperçu générée automatiquement.
Idéalement, votre aperçu devrait inciter les utilisateurs à sélectionner votre widget dans le sélecteur de widgets, mais il devrait au moins être une représentation précise de l'apparence réelle de votre widget! Actuellement, nos ticks d'image d'aperçu ni de ces boîtes, nous avons donc besoin de créer un nouveau.
La méthode la plus simple consiste à utiliser le Aperçu du widget application incluse dans l'émulateur Android.
Création d'un aperçu du widget
Commencez par installer votre projet sur un périphérique virtuel Android (AVD). Ouvrez ensuite le tiroir d'applications de l'AVD et lancez l'application Widget Preview. L'AVD affichera une liste de toutes les applications installées sur l'appareil. Sélectionnez votre application dans la liste..
Votre widget sera affiché sur un fond vide. Passez un peu de temps à redimensionner et à peaufiner votre widget afin qu'il soit le plus beau possible, et une fois satisfait du résultat, sélectionnez Prendre un instantané. La capture d'écran sera sauvegardée en tant que PNG dans les AVD Télécharger dossier. Pour récupérer ce fichier, revenez dans Android Studio et ouvrez le Explorateur de fichier de périphérique, en sélectionnant Affichage> Fenêtres d'outils> Explorateur de fichiers du périphérique de la barre d'outils. Dans la vue Explorateur de fichiers du périphérique, accédez au sdcard / Télécharger dossier, où vous trouverez l'image de prévisualisation enregistrée en tant que: [nom_app] _ori_ [orientation] .png
Faites glisser cette image hors d'Android Studio et déposez-la dans un endroit facilement accessible, tel que votre bureau. Attribuez un nom plus descriptif à l’image, puis faites-la glisser dans l’image de votre projet. tirable dossier. Maintenant vous pouvez ouvrir le AppWidgetProviderInfo fichier (dans ce cas, c'est new_app_widget_info.xml) et modifiez la ligne suivante pour référencer votre nouvelle image d’aperçu:
android: previewImage = "@ drawable / example_appwidget_preview"
Enfin, vous pouvez supprimer les informations inutiles. example_appwidget_preview tirable de votre projet.
Il est temps de mettre le widget fini à l'épreuve!
Tout d’abord, installez le projet mis à jour sur votre périphérique Android physique ou AVD. Supprimez toutes les instances existantes de ce widget de votre écran d’accueil afin que vous puissiez: savoir vous travaillez avec la dernière version.
Pour ajouter votre widget, appuyez sur n’importe quel espace vide sur l’écran d’accueil, appuyez sur Widget puis sélectionnez votre widget. Vous aurez la possibilité de redimensionner et de repositionner le widget, si nécessaire..
le Dernière mise à jour valeur affichera l'heure à laquelle vous avez créé ce widget. presse Appuyez sur pour mettre à jour et le widget devrait afficher un toast et une nouvelle heure. Si vous placez une seconde instance du widget sur votre écran d’accueil, il devrait afficher une heure différente de la première..
Vous pouvez mettre à jour l'une ou l'autre de ces instances de widget en donnant sa Appuyez sur pour mettre à jour Affichage un robinet. Si vous déclenchez une mise à jour manuelle pour le premier widget, le second ne sera pas mis à jour, et inversement..
En plus des mises à jour manuelles, le gestionnaire de widgets d'applications mettra à jour tout instances de votre widget une fois toutes les 30 minutes, en fonction du moment où vous avez créé la première instance. Bien que les mises à jour manuelles puissent avoir pour conséquence que les instances affichent des heures différentes, toutes les instances sont mises à jour simultanément toutes les demi-heures. Elles s'affichent ensuite à la même heure..
Vous souhaiterez peut-être conserver quelques instances de ce widget sur votre écran d'accueil afin de pouvoir surveiller l'évolution de leur contenu au fil du temps en réponse à une combinaison de mises à jour automatiques et manuelles..
Dans cette série, nous avons créé un widget d'application Android qui montre comment implémenter toutes les fonctionnalités les plus courantes des widgets d'application. Si vous suivez depuis le début, vous aurez alors créé un widget qui se mettra à jour automatiquement et en réponse aux entrées de l'utilisateur, et capable de réagir aux événements onClick (vous pouvez également télécharger le projet complet à partir de GitHub. ).
Dans le prochain article, nous examinerons certaines des meilleures pratiques pour vous assurer que votre widget fournit une bonne expérience utilisateur et comment améliorer votre widget avec une activité de configuration..
