Java pour Android : tâches exécutables et minuteurs

Name: Java pour Android : tâches exécutables et minuteurs
Author: Shad Sluiter

Apprenez les fonctionnalités mobiles avec ce cours de programmation Java intermédiaire pour Android.

Preview the first lesson free — get full access to all 6 lessons.

Cours : à la demande

Bonjour, dans cette vidéo, nous allons parler de comment démarrer une tâche en arrière-plan dans votre application Android. Désormais, en Java, une tâche exécutable est une unité de travail. Et ainsi nous pouvons attribuer des choses comme le niveau de priorité de l'emploi, et nous pouvons également le définir pour être retardé afin qu'il puisse être exécuté à l'avenir. Nous lui donnons donc un horodatage. Alors voilà à quoi ça ressemble lorsque vous créez une tâche exécutable en Java. Tu dis, exécutable, donne-lui un nom, puis en faire une nouvelle classe exécutable. Il contient une méthode appelée run. Et donc le but d'une tâche exécutable est afin que vous puissiez le diviser en différents fils. Maintenant, un fil est un processus ou un chemin qu'un processus passe. Et donc le fil principal est généralement ce sur quoi nous programmons, parce que nous pensons à un programme séquentiel. Jetons donc un coup d'œil à un code de la façon dont cela pourrait être fait. Donc ce que j'ai devant ici c'est un exemple d'écouteur de clic pour un bouton. Et nous en avons donc un clic. Maintenant, ce que nous avons à l'intérieur est un peu différent. J'ai créé un nouveau fil, et à l'intérieur de ce fil, J'ai créé ce qu'on appelle une unité de travail. Nous allons donc voir cela dans une seconde. C'est vraiment un processus exécutable. Et puis nous disons au fil de commencer. Alors ce que cela fera, c'est qu'il dira, ne touche pas au fil principal où nous écoutons les clics de souris. Commençons un autre fil. Cela a probablement une priorité inférieure, et nous laisserons le processus s'exécuter là-bas. Donc, vous voudrez peut-être dire, téléchargeons un fichier ou interrogeons une base de données ou dessinons quelque chose ou rendons une image. Et donc le processus va probablement prendre un certain temps. La plupart du temps, nous n'avons pas à nous soucier du temps que prend quelque chose parce que les processus sont presque instantanés. Mais dans ce cas, prétendre que nous avons quelque chose de très lent. Regardons le code suivant. Voici donc à quoi ressemble l'unité de travail. C'est le processus exécutable. Donc le processus exécutable va avoir une seule méthode appelée run. Et puis dans mon cas, on va coder ici, c'est que je vais simuler quelque chose cela prend cinq secondes. Et donc j'ai juste la déclaration de retard ici, ou la déclaration de sommeil qui dit, quoi que tu fasses, arrête, et n'allez pas plus loin pendant 5 000 millisecondes. Maintenant, quand nous arrivons à cette fin, Je veux faire apparaître quelque chose à l'écran. Je veux qu'il porte un toast. Et pour porter un toast, vous devez pouvoir l'exécuter sur le thread principal. Et donc nous devons créer un autre processus exécutable à l'intérieur de cet exécutable. Donc, ce runnable a une commande spéciale, c'est unique à Android, il dit exécuter sur le fil d'interface utilisateur. Cela signifie donc aller au fil principal qui gérait tous les clics sur les boutons, puis effectuez ce processus. Et vous pouvez voir qu'un toast est quelque chose c'est l'interface utilisateur. S'il s'agissait d'autre chose, comme imprimer dans un fichier journal ou simplement calculer une réponse et la renvoyer, alors tu n'aurais pas à t'inquiéter s'exécutant sur le thread de l'interface utilisateur. Mais si vous devez mettre à jour un champ de texte ou changer la couleur d'un bouton ou, dans ce cas, portez un toast, vous touchez le fil de l'interface utilisateur. Et c'est pourquoi nous lui disons sur quel thread s'exécuter. Et donc cette unité de travail serait ce que nous mettrions dans le clic sur le bouton. Maintenant, il y a une autre façon de gérer cela. Au lieu d'utiliser run on UI thread, la plupart des programmeurs l'utiliseraient. Ils appelleraient un gestionnaire. Alors rappelez-vous, le gestionnaire est comme le bras du robot qui prend la tâche et la met sur la bande transporteuse. Alors le gestionnaire dit, Je vais créer une nouvelle instance de l'objet gestionnaire, et je vais préciser que cela vient du Looper principal. Et puis à l'intérieur ici, vous pouvez me dire que je vais poster un nouvel objet exécutable sur la boucle principale. Et donc poster un nouvel article. Et c'est comme l'insérer dans la bande transporteuse dans le sol de l'usine. Et quand vous POSTEZ, vous pouvez supposer que cela va être traité immédiatement. Mais il existe d'autres commandes, telles que POST avec un délai. Et ainsi vous pouvez configurer une minuterie pour dire, le faire en cinq secondes, puis il attendra avant que cela ne soit réellement exécuté. Voici donc quelques exemples de la façon dont vous créez des tâches exécutables et comment vous les POSTEZ et comment vous protégez votre boucle principale, votre interface utilisateur, afin qu'elle ne se bloque pas. Nous allons donc coder une partie de cela, et nous verrons un exemple de la façon dont cela fonctionne.

Intermédiaire Fournisseur : Shad Sluiter 6 leçons · 20m en Arabe, Allemand, Anglais, Espagnol, Français, Portugais, Chinese

Description du cours

Dans cette section, vous allez créer une application qui illustre l’utilisation des tâches en arrière-plan. Dans un environnement multitâches, les tâches, ou threads, partagent des ressources, y compris l’accès au processeur et à la mémoire. Dans Android, le thread de l’interface utilisateur est responsable de l’écoute des événements de clics. Il est important de ne pas mettre une tâche à long terme sur ce thread qui le gèlera pendant plus de quelques millisecondes. Pour répondre à cette exigence, Java fournit un processus exécutable et une classe Handler pour effectuer des opérations lentes en arrière-plan. Cette application montrera d’abord comment ne pas programmer un processus lent, puis comment créer une tâche exécutable.

Objectifs de la formation

Ce que vous allez apprendre

Créer une application Android qui démontre l'utilisation de tâches en arrière-plan
Démontrer les dangers de l'exécution d'une tâche gourmande en CPU sur le thread de l'interface utilisateur
Créer un processus exécutable pour exécuter le travail en arrière-plan
Créer une instance de la classe Handler pour planifier l'exécution de tâches sur le thread de l'interface utilisateur
Configurer une interface utilisateur et un écouteur de clic pour lancer une tâche en arrière-plan
Créer un projet dans Android Studio pour créer l'application de tâche en arrière-plan

Points clés à retenir

Dans un environnement multitâche, les tâches (threads) partagent des ressources, notamment l'accès au processeur et à la mémoire.
Dans Android, le thread d'interface utilisateur est chargé d'écouter les événements de clic.
Les tâches à long terme ne doivent pas être placées sur le thread de l'interface utilisateur, car cela peut le figer pendant plus de quelques millisecondes.
Java fournit un processus Runnable et une classe Handler pour effectuer des opérations lentes en arrière-plan.
L'application démontre d'abord comment ne pas programmer un processus lent, puis comment créer une tâche exécutable.

Foire aux questions

Que vais-je construire dans ce cours ?

Vous créerez une application Android qui démontre l'utilisation de tâches d'arrière-plan, en montrant d'abord comment ne pas programmer un processus lent, puis comment créer une tâche exécutable.

Pourquoi les tâches à exécution longue ne doivent-elles pas s'exécuter sur le thread d'interface utilisateur ?

Dans Android, le thread d'interface utilisateur est chargé d'écouter les événements de clic, et y placer une tâche à long terme peut figer le thread pendant plus de quelques millisecondes. Le cours démontre donc les dangers de l'exécution d'une tâche gourmande en CPU sur le thread de l'interface utilisateur.

Quelles fonctionnalités Java ce cours utilise-t-il pour gérer le travail en arrière-plan ?

Il utilise le processus Runnable de Java pour exécuter des opérations lentes en arrière-plan et la classe Handler pour planifier des tâches à exécuter sur le thread de l'interface utilisateur.

Quelles compétences vais-je acquérir grâce à ce cours ?

Vous acquerrez des compétences dans les applications Android, le développement Android, l'interface utilisateur Android, AsyncTask, les tâches en arrière-plan et le multithreading.

Quels sujets les leçons couvrent-elles ?

Les leçons couvrent les threads d'arrière-plan, la configuration de l'interface utilisateur pour une tâche d'arrière-plan, la définition d'un écouteur de clic pour lancer une tâche d'arrière-plan, la création d'un projet dans Android Studio, la création d'un thread d'arrière-plan et la création d'un gestionnaire pour démarrer un thread d'arrière-plan.