Initial commit

sources/com/bumptech/glide/manager/ActivityFragmentLifecycle.java

@@ -0,0 +1,58 @@
+package com.bumptech.glide.manager;
+
+import com.bumptech.glide.util.Util;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.WeakHashMap;
+
+/* loaded from: classes.dex */
+class ActivityFragmentLifecycle implements Lifecycle {
+    private final Set<LifecycleListener> a = Collections.newSetFromMap(new WeakHashMap());
+    private boolean b;
+    private boolean c;
+
+    ActivityFragmentLifecycle() {
+    }
+
+    @Override // com.bumptech.glide.manager.Lifecycle
+    public void a(LifecycleListener lifecycleListener) {
+        this.a.add(lifecycleListener);
+        if (this.c) {
+            lifecycleListener.a();
+        } else if (this.b) {
+            lifecycleListener.onStart();
+        } else {
+            lifecycleListener.b();
+        }
+    }
+
+    @Override // com.bumptech.glide.manager.Lifecycle
+    public void b(LifecycleListener lifecycleListener) {
+        this.a.remove(lifecycleListener);
+    }
+
+    void c() {
+        this.b = false;
+        Iterator it = Util.a(this.a).iterator();
+        while (it.hasNext()) {
+            ((LifecycleListener) it.next()).b();
+        }
+    }
+
+    void b() {
+        this.b = true;
+        Iterator it = Util.a(this.a).iterator();
+        while (it.hasNext()) {
+            ((LifecycleListener) it.next()).onStart();
+        }
+    }
+
+    void a() {
+        this.c = true;
+        Iterator it = Util.a(this.a).iterator();
+        while (it.hasNext()) {
+            ((LifecycleListener) it.next()).a();
+        }
+    }
+}

sources/com/bumptech/glide/manager/ApplicationLifecycle.java

@@ -0,0 +1,16 @@
+package com.bumptech.glide.manager;
+
+/* loaded from: classes.dex */
+class ApplicationLifecycle implements Lifecycle {
+    ApplicationLifecycle() {
+    }
+
+    @Override // com.bumptech.glide.manager.Lifecycle
+    public void a(LifecycleListener lifecycleListener) {
+        lifecycleListener.onStart();
+    }
+
+    @Override // com.bumptech.glide.manager.Lifecycle
+    public void b(LifecycleListener lifecycleListener) {
+    }
+}

sources/com/bumptech/glide/manager/ConnectivityMonitor.java

@@ -0,0 +1,9 @@
+package com.bumptech.glide.manager;
+
+/* loaded from: classes.dex */
+public interface ConnectivityMonitor extends LifecycleListener {
+
+    public interface ConnectivityListener {
+        void a(boolean z);
+    }
+}

sources/com/bumptech/glide/manager/ConnectivityMonitorFactory.java

@@ -0,0 +1,9 @@
+package com.bumptech.glide.manager;
+
+import android.content.Context;
+import com.bumptech.glide.manager.ConnectivityMonitor;
+
+/* loaded from: classes.dex */
+public interface ConnectivityMonitorFactory {
+    ConnectivityMonitor a(Context context, ConnectivityMonitor.ConnectivityListener connectivityListener);
+}

sources/com/bumptech/glide/manager/DefaultConnectivityMonitor.java

@@ -0,0 +1,91 @@
+package com.bumptech.glide.manager;
+
+import android.annotation.SuppressLint;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.util.Log;
+import com.bumptech.glide.manager.ConnectivityMonitor;
+import com.bumptech.glide.util.Preconditions;
+
+/* loaded from: classes.dex */
+final class DefaultConnectivityMonitor implements ConnectivityMonitor {
+    private final Context a;
+    final ConnectivityMonitor.ConnectivityListener b;
+    boolean c;
+    private boolean d;
+    private final BroadcastReceiver e = new BroadcastReceiver() { // from class: com.bumptech.glide.manager.DefaultConnectivityMonitor.1
+        @Override // android.content.BroadcastReceiver
+        public void onReceive(Context context, Intent intent) {
+            DefaultConnectivityMonitor defaultConnectivityMonitor = DefaultConnectivityMonitor.this;
+            boolean z = defaultConnectivityMonitor.c;
+            defaultConnectivityMonitor.c = defaultConnectivityMonitor.a(context);
+            if (z != DefaultConnectivityMonitor.this.c) {
+                if (Log.isLoggable("ConnectivityMonitor", 3)) {
+                    Log.d("ConnectivityMonitor", "connectivity changed, isConnected: " + DefaultConnectivityMonitor.this.c);
+                }
+                DefaultConnectivityMonitor defaultConnectivityMonitor2 = DefaultConnectivityMonitor.this;
+                defaultConnectivityMonitor2.b.a(defaultConnectivityMonitor2.c);
+            }
+        }
+    };
+
+    DefaultConnectivityMonitor(Context context, ConnectivityMonitor.ConnectivityListener connectivityListener) {
+        this.a = context.getApplicationContext();
+        this.b = connectivityListener;
+    }
+
+    private void c() {
+        if (this.d) {
+            return;
+        }
+        this.c = a(this.a);
+        try {
+            this.a.registerReceiver(this.e, new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE"));
+            this.d = true;
+        } catch (SecurityException e) {
+            if (Log.isLoggable("ConnectivityMonitor", 5)) {
+                Log.w("ConnectivityMonitor", "Failed to register", e);
+            }
+        }
+    }
+
+    private void d() {
+        if (this.d) {
+            this.a.unregisterReceiver(this.e);
+            this.d = false;
+        }
+    }
+
+    @Override // com.bumptech.glide.manager.LifecycleListener
+    public void a() {
+    }
+
+    @SuppressLint({"MissingPermission"})
+    boolean a(Context context) {
+        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
+        Preconditions.a(connectivityManager);
+        try {
+            NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
+            return activeNetworkInfo != null && activeNetworkInfo.isConnected();
+        } catch (RuntimeException e) {
+            if (Log.isLoggable("ConnectivityMonitor", 5)) {
+                Log.w("ConnectivityMonitor", "Failed to determine connectivity status when connectivity changed", e);
+            }
+            return true;
+        }
+    }
+
+    @Override // com.bumptech.glide.manager.LifecycleListener
+    public void b() {
+        d();
+    }
+
+    @Override // com.bumptech.glide.manager.LifecycleListener
+    public void onStart() {
+        c();
+    }
+}

sources/com/bumptech/glide/manager/DefaultConnectivityMonitorFactory.java

@@ -0,0 +1,18 @@
+package com.bumptech.glide.manager;
+
+import android.content.Context;
+import android.util.Log;
+import androidx.core.content.ContextCompat;
+import com.bumptech.glide.manager.ConnectivityMonitor;
+
+/* loaded from: classes.dex */
+public class DefaultConnectivityMonitorFactory implements ConnectivityMonitorFactory {
+    @Override // com.bumptech.glide.manager.ConnectivityMonitorFactory
+    public ConnectivityMonitor a(Context context, ConnectivityMonitor.ConnectivityListener connectivityListener) {
+        boolean z = ContextCompat.a(context, "android.permission.ACCESS_NETWORK_STATE") == 0;
+        if (Log.isLoggable("ConnectivityMonitor", 3)) {
+            Log.d("ConnectivityMonitor", z ? "ACCESS_NETWORK_STATE permission granted, registering connectivity monitor" : "ACCESS_NETWORK_STATE permission missing, cannot register connectivity monitor");
+        }
+        return z ? new DefaultConnectivityMonitor(context, connectivityListener) : new NullConnectivityMonitor();
+    }
+}

sources/com/bumptech/glide/manager/EmptyRequestManagerTreeNode.java

@@ -0,0 +1,7 @@
+package com.bumptech.glide.manager;
+
+/* loaded from: classes.dex */
+final class EmptyRequestManagerTreeNode implements RequestManagerTreeNode {
+    EmptyRequestManagerTreeNode() {
+    }
+}

sources/com/bumptech/glide/manager/Lifecycle.java

@@ -0,0 +1,8 @@
+package com.bumptech.glide.manager;
+
+/* loaded from: classes.dex */
+public interface Lifecycle {
+    void a(LifecycleListener lifecycleListener);
+
+    void b(LifecycleListener lifecycleListener);
+}

sources/com/bumptech/glide/manager/LifecycleListener.java

@@ -0,0 +1,10 @@
+package com.bumptech.glide.manager;
+
+/* loaded from: classes.dex */
+public interface LifecycleListener {
+    void a();
+
+    void b();
+
+    void onStart();
+}

sources/com/bumptech/glide/manager/NullConnectivityMonitor.java

@@ -0,0 +1,19 @@
+package com.bumptech.glide.manager;
+
+/* loaded from: classes.dex */
+class NullConnectivityMonitor implements ConnectivityMonitor {
+    NullConnectivityMonitor() {
+    }
+
+    @Override // com.bumptech.glide.manager.LifecycleListener
+    public void a() {
+    }
+
+    @Override // com.bumptech.glide.manager.LifecycleListener
+    public void b() {
+    }
+
+    @Override // com.bumptech.glide.manager.LifecycleListener
+    public void onStart() {
+    }
+}

sources/com/bumptech/glide/manager/RequestManagerFragment.java

@@ -0,0 +1,140 @@
+package com.bumptech.glide.manager;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.app.Fragment;
+import android.os.Build;
+import android.util.Log;
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.RequestManager;
+import java.util.HashSet;
+import java.util.Set;
+
+@Deprecated
+/* loaded from: classes.dex */
+public class RequestManagerFragment extends Fragment {
+    private final ActivityFragmentLifecycle a;
+    private final RequestManagerTreeNode b;
+    private final Set<RequestManagerFragment> c;
+    private RequestManager d;
+    private RequestManagerFragment e;
+    private Fragment f;
+
+    private class FragmentRequestManagerTreeNode implements RequestManagerTreeNode {
+        FragmentRequestManagerTreeNode() {
+        }
+
+        public String toString() {
+            return super.toString() + "{fragment=" + RequestManagerFragment.this + "}";
+        }
+    }
+
+    public RequestManagerFragment() {
+        this(new ActivityFragmentLifecycle());
+    }
+
+    @TargetApi(17)
+    private Fragment d() {
+        Fragment parentFragment = Build.VERSION.SDK_INT >= 17 ? getParentFragment() : null;
+        return parentFragment != null ? parentFragment : this.f;
+    }
+
+    private void e() {
+        RequestManagerFragment requestManagerFragment = this.e;
+        if (requestManagerFragment != null) {
+            requestManagerFragment.b(this);
+            this.e = null;
+        }
+    }
+
+    public void a(RequestManager requestManager) {
+        this.d = requestManager;
+    }
+
+    public RequestManager b() {
+        return this.d;
+    }
+
+    public RequestManagerTreeNode c() {
+        return this.b;
+    }
+
+    @Override // android.app.Fragment
+    public void onAttach(Activity activity) {
+        super.onAttach(activity);
+        try {
+            a(activity);
+        } catch (IllegalStateException e) {
+            if (Log.isLoggable("RMFragment", 5)) {
+                Log.w("RMFragment", "Unable to register fragment with root", e);
+            }
+        }
+    }
+
+    @Override // android.app.Fragment
+    public void onDestroy() {
+        super.onDestroy();
+        this.a.a();
+        e();
+    }
+
+    @Override // android.app.Fragment
+    public void onDetach() {
+        super.onDetach();
+        e();
+    }
+
+    @Override // android.app.Fragment
+    public void onStart() {
+        super.onStart();
+        this.a.b();
+    }
+
+    @Override // android.app.Fragment
+    public void onStop() {
+        super.onStop();
+        this.a.c();
+    }
+
+    @Override // android.app.Fragment
+    public String toString() {
+        return super.toString() + "{parent=" + d() + "}";
+    }
+
+    @SuppressLint({"ValidFragment"})
+    RequestManagerFragment(ActivityFragmentLifecycle activityFragmentLifecycle) {
+        this.b = new FragmentRequestManagerTreeNode();
+        this.c = new HashSet();
+        this.a = activityFragmentLifecycle;
+    }
+
+    private void b(RequestManagerFragment requestManagerFragment) {
+        this.c.remove(requestManagerFragment);
+    }
+
+    ActivityFragmentLifecycle a() {
+        return this.a;
+    }
+
+    private void a(RequestManagerFragment requestManagerFragment) {
+        this.c.add(requestManagerFragment);
+    }
+
+    void a(Fragment fragment) {
+        this.f = fragment;
+        if (fragment == null || fragment.getActivity() == null) {
+            return;
+        }
+        a(fragment.getActivity());
+    }
+
+    private void a(Activity activity) {
+        e();
+        this.e = Glide.b(activity).i().b(activity);
+        if (equals(this.e)) {
+            return;
+        }
+        this.e.a(this);
+    }
+}

sources/com/bumptech/glide/manager/RequestManagerRetriever.java

@@ -0,0 +1,324 @@
+package com.bumptech.glide.manager;
+
+import android.R;
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.app.Application;
+import android.app.FragmentManager;
+import android.content.ComponentCallbacks;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+import android.view.View;
+import androidx.collection.ArrayMap;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
+import androidx.fragment.app.FragmentTransaction;
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.RequestManager;
+import com.bumptech.glide.util.Preconditions;
+import com.bumptech.glide.util.Util;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class RequestManagerRetriever implements Handler.Callback {
+    private static final RequestManagerFactory i = new RequestManagerFactory() { // from class: com.bumptech.glide.manager.RequestManagerRetriever.1
+        @Override // com.bumptech.glide.manager.RequestManagerRetriever.RequestManagerFactory
+        public RequestManager a(Glide glide, Lifecycle lifecycle, RequestManagerTreeNode requestManagerTreeNode, Context context) {
+            return new RequestManager(glide, lifecycle, requestManagerTreeNode, context);
+        }
+    };
+    private volatile RequestManager a;
+    private final Handler d;
+    private final RequestManagerFactory e;
+    final Map<FragmentManager, RequestManagerFragment> b = new HashMap();
+    final Map<androidx.fragment.app.FragmentManager, SupportRequestManagerFragment> c = new HashMap();
+    private final ArrayMap<View, Fragment> f = new ArrayMap<>();
+    private final ArrayMap<View, android.app.Fragment> g = new ArrayMap<>();
+    private final Bundle h = new Bundle();
+
+    public interface RequestManagerFactory {
+        RequestManager a(Glide glide, Lifecycle lifecycle, RequestManagerTreeNode requestManagerTreeNode, Context context);
+    }
+
+    public RequestManagerRetriever(RequestManagerFactory requestManagerFactory) {
+        this.e = requestManagerFactory == null ? i : requestManagerFactory;
+        this.d = new Handler(Looper.getMainLooper(), this);
+    }
+
+    @Deprecated
+    private void b(FragmentManager fragmentManager, ArrayMap<View, android.app.Fragment> arrayMap) {
+        int i2 = 0;
+        while (true) {
+            int i3 = i2 + 1;
+            this.h.putInt("key", i2);
+            android.app.Fragment fragment = null;
+            try {
+                fragment = fragmentManager.getFragment(this.h, "key");
+            } catch (Exception unused) {
+            }
+            if (fragment == null) {
+                return;
+            }
+            if (fragment.getView() != null) {
+                arrayMap.put(fragment.getView(), fragment);
+                if (Build.VERSION.SDK_INT >= 17) {
+                    a(fragment.getChildFragmentManager(), arrayMap);
+                }
+            }
+            i2 = i3;
+        }
+    }
+
+    private RequestManager c(Context context) {
+        if (this.a == null) {
+            synchronized (this) {
+                if (this.a == null) {
+                    this.a = this.e.a(Glide.b(context.getApplicationContext()), new ApplicationLifecycle(), new EmptyRequestManagerTreeNode(), context.getApplicationContext());
+                }
+            }
+        }
+        return this.a;
+    }
+
+    private static boolean d(Activity activity) {
+        return !activity.isFinishing();
+    }
+
+    public RequestManager a(Context context) {
+        if (context == null) {
+            throw new IllegalArgumentException("You cannot start a load on a null Context");
+        }
+        if (Util.d() && !(context instanceof Application)) {
+            if (context instanceof FragmentActivity) {
+                return a((FragmentActivity) context);
+            }
+            if (context instanceof Activity) {
+                return a((Activity) context);
+            }
+            if (context instanceof ContextWrapper) {
+                return a(((ContextWrapper) context).getBaseContext());
+            }
+        }
+        return c(context);
+    }
+
+    @Override // android.os.Handler.Callback
+    public boolean handleMessage(Message message) {
+        ComponentCallbacks remove;
+        int i2 = message.what;
+        Object obj = null;
+        boolean z = true;
+        if (i2 == 1) {
+            obj = (FragmentManager) message.obj;
+            remove = this.b.remove(obj);
+        } else if (i2 != 2) {
+            z = false;
+            remove = null;
+        } else {
+            obj = (androidx.fragment.app.FragmentManager) message.obj;
+            remove = this.c.remove(obj);
+        }
+        if (z && remove == null && Log.isLoggable("RMRetriever", 5)) {
+            Log.w("RMRetriever", "Failed to remove expected request manager fragment, manager: " + obj);
+        }
+        return z;
+    }
+
+    private Activity b(Context context) {
+        if (context instanceof Activity) {
+            return (Activity) context;
+        }
+        if (context instanceof ContextWrapper) {
+            return b(((ContextWrapper) context).getBaseContext());
+        }
+        return null;
+    }
+
+    @TargetApi(17)
+    private static void c(Activity activity) {
+        if (Build.VERSION.SDK_INT >= 17 && activity.isDestroyed()) {
+            throw new IllegalArgumentException("You cannot start a load for a destroyed activity");
+        }
+    }
+
+    public RequestManager a(FragmentActivity fragmentActivity) {
+        if (Util.c()) {
+            return a(fragmentActivity.getApplicationContext());
+        }
+        c((Activity) fragmentActivity);
+        return a(fragmentActivity, fragmentActivity.getSupportFragmentManager(), (Fragment) null, d(fragmentActivity));
+    }
+
+    @Deprecated
+    RequestManagerFragment b(Activity activity) {
+        return a(activity.getFragmentManager(), (android.app.Fragment) null, d(activity));
+    }
+
+    SupportRequestManagerFragment b(FragmentActivity fragmentActivity) {
+        return a(fragmentActivity.getSupportFragmentManager(), (Fragment) null, d(fragmentActivity));
+    }
+
+    public RequestManager a(Fragment fragment) {
+        Preconditions.a(fragment.getActivity(), "You cannot start a load on a fragment before it is attached or after it is destroyed");
+        if (Util.c()) {
+            return a(fragment.getActivity().getApplicationContext());
+        }
+        return a(fragment.getActivity(), fragment.getChildFragmentManager(), fragment, fragment.isVisible());
+    }
+
+    public RequestManager a(Activity activity) {
+        if (Util.c()) {
+            return a(activity.getApplicationContext());
+        }
+        c(activity);
+        return a(activity, activity.getFragmentManager(), (android.app.Fragment) null, d(activity));
+    }
+
+    public RequestManager a(View view) {
+        if (Util.c()) {
+            return a(view.getContext().getApplicationContext());
+        }
+        Preconditions.a(view);
+        Preconditions.a(view.getContext(), "Unable to obtain a request manager for a view without a Context");
+        Activity b = b(view.getContext());
+        if (b == null) {
+            return a(view.getContext().getApplicationContext());
+        }
+        if (b instanceof FragmentActivity) {
+            Fragment a = a(view, (FragmentActivity) b);
+            return a != null ? a(a) : a(b);
+        }
+        android.app.Fragment a2 = a(view, b);
+        if (a2 == null) {
+            return a(b);
+        }
+        return a(a2);
+    }
+
+    private static void a(Collection<Fragment> collection, Map<View, Fragment> map) {
+        if (collection == null) {
+            return;
+        }
+        for (Fragment fragment : collection) {
+            if (fragment != null && fragment.getView() != null) {
+                map.put(fragment.getView(), fragment);
+                a(fragment.getChildFragmentManager().b(), map);
+            }
+        }
+    }
+
+    private Fragment a(View view, FragmentActivity fragmentActivity) {
+        this.f.clear();
+        a(fragmentActivity.getSupportFragmentManager().b(), this.f);
+        View findViewById = fragmentActivity.findViewById(R.id.content);
+        Fragment fragment = null;
+        while (!view.equals(findViewById) && (fragment = this.f.get(view)) == null && (view.getParent() instanceof View)) {
+            view = (View) view.getParent();
+        }
+        this.f.clear();
+        return fragment;
+    }
+
+    @Deprecated
+    private android.app.Fragment a(View view, Activity activity) {
+        this.g.clear();
+        a(activity.getFragmentManager(), this.g);
+        View findViewById = activity.findViewById(R.id.content);
+        android.app.Fragment fragment = null;
+        while (!view.equals(findViewById) && (fragment = this.g.get(view)) == null && (view.getParent() instanceof View)) {
+            view = (View) view.getParent();
+        }
+        this.g.clear();
+        return fragment;
+    }
+
+    @TargetApi(26)
+    @Deprecated
+    private void a(FragmentManager fragmentManager, ArrayMap<View, android.app.Fragment> arrayMap) {
+        if (Build.VERSION.SDK_INT >= 26) {
+            for (android.app.Fragment fragment : fragmentManager.getFragments()) {
+                if (fragment.getView() != null) {
+                    arrayMap.put(fragment.getView(), fragment);
+                    a(fragment.getChildFragmentManager(), arrayMap);
+                }
+            }
+            return;
+        }
+        b(fragmentManager, arrayMap);
+    }
+
+    @TargetApi(17)
+    @Deprecated
+    public RequestManager a(android.app.Fragment fragment) {
+        if (fragment.getActivity() != null) {
+            if (!Util.c() && Build.VERSION.SDK_INT >= 17) {
+                return a(fragment.getActivity(), fragment.getChildFragmentManager(), fragment, fragment.isVisible());
+            }
+            return a(fragment.getActivity().getApplicationContext());
+        }
+        throw new IllegalArgumentException("You cannot start a load on a fragment before it is attached");
+    }
+
+    private RequestManagerFragment a(FragmentManager fragmentManager, android.app.Fragment fragment, boolean z) {
+        RequestManagerFragment requestManagerFragment = (RequestManagerFragment) fragmentManager.findFragmentByTag("com.bumptech.glide.manager");
+        if (requestManagerFragment == null && (requestManagerFragment = this.b.get(fragmentManager)) == null) {
+            requestManagerFragment = new RequestManagerFragment();
+            requestManagerFragment.a(fragment);
+            if (z) {
+                requestManagerFragment.a().b();
+            }
+            this.b.put(fragmentManager, requestManagerFragment);
+            fragmentManager.beginTransaction().add(requestManagerFragment, "com.bumptech.glide.manager").commitAllowingStateLoss();
+            this.d.obtainMessage(1, fragmentManager).sendToTarget();
+        }
+        return requestManagerFragment;
+    }
+
+    @Deprecated
+    private RequestManager a(Context context, FragmentManager fragmentManager, android.app.Fragment fragment, boolean z) {
+        RequestManagerFragment a = a(fragmentManager, fragment, z);
+        RequestManager b = a.b();
+        if (b != null) {
+            return b;
+        }
+        RequestManager a2 = this.e.a(Glide.b(context), a.a(), a.c(), context);
+        a.a(a2);
+        return a2;
+    }
+
+    private SupportRequestManagerFragment a(androidx.fragment.app.FragmentManager fragmentManager, Fragment fragment, boolean z) {
+        SupportRequestManagerFragment supportRequestManagerFragment = (SupportRequestManagerFragment) fragmentManager.a("com.bumptech.glide.manager");
+        if (supportRequestManagerFragment == null && (supportRequestManagerFragment = this.c.get(fragmentManager)) == null) {
+            supportRequestManagerFragment = new SupportRequestManagerFragment();
+            supportRequestManagerFragment.a(fragment);
+            if (z) {
+                supportRequestManagerFragment.b().b();
+            }
+            this.c.put(fragmentManager, supportRequestManagerFragment);
+            FragmentTransaction a = fragmentManager.a();
+            a.a(supportRequestManagerFragment, "com.bumptech.glide.manager");
+            a.b();
+            this.d.obtainMessage(2, fragmentManager).sendToTarget();
+        }
+        return supportRequestManagerFragment;
+    }
+
+    private RequestManager a(Context context, androidx.fragment.app.FragmentManager fragmentManager, Fragment fragment, boolean z) {
+        SupportRequestManagerFragment a = a(fragmentManager, fragment, z);
+        RequestManager o = a.o();
+        if (o != null) {
+            return o;
+        }
+        RequestManager a2 = this.e.a(Glide.b(context), a.b(), a.q(), context);
+        a.a(a2);
+        return a2;
+    }
+}

sources/com/bumptech/glide/manager/RequestManagerTreeNode.java

@@ -0,0 +1,5 @@
+package com.bumptech.glide.manager;
+
+/* loaded from: classes.dex */
+public interface RequestManagerTreeNode {
+}

sources/com/bumptech/glide/manager/RequestTracker.java

@@ -0,0 +1,97 @@
+package com.bumptech.glide.manager;
+
+import android.util.Log;
+import com.bumptech.glide.request.Request;
+import com.bumptech.glide.util.Util;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.WeakHashMap;
+
+/* loaded from: classes.dex */
+public class RequestTracker {
+    private final Set<Request> a = Collections.newSetFromMap(new WeakHashMap());
+    private final List<Request> b = new ArrayList();
+    private boolean c;
+
+    public boolean a(Request request) {
+        return a(request, true);
+    }
+
+    public void b(Request request) {
+        this.a.add(request);
+        if (!this.c) {
+            request.e();
+            return;
+        }
+        if (Log.isLoggable("RequestTracker", 2)) {
+            Log.v("RequestTracker", "Paused, delaying request");
+        }
+        this.b.add(request);
+    }
+
+    public void c() {
+        for (Request request : Util.a(this.a)) {
+            if (!request.g() && !request.isCancelled()) {
+                request.pause();
+                if (this.c) {
+                    this.b.add(request);
+                } else {
+                    request.e();
+                }
+            }
+        }
+    }
+
+    public void d() {
+        this.c = false;
+        for (Request request : Util.a(this.a)) {
+            if (!request.g() && !request.isCancelled() && !request.isRunning()) {
+                request.e();
+            }
+        }
+        this.b.clear();
+    }
+
+    public String toString() {
+        return super.toString() + "{numRequests=" + this.a.size() + ", isPaused=" + this.c + "}";
+    }
+
+    private boolean a(Request request, boolean z) {
+        boolean z2 = true;
+        if (request == null) {
+            return true;
+        }
+        boolean remove = this.a.remove(request);
+        if (!this.b.remove(request) && !remove) {
+            z2 = false;
+        }
+        if (z2) {
+            request.clear();
+            if (z) {
+                request.a();
+            }
+        }
+        return z2;
+    }
+
+    public void a() {
+        Iterator it = Util.a(this.a).iterator();
+        while (it.hasNext()) {
+            a((Request) it.next(), false);
+        }
+        this.b.clear();
+    }
+
+    public void b() {
+        this.c = true;
+        for (Request request : Util.a(this.a)) {
+            if (request.isRunning()) {
+                request.pause();
+                this.b.add(request);
+            }
+        }
+    }
+}

sources/com/bumptech/glide/manager/SupportRequestManagerFragment.java

@@ -0,0 +1,138 @@
+package com.bumptech.glide.manager;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.util.Log;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.RequestManager;
+import java.util.HashSet;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+public class SupportRequestManagerFragment extends Fragment {
+    private final ActivityFragmentLifecycle a;
+    private final RequestManagerTreeNode b;
+    private final Set<SupportRequestManagerFragment> c;
+    private SupportRequestManagerFragment d;
+    private RequestManager e;
+    private Fragment f;
+
+    private class SupportFragmentRequestManagerTreeNode implements RequestManagerTreeNode {
+        SupportFragmentRequestManagerTreeNode() {
+        }
+
+        public String toString() {
+            return super.toString() + "{fragment=" + SupportRequestManagerFragment.this + "}";
+        }
+    }
+
+    public SupportRequestManagerFragment() {
+        this(new ActivityFragmentLifecycle());
+    }
+
+    private Fragment v() {
+        Fragment parentFragment = getParentFragment();
+        return parentFragment != null ? parentFragment : this.f;
+    }
+
+    private void x() {
+        SupportRequestManagerFragment supportRequestManagerFragment = this.d;
+        if (supportRequestManagerFragment != null) {
+            supportRequestManagerFragment.b(this);
+            this.d = null;
+        }
+    }
+
+    public void a(RequestManager requestManager) {
+        this.e = requestManager;
+    }
+
+    ActivityFragmentLifecycle b() {
+        return this.a;
+    }
+
+    public RequestManager o() {
+        return this.e;
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    public void onAttach(Context context) {
+        super.onAttach(context);
+        try {
+            a(getActivity());
+        } catch (IllegalStateException e) {
+            if (Log.isLoggable("SupportRMFragment", 5)) {
+                Log.w("SupportRMFragment", "Unable to register fragment with root", e);
+            }
+        }
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    public void onDestroy() {
+        super.onDestroy();
+        this.a.a();
+        x();
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    public void onDetach() {
+        super.onDetach();
+        this.f = null;
+        x();
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    public void onStart() {
+        super.onStart();
+        this.a.b();
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    public void onStop() {
+        super.onStop();
+        this.a.c();
+    }
+
+    public RequestManagerTreeNode q() {
+        return this.b;
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    public String toString() {
+        return super.toString() + "{parent=" + v() + "}";
+    }
+
+    @SuppressLint({"ValidFragment"})
+    public SupportRequestManagerFragment(ActivityFragmentLifecycle activityFragmentLifecycle) {
+        this.b = new SupportFragmentRequestManagerTreeNode();
+        this.c = new HashSet();
+        this.a = activityFragmentLifecycle;
+    }
+
+    private void a(SupportRequestManagerFragment supportRequestManagerFragment) {
+        this.c.add(supportRequestManagerFragment);
+    }
+
+    private void b(SupportRequestManagerFragment supportRequestManagerFragment) {
+        this.c.remove(supportRequestManagerFragment);
+    }
+
+    void a(Fragment fragment) {
+        this.f = fragment;
+        if (fragment == null || fragment.getActivity() == null) {
+            return;
+        }
+        a(fragment.getActivity());
+    }
+
+    private void a(FragmentActivity fragmentActivity) {
+        x();
+        this.d = Glide.b(fragmentActivity).i().b(fragmentActivity);
+        if (equals(this.d)) {
+            return;
+        }
+        this.d.a(this);
+    }
+}

sources/com/bumptech/glide/manager/TargetTracker.java

@@ -0,0 +1,54 @@
+package com.bumptech.glide.manager;
+
+import com.bumptech.glide.request.target.Target;
+import com.bumptech.glide.util.Util;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.WeakHashMap;
+
+/* loaded from: classes.dex */
+public final class TargetTracker implements LifecycleListener {
+    private final Set<Target<?>> a = Collections.newSetFromMap(new WeakHashMap());
+
+    public void a(Target<?> target) {
+        this.a.add(target);
+    }
+
+    public void b(Target<?> target) {
+        this.a.remove(target);
+    }
+
+    public void d() {
+        this.a.clear();
+    }
+
+    public List<Target<?>> e() {
+        return Util.a(this.a);
+    }
+
+    @Override // com.bumptech.glide.manager.LifecycleListener
+    public void onStart() {
+        Iterator it = Util.a(this.a).iterator();
+        while (it.hasNext()) {
+            ((Target) it.next()).onStart();
+        }
+    }
+
+    @Override // com.bumptech.glide.manager.LifecycleListener
+    public void a() {
+        Iterator it = Util.a(this.a).iterator();
+        while (it.hasNext()) {
+            ((Target) it.next()).a();
+        }
+    }
+
+    @Override // com.bumptech.glide.manager.LifecycleListener
+    public void b() {
+        Iterator it = Util.a(this.a).iterator();
+        while (it.hasNext()) {
+            ((Target) it.next()).b();
+        }
+    }
+}