Android开发用Glide加载网络图片

Android开发用Glide加载网络图片

用Glide加载网络图片，已经是很老技术了。这里就分享个项目中自己总结的工具类。

一、用到的Glide的版本

api 'com.github.bumptech.glide:glide:4.13.2'
kapt 'com.github.bumptech.glide:glide:4.13.2'

二、Glide工具类

ImageLoader

object ImageLoader {

    /**
     * 创建控件
     */
    fun createView(context: Context): ImageView {
        return ImageView(context)
    }

    /**
     * 加载圆形图，一般是头像
     *
     * @param iv 目标 view
     * @param avatar 图片地址
     */
    @JvmOverloads
    fun loadAvatar(
        iv: ImageView?,
        avatar: Any?,
        isCircle: Boolean = true,
        isRadius: Boolean = false,
        radiusSize: Int = 4,
        defaultResId: Int = R.mipmap.ic_default,
        skipCache: Boolean = false
    ) {
        iv?.let {
            val options = Options(avatar, defaultResId, isCircle, isRadius, radiusSize)
            load(options, it, skipCache)
        }

    }

    /**
     * time : 2023/3/6 11:13
     * author : hpy
     * desc : 专门加载不做圆角之类处理的gif
     * loopCount : 循环次数
     * endCallback : 固定循环次数时候的结束回调
     */
    @JvmOverloads
    fun loadGif(iv: ImageView?, cover: Any,loopCount:Int = 0,endCallback:(() -> Unit)? = null){
        iv?.let { imageView ->
            Glide.with(iv.context)
                .asGif()
                .listener(object :RequestListener<GifDrawable>{
                    override fun onLoadFailed(
                        e: GlideException?,
                        model: Any?,
                        target: Target<GifDrawable>?,
                        isFirstResource: Boolean
                    ): Boolean {
                        return false
                    }

                    override fun onResourceReady(
                        resource: GifDrawable?,
                        model: Any?,
                        target: Target<GifDrawable>?,
                        dataSource: DataSource?,
                        isFirstResource: Boolean
                    ): Boolean {
                        if(loopCount > 0){
                            resource?.run {
                                setLoopCount(1)
                                endCallback ?.let {
                                    registerAnimationCallback(object : Animatable2Compat.AnimationCallback() {
                                        override fun onAnimationEnd(drawable: Drawable?) {
                                            it()
                                        }
                                    })
                                }
                            }
                        }
                        return false
                    }
                })
                .diskCacheStrategy(DiskCacheStrategy.RESOURCE)
                .load(wrapOptions(Options(cover)).res)
                .into(imageView)
        }

    }

    /**
     * 加载封面图
     *
     * @param iv 目标 view
     * @param cover 图片地址
     * @param isRadius 是否圆角
     * @param radiusSize 圆角大小
     * @param isBlur 是否模糊
     */
    @JvmOverloads
    fun loadCover(
            iv: ImageView?,
            cover: Any?,
            isRadius: Boolean = false,
            radiusSize: Int = 8,
            radiusTL: Int = 0,
            radiusTR: Int = 0,
            radiusBL: Int = 0,
            radiusBR: Int = 0,
            isBlur: Boolean = false,
            thumbnailUrl: String = "",
            defaultResId: Int = R.drawable.ic_gf_default_photo,
            isGif: Boolean = false
    ) {
        iv?.let {
            val options = Options(
                cover,
                defaultResId,
                isRadius = isRadius,
                radiusSize = radiusSize,
                radiusTL = radiusTL,
                radiusTR = radiusTR,
                radiusBL = radiusBL,
                radiusBR = radiusBR,
                isBlur = isBlur,
                thumbnailUrl = thumbnailUrl
            )
            load(options, it,isGif = isGif)
        }

    }

    fun loadVideoThumbnail(
        iv: ImageView,
        path: Any?,
        isRadius: Boolean = true,
        radiusSize: Int = 4,
        size: Int = 256
    ) {
        val options = Options(
            path,
            isRadius = isRadius,
            radiusSize = radiusSize,
            isThumbnail = true,
            thumbnailSize = size,
            isVideo = true
        )
        load(options, iv)
    }

    /**
     * 加载缩略图
     *
     * @param iv 目标 view
     * @param path 图片地址
     * @param isRadius 是否圆角
     * @param radiusSize 圆角大小
     * @param isBlur 是否模糊
     */
    fun loadThumbnail(
        iv: ImageView,
        path: Any?,
        isRadius: Boolean = true,
        radiusSize: Int = 4,
        size: Int = 256
    ) {
        val options = Options(
            path,
            isRadius = isRadius,
            radiusSize = radiusSize,
            isThumbnail = true,
            thumbnailSize = size
        )
        load(options, iv)
    }

    /**
     * 加载图片
     *
     * @param options   加载图片配置
     * @param imageView 目标 view
     */
    private fun load(options: Options, imageView: ImageView, skipCache: Boolean = false, isGif: Boolean = false) {
        val requestOptions = RequestOptions()
        if (options.isCircle) {
            requestOptions.circleCrop()
        } else if (options.isRadius) {
            requestOptions.transform(
                MultiTransformation(
                    CenterCrop(),
                    RoundedCorners(options.radiusSize)
                )
            )
        }
        if (options.isBlur) {
            requestOptions.transform(BlurTransformation())
        }
        if (options.isThumbnail) {
            requestOptions.format(DecodeFormat.PREFER_RGB_565).override(options.thumbnailSize)
        }

        if (options.isVideo)
            requestOptions.skipMemoryCache(true).diskCacheStrategy(DiskCacheStrategy.ALL)
                .frame(10000000)
                .centerCrop()

        val wOptions = wrapOptions(options)
        //出现过activity被回收了，还在用它的context会报错，所以用application的context
        if (isGif) {
            Glide.with(imageView.context)
                .asGif()
                .diskCacheStrategy(DiskCacheStrategy.RESOURCE)
                .load(wOptions.res)
                .into(imageView)
        } else if (options.defaultResId == 0) {
            Glide.with(MyApplication.getInstance().applicationContext)
                .load(wOptions.res)
                .apply(requestOptions)
                .into(imageView)
        } else {
            val thumbnail = thumbnail(MyApplication.getInstance().applicationContext, wOptions)
            if (options.isCircle || options.isRadius) {
                val placeholder = placeholder(MyApplication.getInstance().applicationContext, wOptions)
                Glide.with(MyApplication.getInstance().applicationContext)
                    .load(wOptions.res)
                    .thumbnail(thumbnail)
                    .thumbnail(placeholder)
                    .skipMemoryCache(skipCache)
                    .diskCacheStrategy(if (skipCache) DiskCacheStrategy.NONE else DiskCacheStrategy.ALL)
                    .apply(requestOptions)
                    .into(imageView)
            } else {
                Glide.with(MyApplication.getInstance().applicationContext)
                    .load(wOptions.res)
                    .apply(requestOptions)
                    .thumbnail(thumbnail)
                    .placeholder(wOptions.defaultResId)
                    .into(imageView)
            }
        }
    }

    /**
     * 处理占位图
     *
     * @param context 上下文对象
     * @param options 加载配置
     * @return
     */
    private fun placeholder(context: Context, options: Options): RequestBuilder<Drawable> {
        val requestOptions = RequestOptions()
        if (options.isCircle) {
            requestOptions.circleCrop()
        } else if (options.isRadius) {
            requestOptions.transform(
                MultiTransformation(
                    CenterCrop(),
                    RoundedCorners(options.radiusSize)
                )
            )
        }
        if (options.isBlur) {
            requestOptions.transform(BlurTransformation())
        }
        return Glide.with(context).load(options.defaultResId).apply(requestOptions)
    }

    /**
     * 处理缩略图
     *
     * @param context 上下文对象
     * @param options 加载配置
     * @return
     */
    private fun thumbnail(context: Context, options: Options): RequestBuilder<Drawable> {
        val requestOptions = RequestOptions()
        if (options.isCircle) {
            requestOptions.circleCrop()
        } else if (options.isRadius) {
            requestOptions.transform(
                MultiTransformation(
                    CenterCrop(),
                    RoundedCorners(options.radiusSize)
                )
            )
        }
        if (options.isBlur) {
            requestOptions.transform(BlurTransformation())
        }
        return Glide.with(context).load(options.thumbnailUrl).apply(requestOptions)
    }

    /**
     * 包装下图片加载属性
     */
    private fun wrapOptions(options: Options): Options {
        if (options.res is String && (options.res as String).indexOf("http") != 0) {
            if ((options.res as String).indexOf("file:///") == 0 || (options.res as String).indexOf("content:///") == 0) {
                options.res = Uri.parse(options.res as String)
            } else if ((options.res as String).indexOf("/storage") != 0) {
                options.res =  options.res
            }
        }
        return options
    }


    /**
     * 加载图片配置
     */
    data class Options(
        // 图片资源，可以为 Uri/String/resId
        var res: Any?,
        // 默认资源
        var defaultResId: Int = R.mipmap.ic_default,
        // 是否圆形
        var isCircle: Boolean = false,
        // 圆角
        var isRadius: Boolean = false,
        var radiusSize: Int = 4,
        var radiusTL: Int = 0,
        var radiusTR: Int = 0,
        var radiusBL: Int = 0,
        var radiusBR: Int = 0,
        // 是否模糊
        var isBlur: Boolean = false,
        // 缩略图
        var thumbnailUrl: String = "",
        var isThumbnail: Boolean = false,
        var thumbnailSize: Int = 256,

        // 参考参数，防盗链使用
        var referer: String = "",
        var isVideo: Boolean = false
    )

}

ImageLoaderUtils

object ImageLoaderUtils {
    /**
     * desc:普通加载图片
     * Created by congge on 2018/9/4 11:14
     */
    @JvmStatic
    fun load(imageView: ImageView?, url: String?) {
        imageView?.let {
            loadCover(it, url)
        }
    }

    /**
     * @param corner 以dp为单位
     * desc:圆角图片
     * Created by congge on 2018/9/4 11:13
     */
    @JvmStatic
    fun loadCorner(imageView: ImageView?, url: String?, corner: Int) {
        imageView?.let {
            loadCover(it, url, true, corner)
        }

    }

    /**
     * @desc :带默认图的圆角网络图片
     * @author :congge on 2019/6/11 10:41
     */
    @JvmStatic
    fun loadCorner(imageView: ImageView?, url: String?, corner: Int, defaultDrawableId: Int) {
        imageView?.let {
            loadCover(it, url, true, corner,defaultResId = defaultDrawableId)
        }

    }

    /**
     * desc:圆角图片,圆角默认为5dp
     * Created by congge on 2018/9/4 11:13
     */
    @JvmStatic
    fun loadCornerDefault(imageView: ImageView?, url: String?) {
        imageView?.let {
            loadCover(it, url, true, radiusSize = 5)
        }
    }

    /**
     * desc:圆形图片
     * Created by congge on 2018/9/4 11:13
     */
    @JvmStatic
    fun loadCircular(imageView: ImageView?, url: String?, defaultDrawableId: Int) {
        imageView?.let {
            ImageLoader.loadAvatar(it,url,defaultResId = defaultDrawableId)
        }
    }

    @JvmStatic
    fun loadCircular(imageView: ImageView?, url: String?) {
        imageView?.let {
            ImageLoader.loadAvatar(it,url)
        }
    }

}

用ImageLoader和ImageLoaderUtils都行，看你喜欢

三、使用案例示例代码：

        ImageLoaderUtils.loadCircular((ImageView) helper.getView(R.id.iv_head), userBean.getHeadImg().getSmallHeadImg());