Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

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 {
+}