翰林优商.apk(点击下载) / Glide.java

package com.sjm.bumptech.glide;

import android.app.Activity;
import android.app.Fragment;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.os.ParcelFileDescriptor;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;
import androidx.fragment.app.FragmentActivity;
import com.sjm.bumptech.glide.load.DecodeFormat;
import com.sjm.bumptech.glide.load.engine.Engine;
import com.sjm.bumptech.glide.load.engine.bitmap_recycle.BitmapPool;
import com.sjm.bumptech.glide.load.engine.cache.MemoryCache;
import com.sjm.bumptech.glide.load.engine.prefill.BitmapPreFiller;
import com.sjm.bumptech.glide.load.engine.prefill.PreFillType;
import com.sjm.bumptech.glide.load.model.GenericLoaderFactory;
import com.sjm.bumptech.glide.load.model.GlideUrl;
import com.sjm.bumptech.glide.load.model.ImageVideoWrapper;
import com.sjm.bumptech.glide.load.model.ModelLoader;
import com.sjm.bumptech.glide.load.model.ModelLoaderFactory;
import com.sjm.bumptech.glide.load.model.file_descriptor.FileDescriptorFileLoader;
import com.sjm.bumptech.glide.load.model.file_descriptor.FileDescriptorResourceLoader;
import com.sjm.bumptech.glide.load.model.file_descriptor.FileDescriptorStringLoader;
import com.sjm.bumptech.glide.load.model.file_descriptor.FileDescriptorUriLoader;
import com.sjm.bumptech.glide.load.model.stream.HttpUrlGlideUrlLoader;
import com.sjm.bumptech.glide.load.model.stream.StreamByteArrayLoader;
import com.sjm.bumptech.glide.load.model.stream.StreamFileLoader;
import com.sjm.bumptech.glide.load.model.stream.StreamResourceLoader;
import com.sjm.bumptech.glide.load.model.stream.StreamStringLoader;
import com.sjm.bumptech.glide.load.model.stream.StreamUriLoader;
import com.sjm.bumptech.glide.load.model.stream.StreamUrlLoader;
import com.sjm.bumptech.glide.load.resource.bitmap.CenterCrop;
import com.sjm.bumptech.glide.load.resource.bitmap.FileDescriptorBitmapDataLoadProvider;
import com.sjm.bumptech.glide.load.resource.bitmap.FitCenter;
import com.sjm.bumptech.glide.load.resource.bitmap.GlideBitmapDrawable;
import com.sjm.bumptech.glide.load.resource.bitmap.ImageVideoDataLoadProvider;
import com.sjm.bumptech.glide.load.resource.bitmap.StreamBitmapDataLoadProvider;
import com.sjm.bumptech.glide.load.resource.drawable.GlideDrawable;
import com.sjm.bumptech.glide.load.resource.file.StreamFileDataLoadProvider;
import com.sjm.bumptech.glide.load.resource.gif.GifDrawable;
import com.sjm.bumptech.glide.load.resource.gif.GifDrawableLoadProvider;
import com.sjm.bumptech.glide.load.resource.gifbitmap.GifBitmapWrapper;
import com.sjm.bumptech.glide.load.resource.gifbitmap.GifBitmapWrapperTransformation;
import com.sjm.bumptech.glide.load.resource.gifbitmap.ImageVideoGifDrawableLoadProvider;
import com.sjm.bumptech.glide.load.resource.transcode.GifBitmapWrapperDrawableTranscoder;
import com.sjm.bumptech.glide.load.resource.transcode.GlideBitmapDrawableTranscoder;
import com.sjm.bumptech.glide.load.resource.transcode.ResourceTranscoder;
import com.sjm.bumptech.glide.load.resource.transcode.TranscoderRegistry;
import com.sjm.bumptech.glide.manager.RequestManagerRetriever;
import com.sjm.bumptech.glide.module.GlideModule;
import com.sjm.bumptech.glide.module.ManifestParser;
import com.sjm.bumptech.glide.provider.DataLoadProvider;
import com.sjm.bumptech.glide.provider.DataLoadProviderRegistry;
import com.sjm.bumptech.glide.request.FutureTarget;
import com.sjm.bumptech.glide.request.Request;
import com.sjm.bumptech.glide.request.animation.GlideAnimation;
import com.sjm.bumptech.glide.request.target.ImageViewTargetFactory;
import com.sjm.bumptech.glide.request.target.Target;
import com.sjm.bumptech.glide.request.target.ViewTarget;
import com.sjm.bumptech.glide.util.Util;
import java.io.File;
import java.io.InputStream;
import java.net.URL;
import java.util.List;

public class Glide {
    private static final String TAG = "Glide";
    private static volatile Glide glide;
    private final CenterCrop bitmapCenterCrop;
    private final FitCenter bitmapFitCenter;
    private final BitmapPool bitmapPool;
    private final BitmapPreFiller bitmapPreFiller;
    private final DataLoadProviderRegistry dataLoadProviderRegistry;
    private final DecodeFormat decodeFormat;
    private final GifBitmapWrapperTransformation drawableCenterCrop;
    private final GifBitmapWrapperTransformation drawableFitCenter;
    private final Engine engine;
    private final ImageViewTargetFactory imageViewTargetFactory = new ImageViewTargetFactory();
    private final GenericLoaderFactory loaderFactory;
    private final Handler mainHandler;
    private final MemoryCache memoryCache;
    private final TranscoderRegistry transcoderRegistry;

    private static class ClearTarget extends ViewTarget<View, Object> {
        public ClearTarget(View view) {
            super(view);
        }

        @Override // com.sjm.bumptech.glide.request.target.Target, com.sjm.bumptech.glide.request.target.BaseTarget
        public void onLoadCleared(Drawable drawable) {
        }

        @Override // com.sjm.bumptech.glide.request.target.Target, com.sjm.bumptech.glide.request.target.BaseTarget
        public void onLoadFailed(Exception exc, Drawable drawable) {
        }

        @Override // com.sjm.bumptech.glide.request.target.Target, com.sjm.bumptech.glide.request.target.BaseTarget
        public void onLoadStarted(Drawable drawable) {
        }

        @Override // com.sjm.bumptech.glide.request.target.Target
        public void onResourceReady(Object obj, GlideAnimation<? super Object> glideAnimation) {
        }
    }

    Glide(Engine engine2, MemoryCache memoryCache2, BitmapPool bitmapPool2, Context context, DecodeFormat decodeFormat2) {
        TranscoderRegistry transcoderRegistry2 = new TranscoderRegistry();
        this.transcoderRegistry = transcoderRegistry2;
        this.engine = engine2;
        this.bitmapPool = bitmapPool2;
        this.memoryCache = memoryCache2;
        this.decodeFormat = decodeFormat2;
        this.loaderFactory = new GenericLoaderFactory(context);
        this.mainHandler = new Handler(Looper.getMainLooper());
        this.bitmapPreFiller = new BitmapPreFiller(memoryCache2, bitmapPool2, decodeFormat2);
        DataLoadProviderRegistry dataLoadProviderRegistry2 = new DataLoadProviderRegistry();
        this.dataLoadProviderRegistry = dataLoadProviderRegistry2;
        StreamBitmapDataLoadProvider streamBitmapDataLoadProvider = new StreamBitmapDataLoadProvider(bitmapPool2, decodeFormat2);
        dataLoadProviderRegistry2.register(InputStream.class, Bitmap.class, streamBitmapDataLoadProvider);
        FileDescriptorBitmapDataLoadProvider fileDescriptorBitmapDataLoadProvider = new FileDescriptorBitmapDataLoadProvider(bitmapPool2, decodeFormat2);
        dataLoadProviderRegistry2.register(ParcelFileDescriptor.class, Bitmap.class, fileDescriptorBitmapDataLoadProvider);
        ImageVideoDataLoadProvider imageVideoDataLoadProvider = new ImageVideoDataLoadProvider(streamBitmapDataLoadProvider, fileDescriptorBitmapDataLoadProvider);
        dataLoadProviderRegistry2.register(ImageVideoWrapper.class, Bitmap.class, imageVideoDataLoadProvider);
        GifDrawableLoadProvider gifDrawableLoadProvider = new GifDrawableLoadProvider(context, bitmapPool2);
        dataLoadProviderRegistry2.register(InputStream.class, GifDrawable.class, gifDrawableLoadProvider);
        dataLoadProviderRegistry2.register(ImageVideoWrapper.class, GifBitmapWrapper.class, new ImageVideoGifDrawableLoadProvider(imageVideoDataLoadProvider, gifDrawableLoadProvider, bitmapPool2));
        dataLoadProviderRegistry2.register(InputStream.class, File.class, new StreamFileDataLoadProvider());
        register(File.class, ParcelFileDescriptor.class, new FileDescriptorFileLoader.Factory());
        register(File.class, InputStream.class, new StreamFileLoader.Factory());
        register(Integer.TYPE, ParcelFileDescriptor.class, new FileDescriptorResourceLoader.Factory());
        register(Integer.TYPE, InputStream.class, new StreamResourceLoader.Factory());
        register(Integer.class, ParcelFileDescriptor.class, new FileDescriptorResourceLoader.Factory());
        register(Integer.class, InputStream.class, new StreamResourceLoader.Factory());
        register(String.class, ParcelFileDescriptor.class, new FileDescriptorStringLoader.Factory());
        register(String.class, InputStream.class, new StreamStringLoader.Factory());
        register(Uri.class, ParcelFileDescriptor.class, new FileDescriptorUriLoader.Factory());
        register(Uri.class, InputStream.class, new StreamUriLoader.Factory());
        register(URL.class, InputStream.class, new StreamUrlLoader.Factory());
        register(GlideUrl.class, InputStream.class, new HttpUrlGlideUrlLoader.Factory());
        register(byte[].class, InputStream.class, new StreamByteArrayLoader.Factory());
        transcoderRegistry2.register(Bitmap.class, GlideBitmapDrawable.class, new GlideBitmapDrawableTranscoder(context.getResources(), bitmapPool2));
        transcoderRegistry2.register(GifBitmapWrapper.class, GlideDrawable.class, new GifBitmapWrapperDrawableTranscoder(new GlideBitmapDrawableTranscoder(context.getResources(), bitmapPool2)));
        CenterCrop centerCrop = new CenterCrop(bitmapPool2);
        this.bitmapCenterCrop = centerCrop;
        this.drawableCenterCrop = new GifBitmapWrapperTransformation(bitmapPool2, centerCrop);
        FitCenter fitCenter = new FitCenter(bitmapPool2);
        this.bitmapFitCenter = fitCenter;
        this.drawableFitCenter = new GifBitmapWrapperTransformation(bitmapPool2, fitCenter);
    }

    public static <T> ModelLoader<T, ParcelFileDescriptor> buildFileDescriptorModelLoader(Class<T> cls, Context context) {
        return buildModelLoader((Class) cls, ParcelFileDescriptor.class, context);
    }

    public static <T> ModelLoader<T, ParcelFileDescriptor> buildFileDescriptorModelLoader(T t, Context context) {
        return buildModelLoader((Object) t, ParcelFileDescriptor.class, context);
    }

    public static <T, Y> ModelLoader<T, Y> buildModelLoader(Class<T> cls, Class<Y> cls2, Context context) {
        if (cls != null) {
            return get(context).getLoaderFactory().buildModelLoader(cls, cls2);
        }
        if (!Log.isLoggable(TAG, 3)) {
            return null;
        }
        Log.d(TAG, "Unable to load null model, setting placeholder only");
        return null;
    }

    public static <T, Y> ModelLoader<T, Y> buildModelLoader(T t, Class<Y> cls, Context context) {
        return buildModelLoader((Class) (t != null ? t.getClass() : null), (Class) cls, context);
    }

    public static <T> ModelLoader<T, InputStream> buildStreamModelLoader(Class<T> cls, Context context) {
        return buildModelLoader((Class) cls, InputStream.class, context);
    }

    public static <T> ModelLoader<T, InputStream> buildStreamModelLoader(T t, Context context) {
        return buildModelLoader((Object) t, InputStream.class, context);
    }

    public static void clear(View view) {
        clear(new ClearTarget(view));
    }

    public static void clear(FutureTarget<?> futureTarget) {
        futureTarget.clear();
    }

    public static void clear(Target<?> target) {
        Util.assertMainThread();
        Request request = target.getRequest();
        if (request != null) {
            request.clear();
            target.setRequest(null);
        }
    }

    public static Glide get(Context context) {
        if (glide == null) {
            synchronized (Glide.class) {
                if (glide == null) {
                    Context applicationContext = context.getApplicationContext();
                    List<GlideModule> parse = new ManifestParser(applicationContext).parse();
                    GlideBuilder glideBuilder = new GlideBuilder(applicationContext);
                    for (GlideModule glideModule : parse) {
                        glideModule.applyOptions(applicationContext, glideBuilder);
                    }
                    glide = glideBuilder.createGlide();
                    for (GlideModule glideModule2 : parse) {
                        glideModule2.registerComponents(applicationContext, glide);
                    }
                }
            }
        }
        return glide;
    }

    private GenericLoaderFactory getLoaderFactory() {
        return this.loaderFactory;
    }

    public static File getPhotoCacheDir(Context context) {
        return getPhotoCacheDir(context, "image_manager_disk_cache");
    }

    public static File getPhotoCacheDir(Context context, String str) {
        File cacheDir = context.getCacheDir();
        if (cacheDir != null) {
            File file = new File(cacheDir, str);
            if (file.mkdirs() || (file.exists() && file.isDirectory())) {
                return file;
            }
            return null;
        }
        if (Log.isLoggable(TAG, 6)) {
            Log.e(TAG, "default disk cache dir is null");
        }
        return null;
    }

    @Deprecated
    public static boolean isSetup() {
        return glide != null;
    }

    @Deprecated
    public static void setup(GlideBuilder glideBuilder) {
        if (!isSetup()) {
            glide = glideBuilder.createGlide();
            return;
        }
        throw new IllegalArgumentException("Glide is already setup, check with isSetup() first");
    }

    static void tearDown() {
        glide = null;
    }

    public static RequestManager with(Activity activity) {
        return RequestManagerRetriever.get().get(activity);
    }

    public static RequestManager with(Fragment fragment) {
        return RequestManagerRetriever.get().get(fragment);
    }

    public static RequestManager with(Context context) {
        return RequestManagerRetriever.get().get(context);
    }

    public static RequestManager with(androidx.fragment.app.Fragment fragment) {
        return RequestManagerRetriever.get().get(fragment);
    }

    public static RequestManager with(FragmentActivity fragmentActivity) {
        return RequestManagerRetriever.get().get(fragmentActivity);
    }

    /* access modifiers changed from: package-private */
    public <T, Z> DataLoadProvider<T, Z> buildDataProvider(Class<T> cls, Class<Z> cls2) {
        return this.dataLoadProviderRegistry.get(cls, cls2);
    }

    /* access modifiers changed from: package-private */
    public <R> Target<R> buildImageViewTarget(ImageView imageView, Class<R> cls) {
        return this.imageViewTargetFactory.buildTarget(imageView, cls);
    }

    /* access modifiers changed from: package-private */
    public <Z, R> ResourceTranscoder<Z, R> buildTranscoder(Class<Z> cls, Class<R> cls2) {
        return this.transcoderRegistry.get(cls, cls2);
    }

    public void clearDiskCache() {
        Util.assertBackgroundThread();
        getEngine().clearDiskCache();
    }

    public void clearMemory() {
        this.bitmapPool.clearMemory();
        this.memoryCache.clearMemory();
    }

    /* access modifiers changed from: package-private */
    public CenterCrop getBitmapCenterCrop() {
        return this.bitmapCenterCrop;
    }

    /* access modifiers changed from: package-private */
    public FitCenter getBitmapFitCenter() {
        return this.bitmapFitCenter;
    }

    public BitmapPool getBitmapPool() {
        return this.bitmapPool;
    }

    /* access modifiers changed from: package-private */
    public DecodeFormat getDecodeFormat() {
        return this.decodeFormat;
    }

    /* access modifiers changed from: package-private */
    public GifBitmapWrapperTransformation getDrawableCenterCrop() {
        return this.drawableCenterCrop;
    }

    /* access modifiers changed from: package-private */
    public GifBitmapWrapperTransformation getDrawableFitCenter() {
        return this.drawableFitCenter;
    }

    /* access modifiers changed from: package-private */
    public Engine getEngine() {
        return this.engine;
    }

    /* access modifiers changed from: package-private */
    public Handler getMainHandler() {
        return this.mainHandler;
    }

    public void preFillBitmapPool(PreFillType.Builder... builderArr) {
        this.bitmapPreFiller.preFill(builderArr);
    }

    public <T, Y> void register(Class<T> cls, Class<Y> cls2, ModelLoaderFactory<T, Y> modelLoaderFactory) {
        ModelLoaderFactory<T, Y> register = this.loaderFactory.register(cls, cls2, modelLoaderFactory);
        if (register != null) {
            register.teardown();
        }
    }

    public void setMemoryCategory(MemoryCategory memoryCategory) {
        this.memoryCache.setSizeMultiplier(memoryCategory.getMultiplier());
        this.bitmapPool.setSizeMultiplier(memoryCategory.getMultiplier());
    }

    public void trimMemory(int i) {
        this.bitmapPool.trimMemory(i);
        this.memoryCache.trimMemory(i);
    }

    @Deprecated
    public <T, Y> void unregister(Class<T> cls, Class<Y> cls2) {
        ModelLoaderFactory<T, Y> unregister = this.loaderFactory.unregister(cls, cls2);
        if (unregister != null) {
            unregister.teardown();
        }
    }
}