PS:最后一篇关于Volley框架的博客...
学习内容：
1.使用ImageRequest.java实现网络图片加载
2.使用ImageLoader.java实现网络图片加载
3.使用NetWorkImageView.java实现网络图片加载
Volley的第三个作用就是实现网络图片的加载，图片加载在Volley中有三种不同的方式，各有各的用法，只是后两个还算是有相关联系的，因为NetWorkImageView是基于ImageLoader的..内部的图片加载还是使用ImageLoader，只是在后续的过程中有一些不同...
1.ImageRequest.java
使用ImageRequest加载图片数据，ImageRequest没有什么特殊的，也需要建立一个请求队列，向请求队列当中添加这次请求就可以完成图片数据的加载...
package com.android.volley.toolbox; import com.android.volley.DefaultRetryPolicy;
import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.VolleyLog; import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory; public class ImageRequest extends Request<Bitmap> {
/** Socket timeout in milliseconds for image requests */
private static final int IMAGE_TIMEOUT_MS = 1000; //超时时间的定义.. /** Default number of retries for image requests */
private static final int IMAGE_MAX_RETRIES = 2; //一次最多重试的图片数量... /** Default backoff multiplier for image requests */
private static final float IMAGE_BACKOFF_MULT = 2f; //后退请求的数量.. private final Response.Listener<Bitmap> mListener; //成功监听..
private final Config mDecodeConfig; //属性编码...
private final int mMaxWidth; //最大宽度...
private final int mMaxHeight; //最大高度... /** Decoding lock so that we don't decode more than one image at a time (to avoid OOM's) */
private static final Object sDecodeLock = new Object(); //一个编码锁..目的是一次只能对一个图片进行编码，加载，避免OOM的发生...
//指定url来创建一个ImageRequest请求...
public ImageRequest(String url, Response.Listener<Bitmap> listener, int maxWidth, int maxHeight,
Config decodeConfig, Response.ErrorListener errorListener) {
super(Method.GET, url, errorListener);
setRetryPolicy(
new DefaultRetryPolicy(IMAGE_TIMEOUT_MS, IMAGE_MAX_RETRIES, IMAGE_BACKOFF_MULT));
mListener = listener;
mDecodeConfig = decodeConfig;
mMaxWidth = maxWidth;
mMaxHeight = maxHeight;
}
//获取优先级...图片加载的优先级一般是最低的..
@Override
public Priority getPriority() {
return Priority.LOW;
} //重新设置图片的大小...其实为了缩小图片...
private static int getResizedDimension(int maxPrimary, int maxSecondary, int actualPrimary,
int actualSecondary) {
// If no dominant value at all, just return the actual.
if (maxPrimary == 0 && maxSecondary == 0) {
return actualPrimary;
} // If primary is unspecified, scale primary to match secondary's scaling ratio.
if (maxPrimary == 0) {
double ratio = (double) maxSecondary / (double) actualSecondary;
return (int) (actualPrimary * ratio);
} if (maxSecondary == 0) {
return maxPrimary;
} double ratio = (double) actualSecondary / (double) actualPrimary;
int resized = maxPrimary;
if (resized * ratio > maxSecondary) {
resized = (int) (maxSecondary / ratio);
}
return resized;
}
//解析响应...
@Override
protected Response<Bitmap> parseNetworkResponse(NetworkResponse response) {
// Serialize all decode on a global lock to reduce concurrent heap usage.
synchronized (sDecodeLock) {
try {
return doParse(response); //调用doParse函数..
} catch (OutOfMemoryError e) {
VolleyLog.e("Caught OOM for %d byte image, url=%s", response.data.length, getUrl());
return Response.error(new ParseError(e));
}
}
} /**
* The real guts of parseNetworkResponse. Broken out for readability.
*/
//获取图片数据的过程...
private Response<Bitmap> doParse(NetworkResponse response) {
byte[] data = response.data; //图片数据...
BitmapFactory.Options decodeOptions = new BitmapFactory.Options(); //定义一个位图选项对象..
Bitmap bitmap = null;
if (mMaxWidth == 0 && mMaxHeight == 0) {//这里表示如果为0，那么表示图片按照图片本身的大小进行展现..不用进行其他操作...
decodeOptions.inPreferredConfig = mDecodeConfig;
bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, decodeOptions);
} else {
// If we have to resize this image, first get the natural bounds.
decodeOptions.inJustDecodeBounds = true; //表示图片需要缩放..
BitmapFactory.decodeByteArray(data, 0, data.length, decodeOptions);//这里并不是完全对图片进行编码，而是获取图片的基本参数..
int actualWidth = decodeOptions.outWidth; //获取图片的宽度...
int actualHeight = decodeOptions.outHeight; //获取图片的高度.. // Then compute the dimensions we would ideally like to decode to.
int desiredWidth = getResizedDimension(mMaxWidth, mMaxHeight,
actualWidth, actualHeight); //对宽度进行缩放...
int desiredHeight = getResizedDimension(mMaxHeight, mMaxWidth,
actualHeight, actualWidth); //对高度进行缩放... // Decode to the nearest power of two scaling factor.
decodeOptions.inJustDecodeBounds = false; //缩放后，表示图片不需要进行缩放了...
// TODO(ficus): Do we need this or is it okay since API 8 doesn't support it?
// decodeOptions.inPreferQualityOverSpeed = PREFER_QUALITY_OVER_SPEED;
decodeOptions.inSampleSize =
findBestSampleSize(actualWidth, actualHeight, desiredWidth, desiredHeight);//根据实际大小和所需大小去找到一个最合适的大小...
Bitmap tempBitmap =
BitmapFactory.decodeByteArray(data, 0, data.length, decodeOptions);//对图片编码，转化成比特流的形式... // If necessary, scale down to the maximal acceptable size.
if (tempBitmap != null && (tempBitmap.getWidth() > desiredWidth ||
tempBitmap.getHeight() > desiredHeight)) {
//这里表示如果通过上述缩放后图片的大小仍然比所需大小要大，那么按照所需大小进一步进行缩放...
bitmap = Bitmap.createScaledBitmap(tempBitmap,
desiredWidth, desiredHeight, true);
tempBitmap.recycle();
} else {
bitmap = tempBitmap; //否则直接为当前临时图片...
}
} if (bitmap == null) {
return Response.error(new ParseError(response)); //返回错误数据..
} else {
return Response.success(bitmap, HttpHeaderParser.parseCacheHeaders(response)); //返回成功数据...
}
}
//对响应分发...
@Override
protected void deliverResponse(Bitmap response) {
mListener.onResponse(response);
} //需找最优大小..
static int findBestSampleSize(
int actualWidth, int actualHeight, int desiredWidth, int desiredHeight) {
double wr = (double) actualWidth / desiredWidth;
double hr = (double) actualHeight / desiredHeight;
double ratio = Math.min(wr, hr);
float n = 1.0f;
while ((n * 2) <= ratio) {
n *= 2;
} return (int) n;
}
}
源码看起来其实并不是非常的困难，还是比较好理解的..如果预先对ImageLoader加载图片非常熟悉的话，那么这个理解起来就不是非常的费劲...源码就分析到这，还是看看调用过程..这里的构造函数需要传递六个参数...
public ImageRequest(url,Listener,maxWidth,maxHeight,Config,errorListener);
传递的参数分别是url，成功监听，最大宽度和高度，图片使用的颜色属性，以及失败后的监听...这里宽度和高度如果指定成自定义的大小，那么图图片就会按照指定大小进行缩放，如果都指定成0，那么图片按照原本大小进行显示，不进行缩放设置...
package com.example.oop; import com.android.volley.RequestQueue;
import com.android.volley.toolbox.ImageLoader;
import com.android.volley.toolbox.ImageLoader.ImageCache;
import com.android.volley.toolbox.NetworkImageView;
import com.android.volley.toolbox.Volley; import android.os.Bundle;
import android.app.Activity;
import android.graphics.Bitmap;
import android.support.v4.util.LruCache;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener; public class MainActivity extends Activity implements OnClickListener { String url="http://192.168.199.172:8080/JSP/imageview.jpg";
ImageView iv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
iv=(ImageView)findViewById(R.id.iv);
init();
} public void init(){
RequestQueue queue=Volley.newRequestQueue(MainActivity.this);
queue.add(new ImageRequest("http://192.168.199.172:8080/JSP/imageview.jpg",new Listener<Bitmap>(){
@Override
public void onResponse(Bitmap response){
//自定义了一个imageview...图片资源就是下载后的Bitmap
iv.setImageBitmap(response);
}
},0,0,Config.ARGB_8888, new ErrorListener(){
@Override
public void onErrorResponse(VolleyError error){
System.out.println(error.toString());
}
}));
} @Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
} @Override
public void onClick(View v) {
// TODO Auto-generated method stub } }
这样就成功的使用ImageRequest加载了网络上的图片数据...但是使用ImageRequest加载网络图片的缺点是没有缓存机制，只能频繁的发送网络请求，而没有缓存请求，这样会增加服务器的负担...因此在这点上ImageRequest并不是非常的完善...
2.ImageLoader.java
ImageLoader算是对ImageRequest的一个强化，这个类内部提供了缓存机制，这样我们可以更好的去处理请求，由于存在缓存，那么相同的请求可以通过从缓存中直接获取相关的数据，从而能够减少一些不必要的请求，这样会减少网络请求，减少服务器的负担...
package com.android.volley.toolbox; import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.os.Handler;
import android.os.Looper;
import android.widget.ImageView; import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response.ErrorListener;
import com.android.volley.Response.Listener;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.ImageRequest; import java.util.HashMap;
import java.util.LinkedList; public class ImageLoader {
/** RequestQueue for dispatching ImageRequests onto. */
private final RequestQueue mRequestQueue; //请求队列.. /** Amount of time to wait after first response arrives before delivering all responses. */
private int mBatchResponseDelayMs = 100; //响应到达的延时... /** The cache implementation to be used as an L1 cache before calling into volley. */
private final ImageCache mCache; //图片缓存对象... private final HashMap<String, BatchedImageRequest> mInFlightRequests =
new HashMap<String, BatchedImageRequest>(); //表示正在处理的请求集合... /** HashMap of the currently pending responses (waiting to be delivered). */
private final HashMap<String, BatchedImageRequest> mBatchedResponses =
new HashMap<String, BatchedImageRequest>(); //批处理响应的集合.. /** Handler to the main thread. */
private final Handler mHandler = new Handler(Looper.getMainLooper()); /** Runnable for in-flight response delivery. */
private Runnable mRunnable; //用于分发响应...
//缓存对象构造...
public interface ImageCache {
public Bitmap getBitmap(String url);
public void putBitmap(String url, Bitmap bitmap);
} //通过一个请求队列和缓存机制来构造一个ImageLoader对象...
public ImageLoader(RequestQueue queue, ImageCache imageCache) {
mRequestQueue = queue;
mCache = imageCache;
} //获取图片监听...
public static ImageListener getImageListener(final ImageView view,
final int defaultImageResId, final int errorImageResId) {
return new ImageListener() { //失败的监听...
@Override
public void onErrorResponse(VolleyError error) {
if (errorImageResId != 0) {
view.setImageResource(errorImageResId); //如果加载失败，使用默认图片来显示...
}
} @Override
public void onResponse(ImageContainer response, boolean isImmediate) {
if (response.getBitmap() != null) {
view.setImageBitmap(response.getBitmap());//如果响应数据不为空，那么显示网络图片...
} else if (defaultImageResId != 0) {
view.setImageResource(defaultImageResId);//失败显示默认图片...
}
}
};
} //失败监听的一个接口...
public interface ImageListener extends ErrorListener { public void onResponse(ImageContainer response, boolean isImmediate);
} //如果请求允许缓存，那么保存缓存数据...
public boolean isCached(String requestUrl, int maxWidth, int maxHeight) {
throwIfNotOnMainThread(); String cacheKey = getCacheKey(requestUrl, maxWidth, maxHeight);
return mCache.getBitmap(cacheKey) != null;
} //调用下面的函数...
public ImageContainer get(String requestUrl, final ImageListener listener) {
return get(requestUrl, listener, 0, 0);
} //获取图片的过程...
public ImageContainer get(String requestUrl, ImageListener imageListener,
int maxWidth, int maxHeight) {
// only fulfill requests that were initiated from the main thread.
throwIfNotOnMainThread();
//如果缓存中存在，那么从缓存当中取出数据...
final String cacheKey = getCacheKey(requestUrl, maxWidth, maxHeight); Bitmap cachedBitmap = mCache.getBitmap(cacheKey);
if (cachedBitmap != null) { //缓存存在...
// Return the cached bitmap.
ImageContainer container = new ImageContainer(cachedBitmap, requestUrl, null, null);//将缓存数据的图片，以及url进行封装，返回...
imageListener.onResponse(container, true);
return container;
} ImageContainer imageContainer =
new ImageContainer(null, requestUrl, cacheKey, imageListener); //缓存不存在，新建立一个ImageContainer对象... // Update the caller to let them know that they should use the default bitmap.
//回调函数，使用默认图片...
imageListener.onResponse(imageContainer, true); // Check to see if a request is already in-flight.
BatchedImageRequest request = mInFlightRequests.get(cacheKey); //查看当前执行队列中是否有与之相同的请求..
if (request != null) {
// If it is, add this request to the list of listeners.
request.addContainer(imageContainer); //如果有，那么加入到批处理请求队列当中，由这个请求队列去处理这些相同的请求..
return imageContainer;
} //如果没有，那么新建立一个请求...
Request<?> newRequest =
new ImageRequest(requestUrl, new Listener<Bitmap>() {
@Override
public void onResponse(Bitmap response) {
onGetImageSuccess(cacheKey, response);
}
}, maxWidth, maxHeight,
Config.RGB_565, new ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
onGetImageError(cacheKey, error);
}
});
//添加新请求到请求队列当中
mRequestQueue.add(newRequest);
//向当前请求队列中加入这次请求的键和值...
mInFlightRequests.put(cacheKey,
new BatchedImageRequest(newRequest, imageContainer));
return imageContainer;
} //设置批处理响应的延时...
public void setBatchedResponseDelay(int newBatchedResponseDelayMs) {
mBatchResponseDelayMs = newBatchedResponseDelayMs;
} //成功获取图片...
private void onGetImageSuccess(String cacheKey, Bitmap response) {
// cache the image that was fetched.
mCache.putBitmap(cacheKey, response); //向缓存中放入数据... // remove the request from the list of in-flight requests.
BatchedImageRequest request = mInFlightRequests.remove(cacheKey); //请求成功，那么表示所有与之相同的请求都获取到了相关数据，那么就将请求移出队列... if (request != null) {
// Update the response bitmap.
request.mResponseBitmap = response; // Send the batched response
batchResponse(cacheKey, request);//发送相同请求的响应...
}
} //获取图片失败的时候和成功时执行的操作基本是相同的...
private void onGetImageError(String cacheKey, VolleyError error) {
// Notify the requesters that something failed via a null result.
// Remove this request from the list of in-flight requests.
BatchedImageRequest request = mInFlightRequests.remove(cacheKey); // Set the error for this request
request.setError(error); if (request != null) {
// Send the batched response
batchResponse(cacheKey, request);
}
} //ImageContainer类..
public class ImageContainer { private Bitmap mBitmap; //图片对象.. private final ImageListener mListener; //成功监听.. /** The cache key that was associated with the request */
private final String mCacheKey; //缓存键值 /** The request URL that was specified */
private final String mRequestUrl; //url地址... //将图片，url，缓存键值，以及监听的一个封装...
public ImageContainer(Bitmap bitmap, String requestUrl,
String cacheKey, ImageListener listener) {
mBitmap = bitmap;
mRequestUrl = requestUrl;
mCacheKey = cacheKey;
mListener = listener;
} //是否中断了请求...
public void cancelRequest() {
if (mListener == null) {
return;
} BatchedImageRequest request = mInFlightRequests.get(mCacheKey);
if (request != null) {
boolean canceled = request.removeContainerAndCancelIfNecessary(this); //请求如果中断，那么判断是否有必要中断请求...
if (canceled) {
mInFlightRequests.remove(mCacheKey); //如果有必要，直接中断处理...
}
} else {
// check to see if it is already batched for delivery.
request = mBatchedResponses.get(mCacheKey); //判断请求的响应是否已经被分发...
if (request != null) {
request.removeContainerAndCancelIfNecessary(this);//判断是否有必要移除所有与之相同的请求并中断..
if (request.mContainers.size() == 0) { //如果同一种请求已经空了，那么就从批处理请求中移除这个键值..
mBatchedResponses.remove(mCacheKey);
}
}
}
}
//获取图片数据...
public Bitmap getBitmap() {
return mBitmap;
} //获取url...
public String getRequestUrl() {
return mRequestUrl;
}
} private class BatchedImageRequest {
/** The request being tracked */
private final Request<?> mRequest; //请求对象.. /** The result of the request being tracked by this item */
private Bitmap mResponseBitmap; //位图对象... /** Error if one occurred for this response */
private VolleyError mError; //错误对象... private final LinkedList<ImageContainer> mContainers = new LinkedList<ImageContainer>(); //用于保存相同的键值对应的请求... //构造函数...
public BatchedImageRequest(Request<?> request, ImageContainer container) {
mRequest = request;
mContainers.add(container);
} /**
* Set the error for this response
*/
public void setError(VolleyError error) {
mError = error;
} /**
* Get the error for this response
*/
public VolleyError getError() {
return mError;
} //将每一个不同的请求加入队列中
public void addContainer(ImageContainer container) {
mContainers.add(container);
} //是否有必要中断请求...
public boolean removeContainerAndCancelIfNecessary(ImageContainer container) {
mContainers.remove(container);
if (mContainers.size() == 0) {
mRequest.cancel();
return true;
}
return false;
}
} //批处理响应...
private void batchResponse(String cacheKey, BatchedImageRequest request) {
mBatchedResponses.put(cacheKey, request);//放入响应...
//开启一个线程分发响应的过程...
if (mRunnable == null) {
mRunnable = new Runnable() {
@Override
public void run() {
for (BatchedImageRequest bir : mBatchedResponses.values()) {
for (ImageContainer container : bir.mContainers) {
// If one of the callers in the batched request canceled the request
// after the response was received but before it was delivered,
// skip them.
if (container.mListener == null) {
continue;
}
if (bir.getError() == null) {
container.mBitmap = bir.mResponseBitmap;
container.mListener.onResponse(container, false);
} else {
container.mListener.onErrorResponse(bir.getError());
}
}
}
mBatchedResponses.clear();
mRunnable = null;
} };
// Post the runnable.
mHandler.postDelayed(mRunnable, mBatchResponseDelayMs);
}
} private void throwIfNotOnMainThread() {
if (Looper.myLooper() != Looper.getMainLooper()) {
throw new IllegalStateException("ImageLoader must be invoked from the main thread.");
}
}
//获取缓存中的键值..
private static String getCacheKey(String url, int maxWidth, int maxHeight) {
return new StringBuilder(url.length() + 12).append("#W").append(maxWidth)
.append("#H").append(maxHeight).append(url).toString();
}
}
这个源码相对就比较多，但是其中的过程并不是非常的难理解...还是看一下实际中是如何使用的...
package com.example.oop; import com.android.volley.RequestQueue;
import com.android.volley.toolbox.ImageLoader;
import com.android.volley.toolbox.ImageLoader.ImageCache;
import com.android.volley.toolbox.NetworkImageView;
import com.android.volley.toolbox.Volley; import android.os.Bundle;
import android.app.Activity;
import android.graphics.Bitmap;
import android.support.v4.util.LruCache;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener; public class MainActivity extends Activity implements OnClickListener { String url="http://192.168.199.172:8080/JSP/imageview.jpg";
ImageView iv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
imageView=(ImageView) findViewById(R.id.iv);
init();
} public void init(){
RequestQueue queue=Volley.newRequestQueue(MainActivity.this);
ImageLoader imageLoader=new ImageLoader(queue, new ImageCache() { LruCache<String,Bitmap>cache=new LruCache<String, Bitmap>(((int) Runtime.getRuntime().maxMemory())/8){ @Override
protected int sizeOf(String key,Bitmap bitmap){
return bitmap.getRowBytes()*bitmap.getHeight();
}
}; @Override
public void putBitmap(String url, Bitmap bitmap) {
// TODO Auto-generated method stub
cache.put(url, bitmap);
} @Override
public Bitmap getBitmap(String url) {
// TODO Auto-generated method stub
return cache.get(url);
}
});
//为ImageLoader设置监听...成功则iv显示成功图片，没加载完显示默认图片，加载失败显示失败图片..
ImageListener imagelistener=imageLoader.getImageListener(iv,default_image,error_image);
imageloader.get(url,imagelistener);
} @Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
} @Override
public void onClick(View v) {
// TODO Auto-generated method stub } }
imageloader.get(url,imagelistener);获取图片的最终过程...这里get函数首先判断图片是否有缓存，通过url的形式来判断是否存在缓存，缓存内部存在，那么直接从缓存中取出，如果缓存中不存在，那么首先看本次的请求是否在批处理图像请求队列中，如果队列中存在这类请求，那么就直接再次添加相同的请求，就没有必要重新建立一个新的请求了...如果这个请求在批处理队列中并不存在，那么就创建一个新的请求来完成...然后放入RequestQueue中和批处理请求队列中...这样就完成了使用ImageLoader来加载图片数据...
这里使用了LruCache()最近最久未使用算法设立的缓存机制，如果缓存的容量发生了不足，那么直接清除最近最久未被使用的图片缓存...同时每一个Key对应的请求仅仅被放入请求队列一次，对于相同key值的请求，直接从缓存中取出即可，如果缓存内部没有数据，那么通过判断当前是否有这类的请求...如果有，直接进行赋值，如果没有定义一个新的请求...
3.NetWorkImageLoader.java
第三种加载图片的方式...它基于ImageLoader，加载图片也是通过ImageLoader来实现的，只是在一些地方有一定的差异...
package com.android.volley.toolbox; import android.content.Context;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.ViewGroup.LayoutParams;
import android.widget.ImageView; import com.android.volley.VolleyError;
import com.android.volley.toolbox.ImageLoader.ImageContainer;
import com.android.volley.toolbox.ImageLoader.ImageListener; public class NetworkImageView extends ImageView {
/** The URL of the network image to load */
private String mUrl; //图片的url /**
* Resource ID of the image to be used as a placeholder until the network image is loaded.
*/
private int mDefaultImageId; //默认图片的ID.. /**
* Resource ID of the image to be used if the network response fails.
*/
private int mErrorImageId; //错误显示的图片... /** Local copy of the ImageLoader. */
private ImageLoader mImageLoader; //图片加载对象... /** Current ImageContainer. (either in-flight or finished) */
private ImageContainer mImageContainer; //ImageContainer对象.. public NetworkImageView(Context context) {
this(context, null);
} public NetworkImageView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
} public NetworkImageView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
} //设置图片的url...
public void setImageUrl(String url, ImageLoader imageLoader) {
mUrl = url;
mImageLoader = imageLoader;
// The URL has potentially changed. See if we need to load it.
loadImageIfNecessary(false);
} //设置默认图片...
public void setDefaultImageResId(int defaultImage) {
mDefaultImageId = defaultImage;
} //设置错误图片...
public void setErrorImageResId(int errorImage) {
mErrorImageId = errorImage;
} //这个函数在OnLauout调用时才被调用...用于加载图片...
private void loadImageIfNecessary(final boolean isInLayoutPass) {
//获取长度和宽度...
int width = getWidth();
int height = getHeight(); boolean isFullyWrapContent = getLayoutParams() != null
&& getLayoutParams().height == LayoutParams.WRAP_CONTENT
&& getLayoutParams().width == LayoutParams.WRAP_CONTENT;
//如果view控件的大小界限是不确定的，并且还不是wrap_content属性，那么放弃加载...
if (width == 0 && height == 0 && !isFullyWrapContent) {
return;
} // if the URL to be loaded in this view is empty, cancel any old requests and clear the
// currently loaded image.
//如果这个url被加载后，view是空的，那么就撤销掉与之相同的所有请求...
if (TextUtils.isEmpty(mUrl)) {
if (mImageContainer != null) {
mImageContainer.cancelRequest();
mImageContainer = null;
}
setImageBitmap(null);
return;
} // if there was an old request in this view, check if it needs to be canceled.
//如果请求是相同的url，那么直接return，数据的获取由缓存处理...
if (mImageContainer != null && mImageContainer.getRequestUrl() != null) {
if (mImageContainer.getRequestUrl().equals(mUrl)) {
// if the request is from the same URL, return.
return;
} else {
// if there is a pre-existing request, cancel it if it's fetching a different URL.
mImageContainer.cancelRequest();
setImageBitmap(null);
}
} // The pre-existing content of this view didn't match the current URL. Load the new image
// from the network.
//如果不满足上述情况，那么就建立一个新的ImageContainer来保存...
ImageContainer newContainer = mImageLoader.get(mUrl,
new ImageListener() {
@Override
public void onErrorResponse(VolleyError error) {
if (mErrorImageId != 0) {
setImageResource(mErrorImageId);
}
} @Override
public void onResponse(final ImageContainer response, boolean isImmediate) {
// If this was an immediate response that was delivered inside of a layout
// pass do not set the image immediately as it will trigger a requestLayout
// inside of a layout. Instead, defer setting the image by posting back to
// the main thread.
if (isImmediate && isInLayoutPass) {
post(new Runnable() {
@Override
public void run() {
onResponse(response, false);
}
});
return;
} if (response.getBitmap() != null) {
setImageBitmap(response.getBitmap());
} else if (mDefaultImageId != 0) {
setImageResource(mDefaultImageId);
}
}
}); // update the ImageContainer to be the new bitmap container.
mImageContainer = newContainer;
}
//布局函数调用...
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
super.onLayout(changed, left, top, right, bottom);
loadImageIfNecessary(true); //这里才会去调用图片加载函数...
} @Override
protected void onDetachedFromWindow() {
if (mImageContainer != null) {
// If the view was bound to an image request, cancel it and clear
// out the image from the view.
mImageContainer.cancelRequest();
setImageBitmap(null);
// also clear out the container so we can reload the image if necessary.
mImageContainer = null;
}
super.onDetachedFromWindow();
} @Override
protected void drawableStateChanged() {
super.drawableStateChanged();
invalidate();
}
}
这是源码的实现过程，有些细节上的问题就不进行分析了...我们还是来看一下实例...
package com.example.oop; import com.android.volley.RequestQueue;
import com.android.volley.toolbox.ImageLoader;
import com.android.volley.toolbox.ImageLoader.ImageCache;
import com.android.volley.toolbox.NetworkImageView;
import com.android.volley.toolbox.Volley; import android.os.Bundle;
import android.app.Activity;
import android.graphics.Bitmap;
import android.support.v4.util.LruCache;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener; public class MainActivity extends Activity implements OnClickListener { String url="http://192.168.199.172:8080/JSP/imageview.jpg";
NetworkImageView imageView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
imageView=(NetworkImageView) findViewById(R.id.network);
init();
} public void init(){
RequestQueue queue=Volley.newRequestQueue(MainActivity.this);
ImageLoader imageLoader=new ImageLoader(queue, new ImageCache() { LruCache<String,Bitmap>cache=new LruCache<String, Bitmap>(((int) Runtime.getRuntime().maxMemory())/8){ @Override
protected int sizeOf(String key,Bitmap bitmap){
return bitmap.getRowBytes()*bitmap.getHeight();
}
}; @Override
public void putBitmap(String url, Bitmap bitmap) {
// TODO Auto-generated method stub
cache.put(url, bitmap);
} @Override
public Bitmap getBitmap(String url) {
// TODO Auto-generated method stub
return cache.get(url);
}
});
imageView.setDefaultImageResId(R.drawable.default_image); //这里需要手动设置默认图片和错误显示图片...
imageView.setErrorImageResId(R.drawable.no_image);
//加载获取图片的过程...
imageView.setImageUrl(url, imageLoader);
} @Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
} @Override
public void onClick(View v) {
// TODO Auto-generated method stub } }
需要说的是，布局文件中我们需要这样进行书写去定义一个NetWorkImageView对象...通过获取ID，来进行数据信息的加载...
<com.android.volley.toolbox.NetworkImageView
android:id="@+id/network"
android:layout_height="100dip"
android:layout_width="100dip">
</com.android.volley.toolbox.NetworkImageView>