L'UI thread

Date de publication : 7 avril 2010

Par Davy Leggieri (Page de Davy Leggieri)
 

Cet article présente l'UI thread et les principes de base pour interagir convenablement avec celui-ci.

12 commentaires

       Version PDF (Miroir)   Version hors-ligne (Miroir)

                    

I. Introduction

II. Le fonctionnement de l'UI thread

...
tant que ( vrai )
{
    si (il y a au moins une chose à faire) alors
	{
		faire la chose
		//Ex1: dessiner à l'écran
		//EX2: exécuter le code lié au bouton cliqué
	}
}
...

III. Le responsable de l'affichage et des interactions avec l'utilisateur

public class TestActivity extends Activity {
    ...
    public void onCreate(Bundle savedInstanceState) {
        //Code exécuté dans l'UI thread
        super.onCreate(savedInstanceState);
        ...
        //On lie une action au bouton
        unButton.setOnClickListener(new OnClickListener() {
            //Définition de l'action qui sera exécutée par l'UI thread lors d'un clic
            @Override
            public void onClick(View v) {
                //Le code s'exécutant dans l'UI Thread, nous pouvons donc modifier l'IHM sans craintes
                unTextView.setText("Nouveau text");
            }
        }
    }
    ...
}

• appel de onCreate(savedInstanceState) ;
• -- appel de super.onCreate(savedInstanceState) ;
• -- liaison d'une action au clic sur le bouton "unButton" ;
• appel de onStart() ;
• lors d'un clic sur le bouton "unButton", exécution l'action onClic(v) ;
• -- exécution de unTextView.setText("Nouveau text").

IV. Un thread à préserver

public class blockUIThread extends Activity {
    private Button mButtonBlock;
    ...
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        setContentView(R.layout.main);
        
        mButtonBlock = (Button) findViewById(R.id.ButtonBlock);
        mButtonBlock.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    //Stopper l'UI thread pendant 3 secondes
                    Thread.sleep(3000L);
                } catch (InterruptedException e) {}
            }
        });
    }
    ...
}

État du bouton avant le clic

État du bouton pendant le clic et durant 3 secondes

• ...
• (Clic sur le bouton "unButton")
• x ème passage dans la boucle infinie
• -- Est-ce qu'il y a au moins une chose à faire ?
• ---- Il y a le clic sur le bouton à traiter
• ------- Demander au bouton de se dessiner enfoncé
• -------- Exécuter le code lié au clic sur le bouton
• ---------- Pause du thread pendant 3 secondes
• -------- Demander au bouton de se dessiner relâché (état normal)
• x+1 ème passage dans la boucle infinie
• ...

V. Où mettre les instructions consommatrices en temps ?

Chaque thread possédant son propre fil d'exécution, nous allons avoir des instructions qui vont être exécutées en parallèle. Si vous désirez plus d'informations sur les threads Java, je vous invite à consulter le tutoriel suivant : "Programmation des Threads en Java".

public class TestActivity extends Activity {
    ...
    public void onCreate(Bundle savedInstanceState) {
        //Code executé dans le thread principal
        super.onCreate(savedInstanceState);
        ...
        //On lie une action au bouton
        unButton.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                //Création et exécution d'un nouveau thread
                new Thread(new Runnable() {
            		@Override
            		public void run() {
                		// Instructions consommatrices en temps
            		}
                }).start();
        }
    }
    ...
}

• appel de onCreate(savedInstanceState) ;
• -- appel de super.onCreate(savedInstanceState) ;
• -- liaison d'une action au clic sur le bouton unButton ;
• ...
• (clic sur le bouton "unButton") ;
• n-ième passage dans la boucle infinie ;
• -- est-ce qu'il y a au moins une chose à faire ? ;
• ---- il y a le clic sur le bouton à traiter ;
• ------- demander au bouton de se dessiner enfoncé ;
• -------- exécuter le code lié au clic sur le bouton ;
• ---------- création et exécution du nouveau thread ;
• -------- demander au bouton de se dessiner relâché (état normal) ;
• n-ième+1 passage dans la boucle infinie.
• ...

• Exécution de la méthode run() ;
• -- exécution de l'opération consommatrice en temps ;
• mort du thread.

VI. Ordonner des tâches à l'UI thread

VI-A. Ordonner depuis l'activity

public class TestActivity extends Activity {
    ...
    public void onCreate(Bundle savedInstanceState) {
        //Code executé dans le thread principal
        super.onCreate(savedInstanceState);
        ...
        //On lie une action au bouton
        unButton.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                //Création et exécution d'un nouveau thread
                new Thread(new Runnable() {
            		@Override
            		public void run() {
                    	//Opération consommatrice en temps
                    	//Appeler d'une méthode (pour améliorer la lisibilité du code)
                    	UpdateIHM(resultat);
			       } 	
                }).start();
        }
    }
    
    public void UpdateIHM(String resultat)
    {
    	//Déposer le Runnable dans la file d'attente de l'UI thread
    	runOnUiThread(new Runnable() {
           @Override
           public void run() {
           		//code exécuté par l'UI thread
            	mTextView.setText(resultat);
            }
        });
    }
    ...
}

• appel de onCreate(savedInstanceState) ;
• -- appel de super.onCreate(savedInstanceState) ;
• -- liaison d'une action au clic sur le bouton unButton ;
• ...
• (clic sur le bouton "unButton") ;
• n-ième passage dans la boucle infinie ;
• -- est-ce qu'il y a au moins une chose à faire ? ;
• ---- il y a le clic sur le bouton à traiter ;
• -------- exécuter le code lié au clic sur le bouton ;
• ---------- création et exécution du nouveau thread ;
• n-ième passage dans la boucle infinie.
• ...

• Exécution de la méthode run() ;
• -- exécution de UpdateIHM(resultat) ;
• ---- exécution de runOnUiThread(...) ;
• ------ déposer le Runnable dans la file d'attente de l'UI thread ;
• mort du thread.

• ...
• n-ième passage dans la boucle infinie ;
• -- est-ce qu'il y a au moins une chose à faire ? ;
• ---- il y a le Runnable à exécuter ;
• -------- exécuter "mTextView.setText(...)" ;
• n-ième+1 passage dans la boucle infinie.
• ...

VI-B. Ordonner depuis une view

Le recours à cette méthode pour ordonner des actions à l'UI thread est assez rare. En effet, les cas d'utilisations ne sont pas légende, et cela est principalement utilisé lorsque nous définissons nos classes de vue par héritage (création d'une boussole, création d'un textView ayant un comportement spécifique).

//Attention, nous ne sommes plus dans une Activity dans le cas présent
public class monButton extends Button {

	public monButton(Context context) {
		super(context);
		//code exécuté par l'UI thread
	}
	...
	public boolean onKeyDown(int keyCode, KeyEvent event){
		//Création du thread par l'UI thread
		new Thread(new Runnable() {		
			@Override
			public void run() {
				// Opération consommatrice en temps exécuté par le nouveau thread
				//appel de updateIHM par le nouveau thread
				updateIHM(resultat);
			}
		}).start();
		
		return super.onKeyDown(keyCode, event);	//Imposé par le SDK
	}
	
	private void updateIHM(String resultat){
		//Déposer un tunnable dans l'UI thread
		post(new Runnable() {		
			@Override
			public void run() {
				//Code exécuté dans l'UI thread
				setText(resultat);			
			}
		});
	}
	...
}

Vous pouvez aussi utiliser la méthode postDelay(runnable,time) qui permet de déposer un Runnable dans la file d'attente de l'UI thread avec un certain retard.

• Instanciation du bouton ;
• ...
• (pression d'une touche par l'utilisateur lorsque le focus est sur le bouton) ;
• n-ième passage dans la boucle infinie ;
• -- est-ce qu'il y a au moins une chose à faire ? ;
• ---- il y a la touche pressée à traiter ;
• ------ appel de la méthode 'onKeyDown()' ;
• -------- création et exécution du nouveau thread ;
• n-ième+1 passage dans la boucle infinie.
• ...

• Exécution de la méthode run() ;
• -- exécution de UpdateIHM(resultat) ;
• ---- exécution de post(...) ;
• ------ déposer le Runnable dans la file d'attente de l'UI thread ;
• mort du thread.

• ...
• n-ième passage dans la boucle infinie ;
• -- est-ce qu'il y a au moins une chose à faire ? ;
• ---- il y a le Runnable à exécuter ;
• -------- exécuter "mTextView.setText(...)" ;
• n-ième+1 passage dans la boucle infinie.
• ...

VI-C. Ordonner grâce à un handler

Les handlers sont des files d'attente, ou encore ce que nous appelons jusqu'à présent boucle infinie (cf. boucle infinie dans l'algorithme de l'UI thread).

VI-D. Ordonner grâce à une AsyncTask

private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
	//Action de la tâche asynchrone
     protected Long doInBackground(URL... urls) {
     	//Code exécuté dans un nouveau thread
         int count = urls.length;
         long totalSize = 0;
         for (int i = 0; i < count; i++) {
             totalSize += Downloader.downloadFile(urls[i]);
             publishProgress((int) ((i / (float) count) * 100));
         }
         return totalSize;
     }

	//Définition optionnelle
	//Permet d'avertir l'utilisateur de la progression
     protected void onProgressUpdate(Integer... progress) {
     	//Code exécuté dans l'UI thread pour chaque appel à publishProgress(...)
         setProgressPercent(progress[0]);
     }

	//Définition optionnelle
	//Permet d'avertir l'utilisateur de la fin de la tâche asynchrone
     protected void onPostExecute(Long result) {
     	//Code exécuté dans l'UI thread
         showDialog("Downloaded " + result + " bytes");
     }
 }

new DownloadFilesTask().execute(url1, url2, url3);

• ...
• Exécution de "new DownloadFilesTask().execute(...)" ;
• -- création d'un nouveau thread ;
• n-ième passage dans la boucle infinie.
• ...

• Exécution de la méthode "doInBackground()" ;
• -- 1re exécution de "Downloader.downloadFile(..)" ;
• -- 1er appel de la méthode "publishProgress()".
• ...

• ...
• n-ième passage dans la boucle infinie ;
• -- est-ce qu'il y a au moins une chose à faire ? ;
• ---- il y a un Runnable à exécuter ;
• -------- exécuter "onProgressUpdate(...)" ;
• n-ième+1 passage dans la boucle infinie.
• ...

• -- 2e exécution de "Downloader.downloadFile(..)" ;
• -- 2e appel de la méthode "publishProgress()" ;
• ...
• -- ainsi de suite jusqu'à ce que l'opération effectuée par la tâche soit totalement terminée et qu'elle retourne "totalSize" ;
• mort du thread.

• ...
• n ème passage dans la boucle infinie
• -- Est-ce qu'il y a au moins une chose à faire ?
• ---- Il y a un Runnable à exécuter
• -------- Exécuter "onPostExecute(...)"
• n+1 ème passage dans la boucle infinie
• ...

VII. Conclusion

VIII. Remerciements