首页 / 操作系统 / Linux / Android中播放GIF图片动画

1. 引言    在Android中，默认情况下是不允许播放GIF图片动画的，这时需要自己实现来播放GIF动画，在网上搜索了一个可用的实现，贴出来与大家共享。2. 功能实现    （1） 主Activity实现：  

0. package com.focus.fishme;   
1. import android.app.Activity;   
2. import android.os.Bundle;   
3. public class GIFPlayerActivity extends Activity {   
4.        
5.     @Override  
6.     public void onCreate（Bundle savedInstanceState） {   
7.         super.onCreate（savedInstanceState）;   
8.            
9.         GameView gameView = new GameView（this）;   
10.            
11.         setContentView（gameView）;   
12.     }   
13.        
14. }  

    （2） GIF图片动画View：  

0. package com.focus.fishme;   
1. import java.io.ByteArrayOutputStream;   
2. import java.io.IOException;   
3. import java.io.InputStream;   
4. import android.content.Context;   
5. import android.graphics.Bitmap;   
6. import android.graphics.Canvas;   
7. import android.graphics.Paint;   
8. import android.view.View;   
9. public class GameView extends View implements Runnable {   
10.     private GIFFrameManager mGIFFrameManager = null;   
11.     private Paint mPaint = null;   
12.     public GameView（Context context） {   
13.         super（context）;   
14.         mGIFFrameManager = GIFFrameManager.CreateGifImage（this.fileConnect（this  
15.                 .getResources（）.openRawResource（R.drawable.cat）））;   
16.         new Thread（this）.start（）;   
17.     }   
18.     protected void onDraw（Canvas canvas） {   
19.         super.onDraw（canvas）;   
20.         mPaint = new Paint（）;   
21.         mGIFFrameManager.nextFrame（）;   
22.         Bitmap bitmap = mGIFFrameManager.getImage（）;   
23.         if （bitmap ！= null） {   
24.             canvas.drawBitmap（bitmap, 0, 0, mPaint）;   
25.         }   
26.     }   
27.     public byte[] fileConnect（InputStream in） {   
28.         ByteArrayOutputStream out = new ByteArrayOutputStream（）;   
29.         int ch = 0;   
30.         try {   
31.             while （（ch = in.read（）） ！= -1） {   
32.                 out.write（ch）;   
33.             }   
34.             byte[] b = out.toByteArray（）;   
35.             out.close（）;   
36.             out = null;   
37.             in.close（）;   
38.             in = null;   
39.             return b;   
40.         } catch （IOException e） {   
41.             e.printStackTrace（）;   
42.             return null;   
43.         }   
44.     }   
45.     public void run（） {   
46.         while （！Thread.interrupted（）） {   
47.             try {   
48.                 Thread.sleep（100）;   
49.                 this.postInvalidate（）;   
50.             } catch （Exception ex） {   
51.                 ex.printStackTrace（）;   
52.                 Thread.currentThread（）.interrupt（）;   
53.             }   
54.         }   
55.     }   
56. }   

    （3） GIF图片动画播放管理器：  

1. package com.focus.fishme;   
2. import java.util.Vector;   
3. import android.graphics.Bitmap;   
4. public class GIFFrameManager {   
5.        
6.     private Vector<Bitmap> frames;   
7.     private int index;   
8.     public GIFFrameManager（） {   
9.         frames = new Vector<Bitmap>（1）;   
10.         index = 0;   
11.     }   
12.     public void addImage（Bitmap image） {   
13.         frames.addElement（image）;   
14.     }   
15.     public int size（） {   
16.         return frames.size（）;   
17.     }   
18.     public Bitmap getImage（） {   
19.         if （size（） == 0） {   
20.             return null;   
21.         } else {   
22.             return （Bitmap） frames.elementAt（index）;   
23.         }   
24.     }   
25.     public void nextFrame（） {   
26.         if （index + 1 < size（）） {   
27.             index++;   
28.         } else {   
29.             index = 0;   
30.         }   
31.     }   
32.     public static GIFFrameManager CreateGifImage（byte bytes[]） {   
33.         try {   
34.             GIFFrameManager GF = new GIFFrameManager（）;   
35.             Bitmap image = null;   
36.             GIFEncoder gifdecoder = new GIFEncoder（bytes）;   
37.             for （; gifdecoder.moreFrames（）; gifdecoder.nextFrame（）） {   
38.                 try {   
39.                     image = gifdecoder.decodeImage（）;   
40.                     if （GF ！= null && image ！= null） {   
41.                         GF.addImage（image）;   
42.                     }   
43.                     continue;   
44.                 } catch （Exception e） {   
45.                     e.printStackTrace（）;   
46.                 }   
47.                 break;   
48.             }   
49.             gifdecoder.clear（）;   
50.             gifdecoder = null;   
51.             return GF;   
52.         } catch （Exception e） {   
53.             e.printStackTrace（）;   
54.             return null;   
55.         }   
56.     }   
57. }  

    （4） GIF图片动画编码：  

0. package com.focus.fishme;   
1. import android.graphics.Bitmap;   
2. import android.graphics.Bitmap.Config;   
3. public class GIFEncoder {   
4.     private int E0;   
5.     private int E1[];   
6.     private int E2;   
7.     private int E6;   
8.     private boolean E7;   
9.     private int E8[];   
10.     private int width;   
11.     private int height;   
12.     private int ED;   
13.     private boolean EE;   
14.     private boolean EF;   
15.     private int F0[];   
16.     private int F1;   
17.     private boolean F2;   
18.     private int F3;   
19.     private long F4;   
20.     private int F5;   
21.     private static final int F6[] = { 8, 8, 4, 2 };   
22.     private static final int F8[] = { 0, 4, 2, 1 };   
23.     int curFrame;   
24.     int poolsize;   
25.     int FA;   
26.     byte C2[];   
27.     int FB;   
28.     int FC;   
29.     int FD;   
30.     public GIFEncoder（byte abyte0[]） {   
31.         E0 = -1;   
32.         E1 = new int[280];   
33.         E2 = -1;   
34.         E6 = 0;   
35.         E7 = false;   
36.         E8 = null;   
37.         width = 0;   
38.         height = 0;   
39.         ED = 0;   
40.         EE = false;   
41.         EF = false;   
42.         F0 = null;   
43.         F1 = 0;   
44.         F5 = 0;   
45.         curFrame = 0;   
46.         C2 = abyte0;   
47.         poolsize = C2.length;   
48.         FA = 0;   
49.     }   
50.     public boolean moreFrames（） {   
51.         return poolsize - FA >= 16;   
52.     }   
53.     public void nextFrame（） {   
54.         curFrame++;   
55.     }   
56.     public Bitmap decodeImage（） {   
57.         return decodeImage（curFrame）;   
58.     }   
59.     public Bitmap decodeImage（int i） {   
60.         if （i <= E0） {   
61.             return null;   
62.         }   
63.         if （E0 < 0） {   
64.             if （！E3（）） {   
65.                 return null;   
66.             }   
67.             if （！E4（）） {   
68.                 return null;   
69.             }   
70.         }   
71.         do {   
72.             if （！E9（1）） {   
73.                 return null;   
74.             }   
75.             int j = E1[0];   
76.             if （j == 59） {   
77.                 return null;   
78.             }   
79.             if （j == 33） {   
80.                 if （！E7（）） {   
81.                     return null;   
82.                 }   
83.             } else if （j == 44） {   
84.                 if （！E5（）） {   
85.                     return null;   
86.                 }   
87.                 Bitmap image = createImage（）;   
88.                 E0++;   
89.                 if （E0 < i） {   
90.                     image = null;   
91.                 } else {   
92.                     return image;   
93.                 }   
94.             }   
95.         } while （true）;   
96.     }   
97.     public void clear（） {   
98.         C2 = null;   
99.         E1 = null;   
100.         E8 = null;   
101.         F0 = null;   
102.     }   
103.     private Bitmap createImage（） {   
104.         int i = width;   
105.         int j = height;   
106.         int j1 = 0;   
107.         int k1 = 0;   
108.         int ai[] = new int[4096];   
109.         int ai1[] = new int[4096];   
110.         int ai2[] = new int[8192];   
111.         if （！E9（1）） {   
112.             return null;   
113.         }   
114.         int k = E1[0];   
115.         int[] image = new int[width * height];   
116.         int ai3[] = E8;   
117.         if （EE） {   
118.             ai3 = F0;   
119.         }   
120.         if （E2 >= 0） {   
121.             ai3[E2] = 0xffffff;   
122.         }   
123.         int l2 = 1 << k;   
124.         int j3 = l2 + 1;   
125.         int k2 = k + 1;   
126.         int l3 = l2 + 2;   
127.         int k3 = -1;   
128.         int j4 = -1;   
129.         for （int l1 = 0; l1 < l2; l1++） {   
130.             ai1[l1] = l1;   
131.         }   
132.         int j2 = 0;   
133.         E2（）;   
134.         j1 = 0;   
135.         label0: for （int i2 = 0; i2 < j; i2++） {   
136.             int i1 = 0;   
137.             do {   
138.                 if （i1 >= i） {   
139.                     break;   
140.                 }   
141.                 if （j2 == 0） {   
142.                     int i4 = E1（k2）;   
143.                     if （i4 < 0） {   
144.                         return Bitmap.createBitmap（image, width, height,   
145.                                 Config.RGB_565）;   
146.                     }   
147.                     if （i4 > l3 || i4 == j3） {   
148.                         return Bitmap.createBitmap（image, width, height,   
149.                                 Config.RGB_565）;   
150.                     }   
151.                     if （i4 == l2） {   
152.                         k2 = k + 1;   
153.                         l3 = l2 + 2;   
154.                         k3 = -1;   
155.                         continue;   
156.                     }   
157.                     if （k3 == -1） {   
158.                         ai2[j2++] = ai1[i4];   
159.                         k3 = i4;   
160.                         j4 = i4;   
161.                         continue;   
162.                     }   
163.                     int i3 = i4;   
164.                     if （i4 == l3） {   
165.                         ai2[j2++] = j4;   
166.                         i4 = k3;   
167.                     }   
168.                     for （; i4 > l2; i4 = ai[i4]） {   
169.                         ai2[j2++] = ai1[i4];   
170.                     }   
171.                     j4 = ai1[i4];   
172.                     if （l3 >= 4096） {   
173.                         return Bitmap.createBitmap（image, width, height,   
174.                                 Config.RGB_565）;   
175.                     }   
176.                     ai2[j2++] = j4;   
177.                     ai[l3] = k3;   
178.                     ai1[l3] = j4;   
179.                     if （++l3 >= 1 << k2 && l3 < 4096） {   
180.                         k2++;   
181.                     }   
182.                     k3 = i3;   
183.                 }   
184.                 int l = ai2[--j2];   
185.                 if （l < 0） {   
186.                     return Bitmap.createBitmap（image, width, height,   
187.                             Config.RGB_565）;   
188.                 }   
189.                 if （i1 == 0） {   
190.                     FC = 0;   
191.                     FB = ai3[l];   
192.                     FD = 0;   
193.                 } else if （FB ！= ai3[l]） {   
194.                     for （int mm = FD; mm <= FD + FC; mm++） {   
195.                         image[j1 * width + mm] = FB;   
196.                     }   
197.                     FC = 0;   
198.                     FB = ai3[l];   
199.                     FD = i1;   
200.                     if （i1 == i - 1） {   
201.                         image[j1 * width + i1] = ai3[l];   
202.                     }   
203.                 } else {   
204.                     FC++;   
205.                     if （i1 == i - 1） {   
206.                         for （int mm = FD; mm <= FD + FC; mm++） {   
207.                             image[j1 * width + mm] = FB;   
208.                         }   
209.                     }   
210.                 }   
211.                 i1++;   
212.             } while （true）;   
213.             if （EF） {   
214.                 j1 += F6[k1];   
215.                 do {   
216.                     if （j1 < j） {   
217.                         continue label0;   
218.                     }   
219.                     if （++k1 > 3） {   
220.                         return Bitmap.createBitmap（image, width, height,   
221.                                 Config.RGB_565）;   
222.                     }   
223.                     j1 = F8[k1];   
224.                 } while （true）;   
225.             }   
226.             j1++;   
227.         }   
228.         return Bitmap.createBitmap（image, width, height, Config.RGB_565）;   
229.     }   
230.     private int E1（int i） {   
231.         while （F5 < i） {   
232.             if （F2） {   
233.                 return -1;   
234.             }   
235.             if （F1 == 0） {   
236.                 F1 = E8（）;   
237.                 F3 = 0;   
238.                 if （F1 <= 0） {   
239.                     F2 = true;   
240.                     break;   
241.                 }   
242.             }   
243.             F4 += E1[F3] << F5;   
244.             F3++;   
245.             F5 += 8;   
246.             F1--;   
247.         }   
248.         int j = （int） F4 & （1 << i） - 1;   
249.         F4 >>= i;   
250.         F5 -= i;   
251.         return j;   
252.     }   
253.     private void E2（） {   
254.         F5 = 0;   
255.         F1 = 0;   
256.         F4 = 0L;   
257.         F2 = false;   
258.         F3 = -1;   
259.     }   
260.     private