CrackMe.apk
Download file
package com.google.firebase.components;
import android.util.Log;
import com.google.firebase.dynamicloading.ComponentLoader;
import com.google.firebase.events.Publisher;
import com.google.firebase.events.Subscriber;
import com.google.firebase.inject.Deferred;
import com.google.firebase.inject.Provider;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicReference;
public class ComponentRuntime extends AbstractComponentContainer implements ComponentLoader {
private static final Provider<Set<Object>> EMPTY_PROVIDER = ComponentRuntime$$ExternalSyntheticLambda2.INSTANCE;
private final ComponentRegistrarProcessor componentRegistrarProcessor;
private final Map<Component<?>, Provider<?>> components;
private final AtomicReference<Boolean> eagerComponentsInitializedWith;
private final EventBus eventBus;
private final Map<Class<?>, Provider<?>> lazyInstanceMap;
private final Map<Class<?>, LazySet<?>> lazySetMap;
private final List<Provider<ComponentRegistrar>> unprocessedRegistrarProviders;
static /* synthetic */ ComponentRegistrar lambda$toProviders$1(ComponentRegistrar componentRegistrar) {
return componentRegistrar;
}
public /* bridge */ /* synthetic */ Object get(Class cls) {
return super.get(cls);
}
public /* bridge */ /* synthetic */ Set setOf(Class cls) {
return super.setOf(cls);
}
@Deprecated
public ComponentRuntime(Executor executor, Iterable<ComponentRegistrar> iterable, Component<?>... componentArr) {
this(executor, toProviders(iterable), Arrays.asList(componentArr), ComponentRegistrarProcessor.NOOP);
}
public static Builder builder(Executor executor) {
return new Builder(executor);
}
private ComponentRuntime(Executor executor, Iterable<Provider<ComponentRegistrar>> iterable, Collection<Component<?>> collection, ComponentRegistrarProcessor componentRegistrarProcessor2) {
this.components = new HashMap();
this.lazyInstanceMap = new HashMap();
this.lazySetMap = new HashMap();
this.eagerComponentsInitializedWith = new AtomicReference<>();
EventBus eventBus2 = new EventBus(executor);
this.eventBus = eventBus2;
this.componentRegistrarProcessor = componentRegistrarProcessor2;
ArrayList arrayList = new ArrayList();
arrayList.add(Component.of(eventBus2, EventBus.class, Subscriber.class, Publisher.class));
arrayList.add(Component.of(this, ComponentLoader.class, new Class[0]));
for (Component next : collection) {
if (next != null) {
arrayList.add(next);
}
}
this.unprocessedRegistrarProviders = iterableToList(iterable);
discoverComponents(arrayList);
}
private void discoverComponents(List<Component<?>> list) {
ArrayList<Runnable> arrayList = new ArrayList<>();
synchronized (this) {
Iterator<Provider<ComponentRegistrar>> it = this.unprocessedRegistrarProviders.iterator();
while (it.hasNext()) {
try {
ComponentRegistrar componentRegistrar = (ComponentRegistrar) it.next().get();
if (componentRegistrar != null) {
list.addAll(this.componentRegistrarProcessor.processRegistrar(componentRegistrar));
it.remove();
}
} catch (InvalidRegistrarException e) {
it.remove();
Log.w("ComponentDiscovery", "Invalid component registrar.", e);
}
}
if (this.components.isEmpty()) {
CycleDetector.detect(list);
} else {
ArrayList arrayList2 = new ArrayList(this.components.keySet());
arrayList2.addAll(list);
CycleDetector.detect(arrayList2);
}
for (Component next : list) {
this.components.put(next, new Lazy(new ComponentRuntime$$ExternalSyntheticLambda1(this, next)));
}
arrayList.addAll(processInstanceComponents(list));
arrayList.addAll(processSetComponents());
processDependencies();
}
for (Runnable run : arrayList) {
run.run();
}
maybeInitializeEagerComponents();
}
/* access modifiers changed from: package-private */
/* renamed from: lambda$discoverComponents$0$com-google-firebase-components-ComponentRuntime reason: not valid java name */
public /* synthetic */ Object m157lambda$discoverComponents$0$comgooglefirebasecomponentsComponentRuntime(Component component) {
return component.getFactory().create(new RestrictedComponentContainer(component, this));
}
private void maybeInitializeEagerComponents() {
Boolean bool = this.eagerComponentsInitializedWith.get();
if (bool != null) {
doInitializeEagerComponents(this.components, bool.booleanValue());
}
}
private static Iterable<Provider<ComponentRegistrar>> toProviders(Iterable<ComponentRegistrar> iterable) {
ArrayList arrayList = new ArrayList();
for (ComponentRegistrar componentRuntime$$ExternalSyntheticLambda0 : iterable) {
arrayList.add(new ComponentRuntime$$ExternalSyntheticLambda0(componentRuntime$$ExternalSyntheticLambda0));
}
return arrayList;
}
private static <T> List<T> iterableToList(Iterable<T> iterable) {
ArrayList arrayList = new ArrayList();
for (T add : iterable) {
arrayList.add(add);
}
return arrayList;
}
private List<Runnable> processInstanceComponents(List<Component<?>> list) {
ArrayList arrayList = new ArrayList();
for (Component next : list) {
if (next.isValue()) {
Provider provider = this.components.get(next);
for (Class cls : next.getProvidedInterfaces()) {
if (!this.lazyInstanceMap.containsKey(cls)) {
this.lazyInstanceMap.put(cls, provider);
} else {
arrayList.add(new ComponentRuntime$$ExternalSyntheticLambda4((OptionalProvider) this.lazyInstanceMap.get(cls), provider));
}
}
}
}
return arrayList;
}
private List<Runnable> processSetComponents() {
ArrayList arrayList = new ArrayList();
HashMap hashMap = new HashMap();
for (Map.Entry next : this.components.entrySet()) {
Component component = (Component) next.getKey();
if (!component.isValue()) {
Provider provider = (Provider) next.getValue();
for (Class cls : component.getProvidedInterfaces()) {
if (!hashMap.containsKey(cls)) {
hashMap.put(cls, new HashSet());
}
((Set) hashMap.get(cls)).add(provider);
}
}
}
for (Map.Entry entry : hashMap.entrySet()) {
if (!this.lazySetMap.containsKey(entry.getKey())) {
this.lazySetMap.put((Class) entry.getKey(), LazySet.fromCollection((Collection) entry.getValue()));
} else {
LazySet lazySet = this.lazySetMap.get(entry.getKey());
for (Provider componentRuntime$$ExternalSyntheticLambda3 : (Set) entry.getValue()) {
arrayList.add(new ComponentRuntime$$ExternalSyntheticLambda3(lazySet, componentRuntime$$ExternalSyntheticLambda3));
}
}
}
return arrayList;
}
public synchronized <T> Provider<T> getProvider(Class<T> cls) {
Preconditions.checkNotNull(cls, "Null interface requested.");
return this.lazyInstanceMap.get(cls);
}
public <T> Deferred<T> getDeferred(Class<T> cls) {
Provider<T> provider = getProvider(cls);
if (provider == null) {
return OptionalProvider.empty();
}
if (provider instanceof OptionalProvider) {
return (OptionalProvider) provider;
}
return OptionalProvider.of(provider);
}
public synchronized <T> Provider<Set<T>> setOfProvider(Class<T> cls) {
LazySet lazySet = this.lazySetMap.get(cls);
if (lazySet != null) {
return lazySet;
}
return EMPTY_PROVIDER;
}
public void initializeEagerComponents(boolean z) {
HashMap hashMap;
if (this.eagerComponentsInitializedWith.compareAndSet((Object) null, Boolean.valueOf(z))) {
synchronized (this) {
hashMap = new HashMap(this.components);
}
doInitializeEagerComponents(hashMap, z);
}
}
private void doInitializeEagerComponents(Map<Component<?>, Provider<?>> map, boolean z) {
for (Map.Entry next : map.entrySet()) {
Component component = (Component) next.getKey();
Provider provider = (Provider) next.getValue();
if (component.isAlwaysEager() || (component.isEagerInDefaultApp() && z)) {
provider.get();
}
}
this.eventBus.enablePublishingAndFlushPending();
}
public void discoverComponents() {
synchronized (this) {
if (!this.unprocessedRegistrarProviders.isEmpty()) {
discoverComponents(new ArrayList());
}
}
}
public void initializeAllComponentsForTests() {
for (Provider<?> provider : this.components.values()) {
provider.get();
}
}
private void processDependencies() {
for (Component next : this.components.keySet()) {
Iterator<Dependency> it = next.getDependencies().iterator();
while (true) {
if (it.hasNext()) {
Dependency next2 = it.next();
if (next2.isSet() && !this.lazySetMap.containsKey(next2.getInterface())) {
this.lazySetMap.put(next2.getInterface(), LazySet.fromCollection(Collections.emptySet()));
} else if (this.lazyInstanceMap.containsKey(next2.getInterface())) {
continue;
} else if (next2.isRequired()) {
throw new MissingDependencyException(String.format("Unsatisfied dependency for component %s: %s", new Object[]{next, next2.getInterface()}));
} else if (!next2.isSet()) {
this.lazyInstanceMap.put(next2.getInterface(), OptionalProvider.empty());
}
}
}
}
}
/* access modifiers changed from: package-private */
public Collection<Component<?>> getAllComponentsForTest() {
return this.components.keySet();
}
public static final class Builder {
private final List<Component<?>> additionalComponents = new ArrayList();
private ComponentRegistrarProcessor componentRegistrarProcessor = ComponentRegistrarProcessor.NOOP;
private final Executor defaultExecutor;
private final List<Provider<ComponentRegistrar>> lazyRegistrars = new ArrayList();
static /* synthetic */ ComponentRegistrar lambda$addComponentRegistrar$0(ComponentRegistrar componentRegistrar) {
return componentRegistrar;
}
Builder(Executor executor) {
this.defaultExecutor = executor;
}
public Builder addLazyComponentRegistrars(Collection<Provider<ComponentRegistrar>> collection) {
this.lazyRegistrars.addAll(collection);
return this;
}
public Builder addComponentRegistrar(ComponentRegistrar componentRegistrar) {
this.lazyRegistrars.add(new ComponentRuntime$Builder$$ExternalSyntheticLambda0(componentRegistrar));
return this;
}
public Builder addComponent(Component<?> component) {
this.additionalComponents.add(component);
return this;
}
public Builder setProcessor(ComponentRegistrarProcessor componentRegistrarProcessor2) {
this.componentRegistrarProcessor = componentRegistrarProcessor2;
return this;
}
public ComponentRuntime build() {
return new ComponentRuntime(this.defaultExecutor, this.lazyRegistrars, this.additionalComponents, this.componentRegistrarProcessor);
}
}
}
Download file