Comment mettre en pause / dormir le fil ou le processus dans Android?

Je veux faire une pause entre deux lignes de code, laissez-moi vous expliquer un peu:

-> l'utilisateur clique sur un bouton (une carte en fait) et je le montre en changeant l'arrière-plan de ce bouton:

thisbutton.setBackgroundResource(R.drawable.icon);

-> après disons 1 seconde, je dois revenir à l'état précédent du bouton en modifiant son arrière-plan:

thisbutton.setBackgroundResource(R.drawable.defaultcard);

-> J'ai essayé de suspendre le thread entre ces deux lignes de code avec:

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

Cependant, cela ne fonctionne pas. C'est peut-être le processus et non le fil que je dois interrompre?

J'ai aussi essayé (mais ça ne marche pas):

new Reminder(5);

Avec ça:

public class Reminder {

Timer timer;

        public Reminder(int seconds) {
            timer = new Timer();
            timer.schedule(new RemindTask(), seconds*1000);
        }

        class RemindTask extends TimerTask {
            public void run() {
                System.out.format("Time's up!%n");
                timer.cancel(); //Terminate the timer thread
            }
        }  
    }

Comment puis-je suspendre / dormir le fil ou le processus?

Une solution à ce problème consiste à utiliser la méthode Handler.postDelayed () . Certains supports de formation Google suggèrent la même solution.

@Override
public void onClick(View v) {
    my_button.setBackgroundResource(R.drawable.icon);

    Handler handler = new Handler(); 
    handler.postDelayed(new Runnable() {
         @Override 
         public void run() { 
              my_button.setBackgroundResource(R.drawable.defaultcard); 
         } 
    }, 2000); 
}

Cependant, certains ont souligné que la solution ci-dessus provoque une fuite de mémoire car elle utilise une classe interne et anonyme non statique qui contient implicitement une référence à sa classe externe, l'activité. Il s'agit d'un problème lorsque le contexte d'activité est récupéré.

Une solution plus complexe qui évite la fuite de mémoire sous-classe les Handleret Runnableavec les classes internes statiques à l'intérieur de l'activité car les classes internes statiques ne contiennent pas de référence implicite à leur classe externe:

private static class MyHandler extends Handler {}
private final MyHandler mHandler = new MyHandler();

public static class MyRunnable implements Runnable {
    private final WeakReference<Activity> mActivity;

    public MyRunnable(Activity activity) {
        mActivity = new WeakReference<>(activity);
    }

    @Override
    public void run() {
        Activity activity = mActivity.get();
        if (activity != null) {
            Button btn = (Button) activity.findViewById(R.id.button);
            btn.setBackgroundResource(R.drawable.defaultcard);
        }
    }
}

private MyRunnable mRunnable = new MyRunnable(this);

public void onClick(View view) {
    my_button.setBackgroundResource(R.drawable.icon);

    // Execute the Runnable in 2 seconds
    mHandler.postDelayed(mRunnable, 2000);
}

Notez que le Runnableutilise une WeakReference à l'activité, qui est nécessaire dans une classe statique qui a besoin d'accéder à l'interface utilisateur.

Vous pouvez essayer celui-ci il est court

SystemClock.sleep(7000);

AVERTISSEMENT : ne faites jamais cela sur un thread d'interface utilisateur.

Utilisez-le pour dormir, par exemple. fil de fond.

La solution complète pour votre problème sera: Ceci est disponible API 1

findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(final View button) {
                button.setBackgroundResource(R.drawable.avatar_dead);
                final long changeTime = 1000L;
                button.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        button.setBackgroundResource(R.drawable.avatar_small);
                    }
                }, changeTime);
            }
        });

Sans créer de gestionnaire tmp. Cette solution est également meilleure que @tronman car nous ne conservons pas la vue par le gestionnaire. Nous n'avons pas non plus de problème avec le gestionnaire créé sur un mauvais thread;)

Documentation

sommeil public vide statique (long ms)

Ajouté au niveau 1 de l'API

Attend un nombre donné de millisecondes (de uptimeMillis) avant de revenir. Similaire au sommeil (long), mais ne lève pas InterruptedException ; Les événements interrupt () sont différés jusqu'à la prochaine opération interruptible. Ne revient pas tant qu'au moins le nombre de millisecondes spécifié ne s'est pas écoulé.

Paramètres

ms pour dormir avant de revenir, en millisecondes de disponibilité.

Code pour la classe postDelayed from View:

/**
 * <p>Causes the Runnable to be added to the message queue, to be run
 * after the specified amount of time elapses.
 * The runnable will be run on the user interface thread.</p>
 *
 * @param action The Runnable that will be executed.
 * @param delayMillis The delay (in milliseconds) until the Runnable
 *        will be executed.
 *
 * @return true if the Runnable was successfully placed in to the
 *         message queue.  Returns false on failure, usually because the
 *         looper processing the message queue is exiting.  Note that a
 *         result of true does not mean the Runnable will be processed --
 *         if the looper is quit before the delivery time of the message
 *         occurs then the message will be dropped.
 *
 * @see #post
 * @see #removeCallbacks
 */
public boolean postDelayed(Runnable action, long delayMillis) {
    final AttachInfo attachInfo = mAttachInfo;
    if (attachInfo != null) {
        return attachInfo.mHandler.postDelayed(action, delayMillis);
    }
    // Assume that post will succeed later
    ViewRootImpl.getRunQueue().postDelayed(action, delayMillis);
    return true;
}

J'utilise ceci:

Thread closeActivity = new Thread(new Runnable() {
  @Override
  public void run() {
    try {
      Thread.sleep(3000);
      // Do some stuff
    } catch (Exception e) {
      e.getLocalizedMessage();
    }
  }
});

Vous ne voulez probablement pas le faire de cette façon. En mettant un explicite sleep()dans votre gestionnaire d'événements cliqué sur un bouton, vous verrouillez réellement l'interface utilisateur entière pendant une seconde. Une alternative consiste à utiliser une sorte de minuterie à un coup . Créez une TimerTask pour redonner à la couleur d'arrière-plan la couleur par défaut et planifiez-la sur la minuterie.

Une autre possibilité consiste à utiliser un gestionnaire . Il y a un tutoriel sur quelqu'un qui est passé de l'utilisation d'une minuterie à l'utilisation d'un gestionnaire.

Soit dit en passant, vous ne pouvez pas suspendre un processus. Un processus Java (ou Android) a au moins 1 thread et vous ne pouvez mettre en veille que les threads.

J'utilise CountDownTime

new CountDownTimer(5000, 1000) {

    @Override
    public void onTick(long millisUntilFinished) {
        // do something after 1s
    }

    @Override
    public void onFinish() {
        // do something end times 5s
    }

}.start(); 

C'est ce que j'ai fait à la fin de la journée - fonctionne bien maintenant:

@Override
    public void onClick(View v) {
        my_button.setBackgroundResource(R.drawable.icon);
        // SLEEP 2 SECONDS HERE ...
        final Handler handler = new Handler(); 
        Timer t = new Timer(); 
        t.schedule(new TimerTask() { 
                public void run() { 
                        handler.post(new Runnable() { 
                                public void run() { 
                                 my_button.setBackgroundResource(R.drawable.defaultcard); 
                                } 
                        }); 
                } 
        }, 2000); 
    }

En plus des réponses de M. Yankowsky, vous pouvez également utiliser postDelayed(). Celui-ci est disponible sur tout View(par exemple, votre carte) et prend un Runnableet un délai Il exécute Runnableaprès ce délai.

Ceci est mon exemple

Créer un Java Utils

    import android.app.ProgressDialog;
    import android.content.Context;
    import android.content.Intent;

    public class Utils {

        public static void showDummyWaitingDialog(final Context context, final Intent startingIntent) {
            // ...
            final ProgressDialog progressDialog = ProgressDialog.show(context, "Please wait...", "Loading data ...", true);

            new Thread() {
                public void run() {
                    try{
                        // Do some work here
                        sleep(5000);
                    } catch (Exception e) {
                    }
                    // start next intent
                    new Thread() {
                        public void run() {
                        // Dismiss the Dialog 
                        progressDialog.dismiss();
                        // start selected activity
                        if ( startingIntent != null) context.startActivity(startingIntent);
                        }
                    }.start();
                }
            }.start();  

        }

    }    

Ou vous pouvez utiliser:

android.os.SystemClock.sleep(checkEvery)

ce qui a l'avantage de ne pas nécessiter d'emballage try ... catch.

Si vous utilisez Kotlin et coroutines , vous pouvez simplement faire

GlobalScope.launch {
   delay(3000) // In ms
   //Code after sleep
}

Et si vous devez mettre à jour l'interface utilisateur

GlobalScope.launch {
  delay(3000)
  GlobalScope.launch(Dispatchers.Main) {
    //Action on UI thread
  }
}

Je sais que c'est un vieux fil, mais dans la documentation Android j'ai trouvé une solution qui fonctionnait très bien pour moi ...

new CountDownTimer(30000, 1000) {

    public void onTick(long millisUntilFinished) {
        mTextField.setText("seconds remaining: " + millisUntilFinished / 1000);
    }

    public void onFinish() {
        mTextField.setText("done!");
    }
}.start();

https://developer.android.com/reference/android/os/CountDownTimer.html

J'espère que cela aide quelqu'un ...

  class MyActivity{
    private final Handler handler = new Handler();
    private Runnable yourRunnable;
    protected void onCreate(@Nullable Bundle savedInstanceState) {
       // ....
       this.yourRunnable = new Runnable() {
               @Override
               public void run() {
                   //code
               }
            };

        this.handler.postDelayed(this.yourRunnable, 2000);
       }


     @Override
  protected void onDestroy() {
      // to avoid memory leaks
      this.handler.removeCallbacks(this.yourRunnable);
      }
    }

Et pour être sûr que vous pouvez le combiner avec la méthode de la "classe statique" comme décrit dans la réponse tronman