Comment faire pour exécuter une tâche asynchrone pour chaque x minutes dans android?

Vous pouvez utiliser le gestionnaire si vous voulez commencer quelque chose de toutes les X secondes. Gestionnaire est bon parce que vous n'avez pas besoin de fil supplémentaire pour en garder une trace lors du déclenchement de l'événement. Voici un court extrait:

private final static int INTERVAL = 1000 * 60 * 2; //2 minutes
Handler mHandler = new Handler();

Runnable mHandlerTask = new Runnable()
{
     @Override 
     public void run() {
          doSomething();
          mHandler.postDelayed(mHandlerTask, INTERVAL);
     }
};

void startRepeatingTask()
{
    mHandlerTask.run(); 
}

void stopRepeatingTask()
{
    mHandler.removeCallbacks(mHandlerTask);
}

Noter que doSomething ne devrait pas prendre longtemps (quelque chose comme la mise à jour de la position de lecture audio dans l'INTERFACE utilisateur). Si elle peut éventuellement prendre un certain temps (comme le téléchargement ou le téléchargement sur le web), alors vous devriez utiliser ScheduledExecutorService's scheduleWithFixedDelay fonction de la place.

vous pouvez utiliser TimerTask au lieu de AsyncTask.

ex:

Timer myTimer = new Timer("MyTimer", true);
myTimer.scheduleAtFixedRate(new MyTask(), ASAP, TWO_MINUTES);


private class MyTask extends TimerTask {

    public void run(){
      readWebPage();
    }

}

Je suggère d'aller avec Handler#postDelayed(Runnable). Gardez à l'esprit que cette méthode ne fonctionne que lorsque votre application est en cours d'exécution (peut-être en arrière-plan), mais si l'utilisateur ferme manuellement ou simplement Android est à court de mémoire, il va arrêter de travailler et de ne pas être redémarré à nouveau plus tard - pour cela, vous devez utiliser les services.

final Handler handler = new Handler();
handler.postDelayed(new Runnable() {
    @Override
    public void run() {
        handler.postDelayed(this, 2 * 60 * 1000); //every 2 minutes
        /* your code here */
    }
}, 2 * 60 * 1000); //first run after 2 minutes

Ce code va attendre 2 minutes, pour exécuter votre code, puis continuer à le faire toutes les 2 minutes. Mais si vous voulez qu'il fonctionne instantanément pour la première fois - et puis démarrer l'attente en boucle, au lieu d'utilisation:

final Handler handler = new Handler();
 /* your code here */
new Runnable() {
    @Override
    public void run() {
        handler.postDelayed(this, 2 * 60 * 1000); //every 2 minutes
         /* and also here - your code */
    }
}.run(); 

ou, si votre code est plus que juste une méthode (readWebsite() dans ce cas), et vous ne voulez pas que d'être dupliqué:

final Handler handler = new Handler();
handler.postDelayed(new Runnable() {
    @Override
    public void run() {
        handler.postDelayed(this, 2 * 60 * 1000); //every 2 minutes
         /* your longer code here */
    }
}, 0); //first run instantly

(^ c'est exactement comme le premier exemple mais a un 0ms délai avant la première exécution au lieu de 2 minutes)

(Cette réponse est fondée sur @Devashish Mamgain est un, mais j'ai ajouté trop de détails pour un montage donc j'ai dû ajouter un nouveau)

Exécuter plusieurs messages(Runnables) puis il faut utiliser la fonction Looper classe qui est responsable de la création d'une file d'attente dans le fil. Par exemple, lors de l'écriture d'une application qui télécharge des fichiers à partir d'internet, nous pouvons utiliser de l'Arpenteuse de la classe pour mettre des fichiers en téléchargement dans la file d'attente. Cela vous aidera à effectuer la tâche asynchrone dans android...

HandlerThread hThread = new HandlerThread("HandlerThread");
  hThread.start();
  Handler handler = new Handler(hThread.getLooper());
  final Handler handler1 = new Handler(hThread.getLooper());
  final long oneMinuteMs = 60 * 1000;

  Runnable eachMinute = new Runnable() { 
   @Override
   public void run() {
    Log.d(TAG, "Each minute task executing");
    handler1.postDelayed(this, oneMinuteMs);
    sendPostRequest();
   }
  };
 //sendPostRequest();
  //Schedule the first execution
  handler1.postDelayed(eachMinute, oneMinuteMs);

Vous pouvez exécuter une boucle dans le AsyncTask qui dort pendant deux secondes entre les tâches. Quelque chose comme ceci:

protected Result doInBackground (Params... params) {
    while (!interrupted) {
        doWork();
        Thread.sleep(2000);
    }
}