package com.wd.common.imageglide;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.media.MediaMetadataRetriever;
import android.media.ThumbnailUtils;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.Uri;
import android.provider.MediaStore;
import android.text.TextUtils;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;

import androidx.annotation.DrawableRes;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;


import com.bumptech.glide.Glide;
import com.bumptech.glide.Priority;
import com.bumptech.glide.RequestBuilder;
import com.bumptech.glide.load.DataSource;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.bumptech.glide.load.engine.GlideException;
import com.bumptech.glide.load.resource.bitmap.RoundedCorners;
import com.bumptech.glide.load.resource.drawable.DrawableTransitionOptions;
import com.bumptech.glide.load.resource.gif.GifDrawable;
import com.bumptech.glide.request.FutureTarget;
import com.bumptech.glide.request.RequestFutureTarget;
import com.bumptech.glide.request.RequestListener;
import com.bumptech.glide.request.RequestOptions;
import com.bumptech.glide.request.target.BitmapImageViewTarget;
import com.bumptech.glide.request.target.CustomTarget;
import com.bumptech.glide.request.target.Target;
import com.bumptech.glide.request.transition.Transition;
import com.wd.fastcoding.base.R;
import com.wd.foundation.bean.custom.MenuBean;
import com.wd.foundation.wdkit.image.GlideApp;
import com.wd.foundation.wdkit.image.GlideOptions;
import com.wd.foundation.wdkit.utils.BitMapUtils;
import com.wd.foundation.wdkit.utils.ColorUtils;
import com.wd.foundation.wdkit.utils.DeviceUtil;
import com.wd.foundation.wdkit.utils.FileZipUtils;
import com.wd.foundation.wdkit.utils.SpUtils;
import com.wd.foundation.wdkit.utils.UiUtils;
import com.wd.foundation.wdkit.view.RenderViewOutlineProvider;
import com.wd.foundation.wdkitcore.tools.AppContext;
import com.wd.foundation.wdkitcore.tools.StringUtils;

import org.jetbrains.annotations.NotNull;
import org.libpag.PAGFile;
import org.libpag.PAGView;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.SoftReference;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;


/**
 * @author yzm
 * @date 2022/7/4
 * @time 17:31.
 */
public class ImageUtils {
    /**
     * 圆角角度
     */
    private static final int ANGLENUM = 6;

    /**
     * 主题背景图
     */
    public static Bitmap defaultThemeBitmap = null;

    private Map<String, SoftReference<Bitmap>> bitmapList = new HashMap<>();
    /**
     * 图片地址是否正确
     */
    private static boolean isLoadSuccess = false;

    private ImageUtils() {
    }

    private static class Holder {
        private static final ImageUtils INSTANCE = new ImageUtils();
    }

    public static ImageUtils getInstance() {
        return Holder.INSTANCE;
    }

    /**
     * 优先加载的图片
     *
     * @param imageView
     * @param url
     */
    public void loadImageHighLev(ImageView imageView, String url) {

        if (imageView == null) {
            return;
        }

        try {
            GlideApp.with(AppContext.getContext())
                    .load(url)
                    .priority(Priority.HIGH)
                    .apply(new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA))
                    .into(imageView);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 优先加载的图片
     */
    public void loadImageHighLev(ImageView imageView, String url, @DrawableRes int defaultImg) {
        if (imageView == null) {
            return;
        }
        try {
            GlideApp.with(imageView.getContext())
                    .load(url)
                    .priority(Priority.HIGH)
                    .apply(new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA))
                    .placeholder(defaultImg)
                    .error(defaultImg)
                    .into(imageView);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 优先加载的图片
     */
    public void loadImageHighLev(ImageView imageView, String url, RequestListener<Drawable> listener) {
        if (imageView == null || TextUtils.isEmpty(url)) {
            return;
        }
        try {
            GlideApp.with(imageView.getContext())
                    .load(url)
                    .priority(Priority.HIGH)
                    .apply(new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA))
                    .addListener(listener)
                    .into(imageView);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 优先加载的图片
     */
    public void loadImageHighLev(ImageView imageView, File file, RequestListener<Drawable> listener) {
        if (imageView == null || file == null) {
            return;
        }
        try {
            GlideApp.with(imageView.getContext())
                    .load(file)
                    .priority(Priority.HIGH)
                    .apply(new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA))
                    .addListener(listener)
                    .into(imageView);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 清理图片缓存
     */
    public void clearCacheBitmapList() {

        if (bitmapList.size() > 0) {
            bitmapList.clear();
        }

    }

    /**
     * 首页背景图加载和保存 （其它地方慎用）
     *
     * @param imageView
     * @param height
     * @param url
     */
    public void homeThemeImageLoadAndSave(ImageView imageView, int height, String url, int placeholder) {
        if (imageView == null) {
            return;
        }

        try {
            if (!TextUtils.isEmpty(url) && url.contains(".gif")) {
                GlideApp.with(AppContext.getContext()).load(url).apply(baseNoDefaultOptions()).into(imageView);
            } else {

                // 相同控件加载不同图片资源的默认图，用上一个url产生的bitmap作为默认图,无则为ull
                defaultThemeBitmap = null;

                if (!TextUtils.isEmpty(url)) {
                    Object object = imageView.getTag();
                    if (object != null) {
                        String cacheImageUrl = (String) object;
                        if (bitmapList.containsKey(cacheImageUrl)) {
                            SoftReference<Bitmap> imageBitmap = bitmapList.get(cacheImageUrl);
                            if (imageBitmap != null) {
                                defaultThemeBitmap = imageBitmap.get();
                            }
                        }
                    }

                    boolean flag = !avoidDoubleSameUrl(imageView, url);
                    if (flag) {
                        return;
                    }

                    if (!TextUtils.isEmpty(url) && bitmapList.containsKey(url)) {
                        SoftReference<Bitmap> imageBitmap = bitmapList.get(url);
                        if (imageBitmap != null) {
                            imageView.setImageBitmap(imageBitmap.get());
                            return;
                        }
                    }
                } else {
                    imageView.setTag(null);

                }

                GlideApp.with(AppContext.getContext())
                        .asBitmap()
                        .load(url)
                        .apply(baseThemeBgScreenOptions(defaultThemeBitmap, placeholder))
                        .into(new BitmapImageViewTarget(imageView) {

                            @Override
                            protected void setResource(Bitmap bitmap) {

                                if (bitmap != null) {
                                    Bitmap newBitmap = zoomCropBitmap(bitmap, 0, height, true);
                                    if (newBitmap != null) {
                                        imageView.setImageBitmap(newBitmap);

                                        if (!bitmapList.containsKey(url)) {
                                            // 把bitmap copy出新的bitmap 收集起来，因为glide 会把收集的bitmap内容修改掉
                                            Bitmap copybitmap =
                                                    Bitmap.createBitmap(newBitmap.getWidth(), newBitmap.getHeight(), newBitmap.getConfig());

                                            Canvas canvas = new Canvas(copybitmap);
                                            Paint paint = new Paint();
                                            canvas.drawBitmap(newBitmap, new Matrix(), paint);

                                            SoftReference<Bitmap> softBitmap = new SoftReference<Bitmap>(newBitmap);
                                            bitmapList.put(url, softBitmap);
                                        }
                                    }
                                }
                            }
                        });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 使用Glide方式获取视频某一帧
     * @param context 上下文
     * @param uri 视频地址
     * @param imageView 设置image
     */
    public  void loadVideoScreenshot(final Context context, String uri, ImageView imageView) {

        Glide.with(context)
                .setDefaultRequestOptions(
                        new RequestOptions()
                                .frame(0)
                                .centerCrop()
                )
                .load(uri)
                .into(imageView);

    }
    /**
     * 使用MediaMetadataRetriever方式获取视频某一帧
     */
    public  Bitmap createVideoThumbnail(String filePath, int kind) {
        Bitmap bitmap = null;
        MediaMetadataRetriever retriever = new MediaMetadataRetriever();
        try {
            if (filePath.startsWith("http://")
                    || filePath.startsWith("https://")
                    || filePath.startsWith("widevine://")) {
                retriever.setDataSource(filePath, new Hashtable<String, String>());
            } else {
                retriever.setDataSource(filePath);
            }
            bitmap = retriever.getFrameAtTime(0, MediaMetadataRetriever.OPTION_CLOSEST_SYNC); //retriever.getFrameAtTime(-1);
        } catch (IllegalArgumentException ex) {
            // Assume this is a corrupt video file
            ex.printStackTrace();
        } catch (RuntimeException ex) {
            // Assume this is a corrupt video file.
            ex.printStackTrace();
        } finally {
            try {
                retriever.release();
            } catch (RuntimeException ex) {
                // Ignore failures while cleaning up.
                ex.printStackTrace();
            }
        }

        if (bitmap == null) {
            return null;
        }

        if (kind == MediaStore.Images.Thumbnails.MINI_KIND) {//压缩图片 开始处
            // Scale down the bitmap if it's too large.
            int width = bitmap.getWidth();
            int height = bitmap.getHeight();
            int max = Math.max(width, height);
            if (max > 512) {
                float scale = 512f / max;
                int w = Math.round(scale * width);
                int h = Math.round(scale * height);
                bitmap = Bitmap.createScaledBitmap(bitmap, w, h, true);
            }//压缩图片 结束处
        } else if (kind == MediaStore.Images.Thumbnails.MICRO_KIND) {
            bitmap = ThumbnailUtils.extractThumbnail(bitmap,
                    96,
                    96,
                    ThumbnailUtils.OPTIONS_RECYCLE_INPUT);
        }
        return bitmap;
    }

    /**
     * 为ImageView加载图片
     *
     * @param imageView
     * @param url
     */
    public void loadImage(ImageView imageView, String url) {
        if (imageView == null) {
            return;
        }
        if (TextUtils.isEmpty(url)) {
            imageView.setTag("");
            GlideApp.with(AppContext.getContext())
                    .load(R.drawable.rmrb_placeholder_default)
                    .apply(baseOptions())
                    .into(imageView);
            return;
        }
        if (!avoidDoubleSameUrl(imageView, url)) {
            return;
        }
        try {
            if (url.contains(".gif")) {
                GlideApp.with(AppContext.getContext()).load(url).apply(baseGifOptions()).into(imageView);
            } else {
                GlideApp.with(AppContext.getContext()).load(url).apply(baseOptions()).into(imageView);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 为ImageView加载图片
     *
     * @param imageView
     * @param url
     * @param placeholderImg 携带制定默认图
     */
    public void loadImage(ImageView imageView, String url, int placeholderImg) {
        if (imageView == null) {
            return;
        }
        if (TextUtils.isEmpty(url)) {
            imageView.setTag("");
            GlideApp.with(AppContext.getContext())
                    .load(placeholderImg)
                    .apply(baseOptions(placeholderImg, placeholderImg))
                    .into(imageView);
            return;
        }
        if (!avoidDoubleSameUrl(imageView, url)) {
            return;
        }
        try {
            if (url.contains(".gif")) {
                GlideApp.with(AppContext.getContext()).load(url).apply(baseGifOptions(placeholderImg, placeholderImg)).into(imageView);
            } else {
                GlideApp.with(AppContext.getContext()).load(url).apply(baseOptions(placeholderImg, placeholderImg)).into(imageView);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 加载本地资源
     *
     * @param imageView
     * @param url
     */
    public void loadImage(ImageView imageView, int url) {
        if (imageView == null) {
            return;
        }
        try {
            GlideApp.with(AppContext.getContext()).load(url).apply(baseGifOptions()).into(imageView);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 加载本地资源
     *
     * @param imageView
     * @param url
     * @param placeholderImg
     * @param errorImg
     */
    public void loadImage(ImageView imageView, int url, int placeholderImg, int errorImg) {
        if (imageView == null) {
            return;
        }
        try {
            GlideApp.with(AppContext.getContext()).load(url).apply(baseGifOptions(placeholderImg, errorImg)).into(imageView);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 为ImageView加载图片
     *
     * @param context
     * @param url
     */
    public void preloadImage(Context context, String url) {
        preloadImage(context, url, new RequestListener<Drawable>() {
            @Override
            public boolean onLoadFailed(@Nullable GlideException e, Object model, Target<Drawable> target,
                                        boolean isFirstResource) {
                return false;
            }

            @Override
            public boolean onResourceReady(Drawable resource, Object model, Target<Drawable> target,
                                           DataSource dataSource, boolean isFirstResource) {
                // Logger.e("预加载成功="+url);
                return true;
            }
        });
    }

    /**
     * 为ImageView加载图片
     *
     * @param context
     * @param url
     */
    public void preloadImage(Context context, String url, RequestListener<Drawable> requestListener) {
        if (TextUtils.isEmpty(url) || context == null) {
            return;
        }

        try {
            // url = getOssUrl(context, url);
            GlideApp.with(context)
                    .load(url)
                    .diskCacheStrategy(DiskCacheStrategy.DATA)
                    .listener(requestListener)
                    .preload();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 为ImageView加载图片缓存到本地
     *
     * @param context
     * @param url
     */
    public void preloadImageInDir(Context context, String url) {
        if (TextUtils.isEmpty(url) || context == null) {
            return;
        }
        try {
            FutureTarget<File> target =
                    GlideApp.with(context).load(url).diskCacheStrategy(DiskCacheStrategy.ALL).downloadOnly(Target.SIZE_ORIGINAL, Target.SIZE_ORIGINAL);
            // Logger.e("加载预览地址" + url);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 加载圆角图片
     *
     * @param imageView
     * @param url
     * @param defaultImg
     */
    public void loadAngleImage(ImageView imageView, String url, @DrawableRes int defaultImg) {

        if (imageView == null) {
            return;
        }

        if (TextUtils.isEmpty(url)) {
            GlideApp.with(AppContext.getContext())
                    .load(defaultImg)
                    .apply(baseAngleOptions(defaultImg, imageView, ANGLENUM))
                    .into(imageView);
            return;
        }

        // 防止刷新相同资源图片加载闪烁
        if (!avoidDoubleSameUrl(imageView, url)) {
            return;
        }
        try {

            if (url.contains(".gif")) {
                GlideApp.with(AppContext.getContext())
                        .load(url)
                        .apply(baseGifOptions(defaultImg, defaultImg, imageView, ANGLENUM))
                        .into(imageView);
            } else {
                GlideApp.with(AppContext.getContext())
                        .load(url)
                        .apply(baseAngleOptions(defaultImg, imageView, ANGLENUM))
                        .into(imageView);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void loadAngleImage(ImageView imageView, String url, Bitmap defaultImg, int angleInt) {

        imageView.setOutlineProvider(new RenderViewOutlineProvider(UiUtils.dp2px(angleInt)));
        imageView.setClipToOutline(true);
        if (imageView == null) {
            return;
        }

        if (TextUtils.isEmpty(url)) {
            imageView.setTag("");
            GlideApp.with(AppContext.getContext())
                    .load(defaultImg)
                    .apply(baseAngleOptions(defaultImg, imageView))
                    .into(imageView);
            return;
        }

        // 防止刷新相同资源图片加载闪烁
        if (!avoidDoubleSameUrl(imageView, url)) {
            return;
        }
        try {

            if (url.contains(".gif")) {
                GlideApp.with(AppContext.getContext())
                        .load(url)
                        .apply(baseGifOptions(defaultImg, defaultImg, imageView))
                        .into(imageView);
            } else {
                GlideApp.with(AppContext.getContext())
                        .load(url)
                        .apply(baseAngleOptions(defaultImg, imageView))
                        .into(imageView);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void loadAngleImage(ImageView imageView, String url) {
        loadAngleImage(imageView, url, R.drawable.rmrb_placeholder_default, ANGLENUM);
    }

    /**
     * 加载原图到imageview
     * 对控件本体进行圆角处理
     *
     * @param imageView
     * @param url
     */
    public void loadUrlCircularImageView(ImageView imageView, String url) {
        loadUrlCircularImageView(imageView, url, R.drawable.rmrb_placeholder_default, ANGLENUM);
    }

    /**
     * 加载原图到imageview
     * 对控件本体进行圆角处理
     *
     * @param imageView
     * @param url
     * @param defaultImg
     * @param angleInt
     */
    public void loadUrlCircularImageView(ImageView imageView, String url, @DrawableRes int defaultImg, int angleInt) {

        imageView.setOutlineProvider(new RenderViewOutlineProvider(UiUtils.dp2px(angleInt)));
        imageView.setClipToOutline(true);

        if (imageView == null) {
            return;
        }

        if (TextUtils.isEmpty(url)) {
            imageView.setTag("");
            GlideApp.with(AppContext.getContext()).load(defaultImg).apply(baseOptions(defaultImg)).into(imageView);
            return;
        }

        // 防止刷新相同资源图片加载闪烁
        if (!avoidDoubleSameUrl(imageView, url)) {
            return;
        }
        try {

            if (url.contains(".gif")) {
                GlideApp.with(AppContext.getContext())
                        .load(url)
                        .apply(baseOgifOptions(defaultImg, defaultImg))
                        .into(imageView);
            } else {
                GlideApp.with(AppContext.getContext())
                        .load(url)
                        .thumbnail(0.1f)
                        .apply(baseOptions(defaultImg))
                        .into(imageView);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 避免重复加载相同url
     *
     * @param imageView
     * @param url
     * @return true: 执行加载；false 停止继续加载图片
     */
    private boolean avoidDoubleSameUrl(ImageView imageView, String url) {
        if (TextUtils.isEmpty(url)) {
            return true;
        }
        if (imageView != null) {
            if (imageView.getTag() != null) {
                String tagUrl = (String) imageView.getTag();
                if (url.equals(tagUrl)) {
                    return false;
                }
            }
            imageView.setTag(url);
        }
        return true;
    }

    /**
     * 文件下载路径监听
     */
    public void loadAngleImage(ImageView imageView, String url, @DrawableRes int defaultImg, int angle) {

        if (imageView == null) {
            return;
        }
        if (TextUtils.isEmpty(url)) {
            imageView.setTag("");
            GlideApp.with(AppContext.getContext())
                    .load(defaultImg)
                    .apply(baseAngleOptions(defaultImg, imageView, angle))
                    .into(imageView);
            return;
        }
        if (!avoidDoubleSameUrl(imageView, url)) {
            return;
        }
        try {

            if (url.contains(".gif")) {
                GlideApp.with(AppContext.getContext())
                        .load(url)
                        .apply(baseGifOptions(defaultImg, defaultImg, imageView, angle))
                        .into(imageView);
            } else {
                GlideApp.with(AppContext.getContext())
                        .load(url)
                        .apply(baseAngleOptions(defaultImg, imageView, angle))
                        .into(imageView);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 加载圆形图片
     *
     * @param imageView
     * @param url
     * @placeholderImg 默认、错误图片
     */
    public void loadImageCircle(final ImageView imageView, String url, @DrawableRes int defaultImg,RequestListener listener) {
        if (imageView == null) {
            return;
        }
        if (TextUtils.isEmpty(url)) {
            imageView.setTag("");
            GlideApp.with(AppContext.getContext())
                    .load(defaultImg)
                    .listener(listener)
                    .apply(baseCicleOptions(defaultImg, defaultImg))
                    .into(imageView);
            return;
        }
        if (!avoidDoubleSameUrl(imageView, url)) {
            return;
        }
        try {
            GlideApp.with(AppContext.getContext())
                    .load(url)
                    .listener(listener)
                    .apply(baseCicleOptions(defaultImg, defaultImg))
                    .into(imageView);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 加载圆形图片
     *
     * @param imageView
     * @param url
     * @placeholderImg 默认、错误图片
     */
    public void loadImageCircle(final ImageView imageView, String url, @DrawableRes int defaultImg) {
        if (imageView == null) {
            return;
        }
        if (TextUtils.isEmpty(url)) {
            imageView.setTag("");
            GlideApp.with(AppContext.getContext())
                    .load(defaultImg)
                    .apply(baseCicleOptions(defaultImg, defaultImg))
                    .into(imageView);
            return;
        }
        if (!avoidDoubleSameUrl(imageView, url)) {
            return;
        }
        try {
            GlideApp.with(AppContext.getContext())
                    .load(url)
                    .apply(baseCicleOptions(defaultImg, defaultImg))
                    .into(imageView);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 加载圆形图片
     *
     * @param imageView
     * @param url
     * @placeholderImg 默认、错误图片
     */
    public void loadImageCrop(final ImageView imageView, String url) {
        if (imageView == null) {
            return;
        }
        if (TextUtils.isEmpty(url)) {
            imageView.setTag("");
            GlideApp.with(AppContext.getContext())
                    .load(R.drawable.rmrb_placeholder_default)
                    .apply(baseOptions().centerCrop())
                    .into(imageView);
            return;
        }
        if (!avoidDoubleSameUrl(imageView, url)) {
            return;
        }
        try {
            if (url.contains(".gif")) {
                GlideApp.with(AppContext.getContext()).load(url).apply(baseGifOptions().centerCrop()).into(imageView);
            } else {
                GlideApp.with(AppContext.getContext()).load(url).apply(baseOptions().centerCrop()).into(imageView);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * error图片和默认图片不一样
     *
     * @param imageView
     * @param url
     * @param defaultImg 默认图片
     * @param errorImg   错误图片
     */
    public void loadImageDifferent(ImageView imageView, String url, @DrawableRes int defaultImg, int errorImg) {
        if (imageView == null) {
            return;
        }

        if (TextUtils.isEmpty(url)) {
            imageView.setTag("");
            GlideApp.with(AppContext.getContext())
                    .load(defaultImg)
                    .transition(new DrawableTransitionOptions().crossFade())
                    .apply(baseOptions(defaultImg, errorImg))
                    .into(imageView);
            return;
        }

        if (!avoidDoubleSameUrl(imageView, url)) {
            return;
        }
        try {

            if (url.contains(".gif")) {
                GlideApp.with(AppContext.getContext())
                        .load(url)
                        .transition(new DrawableTransitionOptions().crossFade())
                        .apply(baseGifOptions(defaultImg, errorImg, imageView, ANGLENUM))
                        .into(imageView);
            } else {
                GlideApp.with(AppContext.getContext())
                        .load(url)
                        .transition(new DrawableTransitionOptions().crossFade())
                        .apply(baseOptions(defaultImg, errorImg))
                        .into(imageView);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 加载图片有回调
     *
     * @param imageView
     * @param url
     * @param defaultImg 默认图
     * @param errorImg   加载异常占位图
     * @param listener   加载监听
     */
    public void loadImageHaveListener(Context context, ImageView imageView, String url, @DrawableRes int defaultImg, int errorImg, RequestListener listener) {
        if (imageView == null) {
            return;
        }
        if (TextUtils.isEmpty(url)) {
            imageView.setTag("");
            GlideApp.with(AppContext.getContext())
                    .load(defaultImg)
                    .listener(listener)
                    .transition(new DrawableTransitionOptions().crossFade())
                    .apply(baseOptions(defaultImg, errorImg))
                    .into(imageView);
            return;
        }
        if (!avoidDoubleSameUrl(imageView, url)) {
            return;
        }
        try {
            if (url.contains(".gif")) {
                GlideApp.with(AppContext.getContext())
                        .load(url)
                        .listener(listener)
                        .thumbnail(Glide.with(context).load(defaultImg))
                        .transition(new DrawableTransitionOptions().crossFade())
                        .apply(baseGifOptions(defaultImg, errorImg, imageView, ANGLENUM))
                        .into(imageView);
            } else {
                GlideApp.with(AppContext.getContext())
                        .load(url)
                        .listener(listener)
                        .thumbnail(Glide.with(context).load(defaultImg))
                        .transition(new DrawableTransitionOptions().crossFade())
                        .apply(baseOptions(defaultImg, errorImg))
                        .into(imageView);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static RequestOptions baseOptions(@DrawableRes int placeholderImg, @DrawableRes int errorImg) {
        return new RequestOptions().placeholder(placeholderImg)
                .error(errorImg)
                .diskCacheStrategy(DiskCacheStrategy.DATA);
    }

    private static RequestOptions baseOptions() {
        return new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA)
                .placeholder(R.drawable.rmrb_placeholder_default)
                .error(R.drawable.rmrb_placeholder_default)
                .dontAnimate();
    }


    /**
     * 设置默认主题图
     *
     * @param defaultBitmap
     * @return
     */
    private RequestOptions baseThemeBgScreenOptions(Bitmap defaultBitmap, int placeholder) {

        RequestOptions options = new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA)
                .dontAnimate();
        if (defaultBitmap != null) {
            BitmapDrawable drawable = new BitmapDrawable(AppContext.getContext().getResources(), defaultBitmap);
            options.placeholder(drawable);
        } else {
            options.placeholder(placeholder);
        }

        return options;

    }

    private static RequestOptions baseCicleOptions(@DrawableRes int placeholderImg, @DrawableRes int errorImg) {
        return new RequestOptions().placeholder(placeholderImg)
                .error(errorImg)
                .circleCrop()
                .diskCacheStrategy(DiskCacheStrategy.DATA);
    }

    private static RequestOptions baseOptions(@DrawableRes int placeholderImg) {
        return new RequestOptions().centerCrop()
                .placeholder(placeholderImg)
                .diskCacheStrategy(DiskCacheStrategy.RESOURCE);
    }

    private static RequestOptions baseOgifOptions(@DrawableRes int placeholderImg, @DrawableRes int errorImg) {
        return new RequestOptions().placeholder(placeholderImg)
                .error(errorImg)
                .diskCacheStrategy(DiskCacheStrategy.DATA);
    }

    /**
     * 圆角图片
     *
     * @param imageView
     * @param angle
     * @return
     */
    private static RequestOptions baseAngleOptions(@DrawableRes int placeholderImg, ImageView imageView, int angle) {
        return new RequestOptions().centerCrop()
                .transform(new GlideRoundTransform(AppContext.getContext(), angle))
                .placeholder(placeholderImg)
                // .skipMemoryCache(true)
                .diskCacheStrategy(DiskCacheStrategy.DATA);
    }

    private static RequestOptions baseAngleOptions(Bitmap placeholderImg, ImageView imageView) {
        BitmapDrawable drawable = new BitmapDrawable(AppContext.getContext().getResources(), placeholderImg);
        return new RequestOptions().centerCrop()
                .placeholder(drawable)
                // .skipMemoryCache(true)
                .diskCacheStrategy(DiskCacheStrategy.DATA);
    }

    // GIF
    private static RequestOptions baseGifOptions(@DrawableRes int placeholderImg, @DrawableRes int errorImg,
                                                 ImageView imageView, int angle) {
        return new RequestOptions().placeholder(placeholderImg)
                .error(errorImg)
                .skipMemoryCache(true)
                .diskCacheStrategy(DiskCacheStrategy.DATA)
                .transform(new GlideRoundTransform(AppContext.getContext(), angle));
    }

    private static RequestOptions baseGifOptions(Bitmap placeholderImg, Bitmap errorImg, ImageView imageView) {

        BitmapDrawable drawable = new BitmapDrawable(AppContext.getContext().getResources(), placeholderImg);
        return new RequestOptions().placeholder(drawable)
                .error(drawable)
                .diskCacheStrategy(DiskCacheStrategy.DATA)
                .skipMemoryCache(true);
    }

    // GIF
    private static RequestOptions baseGifOptions(@DrawableRes int placeholderImg, @DrawableRes int errorImg) {
        return new RequestOptions().placeholder(placeholderImg)
                .error(errorImg)
                // .skipMemoryCache(true)
                .diskCacheStrategy(DiskCacheStrategy.DATA);
    }

    // GIF
    private static RequestOptions baseGifOptions() {
        return new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA)
                // .skipMemoryCache(true)
                .placeholder(R.drawable.rmrb_placeholder_default)
                .error(R.drawable.rmrb_placeholder_default);
    }

    // 不适用占位图和错误图
    private static RequestOptions baseNoDefaultOptions() {
        return new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA);
    }

    /**
     * 文件下载路径监听
     */
    public interface OnImageResultListener {
        void onResult(String localPath);
    }


    // 加载本地圆角图片
    public void loadAngleImage(ImageView imageView, File url, @DrawableRes int defaultImg) {

        if (imageView == null) {
            return;
        }

        if (TextUtils.isEmpty(url.getAbsolutePath())) {
            imageView.setTag("");
            GlideApp.with(AppContext.getContext())
                    .load(url)
                    .apply(baseAngleOptions(defaultImg, imageView, ANGLENUM))
                    .into(imageView);
            return;
        }

        // 防止刷新相同资源图片加载闪烁
        if (!avoidDoubleSameUrl(imageView, url.getAbsolutePath())) {
            return;
        }
        try {

            if (url.getAbsolutePath().contains(".gif")) {
                GlideApp.with(AppContext.getContext())
                        .load(url)
                        .apply(baseGifOptions(defaultImg, defaultImg, imageView, ANGLENUM))
                        .into(imageView);
            } else {
                GlideApp.with(AppContext.getContext())
                        .load(url)
                        .apply(baseAngleOptions(defaultImg, imageView, ANGLENUM))
                        .into(imageView);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 该方法调用时要放在子线程中
     *
     * @param imgUrl 网络资源图片路径
     * @return Bitmap
     */
    public static Bitmap netToLocalBitmap(String imgUrl) {
        Bitmap bitmap;
        try {
            // 对资源链接
            URL url = new URL(imgUrl);
            // 打开输入流
            InputStream inputStream = url.openStream();
            // 对网上资源进行下载转换位图图片
            bitmap = BitmapFactory.decodeStream(inputStream);
            inputStream.close();
            return bitmap;
        } catch (IOException e) {
            return null;
        }
    }

    /**
     * 设置底部导航tab 中文字颜色
     *
     * @param textView
     * @param tabData
     * @param selectedFlag
     * @param isImmersePageFlag 沉浸式
     */
    public void setBottomTabTextColor(TextView textView, MenuBean tabData, boolean selectedFlag, boolean isImmersePageFlag) {
        //设置文字颜色
        if (selectedFlag) {
            if (isImmersePageFlag) {
                ColorUtils.setTextColor(textView, StringUtils.isBlank(tabData.getImmersiveNameCColor()) ? "#CB0000" : tabData.getImmersiveNameCColor());
            } else {
                //夜间模式
                if (SpUtils.isNightMode()) {
                    ColorUtils.setTextColor(textView, StringUtils.isBlank(tabData.getNightNameCColor()) ? "#B71D26" : tabData.getNightNameCColor());
                }
                //日间模式
                else {
                    ColorUtils.setTextColor(textView, StringUtils.isBlank(tabData.getNameCColor()) ? "#CB0000" : tabData.getNameCColor());
                }
            }
        } else {
            if (isImmersePageFlag) {
                ColorUtils.setTextColor(textView, StringUtils.isBlank(tabData.getImmersiveNameColor()) ? "#999999" : tabData.getImmersiveNameColor());
            } else {
                //夜间模式
                if (SpUtils.isNightMode()) {
                    ColorUtils.setTextColor(textView, StringUtils.isBlank(tabData.getNightNameColor()) ? "#A3A3A3" : tabData.getNightNameColor());
                }
                //日间模式
                else {
                    ColorUtils.setTextColor(textView, StringUtils.isBlank(tabData.getNameColor()) ? "#888888" : tabData.getNameColor());
                }
            }
        }


    }

    /**
     * 加载选中的底部图片方法
     *
     * @param imageView
     * @param tabData
     * @param selectedFlag      true: 选中；false：未选中
     * @param isImmersePageFlag 沉浸式
     */
    public void loadBottomTabImage(ImageView imageView, MenuBean tabData, boolean selectedFlag, boolean isImmersePageFlag) {
        if (imageView == null) {
            return;
        }
        // 非沉浸式图标 url
        String url = null;
        // 非沉浸式图标 兜底icon
        int localIcon;
        //沉浸式图标 url
        String immerseUrl;
        //沉浸式图标 兜底icon
        int localImmerseIcon;
        if (selectedFlag) {
            if (SpUtils.isNightMode()) {
                //夜间
                url = tabData.getNightIconCUrl();
            } else {
                //日间
                url = tabData.getSelIcon();
            }
            localIcon = tabData.getLocalIconC();
            // 沉浸式 tab icon用准备 icon兜底，没有则用非沉浸式icon兜底
            localImmerseIcon = tabData.getLocalImmerseIconC() == 0 ? tabData.getLocalIconC() : tabData.getLocalImmerseIconC();
            immerseUrl = tabData.getImmersiveIconCUrl();

        } else {
            if (SpUtils.isNightMode()) {
                //夜间
                url = tabData.getNightIconUrl();
            } else {
                //日间
                url = tabData.getNormalIcon();
            }
            localIcon = tabData.getLocalIcon();
            // 沉浸式未选中tab icon用非沉浸式未选中tab icon 兜底
            localImmerseIcon = tabData.getLocalIcon();
            immerseUrl = tabData.getImmersiveIconUrl();
        }
        // 是否是沉浸式页面
        if (isImmersePageFlag) {
            if (url != null && url.contains(".gif")) {
                if ("default.gif".equals(url)) {
                    loadOneTimeGif(imageView, "", localImmerseIcon);
                } else {
                    loadOneTimeGif(imageView, immerseUrl, localImmerseIcon);
                }

            } else {
                loadImageHighLev(imageView, immerseUrl, localImmerseIcon);
            }
        } else {

            if (url != null && url.contains(".gif")) {
                if ("default.gif".equals(url)) {
                    loadOneTimeGif(imageView, "", localIcon);
                } else {
                    loadOneTimeGif(imageView, url, localIcon);
                }
            } else {
                loadImageHighLev(imageView, url, localIcon);
            }
        }

    }

    /**
     * 加载选中的底部图片方法
     *
     * @param imageView
     * @param tabData
     * @param selectedFlag      true: 选中；false：未选中
     * @param isImmersePageFlag 沉浸式
     */
    public void loadBottomTabImage(PAGView pageView, ImageView imageView, MenuBean tabData,
                                   boolean selectedFlag, boolean isImmersePageFlag) {
        if (imageView == null) {
            return;
        }
        // 非沉浸式图标 url
        String url = null;
        // 非沉浸式图标 兜底icon
        int localIcon;

        String localPag = tabData.getLocalPag();
        //沉浸式图标 url
        String immerseUrl;
        //沉浸式图标 兜底icon
        int localImmerseIcon;
        if (selectedFlag) {
            if (SpUtils.isNightMode()) {
                //夜间
                url = tabData.getNightIconCUrl();
            } else {
                //日间
                url = tabData.getSelIcon();
            }
            localIcon = tabData.getLocalIconC();
            // 沉浸式 tab icon用准备 icon兜底，没有则用非沉浸式icon兜底
            localImmerseIcon = tabData.getLocalImmerseIconC() == 0 ? tabData.getLocalIconC() : tabData.getLocalImmerseIconC();
            immerseUrl = tabData.getImmersiveIconCUrl();
            if (isImmersePageFlag) {
                localPag = tabData.getLocalImmPage();
            } else {
                localPag = tabData.getLocalPag();
            }


        } else {
            if (SpUtils.isNightMode()) {
                //夜间
                url = tabData.getNightIconUrl();
            } else {
                //日间
                url = tabData.getNormalIcon();
            }
            localIcon = tabData.getLocalIcon();
            // 沉浸式未选中tab icon用非沉浸式未选中tab icon 兜底
            localImmerseIcon = tabData.getLocalIcon();
            immerseUrl = tabData.getImmersiveIconUrl();
        }

        // 是否是沉浸式页面
        if (isImmersePageFlag) {
            // 沉浸式
            loadTabImage(pageView, imageView, immerseUrl, localImmerseIcon, localPag, selectedFlag);

        } else {
            // 非沉浸式
            loadTabImage(pageView, imageView, url, localIcon, localPag, selectedFlag);

        }
    }


    /**
     * 加载tab 图片、gif、pag资源
     *
     * @param pageView
     * @param imageView
     * @param url
     * @param localIcon
     * @param localPag
     */
    private void loadTabImage(PAGView pageView, ImageView imageView, String url, int localIcon, String localPag, boolean selectedFlag) {

        if (!TextUtils.isEmpty(url)) {
            if (url != null && url.contains(".gif")) {
                imageView.setVisibility(View.VISIBLE);

                if (pageView != null) {
                    pageView.setVisibility(View.INVISIBLE);
                    pageView.setAlpha(0);
                }

                if ("default.gif".equals(url)) {
                    loadOneTimeGif(imageView, "", localIcon);
                } else {
                    loadOneTimeGif(imageView, url, localIcon);
                }
            } else if (url != null && url.contains(".pag")) {
                imageView.setVisibility(View.INVISIBLE);
                if (pageView != null) {
                    pageView.setVisibility(View.VISIBLE);
                    pageView.setAlpha(1);

                    PAGFile.LoadAsync(url, new PAGFile.LoadListener() {
                        @Override
                        public void onLoad(PAGFile pagFile) {
                            if (pagFile == null) {
                                pagFile = PAGFile.Load(pageView.getContext().getAssets(), localPag);
                            }
                            pageView.setComposition(pagFile);
                            pageView.setRepeatCount(1);
                            pageView.play();
                        }
                    });
                }

            } else {
                imageView.setVisibility(View.VISIBLE);
                if (pageView != null) {
                    pageView.setVisibility(View.INVISIBLE);
                    pageView.setAlpha(0);
                }
                loadImageHighLev(imageView, url, localIcon);
            }

        } else {

//            if (selectedFlag) {
//                imageView.setVisibility(View.INVISIBLE);
//                if (pageView != null) {
//                    pageView.setVisibility(View.VISIBLE);
//                    pageView.setAlpha(1);
//
//                    PAGFile pagFile = PAGFile.Load(pageView.getContext().getAssets(), localPag);
//                    pageView.setComposition(pagFile);
//                    pageView.setRepeatCount(1);
//                    pageView.play();
//                }
//            } else {
            imageView.setVisibility(View.VISIBLE);
            if (pageView != null) {
                pageView.setVisibility(View.INVISIBLE);
                pageView.setAlpha(0);
            }
            loadImageHighLev(imageView, url, localIcon);
//            }

        }

    }

    /**
     * 加载图片资源和gif资源（gif资源只播放一次）
     *
     * @param imageView
     * @param url
     */
    public void loadChannelImageUrl(ImageView imageView, String url) {

        if (url != null && url.contains(".gif")) {
            if (url.contains("?")) {
                url = url.substring(0, url.indexOf("?"));
            }
            loadOneTimeGif(imageView, url, 0);
        } else {
            GlideApp.with(imageView.getContext())
                    .load(url)
                    .priority(Priority.HIGH)
                    .apply(new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA))
                    .into(imageView);
        }

    }

    /**
     * 加载一次gif
     */
    public void loadOneTimeGif(ImageView imageView, String url, @DrawableRes int defaultImg) {
        loadOneTimeGif(url, imageView, null, defaultImg);
    }

    /**
     * 加载一次gif
     */
    public void loadOneTimeGif(String url, final ImageView imageView, final GifListener gifListener,
                               @DrawableRes int defaultImg) {

        RequestOptions requestOptions = new RequestOptions().skipMemoryCache(true);
        try {
            RequestBuilder<GifDrawable> gifDrawableRequestBuilder = GlideApp.with(AppContext.getContext()).asGif();
            if (!TextUtils.isEmpty(url)) {
                gifDrawableRequestBuilder.load(url);
            } else {
                gifDrawableRequestBuilder.load(defaultImg);
            }
            gifDrawableRequestBuilder.apply(requestOptions).listener(new RequestListener<GifDrawable>() {
                @Override
                public boolean onLoadFailed(@Nullable GlideException e, Object model, Target<GifDrawable> target,
                                            boolean isFirstResource) {
                    return false;
                }

                @Override
                public boolean onResourceReady(GifDrawable resource, Object model, Target<GifDrawable> target,
                                               DataSource dataSource, boolean isFirstResource) {
                    try {
                        Field gifStateField = GifDrawable.class.getDeclaredField("state");
                        gifStateField.setAccessible(true);
                        Class gifStateClass =
                                Class.forName("com.bumptech.glide.load.resource.gif.GifDrawable$GifState");
                        Field gifFrameLoaderField = gifStateClass.getDeclaredField("frameLoader");
                        gifFrameLoaderField.setAccessible(true);
                        Class gifFrameLoaderClass =
                                Class.forName("com.bumptech.glide.load.resource.gif.GifFrameLoader");
                        Field gifDecoderField = gifFrameLoaderClass.getDeclaredField("gifDecoder");
                        gifDecoderField.setAccessible(true);
                        Class gifDecoderClass = Class.forName("com.bumptech.glide.gifdecoder.GifDecoder");
                        Object gifDecoder = gifDecoderField.get(gifFrameLoaderField.get(gifStateField.get(resource)));
                        Method getDelayMethod = gifDecoderClass.getDeclaredMethod("getDelay", int.class);
                        getDelayMethod.setAccessible(true);
                        // 设置只播放一次
                        resource.setLoopCount(1);

                        if (null != gifListener) {
                            // 获得总帧数
                            int count = resource.getFrameCount();
                            int delay = 0;
                            for (int i = 0; i < count; i++) {
                                // 计算每一帧所需要的时间进行累加
                                delay += (int) getDelayMethod.invoke(gifDecoder, i);
                            }
                            imageView.postDelayed(new Runnable() {
                                @Override
                                public void run() {
                                    if (gifListener != null) {
                                        gifListener.gifPlayComplete();
                                    }
                                }
                            }, delay);
                        }

                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    return false;
                }
            }).into(imageView);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Gif播放完毕回调
     */
    public interface GifListener {
        void gifPlayComplete();
    }


    /**
     * 处理图片
     *
     * @param bitmap 所要转换的bitmap
     * @param dst_w  新的宽
     * @param dst_h  新的高
     * @return 指定宽高的bitmap
     */
    public Bitmap zoomImg(Bitmap bitmap, int dst_w, int dst_h) {

        if (bitmap == null) {
            return null;
        }
        int src_w = bitmap.getWidth();
        int src_h = bitmap.getHeight();
        float scale_w = ((float) dst_w) / src_w;
        float scale_h = ((float) dst_h) / src_h;
        Matrix matrix = new Matrix();
        matrix.postScale(scale_w, scale_h);
        Bitmap dstbmp = Bitmap.createBitmap(bitmap, 0, 0, src_w, src_h, matrix, true);
        return dstbmp;
    }

    /**
     * 分享图片裁剪
     *
     * @param bitmap
     * @return
     */
    public Bitmap getShareZoomImg(Bitmap bitmap, int dst_w, int dst_h) {
        if (bitmap == null) {
            return null;
        }
        int x = 0;
        int y = 0;
        int outputSize = 150;
        int src_w = bitmap.getWidth();
        int src_h = bitmap.getHeight();
        if (src_w > src_h) {
            x = (src_w - src_h) / 2;
            outputSize = src_h;
        } else if (src_w < src_h) {
            y = (src_h - src_w) / 2;
            outputSize = src_w;
        } else {
            outputSize = src_w;
        }
        Bitmap tempBitmap = Bitmap.createBitmap(bitmap, x, y, outputSize, outputSize);
        return zoomImg(tempBitmap, dst_w, dst_h);
    }

    /**
     * 文字绘制到图片上
     *
     * @param text          文字内容
     * @param imgResourceId 目标图
     * @param mContext
     * @return
     */
    public static Bitmap drawText2Bitmap(String text, int imgResourceId, Context mContext) {
        try {
            Resources resources = mContext.getResources();
            float scale = resources.getDisplayMetrics().density;
            Bitmap bitmap = BitmapFactory.decodeResource(resources, imgResourceId);

            Bitmap.Config bitmapConfig = bitmap.getConfig();
            // set default bitmap config if none
            if (bitmapConfig == null) {
                bitmapConfig = Bitmap.Config.ARGB_8888;
            }
            // resource bitmaps are imutable, so we need to convert it to mutable one
            bitmap = bitmap.copy(bitmapConfig, true);

            Canvas canvas = new Canvas(bitmap);
            Paint paint = new Paint(Paint.FAKE_BOLD_TEXT_FLAG | Paint.ANTI_ALIAS_FLAG); // new antialised Paint
            paint.setColor(Color.parseColor("#FF6C0A"));       // text color - #3D3D3D
            paint.setTextSize((int) (22 * scale));           // text size in pixels
            // paint.setShadowLayer(1f, 0f, 1f, Color.DKGRAY); // text shadow

            // draw text to the Canvas center
            Rect bounds = new Rect();
            paint.getTextBounds(text, 0, text.length(), bounds);
            int x = (bitmap.getWidth() - bounds.width()) / 6;
            int y = (bitmap.getHeight() + bounds.height()) / 5;
            int distanceY = bounds.height() / 2;

            canvas.drawText(text, x * scale, y * scale - distanceY, paint);
            return bitmap;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 添加背景
     *
     * @param color
     * @param orginBitmap
     * @return
     */
    public Bitmap setBitmapBg(int color, Bitmap orginBitmap, int THUMB_SIZE) {
        Paint paint = new Paint();
        paint.setColor(color);
        // Bitmap bitmap = Bitmap.createBitmap(orginBitmap.getWidth(),
        // orginBitmap.getHeight(), orginBitmap.getConfig());
        Bitmap bitmap = zoomImg(orginBitmap, THUMB_SIZE, THUMB_SIZE);
        Canvas canvas = new Canvas(bitmap);
        canvas.drawRect(0, 0, THUMB_SIZE, THUMB_SIZE, paint);
        canvas.drawBitmap(orginBitmap, 0, 0, paint);
        return bitmap;
    }

    /**
     * 合成图片
     *
     * @param background
     * @param foreground
     * @return
     */
    public Bitmap toConformBitmap(Bitmap background, Bitmap foreground) {
        if (background == null) {
            return null;
        }
        int bgWidth = background.getWidth();
        int bgHeight = background.getHeight();
        // create the new blank bitmap 创建一个新的和SRC长度宽度一样的位图
        Bitmap newbmp = Bitmap.createBitmap(bgWidth, bgHeight, Bitmap.Config.ARGB_8888);
        Canvas cv = new Canvas(newbmp);
        // draw bg into
        cv.drawBitmap(background, 0, 0, null);// 在 0，0坐标开始画入bg
        // draw fg into
        cv.drawBitmap(foreground, 0, 0, null);// 在 0，0坐标开始画入fg ，可以从任意位置画入
        // save all clip
        cv.save();// 保存
        // store
        cv.restore();// 存储
        return newbmp;
    }

    /**
     * 图片按比例大小压缩方法
     *
     * @param image      （根据Bitmap图片压缩）
     * @param outputSize 输出的文件大小（KB）
     * @return
     */
    public static Bitmap compressScale(Bitmap image, long outputSize) {

        return FileZipUtils.compressScale(image, outputSize);
    }


    /**
     * 把bitmap，依据needWith按bitmap 宽高比例计算出新高度，裁剪出符合 needWith和needHeight的bitmap
     *
     * @param bitmap     原
     * @param needWith   needWith= 0 ，按屏幕宽度，
     * @param needHeight needHeight = 0 ，按屏幕高度
     * @param cropFlag   true: 按照needHeight 需要的高度裁剪,从顶部裁剪；flase：不需按照needHeight裁剪
     * @return
     */
    private Bitmap zoomCropBitmap(Bitmap bitmap, int needWith, int needHeight, boolean cropFlag) {

        if (bitmap == null) {
            return null;
        }
        int bitmapW = bitmap.getWidth();
        int bitmapH = bitmap.getHeight();

        int standarWith = needWith;
        if (needWith == 0) {
            standarWith = DeviceUtil.getDeviceWidth();
        }

        int standarHeight = needHeight;

        if (needHeight == 0) {
            standarHeight = DeviceUtil.getScreenHeight();
        }

        // 1、 以屏幕宽度为准，按图片实际比例缩放产生新的bitmap；
        int bigBitmapH = (int) (bitmapH * standarWith / bitmapW);
        int bigBitmapW = standarWith;
        Bitmap zoomBitmap = BitMapUtils.zoomBitMap(bitmap, bigBitmapW, bigBitmapH);

        if (cropFlag) {
            if (bitmapW > bitmapH) {
                // 横图
            } else {
                // 竖图或正方形
                // 2、缩放产生新的bitmap的高度小于或等于手机屏幕高度，使用缩放产生新的bitmap；反之 则按照手机屏幕的高度 裁剪放大的bitmap
                if (zoomBitmap.getHeight() <= standarHeight) {
                } else {
                    //裁剪图片
                    Bitmap scaledSmallBitamp = Bitmap.createBitmap(zoomBitmap, 0, 0, zoomBitmap.getWidth(), standarHeight);
                    zoomBitmap = scaledSmallBitamp;
                }
            }
        }


        return zoomBitmap;
    }


    /**
     * Glide 加载动图,增加圆角，亲测有效
     *
     * @param mContext 上下文
     * @param imgView  加载对象
     * @param url      图片链接
     * @param listener 回调
     * @param fillet   角度大小
     */
    public static void loadGlideShape(final Context mContext, final ImageView imgView, String url, final int fillet, RequestListener listener) {
        if (mContext == null) {
            return;
        }
        if (!TextUtils.isEmpty(url)) {
            // 设置图片圆角角度
            RequestOptions gifOptions =
                    RequestOptions.bitmapTransform(new RoundedCorners(fillet))
                            .diskCacheStrategy(DiskCacheStrategy.DATA);

            try {
                GlideApp.with(mContext).load(url).listener(listener).apply(gifOptions).into(imgView);
            } catch (Exception e) {
            }
        }

    }

    /**
     * 加载图片资源
     *
     * @param imageView
     * @param url
     * @param callback  成功获取图片资源
     */
    public void loadImageSource(ImageView imageView, String url, LoadImageCallback callback) {

        if (imageView == null) {
            return;
        }

        try {
            if (!TextUtils.isEmpty(url) && url.contains(".gif")) {
                GlideApp.with(AppContext.getContext()).load(url).apply(baseGifOptions()).into(imageView);
            } else {

                GlideApp.with(AppContext.getContext())
                        .asBitmap()
                        .load(url)
                        .apply(baseOptions())
                        .into(new BitmapImageViewTarget(imageView) {

                            @Override
                            protected void setResource(Bitmap bitmap) {

                                if (bitmap != null) {
                                    if (callback != null) {
                                        callback.callbackBitmap(bitmap);
                                    }
                                    imageView.setImageBitmap(bitmap);
                                }
                            }
                        });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static File getCache(Context context, String url) {
        File cacheFile = null;
        RequestFutureTarget<File> futureTarget = (RequestFutureTarget<File>) GlideApp.with(context).downloadOnly().load(url).apply(new GlideOptions().onlyRetrieveFromCache(true)).submit();
        Class<?> class1 = futureTarget.getClass();
        Field field = null;
        try {
            //等待Glide给resource对象赋值
            synchronized (futureTarget) {
                futureTarget.wait();
            }
            field = class1.getDeclaredField("resource");
            field.setAccessible(true);//开放权限
            cacheFile = (File) field.get(futureTarget);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return cacheFile;
    }


    /**
     * 验证可用的url,此方法有点耗时
     */
    public static boolean checkLoadUrl(Context context, String url) {
        GlideApp.with(context)
                .load(url)
                .into(new CustomTarget<Drawable>() {
                    @Override
                    public void onResourceReady(@NonNull @NotNull Drawable resource, @Nullable @org.jetbrains.annotations.Nullable Transition<? super Drawable> transition) {
                        isLoadSuccess = true;
                    }

                    @Override
                    public void onLoadCleared(@Nullable @org.jetbrains.annotations.Nullable Drawable placeholder) {

                    }

                    @Override
                    public void onLoadFailed(@Nullable @org.jetbrains.annotations.Nullable Drawable errorDrawable) {
                        isLoadSuccess = false;
                    }
                });
        return isLoadSuccess;
    }


    /**
     * 加载图片资源依据网络信息和设置开关
     *
     * @param imageView
     * @param url
     * @param placeholderImg
     */
    public void loadImageSourceByNetStatus(ImageView imageView, String url, int placeholderImg) {

        //仅wifi开关
        String imgTag = SpUtils.getWifiLoadImgSwitchTag();
        boolean isWifi = isWifi();
        if (!isWifi && StringUtils.isEqual("1", imgTag)) {
            // 不是WiFi网络环境并且设置仅WiFi网络加载图片
            GlideApp.with(AppContext.getContext())
                    .load(placeholderImg)
                    //淡入淡出的动画效果
                    .transition(new DrawableTransitionOptions().crossFade())
                    .apply(baseOptions(placeholderImg, placeholderImg))
                    .into(imageView);
        } else {
            loadImage(imageView, url, placeholderImg);
        }
    }


    /**
     * 判断是否是wifi连接
     *
     * @return
     */
    private boolean isWifi() {
        ConnectivityManager mConnectivityManager =
                (ConnectivityManager) AppContext.getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
        if (mConnectivityManager == null) {
            return false;
        }
        NetworkInfo mWiFiNetworkInfo = mConnectivityManager.getActiveNetworkInfo();
        if (mWiFiNetworkInfo != null) {
            return mWiFiNetworkInfo.getType() == ConnectivityManager.TYPE_WIFI;
        }
        return false;
    }

    /**
     * 获取图片bitmap
     */
    public static void loadBitmapListener(Context mContext, String url, CustomTarget<Bitmap> listener) {
        if (mContext == null) {
            return;
        }
        RequestOptions mRequestOptions = new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA)
                .dontAnimate();
        GlideApp.with(mContext).asBitmap().load(url).apply(mRequestOptions).into(listener);
    }

    /**
     * 给viewGroup 相关的控件加载图片
     *
     * @param mContext
     * @param url
     * @param viewGroup
     * @param placeHolderId
     */
    public static void loadBitmapListener(Context mContext, String url, ViewGroup viewGroup, int placeHolderId) {
        if (mContext == null) {
            return;
        }
        RequestOptions mRequestOptions = new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA)
                .dontAnimate();
        GlideApp.with(mContext).asBitmap().load(url).apply(mRequestOptions).into(new CustomTarget<Bitmap>() {
            @Override
            public void onResourceReady(@NonNull @NotNull Bitmap resource, @Nullable @org.jetbrains.annotations.Nullable Transition<? super Bitmap> transition) {
                if (resource != null) {
                    viewGroup.setBackground(new BitmapDrawable(viewGroup.getContext().getResources(), resource));
                } else {
                    viewGroup.setBackgroundResource(placeHolderId);
                }
            }

            @Override
            public void onLoadCleared(@Nullable @org.jetbrains.annotations.Nullable Drawable placeholder) {
                viewGroup.setBackgroundResource(placeHolderId);
            }
        });
    }


    /**
     * 获取图片bitmap
     */
    public static void loadBitmapListener(Context mContext, Uri uri, CustomTarget<Bitmap> listener) {
        if (mContext == null) {
            return;
        }
        RequestOptions mRequestOptions = new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA)
                .dontAnimate();
        GlideApp.with(mContext).asBitmap().load(uri).apply(mRequestOptions).into(listener);
    }
}