android 自定义控件 播放gif 既可以是从网络上获取资源 也可以是本地资源

  很纠结啊 这几天 在研究怎么从网络上加载gif图片，看了很多例子，感觉大多数功能都不够完成 ，所以我自己 整理了一下，结合了网络加载和本地加载，以及不是gif的图片，这样估计功能强大一些。

 但是现在纠结的是 我是结合两个人的东西 自己后加的并不算多，不知道 这个是属于原创呢？还是转载呢？纠结了很长时间，还是写成原创了，如果不可以，在改回来，参考的那两个地址，一个是：http://blog.csdn.net/guolin_blog/article/details/11100315，这个是本地加载的另一个是：http://blog.csdn.net/a764424767/article/details/17915177，这个是网络加载的。 我添加的功能是 自定义了一个 <attr name="gif_url" format="string"></attr>属性，可以直接在xml文件了设置网络地址，再次就是将两个代码整合了一下 ，改动了一些地方。

下面不说了直接上代码：

package com.lgwteam.security_ui;


import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Movie;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.util.AttributeSet;
import android.util.Log;
import android.util.TypedValue;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup.LayoutParams;
import android.widget.ImageView;


import com.example.myproject_test1.R;


public class GifView extends ImageView implements OnClickListener {


private static final int LOADACOMPLISH = 1;
/**
* 获取线程池
*/
private static ExecutorService pools = Executors.newCachedThreadPool();
/**
* 播放GIF动画的关键类
*/
private Movie gifMovie;


/**
* 开始播放按钮图片
*/
private Bitmap gifStartButton;


/**
* 记录动画开始的时间
*/
private long gifMovieStart;


/**
* GIF图片的宽度
*/
private int gifImageWidth;


/**
* GIF图片的高度
*/
private int gifImageHeight;


/**
* 图片是否正在播放
*/
private boolean isPlaying;


/**
* 是否允许自动播放
*/
private boolean isAutoPlay;


/**
* 加载完毕，通知重绘控件
*/
private final Handler handler = new Handler(this.getContext()
.getMainLooper()) {
public void handleMessage(Message msg) {
switch (msg.what) {
case LOADACOMPLISH:
if (msg.obj == null) {
return;
}
Log.e("look", "加载完毕！！！");
setResource((byte[]) msg.obj);
break;


default:
break;
}
}
};


/**
* GifView构造函数。
* 
* @param context
*/
public GifView(Context context) {
super(context);
}


/**
* GifView构造函数。
* 
* @param context
*/
public GifView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}


/**
* GifView构造函数，在这里完成所有必要的初始化操作。
* 
* @param context
*/
public GifView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
TypedArray a = context.obtainStyledAttributes(attrs,
R.styleable.GifView);
int resourceId = getResourceId(a, context, attrs);
isAutoPlay = a.getBoolean(R.styleable.GifView_auto_play, false);
String urlstr = a.getString(R.styleable.GifView_gif_url);
if (urlstr != null) {
Log.i("urlstr", urlstr);
setResource(urlstr);
}
if (resourceId != 0) {
// 当资源id不等于0时，就去获取该资源的流
InputStream is = getResources().openRawResource(resourceId);
// 使用Movie类对流进行解码
gifMovie = Movie.decodeStream(is);
if (gifMovie != null) {
// 如果返回值不等于null，就说明这是一个GIF图片，下面获取是否自动播放的属性


Bitmap bitmap = BitmapFactory.decodeStream(is);
gifImageWidth = bitmap.getWidth();
gifImageHeight = bitmap.getHeight();
bitmap.recycle();
if (!isAutoPlay) {
// 当不允许自动播放的时候，得到开始播放按钮的图片，并注册点击事件
gifStartButton = BitmapFactory.decodeResource(
getResources(), R.drawable.start_play);
setOnClickListener(this);
}
}
}


}


@Override
public void onClick(View v) {
// TODO Auto-generated method stub
if (v.getId() == getId()) {
// 当用户点击图片时，开始播放GIF动画
isPlaying = true;
invalidate();
}
}


/**
* 通过Java反射，获取到src指定图片资源所对应的id。
* 
* @param typeArray
* @param context
* @param attrs
* @return 返回布局文件中指定图片资源所对应的id，没有指定任何图片资源就返回0。
*/
private int getResourceId(TypedArray typeArray, Context context,
AttributeSet attrs) {
try {
Field field = TypedArray.class.getDeclaredField("mValue");
field.setAccessible(true);
TypedValue typedValueObject = (TypedValue) field.get(typeArray);
return typedValueObject.resourceId;
} catch (Exception e) {
e.printStackTrace();
} finally {
if (typeArray != null) {
typeArray.recycle();
}
}
return 0;
}


/**
* 获取网络资源
* 
* @param urlstr
*/
public void setResource(final String urlstr) {
pools.execute(new Runnable() {
public void run() {
try {
URL url = new URL(urlstr);
HttpURLConnection connection = (HttpURLConnection) url
.openConnection();
connection.setConnectTimeout(10000);
connection.setReadTimeout(10000);
connection.setRequestMethod("GET");
if (connection.getResponseCode() == 200) {
InputStream is = connection.getInputStream();


byte[] buffer = getByte(is);
handler.obtainMessage(1, buffer).sendToTarget();
} else {
Log.e("getResponseCode", connection.getResponseCode()
+ ":");
}
} catch (Exception e) {
e.printStackTrace();
}
}
});
}


/**
* 读取InputStream里面的内容
* 
* @param inputStream
* @return byte[]
*/
private final static byte[] getByte(InputStream inputStream) {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
int len = 0;
byte[] buffer = new byte[1024];
try {
while ((len = inputStream.read(buffer)) > 0) {
outputStream.write(buffer, 0, len);
}
return outputStream.toByteArray();
} catch (Exception e) {
e.printStackTrace();
return null;
}
}


@Override
protected void onDraw(Canvas canvas) {
Log.i("onDraw", "onDraw");
if (gifMovie == null) {
// mMovie等于null，说明是张普通的图片，则直接调用父类的onDraw()方法
super.onDraw(canvas);
} else {
// mMovie不等于null，说明是张GIF图片
if (isAutoPlay) {
// 如果允许自动播放，就调用playMovie()方法播放GIF动画
playMovie(canvas);
invalidate();
} else {
// 不允许自动播放时，判断当前图片是否正在播放
if (isPlaying) {
// 正在播放就继续调用playMovie()方法，一直到动画播放结束为止
if (playMovie(canvas)) {
isPlaying = false;
}
invalidate();
} else {
// 还没开始播放就只绘制GIF图片的第一帧，并绘制一个开始按钮
gifMovie.setTime(0);
gifMovie.draw(canvas, 0, 0);
int offsetW = (gifImageWidth - gifStartButton.getWidth()) / 2;
int offsetH = (gifImageHeight - gifStartButton.getHeight()) / 2;
canvas.drawBitmap(gifStartButton, offsetW, offsetH, null);
}
}
}
}


/**
* 开始播放GIF动画，播放完成返回true，未完成返回false。
* 
* @param canvas
* @return 播放完成返回true，未完成返回false。
*/
private boolean playMovie(Canvas canvas) {
long now = SystemClock.uptimeMillis();
if (gifMovieStart == 0) {
gifMovieStart = now;
}
int duration = gifMovie.duration();
if (duration == 0) {
duration = 1000;
}
int relTime = (int) ((now - gifMovieStart) % duration);
gifMovie.setTime(relTime);
gifMovie.draw(canvas, 0, 0);
if ((now - gifMovieStart) >= duration) {
gifMovieStart = 0;
return true;
}
return false;
}


/**
* 获取gif动态图
* 
* @param data
*/
public void setResource(byte[] data) {
gifMovie = Movie.decodeByteArray(data, 0, data.length);
Log.i("setResource", "setResource");
gifImageHeight = gifMovie.height();
gifImageWidth = gifMovie.width();
reMeasure();
invalidate();
}


/**
* 重新测量长度
*/
private final void reMeasure() {
if (gifMovie != null) {
Log.i("reMeasure", "reMeasure");
measure(MeasureSpec.makeMeasureSpec(gifMovie.width(),
MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(
gifMovie.height(), MeasureSpec.EXACTLY));
}
}


@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
if (gifMovie != null) {
Log.i("gifMovie", "gifMovie");
LayoutParams lp = (LayoutParams) getLayoutParams();
boolean isWidMat = lp.width == LayoutParams.MATCH_PARENT;
boolean isHeiMat = lp.height == LayoutParams.MATCH_PARENT;
boolean isWidWra = lp.width == LayoutParams.WRAP_CONTENT;
boolean isHeiWra = lp.height == LayoutParams.WRAP_CONTENT;
if (isWidMat && isHeiMat) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
return;
}


if (gifMovie != null) {
requestLayout();
setMeasuredDimension(
isWidMat ? MeasureSpec.getSize(widthMeasureSpec)
: isWidWra ? gifImageWidth : lp.width,
isHeiMat ? MeasureSpec.getSize(heightMeasureSpec)
: isHeiWra ? gifImageHeight : lp.height);
}
}
}
}

xml文件：

 <com.lgwteam.security_ui.GifView
            android:id="@+id/gfGif"
            android:layout_width="wrap_content"
            android:layout_gravity="center"
            android:layout_height="wrap_content"
            android:src="@drawable/loading"
            android:scaleType="fitCenter"
            app:gif_url="@string/web_address"
            app:auto_play="true" />