Android新浪微博如何下载用户头像和微博图片

由于获取图片从来是我的弱项,因此特地记录下方法

 

先建立一个被其它类调用的方法类:ShowImage()

package chj.weibo.imgutil;

import chj.weibo.app.WeiboApplication;
import android.graphics.Bitmap;
import android.widget.ImageView;

public class ShowImageLoader {

    public void showImg(ImageView view,String url){
        view.setTag(url);
        
        view.setImageBitmap(WeiboApplication.loader.get(url, getCallback(view,url)));
    }
    
    private static ImageLoaderCallback getCallback(final ImageView view,String url){
        
        return new ImageLoaderCallback() {
            
            @Override
            public void refresh(String url, Bitmap bmp) {
                if(url.equals(view.getTag().toString())){
                    view.setImageBitmap(bmp);
                }
            }
        };
    }
}

 

然后建立一个ImageLoader:

package chj.weibo.imgutil;

import java.lang.Thread.State;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

import chj.weibo.app.WeiboApplication;

import android.graphics.Bitmap;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;

public class LazyImgLoader {

    public static final int SUCCESS_DOWM = 1;
    public static final String IMG_URL="img_url";
    public static final String IMG = "img";
    
    private ImageManager imgManager = new ImageManager(WeiboApplication.context);
    
    private BlockingQueue<String> urlQueue = new ArrayBlockingQueue<String>(20);
    
    private DownloadImgThread thread = new DownloadImgThread();
    
    private CallbackManager manager = new CallbackManager();
    
    public Bitmap get(String url,ImageLoaderCallback callback){
        try {
            Bitmap bmp = null;
            //首先从缓存获取
            if(imgManager.contains(url)){
                bmp = imgManager.getFromCache(url);
                return bmp;
            }
            else{
                manager.put(url, callback);
                //开始从网络下载
                startDownloadThread(url);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    
    private void startDownloadThread(String url) throws Exception{
        //从网络下载
        if(!urlQueue.contains(url)){
            //放入下载队伍
            urlQueue.put(url);
        }
        State s = thread.getState();
        if(s == State.NEW){
            thread.start();
        }
        //线程已经结束
        else if(s == State.TERMINATED){
            thread = new DownloadImgThread();
            thread.start();
        }
    }
    
    Handler handler = new Handler(){

        @Override
        public void handleMessage(Message msg) {
            switch(msg.what){
            case SUCCESS_DOWM:
                Bundle b = msg.getData();
                String url  = b.getString(IMG_URL);
                Bitmap bmp = b.getParcelable(IMG);
                manager.callback(url,bmp);
            }
        }
        
    };
    
    private class DownloadImgThread extends Thread{

        private boolean isRun = true;
        
        @Override
        public void run() {
            try {
                while(isRun){
                    String u = urlQueue.poll();
                    Bitmap bmp;
                    if(null == u){
                        //下载完毕
                        break;
                    }
                    if(imgManager.getFromFile(u) == null){
                        bmp = imgManager.downloadFromNet(u);
                    }
                    else{
                        bmp = imgManager.getFromFile(u);
                    }
                    
                    Message msg = handler.obtainMessage(SUCCESS_DOWM);
                    Bundle b = msg.getData();
                    b.putString(IMG_URL, u);
                    b.putParcelable(IMG, bmp);
                    handler.sendMessage(msg);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                isRun = false;
            }
        }
        
    }
    
}

 

ImageLoader会调用一下从缓存读取图片或者从互联网下载图片的方法,因此需要一个ImageManager的类:

package chj.weibo.imgutil;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.SoftReference;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

import chj.weibo.util.MD5Util;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;

public class ImageManager {

    private Context context;
    private Map<String, SoftReference<Bitmap>> imgCache ;

    public ImageManager(Context context) {
        this.context = context;
        imgCache = new HashMap<String, SoftReference<Bitmap>>(20);
    }
    
    public boolean contains(String url){
        return imgCache.containsKey(url);
    }
    
    /**
     * 从缓存获取图片
     * @param url
     * @return
     */
    public Bitmap getFromCache(String url){
        Bitmap bmp = null;
        //先从缓存读取
        bmp = this.getFromMap(url);
        if(null == bmp){
            //从文件读取
            bmp = this.getFromFile(url);
            imgCache.put(url, new SoftReference<Bitmap>(bmp));
        }
        return bmp;
    }
    
    /**
     * 从文件读取图片
     * @param url
     * @return
     */
    public Bitmap getFromFile(String url){
        Bitmap bmp = null;
        InputStream is = null;
        String fileName = MD5Util.getMD5String(url);
        try {
            is = context.openFileInput(fileName);
            if(null != is){
                bmp = BitmapFactory.decodeStream(is);
                return bmp;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }finally{
            try {
                if(is != null){
                    is.close();
                    is = null;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    
    /**
     * 从Map读取图片
     * @param url
     * @return
     */
    public Bitmap getFromMap(String url){
        Bitmap bmp = null;
        SoftReference<Bitmap> ref = null;
        
        synchronized (this) {
            ref = imgCache.get(url);
        }
        if(null != ref){
            bmp = ref.get();
        }
        return bmp;
    }
    
    /**
     * 从网络下载图片并把他放入文件系统中
     * @param url
     * @return
     */
    public Bitmap downloadFromNet(String url){
        if(url == null || "".equals(url)){
            return null;
        }
        
        try {
            URL u = new URL(url);
            HttpURLConnection conn =  (HttpURLConnection)u.openConnection();
            String fileName = writeToFile(url, conn.getInputStream());
            return BitmapFactory.decodeFile(fileName);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    
    //将图片写入文件系统
    private String writeToFile(String fileName,InputStream is){
        BufferedOutputStream bos = null;
        BufferedInputStream bis = null;
        byte[] buff = new byte[1024];
        int length = 0;
        String fileNameMD5 = null;
        try {
            fileNameMD5 = MD5Util.getMD5String(fileName);
            bis = new BufferedInputStream(is);
            bos = new BufferedOutputStream(context.openFileOutput(fileNameMD5, Context.MODE_PRIVATE));
            while((length = bis.read(buff)) != -1){
                bos.write(buff, 0, length);
            }
        } catch (Exception e) {
            return null;
        }
        finally{
            try {
                if(null != is){
                    is.close();
                    is = null;
                }
                if(null != bis){
                    bis.close();
                    bis = null;
                }
                if(null != bos){
                    bos.flush();
                    bos.close();
                    bos = null;
                }
            } catch (Exception e2) {}
        }
        
        return context.getFilesDir() + "/" + fileNameMD5;
    }
}

 

然后需要一个接口做图片回调用:ImageLoaderCallback:

package chj.weibo.imgutil;

import android.graphics.Bitmap;


public interface ImageLoaderCallback {

    public void refresh(String url,Bitmap bmp);
    
}

 

最后需要一个CallbackManager:

package chj.weibo.imgutil;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

import android.graphics.Bitmap;


public class CallbackManager {

    private ConcurrentHashMap<String, List<ImageLoaderCallback>> maps;
    
    public CallbackManager() {
        maps = new ConcurrentHashMap<String, List<ImageLoaderCallback>>();
    }

    public void put(String url,ImageLoaderCallback cb){
        if(!maps.contains(url)){
            maps.put(url, new ArrayList<ImageLoaderCallback>());
        }
        maps.get(url).add(cb);
    }

    public void callback(String url,Bitmap bmp){
        List<ImageLoaderCallback> callback = maps.get(url);
        if(null == callback){
            return;
        }
        for (ImageLoaderCallback c : callback) {
            c.refresh(url, bmp);
        }
    }
}

 

然后直接在需要使用的类中调用showImage即可.

由于Android的openfileoutput和input传入的字符串不可带有分隔符,因此另外需要一个类用于加密,这里采用MD5加密算法:

package chj.weibo.util;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class MD5Util {

    /**
     * 16进制字符集
     */
    private static final char HEX_DIGITS[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
 
    /**
     * 指定算法为MD5的MessageDigest
     */
    private static MessageDigest messageDigest = null;
 
    /**
     * 初始化messageDigest的加密算法为MD5
     */
    static
    {
        try
        {
            messageDigest = MessageDigest.getInstance("MD5");
        }
        catch(NoSuchAlgorithmException e)
        {
            e.printStackTrace();
        }
    }
 
    
    /**
     * MD5加密字符串
     * @param str 目标字符串
     * @return MD5加密后的字符串
     */
    public static String getMD5String(String str)
    {
        return getMD5String(str.getBytes());
    }
 
    /**
     * MD5加密以byte数组表示的字符串
     * @param bytes 目标byte数组
     * @return MD5加密后的字符串
     */
    public static String getMD5String(byte[] bytes)
    {
        messageDigest.update(bytes);
        return bytesToHex(messageDigest.digest());
    }
     
   
 
 
    /**
     * 将字节数组转换成16进制字符串
     * @param bytes 目标字节数组
     * @return 转换结果
     */
    public static String bytesToHex(byte bytes[])
    {
        return bytesToHex(bytes, 0, bytes.length);
    }
 
    /**
     * 将字节数组中指定区间的子数组转换成16进制字符串
     * @param bytes 目标字节数组
     * @param start 起始位置（包括该位置）
     * @param end 结束位置（不包括该位置）
     * @return 转换结果
     */
    public static String bytesToHex(byte bytes[], int start, int end)
    {
        StringBuilder sb = new StringBuilder();
 
        for(int i = start; i < start + end; i++)
        {
            sb.append(byteToHex(bytes[i]));
        }
 
        return sb.toString();
    }
 
    /**
     * 将单个字节码转换成16进制字符串
     * @param bt 目标字节
     * @return 转换结果
     */
    public static String byteToHex(byte bt)
    {
        return HEX_DIGITS[(bt & 0xf0) >> 4] + "" + HEX_DIGITS[bt & 0xf];
    }
 
 
 

}