Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/dagger/hilt/android/internal/Contexts.java

@@ -0,0 +1,25 @@
+package dagger.hilt.android.internal;
+
+import android.app.Application;
+import android.content.Context;
+import android.content.ContextWrapper;
+
+/* loaded from: classes3.dex */
+public final class Contexts {
+    private Contexts() {
+    }
+
+    public static Application getApplication(Context context) {
+        if (context instanceof Application) {
+            return (Application) context;
+        }
+        Context context2 = context;
+        while (context2 instanceof ContextWrapper) {
+            context2 = ((ContextWrapper) context2).getBaseContext();
+            if (context2 instanceof Application) {
+                return (Application) context2;
+            }
+        }
+        throw new IllegalStateException("Could not find an Application in the given context: " + context);
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/OnReceiveBytecodeInjectionMarker.java

@@ -0,0 +1,12 @@
+package dagger.hilt.android.internal;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface OnReceiveBytecodeInjectionMarker {
+}

apk_decompiled/sources/dagger/hilt/android/internal/ThreadUtil.java

@@ -0,0 +1,24 @@
+package dagger.hilt.android.internal;
+
+import android.os.Looper;
+
+/* loaded from: classes3.dex */
+public final class ThreadUtil {
+    private static Thread mainThread;
+
+    private ThreadUtil() {
+    }
+
+    public static void ensureMainThread() {
+        if (!isMainThread()) {
+            throw new IllegalStateException("Must be called on the Main thread.");
+        }
+    }
+
+    public static boolean isMainThread() {
+        if (mainThread == null) {
+            mainThread = Looper.getMainLooper().getThread();
+        }
+        return Thread.currentThread() == mainThread;
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/builders/ActivityComponentBuilder.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.internal.builders;
+
+import android.app.Activity;
+import dagger.BindsInstance;
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.components.ActivityComponent;
+
+@DefineComponent.Builder
+/* loaded from: classes3.dex */
+public interface ActivityComponentBuilder {
+    ActivityComponentBuilder activity(@BindsInstance Activity activity);
+
+    ActivityComponent build();
+}

apk_decompiled/sources/dagger/hilt/android/internal/builders/ActivityRetainedComponentBuilder.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.internal.builders;
+
+import dagger.BindsInstance;
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.internal.managers.SavedStateHandleHolder;
+
+@DefineComponent.Builder
+/* loaded from: classes3.dex */
+public interface ActivityRetainedComponentBuilder {
+    ActivityRetainedComponent build();
+
+    ActivityRetainedComponentBuilder savedStateHandleHolder(@BindsInstance SavedStateHandleHolder savedStateHandleHolder);
+}

apk_decompiled/sources/dagger/hilt/android/internal/builders/FragmentComponentBuilder.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.internal.builders;
+
+import androidx.fragment.app.K;
+import dagger.BindsInstance;
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.components.FragmentComponent;
+
+@DefineComponent.Builder
+/* loaded from: classes3.dex */
+public interface FragmentComponentBuilder {
+    FragmentComponent build();
+
+    FragmentComponentBuilder fragment(@BindsInstance K k4);
+}

apk_decompiled/sources/dagger/hilt/android/internal/builders/ServiceComponentBuilder.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.internal.builders;
+
+import android.app.Service;
+import dagger.BindsInstance;
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.components.ServiceComponent;
+
+@DefineComponent.Builder
+/* loaded from: classes3.dex */
+public interface ServiceComponentBuilder {
+    ServiceComponent build();
+
+    ServiceComponentBuilder service(@BindsInstance Service service);
+}

apk_decompiled/sources/dagger/hilt/android/internal/builders/ViewComponentBuilder.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.internal.builders;
+
+import android.view.View;
+import dagger.BindsInstance;
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.components.ViewComponent;
+
+@DefineComponent.Builder
+/* loaded from: classes3.dex */
+public interface ViewComponentBuilder {
+    ViewComponent build();
+
+    ViewComponentBuilder view(@BindsInstance View view);
+}

apk_decompiled/sources/dagger/hilt/android/internal/builders/ViewModelComponentBuilder.java

@@ -0,0 +1,17 @@
+package dagger.hilt.android.internal.builders;
+
+import androidx.lifecycle.n0;
+import dagger.BindsInstance;
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.ViewModelLifecycle;
+import dagger.hilt.android.components.ViewModelComponent;
+
+@DefineComponent.Builder
+/* loaded from: classes3.dex */
+public interface ViewModelComponentBuilder {
+    ViewModelComponent build();
+
+    ViewModelComponentBuilder savedStateHandle(@BindsInstance n0 n0Var);
+
+    ViewModelComponentBuilder viewModelLifecycle(@BindsInstance ViewModelLifecycle viewModelLifecycle);
+}

apk_decompiled/sources/dagger/hilt/android/internal/builders/ViewWithFragmentComponentBuilder.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.internal.builders;
+
+import android.view.View;
+import dagger.BindsInstance;
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.components.ViewWithFragmentComponent;
+
+@DefineComponent.Builder
+/* loaded from: classes3.dex */
+public interface ViewWithFragmentComponentBuilder {
+    ViewWithFragmentComponent build();
+
+    ViewWithFragmentComponentBuilder view(@BindsInstance View view);
+}

apk_decompiled/sources/dagger/hilt/android/internal/earlyentrypoint/AggregatedEarlyEntryPoint.java

@@ -0,0 +1,10 @@
+package dagger.hilt.android.internal.earlyentrypoint;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface AggregatedEarlyEntryPoint {
+    String earlyEntryPoint();
+}

apk_decompiled/sources/dagger/hilt/android/internal/legacy/AggregatedElementProxy.java

@@ -0,0 +1,13 @@
+package dagger.hilt.android.internal.legacy;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface AggregatedElementProxy {
+    Class<?> value();
+}

apk_decompiled/sources/dagger/hilt/android/internal/lifecycle/DefaultViewModelFactories.java

@@ -0,0 +1,79 @@
+package dagger.hilt.android.internal.lifecycle;
+
+import androidx.fragment.app.K;
+import androidx.lifecycle.y0;
+import b.o;
+import dagger.Module;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.components.FragmentComponent;
+import dagger.hilt.android.internal.builders.ViewModelComponentBuilder;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+import dagger.hilt.internal.Preconditions;
+import dagger.multibindings.Multibinds;
+import java.util.Set;
+import javax.inject.Inject;
+
+/* loaded from: classes3.dex */
+public final class DefaultViewModelFactories {
+
+    @EntryPoint
+    @InstallIn({ActivityComponent.class})
+    /* loaded from: classes3.dex */
+    public interface ActivityEntryPoint {
+        InternalFactoryFactory getHiltInternalFactoryFactory();
+    }
+
+    @Module
+    @InstallIn({ActivityComponent.class})
+    /* loaded from: classes3.dex */
+    public interface ActivityModule {
+        @HiltViewModelMap.KeySet
+        @Multibinds
+        Set<String> viewModelKeys();
+    }
+
+    @EntryPoint
+    @InstallIn({FragmentComponent.class})
+    /* loaded from: classes3.dex */
+    public interface FragmentEntryPoint {
+        InternalFactoryFactory getHiltInternalFactoryFactory();
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class InternalFactoryFactory {
+        private final Set<String> keySet;
+        private final ViewModelComponentBuilder viewModelComponentBuilder;
+
+        @Inject
+        public InternalFactoryFactory(@HiltViewModelMap.KeySet Set<String> set, ViewModelComponentBuilder viewModelComponentBuilder) {
+            this.keySet = set;
+            this.viewModelComponentBuilder = viewModelComponentBuilder;
+        }
+
+        private y0 getHiltViewModelFactory(y0 y0Var) {
+            return new HiltViewModelFactory(this.keySet, (y0) Preconditions.checkNotNull(y0Var), this.viewModelComponentBuilder);
+        }
+
+        public y0 fromActivity(o oVar, y0 y0Var) {
+            return getHiltViewModelFactory(y0Var);
+        }
+
+        public y0 fromFragment(K k4, y0 y0Var) {
+            return getHiltViewModelFactory(y0Var);
+        }
+    }
+
+    private DefaultViewModelFactories() {
+    }
+
+    public static y0 getActivityFactory(o oVar, y0 y0Var) {
+        return ((ActivityEntryPoint) EntryPoints.get(oVar, ActivityEntryPoint.class)).getHiltInternalFactoryFactory().fromActivity(oVar, y0Var);
+    }
+
+    public static y0 getFragmentFactory(K k4, y0 y0Var) {
+        return ((FragmentEntryPoint) EntryPoints.get(k4, FragmentEntryPoint.class)).getHiltInternalFactoryFactory().fromFragment(k4, y0Var);
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/lifecycle/DefaultViewModelFactories_InternalFactoryFactory_Factory.java

@@ -0,0 +1,37 @@
+package dagger.hilt.android.internal.lifecycle;
+
+import dagger.hilt.android.internal.builders.ViewModelComponentBuilder;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import java.util.Set;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata({"dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet"})
+/* loaded from: classes3.dex */
+public final class DefaultViewModelFactories_InternalFactoryFactory_Factory implements Factory<DefaultViewModelFactories.InternalFactoryFactory> {
+    private final Provider<Set<String>> keySetProvider;
+    private final Provider<ViewModelComponentBuilder> viewModelComponentBuilderProvider;
+
+    public DefaultViewModelFactories_InternalFactoryFactory_Factory(Provider<Set<String>> provider, Provider<ViewModelComponentBuilder> provider2) {
+        this.keySetProvider = provider;
+        this.viewModelComponentBuilderProvider = provider2;
+    }
+
+    public static DefaultViewModelFactories_InternalFactoryFactory_Factory create(Provider<Set<String>> provider, Provider<ViewModelComponentBuilder> provider2) {
+        return new DefaultViewModelFactories_InternalFactoryFactory_Factory(provider, provider2);
+    }
+
+    public static DefaultViewModelFactories.InternalFactoryFactory newInstance(Set<String> set, ViewModelComponentBuilder viewModelComponentBuilder) {
+        return new DefaultViewModelFactories.InternalFactoryFactory(set, viewModelComponentBuilder);
+    }
+
+    @Override // javax.inject.Provider
+    public DefaultViewModelFactories.InternalFactoryFactory get() {
+        return newInstance(this.keySetProvider.get(), this.viewModelComponentBuilderProvider.get());
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/lifecycle/HiltViewModelAssistedMap.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.internal.lifecycle;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.inject.Qualifier;
+
+@Target({ElementType.METHOD, ElementType.PARAMETER})
+@Qualifier
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface HiltViewModelAssistedMap {
+}

apk_decompiled/sources/dagger/hilt/android/internal/lifecycle/HiltViewModelFactory.java

@@ -0,0 +1,150 @@
+package dagger.hilt.android.internal.lifecycle;
+
+import android.app.Activity;
+import android.os.Bundle;
+import androidx.lifecycle.q0;
+import androidx.lifecycle.w0;
+import androidx.lifecycle.y0;
+import dagger.Module;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.builders.ViewModelComponentBuilder;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+import dagger.multibindings.Multibinds;
+import java.io.Closeable;
+import java.util.Map;
+import java.util.Set;
+import javax.inject.Provider;
+import kotlin.jvm.functions.Function1;
+import kotlin.reflect.KClass;
+import l0.b;
+import l0.c;
+import v0.f;
+
+/* loaded from: classes3.dex */
+public final class HiltViewModelFactory implements y0 {
+    public static final b CREATION_CALLBACK_KEY = new b() { // from class: dagger.hilt.android.internal.lifecycle.HiltViewModelFactory.1
+    };
+    private final y0 delegateFactory;
+    private final y0 hiltViewModelFactory;
+    private final Set<String> hiltViewModelKeys;
+
+    @EntryPoint
+    @InstallIn({ActivityComponent.class})
+    /* loaded from: classes3.dex */
+    public interface ActivityCreatorEntryPoint {
+        ViewModelComponentBuilder getViewModelComponentBuilder();
+
+        @HiltViewModelMap.KeySet
+        Set<String> getViewModelKeys();
+    }
+
+    @EntryPoint
+    @InstallIn({ViewModelComponent.class})
+    /* loaded from: classes3.dex */
+    public interface ViewModelFactoriesEntryPoint {
+        @HiltViewModelAssistedMap
+        Map<String, Object> getHiltViewModelAssistedMap();
+
+        @HiltViewModelMap
+        Map<String, Provider<w0>> getHiltViewModelMap();
+    }
+
+    @Module
+    @InstallIn({ViewModelComponent.class})
+    /* loaded from: classes3.dex */
+    public interface ViewModelModule {
+        @HiltViewModelAssistedMap
+        @Multibinds
+        Map<String, Object> hiltViewModelAssistedMap();
+
+        @HiltViewModelMap
+        @Multibinds
+        Map<String, w0> hiltViewModelMap();
+    }
+
+    public HiltViewModelFactory(Set<String> set, y0 y0Var, final ViewModelComponentBuilder viewModelComponentBuilder) {
+        this.hiltViewModelKeys = set;
+        this.delegateFactory = y0Var;
+        this.hiltViewModelFactory = new y0() { // from class: dagger.hilt.android.internal.lifecycle.HiltViewModelFactory.2
+            private <T extends w0> T createViewModel(ViewModelComponent viewModelComponent, Class<T> cls, c cVar) {
+                Provider<w0> provider = ((ViewModelFactoriesEntryPoint) EntryPoints.get(viewModelComponent, ViewModelFactoriesEntryPoint.class)).getHiltViewModelMap().get(cls.getName());
+                Function1 function1 = (Function1) cVar.a(HiltViewModelFactory.CREATION_CALLBACK_KEY);
+                Object obj = ((ViewModelFactoriesEntryPoint) EntryPoints.get(viewModelComponent, ViewModelFactoriesEntryPoint.class)).getHiltViewModelAssistedMap().get(cls.getName());
+                if (obj == null) {
+                    if (function1 != null) {
+                        throw new IllegalStateException("Found creation callback but class " + cls.getName() + " does not have an assisted factory specified in @HiltViewModel.");
+                    }
+                    if (provider != null) {
+                        return (T) provider.get();
+                    }
+                    throw new IllegalStateException("Expected the @HiltViewModel-annotated class " + cls.getName() + " to be available in the multi-binding of @HiltViewModelMap but none was found.");
+                }
+                if (provider != null) {
+                    throw new AssertionError("Found the @HiltViewModel-annotated class " + cls.getName() + " in both the multi-bindings of @HiltViewModelMap and @HiltViewModelAssistedMap.");
+                }
+                if (function1 != null) {
+                    return (T) function1.invoke(obj);
+                }
+                throw new IllegalStateException("Found @HiltViewModel-annotated class " + cls.getName() + " using @AssistedInject but no creation callback was provided in CreationExtras.");
+            }
+
+            @Override // androidx.lifecycle.y0
+            public /* bridge */ /* synthetic */ w0 create(Class cls) {
+                super.create(cls);
+                throw null;
+            }
+
+            @Override // androidx.lifecycle.y0
+            public /* bridge */ /* synthetic */ w0 create(KClass kClass, c cVar) {
+                return super.create(kClass, cVar);
+            }
+
+            @Override // androidx.lifecycle.y0
+            public <T extends w0> T create(Class<T> cls, c cVar) {
+                final RetainedLifecycleImpl retainedLifecycleImpl = new RetainedLifecycleImpl();
+                T t2 = (T) createViewModel(viewModelComponentBuilder.savedStateHandle(q0.e(cVar)).viewModelLifecycle(retainedLifecycleImpl).build(), cls, cVar);
+                t2.addCloseable(new Closeable() { // from class: dagger.hilt.android.internal.lifecycle.a
+                    @Override // java.io.Closeable, java.lang.AutoCloseable
+                    public final void close() {
+                        RetainedLifecycleImpl.this.dispatchOnCleared();
+                    }
+                });
+                return t2;
+            }
+        };
+    }
+
+    public static y0 createInternal(Activity activity, f fVar, Bundle bundle, y0 y0Var) {
+        return createInternal(activity, y0Var);
+    }
+
+    @Override // androidx.lifecycle.y0
+    public /* bridge */ /* synthetic */ w0 create(KClass kClass, c cVar) {
+        return super.create(kClass, cVar);
+    }
+
+    public static y0 createInternal(Activity activity, y0 y0Var) {
+        ActivityCreatorEntryPoint activityCreatorEntryPoint = (ActivityCreatorEntryPoint) EntryPoints.get(activity, ActivityCreatorEntryPoint.class);
+        return new HiltViewModelFactory(activityCreatorEntryPoint.getViewModelKeys(), y0Var, activityCreatorEntryPoint.getViewModelComponentBuilder());
+    }
+
+    @Override // androidx.lifecycle.y0
+    public <T extends w0> T create(Class<T> cls, c cVar) {
+        if (this.hiltViewModelKeys.contains(cls.getName())) {
+            return (T) this.hiltViewModelFactory.create(cls, cVar);
+        }
+        return (T) this.delegateFactory.create(cls, cVar);
+    }
+
+    @Override // androidx.lifecycle.y0
+    public <T extends w0> T create(Class<T> cls) {
+        if (this.hiltViewModelKeys.contains(cls.getName())) {
+            return (T) this.hiltViewModelFactory.create(cls);
+        }
+        return (T) this.delegateFactory.create(cls);
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/lifecycle/HiltViewModelMap.java

@@ -0,0 +1,21 @@
+package dagger.hilt.android.internal.lifecycle;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.inject.Qualifier;
+
+@Target({ElementType.METHOD, ElementType.PARAMETER})
+@Qualifier
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface HiltViewModelMap {
+
+    @Target({ElementType.METHOD, ElementType.PARAMETER})
+    @Qualifier
+    @Retention(RetentionPolicy.CLASS)
+    /* loaded from: classes3.dex */
+    public @interface KeySet {
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/lifecycle/HiltWrapper_DefaultViewModelFactories_ActivityModule.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.internal.lifecycle;
+
+import dagger.Module;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
+import dagger.hilt.codegen.OriginatingElement;
+
+@OriginatingElement(topLevelClass = DefaultViewModelFactories.class)
+@Module(includes = {DefaultViewModelFactories.ActivityModule.class})
+@InstallIn({ActivityComponent.class})
+/* loaded from: classes3.dex */
+public final class HiltWrapper_DefaultViewModelFactories_ActivityModule {
+}

apk_decompiled/sources/dagger/hilt/android/internal/lifecycle/HiltWrapper_HiltViewModelFactory_ActivityCreatorEntryPoint.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.internal.lifecycle;
+
+import dagger.hilt.EntryPoint;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelFactory;
+import dagger.hilt.codegen.OriginatingElement;
+
+@EntryPoint
+@OriginatingElement(topLevelClass = HiltViewModelFactory.class)
+@InstallIn({ActivityComponent.class})
+/* loaded from: classes3.dex */
+public interface HiltWrapper_HiltViewModelFactory_ActivityCreatorEntryPoint extends HiltViewModelFactory.ActivityCreatorEntryPoint {
+}

apk_decompiled/sources/dagger/hilt/android/internal/lifecycle/HiltWrapper_HiltViewModelFactory_ViewModelModule.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.internal.lifecycle;
+
+import dagger.Module;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelFactory;
+import dagger.hilt.codegen.OriginatingElement;
+
+@OriginatingElement(topLevelClass = HiltViewModelFactory.class)
+@Module(includes = {HiltViewModelFactory.ViewModelModule.class})
+@InstallIn({ViewModelComponent.class})
+/* loaded from: classes3.dex */
+public final class HiltWrapper_HiltViewModelFactory_ViewModelModule {
+}

apk_decompiled/sources/dagger/hilt/android/internal/lifecycle/RetainedLifecycleImpl.java

@@ -0,0 +1,44 @@
+package dagger.hilt.android.internal.lifecycle;
+
+import dagger.hilt.android.ActivityRetainedLifecycle;
+import dagger.hilt.android.ViewModelLifecycle;
+import dagger.hilt.android.internal.ThreadUtil;
+import dagger.hilt.android.lifecycle.RetainedLifecycle;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+/* loaded from: classes3.dex */
+public final class RetainedLifecycleImpl implements ActivityRetainedLifecycle, ViewModelLifecycle {
+    private final Set<RetainedLifecycle.OnClearedListener> listeners = new HashSet();
+    private boolean onClearedDispatched = false;
+
+    private void throwIfOnClearedDispatched() {
+        if (this.onClearedDispatched) {
+            throw new IllegalStateException("There was a race between the call to add/remove an OnClearedListener and onCleared(). This can happen when posting to the Main thread from a background thread, which is not supported.");
+        }
+    }
+
+    @Override // dagger.hilt.android.lifecycle.RetainedLifecycle
+    public void addOnClearedListener(RetainedLifecycle.OnClearedListener onClearedListener) {
+        ThreadUtil.ensureMainThread();
+        throwIfOnClearedDispatched();
+        this.listeners.add(onClearedListener);
+    }
+
+    public void dispatchOnCleared() {
+        ThreadUtil.ensureMainThread();
+        this.onClearedDispatched = true;
+        Iterator<RetainedLifecycle.OnClearedListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onCleared();
+        }
+    }
+
+    @Override // dagger.hilt.android.lifecycle.RetainedLifecycle
+    public void removeOnClearedListener(RetainedLifecycle.OnClearedListener onClearedListener) {
+        ThreadUtil.ensureMainThread();
+        throwIfOnClearedDispatched();
+        this.listeners.remove(onClearedListener);
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/ActivityComponentManager.java

@@ -0,0 +1,65 @@
+package dagger.hilt.android.internal.managers;
+
+import android.app.Activity;
+import android.app.Application;
+import b.o;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.internal.builders.ActivityComponentBuilder;
+import dagger.hilt.internal.GeneratedComponentManager;
+
+/* loaded from: classes3.dex */
+public class ActivityComponentManager implements GeneratedComponentManager<Object> {
+    protected final Activity activity;
+    private final GeneratedComponentManager<ActivityRetainedComponent> activityRetainedComponentManager;
+    private volatile Object component;
+    private final Object componentLock = new Object();
+
+    @EntryPoint
+    @InstallIn({ActivityRetainedComponent.class})
+    /* loaded from: classes3.dex */
+    public interface ActivityComponentBuilderEntryPoint {
+        ActivityComponentBuilder activityComponentBuilder();
+    }
+
+    public ActivityComponentManager(Activity activity) {
+        this.activity = activity;
+        this.activityRetainedComponentManager = new ActivityRetainedComponentManager((o) activity);
+    }
+
+    public Object createComponent() {
+        String str;
+        if (this.activity.getApplication() instanceof GeneratedComponentManager) {
+            return ((ActivityComponentBuilderEntryPoint) EntryPoints.get(this.activityRetainedComponentManager, ActivityComponentBuilderEntryPoint.class)).activityComponentBuilder().activity(this.activity).build();
+        }
+        StringBuilder sb = new StringBuilder("Hilt Activity must be attached to an @HiltAndroidApp Application. ");
+        if (Application.class.equals(this.activity.getApplication().getClass())) {
+            str = "Did you forget to specify your Application's class name in your manifest's <application />'s android:name attribute?";
+        } else {
+            str = "Found: " + this.activity.getApplication().getClass();
+        }
+        sb.append(str);
+        throw new IllegalStateException(sb.toString());
+    }
+
+    @Override // dagger.hilt.internal.GeneratedComponentManager
+    public Object generatedComponent() {
+        if (this.component == null) {
+            synchronized (this.componentLock) {
+                try {
+                    if (this.component == null) {
+                        this.component = createComponent();
+                    }
+                } finally {
+                }
+            }
+        }
+        return this.component;
+    }
+
+    public final SavedStateHandleHolder getSavedStateHandleHolder() {
+        return ((ActivityRetainedComponentManager) this.activityRetainedComponentManager).getSavedStateHandleHolder();
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/ActivityRetainedComponentManager.java

@@ -0,0 +1,155 @@
+package dagger.hilt.android.internal.managers;
+
+import android.content.Context;
+import androidx.lifecycle.B0;
+import androidx.lifecycle.D0;
+import androidx.lifecycle.w0;
+import androidx.lifecycle.y0;
+import b.o;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.ActivityRetainedLifecycle;
+import dagger.hilt.android.EntryPointAccessors;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.internal.builders.ActivityRetainedComponentBuilder;
+import dagger.hilt.android.internal.lifecycle.RetainedLifecycleImpl;
+import dagger.hilt.android.scopes.ActivityRetainedScoped;
+import dagger.hilt.components.SingletonComponent;
+import dagger.hilt.internal.GeneratedComponentManager;
+import kotlin.jvm.JvmClassMappingKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.KClass;
+import l0.c;
+
+/* loaded from: classes3.dex */
+final class ActivityRetainedComponentManager implements GeneratedComponentManager<ActivityRetainedComponent> {
+    private volatile ActivityRetainedComponent component;
+    private final Object componentLock = new Object();
+    private final Context context;
+    private final D0 viewModelStoreOwner;
+
+    @EntryPoint
+    @InstallIn({SingletonComponent.class})
+    /* loaded from: classes3.dex */
+    public interface ActivityRetainedComponentBuilderEntryPoint {
+        ActivityRetainedComponentBuilder retainedComponentBuilder();
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class ActivityRetainedComponentViewModel extends w0 {
+        private final ActivityRetainedComponent component;
+        private final SavedStateHandleHolder savedStateHandleHolder;
+
+        public ActivityRetainedComponentViewModel(ActivityRetainedComponent activityRetainedComponent, SavedStateHandleHolder savedStateHandleHolder) {
+            this.component = activityRetainedComponent;
+            this.savedStateHandleHolder = savedStateHandleHolder;
+        }
+
+        public ActivityRetainedComponent getComponent() {
+            return this.component;
+        }
+
+        public SavedStateHandleHolder getSavedStateHandleHolder() {
+            return this.savedStateHandleHolder;
+        }
+
+        @Override // androidx.lifecycle.w0
+        public void onCleared() {
+            super.onCleared();
+            ((RetainedLifecycleImpl) ((ActivityRetainedLifecycleEntryPoint) EntryPoints.get(this.component, ActivityRetainedLifecycleEntryPoint.class)).getActivityRetainedLifecycle()).dispatchOnCleared();
+        }
+    }
+
+    @EntryPoint
+    @InstallIn({ActivityRetainedComponent.class})
+    /* loaded from: classes3.dex */
+    public interface ActivityRetainedLifecycleEntryPoint {
+        ActivityRetainedLifecycle getActivityRetainedLifecycle();
+    }
+
+    @Module
+    @InstallIn({ActivityRetainedComponent.class})
+    /* loaded from: classes3.dex */
+    public static abstract class LifecycleModule {
+        @Provides
+        @ActivityRetainedScoped
+        public static ActivityRetainedLifecycle provideActivityRetainedLifecycle() {
+            return new RetainedLifecycleImpl();
+        }
+    }
+
+    public ActivityRetainedComponentManager(o oVar) {
+        this.viewModelStoreOwner = oVar;
+        this.context = oVar;
+    }
+
+    private ActivityRetainedComponent createComponent() {
+        B0 viewModelProvider = getViewModelProvider(this.viewModelStoreOwner, this.context);
+        viewModelProvider.getClass();
+        Intrinsics.checkNotNullParameter(ActivityRetainedComponentViewModel.class, "modelClass");
+        KClass modelClass = JvmClassMappingKt.getKotlinClass(ActivityRetainedComponentViewModel.class);
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Intrinsics.checkNotNullParameter(modelClass, "<this>");
+        String qualifiedName = modelClass.getQualifiedName();
+        if (qualifiedName == null) {
+            throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
+        }
+        return ((ActivityRetainedComponentViewModel) viewModelProvider.f3286a.i(modelClass, "androidx.lifecycle.ViewModelProvider.DefaultKey:".concat(qualifiedName))).getComponent();
+    }
+
+    private B0 getViewModelProvider(D0 d02, final Context context) {
+        return new B0(d02, new y0() { // from class: dagger.hilt.android.internal.managers.ActivityRetainedComponentManager.1
+            @Override // androidx.lifecycle.y0
+            public /* bridge */ /* synthetic */ w0 create(Class cls) {
+                super.create(cls);
+                throw null;
+            }
+
+            @Override // androidx.lifecycle.y0
+            public /* bridge */ /* synthetic */ w0 create(KClass kClass, c cVar) {
+                return super.create(kClass, cVar);
+            }
+
+            @Override // androidx.lifecycle.y0
+            public <T extends w0> T create(Class<T> cls, c cVar) {
+                SavedStateHandleHolder savedStateHandleHolder = new SavedStateHandleHolder(cVar);
+                return new ActivityRetainedComponentViewModel(((ActivityRetainedComponentBuilderEntryPoint) EntryPointAccessors.fromApplication(context, ActivityRetainedComponentBuilderEntryPoint.class)).retainedComponentBuilder().savedStateHandleHolder(savedStateHandleHolder).build(), savedStateHandleHolder);
+            }
+        });
+    }
+
+    public SavedStateHandleHolder getSavedStateHandleHolder() {
+        B0 viewModelProvider = getViewModelProvider(this.viewModelStoreOwner, this.context);
+        viewModelProvider.getClass();
+        Intrinsics.checkNotNullParameter(ActivityRetainedComponentViewModel.class, "modelClass");
+        KClass modelClass = JvmClassMappingKt.getKotlinClass(ActivityRetainedComponentViewModel.class);
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Intrinsics.checkNotNullParameter(modelClass, "<this>");
+        String qualifiedName = modelClass.getQualifiedName();
+        if (qualifiedName == null) {
+            throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
+        }
+        return ((ActivityRetainedComponentViewModel) viewModelProvider.f3286a.i(modelClass, "androidx.lifecycle.ViewModelProvider.DefaultKey:".concat(qualifiedName))).getSavedStateHandleHolder();
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // dagger.hilt.internal.GeneratedComponentManager
+    public ActivityRetainedComponent generatedComponent() {
+        if (this.component == null) {
+            synchronized (this.componentLock) {
+                try {
+                    if (this.component == null) {
+                        this.component = createComponent();
+                    }
+                } finally {
+                }
+            }
+        }
+        return this.component;
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/ActivityRetainedComponentManager_LifecycleModule_ProvideActivityRetainedLifecycleFactory.java

@@ -0,0 +1,37 @@
+package dagger.hilt.android.internal.managers;
+
+import dagger.hilt.android.ActivityRetainedLifecycle;
+import dagger.hilt.android.internal.managers.ActivityRetainedComponentManager;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+
+@ScopeMetadata("dagger.hilt.android.scopes.ActivityRetainedScoped")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes3.dex */
+public final class ActivityRetainedComponentManager_LifecycleModule_ProvideActivityRetainedLifecycleFactory implements Factory<ActivityRetainedLifecycle> {
+
+    /* loaded from: classes3.dex */
+    public static final class InstanceHolder {
+        private static final ActivityRetainedComponentManager_LifecycleModule_ProvideActivityRetainedLifecycleFactory INSTANCE = new ActivityRetainedComponentManager_LifecycleModule_ProvideActivityRetainedLifecycleFactory();
+
+        private InstanceHolder() {
+        }
+    }
+
+    public static ActivityRetainedComponentManager_LifecycleModule_ProvideActivityRetainedLifecycleFactory create() {
+        return InstanceHolder.INSTANCE;
+    }
+
+    public static ActivityRetainedLifecycle provideActivityRetainedLifecycle() {
+        return (ActivityRetainedLifecycle) Preconditions.checkNotNullFromProvides(ActivityRetainedComponentManager.LifecycleModule.provideActivityRetainedLifecycle());
+    }
+
+    @Override // javax.inject.Provider
+    public ActivityRetainedLifecycle get() {
+        return provideActivityRetainedLifecycle();
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/ApplicationComponentManager.java

@@ -0,0 +1,29 @@
+package dagger.hilt.android.internal.managers;
+
+import dagger.hilt.internal.GeneratedComponentManager;
+
+/* loaded from: classes3.dex */
+public final class ApplicationComponentManager implements GeneratedComponentManager<Object> {
+    private volatile Object component;
+    private final ComponentSupplier componentCreator;
+    private final Object componentLock = new Object();
+
+    public ApplicationComponentManager(ComponentSupplier componentSupplier) {
+        this.componentCreator = componentSupplier;
+    }
+
+    @Override // dagger.hilt.internal.GeneratedComponentManager
+    public Object generatedComponent() {
+        if (this.component == null) {
+            synchronized (this.componentLock) {
+                try {
+                    if (this.component == null) {
+                        this.component = this.componentCreator.get();
+                    }
+                } finally {
+                }
+            }
+        }
+        return this.component;
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/BroadcastReceiverComponentManager.java

@@ -0,0 +1,19 @@
+package dagger.hilt.android.internal.managers;
+
+import android.content.ComponentCallbacks2;
+import android.content.Context;
+import dagger.hilt.android.internal.Contexts;
+import dagger.hilt.internal.GeneratedComponentManager;
+import dagger.hilt.internal.Preconditions;
+
+/* loaded from: classes3.dex */
+public final class BroadcastReceiverComponentManager {
+    private BroadcastReceiverComponentManager() {
+    }
+
+    public static Object generatedComponent(Context context) {
+        ComponentCallbacks2 application = Contexts.getApplication(context.getApplicationContext());
+        Preconditions.checkArgument(application instanceof GeneratedComponentManager, "Hilt BroadcastReceiver must be attached to an @HiltAndroidApp Application. Found: %s", application.getClass());
+        return ((GeneratedComponentManager) application).generatedComponent();
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/ComponentSupplier.java

@@ -0,0 +1,6 @@
+package dagger.hilt.android.internal.managers;
+
+/* loaded from: classes3.dex */
+public interface ComponentSupplier {
+    Object get();
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/FragmentComponentManager.java

@@ -0,0 +1,81 @@
+package dagger.hilt.android.internal.managers;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import androidx.fragment.app.K;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.internal.builders.FragmentComponentBuilder;
+import dagger.hilt.android.internal.managers.ViewComponentManager;
+import dagger.hilt.internal.GeneratedComponentManager;
+import dagger.hilt.internal.Preconditions;
+
+/* loaded from: classes3.dex */
+public class FragmentComponentManager implements GeneratedComponentManager<Object> {
+    private volatile Object component;
+    private final Object componentLock = new Object();
+    private final K fragment;
+
+    @EntryPoint
+    @InstallIn({ActivityComponent.class})
+    /* loaded from: classes3.dex */
+    public interface FragmentComponentBuilderEntryPoint {
+        FragmentComponentBuilder fragmentComponentBuilder();
+    }
+
+    public FragmentComponentManager(K k4) {
+        this.fragment = k4;
+    }
+
+    private Object createComponent() {
+        Preconditions.checkNotNull(this.fragment.getHost(), "Hilt Fragments must be attached before creating the component.");
+        Preconditions.checkState(this.fragment.getHost() instanceof GeneratedComponentManager, "Hilt Fragments must be attached to an @AndroidEntryPoint Activity. Found: %s", this.fragment.getHost().getClass());
+        validate(this.fragment);
+        return ((FragmentComponentBuilderEntryPoint) EntryPoints.get(this.fragment.getHost(), FragmentComponentBuilderEntryPoint.class)).fragmentComponentBuilder().fragment(this.fragment).build();
+    }
+
+    public static ContextWrapper createContextWrapper(Context context, K k4) {
+        return new ViewComponentManager.FragmentContextWrapper(context, k4);
+    }
+
+    public static final Context findActivity(Context context) {
+        while ((context instanceof ContextWrapper) && !(context instanceof Activity)) {
+            context = ((ContextWrapper) context).getBaseContext();
+        }
+        return context;
+    }
+
+    public static final void initializeArguments(K k4) {
+        Preconditions.checkNotNull(k4);
+        if (k4.getArguments() == null) {
+            k4.setArguments(new Bundle());
+        }
+    }
+
+    @Override // dagger.hilt.internal.GeneratedComponentManager
+    public Object generatedComponent() {
+        if (this.component == null) {
+            synchronized (this.componentLock) {
+                try {
+                    if (this.component == null) {
+                        this.component = createComponent();
+                    }
+                } finally {
+                }
+            }
+        }
+        return this.component;
+    }
+
+    public void validate(K k4) {
+    }
+
+    public static ContextWrapper createContextWrapper(LayoutInflater layoutInflater, K k4) {
+        return new ViewComponentManager.FragmentContextWrapper(layoutInflater, k4);
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedComponentBuilderEntryPoint.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.internal.managers;
+
+import dagger.hilt.EntryPoint;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.internal.managers.ActivityRetainedComponentManager;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.components.SingletonComponent;
+
+@EntryPoint
+@OriginatingElement(topLevelClass = ActivityRetainedComponentManager.class)
+@InstallIn({SingletonComponent.class})
+/* loaded from: classes3.dex */
+public interface HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedComponentBuilderEntryPoint extends ActivityRetainedComponentManager.ActivityRetainedComponentBuilderEntryPoint {
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedLifecycleEntryPoint.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.internal.managers;
+
+import dagger.hilt.EntryPoint;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.internal.managers.ActivityRetainedComponentManager;
+import dagger.hilt.codegen.OriginatingElement;
+
+@EntryPoint
+@OriginatingElement(topLevelClass = ActivityRetainedComponentManager.class)
+@InstallIn({ActivityRetainedComponent.class})
+/* loaded from: classes3.dex */
+public interface HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedLifecycleEntryPoint extends ActivityRetainedComponentManager.ActivityRetainedLifecycleEntryPoint {
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/HiltWrapper_ActivityRetainedComponentManager_LifecycleModule.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.internal.managers;
+
+import dagger.Module;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.internal.managers.ActivityRetainedComponentManager;
+import dagger.hilt.codegen.OriginatingElement;
+
+@OriginatingElement(topLevelClass = ActivityRetainedComponentManager.class)
+@Module(includes = {ActivityRetainedComponentManager.LifecycleModule.class})
+@InstallIn({ActivityRetainedComponent.class})
+/* loaded from: classes3.dex */
+public final class HiltWrapper_ActivityRetainedComponentManager_LifecycleModule {
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/HiltWrapper_SavedStateHandleModule.java

@@ -0,0 +1,13 @@
+package dagger.hilt.android.internal.managers;
+
+import dagger.Module;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.codegen.OriginatingElement;
+
+@OriginatingElement(topLevelClass = SavedStateHandleModule.class)
+@Module(includes = {SavedStateHandleModule.class})
+@InstallIn({ActivityRetainedComponent.class})
+/* loaded from: classes3.dex */
+public final class HiltWrapper_SavedStateHandleModule {
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/SavedStateHandleHolder.java

@@ -0,0 +1,53 @@
+package dagger.hilt.android.internal.managers;
+
+import android.os.Bundle;
+import androidx.lifecycle.n0;
+import androidx.lifecycle.q0;
+import dagger.hilt.android.internal.ThreadUtil;
+import dagger.hilt.internal.Preconditions;
+import l0.c;
+import l0.d;
+
+/* loaded from: classes3.dex */
+public final class SavedStateHandleHolder {
+    private c extras;
+    private n0 handle;
+    private final boolean nonComponentActivity;
+
+    public SavedStateHandleHolder(c cVar) {
+        this.nonComponentActivity = cVar == null;
+        this.extras = cVar;
+    }
+
+    public void clear() {
+        this.extras = null;
+    }
+
+    public n0 getSavedStateHandle() {
+        ThreadUtil.ensureMainThread();
+        Preconditions.checkState(!this.nonComponentActivity, "Activity that does not extend ComponentActivity cannot use SavedStateHandle", new Object[0]);
+        n0 n0Var = this.handle;
+        if (n0Var != null) {
+            return n0Var;
+        }
+        Preconditions.checkNotNull(this.extras, "The first access to SavedStateHandle should happen between super.onCreate() and super.onDestroy()");
+        d dVar = new d(this.extras);
+        dVar.b(q0.f3419c, Bundle.EMPTY);
+        this.extras = dVar;
+        n0 e4 = q0.e(dVar);
+        this.handle = e4;
+        this.extras = null;
+        return e4;
+    }
+
+    public boolean isInvalid() {
+        return this.handle == null && this.extras == null;
+    }
+
+    public void setExtras(c cVar) {
+        if (this.handle != null) {
+            return;
+        }
+        this.extras = cVar;
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/SavedStateHandleModule.java

@@ -0,0 +1,21 @@
+package dagger.hilt.android.internal.managers;
+
+import androidx.lifecycle.n0;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.lifecycle.ActivityRetainedSavedState;
+import dagger.hilt.android.scopes.ActivityRetainedScoped;
+
+@Module
+@InstallIn({ActivityRetainedComponent.class})
+/* loaded from: classes3.dex */
+abstract class SavedStateHandleModule {
+    @Provides
+    @ActivityRetainedScoped
+    @ActivityRetainedSavedState
+    public static n0 provideSavedStateHandle(SavedStateHandleHolder savedStateHandleHolder) {
+        return savedStateHandleHolder.getSavedStateHandle();
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/SavedStateHandleModule_ProvideSavedStateHandleFactory.java

@@ -0,0 +1,34 @@
+package dagger.hilt.android.internal.managers;
+
+import androidx.lifecycle.n0;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("dagger.hilt.android.scopes.ActivityRetainedScoped")
+@DaggerGenerated
+@QualifierMetadata({"dagger.hilt.android.lifecycle.ActivityRetainedSavedState"})
+/* loaded from: classes3.dex */
+public final class SavedStateHandleModule_ProvideSavedStateHandleFactory implements Factory<n0> {
+    private final Provider<SavedStateHandleHolder> savedStateHandleHolderProvider;
+
+    public SavedStateHandleModule_ProvideSavedStateHandleFactory(Provider<SavedStateHandleHolder> provider) {
+        this.savedStateHandleHolderProvider = provider;
+    }
+
+    public static SavedStateHandleModule_ProvideSavedStateHandleFactory create(Provider<SavedStateHandleHolder> provider) {
+        return new SavedStateHandleModule_ProvideSavedStateHandleFactory(provider);
+    }
+
+    public static n0 provideSavedStateHandle(SavedStateHandleHolder savedStateHandleHolder) {
+        return (n0) Preconditions.checkNotNullFromProvides(SavedStateHandleModule.provideSavedStateHandle(savedStateHandleHolder));
+    }
+
+    @Override // javax.inject.Provider
+    public n0 get() {
+        return provideSavedStateHandle(this.savedStateHandleHolderProvider.get());
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/ServiceComponentManager.java

@@ -0,0 +1,42 @@
+package dagger.hilt.android.internal.managers;
+
+import android.app.Application;
+import android.app.Service;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.internal.builders.ServiceComponentBuilder;
+import dagger.hilt.components.SingletonComponent;
+import dagger.hilt.internal.GeneratedComponentManager;
+import dagger.hilt.internal.Preconditions;
+
+/* loaded from: classes3.dex */
+public final class ServiceComponentManager implements GeneratedComponentManager<Object> {
+    private Object component;
+    private final Service service;
+
+    @EntryPoint
+    @InstallIn({SingletonComponent.class})
+    /* loaded from: classes3.dex */
+    public interface ServiceComponentBuilderEntryPoint {
+        ServiceComponentBuilder serviceComponentBuilder();
+    }
+
+    public ServiceComponentManager(Service service) {
+        this.service = service;
+    }
+
+    private Object createComponent() {
+        Application application = this.service.getApplication();
+        Preconditions.checkState(application instanceof GeneratedComponentManager, "Hilt service must be attached to an @HiltAndroidApp Application. Found: %s", application.getClass());
+        return ((ServiceComponentBuilderEntryPoint) EntryPoints.get(application, ServiceComponentBuilderEntryPoint.class)).serviceComponentBuilder().service(this.service).build();
+    }
+
+    @Override // dagger.hilt.internal.GeneratedComponentManager
+    public Object generatedComponent() {
+        if (this.component == null) {
+            this.component = createComponent();
+        }
+        return this.component;
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/managers/ViewComponentManager.java

@@ -0,0 +1,174 @@
+package dagger.hilt.android.internal.managers;
+
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.view.LayoutInflater;
+import android.view.View;
+import androidx.fragment.app.K;
+import androidx.lifecycle.A;
+import androidx.lifecycle.H;
+import androidx.lifecycle.J;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.components.FragmentComponent;
+import dagger.hilt.android.internal.Contexts;
+import dagger.hilt.android.internal.builders.ViewComponentBuilder;
+import dagger.hilt.android.internal.builders.ViewWithFragmentComponentBuilder;
+import dagger.hilt.internal.GeneratedComponentManager;
+import dagger.hilt.internal.Preconditions;
+
+/* loaded from: classes3.dex */
+public final class ViewComponentManager implements GeneratedComponentManager<Object> {
+    private volatile Object component;
+    private final Object componentLock = new Object();
+    private final boolean hasFragmentBindings;
+    private final View view;
+
+    @EntryPoint
+    @InstallIn({ActivityComponent.class})
+    /* loaded from: classes3.dex */
+    public interface ViewComponentBuilderEntryPoint {
+        ViewComponentBuilder viewComponentBuilder();
+    }
+
+    @EntryPoint
+    @InstallIn({FragmentComponent.class})
+    /* loaded from: classes3.dex */
+    public interface ViewWithFragmentComponentBuilderEntryPoint {
+        ViewWithFragmentComponentBuilder viewWithFragmentComponentBuilder();
+    }
+
+    public ViewComponentManager(View view, boolean z3) {
+        this.view = view;
+        this.hasFragmentBindings = z3;
+    }
+
+    private Object createComponent() {
+        GeneratedComponentManager<?> parentComponentManager = getParentComponentManager(false);
+        return this.hasFragmentBindings ? ((ViewWithFragmentComponentBuilderEntryPoint) EntryPoints.get(parentComponentManager, ViewWithFragmentComponentBuilderEntryPoint.class)).viewWithFragmentComponentBuilder().view(this.view).build() : ((ViewComponentBuilderEntryPoint) EntryPoints.get(parentComponentManager, ViewComponentBuilderEntryPoint.class)).viewComponentBuilder().view(this.view).build();
+    }
+
+    private GeneratedComponentManager<?> getParentComponentManager(boolean z3) {
+        if (this.hasFragmentBindings) {
+            Context parentContext = getParentContext(FragmentContextWrapper.class, z3);
+            if (parentContext instanceof FragmentContextWrapper) {
+                return (GeneratedComponentManager) ((FragmentContextWrapper) parentContext).getFragment();
+            }
+            if (z3) {
+                return null;
+            }
+            Preconditions.checkState(!(r5 instanceof GeneratedComponentManager), "%s, @WithFragmentBindings Hilt view must be attached to an @AndroidEntryPoint Fragment. Was attached to context %s", this.view.getClass(), getParentContext(GeneratedComponentManager.class, z3).getClass().getName());
+        } else {
+            Object parentContext2 = getParentContext(GeneratedComponentManager.class, z3);
+            if (parentContext2 instanceof GeneratedComponentManager) {
+                return (GeneratedComponentManager) parentContext2;
+            }
+            if (z3) {
+                return null;
+            }
+        }
+        throw new IllegalStateException(this.view.getClass() + ", Hilt view must be attached to an @AndroidEntryPoint Fragment or Activity.");
+    }
+
+    private Context getParentContext(Class<?> cls, boolean z3) {
+        Context unwrap = unwrap(this.view.getContext(), cls);
+        if (unwrap != Contexts.getApplication(unwrap.getApplicationContext())) {
+            return unwrap;
+        }
+        Preconditions.checkState(z3, "%s, Hilt view cannot be created using the application context. Use a Hilt Fragment or Activity context.", this.view.getClass());
+        return null;
+    }
+
+    private static Context unwrap(Context context, Class<?> cls) {
+        while ((context instanceof ContextWrapper) && !cls.isInstance(context)) {
+            context = ((ContextWrapper) context).getBaseContext();
+        }
+        return context;
+    }
+
+    @Override // dagger.hilt.internal.GeneratedComponentManager
+    public Object generatedComponent() {
+        if (this.component == null) {
+            synchronized (this.componentLock) {
+                try {
+                    if (this.component == null) {
+                        this.component = createComponent();
+                    }
+                } finally {
+                }
+            }
+        }
+        return this.component;
+    }
+
+    public GeneratedComponentManager<?> maybeGetParentComponentManager() {
+        return getParentComponentManager(true);
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class FragmentContextWrapper extends ContextWrapper {
+        private LayoutInflater baseInflater;
+        private K fragment;
+        private final H fragmentLifecycleObserver;
+        private LayoutInflater inflater;
+
+        public FragmentContextWrapper(Context context, K k4) {
+            super((Context) Preconditions.checkNotNull(context));
+            H h = new H() { // from class: dagger.hilt.android.internal.managers.ViewComponentManager.FragmentContextWrapper.1
+                @Override // androidx.lifecycle.H
+                public void onStateChanged(J j4, A a2) {
+                    if (a2 == A.ON_DESTROY) {
+                        FragmentContextWrapper.this.fragment = null;
+                        FragmentContextWrapper.this.baseInflater = null;
+                        FragmentContextWrapper.this.inflater = null;
+                    }
+                }
+            };
+            this.fragmentLifecycleObserver = h;
+            this.baseInflater = null;
+            K k5 = (K) Preconditions.checkNotNull(k4);
+            this.fragment = k5;
+            k5.getLifecycle().a(h);
+        }
+
+        public K getFragment() {
+            Preconditions.checkNotNull(this.fragment, "The fragment has already been destroyed.");
+            return this.fragment;
+        }
+
+        @Override // android.content.ContextWrapper, android.content.Context
+        public Object getSystemService(String str) {
+            if (!"layout_inflater".equals(str)) {
+                return getBaseContext().getSystemService(str);
+            }
+            if (this.inflater == null) {
+                if (this.baseInflater == null) {
+                    this.baseInflater = (LayoutInflater) getBaseContext().getSystemService("layout_inflater");
+                }
+                this.inflater = this.baseInflater.cloneInContext(this);
+            }
+            return this.inflater;
+        }
+
+        public FragmentContextWrapper(LayoutInflater layoutInflater, K k4) {
+            super((Context) Preconditions.checkNotNull(((LayoutInflater) Preconditions.checkNotNull(layoutInflater)).getContext()));
+            H h = new H() { // from class: dagger.hilt.android.internal.managers.ViewComponentManager.FragmentContextWrapper.1
+                @Override // androidx.lifecycle.H
+                public void onStateChanged(J j4, A a2) {
+                    if (a2 == A.ON_DESTROY) {
+                        FragmentContextWrapper.this.fragment = null;
+                        FragmentContextWrapper.this.baseInflater = null;
+                        FragmentContextWrapper.this.inflater = null;
+                    }
+                }
+            };
+            this.fragmentLifecycleObserver = h;
+            this.baseInflater = layoutInflater;
+            K k5 = (K) Preconditions.checkNotNull(k4);
+            this.fragment = k5;
+            k5.getLifecycle().a(h);
+        }
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/migration/HasCustomInject.java

@@ -0,0 +1,6 @@
+package dagger.hilt.android.internal.migration;
+
+/* loaded from: classes3.dex */
+public interface HasCustomInject {
+    void customInject();
+}

apk_decompiled/sources/dagger/hilt/android/internal/migration/InjectedByHilt.java

@@ -0,0 +1,6 @@
+package dagger.hilt.android.internal.migration;
+
+/* loaded from: classes3.dex */
+public interface InjectedByHilt {
+    boolean wasInjectedByHilt();
+}

apk_decompiled/sources/dagger/hilt/android/internal/modules/ActivityModule.java

@@ -0,0 +1,34 @@
+package dagger.hilt.android.internal.modules;
+
+import android.app.Activity;
+import android.content.Context;
+import androidx.fragment.app.P;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.Reusable;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.qualifiers.ActivityContext;
+
+@Module
+@InstallIn({ActivityComponent.class})
+/* loaded from: classes3.dex */
+abstract class ActivityModule {
+    private ActivityModule() {
+    }
+
+    @Provides
+    @Reusable
+    public static P provideFragmentActivity(Activity activity) {
+        try {
+            return (P) activity;
+        } catch (ClassCastException e4) {
+            throw new IllegalStateException("Expected activity to be a FragmentActivity: " + activity, e4);
+        }
+    }
+
+    @Binds
+    @ActivityContext
+    public abstract Context provideContext(Activity activity);
+}

apk_decompiled/sources/dagger/hilt/android/internal/modules/ActivityModule_ProvideFragmentActivityFactory.java

@@ -0,0 +1,35 @@
+package dagger.hilt.android.internal.modules;
+
+import android.app.Activity;
+import androidx.fragment.app.P;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("dagger.Reusable")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes3.dex */
+public final class ActivityModule_ProvideFragmentActivityFactory implements Factory<P> {
+    private final Provider<Activity> activityProvider;
+
+    public ActivityModule_ProvideFragmentActivityFactory(Provider<Activity> provider) {
+        this.activityProvider = provider;
+    }
+
+    public static ActivityModule_ProvideFragmentActivityFactory create(Provider<Activity> provider) {
+        return new ActivityModule_ProvideFragmentActivityFactory(provider);
+    }
+
+    public static P provideFragmentActivity(Activity activity) {
+        return (P) Preconditions.checkNotNullFromProvides(ActivityModule.provideFragmentActivity(activity));
+    }
+
+    @Override // javax.inject.Provider
+    public P get() {
+        return provideFragmentActivity(this.activityProvider.get());
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/modules/ApplicationContextModule.java

@@ -0,0 +1,32 @@
+package dagger.hilt.android.internal.modules;
+
+import android.app.Application;
+import android.content.Context;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.internal.Contexts;
+import dagger.hilt.android.qualifiers.ApplicationContext;
+import dagger.hilt.components.SingletonComponent;
+
+@Module
+@InstallIn({SingletonComponent.class})
+/* loaded from: classes3.dex */
+public final class ApplicationContextModule {
+    private final Context applicationContext;
+
+    public ApplicationContextModule(Context context) {
+        this.applicationContext = context;
+    }
+
+    @Provides
+    public Application provideApplication() {
+        return Contexts.getApplication(this.applicationContext);
+    }
+
+    @Provides
+    @ApplicationContext
+    public Context provideContext() {
+        return this.applicationContext;
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/modules/ApplicationContextModule_ProvideApplicationFactory.java

@@ -0,0 +1,33 @@
+package dagger.hilt.android.internal.modules;
+
+import android.app.Application;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes3.dex */
+public final class ApplicationContextModule_ProvideApplicationFactory implements Factory<Application> {
+    private final ApplicationContextModule module;
+
+    public ApplicationContextModule_ProvideApplicationFactory(ApplicationContextModule applicationContextModule) {
+        this.module = applicationContextModule;
+    }
+
+    public static ApplicationContextModule_ProvideApplicationFactory create(ApplicationContextModule applicationContextModule) {
+        return new ApplicationContextModule_ProvideApplicationFactory(applicationContextModule);
+    }
+
+    public static Application provideApplication(ApplicationContextModule applicationContextModule) {
+        return (Application) Preconditions.checkNotNullFromProvides(applicationContextModule.provideApplication());
+    }
+
+    @Override // javax.inject.Provider
+    public Application get() {
+        return provideApplication(this.module);
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/modules/ApplicationContextModule_ProvideContextFactory.java

@@ -0,0 +1,33 @@
+package dagger.hilt.android.internal.modules;
+
+import android.content.Context;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata({"dagger.hilt.android.qualifiers.ApplicationContext"})
+/* loaded from: classes3.dex */
+public final class ApplicationContextModule_ProvideContextFactory implements Factory<Context> {
+    private final ApplicationContextModule module;
+
+    public ApplicationContextModule_ProvideContextFactory(ApplicationContextModule applicationContextModule) {
+        this.module = applicationContextModule;
+    }
+
+    public static ApplicationContextModule_ProvideContextFactory create(ApplicationContextModule applicationContextModule) {
+        return new ApplicationContextModule_ProvideContextFactory(applicationContextModule);
+    }
+
+    public static Context provideContext(ApplicationContextModule applicationContextModule) {
+        return (Context) Preconditions.checkNotNullFromProvides(applicationContextModule.provideContext());
+    }
+
+    @Override // javax.inject.Provider
+    public Context get() {
+        return provideContext(this.module);
+    }
+}

apk_decompiled/sources/dagger/hilt/android/internal/modules/HiltWrapper_ActivityModule.java

@@ -0,0 +1,13 @@
+package dagger.hilt.android.internal.modules;
+
+import dagger.Module;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.codegen.OriginatingElement;
+
+@OriginatingElement(topLevelClass = ActivityModule.class)
+@Module(includes = {ActivityModule.class})
+@InstallIn({ActivityComponent.class})
+/* loaded from: classes3.dex */
+public final class HiltWrapper_ActivityModule {
+}