jimu-decompiled/sources/com/bumptech/glide/load/engine/ActiveResources.java

package com.bumptech.glide.load.engine;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.Process;
import com.bumptech.glide.load.Key;
import com.bumptech.glide.load.engine.EngineResource;
import com.bumptech.glide.util.Preconditions;
import com.bumptech.glide.util.Util;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.Map;

/* loaded from: classes.dex */
final class ActiveResources {
    private final boolean a;
    private final Handler b = new Handler(Looper.getMainLooper(), new Handler.Callback() { // from class: com.bumptech.glide.load.engine.ActiveResources.1
        @Override // android.os.Handler.Callback
        public boolean handleMessage(Message message) {
            if (message.what != 1) {
                return false;
            }
            ActiveResources.this.a((ResourceWeakReference) message.obj);
            return true;
        }
    });
    final Map<Key, ResourceWeakReference> c = new HashMap();
    private EngineResource.ResourceListener d;
    private ReferenceQueue<EngineResource<?>> e;
    private Thread f;
    private volatile boolean g;
    private volatile DequeuedResourceCallback h;

    interface DequeuedResourceCallback {
        void a();
    }

    static final class ResourceWeakReference extends WeakReference<EngineResource<?>> {
        final Key a;
        final boolean b;
        Resource<?> c;

        ResourceWeakReference(Key key, EngineResource<?> engineResource, ReferenceQueue<? super EngineResource<?>> referenceQueue, boolean z) {
            super(engineResource, referenceQueue);
            Resource<?> resource;
            Preconditions.a(key);
            this.a = key;
            if (engineResource.e() && z) {
                Resource<?> d = engineResource.d();
                Preconditions.a(d);
                resource = d;
            } else {
                resource = null;
            }
            this.c = resource;
            this.b = engineResource.e();
        }

        void a() {
            this.c = null;
            clear();
        }
    }

    ActiveResources(boolean z) {
        this.a = z;
    }

    void a(EngineResource.ResourceListener resourceListener) {
        this.d = resourceListener;
    }

    EngineResource<?> b(Key key) {
        ResourceWeakReference resourceWeakReference = this.c.get(key);
        if (resourceWeakReference == null) {
            return null;
        }
        EngineResource<?> engineResource = resourceWeakReference.get();
        if (engineResource == null) {
            a(resourceWeakReference);
        }
        return engineResource;
    }

    void a(Key key, EngineResource<?> engineResource) {
        ResourceWeakReference put = this.c.put(key, new ResourceWeakReference(key, engineResource, b(), this.a));
        if (put != null) {
            put.a();
        }
    }

    private ReferenceQueue<EngineResource<?>> b() {
        if (this.e == null) {
            this.e = new ReferenceQueue<>();
            this.f = new Thread(new Runnable() { // from class: com.bumptech.glide.load.engine.ActiveResources.2
                @Override // java.lang.Runnable
                public void run() {
                    Process.setThreadPriority(10);
                    ActiveResources.this.a();
                }
            }, "glide-active-resources");
            this.f.start();
        }
        return this.e;
    }

    void a(Key key) {
        ResourceWeakReference remove = this.c.remove(key);
        if (remove != null) {
            remove.a();
        }
    }

    void a(ResourceWeakReference resourceWeakReference) {
        Resource<?> resource;
        Util.b();
        this.c.remove(resourceWeakReference.a);
        if (!resourceWeakReference.b || (resource = resourceWeakReference.c) == null) {
            return;
        }
        EngineResource<?> engineResource = new EngineResource<>(resource, true, false);
        engineResource.a(resourceWeakReference.a, this.d);
        this.d.a(resourceWeakReference.a, engineResource);
    }

    void a() {
        while (!this.g) {
            try {
                this.b.obtainMessage(1, (ResourceWeakReference) this.e.remove()).sendToTarget();
                DequeuedResourceCallback dequeuedResourceCallback = this.h;
                if (dequeuedResourceCallback != null) {
                    dequeuedResourceCallback.a();
                }
            } catch (InterruptedException unused) {
                Thread.currentThread().interrupt();
            }
        }
    }
}