Android异步加载网络图片

Posted 2020-06-17

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Android异步加载网络图片相关的知识，希望对你有一定的参考价值。

android图片的异步加载，主要原理：

加载图片时先查看缓存中时候存在该图片，如果存在则返回该图片，否则先加载载一个默认的占位图片，同时创建一个通过网络获取图片的任务并添加，任务完成后放松消息给主线程更新界面。

使用方法：

[java] view plain copy

AsynImageLoader asynImageLoader = new AsynImageLoader();
asynImageLoader.showImageAsyn(imageView, imageUrl, resId);

类代码：

[java] view plain copy

package com.wangge.uumao.http;
import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import android.graphics.Bitmap;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.widget.ImageView;
import com.wangge.uumao.util.PicUtil;
public class AsynImageLoader {
private static final String TAG = "AsynImageLoader";
// 缓存下载过的图片的Map
private Map<String, SoftReference<Bitmap>> caches;
// 任务队列
private List<Task> taskQueue;
private boolean isRunning = false;
public AsynImageLoader(){
// 初始化变量
caches = new HashMap<String, SoftReference<Bitmap>>();
taskQueue = new ArrayList<AsynImageLoader.Task>();
// 启动图片下载线程
isRunning = true;
new Thread(runnable).start();
}
/**
*
* @param imageView 需要延迟加载图片的对象
* @param url 图片的URL地址
* @param resId 图片加载过程中显示的图片资源
*/
public void showImageAsyn(ImageView imageView, String url, int resId){
imageView.setTag(url);
Bitmap bitmap = loadImageAsyn(url, getImageCallback(imageView, resId));
if(bitmap == null){
imageView.setImageResource(resId);
}else{
imageView.setImageBitmap(bitmap);
}
}
public Bitmap loadImageAsyn(String path, ImageCallback callback){
// 判断缓存中是否已经存在该图片
if(caches.containsKey(path)){
// 取出软引用
SoftReference<Bitmap> rf = caches.get(path);
// 通过软引用，获取图片
Bitmap bitmap = rf.get();
// 如果该图片已经被释放，则将该path对应的键从Map中移除掉
if(bitmap == null){
caches.remove(path);
}else{
// 如果图片未被释放，直接返回该图片
Log.i(TAG, "return image in cache" + path);
return bitmap;
}
}else{
// 如果缓存中不常在该图片，则创建图片下载任务
Task task = new Task();
task.path = path;
task.callback = callback;
Log.i(TAG, "new Task ," + path);
if(!taskQueue.contains(task)){
taskQueue.add(task);
// 唤醒任务下载队列
synchronized (runnable) {
runnable.notify();
}
}
}
// 缓存中没有图片则返回null
return null;
}
/**
*
* @param imageView
* @param resId 图片加载完成前显示的图片资源ID
* @return
*/
private ImageCallback getImageCallback(final ImageView imageView, final int resId){
return new ImageCallback() {
@Override
public void loadImage(String path, Bitmap bitmap) {
if(path.equals(imageView.getTag().toString())){
imageView.setImageBitmap(bitmap);
}else{
imageView.setImageResource(resId);
}
}
};
}
private Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
// 子线程中返回的下载完成的任务
Task task = (Task)msg.obj;
// 调用callback对象的loadImage方法，并将图片路径和图片回传给adapter
task.callback.loadImage(task.path, task.bitmap);
}
};
private Runnable runnable = new Runnable() {
@Override
public void run() {
while(isRunning){
// 当队列中还有未处理的任务时，执行下载任务
while(taskQueue.size() > 0){
// 获取第一个任务，并将之从任务队列中删除
Task task = taskQueue.remove(0);
// 将下载的图片添加到缓存
task.bitmap = PicUtil.getbitmap(task.path);
caches.put(task.path, new SoftReference<Bitmap>(task.bitmap));
if(handler != null){
// 创建消息对象，并将完成的任务添加到消息对象中
Message msg = handler.obtainMessage();
msg.obj = task;
// 发送消息回主线程
handler.sendMessage(msg);
}
}
//如果队列为空,则令线程等待
synchronized (this) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
};
//回调接口
public interface ImageCallback{
void loadImage(String path, Bitmap bitmap);
}
class Task{
// 下载任务的下载路径
String path;
// 下载的图片
Bitmap bitmap;
// 回调对象
ImageCallback callback;
@Override
public boolean equals(Object o) {
Task task = (Task)o;
return task.path.equals(path);
}
}
}

最后附上PicUtil类的代码，之前忘了贴这个类的代码，不好意识了~~

[java] view plain copy

public class PicUtil {
private static final String TAG = "PicUtil";
/**
* 根据一个网络连接(URL)获取bitmapDrawable图像
*
* @param imageUri
* @return
*/
public static BitmapDrawable getfriendicon(URL imageUri) {
BitmapDrawable icon = null;
try {
HttpURLConnection hp = (HttpURLConnection) imageUri
.openConnection();
icon = new BitmapDrawable(hp.getInputStream());// 将输入流转换成bitmap
hp.disconnect();// 关闭连接
} catch (Exception e) {
}
return icon;
}
/**
* 根据一个网络连接(String)获取bitmapDrawable图像
*
* @param imageUri
* @return
*/
public static BitmapDrawable getcontentPic(String imageUri) {
URL imgUrl = null;
try {
imgUrl = new URL(imageUri);
} catch (MalformedURLException e1) {
e1.printStackTrace();
}
BitmapDrawable icon = null;
try {
HttpURLConnection hp = (HttpURLConnection) imgUrl.openConnection();
icon = new BitmapDrawable(hp.getInputStream());// 将输入流转换成bitmap
hp.disconnect();// 关闭连接
} catch (Exception e) {
}
return icon;
}
/**
* 根据一个网络连接(URL)获取bitmap图像
*
* @param imageUri
* @return
*/
public static Bitmap getusericon(URL imageUri) {
// 显示网络上的图片
URL myFileUrl = imageUri;
Bitmap bitmap = null;
try {
HttpURLConnection conn = (HttpURLConnection) myFileUrl
.openConnection();
conn.setDoInput(true);
conn.connect();
InputStream is = conn.getInputStream();
bitmap = BitmapFactory.decodeStream(is);
is.close();
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
/**
* 根据一个网络连接(String)获取bitmap图像
*
* @param imageUri
* @return
* @throws MalformedURLException
*/
public static Bitmap getbitmap(String imageUri) {
// 显示网络上的图片
Bitmap bitmap = null;
try {
URL myFileUrl = new URL(imageUri);
HttpURLConnection conn = (HttpURLConnection) myFileUrl
.openConnection();
conn.setDoInput(true);
conn.connect();
InputStream is = conn.getInputStream();
bitmap = BitmapFactory.decodeStream(is);
is.close();
Log.i(TAG, "image download finished." + imageUri);
} catch (IOException e) {
e.printStackTrace();
return null;
}
return bitmap;
}
/**
* 下载图片同时写道本地缓存文件中
*
* @param context
* @param imageUri
* @return
* @throws MalformedURLException
*/
public static Bitmap getbitmapAndwrite(String imageUri) {
Bitmap bitmap = null;
try {
// 显示网络上的图片
URL myFileUrl = new URL(imageUri);
HttpURLConnection conn = (HttpURLConnection) myFileUrl
.openConnection();
conn.setDoInput(true);
conn.connect();
InputStream is = conn.getInputStream();
File cacheFile = FileUtil.getCacheFile(imageUri);
BufferedOutputStream bos = null;
bos = new BufferedOutputStream(new FileOutputStream(cacheFile));
Log.i(TAG, "write file to " + cacheFile.getCanonicalPath());
byte[] buf = new byte[1024];
int len = 0;
// 将网络上的图片存储到本地
while ((len = is.read(buf)) > 0) {
bos.write(buf, 0, len);
}
is.close();
bos.close();
// 从本地加载图片
bitmap = BitmapFactory.decodeFile(cacheFile.getCanonicalPath());
String name = MD5Util.MD5(imageUri);
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
public static boolean downpic(String picName, Bitmap bitmap) {
boolean nowbol = false;
try {
File saveFile = new File("/mnt/sdcard/download/weibopic/" + picName
+ ".png");
if (!saveFile.exists()) {
saveFile.createNewFile();
}
FileOutputStream saveFileOutputStream;
saveFileOutputStream = new FileOutputStream(saveFile);
nowbol = bitmap.compress(Bitmap.CompressFormat.PNG, 100,
saveFileOutputStream);
saveFileOutputStream.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return nowbol;
}
public static void writeTofiles(Context context, Bitmap bitmap,
String filename) {
BufferedOutputStream outputStream = null;
try {
outputStream = new BufferedOutputStream(context.openFileOutput(
filename, Context.MODE_PRIVATE));
bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
/**
* 将文件写入缓存系统中
*
* @param filename
* @param is
* @return
*/
public static String writefile(Context context, String filename,
InputStream is) {
BufferedInputStream inputStream = null;
BufferedOutputStream outputStream = null;
try {
inputStream = new BufferedInputStream(is);
outputStream = new BufferedOutputStream(context.openFileOutput(
filename, Context.MODE_PRIVATE));
byte[] buffer = new byte[1024];
int length;
while ((length = inputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, length);
}
} catch (Exception e) {
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (outputStream != null) {
try {
outputStream.flush();
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return context.getFilesDir() + "/" + filename + ".jpg";
}
// 放大缩小图片
public static Bitmap zoomBitmap(Bitmap bitmap, int w, int h) {
int width = bitmap.getWidth();
int height = bitmap.getHeight();
Matrix matrix = new Matrix();
float scaleWidht = ((float) w / width);
float scaleHeight = ((float) h / height);
matrix.postScale(scaleWidht, scaleHeight);
Bitmap newbmp = Bitmap.createBitmap(bitmap, 0, 0, width, height,
matrix, true);
return newbmp;
}
// 将Drawable转化为Bitmap
public static Bitmap drawableToBitmap(Drawable drawable) {
int width = drawable.getIntrinsicWidth();
int height = drawable.getIntrinsicHeight();
Bitmap bitmap = Bitmap.createBitmap(width, height, drawable
.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888
: Bitmap.Config.RGB_565);
Canvas canvas = new Canvas(bitmap);
drawable.setBounds(0, 0, width, height);
drawable.draw(canvas);
return bitmap;
}
// 获得圆角图片的方法
public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, float roundPx) {
if(bitmap == null){
return null;
}
Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),
bitmap.getHeight(), Config.ARGB_8888);
Canvas canvas = new Canvas(output);
final int color = 0xff424242;
final Paint paint = new Paint();
final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
final RectF rectF = new RectF(rect);
paint.setAntiAlias(true);
canvas.drawARGB(0, 0, 0, 0);
paint.setColor(color);
canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
canvas.drawBitmap(bitmap, rect, rect, paint);
return output;
}
// 获得带倒影的图片方法
public static Bitmap createReflectionImageWithOrigin(Bitmap bitmap) {
final int reflectionGap = 4;
int width = bitmap.getWidth();
int height = bitmap.getHeight();
Matrix matrix = new Matrix();
matrix.preScale(1, -1);
Bitmap reflectionImage = Bitmap.createBitmap(bitmap, 0, height / 2,
width, height / 2, matrix, false);
Bitmap bitmapWithReflection = Bitmap.createBitmap(width,
(height + height / 2), Config.ARGB_8888);
Canvas canvas = new Canvas(bitmapWithReflection);
canvas.drawBitmap(bitmap, 0, 0, null);
Paint deafalutPaint = new Paint();
canvas.drawRect(0, height, width, height + reflectionGap, deafalutPaint);
canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);
Paint paint = new Paint();
LinearGradient shader = new LinearGradient(0, bitmap.getHeight(), 0,
bitmapWithReflection.getHeight() + reflectionGap, 0x70ffffff,
0x00ffffff, TileMode.CLAMP);
paint.setShader(shader);
// Set the Transfer mode to be porter duff and destination in
paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));
// Draw a rectangle using the paint with our linear gradient
canvas.drawRect(0, height, width, bitmapWithReflection.getHeight()
以上是关于Android异步加载网络图片的主要内容，如果未能解决你的问题，请参考以下文章

Android之ListView异步加载网络图片(优化缓存机制)

xamarin.Android ImageView 异步加载网络图片

AsyncTask实现网络图片的异步加载

Android_开源框架_AndroidUniversalImageLoader网络图片加载

Android中ListView异步加载图片错位重复闪烁问题分析及解决方案

Android 网络图片加载缓存处理库ImageLoader和Picasso