Introduction à cette section

Dans les deux sections précédentes, nous avons étudié les deux mécanismes de gestion d'événements dans Android, et ce sont les deux seuls types de réponses aux événements. Cette section explique Handler, qui est utilisé pour la transmission de messages entre les composants d'interface dans une Activity. Beaucoup de personnes savent peut-être qu'Android, pour la sécurité des threads, ne nous permet pas d'opérer l'interface en dehors du thread UI. Souvent, lorsque nous devons rafraîchir l'interface, nous devons notifier les composants d'interface de se mettre à jour via Handler ! En plus d'utiliser Handler pour les mises à jour d'interface, nous pouvons aussi utiliser runOnUiThread() pour mettre à jour, ou même des bus d'événements plus avancés. Bien sûr, ici nous ne couvrons que Handler : ce qu'est Handler, son flux d'exécution, les méthodes associées, et la différence entre l'utilisation de Handler dans un thread enfant et dans le thread principal !


1. Feuille de route d'apprentissage :


2. Présentation de la classe Handler :


3. Organigramme d'exécution de Handler :

Analyse de l'organigramme : Termes associés

  • Thread UI: Il s'agit de notre thread principal. Lorsque le système crée le thread UI, il initialise un objet Looper et crée également une MessageQueue qui lui est associée.
  • Handler: Sa fonction est d'envoyer et de traiter des messages. Si vous voulez que le Handler fonctionne normalement, il doit y avoir un objet Looper dans le thread actuel.
  • Message: L'objet message que Handler reçoit et traite.
  • MessageQueue: Une file de messages qui gère les Message dans l'ordre FIFO. Lors de l'initialisation d'un objet Looper, une MessageQueue qui lui est associée est créée.
  • Looper: Chaque thread ne peut avoir qu'un seul Looper, qui gère la MessageQueue, en extrait continuellement les Message et les distribue au Handler correspondant pour traitement !

En termes simples :

Lorsque notre thread enfant souhaite modifier des composants UI dans une Activity, nous pouvons créer un nouvel objet Handler et envoyer un message au thread principal via cet objet. Le message que nous envoyons va d'abord attendre dans la MessageQueue du thread principal ; Looper le récupère dans l'ordre FIFO, puis le distribue au Handler correspondant pour traitement en fonction de l'attribut `what` de l'objet message.


4. Méthodes associées de Handler :

  • void handleMessage(Message msg) : La méthode de traitement des messages, généralement destinée à être redéfinie !
  • sendEmptyMessage(int what) : Envoyer un message vide
  • sendEmptyMessageDelayed(int what, long delayMillis) : Envoyer un message vide après un délai spécifié en millisecondes
  • sendMessage(Message msg) : Envoyer un message immédiatement
  • sendMessageDelayed(Message msg) : Envoyer un message après un délai spécifié en millisecondes
  • final boolean hasMessage(int what) : Vérifie si la file de messages contient un message dont l'attribut `what` est la valeur spécifiée. Si le paramètre est (int what, Object object) : en plus de vérifier l'attribut `what`, vérifie également si l'attribut Object correspond à l'objet spécifié.

5. Exemples d'utilisation de Handler :

1) Handler écrit dans le thread principal

Dans le thread principal, comme le système a déjà initialisé un objet Looper, nous pouvons directement créer un objet Handler et ensuite envoyer et traiter des messages !

Exemple de code :Un programme simple qui change périodiquement d'images. Il utilise un Timer pour modifier périodiquement le contenu affiché par l'ImageView, créant ainsi une animation image par image.

Effet d'exécution :

Code d'implémentation :

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    xmlns:tools="http://schemas.android.com/tools"  
    android:id="@+id/RelativeLayout1"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    android:gravity="center"  
    tools:context="com.jay.example.handlerdemo1.MainActivity" >  
  
    <ImageView  
        android:id="@+id/imgchange"  
        android:layout_width="wrap_content"  
        android:layout_height="wrap_content"  
        android:layout_alignParentLeft="true"  
        android:layout_alignParentTop="true" />  
  
</RelativeLayout> 

MainActivity.java :

public class MainActivity extends Activity {  
  
    //定义切换的图片的数组id  
    int imgids[] = new int[]{  
        R.drawable.s_1, R.drawable.s_2,R.drawable.s_3,  
        R.drawable.s_4,R.drawable.s_5,R.drawable.s_6,  
        R.drawable.s_7,R.drawable.s_8  
    };  
    int imgstart = 0;  
      
    final Handler myHandler = new Handler()  
    {  
      @Override  
      //重写handleMessage方法,根据msg中what的值判断是否执行后续操作  
      public void handleMessage(Message msg) {  
        if(msg.what == 0x123)  
           {  
            imgchange.setImageResource(imgids[imgstart++ % 8]);  
           }  
        }  
    };  
    
      
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        final ImageView imgchange = (ImageView) findViewById(R.id.imgchange);  
         
        //使用定时器,每隔200毫秒让handler发送一个空信息  
        new Timer().schedule(new TimerTask() {            
            @Override  
            public void run() {  
                myHandler.sendEmptyMessage(0x123);  
                  
            }  
        }, 0,200);  
    }  
  
} 

2) Handler écrit dans un thread enfant

Si le Handler est écrit dans un thread enfant, nous devons créer nous-mêmes un objet Looper ! Le processus de création est le suivant :

1 )Appelez directement la méthode Looper.prepare() pour créer un objet Looper pour le thread actuel, et son constructeur créera une MessageQueue correspondante.2 )Créez un objet Handler et redéfinissez la méthode handleMessage() pour traiter les messages provenant d'autres threads.3 )Appelez la méthode Looper.loop() pour démarrer le Looper.

Exemple d'utilisation : Saisissez un nombre, calculez, et affichez tous les nombres premiers dans cette plage via Toast.

Code d'implémentation :main.xml:

<LinearLayout  
    xmlns:android="http://schemas.android.com/apk/res/android"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    android:orientation="vertical">  
    <EditText  
        android:id="@+id/etNum"  
        android:inputType="number"  
        android:layout_width="match_parent"  
        android:layout_height="wrap_content"  
        android:hint="请输入上限"/>  
    <Button  
        android:layout_width="match_parent"  
        android:layout_height="wrap_content"  
        android:onClick="cal"  
        android:text="计算"/>    
</LinearLayout>  

MainActivity.java :

public class CalPrime extends Activity  
{  
    static final String UPPER_NUM = "upper";  
    EditText etNum;  
    CalThread calThread;  
    // 定义一个线程类  
    class CalThread extends Thread  
    {  
        public Handler mHandler;  
  
        public void run()  
        {  
            Looper.prepare();  
            mHandler = new Handler()  
            {  
                // 定义处理消息的方法  
                @Override  
                public void handleMessage(Message msg)  
                {  
                    if(msg.what == 0x123)  
                    {  
                        int upper = msg.getData().getInt(UPPER_NUM);  
                        List<Integer> nums = new ArrayList<Integer>();  
                        // 计算从2开始、到upper的所有质数  
                        outer:  
                        for (int i = 2 ; i <= upper ; i++)  
                        {  
                            // 用i处于从2开始、到i的平方根的所有数  
                            for (int j = 2 ; j <= Math.sqrt(i) ; j++)  
                            {  
                                // 如果可以整除,表明这个数不是质数  
                                if(i != 2 && i % j == 0)  
                                {  
                                    continue outer;  
                                }  
                            }  
                            nums.add(i);  
                        }  
                        // 使用Toast显示统计出来的所有质数  
                        Toast.makeText(CalPrime.this , nums.toString()  
                            , Toast.LENGTH_LONG).show();  
                    }  
                }  
            };  
            Looper.loop();  
        }  
    }  
    @Override  
    public void onCreate(Bundle savedInstanceState)  
    {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
        etNum = (EditText)findViewById(R.id.etNum);  
        calThread = new CalThread();  
        // 启动新线程  
        calThread.start();  
    }  
    // 为按钮的点击事件提供事件处理函数  
    public void cal(View source)  
    {  
        // 创建消息  
        Message msg = new Message();  
        msg.what = 0x123;  
        Bundle bundle = new Bundle();  
        bundle.putInt(UPPER_NUM ,  
            Integer.parseInt(etNum.getText().toString()));  
        msg.setData(bundle);  
        // 向新线程中的Handler发送消息  
        calThread.mHandler.sendMessage(msg);  
    }  
} 

PS : Cet exemple provient de "Crazy Android" ~


Résumé de cette section

Cette section fournit une brève analyse du passage de messages Handler dans Android. Nous devons clairement distinguer les concepts de Handler, Message, MessageQueue et Looper, ainsi que la différence entre l'écriture d'un Handler dans le thread principal et dans un thread enfant !