图片加载小框架

Bertha 。 2022-07-11 01:59 232阅读 0赞

# 效果图 #

![SouthEast][] ![SouthEast 1][]

public class ImageLoader { 
        private Handler mUIHandler;
        private Handler mPollThreadHandler;
        private Semaphore mSemaphoreThreadPool;
        private Semaphore mSemaphorePollThreadHandler = new Semaphore(0);
        //private Thread mPollThread;
        private HandlerThread mThread;// 轮询线程，在后台去执行下载图片任务
        private ExecutorService mThreadPool;
        private LinkedList<Runnable> mTaskQueue;
        private LruCache<String, Bitmap> mLruCache;
    
        private static int DEFAULT_THREAD_COUNT = 3;
        private String mMaxWidth = "mMaxWidth";
        private String mMaxHeight = "mMaxHeight";
    
        private Type mType = Type.LIFO;
    
        private enum Type {
            FIFO, LIFO
        }
    
        private static ImageLoader mInstance;
    
        private ImageLoader(int threadCount, Type type) {
            init(threadCount, type);
        }
    
        public static ImageLoader getInstance() {
            return getInstance(DEFAULT_THREAD_COUNT, Type.LIFO);
        }
    
        public static ImageLoader getInstance(int threadCount, Type type) {
            if (mInstance == null) {
                synchronized (ImageLoader.class) {
                    if (mInstance == null) {
                        mInstance = new ImageLoader(threadCount, type);
                    }
                }
            }
            return mInstance;
        }
    
        private void init(int threadCount, Type type) {
            mType = type;
            mSemaphoreThreadPool = new Semaphore(threadCount);
            mTaskQueue = new LinkedList<Runnable>();
            mThreadPool = Executors.newFixedThreadPool(threadCount);
    
            initBackThread();
    
            int maxMemory = (int) Runtime.getRuntime().maxMemory();
            int cacheMemory = maxMemory / 8;
            mLruCache = new LruCache<String, Bitmap>(cacheMemory) {
                @Override
                protected int sizeOf(String key, Bitmap value) {
                    return value.getRowBytes() * value.getHeight();
                }
            };
        }
    
        public void initBackThread(){
    
            mThread = new HandlerThread("PollThread");
            mThread.start();
    
            mPollThreadHandler = new Handler(mThread.getLooper()) {
                @Override
                public void handleMessage(Message msg) {
                    super.handleMessage(msg);
                    mThreadPool.execute(getTask());
                    try {
                        mSemaphoreThreadPool.acquire();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            mSemaphorePollThreadHandler.release();
    
    
            /*mPollThread = new Thread() { @Override public void run() { super.run(); Looper.prepare(); mPollThreadHandler = new Handler() { @Override public void handleMessage(Message msg) { super.handleMessage(msg); mThreadPool.execute(getTask()); try { mSemaphoreThreadPool.acquire(); } catch (InterruptedException e) { e.printStackTrace(); } } }; mSemaphorePollThreadHandler.release(); Looper.loop(); } }; mPollThread.start();*/
        }
    
        private Runnable getTask() {
            if (mType == Type.FIFO) {
                return mTaskQueue.removeFirst();
            } else if (mType == Type.LIFO) {
                return mTaskQueue.removeLast();
            }
            return null;
        }
    
        public void loadImage(final String path, final ImageView imageView) {
            imageView.setTag(path);
            if (mUIHandler == null) {
                mUIHandler = new Handler() {
                    @Override
                    public void handleMessage(Message msg) {
                        super.handleMessage(msg);
                        ImageHolder holder = (ImageHolder) msg.obj;
                        Bitmap bm = holder.bm;
                        String path = holder.path;
                        ImageView imageView = holder.imageView;
                        if (path.equals(imageView.getTag().toString())) {
                            imageView.setImageBitmap(bm);
                        }
                    }
                };
            }
    
            Bitmap bm = getBitmapFromLruCache(path);
            if (bm != null) {
                refreshImageView(path, bm, imageView);
            } else {
                addTask(new Runnable() {
                    @Override
                    public void run() {
                        ImageSize imageSize = getImageViewSize(imageView);
                        Bitmap bm = decodeBitmapFromPath(path, imageSize);
                        addBitmapToLruCache(path, bm);
                        refreshImageView(path, bm, imageView);
                        mSemaphoreThreadPool.release();
                    }
                });
            }
        }
    
        private Bitmap decodeBitmapFromPath(String path, ImageSize imageSize) {
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(path, options);
            options.inSampleSize = calculateInSampleSize(options, imageSize.width, imageSize.height);
            options.inJustDecodeBounds = false;
            return BitmapFactory.decodeFile(path, options);
        }
    
        private int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
            final int height = options.outHeight;
            final int width = options.outWidth;
            int inSampleSize = 1;
    
            if (height > reqHeight || width > reqWidth) {
    
                final int halfHeight = height / 2;
                final int halfWidth = width / 2;
    
                while ((halfHeight / inSampleSize) > reqHeight
                        && (halfWidth / inSampleSize) > reqWidth) {
                    inSampleSize *= 2;
                }
    
               /* long totalPixels = width * height / inSampleSize; final long totalReqPixelsCap = reqWidth * reqHeight * 2; while (totalPixels > totalReqPixelsCap) { inSampleSize *= 2; totalPixels /= 2; }*/
            }
    
            return inSampleSize;
        }
    
        private ImageSize getImageViewSize(ImageView imageView) {
            DisplayMetrics metrics = imageView.getContext().getResources().getDisplayMetrics();
            ViewGroup.LayoutParams lp = imageView.getLayoutParams();
    
            int width = imageView.getWidth();
            if (width <= 0) {
                width = lp.width;
            }
            if (width <= 0) {
                width = getImageViewFieldValue(imageView, mMaxWidth);
            }
            if (width <= 0) {
                width = metrics.widthPixels;
            }
    
            int height = imageView.getWidth();
            if (height <= 0) {
                height = lp.height;
            }
            if (height <= 0) {
                height = getImageViewFieldValue(imageView, mMaxHeight);
            }
            if (height <= 0) {
                height = metrics.heightPixels;
            }
    
            ImageSize imageSize = new ImageSize();
            imageSize.width = width;
            imageSize.height = height;
            return imageSize;
        }
    
        private int getImageViewFieldValue(Object obj, String fieldname) {
            int value = 0;
            try {
                Field field = ImageView.class.getDeclaredField(fieldname);
                field.setAccessible(true);
                int fieldvalue = field.getInt(obj);
                if (fieldvalue > 0 && fieldvalue < Integer.MAX_VALUE) {
                    value = fieldvalue;
                }
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            return value;
        }
    
        private synchronized void addTask(Runnable r) {
            mTaskQueue.add(r);
            if (mPollThreadHandler == null) {
                try {
                    mSemaphorePollThreadHandler.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            mPollThreadHandler.sendEmptyMessage(0);// 给轮询线程发送消息
        }
    
        private void refreshImageView(String path, Bitmap bm, ImageView imageView) {
            Message msg = Message.obtain();
            ImageHolder holder = new ImageHolder();
            holder.bm = bm;
            holder.path = path;
            holder.imageView = imageView;
            msg.obj = holder;
            mUIHandler.sendMessage(msg);
        }
    
        private Bitmap getBitmapFromLruCache(String path) {
            return mLruCache.get(path);
        }
    
        private void addBitmapToLruCache(String path, Bitmap bm) {
            if (getBitmapFromLruCache(path) == null) {
                if (bm != null) {
                    mLruCache.put(path, bm);
                }
            }
        }
    
        class ImageSize {
            protected int width;
            protected int height;
        }
    
        class ImageHolder {
            protected Bitmap bm;
            protected String path;
            protected ImageView imageView;
        }
    }

源代码：[https://github.com/JackChan1999/PhotoSelector][https_github.com_JackChan1999_PhotoSelector]

# 参考 #

*  [Android 框架练成 教你打造高效的图片加载框架][Android _]
 *  [Android Handler 异步消息处理机制的妙用 创建强大的图片加载类][Android Handler _]
 *  [Android-仿微信图片选择器][Android-]
 *  [Android照片墙完整版，完美结合LruCache和DiskLruCache][Android_LruCache_DiskLruCache]
 *  [教你写Android ImageLoader框架][Android ImageLoader]

[SouthEast]: https://img-blog.csdn.net/20170116132107133?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvYXhpMjk1MzA5MDY2/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast
[SouthEast 1]: /images/20220711/c6f6b67633d04124a640fb8d13d01fbb.png
[https_github.com_JackChan1999_PhotoSelector]: https://github.com/JackChan1999/PhotoSelector
[Android _]: http://blog.csdn.net/lmj623565791/article/details/41874561
[Android Handler _]: http://blog.csdn.net/lmj623565791/article/details/38476887
[Android-]: http://www.imooc.com/learn/489
[Android_LruCache_DiskLruCache]: http://blog.csdn.net/guolin_blog/article/details/34093441/
[Android ImageLoader]: http://blog.csdn.net/column/details/android-imageloader.html