Arrêter un thread avec le bouton retour

[Profete162]

Salut la compagnie!

Dans mon appli, j'ai de longs thread avec un petit écran et une progressBar.

Il se peut que pour X raisons ( connection en Edge, mobile plus ancien, etc..) ces calculs prennent beaucoup de temps et j'aimerais donc permettre à l'utilisateur de quitter le thread avec la touche retour.

Apres maintes et moult recherches, la solution que j'ai trouvé est donc le thread.interrupt();

que j'ai implémenté de cette manière

    @Override
   public boolean onKeyDown(int keyCode, KeyEvent event) {
       if ((keyCode == KeyEvent.KEYCODE_BACK)) {
           Log.d(TAG,"back button pressed");
           if(thread!=null)
               thread.interrupt();
           else
               finish();
           thread=null;
       }
       return super.onKeyDown(keyCode, event);
   }

Malheureusement, il semble que le bouton back ne réagisse pas du tout pendant le thread et je deviens fou!

Merci pour vos pistes, car je suppose que vous êtes nombreux à utiliser cette technique.

PS: pour info, dans mon thread, j'affiche l'état:

        for (int i = 0; i < beaucoup; i++) {
                      mProgressDialog.incrementProgressBy(1);
           Log.d(TAG,"thread is: "+thread.getState());
           Log.d(TAG,"interrupted is: "+thread.isInterrupted());
       }

et je vois bien qu'il est Runnable et isInterrupted est toujours false.

[acesyde]

Je te mets rapidement un code à disposition que je viens de faire et ça fonctionne

public class MonActivite extends Activity {

   private Thread thread;

   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.main);

       final Button button = (Button) findViewById(R.id.go);

       button.setOnClickListener(new OnClickListener() {

           @Override
           public void onClick(View v) {
               thread = new Thread(new Runnable() {

                   @Override
                   public void run() {
                       Log.i("thread", "Debut de boucle");
                       for(int i=0;i<10;i++) {

                           if(thread.isInterrupted())
                               return;

                           try {
                               Log.i("thread", "N°"+i);
                               Thread.sleep(500);
                           } catch (InterruptedException e) {
                               Thread.currentThread().interrupt();
                           }
                       }
                       Log.i("thread", "fin de boucle");
                   }

               });

               thread.start();
           }
       });

   }

   @Override
   public boolean onKeyDown(int keyCode, KeyEvent event) {

       if(keyCode == KeyEvent.KEYCODE_BACK) {

           if(thread != null && thread.isAlive()) {
               thread.interrupt();
               Log.i("thread", "termine");
           }

       }

       return super.onKeyDown(keyCode, event);
   }
}

[Profete162]

Et bien merci pour ta réponse.

Comme tu peux le voir dans mon code, dans la grosse boucle du thread, j'ai mis: Log.d(TAG,"interrupted is: "+thread.isInterrupted());

et il m'affiche false en permanence.

On dirait donc que pendant le thread il ne regarde pas le onKeyDown

Je comprends vraiment pas ce qui se passe. Nos codes sont sensiblement pareils.

[acesyde]

En faite à ce que j'ai compris, lorsque un thread est attaqué par Interrupt il se met en interrupt pendant un cour instant mais repart aussitôt si il était déjà au travail. Ce qui est relativement bizarre :rolleyes:

Tu pourrais jouer sur un classe héritant de Thread implémentant un runnable, puis faire en sorte qu'il y est un boolean qui dicte la loi à ton Thread, si tu décrètes de le stopper tu passes à false et il ne travail plus et s'arrête.

Les Threads sont ambiguës par moment.

Autre solution : Un asynctask ?

[Profete162]

Je pense que je vais effectivementtenter un asyncTask:

    @Override
   public boolean onKeyDown(int keyCode, KeyEvent event) {
       stop=true;
       return super.onKeyDown(keyCode, event);
   }

et afficher stop dans le thread m'affiche toujours un false!

Incomprehensible, il ne prend pas le onKeyDown!!!

[acesyde]

quand tu fais un Log.i("test","test"); dans le onkeydown il s'affiche ?

[Profete162]

Non, justement, c'est ce que je dis depuis le début.

C'est ca le gros bordel.

Mais bon, le plan B est en train d'être mis en place:

    class myProgressDialog extends ProgressDialog {
       public myProgressDialog(Context context) {
           super(context);
           // TODO Auto-generated constructor stub
       }

       @Override
       public void onBackPressed() {
           super.onBackPressed();
           Log.v(TAG, "backpressed: interrupt thread");
           thread.interrupt();
           return;
       }
   }

et semble fonctionner!

Le petit couac, c'est que ca semble venir de l'API 2.0 et j'ai peur de tout faire exploser sur un Android 1.5 ou 1.6

[azalsup]

je pense que l'execution de ton thread occupre 100% de ta puissanec cpu

il inserer a l'interieur de ta boocle cette ligne : Thread.Sleep(1000)

ca permet d'interompre ton thread pendant 1000ms (prendre une plus grosse valeur si ce n'est pas assez)

ainsi tu temporise ton thread et tu laisse de la puissance cpu pour d'autre applications et au systeme.

[Profete162]

Bon, bien tout fonctionne avec le onBackPressed!

Par contre que dalle sur le onKeyDown.

J'ai trouvé la solution, mais impossible de comprendre pourquoi.

Enin, le principal est que cela fonctionne et tant mieux si cela peut servir à d'autres.

[acesyde]

onBackPressed ne fonctionne pas sous 1.6 ça te limite à la plateforme ;)

[Profete162]

Oui, j'ai vu, c'est déjà mieux que rien...