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/Binds.java

@@ -0,0 +1,14 @@
+package dagger;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Binds {
+}

apk_decompiled/sources/dagger/BindsInstance.java

@@ -0,0 +1,14 @@
+package dagger;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD, ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface BindsInstance {
+}

apk_decompiled/sources/dagger/BindsOptionalOf.java

@@ -0,0 +1,14 @@
+package dagger;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface BindsOptionalOf {
+}

apk_decompiled/sources/dagger/Component.java

@@ -0,0 +1,32 @@
+package dagger;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Component {
+
+    @Target({ElementType.TYPE})
+    @Documented
+    @Retention(RetentionPolicy.RUNTIME)
+    /* loaded from: classes3.dex */
+    public @interface Builder {
+    }
+
+    @Target({ElementType.TYPE})
+    @Documented
+    @Retention(RetentionPolicy.RUNTIME)
+    /* loaded from: classes3.dex */
+    public @interface Factory {
+    }
+
+    Class<?>[] dependencies() default {};
+
+    Class<?>[] modules() default {};
+}

apk_decompiled/sources/dagger/Lazy.java

@@ -0,0 +1,6 @@
+package dagger;
+
+/* loaded from: classes3.dex */
+public interface Lazy<T> {
+    T get();
+}

apk_decompiled/sources/dagger/MapKey.java

@@ -0,0 +1,15 @@
+package dagger;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.ANNOTATION_TYPE})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface MapKey {
+    boolean unwrapValue() default true;
+}

apk_decompiled/sources/dagger/MembersInjector.java

@@ -0,0 +1,6 @@
+package dagger;
+
+/* loaded from: classes3.dex */
+public interface MembersInjector<T> {
+    void injectMembers(T t2);
+}

apk_decompiled/sources/dagger/Module.java

@@ -0,0 +1,17 @@
+package dagger;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Module {
+    Class<?>[] includes() default {};
+
+    Class<?>[] subcomponents() default {};
+}

apk_decompiled/sources/dagger/Provides.java

@@ -0,0 +1,14 @@
+package dagger;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Provides {
+}

apk_decompiled/sources/dagger/Reusable.java

@@ -0,0 +1,13 @@
+package dagger;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import javax.inject.Scope;
+
+@Scope
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Reusable {
+}

apk_decompiled/sources/dagger/Subcomponent.java

@@ -0,0 +1,30 @@
+package dagger;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Subcomponent {
+
+    @Target({ElementType.TYPE})
+    @Documented
+    @Retention(RetentionPolicy.RUNTIME)
+    /* loaded from: classes3.dex */
+    public @interface Builder {
+    }
+
+    @Target({ElementType.TYPE})
+    @Documented
+    @Retention(RetentionPolicy.RUNTIME)
+    /* loaded from: classes3.dex */
+    public @interface Factory {
+    }
+
+    Class<?>[] modules() default {};
+}

apk_decompiled/sources/dagger/assisted/Assisted.java

@@ -0,0 +1,15 @@
+package dagger.assisted;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Assisted {
+    String value() default "";
+}

apk_decompiled/sources/dagger/assisted/AssistedFactory.java

@@ -0,0 +1,14 @@
+package dagger.assisted;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface AssistedFactory {
+}

apk_decompiled/sources/dagger/assisted/AssistedInject.java

@@ -0,0 +1,14 @@
+package dagger.assisted;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.CONSTRUCTOR})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface AssistedInject {
+}

apk_decompiled/sources/dagger/hilt/DefineComponent.java

@@ -0,0 +1,23 @@
+package dagger.hilt;
+
+import dagger.hilt.internal.definecomponent.DefineComponentNoParent;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@GeneratesRootInput
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface DefineComponent {
+
+    @Target({ElementType.TYPE})
+    @GeneratesRootInput
+    @Retention(RetentionPolicy.CLASS)
+    /* loaded from: classes3.dex */
+    public @interface Builder {
+    }
+
+    Class<?> parent() default DefineComponentNoParent.class;
+}

apk_decompiled/sources/dagger/hilt/EntryPoint.java

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

apk_decompiled/sources/dagger/hilt/EntryPoints.java

@@ -0,0 +1,37 @@
+package dagger.hilt;
+
+import dagger.hilt.internal.GeneratedComponent;
+import dagger.hilt.internal.GeneratedComponentManager;
+import dagger.hilt.internal.Preconditions;
+import dagger.hilt.internal.TestSingletonComponent;
+import java.lang.annotation.Annotation;
+
+/* loaded from: classes3.dex */
+public final class EntryPoints {
+    private static final String EARLY_ENTRY_POINT = "dagger.hilt.android.EarlyEntryPoint";
+
+    private EntryPoints() {
+    }
+
+    public static <T> T get(Object obj, Class<T> cls) {
+        if (obj instanceof GeneratedComponent) {
+            if (obj instanceof TestSingletonComponent) {
+                Preconditions.checkState(!hasAnnotationReflection(cls, EARLY_ENTRY_POINT), "Interface, %s, annotated with @EarlyEntryPoint should be called with EarlyEntryPoints.get() rather than EntryPoints.get()", cls.getCanonicalName());
+            }
+            return cls.cast(obj);
+        }
+        if (obj instanceof GeneratedComponentManager) {
+            return (T) get(((GeneratedComponentManager) obj).generatedComponent(), cls);
+        }
+        throw new IllegalStateException("Given component holder " + obj.getClass() + " does not implement " + GeneratedComponent.class + " or " + GeneratedComponentManager.class);
+    }
+
+    private static boolean hasAnnotationReflection(Class<?> cls, String str) {
+        for (Annotation annotation : cls.getAnnotations()) {
+            if (annotation.annotationType().getCanonicalName().contentEquals(str)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

apk_decompiled/sources/dagger/hilt/GeneratesRootInput.java

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

apk_decompiled/sources/dagger/hilt/InstallIn.java

@@ -0,0 +1,14 @@
+package dagger.hilt;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@GeneratesRootInput
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface InstallIn {
+    Class<?>[] value();
+}

apk_decompiled/sources/dagger/hilt/android/ActivityRetainedLifecycle.java

@@ -0,0 +1,11 @@
+package dagger.hilt.android;
+
+import dagger.hilt.android.lifecycle.RetainedLifecycle;
+
+/* loaded from: classes3.dex */
+public interface ActivityRetainedLifecycle extends RetainedLifecycle {
+
+    /* loaded from: classes3.dex */
+    public interface OnClearedListener extends RetainedLifecycle.OnClearedListener {
+    }
+}

apk_decompiled/sources/dagger/hilt/android/AndroidEntryPoint.java

@@ -0,0 +1,12 @@
+package dagger.hilt.android;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@GeneratesRootInput
+/* loaded from: classes3.dex */
+public @interface AndroidEntryPoint {
+    Class<?> value() default Void.class;
+}

apk_decompiled/sources/dagger/hilt/android/EarlyEntryPoint.java

@@ -0,0 +1,12 @@
+package dagger.hilt.android;
+
+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.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface EarlyEntryPoint {
+}

apk_decompiled/sources/dagger/hilt/android/EarlyEntryPoints.java

@@ -0,0 +1,37 @@
+package dagger.hilt.android;
+
+import android.content.ComponentCallbacks2;
+import android.content.Context;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.android.internal.Contexts;
+import dagger.hilt.internal.GeneratedComponentManager;
+import dagger.hilt.internal.GeneratedComponentManagerHolder;
+import dagger.hilt.internal.Preconditions;
+import dagger.hilt.internal.TestSingletonComponentManager;
+import java.lang.annotation.Annotation;
+
+/* loaded from: classes3.dex */
+public final class EarlyEntryPoints {
+    private EarlyEntryPoints() {
+    }
+
+    public static <T> T get(Context context, Class<T> cls) {
+        ComponentCallbacks2 application = Contexts.getApplication(context);
+        Preconditions.checkState(application instanceof GeneratedComponentManagerHolder, "Expected application to implement GeneratedComponentManagerHolder. Check that you're passing in an application context that uses Hilt. Application class found: %s", application.getClass());
+        GeneratedComponentManager<?> componentManager = ((GeneratedComponentManagerHolder) application).componentManager();
+        if (!(componentManager instanceof TestSingletonComponentManager)) {
+            return (T) EntryPoints.get(application, cls);
+        }
+        Preconditions.checkState(hasAnnotationReflection(cls, EarlyEntryPoint.class), "%s should be called with EntryPoints.get() rather than EarlyEntryPoints.get()", cls.getCanonicalName());
+        return cls.cast(((TestSingletonComponentManager) componentManager).earlySingletonComponent());
+    }
+
+    private static boolean hasAnnotationReflection(Class<?> cls, Class<? extends Annotation> cls2) {
+        for (Annotation annotation : cls.getAnnotations()) {
+            if (annotation.annotationType().equals(cls2)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

apk_decompiled/sources/dagger/hilt/android/EntryPointAccessors.java

@@ -0,0 +1,72 @@
+package dagger.hilt.android;
+
+import android.app.Activity;
+import android.content.Context;
+import android.view.View;
+import androidx.fragment.app.K;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.android.internal.Contexts;
+import kotlin.Metadata;
+import kotlin.jvm.JvmStatic;
+import kotlin.jvm.internal.Intrinsics;
+
+@Metadata(d1 = {"\u00002\n\u0002\u0018\u0002\n\u0002\u0010\u0000\n\u0002\b\u0003\n\u0002\u0018\u0002\n\u0000\n\u0002\u0018\u0002\n\u0002\b\u0003\n\u0002\u0018\u0002\n\u0002\b\u0003\n\u0002\u0018\u0002\n\u0002\b\u0003\n\u0002\u0018\u0002\n\u0002\b\b\bÆ\u0002\u0018\u00002\u00020\u0001B\t\b\u0002¢\u0006\u0004\b\u0002\u0010\u0003J+\u0010\t\u001a\u00028\u0000\"\u0004\b\u0000\u0010\u00042\u0006\u0010\u0006\u001a\u00020\u00052\f\u0010\b\u001a\b\u0012\u0004\u0012\u00028\u00000\u0007H\u0007¢\u0006\u0004\b\t\u0010\nJ+\u0010\r\u001a\u00028\u0000\"\u0004\b\u0000\u0010\u00042\u0006\u0010\f\u001a\u00020\u000b2\f\u0010\b\u001a\b\u0012\u0004\u0012\u00028\u00000\u0007H\u0007¢\u0006\u0004\b\r\u0010\u000eJ+\u0010\u0011\u001a\u00028\u0000\"\u0004\b\u0000\u0010\u00042\u0006\u0010\u0010\u001a\u00020\u000f2\f\u0010\b\u001a\b\u0012\u0004\u0012\u00028\u00000\u0007H\u0007¢\u0006\u0004\b\u0011\u0010\u0012J+\u0010\u0015\u001a\u00028\u0000\"\u0004\b\u0000\u0010\u00042\u0006\u0010\u0014\u001a\u00020\u00132\f\u0010\b\u001a\b\u0012\u0004\u0012\u00028\u00000\u0007H\u0007¢\u0006\u0004\b\u0015\u0010\u0016J \u0010\t\u001a\u00028\u0000\"\u0006\b\u0000\u0010\u0004\u0018\u00012\u0006\u0010\u0006\u001a\u00020\u0005H\u0086\b¢\u0006\u0004\b\t\u0010\u0017J \u0010\r\u001a\u00028\u0000\"\u0006\b\u0000\u0010\u0004\u0018\u00012\u0006\u0010\f\u001a\u00020\u000bH\u0086\b¢\u0006\u0004\b\r\u0010\u0018J \u0010\u0011\u001a\u00028\u0000\"\u0006\b\u0000\u0010\u0004\u0018\u00012\u0006\u0010\u0010\u001a\u00020\u000fH\u0086\b¢\u0006\u0004\b\u0011\u0010\u0019J \u0010\u0015\u001a\u00028\u0000\"\u0006\b\u0000\u0010\u0004\u0018\u00012\u0006\u0010\u0014\u001a\u00020\u0013H\u0086\b¢\u0006\u0004\b\u0015\u0010\u001a¨\u0006\u001b"}, d2 = {"Ldagger/hilt/android/EntryPointAccessors;", "", "<init>", "()V", "T", "Landroid/content/Context;", "context", "Ljava/lang/Class;", "entryPoint", "fromApplication", "(Landroid/content/Context;Ljava/lang/Class;)Ljava/lang/Object;", "Landroid/app/Activity;", "activity", "fromActivity", "(Landroid/app/Activity;Ljava/lang/Class;)Ljava/lang/Object;", "Landroidx/fragment/app/K;", "fragment", "fromFragment", "(Landroidx/fragment/app/K;Ljava/lang/Class;)Ljava/lang/Object;", "Landroid/view/View;", "view", "fromView", "(Landroid/view/View;Ljava/lang/Class;)Ljava/lang/Object;", "(Landroid/content/Context;)Ljava/lang/Object;", "(Landroid/app/Activity;)Ljava/lang/Object;", "(Landroidx/fragment/app/K;)Ljava/lang/Object;", "(Landroid/view/View;)Ljava/lang/Object;", "java_dagger_hilt_android-entry_point_accessors_internal_kt"}, k = 1, mv = {1, 8, 0}, xi = 48)
+/* loaded from: classes3.dex */
+public final class EntryPointAccessors {
+    public static final EntryPointAccessors INSTANCE = new EntryPointAccessors();
+
+    private EntryPointAccessors() {
+    }
+
+    @JvmStatic
+    public static final <T> T fromActivity(Activity activity, Class<T> entryPoint) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        Intrinsics.checkNotNullParameter(entryPoint, "entryPoint");
+        return (T) EntryPoints.get(activity, entryPoint);
+    }
+
+    @JvmStatic
+    public static final <T> T fromApplication(Context context, Class<T> entryPoint) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(entryPoint, "entryPoint");
+        return (T) EntryPoints.get(Contexts.getApplication(context.getApplicationContext()), entryPoint);
+    }
+
+    @JvmStatic
+    public static final <T> T fromFragment(K fragment, Class<T> entryPoint) {
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        Intrinsics.checkNotNullParameter(entryPoint, "entryPoint");
+        return (T) EntryPoints.get(fragment, entryPoint);
+    }
+
+    @JvmStatic
+    public static final <T> T fromView(View view, Class<T> entryPoint) {
+        Intrinsics.checkNotNullParameter(view, "view");
+        Intrinsics.checkNotNullParameter(entryPoint, "entryPoint");
+        return (T) EntryPoints.get(view, entryPoint);
+    }
+
+    public final /* synthetic */ <T> T fromActivity(Activity activity) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        Intrinsics.reifiedOperationMarker(4, "T");
+        return (T) fromActivity(activity, Object.class);
+    }
+
+    public final /* synthetic */ <T> T fromApplication(Context context) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.reifiedOperationMarker(4, "T");
+        return (T) fromApplication(context, Object.class);
+    }
+
+    public final /* synthetic */ <T> T fromFragment(K fragment) {
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        Intrinsics.reifiedOperationMarker(4, "T");
+        return (T) fromFragment(fragment, Object.class);
+    }
+
+    public final /* synthetic */ <T> T fromView(View view) {
+        Intrinsics.checkNotNullParameter(view, "view");
+        Intrinsics.reifiedOperationMarker(4, "T");
+        return (T) fromView(view, Object.class);
+    }
+}

apk_decompiled/sources/dagger/hilt/android/HiltAndroidApp.java

@@ -0,0 +1,15 @@
+package dagger.hilt.android;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@GeneratesRootInput
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface HiltAndroidApp {
+    Class<?> value() default Void.class;
+}

apk_decompiled/sources/dagger/hilt/android/R.java

@@ -0,0 +1,7 @@
+package dagger.hilt.android;
+
+/* loaded from: classes3.dex */
+public final class R {
+    private R() {
+    }
+}

apk_decompiled/sources/dagger/hilt/android/UnstableApi.java

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

apk_decompiled/sources/dagger/hilt/android/ViewModelLifecycle.java

@@ -0,0 +1,7 @@
+package dagger.hilt.android;
+
+import dagger.hilt.android.lifecycle.RetainedLifecycle;
+
+/* loaded from: classes3.dex */
+public interface ViewModelLifecycle extends RetainedLifecycle {
+}

apk_decompiled/sources/dagger/hilt/android/WithFragmentBindings.java

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

apk_decompiled/sources/dagger/hilt/android/components/ActivityComponent.java

@@ -0,0 +1,10 @@
+package dagger.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.ActivityScoped;
+
+@ActivityScoped
+@DefineComponent(parent = ActivityRetainedComponent.class)
+/* loaded from: classes3.dex */
+public interface ActivityComponent {
+}

apk_decompiled/sources/dagger/hilt/android/components/ActivityRetainedComponent.java

@@ -0,0 +1,11 @@
+package dagger.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.ActivityRetainedScoped;
+import dagger.hilt.components.SingletonComponent;
+
+@ActivityRetainedScoped
+@DefineComponent(parent = SingletonComponent.class)
+/* loaded from: classes3.dex */
+public interface ActivityRetainedComponent {
+}

apk_decompiled/sources/dagger/hilt/android/components/FragmentComponent.java

@@ -0,0 +1,10 @@
+package dagger.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.FragmentScoped;
+
+@FragmentScoped
+@DefineComponent(parent = ActivityComponent.class)
+/* loaded from: classes3.dex */
+public interface FragmentComponent {
+}

apk_decompiled/sources/dagger/hilt/android/components/ServiceComponent.java

@@ -0,0 +1,11 @@
+package dagger.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.ServiceScoped;
+import dagger.hilt.components.SingletonComponent;
+
+@DefineComponent(parent = SingletonComponent.class)
+@ServiceScoped
+/* loaded from: classes3.dex */
+public interface ServiceComponent {
+}

apk_decompiled/sources/dagger/hilt/android/components/ViewComponent.java

@@ -0,0 +1,10 @@
+package dagger.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.ViewScoped;
+
+@ViewScoped
+@DefineComponent(parent = ActivityComponent.class)
+/* loaded from: classes3.dex */
+public interface ViewComponent {
+}

apk_decompiled/sources/dagger/hilt/android/components/ViewModelComponent.java

@@ -0,0 +1,10 @@
+package dagger.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.ViewModelScoped;
+
+@ViewModelScoped
+@DefineComponent(parent = ActivityRetainedComponent.class)
+/* loaded from: classes3.dex */
+public interface ViewModelComponent {
+}

apk_decompiled/sources/dagger/hilt/android/components/ViewWithFragmentComponent.java

@@ -0,0 +1,10 @@
+package dagger.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.ViewScoped;
+
+@ViewScoped
+@DefineComponent(parent = FragmentComponent.class)
+/* loaded from: classes3.dex */
+public interface ViewWithFragmentComponent {
+}

apk_decompiled/sources/dagger/hilt/android/flags/FragmentGetContextFix.java

@@ -0,0 +1,53 @@
+package dagger.hilt.android.flags;
+
+import android.content.Context;
+import dagger.Module;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.EntryPointAccessors;
+import dagger.hilt.components.SingletonComponent;
+import dagger.hilt.internal.Preconditions;
+import dagger.multibindings.Multibinds;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import java.util.Set;
+import javax.inject.Qualifier;
+
+/* loaded from: classes3.dex */
+public final class FragmentGetContextFix {
+
+    @Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD})
+    @Qualifier
+    /* loaded from: classes3.dex */
+    public @interface DisableFragmentGetContextFix {
+    }
+
+    @EntryPoint
+    @InstallIn({SingletonComponent.class})
+    /* loaded from: classes3.dex */
+    public interface FragmentGetContextFixEntryPoint {
+        @DisableFragmentGetContextFix
+        Set<Boolean> getDisableFragmentGetContextFix();
+    }
+
+    @Module
+    @InstallIn({SingletonComponent.class})
+    /* loaded from: classes3.dex */
+    public static abstract class FragmentGetContextFixModule {
+        @DisableFragmentGetContextFix
+        @Multibinds
+        public abstract Set<Boolean> disableFragmentGetContextFix();
+    }
+
+    private FragmentGetContextFix() {
+    }
+
+    public static boolean isFragmentGetContextFixDisabled(Context context) {
+        Set<Boolean> disableFragmentGetContextFix = ((FragmentGetContextFixEntryPoint) EntryPointAccessors.fromApplication(context, FragmentGetContextFixEntryPoint.class)).getDisableFragmentGetContextFix();
+        Preconditions.checkState(disableFragmentGetContextFix.size() <= 1, "Cannot bind the flag @DisableFragmentGetContextFix more than once.", new Object[0]);
+        if (disableFragmentGetContextFix.isEmpty()) {
+            return true;
+        }
+        return disableFragmentGetContextFix.iterator().next().booleanValue();
+    }
+}

apk_decompiled/sources/dagger/hilt/android/flags/HiltWrapper_FragmentGetContextFix_FragmentGetContextFixModule.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.flags;
+
+import dagger.Module;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.flags.FragmentGetContextFix;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.components.SingletonComponent;
+
+@OriginatingElement(topLevelClass = FragmentGetContextFix.class)
+@Module(includes = {FragmentGetContextFix.FragmentGetContextFixModule.class})
+@InstallIn({SingletonComponent.class})
+/* loaded from: classes3.dex */
+public final class HiltWrapper_FragmentGetContextFix_FragmentGetContextFixModule {
+}

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

apk_decompiled/sources/dagger/hilt/android/lifecycle/ActivityRetainedSavedState.java

@@ -0,0 +1,16 @@
+package dagger.hilt.android.lifecycle;
+
+import dagger.hilt.android.UnstableApi;
+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, ElementType.FIELD})
+@Qualifier
+@UnstableApi
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface ActivityRetainedSavedState {
+}

apk_decompiled/sources/dagger/hilt/android/lifecycle/HiltViewModel.java

@@ -0,0 +1,15 @@
+package dagger.hilt.android.lifecycle;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@GeneratesRootInput
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface HiltViewModel {
+    Class<?> assistedFactory() default Object.class;
+}

apk_decompiled/sources/dagger/hilt/android/lifecycle/HiltViewModelExtensions.java

@@ -0,0 +1,43 @@
+package dagger.hilt.android.lifecycle;
+
+import androidx.lifecycle.w0;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelFactory;
+import kotlin.Metadata;
+import kotlin.jvm.JvmName;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import l0.b;
+import l0.c;
+import l0.d;
+
+@Metadata(d1 = {"\u0000\u001a\n\u0000\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\b\u0003\n\u0002\u0018\u0002\n\u0002\b\u0003\u001a+\u0010\u0005\u001a\u00020\u0001\"\u0004\b\u0000\u0010\u0000*\u00020\u00012\u0012\u0010\u0004\u001a\u000e\u0012\u0004\u0012\u00028\u0000\u0012\u0004\u0012\u00020\u00030\u0002¢\u0006\u0004\b\u0005\u0010\u0006\u001a+\u0010\b\u001a\u00020\u0001\"\u0004\b\u0000\u0010\u0000*\u00020\u00072\u0012\u0010\u0004\u001a\u000e\u0012\u0004\u0012\u00028\u0000\u0012\u0004\u0012\u00020\u00030\u0002¢\u0006\u0004\b\b\u0010\t¨\u0006\n"}, d2 = {"VMF", "Ll0/c;", "Lkotlin/Function1;", "Landroidx/lifecycle/w0;", "callback", "withCreationCallback", "(Ll0/c;Lkotlin/jvm/functions/Function1;)Ll0/c;", "Ll0/d;", "addCreationCallback", "(Ll0/d;Lkotlin/jvm/functions/Function1;)Ll0/c;", "java_dagger_hilt_android_lifecycle-hilt_view_model_extensions_internal_kt"}, k = 2, mv = {1, 8, 0}, xi = 48)
+@JvmName(name = "HiltViewModelExtensions")
+/* loaded from: classes3.dex */
+public final class HiltViewModelExtensions {
+    public static final <VMF> c addCreationCallback(d dVar, final Function1<? super VMF, ? extends w0> callback) {
+        Intrinsics.checkNotNullParameter(dVar, "<this>");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        b CREATION_CALLBACK_KEY = HiltViewModelFactory.CREATION_CALLBACK_KEY;
+        Intrinsics.checkNotNullExpressionValue(CREATION_CALLBACK_KEY, "CREATION_CALLBACK_KEY");
+        dVar.b(CREATION_CALLBACK_KEY, new Function1<Object, w0>() { // from class: dagger.hilt.android.lifecycle.HiltViewModelExtensions$addCreationCallback$1$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            /* JADX WARN: Multi-variable type inference failed */
+            {
+                super(1);
+            }
+
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // kotlin.jvm.functions.Function1
+            public final w0 invoke(Object obj) {
+                return callback.invoke(obj);
+            }
+        });
+        return dVar;
+    }
+
+    public static final <VMF> c withCreationCallback(c cVar, Function1<? super VMF, ? extends w0> callback) {
+        Intrinsics.checkNotNullParameter(cVar, "<this>");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        return addCreationCallback(new d(cVar), callback);
+    }
+}

apk_decompiled/sources/dagger/hilt/android/lifecycle/RetainedLifecycle.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.lifecycle;
+
+/* loaded from: classes3.dex */
+public interface RetainedLifecycle {
+
+    /* loaded from: classes3.dex */
+    public interface OnClearedListener {
+        void onCleared();
+    }
+
+    void addOnClearedListener(OnClearedListener onClearedListener);
+
+    void removeOnClearedListener(OnClearedListener onClearedListener);
+}

apk_decompiled/sources/dagger/hilt/android/lifecycle/package-info.java

@@ -0,0 +1,2 @@
+package dagger.hilt.android.lifecycle;
+

apk_decompiled/sources/dagger/hilt/android/migration/CustomInject.java

@@ -0,0 +1,9 @@
+package dagger.hilt.android.migration;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+/* loaded from: classes3.dex */
+public @interface CustomInject {
+}

apk_decompiled/sources/dagger/hilt/android/migration/CustomInjection.java

@@ -0,0 +1,18 @@
+package dagger.hilt.android.migration;
+
+import android.app.Application;
+import dagger.hilt.android.internal.migration.HasCustomInject;
+import dagger.hilt.internal.Preconditions;
+
+/* loaded from: classes3.dex */
+public final class CustomInjection {
+    private CustomInjection() {
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public static void inject(Application application) {
+        Preconditions.checkNotNull(application);
+        Preconditions.checkArgument(application instanceof HasCustomInject, "'%s' is not a custom inject application. Check that you have annotated the application with both @HiltAndroidApp and @CustomInject.", application.getClass());
+        ((HasCustomInject) application).customInject();
+    }
+}

apk_decompiled/sources/dagger/hilt/android/migration/OptionalInject.java

@@ -0,0 +1,9 @@
+package dagger.hilt.android.migration;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+/* loaded from: classes3.dex */
+public @interface OptionalInject {
+}

apk_decompiled/sources/dagger/hilt/android/migration/OptionalInjectCheck.java

@@ -0,0 +1,41 @@
+package dagger.hilt.android.migration;
+
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.view.View;
+import androidx.fragment.app.K;
+import b.o;
+import dagger.hilt.android.internal.migration.InjectedByHilt;
+import dagger.hilt.internal.Preconditions;
+
+/* loaded from: classes3.dex */
+public final class OptionalInjectCheck {
+    private OptionalInjectCheck() {
+    }
+
+    private static boolean check(Object obj) {
+        Preconditions.checkNotNull(obj);
+        Preconditions.checkArgument(obj instanceof InjectedByHilt, "'%s' is not an optionally injected android entry point. Check that you have annotated the class with both @AndroidEntryPoint and @OptionalInject.", obj.getClass());
+        return ((InjectedByHilt) obj).wasInjectedByHilt();
+    }
+
+    public static boolean wasInjectedByHilt(o oVar) {
+        return check(oVar);
+    }
+
+    public static boolean wasInjectedByHilt(BroadcastReceiver broadcastReceiver) {
+        return check(broadcastReceiver);
+    }
+
+    public static boolean wasInjectedByHilt(K k4) {
+        return check(k4);
+    }
+
+    public static boolean wasInjectedByHilt(Service service) {
+        return check(service);
+    }
+
+    public static boolean wasInjectedByHilt(View view) {
+        return check(view);
+    }
+}

apk_decompiled/sources/dagger/hilt/android/migration/package-info.java

@@ -0,0 +1,2 @@
+package dagger.hilt.android.migration;
+

apk_decompiled/sources/dagger/hilt/android/package-info.java

@@ -0,0 +1,2 @@
+package dagger.hilt.android;
+

apk_decompiled/sources/dagger/hilt/android/qualifiers/ActivityContext.java

@@ -0,0 +1,14 @@
+package dagger.hilt.android.qualifiers;
+
+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, ElementType.FIELD})
+@Qualifier
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface ActivityContext {
+}

apk_decompiled/sources/dagger/hilt/android/qualifiers/ApplicationContext.java

@@ -0,0 +1,11 @@
+package dagger.hilt.android.qualifiers;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import javax.inject.Qualifier;
+
+@Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD})
+@Qualifier
+/* loaded from: classes3.dex */
+public @interface ApplicationContext {
+}

apk_decompiled/sources/dagger/hilt/android/scopes/ActivityRetainedScoped.java

@@ -0,0 +1,11 @@
+package dagger.hilt.android.scopes;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import javax.inject.Scope;
+
+@Scope
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface ActivityRetainedScoped {
+}

apk_decompiled/sources/dagger/hilt/android/scopes/ActivityScoped.java

@@ -0,0 +1,11 @@
+package dagger.hilt.android.scopes;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import javax.inject.Scope;
+
+@Scope
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface ActivityScoped {
+}

apk_decompiled/sources/dagger/hilt/android/scopes/FragmentScoped.java

@@ -0,0 +1,11 @@
+package dagger.hilt.android.scopes;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import javax.inject.Scope;
+
+@Scope
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface FragmentScoped {
+}

apk_decompiled/sources/dagger/hilt/android/scopes/ServiceScoped.java

@@ -0,0 +1,11 @@
+package dagger.hilt.android.scopes;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import javax.inject.Scope;
+
+@Scope
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface ServiceScoped {
+}