Android--自定义View加载网络图片,实现缩放，圆形剪裁

功能：加载网络图片，本地资源图片，圆形剪裁，图片自动缩放

package com.example.administrator.myapplication;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Rect;
import android.os.Handler;
import android.os.Message;
import android.support.annotation.Nullable;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.View;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by Administrator on 2017/6/28.
 */

public class HeadView extends View {
    private static final int SUCCESS = 101;
    private static final int FAILED = 102;
    private String fileName;
    private Bitmap img;
    private boolean makeCircle = false;
    private Paint paint = new Paint();
    private Rect src = new Rect();
    private Rect dst = new Rect();
    private Path path = new Path();
    private static ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

    private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case SUCCESS:
                    invalidate();
                    if (loadListener != null) {
                        loadListener.onSuccess();
                    }
                    saveBitmap(fileName);
                    break;
                case FAILED:
                    L.e("加载失败！");
                    if (loadListener != null) {
                        loadListener.onFailed();
                    }
                    break;
                default:break;
            }
        }
    };

    public HeadView(Context context) {
        super(context);
        init();
    }

    public HeadView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public void init() {
        paint.setAntiAlias(true);
        paint.setStrokeWidth(40);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
        int width = MeasureSpec.getSize(widthMeasureSpec);
        int height = MeasureSpec.getSize(heightMeasureSpec);
        int w,h;
        if (widthMode == MeasureSpec.EXACTLY) {
            w = width;
        } else {
            w = 200;
        }
        if (heightMode == MeasureSpec.EXACTLY) {
            h = height;
        } else {
            h = 200;
        }
        setMeasuredDimension(w,h);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        if (img != null) {
            int width = getWidth();
            int height = getHeight();
            int w = img.getWidth();
            int h = img.getHeight();

            if (makeCircle) {
                int x = width >> 1;
                int y = height >> 1;
                int radius = (width < height? width : height) >> 1;
                path.addCircle(x, y, radius, Path.Direction.CW);
                canvas.clipPath(path);
                dst.set(x -radius, y - radius, x + radius, y + radius);

                radius = (w < h? w : h) >> 1;
                x = w >> 1;
                y = h >> 1;
                src.set(x -radius, y - radius, x + radius , y + radius);
                canvas.drawBitmap(img, src, dst, paint);
                return;
            }

            float scale;
            if (w < width && h < height) {
                scale = 1.1f;
                while (w * scale < width && h * scale < height) {
                    w *= scale;
                    h *= scale;
                }
            } else {
                scale = 0.9f;
                while (w > width || h > height) {
                    w *= scale;
                    h *= scale;
                }
            }
            int left = (width - w) >> 1;
            int top = (height - h) >> 1;
            int right = width - left;
            int bottom = height - top;
            dst.set(left, top, right, bottom);
            canvas.drawBitmap(img, null, dst, paint);
        }
    }

    @Override
    protected void onDetachedFromWindow() {
        L.e("onDetachedFromWindow start");
        if (img != null) {
            img.recycle();
        }
        if (handler != null) {
            handler.removeCallbacksAndMessages(null);
        }
        L.e("onDetachedFromWindow end");
        super.onDetachedFromWindow();
    }

    public void setImageFromNet(final String url) {
        fixedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                InputStream bis = null;
                ByteArrayOutputStream bos = null;
                try {
                    URL address = new URL(url);
                    HttpURLConnection conn = (HttpURLConnection) address.openConnection();
                    conn.connect();
                    int responseCode = conn.getResponseCode();
                    if (responseCode == 200) {
                        bis = conn.getInputStream();
                        bos = new ByteArrayOutputStream();
                        int len;
                        byte[] array = new byte[4096];
                        while ((len = bis.read(array)) != - 1) {
                            bos.write(array, 0, len);
                        }
                        fileName = subUrlForName(url);
                        byte[] data = bos.toByteArray();
                        img = BitmapFactory.decodeByteArray(data, 0, data.length);
                        conn.disconnect();
                        bis.close();
                        bos.close();
                        handler.sendEmptyMessage(SUCCESS);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    handler.sendEmptyMessage(FAILED);
                    if (bis != null) {
                        try {
                            bis.close();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                    }
                    if (bos != null) {
                        try {
                            bos.close();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                    }
                }
            }
        });
    }

    public void saveBitmap(String name) {
        FileOutputStream fos = null;
        if (img != null) {
            try {
                fos = new FileOutputStream(getContext().getFileStreamPath(name));
                img.compress(Bitmap.CompressFormat.PNG, 100, fos);
                fos.close();
            } catch (Exception e) {
                e.printStackTrace();
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e1) {
                        e1.printStackTrace();
                    }
                }
            }
        }
    }

    private String subUrlForName(String url) {
        if (!TextUtils.isEmpty(url)) {
            return url.substring(url.lastIndexOf("/")+1, url.length());
        } else {
            return "";
        }
    }

    public void setImage(String url) {
        if (!TextUtils.isEmpty(url)) {
            String name = subUrlForName(url);
            File file = getContext().getFileStreamPath(name);
            if (file.exists()) {
                L.e("second cache");
                if (img != null) {
                    img.recycle();
                }
                img = BitmapFactory.decodeFile(getContext().getFileStreamPath(name).getAbsolutePath());
                invalidate();
                handler.sendEmptyMessage(SUCCESS);
            } else {
                L.e("third cache");
                setImageFromNet(url);
            }
        }
    }

    public void setImg(int id) {
        img = BitmapFactory.decodeResource(getResources(), id);
        invalidate();
    }

    public void setCircleImage() {
        makeCircle = true;
        path = new Path();
        invalidate();
    }

    private LoadListener loadListener;

    public interface LoadListener {
        void onSuccess();
        void onFailed();
    }

    public void setLoadListener(LoadListener loadListener) {
        this.loadListener = loadListener;
    }
}