当前位置:首页 > > 充电吧
[导读]importjava.lang.reflect.Field;importjava.util.LinkedList;importjava.util.concurrent.ExecutorService;

importjava.lang.reflect.Field;

importjava.util.LinkedList;

importjava.util.concurrent.ExecutorService;

importjava.util.concurrent.Executors;

importjava.util.concurrent.Semaphore;

 

importandroid.graphics.Bitmap;

importandroid.graphics.BitmapFactory;

importandroid.os.Handler;

importandroid.os.Looper;

importandroid.os.Message;

importandroid.support.v4.util.LruCache;

importandroid.util.DisplayMetrics;

importandroid.view.ViewGroup.LayoutParams;

importandroid.widget.ImageView;

 

publicclass ImageLoader {

    /**

     * 图片缓存的核心类

     */

    privateLruCache

    /**

     * 线程池

     */

    privateExecutorService mThreadPool;

    /**

     * 队列的调度方式

     */

    privateType mType = Type.LIFO;

    /**

     * 任务队列

     */

    privateLinkedList

    /**

     * 轮询的线程

     */

    privateThread mPoolThread;

    privateHandler mPoolThreadHander;

 

    /**

     * 运行在UI线程的handler,用于给ImageView设置图片

     */

    privateHandler mHandler;

 

    /**

     * 引入一个值为1的信号量,防止mPoolThreadHander未初始化完成

     */

    privatevolatile Semaphore mSemaphore = newSemaphore(0);

 

    /**

     * 引入一个值为1的信号量,由于线程池内部也有一个阻塞线程,防止加入任务的速度过快,使LIFO效果不明显

     */

    privatevolatile Semaphore mPoolSemaphore;

 

    privatestatic ImageLoader mInstance;

 

    /**

     * 队列的调度方式

     *

     * @author zhy

     *

     */

    publicenum Type {

        FIFO, LIFO

    }

 

    /**

     * 单例获得该实例对象

     *

     * @return

     */

    publicstatic ImageLoader getInstance() {

 

        if(mInstance == null) {

            synchronized(ImageLoader.class) {

                if(mInstance == null) {

                    mInstance = newImageLoader(1, Type.LIFO);

                }

            }

        }

        returnmInstance;

    }

 

    privateImageLoader(intthreadCount, Type type) {

        init(threadCount, type);

    }

 

    privatevoid init(intthreadCount, Type type) {

        // loop thread

        mPoolThread = newThread() {

            @Override

            publicvoid run() {

                Looper.prepare();

 

                mPoolThreadHander = newHandler() {

                    @Override

                    publicvoid handleMessage(Message msg) {

                        mThreadPool.execute(getTask());

                        try{

                            mPoolSemaphore.acquire();

                        }catch(InterruptedException e) {

                        }

                    }

                };

                // 释放一个信号量

                mSemaphore.release();

                Looper.loop();

            }

        };

        mPoolThread.start();

 

        // 获取应用程序最大可用内存

        intmaxMemory = (int) Runtime.getRuntime().maxMemory();

        intcacheSize = maxMemory / 8;

        mLruCache = newLruCache

            @Override

            protectedint sizeOf(String key, Bitmap value) {

                returnvalue.getRowBytes() * value.getHeight();

            };

        };

 

        mThreadPool = Executors.newFixedThreadPool(threadCount);

        mPoolSemaphore = newSemaphore(threadCount);

        mTasks = newLinkedList

        mType = type == null? Type.LIFO : type;

 

    }

 

    /**

     * 加载图片

     *

     * @param path

     * @param imageView

     */

    publicvoid loadImage(finalString path, finalImageView imageView) {

        // set tag

        imageView.setTag(path);

        // UI线程

        if(mHandler == null) {

            mHandler = newHandler() {

                @Override

                publicvoid handleMessage(Message msg) {

                    ImgBeanHolder holder = (ImgBeanHolder) msg.obj;

                    ImageView imageView = holder.imageView;

                    Bitmap bm = holder.bitmap;

                    String path = holder.path;

                    if(imageView.getTag().toString().equals(path)) {

                        imageView.setImageBitmap(bm);

                    }

                }

            };

        }

 

        Bitmap bm = getBitmapFromLruCache(path);

        if(bm != null) {

            ImgBeanHolder holder = newImgBeanHolder();

            holder.bitmap = bm;

            holder.imageView = imageView;

            holder.path = path;

            Message message = Message.obtain();

            message.obj = holder;

            mHandler.sendMessage(message);

        }else{

            addTask(newRunnable() {

                @Override

                publicvoid run() {

 

                    ImageSize imageSize = getImageViewWidth(imageView);

 

                    intreqWidth = imageSize.width;

                    intreqHeight = imageSize.height;

 

                    Bitmap bm = decodeSampledBitmapFromResource(path, reqWidth,

                            reqHeight);

                    addBitmapToLruCache(path, bm);

                    ImgBeanHolder holder = newImgBeanHolder();

                    holder.bitmap = getBitmapFromLruCache(path);

                    holder.imageView = imageView;

                    holder.path = path;

                    Message message = Message.obtain();

                    message.obj = holder;

                    // Log.e("TAG", "mHandler.sendMessage(message);");

                    mHandler.sendMessage(message);

                    mPoolSemaphore.release();

                }

            });

        }

 

    }

 

    /**

     * 添加一个任务

     *

     * @param runnable

     */

    privatesynchronized void addTask(Runnable runnable) {

        try{

            // 请求信号量,防止mPoolThreadHander为null

            if(mPoolThreadHander == null)

                mSemaphore.acquire();

        }catch(InterruptedException e) {

        }

        mTasks.add(runnable);

 

        mPoolThreadHander.sendEmptyMessage(0x110);

    }

 

    /**

     * 取出一个任务

     *

     * @return

     */

    privatesynchronized Runnable getTask() {

        if(mType == Type.FIFO) {

            returnmTasks.removeFirst();

        }elseif (mType == Type.LIFO) {

            returnmTasks.removeLast();

        }

        returnnull;

    }

 

    /**

     * 单例获得该实例对象

     *

     * @return

     */

    publicstatic ImageLoader getInstance(intthreadCount, Type type) {

 

        if(mInstance == null) {

            synchronized(ImageLoader.class) {

                if(mInstance == null) {

                    mInstance = newImageLoader(threadCount, type);

                }

            }

        }

        returnmInstance;

    }

 

    /**

     * 根据ImageView获得适当的压缩的宽和高

     *

     * @param imageView

     * @return

     */

    privateImageSize getImageViewWidth(ImageView imageView) {

        ImageSize imageSize = newImageSize();

        finalDisplayMetrics displayMetrics = imageView.getContext()

                .getResources().getDisplayMetrics();

        finalLayoutParams params = imageView.getLayoutParams();

 

        intwidth = params.width == LayoutParams.WRAP_CONTENT ? 0: imageView

                .getWidth();// Get actual image width

        if(width <= 0)

            width = params.width; // Get layout width parameter

        if(width <= 0)

            width = getImageViewFieldValue(imageView, "mMaxWidth");// Check

                                                                    // maxWidth

                                                                    // parameter

        if(width <= 0)

            width = displayMetrics.widthPixels;

        intheight = params.height == LayoutParams.WRAP_CONTENT ? 0: imageView

                .getHeight();// Get actual image height

        if(height <= 0)

            height = params.height; // Get layout height parameter

        if(height <= 0)

            height = getImageViewFieldValue(imageView, "mMaxHeight");// Check

                                                                        // maxHeight

                                                                        // parameter

        if(height <= 0)

            height = displayMetrics.heightPixels;

        imageSize.width = width;

        imageSize.height = height;

        returnimageSize;

 

    }

 

    /**

     * 从LruCache中获取一张图片,如果不存在就返回null。

     */

    privateBitmap getBitmapFromLruCache(String key) {

        returnmLruCache.get(key);

    }

 

    /**

     * 往LruCache中添加一张图片

     *

     * @param key

     * @param bitmap

     */

    privatevoid addBitmapToLruCache(String key, Bitmap bitmap) {

        if(getBitmapFromLruCache(key) == null) {

            if(bitmap != null)

                mLruCache.put(key, bitmap);

        }

    }

 

    /**

     * 计算inSampleSize,用于压缩图片

     *

     * @param options

     * @param reqWidth

     * @param reqHeight

     * @return

     */

    privateint calculateInSampleSize(BitmapFactory.Options options,

            intreqWidth, intreqHeight) {

        // 源图片的宽度

        intwidth = options.outWidth;

        intheight = options.outHeight;

        intinSampleSize = 1;

 

        if(width > reqWidth && height > reqHeight) {

            // 计算出实际宽度和目标宽度的比率

            intwidthRatio = Math.round((float) width / (float) reqWidth);

            intheightRatio = Math.round((float) width / (float) reqWidth);

            inSampleSize = Math.max(widthRatio, heightRatio);

        }

        returninSampleSize;

    }

 

    /**

     * 根据计算的inSampleSize,得到压缩后图片

     *

     * @param pathName

     * @param reqWidth

     * @param reqHeight

     * @return

     */

    privateBitmap decodeSampledBitmapFromResource(String pathName,

            intreqWidth, intreqHeight) {

        // 第一次解析将inJustDecodeBounds设置为true,来获取图片大小

        finalBitmapFactory.Options options = newBitmapFactory.Options();

        options.inJustDecodeBounds = true;

        BitmapFactory.decodeFile(pathName, options);

        // 调用上面定义的方法计算inSampleSize值

        options.inSampleSize = calculateInSampleSize(options, reqWidth,

                reqHeight);

        // 使用获取到的inSampleSize值再次解析图片

        options.inJustDecodeBounds = false;

        Bitmap bitmap = BitmapFactory.decodeFile(pathName, options);

 

        returnbitmap;

    }

 

    privateclass ImgBeanHolder {

        Bitmap bitmap;

        ImageView imageView;

        String path;

    }

 

    privateclass ImageSize {

        intwidth;

        intheight;

    }

 

    /**

     * 反射获得ImageView设置的最大宽度和高度

     *

     * @param object

     * @param fieldName

     * @return

     */

    privatestatic int getImageViewFieldValue(Object object, String fieldName) {

        intvalue = 0;

        try{

            Field field = ImageView.class.getDeclaredField(fieldName);

            field.setAccessible(true);

            intfieldValue = (Integer) field.get(object);

            if(fieldValue > 0&& fieldValue < Integer.MAX_VALUE) {

                value = fieldValue;

            }

        }catch(Exception e) {

        }

        returnvalue;

    }

 

}

使用很简单,如果你在是Adapter中,

双击代码复制

ImageItem item = getItem(position);

        String path = item.getPath();

        ImageView imageView = holder.getImageView(R.id.img_plant);

        ImageLoader.getInstance().loadImage(path, imageView);

        imageView.setImageResource(R.drawable.pictures_no);

本站声明: 本文章由作者或相关机构授权发布,目的在于传递更多信息,并不代表本站赞同其观点,本站亦不保证或承诺内容真实性等。需要转载请联系该专栏作者,如若文章内容侵犯您的权益,请及时联系本站删除。
换一批
延伸阅读

LED驱动电源的输入包括高压工频交流(即市电)、低压直流、高压直流、低压高频交流(如电子变压器的输出)等。

关键字: 驱动电源

在工业自动化蓬勃发展的当下,工业电机作为核心动力设备,其驱动电源的性能直接关系到整个系统的稳定性和可靠性。其中,反电动势抑制与过流保护是驱动电源设计中至关重要的两个环节,集成化方案的设计成为提升电机驱动性能的关键。

关键字: 工业电机 驱动电源

LED 驱动电源作为 LED 照明系统的 “心脏”,其稳定性直接决定了整个照明设备的使用寿命。然而,在实际应用中,LED 驱动电源易损坏的问题却十分常见,不仅增加了维护成本,还影响了用户体验。要解决这一问题,需从设计、生...

关键字: 驱动电源 照明系统 散热

根据LED驱动电源的公式,电感内电流波动大小和电感值成反比,输出纹波和输出电容值成反比。所以加大电感值和输出电容值可以减小纹波。

关键字: LED 设计 驱动电源

电动汽车(EV)作为新能源汽车的重要代表,正逐渐成为全球汽车产业的重要发展方向。电动汽车的核心技术之一是电机驱动控制系统,而绝缘栅双极型晶体管(IGBT)作为电机驱动系统中的关键元件,其性能直接影响到电动汽车的动力性能和...

关键字: 电动汽车 新能源 驱动电源

在现代城市建设中,街道及停车场照明作为基础设施的重要组成部分,其质量和效率直接关系到城市的公共安全、居民生活质量和能源利用效率。随着科技的进步,高亮度白光发光二极管(LED)因其独特的优势逐渐取代传统光源,成为大功率区域...

关键字: 发光二极管 驱动电源 LED

LED通用照明设计工程师会遇到许多挑战,如功率密度、功率因数校正(PFC)、空间受限和可靠性等。

关键字: LED 驱动电源 功率因数校正

在LED照明技术日益普及的今天,LED驱动电源的电磁干扰(EMI)问题成为了一个不可忽视的挑战。电磁干扰不仅会影响LED灯具的正常工作,还可能对周围电子设备造成不利影响,甚至引发系统故障。因此,采取有效的硬件措施来解决L...

关键字: LED照明技术 电磁干扰 驱动电源

开关电源具有效率高的特性,而且开关电源的变压器体积比串联稳压型电源的要小得多,电源电路比较整洁,整机重量也有所下降,所以,现在的LED驱动电源

关键字: LED 驱动电源 开关电源

LED驱动电源是把电源供应转换为特定的电压电流以驱动LED发光的电压转换器,通常情况下:LED驱动电源的输入包括高压工频交流(即市电)、低压直流、高压直流、低压高频交流(如电子变压器的输出)等。

关键字: LED 隧道灯 驱动电源
关闭