Android中播放GIF图片动画

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 boolean E3() {   
261.         if (!E9(6)) {   
262.             return false;   
263.         }   
264.         return E1[0] == 71 && E1[1] == 73 && E1[2] == 70 && E1[3] == 56  
265.                 && (E1[4] == 55 || E1[4] == 57) && E1[5] == 97;   
266.     }   
267.     private boolean E4() {   
268.         if (!E9(7)) {   
269.             return false;   
270.         }   
271.         int i = E1[4];   
272.         E6 = 2 << (i & 7);   
273.         E7 = EB(i, 128);   
274.         E8 = null;   
275.         return !E7 || E6(E6, true);   
276.     }   
277.     private boolean E5() {   
278.         if (!E9(9)) {   
279.             return false;   
280.         }   
281.         width = EA(E1[4], E1[5]);   
282.         height = EA(E1[6], E1[7]);   
283.         int i = E1[8];   
284.         EE = EB(i, 128);   
285.         ED = 2 << (i & 7);   
286.         EF = EB(i, 64);   
287.         F0 = null;   
288.         return !EE || E6(ED, false);   
289.     }   
290.     private boolean E6(int i, boolean flag) {   
291.         int ai[] = new int[i];   
292.         for (int j = 0; j < i; j++) {   
293.             if (!E9(3)) {   
294.                 return false;   
295.             }   
296.             ai[j] = E1[0] << 16 | E1[1] << 8 | E1[2] | 0xff000000;   
297.         }   
298.         if (flag) {   
299.             E8 = ai;   
300.         } else {   
301.             F0 = ai;   
302.         }   
303.         return true;   
304.     }   
305.     private boolean E7() {   
306.         if (!E9(1)) {   
307.             return false;   
308.         }   
309.         int i = E1[0];   
310.         int j = -1;   
311.         switch (i) {   
312.         case 249:   
313.             j = E8();   
314.             if (j < 0) {   
315.                 return true;   
316.             }   
317.             if ((E1[0] & 1) != 0) {   
318.                 E2 = E1[3];   
319.             } else {   
320.                 E2 = -1;   
321.             }   
322.             break;   
323.         }   
324.         do {   
325.             j = E8();   
326.         } while (j > 0);   
327.         return true;   
328.     }   
329.     private int E8() {   
330.         if (!E9(1)) {   
331.             return -1;   
332.         }   
333.         int i = E1[0];   
334.         if (i != 0 && !E9(i)) {   
335.             return -1;   
336.         } else {   
337.             return i;   
338.         }   
339.     }   
340.     private boolean E9(int i) {   
341.         if (FA + i >= poolsize) {   
342.             return false;   
343.         }   
344.         for (int j = 0; j < i; j++) {   
345.             int k = C2[FA + j];   
346.             if (k < 0) {   
347.                 k += 256;   
348.             }   
349.             E1[j] = k;   
350.         }   
351.         FA += i;   
352.         return true;   
353.     }   
354.     private static final int EA(int i, int j) {   
355.         return j << 8 | i;   
356.     }   
357.     private static final boolean EB(int i, int j) {   
358.         return (i & j) == j;   
359.     }   
360. }