1.图片压缩:
package com.example.imageloader;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Log;
import java.io.FileDescriptor;
/**
* Created by 1013369768 on 2017/5/27.
* 压缩图片工具类
*/
public class ImageResizer {
public Bitmap decodeFormStream(FileDescriptor fd, int reqWidth, int reqHeight){
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFileDescriptor(fd,null,options);
options.inSampleSize = calculateInSampleSize(options,reqWidth,reqHeight);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeFileDescriptor(fd,null,options);
}
/**
* 计算采样率
* @param options
* @param reqWidth
* @param reqHeight
* @return
*/
public int calculateInSampleSize(BitmapFactory.Options options, int reqWidth,int reqHeight){
if(reqWidth == 0 || reqHeight == 0){
return 1;
}
int inSampleSize = 1;
int width = options.outWidth;
int height = options.outHeight;
if(width>reqWidth || height>reqHeight){
final int halfHeight = height / 2;
final int halfWidth = width / 2;
while ((halfHeight / inSampleSize) >= reqHeight && (halfWidth / inSampleSize) >= reqWidth) {
inSampleSize *= 2;
}
}
return inSampleSize;
}
}
2.内存缓存和磁盘缓存的实现
private ImageLoader(Context context){
mContext = context.getApplicationContext();
//获取当前进程最大可用内存,单位为KB
int maxMemory = (int)(Runtime.getRuntime().maxMemory()/1024);
//以当前进程最大可用内存的1/8作为内存缓存的总容量大小
int cacheSize = maxMemory/8;
mMemoryCache = new LruCache<String,Bitmap>(cacheSize){
@Override
protected int sizeOf(String key, Bitmap bitmap) {
//返回每个图片的大小,单位为KB
return bitmap.getByteCount()/1024;
}
};
File diskCacheDir = getDiskCacheDir(context,"bitmap");
if(!diskCacheDir.exists()){
diskCacheDir.mkdirs();
}
//判断磁盘剩余空间和磁盘缓存空间大小
if(getUsableSpace(diskCacheDir) >DISK_CACHE_SIZE){
try {
mDiskLruCache = DiskLruCache.open(diskCacheDir, 1, 1, DISK_CACHE_SIZE);
mIsDiskLruCacheCreated = true;
} catch (IOException e) {
e.printStackTrace();
}
}
}
3.添加图片到内存缓存和磁盘缓存
//添加到磁盘缓存
private Bitmap loadBitmapFromHttp(String url,int reqWidth,int reqHeight
) throws IOException {
//通过检查当前线程的Looper是否和主线程的Looper相同
if(Looper.myLooper() == Looper.getMainLooper()){
throw new RuntimeException("不能再主线程访问网络");
}
if(mDiskLruCache == null){
return null;
}
String key = hashKeyForUrl(url);
DiskLruCache.Editor editor = mDiskLruCache.edit(key);
if(editor!=null) {
OutputStream outputStream = editor.newOutputStream(DISK_CACHE_I
NDEX);
if (downloadUrlToStream(url, outputStream)) {
editor.commit();
} else {
editor.abort();
}
mDiskLruCache.flush();
}
return loadBitmapFormDiskCache(url,reqWidth,reqHeight);
}
----------
//添加到内存缓存
private void addBitmapToMemoryCache(String key,Bitmap bitmap){
if(getBitmapFormMemoryCache(key) == null){
mMemoryCache.put(key, bitmap);
}
}
4.读取图片
//从磁盘中获取图片
private Bitmap loadBitmapFormDiskCache(String url,int reqWidth,int reqH
eight) throws IOException {
if(Looper.myLooper() == Looper.getMainLooper()){
Log.d("TAG","不允许在主线程加载图片");
}
if(mDiskLruCache == null){
return null;
}
Bitmap bitmap = null;
String key = hashKeyForUrl(url);
DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
if(snapshot !=null){
FileInputStream fileInputStream = (FileInputStream) snapshot.ge
tInputStream(DISK_CACHE_INDEX);
FileDescriptor fileDescriptor = fileInputStream.getFD();
bitmap = mImageResizer.decodeFormStream(fileDescriptor,reqWidth
,reqHeight);
if(bitmap != null){
addBitmapToMemoryCache(key,bitmap);
}
}
return bitmap;
}
----------
//从内存中获取图片
private Bitmap getBitmapFormMemoryCache(String key){
return mMemoryCache.get(key);
}
5.同步加载图片
同步加载接口需要在外部的子线程中调用,若在主线程中调用会抛出异常,通过loadBitmapFromHttp中进行检查,查看当前线程的Looper是否为主线程的Looper,判断当前线程是否为主线程。
public Bitmap loadBitmap(String url,int reqWidth,int reqHeight){
Bitmap bitmap = loadBitmapFormMemoryCache(url);
Log.d("TAG","BITMAP: "+bitmap);
if(bitmap!=null){
Log.d("TAG", "loadBitmapFromMemCache,url:" + url);
return bitmap;
}
try {
bitmap = loadBitmapFormDiskCache(url,reqWidth,reqHeight);
if(bitmap !=null){
Log.d("TAG", "loadBitmapFromDisk,url:" + url);
return bitmap;
}
bitmap = loadBitmapFromHttp(url,reqWidth,reqHeight);
Log.d("TAG", "loadBitmapFromHttp,url:" + url);
} catch (IOException e) {
e.printStackTrace();
}
if(bitmap == null && !mIsDiskLruCacheCreated){
Log.d("TAG", "encounter error, DiskLruCache is not created.");
bitmap = downloadBitmapFormUrl(url);
}
return bitmap;
}
5.异步加载
这里采用线程池加载图片,由于随着列表的滑动会产生大量线程,故不能使用普通线程加载
public void bindBitmap(final String url, final ImageView imageView, fin
al int reqWidth, final int reqHeight){
// View中的setTag(int key, Object tag)表示给View添加额外数据,key值必须是唯一值,必须使用应用程序资源中声明的id,故需要在res/values中新建xml文件进行添加
imageView.setTag(TAG_KEY_URI,url);
Bitmap bitmap = null;
bitmap = loadBitmapFormMemoryCache(url);
if(bitmap!=null){
imageView.setImageBitmap(bitmap);
return;
}
Runnable loadBitmapTask = new Runnable() {
@Override
public void run() {
Bitmap bitmap = loadBitmap(url, reqWidth, reqHeight);
if(bitmap!=null){
//把imageView、url、bitmap封装成一个LoaderBitmap对象
LoaderResult result = new LoaderResult(imageView,url,bi
tmap);
mMainHandler.obtainMessage(MESSAGE_POST_RESULT,result).
sendToTarget();
}
}
};
THTREAD_POOL_EXECUTOR.execute(loadBitmapTask);
}
----------
private static ThreadFactory sThreadFactory = new ThreadFactory() {
// AtomicInteger可以在并发情况下达到原子化更新,避免使用了synchronized
private AtomicInteger mCount = new AtomicInteger(1);
@Override
public Thread newThread(@NonNull Runnable r) {
return new Thread(r,"ImageLoader#"+mCount.getAndIncrement());
}
};
public static final Executor THTREAD_POOL_EXECUTOR = new ThreadPoolExec
utor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE,KEEP_ALIVE, TimeUnit.SECONDS,new
LinkedBlockingQueue<Runnable>(),sThreadFactory);
6.Handler实现
采用主线程的Looper构造Handler对象,这样既可以在主线程更新UI,也可以在其他线程更新UI
private Handler mMainHandler = new Handler(Looper.getMainLooper()){
@Override
public void handleMessage(Message msg) {
LoaderResult result = (LoaderResult) msg.obj;
ImageView imageView = result.imageView;
String url = (String) imageView.getTag(TAG_KEY_URI);
if(url.equals(result.url)){
imageView.setImageBitmap(result.bitmap);
}else {
Log.d("TAG", "set image bitmap,but url has changed, ignored
!");
}
}
};
Handeler实例化时:
① 更新UI,Handler要使用主线程中的Looper:
I、在主线程中可以使用Handler handler = new Handler()构造Handler对象
Handler h = new Handler(){
public void handleMessage (Message msg){
//在这里进行UI更新
}
}
II、如果在其他线程构造Handler对象,则需要:Handler handler = new Handler(Looper.getMainLooper())
private Handler mMainHandler = new Handler(Looper.getMainLooper()){
@Override
public void handleMessage(Message msg) {
//在这里处理UI更新
}
};
② 不更新UI,只处理消息:
I、 如果当前线程是主线程Handler handler = new Handler()
Handler h = new Handler(){
public void handleMessage (Message msg){
//在这里进行消息处理
}
}
II、如果当前线程不是主线程则使用Looper.prepare(); Handler handler = new Handler();Looper.loop()
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Message msg) {
//在这里处理消息
}
};
Looper.loop();
}
}
③ 注意:若是实例化的时候用Looper.getMainLooper()就表示放到UI线程去处理。
因为只有UI线程默认调用过:Loop.prepare();Loop.loop();故处理消息时不再需要调用。在其他线程需要手动调用这两个,否则会报错。
由于ListView和GridView存在View的复用机制,移出屏幕的View会进入到RecycleBin当中,而新进入屏幕的元素则会从RecycleBin中获取View控件。当有新的元素进入界面时就会回调getView()方法,而在getView()方法中会开启异步请求从网络上获取图片,注意网络操作都是比较耗时的,也就是说当我们快速滑动ListView的时候就很有可能出现这样一种情况,某一个位置上的元素进入屏幕后开始从网络上请求图片,但是还没等图片下载完成,它就又被移出了屏幕。这种情况下会产生什么样的现象呢?根据GridView和ListView的工作原理,被移出屏幕的控件将会很快被新进入屏幕的元素重新利用起来,而如果在这个时候刚好前面发起的图片请求有了响应,就会将刚才位置上的图片显示到当前位置上,因为虽然它们位置不同,但都是共用的同一个ImageView实例,这样就出现了乱序的情况。但是还没完,新进入屏幕的元素它也会发起一条网络请求来获取当前位置的图片,等到图片下载完的时候会设置到同样的ImageView上面,因此就会出现先显示一张图片,然后又变成了另外一张图片的情况。
解决方案:在异步请求网络前我们可以使用ImageView的setTag (int key, Object tag)为当前位置的ImageView绑定相关的数据,这里可以传入URL作为tag,然后再异步请求网络后使用getTag(int key)获取URL,若相同则加载图片。
由于GridView和ListView中的ImageView控件都是重用的,移出屏幕的控件很快会被进入屏幕的图片重新利用起来,那么getView()方法就会再次得到执行,而在getView()方法中会为这个ImageView控件设置新的Tag,这样老的Tag就会被覆盖掉,于是这时当老的网络请求完成后调用getTag(int key)获取URL,就只能得到老的URL了,而我们判断只有ImageView的URL相同的时候才会加载图片,这样图片乱序的问题也就不存在了。
照片墙功能的实现
适配器:
public class ImageAdapter extends BaseAdapter {
private LayoutInflater mInflater;
private List<String> mUrList;
private Drawable mDefaultBitmapDrawable;
private ImageLoader mImageLoader;
private boolean mIsGridViewIdle;
public ImageAdapter(List<String> urList, Context context,Boolean mIsGri
dViewIdle){
mImageLoader = ImageLoader.build(context);
mUrList = urList;
mInflater = LayoutInflater.from(context);
mDefaultBitmapDrawable = ContextCompat.getDrawable(context,R.drawab
le.image_default);
this.mIsGridViewIdle = mIsGridViewIdle;
}
@Override
public int getCount() {
return mUrList.size();
}
@Override
public Object getItem(int position) {
return mUrList.get(position);
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder viewHolder = null;
if(convertView == null){
convertView = mInflater.inflate(R.layout.item,parent,false);
viewHolder = new ViewHolder();
viewHolder.imageView = (ImageView)convertView.findViewById(R.id
.image1);
convertView.setTag(viewHolder);
}else {
viewHolder = (ViewHolder) convertView.getTag();
}
ImageView imageView = viewHolder.imageView;
final String tag = (String)imageView.getTag();
final String url = (String)getItem(position);
if(!url.equals(tag)){
imageView.setImageDrawable(mDefaultBitmapDrawable);
}
if(mIsGridViewIdle){
imageView.setTag(url);
//设置压缩后为100*100的像素,填充ImageView
mImageLoader.bindBitmap(url,imageView,100,100);
}
return convertView;
}
private static class ViewHolder{
public ImageView imageView;
}
}
在getView中通过ImageLoader的bindBitmap方法异步加载图片,当用户刻意频繁
滑动就会瞬间产生大量的异步任务,这些异步任务会造成线程池的拥堵,并进行大量的UI更新操作,他们运行在主线程中,因此会造成一定的卡顿;可以考虑在滑动时停止加载图片,等滑动停止后再次加载。
public void onScrollStateChanged(AbsListView view, int scrollState) {
// 判断滑动事件是否结束,只触发一次
if(scrollState == AbsListView.OnScrollListener.SCROLL_STATE_IDLE){
mIsGridViewIdle = true;
mImageAdapter.notifyDataSetChanged();
}else {
mIsGridViewIdle = false;
}
}
参考: