Android 小項目之--消息、線程、動畫顯示圖片

一、
角色描述

1.Looper: 一个线程可以产生一个Looper对象，由它来管理此线程里的Message Queue(消息队列)。

2.Handler: 你可以构造Handler对象来与Looper沟通，以便push新消息到Message Queue里；或者接收Looper(从Message Queue取出)所送来的消息。

3. Message Queue(消息队列):用来存放线程放入的消息。

4．线程：UI thread 通常就是main thread，而Android启动程序时会替它建立一个Message Queue。

每一个线程里可含有一个Looper对象以及一个MessageQueue数据结构。在你的应用程序里，可以定义Handler的子类别来接收Looper所送出的消息。

在你的Android程序里，新诞生一个线程，或执行 (Thread)时，并不会自动建立其Message Loop。

Android里并没有Global的Message Queue数据结构，例如，不同APK里的对象不能透过Massage Queue来交换讯息(Message)。

例如：线程A的Handler对象可以传递消息给别的线程，让别的线程B或C等能送消息来给线程A(存于A的Message Queue里)。

线程A的Message Queue里的讯息，只有线程A所属的对象可以处理。

使用Looper.myLooper可以取得当前线程的Looper对象。

使用mHandler = new EevntHandler(Looper.myLooper()); 可用来构造当前线程的Handler对象；其中，EevntHandler是自已实现的Handler的子类别。

使用mHandler = new EevntHandler(Looper.getMainLooper()); 可诞生用来处理main线程的Handler对象；其中，EevntHandler是自已实现的Handler的子类别。

这样描述可能太抽像，下面举几个实际的例子来说明：

二、
举例

1. 同线程内不同组件间的消息传递

Looper类用来管理特定线程内对象之间的消息交换(Message Exchange)。你的应用程序可以产生许多个线程。而一个线程可以有许多个组件，这些组件之间常常需要互相交换讯息。如果有这种需要，您可以替线程构造一个Looper对象，来担任讯息交换的管理工作。Looper对象会建立一个MessageQueue数据结构来存放各对象传来的消息(包括UI事件或System事件等)。如下图：

每一个线程里可含有一个Looper对象以及一个MessageQueue数据结构。在你的应用程序里，可以定义Handler的子类别来接收Looper所送出的消息。

　--------------------------打醬油---------------------------

運行效果圖：

　　繼上篇文章顯示時針的例子，這次在android線程裏面我又加入了動畫的方式，讓線程更好的幫助我們做更好的動畫效果，本例子，將用到四張圖片，每張圖片出來的顯示方式都不一樣，每隔三秒顯示一張不同的圖片，其顯示方式都不一樣，具體操作看代碼：

1. private static final int my_key=0x123;
   
2.     private int a=0;
   
3.     private int[] myImage={
   
4.             R.drawable.aa,
   
5.             R.drawable.bb,
   
6.             R.drawable.cc,
   
7.             R.drawable.dd
   
8.     };

复制代码

本篇不過多解釋代碼，有任何問題可以參考以上三篇文章，下麵給出效果的全部代碼：

1. package cn.terry;
   
2. 
   
3. import android.app.Activity; 
   
4. import android.os.Bundle;
   
5. import android.os.Handler;
   
6. import android.os.Message; 
   
7. import android.view.animation.AlphaAnimation;
   
8. import android.view.animation.Animation;
   
9. import android.view.animation.RotateAnimation;
   
10. import android.view.animation.ScaleAnimation;
    
11. import android.view.animation.TranslateAnimation;
    
12. import android.widget.*;
    
13. public class testHandler extends Activity implements Runnable { 
    
14.     private static final int my_key=0x123;
    
15.     private int a=0;
    
16.     private int[] myImage={
    
17.             R.drawable.aa,
    
18.             R.drawable.bb,
    
19.             R.drawable.cc,
    
20.             R.drawable.dd
    
21.     };
    
22.     private Handler myHandler;
    
23.     private Thread myThread; 
    
24.     private ImageView myImageView;
    
25.     private Animation myAnimationAlpha;
    
26.      private Animation myAnimationScale;
    
27.         private Animation myAnimationTranslate;
    
28.         private Animation myAnimationRotate;
    
29. 
    
30. 
    
31.     /** Called when the activity is first created. */
    
32.     @Override
    
33.     public void onCreate(Bundle savedInstanceState) {
    
34.         super.onCreate(savedInstanceState);
    
35.         setContentView(R.layout.main);
    
36.         myImageView=(ImageView)findViewById(R.id.ImageView01); 
    
37.         myAnimationAlpha=new AlphaAnimation(0.1f, 1.0f);
    
38.         myAnimationAlpha.setDuration(3000);
    
39.         myAnimationScale=new ScaleAnimation(0.0f, 1.4f, 0.0f, 1.4f,
    
40.                 Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
    
41.         myAnimationScale.setDuration(3000);
    
42.         
    
43.         myAnimationTranslate=new TranslateAnimation(30.0f, -80.0f, 30.0f, 300.0f);
    
44.         myAnimationTranslate.setDuration(3000);
    
45.         
    
46.        myAnimationRotate=new RotateAnimation(0.0f, +350.0f,
    
47.                Animation.RELATIVE_TO_SELF,0.5f,Animation.RELATIVE_TO_SELF, 0.5f);
    
48.        myAnimationRotate.setDuration(3000);
    
49.        // myLinearLayout.setBackgroundColor(Color.WHITE);
    
50.         myHandler=new Handler()
    
51.         {
    
52.             @Override
    
53.             public void handleMessage(Message msg) {
    
54.                 // TODO Auto-generated method stub
    
55.                 switch (msg.what) {
    
56.                 case testHandler.my_key:
    
57.                     switch (a) {
    
58.                     case 0: 
    
59.                         myImageView.startAnimation(myAnimationAlpha);
    
60.                         
    
61.                         break; 
    
62.                     case 1: 
    
63.                         myImageView.startAnimation(myAnimationScale);
    
64.                        
    
65.                         break;
    
66.                     case 2: 
    
67.                         myImageView.startAnimation(myAnimationTranslate);
    
68.                         
    
69.                         break;
    
70.                     case 3: 
    
71.                         myImageView.startAnimation(myAnimationRotate);
    
72.                        
    
73.                         break;
    
74.                     default:
    
75.                         break;
    
76.                     }
    
77.                     myImageView.setImageResource(myImage[a-1]);
    
78.                     myImageView.setScaleType(ImageView.ScaleType.FIT_XY);
    
79.                     //myImageView.setLayoutParams(new LayoutParams(300, 200));
    
80.                     
    
81.                      if(a==myImage.length)
    
82.                      {
    
83.                          a=0;
    
84.                      }
    
85.                     
    
86.                     break;
    
87. 
    
88.                 default:
    
89.                     break;
    
90.                 }
    
91.                 super.handleMessage(msg);
    
92.             }
    
93.         };
    
94.         
    
95.         myThread=new Thread(this);
    
96.         myThread.start();
    
97.     }
    
98.     @Override
    
99.     public void run() {
    
100.         // TODO Auto-generated method stub
     
101.         try {
     
102.              do
     
103.              {
     
104.                  a++;
     
105.                 Thread.sleep(4000);
     
106.                  Message msg=new Message();
     
107.                  msg.what=testHandler.my_key;
     
108.                  myHandler.sendMessage(msg);
     
109.              }
     
110.              while(Thread.interrupted()==false);
     
111.         } catch (Exception e) {
     
112.             // TODO: handle exception
     
113.             e.printStackTrace();
     
114.         }
     
115.         
     
116.         
     
117.         
     
118.         
     
119.     }
     
120. }

复制代码