点击获取网络大图(支持缩放)

项目需要写一个点击查看大图的功能，需要查看大图 然后支持缩放，废话不多说 直接贴代码
这个是点击小图的时候跳转的代码
//存取网络图片名字地址集合 需要和下面baseurl一块才是完整图片路径
private ArrayList pics = new ArrayList();
//当前点击的图片位置 下标
private int index；
//当前点击的图片前缀
private int baseurl；
//BrowsPictureActivity是显示大图的activity
Intent intent = new Intent(mContext, BrowsPictureActivity.class);
Bundle bundle = new Bundle();
bundle.putStringArrayList(“Urls”, pics);
bundle.putInt(“index”, index);
bundle.putString(“baseurl”, baseurl);
intent.putExtra(“msg”, bundle);
mContext.startActivity(intent);

下面是显示大图的aitivity
/**
* 查看大图
*
*@author wangkui
*
*@version 1.0
*
*
*/
public class BrowsPictureActivity extends Activity implements
OnPageChangeListener {

private ViewPager mVp;
private Bundle bundle;
private BrowsePictureAdapter adapter;
private Button closeBtn;
private List<UrlTouchImageView> viewList;
private ArrayList<String> urls;
protected ImageLoader imageLoader = ImageLoader.getInstance();
private TextView picNumTv;
private String baseurl;
private List<UrlTouchImageView> viewList = new  ArrayList<UrlTouchImageView> viewList（）;
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    this.requestWindowFeature(Window.FEATURE_NO_TITLE);// 隐藏标题栏
    setContentView(R.layout.layout_pic);
    mVp = (ViewPager) findViewById(R.id.vp);
    closeBtn = (Button) findViewById(R.id.close_btn);
    picNumTv = (TextView) findViewById(R.id.picnum_tv);
    closeBtn.setOnClickListener(new OnClickListener() {

        @Override
        public void onClick(View arg0) {
            finish();
        }
    });

    viewList = new ArrayList<UrlTouchImageView>();
    Intent intent = getIntent();
    if (intent != null) {
        bundle = intent.getBundleExtra("msg");
        urls = bundle.getStringArrayList("Urls");
        baseurl = bundle.getString("baseurl");
        for (int i = 0; i < urls.size(); i++) {
        //如果不需要支持缩放直接用Imageview

// ImageView iv = new ImageView(this);
final UrlTouchImageView iv = new UrlTouchImageView(this);
LayoutParams params = new LayoutParams(
LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
iv.setLayoutParams(params);
iv.setScaleType(ScaleType.FIT_CENTER);
iv.getImageView().setImageResource(R.drawable.ic_launcher);

            iv.setUrl(baseurl+urls.get(i));
            viewList.add(iv);
        }
        adapter = new BrowsePictureAdapter(viewList);
        // getInternetData();

        mVp.setAdapter(adapter);
        int index = bundle.getInt("index", 1);
        mVp.setCurrentItem(index);
        picNumTv.setText(String.valueOf(index + 1) + "/" + urls.size());
        mVp.setOnPageChangeListener(this);

    }
}

@Override
public void onPageScrollStateChanged(int arg0) {
    // TODO Auto-generated method stub
}

@Override
public void onPageScrolled(int arg0, float arg1, int arg2) {
    // TODO Auto-generated method stub
}

//显示图片下面当前是第几张图
@Override
public void onPageSelected(int arg0) {
picNumTv.setText((arg0 + 1) + “/” + urls.size());
}
}

//下面是图片适配器
public class BrowsePictureAdapter extends PagerAdapter {

private List<UrlTouchImageView> mList;

public BrowsePictureAdapter(List<UrlTouchImageView> list) {
    this.mList = list;
}

public void setData(List<UrlTouchImageView> list) {
    this.mList = list;
    notifyDataSetChanged();
}

@Override
public int getCount() {
    return mList != null ? mList.size() : 0;
}

@Override
public Object instantiateItem(ViewGroup container, int position) {
    container.addView(mList.get(position % mList.size()));

    return mList.get(position % mList.size());
}

@Override
public boolean isViewFromObject(View view, Object obj) {
    return view == obj;
}

@Override
public void destroyItem(ViewGroup container, int position, Object object) {
    container.removeView(mList.get(position % mList.size()));
}

}

//这个是自定义RelativeLayout 初始化就加载自定义imageview
public class UrlTouchImageView extends RelativeLayout {
protected ProgressBar mProgressBar;
protected TouchImageView mImageView;

protected Context mContext;

public UrlTouchImageView(Context ctx)
{
    super(ctx);
    mContext = ctx;
    init();

}
public UrlTouchImageView(Context ctx, AttributeSet attrs)
{
    super(ctx, attrs);
    mContext = ctx;
    init();
}
public TouchImageView getImageView() { return mImageView; }

@SuppressWarnings("deprecation")
protected void init() {
    mImageView = new TouchImageView(mContext);
    LayoutParams params = new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);
    mImageView.setLayoutParams(params);
    this.addView(mImageView);
    mImageView.setVisibility(GONE);

    mProgressBar = new ProgressBar(mContext, null, android.R.attr.progressBarStyleInverse);
    params = new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.WRAP_CONTENT);
    params.addRule(RelativeLayout.CENTER_VERTICAL);
    params.setMargins(30, 0, 30, 0);
    mProgressBar.setLayoutParams(params);
    mProgressBar.setIndeterminate(false);
    mProgressBar.setMax(100);
    this.addView(mProgressBar);
}

public void setUrl(String imageUrl)
{
    new ImageLoadTask().execute(imageUrl);
}

public void setScaleType(ScaleType scaleType) {
    mImageView.setScaleType(scaleType);
}

//No caching load
public class ImageLoadTask extends AsyncTask<String, Integer, Bitmap>
{
    @Override
    protected Bitmap doInBackground(String... strings) {
        String url = strings[0];
        Bitmap bm = null;
        try {
            URL aURL = new URL(url);
            URLConnection conn = aURL.openConnection();
            conn.connect();
            InputStream is = conn.getInputStream();
            int totalLen = conn.getContentLength();
            InputStreamWrapper bis = new InputStreamWrapper(is, 8192, totalLen);
            bis.setProgressListener(new InputStreamProgressListener() {
                @Override
                public void onProgress(float progressValue, long bytesLoaded,
                        long bytesTotal) {
                {
                    publishProgress((int)(progressValue * 100));
                }

                }
            });
            bm = BitmapFactory.decodeStream(bis);
            bis.close();
            is.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bm;
    }

    @Override
    protected void onPostExecute(Bitmap bitmap) {
        if (bitmap == null) 
        {
            mImageView.setScaleType(ScaleType.CENTER);
            bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.default_image);
            mImageView.setImageBitmap(bitmap);
        }
        else 
        {
            mImageView.setScaleType(ScaleType.MATRIX);
            mImageView.setImageBitmap(bitmap);
        }
        mImageView.setVisibility(VISIBLE);
        mProgressBar.setVisibility(GONE);
    }

    @Override
    protected void onProgressUpdate(Integer... values)
    {
        mProgressBar.setProgress(values[0]);
    }
}

}
//支持缩放视图
public class TouchImageView extends ImageView {

private int positionForTouchImageView = -1;

// private static final String TAG = "Touch";
// These matrices will be used to move and zoom image
Matrix matrix = new Matrix();
Matrix savedMatrix = new Matrix();

static final long DOUBLE_PRESS_INTERVAL = 600;
static final float FRICTION = 0.9f;

// We can be in one of these 4 states
static final int NONE = 0;
static final int DRAG = 1;
static final int ZOOM = 2;
static final int CLICK = 10;
int mode = NONE;

float redundantXSpace, redundantYSpace;
float right, bottom, origWidth, origHeight, bmWidth, bmHeight;
float width, height;
PointF last = new PointF();
PointF mid = new PointF();
PointF start = new PointF();
float[] m;
float matrixX, matrixY;

float saveScale = 1f;
float minScale = 1f;
float maxScale = 3f;
float oldDist = 1f;

PointF lastDelta = new PointF(0, 0);
float velocity = 0;

long lastPressTime = 0, lastDragTime = 0;
boolean allowInert = false;

private Context mContext;
private Timer mClickTimer;
private OnClickListener mOnClickListener;
private Object mScaleDetector;
private Handler mTimerHandler = null;

// Scale mode on DoubleTap
private boolean zoomToOriginalSize = false;

public boolean isZoomToOriginalSize() {
    return  this.zoomToOriginalSize;
}

public void setZoomToOriginalSize(boolean zoomToOriginalSize) {
    this.zoomToOriginalSize = zoomToOriginalSize;
}    

public boolean onLeftSide = false, onTopSide = false, onRightSide = false, onBottomSide = false;

public TouchImageView(Context context) {
    super(context);
    super.setClickable(true);
    this.mContext = context;

    init();
}
public TouchImageView(Context context, AttributeSet attrs)
{
    super(context, attrs);
    super.setClickable(true);
    this.mContext = context;

    init();
}

protected void init()
{
    mTimerHandler = new TimeHandler(this);
    matrix.setTranslate(1f, 1f);
    m = new float[9];
    setImageMatrix(matrix);
    setScaleType(ScaleType.MATRIX);
    if (Build.VERSION.SDK_INT >= 8)
    {
        mScaleDetector = new ScaleGestureDetector(mContext, new ScaleListener());
    }
    setOnTouchListener(new OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent rawEvent) {
            WrapMotionEvent event = WrapMotionEvent.wrap(rawEvent);
            if (mScaleDetector != null)
            {
                 ((ScaleGestureDetector)mScaleDetector).onTouchEvent(rawEvent);
            }
            fillMatrixXY();
            PointF curr = new PointF(event.getX(), event.getY());

            switch (event.getAction() & MotionEvent.ACTION_MASK) {
                case MotionEvent.ACTION_DOWN:
                    allowInert = false;
                    savedMatrix.set(matrix);
                    last.set(event.getX(), event.getY());
                    start.set(last);
                    mode = DRAG;

                    break;
                case MotionEvent.ACTION_POINTER_DOWN:
                    oldDist = spacing(event);
                    //Log.d(TAG, "oldDist=" + oldDist);
                    if (oldDist > 10f) {
                        savedMatrix.set(matrix);
                        midPoint(mid, event);
                        mode = ZOOM;
                        //Log.d(TAG, "mode=ZOOM");
                    }
                    break;
                case MotionEvent.ACTION_UP:
                    allowInert = true;
                    mode = NONE;
                    int xDiff = (int) Math.abs(event.getX() - start.x);
                    int yDiff = (int) Math.abs(event.getY() - start.y);

                    if (xDiff < CLICK && yDiff < CLICK) {


                        //Perform scale on double click
                        long pressTime = System.currentTimeMillis();
                        if (pressTime - lastPressTime <= DOUBLE_PRESS_INTERVAL) {
                            if (mClickTimer != null) mClickTimer.cancel();
                            if (saveScale == 1)
                            {
                                final float targetScale = maxScale / saveScale;
                                matrix.postScale(targetScale, targetScale, start.x, start.y);
                                saveScale = maxScale;
                            }
                            else
                            {
                                matrix.postScale(minScale / saveScale, minScale / saveScale, width / 2, height / 2);
                                saveScale = minScale;
                            }
                            calcPadding();
                            checkAndSetTranslate(0, 0);
                            lastPressTime = 0;
                        }
                        else {
                            lastPressTime = pressTime;
                            mClickTimer = new Timer();
                            mClickTimer.schedule(new Task(), 300);
                        }
                        if (saveScale == minScale) {
                            scaleMatrixToBounds();
                        }
                    }

                    break;

                case MotionEvent.ACTION_POINTER_UP:
                    mode = NONE;
                    velocity = 0;
                    savedMatrix.set(matrix);
                    oldDist = spacing(event);
                    //Log.d(TAG, "mode=NONE");
                    break;

                case MotionEvent.ACTION_MOVE:
                    allowInert = false;
                    if (mode == DRAG) {
                        float deltaX = curr.x - last.x;
                        float deltaY = curr.y - last.y;

                        long dragTime = System.currentTimeMillis();

                        velocity = (float)distanceBetween(curr, last) / (dragTime - lastDragTime) * FRICTION;
                        lastDragTime = dragTime;

                        checkAndSetTranslate(deltaX, deltaY);
                        lastDelta.set(deltaX, deltaY);
                        last.set(curr.x, curr.y);
                    }
                    else if (mScaleDetector == null && mode == ZOOM) {
                        float newDist = spacing(event);
                        if (rawEvent.getPointerCount() < 2) break;
                        //There is one serious trouble: when you scaling with two fingers, then pick up first finger of gesture, ACTION_MOVE being called.
                        //Magic number 50 for this case
                        if (10 > Math.abs(oldDist - newDist) || Math.abs(oldDist - newDist) > 50) break;
                        float mScaleFactor = newDist / oldDist;
                        oldDist = newDist;

                        float origScale = saveScale;
                        saveScale *= mScaleFactor;
                        if (saveScale > maxScale) {
                            saveScale = maxScale;
                            mScaleFactor = maxScale / origScale;
                        } else if (saveScale < minScale) {
                            saveScale = minScale;
                            mScaleFactor = minScale / origScale;
                        }

                        calcPadding();
                        if (origWidth * saveScale <= width || origHeight * saveScale <= height) {
                            matrix.postScale(mScaleFactor, mScaleFactor, width / 2, height / 2);
                            if (mScaleFactor < 1) {
                                fillMatrixXY();
                                if (mScaleFactor < 1) {
                                    scaleMatrixToBounds();
                                }
                            }
                        } else {
                            PointF mid = midPointF(event);
                            matrix.postScale(mScaleFactor, mScaleFactor, mid.x, mid.y);
                            fillMatrixXY();
                            if (mScaleFactor < 1) {
                                if (matrixX < -right)
                                    matrix.postTranslate(-(matrixX + right), 0);
                                else if (matrixX > 0)
                                    matrix.postTranslate(-matrixX, 0);
                                if (matrixY < -bottom)
                                    matrix.postTranslate(0, -(matrixY + bottom));
                                else if (matrixY > 0)
                                    matrix.postTranslate(0, -matrixY);
                            }
                        }
                        checkSiding();
                    }
                    break;
            }

            setImageMatrix(matrix);
            invalidate();
            return false;
        }
    });
}
public void resetScale()
{
    fillMatrixXY();
    matrix.postScale(minScale / saveScale, minScale / saveScale, width / 2, height / 2);
    saveScale = minScale;

    calcPadding();
    checkAndSetTranslate(0, 0);

    scaleMatrixToBounds();

    setImageMatrix(matrix);
    invalidate();
}
public boolean pagerCanScroll()
{
    if (mode != NONE) return false;
    return saveScale == minScale;
}

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    if (!allowInert) return;
    final float deltaX = lastDelta.x * velocity, deltaY = lastDelta.y * velocity;
    if (deltaX > width || deltaY > height)
    {
        return;
    }
    velocity *= FRICTION;
    if (Math.abs(deltaX) < 0.1 && Math.abs(deltaY) < 0.1) return;
    checkAndSetTranslate(deltaX, deltaY);
    setImageMatrix(matrix);
}

private void checkAndSetTranslate(float deltaX, float deltaY)
{
    float scaleWidth = Math.round(origWidth * saveScale);
    float scaleHeight = Math.round(origHeight * saveScale);
    fillMatrixXY();
    if (scaleWidth < width) {
        deltaX = 0;
        if (matrixY + deltaY > 0)
            deltaY = -matrixY;
        else if (matrixY + deltaY < -bottom)
            deltaY = -(matrixY + bottom);
    } else if (scaleHeight < height) {
        deltaY = 0;
        if (matrixX + deltaX > 0)
            deltaX = -matrixX;
        else if (matrixX + deltaX < -right)
            deltaX = -(matrixX + right);
    }
    else {
        if (matrixX + deltaX > 0)
            deltaX = -matrixX;
        else if (matrixX + deltaX < -right)
            deltaX = -(matrixX + right);

        if (matrixY + deltaY > 0)
            deltaY = -matrixY;
        else if (matrixY + deltaY < -bottom)
            deltaY = -(matrixY + bottom);
    }
    matrix.postTranslate(deltaX, deltaY);
    checkSiding();
}
private void checkSiding()
{
    fillMatrixXY();
    //Log.d(TAG, "x: " + matrixX + " y: " + matrixY + " left: " + right / 2 + " top:" + bottom / 2);
    float scaleWidth = Math.round(origWidth * saveScale);
    float scaleHeight = Math.round(origHeight * saveScale);
    onLeftSide = onRightSide = onTopSide = onBottomSide = false;
    if (-matrixX < 10.0f ) onLeftSide = true;
    //Log.d("GalleryViewPager", String.format("ScaleW: %f; W: %f, MatrixX: %f", scaleWidth, width, matrixX));
    if ((scaleWidth >= width && (matrixX + scaleWidth - width) < 10) ||
        (scaleWidth <= width && -matrixX + scaleWidth <= width)) onRightSide = true;
    if (-matrixY < 10.0f) onTopSide = true;
    if (Math.abs(-matrixY + height - scaleHeight) < 10.0f) onBottomSide = true;
}
private void calcPadding()
{
    right = width * saveScale - width - (2 * redundantXSpace * saveScale);
    bottom = height * saveScale - height - (2 * redundantYSpace * saveScale);
}
private void fillMatrixXY()
{
    matrix.getValues(m);
    matrixX = m[Matrix.MTRANS_X];
    matrixY = m[Matrix.MTRANS_Y];
}
private void scaleMatrixToBounds()
{
    if (Math.abs(matrixX + right / 2) > 0.5f)
        matrix.postTranslate(-(matrixX + right / 2), 0);
    if (Math.abs(matrixY + bottom / 2) > 0.5f)
        matrix.postTranslate(0, -(matrixY + bottom / 2));
}
@Override
public void setImageBitmap(Bitmap bm) {
    super.setImageBitmap(bm);
    bmWidth = bm.getWidth();
    bmHeight = bm.getHeight();
}
@Override
protected void onMeasure (int widthMeasureSpec, int heightMeasureSpec)
{
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    width = MeasureSpec.getSize(widthMeasureSpec);
    height = MeasureSpec.getSize(heightMeasureSpec);
    //Fit to screen.
    float scale;
    float scaleX =  width / bmWidth;
    float scaleY = height / bmHeight;
    scale = Math.min(scaleX, scaleY);
    matrix.setScale(scale, scale);
    //minScale = scale;
    setImageMatrix(matrix);
    saveScale = 1f;

    // Center the image
    redundantYSpace = height - (scale * bmHeight) ;
    redundantXSpace = width - (scale * bmWidth);
    redundantYSpace /= (float)2;
    redundantXSpace /= (float)2;

    matrix.postTranslate(redundantXSpace, redundantYSpace);

    origWidth = width - 2 * redundantXSpace;
    origHeight = height - 2 * redundantYSpace;
    calcPadding();
    setImageMatrix(matrix);
}

private double distanceBetween(PointF left, PointF right)
{
    return Math.sqrt(Math.pow(left.x - right.x, 2) + Math.pow(left.y - right.y, 2));
}
/** Determine the space between the first two fingers */
private float spacing(WrapMotionEvent event) {
    // ...
    float x = event.getX(0) - event.getX(1);
    float y = event.getY(0) - event.getY(1);
    return FloatMath.sqrt(x * x + y * y);
}

/** Calculate the mid point of the first two fingers */
private void midPoint(PointF point, WrapMotionEvent event) {
    // ...
    float x = event.getX(0) + event.getX(1);
    float y = event.getY(0) + event.getY(1);
    point.set(x / 2, y / 2);
}
private PointF midPointF(WrapMotionEvent event) {
    // ...
    float x = event.getX(0) + event.getX(1);
    float y = event.getY(0) + event.getY(1);
    return new PointF(x / 2, y / 2);
}

@Override
public void setOnClickListener(OnClickListener l) {
    mOnClickListener = l;
}


private class Task extends TimerTask {
    public void run() {
        mTimerHandler.sendEmptyMessage(0);
    }
}

private class ScaleListener extends ScaleGestureDetector.SimpleOnScaleGestureListener {
    @Override
    public boolean onScaleBegin(ScaleGestureDetector detector) {
        mode = ZOOM;
        return true;
    }

    @Override
    public boolean onScale(ScaleGestureDetector detector) {
        float mScaleFactor = (float)Math.min(Math.max(.95f, detector.getScaleFactor()), 1.05);
        float origScale = saveScale;
        saveScale *= mScaleFactor;
        if (saveScale > maxScale) {
            saveScale = maxScale;
            mScaleFactor = maxScale / origScale;
        } else if (saveScale < minScale) {
            saveScale = minScale;
            mScaleFactor = minScale / origScale;
        }
        right = width * saveScale - width - (2 * redundantXSpace * saveScale);
        bottom = height * saveScale - height - (2 * redundantYSpace * saveScale);
        if (origWidth * saveScale <= width || origHeight * saveScale <= height) {
            matrix.postScale(mScaleFactor, mScaleFactor, width / 2, height / 2);
            if (mScaleFactor < 1) {
                matrix.getValues(m);
                float x = m[Matrix.MTRANS_X];
                float y = m[Matrix.MTRANS_Y];
                if (mScaleFactor < 1) {
                    if (Math.round(origWidth * saveScale) < width) {
                        if (y < -bottom)
                            matrix.postTranslate(0, -(y + bottom));
                        else if (y > 0)
                            matrix.postTranslate(0, -y);
                    } else {
                        if (x < -right)
                            matrix.postTranslate(-(x + right), 0);
                        else if (x > 0)
                            matrix.postTranslate(-x, 0);
                    }
                }
            }
        } else {
            matrix.postScale(mScaleFactor, mScaleFactor, detector.getFocusX(), detector.getFocusY());
            matrix.getValues(m);
            float x = m[Matrix.MTRANS_X];
            float y = m[Matrix.MTRANS_Y];
            if (mScaleFactor < 1) {
                if (x < -right)
                    matrix.postTranslate(-(x + right), 0);
                else if (x > 0)
                    matrix.postTranslate(-x, 0);
                if (y < -bottom)
                    matrix.postTranslate(0, -(y + bottom));
                else if (y > 0)
                    matrix.postTranslate(0, -y);
            }
        }
        return true;

    }
}
static class TimeHandler extends Handler {
    private final WeakReference<TouchImageView> mService; 

    TimeHandler(TouchImageView view) {
        mService = new WeakReference<TouchImageView>(view);

    }
    @Override
    public void handleMessage(Message msg)
    {
        mService.get().performClick();
        if (mService.get().mOnClickListener != null) mService.get().mOnClickListener.onClick(mService.get());
    }
}

};
//点击监听方法

package com.heheys.ec.view;

import android.view.MotionEvent;

public class EclairMotionEvent extends WrapMotionEvent {

protected EclairMotionEvent(MotionEvent event) {
    super(event);
}

public float getX(int pointerIndex) {
    return event.getX(pointerIndex);
}

public float getY(int pointerIndex) {
    return event.getY(pointerIndex);
}

public int getPointerCount() {
    return event.getPointerCount();
}

public int getPointerId(int pointerIndex) {
    return event.getPointerId(pointerIndex);
}

}

//点击监听方法

public class WrapMotionEvent {

protected MotionEvent event;
protected WrapMotionEvent(MotionEvent event) {
    this.event = event;
}

static public WrapMotionEvent wrap(MotionEvent event) {
    try {
        return new EclairMotionEvent(event);
    } catch (VerifyError e) {
        return new WrapMotionEvent(event);
    }
}



public int getAction() {
    return event.getAction();
}

public float getX() {
    return event.getX();
}

public float getX(int pointerIndex) {
    verifyPointerIndex(pointerIndex);
    return getX();
}

public float getY() {
    return event.getY();
}

public float getY(int pointerIndex) {
    verifyPointerIndex(pointerIndex);
    return getY();
}

public int getPointerCount() {
    return 1;
}

public int getPointerId(int pointerIndex) {
    verifyPointerIndex(pointerIndex);
    return 0;
}

private void verifyPointerIndex(int pointerIndex) {
    if (pointerIndex > 0) {
        throw new IllegalArgumentException(
                "Invalid pointer index for Donut/Cupcake");
    }
}

}

//读取图片流的方法
public class InputStreamWrapper extends BufferedInputStream
{
protected long mContentLen, mBytesLoaded;
protected InputStreamProgressListener mProgressListener;
public InputStreamWrapper(InputStream in, int size, long contentLen)
{
super(in, size);
mContentLen = contentLen;
mBytesLoaded = 0;
}
@Override
public synchronized int read(byte[] buffer, int offset, int byteCount)
throws IOException
{
mBytesLoaded += byteCount;
if (mProgressListener != null)
{
mProgressListener.onProgress(mBytesLoaded * 1.0f / mContentLen, mBytesLoaded, mContentLen);
}
return super.read(buffer, offset, byteCount);
}
public void setProgressListener(InputStreamProgressListener listener)
{
mProgressListener = listener;
}
public static interface InputStreamProgressListener
{
public void onProgress(float progressValue, long bytesLoaded, long bytesTotal);
}
}
//layout_pic.xml文件

<android.support.v4.view.ViewPager
    android:id="@+id/vp"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_alignParentLeft="true"
    android:layout_alignParentTop="true"
    android:background="@color/black" >
</android.support.v4.view.ViewPager>

<Button
    android:id="@+id/close_btn"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_marginRight="20dp"
    android:layout_marginTop="20dp"
    android:layout_alignParentRight="true"
    android:layout_alignParentTop="true"
    android:background="#00000000"
    android:text="关闭"
    android:textColor="@color/white" />

<TextView
    android:id="@+id/picnum_tv"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_alignParentBottom="true"
    android:layout_centerHorizontal="true"
    android:layout_marginBottom="15dp"
    android:textColor="#ffffff"
    android:textSize="15sp" />

至此一个完整的查看大图工具类就可以使用了 其中部分代码参考了别人的代码
有不明白的可以留言wangkui20090909@sina.com