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/com/google/firebase/components/OptionalProvider.java

@@ -0,0 +1,85 @@
+package com.google.firebase.components;
+
+import com.google.firebase.inject.Deferred;
+import com.google.firebase.inject.Provider;
+
+/* loaded from: classes3.dex */
+public class OptionalProvider<T> implements Provider<T>, Deferred<T> {
+    private volatile Provider<T> delegate;
+    private Deferred.DeferredHandler<T> handler;
+    private static final Deferred.DeferredHandler<Object> NOOP_HANDLER = new Object();
+    private static final Provider<Object> EMPTY_PROVIDER = new g(0);
+
+    private OptionalProvider(Deferred.DeferredHandler<T> deferredHandler, Provider<T> provider) {
+        this.handler = deferredHandler;
+        this.delegate = provider;
+    }
+
+    public static <T> OptionalProvider<T> empty() {
+        return new OptionalProvider<>(NOOP_HANDLER, EMPTY_PROVIDER);
+    }
+
+    public static /* synthetic */ void lambda$static$0(Provider provider) {
+    }
+
+    public static /* synthetic */ Object lambda$static$1() {
+        return null;
+    }
+
+    public static /* synthetic */ void lambda$whenAvailable$2(Deferred.DeferredHandler deferredHandler, Deferred.DeferredHandler deferredHandler2, Provider provider) {
+        deferredHandler.handle(provider);
+        deferredHandler2.handle(provider);
+    }
+
+    public static <T> OptionalProvider<T> of(Provider<T> provider) {
+        return new OptionalProvider<>(null, provider);
+    }
+
+    @Override // com.google.firebase.inject.Provider
+    public T get() {
+        return this.delegate.get();
+    }
+
+    public void set(Provider<T> provider) {
+        Deferred.DeferredHandler<T> deferredHandler;
+        if (this.delegate != EMPTY_PROVIDER) {
+            throw new IllegalStateException("provide() can be called only once.");
+        }
+        synchronized (this) {
+            deferredHandler = this.handler;
+            this.handler = null;
+            this.delegate = provider;
+        }
+        deferredHandler.handle(provider);
+    }
+
+    @Override // com.google.firebase.inject.Deferred
+    public void whenAvailable(final Deferred.DeferredHandler<T> deferredHandler) {
+        Provider<T> provider;
+        Provider<T> provider2;
+        Provider<T> provider3 = this.delegate;
+        Provider<Object> provider4 = EMPTY_PROVIDER;
+        if (provider3 != provider4) {
+            deferredHandler.handle(provider3);
+            return;
+        }
+        synchronized (this) {
+            provider = this.delegate;
+            if (provider != provider4) {
+                provider2 = provider;
+            } else {
+                final Deferred.DeferredHandler<T> deferredHandler2 = this.handler;
+                this.handler = new Deferred.DeferredHandler() { // from class: com.google.firebase.components.h
+                    @Override // com.google.firebase.inject.Deferred.DeferredHandler
+                    public final void handle(Provider provider5) {
+                        OptionalProvider.lambda$whenAvailable$2(Deferred.DeferredHandler.this, deferredHandler, provider5);
+                    }
+                };
+                provider2 = null;
+            }
+        }
+        if (provider2 != null) {
+            deferredHandler.handle(provider);
+        }
+    }
+}