Add an extension point to ComponentRuntime.

firebase-components/src/main/java/com/google/firebase/components/Component.java

@@ -15,6 +15,8 @@
 package com.google.firebase.components;
 
 import androidx.annotation.IntDef;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.Arrays;
@@ -76,6 +78,7 @@ public final class Component<T> {
     int SET = 1;
   }
 
+  private final String name;
   private final Set<Class<? super T>> providedInterfaces;
   private final Set<Dependency> dependencies;
   private final @Instantiation int instantiation;
@@ -84,12 +87,14 @@ public final class Component<T> {
   private final Set<Class<?>> publishedEvents;
 
   private Component(
+      @Nullable String name,
       Set<Class<? super T>> providedInterfaces,
       Set<Dependency> dependencies,
       @Instantiation int instantiation,
       @ComponentType int type,
       ComponentFactory<T> factory,
       Set<Class<?>> publishedEvents) {
+    this.name = name;
     this.providedInterfaces = Collections.unmodifiableSet(providedInterfaces);
     this.dependencies = Collections.unmodifiableSet(dependencies);
     this.instantiation = instantiation;
@@ -98,6 +103,16 @@ private Component(
     this.publishedEvents = Collections.unmodifiableSet(publishedEvents);
   }
 
+  /**
+   * Optional name of the component.
+   *
+   * <p>Used for debug purposes only.
+   */
+  @Nullable
+  public String getName() {
+    return name;
+  }
+
   /**
    * Returns all interfaces this component provides.
    *
@@ -153,6 +168,12 @@ public boolean isValue() {
     return type == ComponentType.VALUE;
   }
 
+  /** Creates a copy of the component with {@link ComponentFactory} replaced. */
+  public Component<T> withFactory(ComponentFactory<T> factory) {
+    return new Component<>(
+        name, providedInterfaces, dependencies, instantiation, type, factory, publishedEvents);
+  }
+
   @Override
   public String toString() {
     StringBuilder sb =
@@ -219,6 +240,7 @@ public static <T> Component<T> intoSet(T value, Class<T> anInterface) {
 
   /** FirebaseComponent builder. */
   public static class Builder<T> {
+    private String name = null;
     private final Set<Class<? super T>> providedInterfaces = new HashSet<>();
     private final Set<Dependency> dependencies = new HashSet<>();
     private @Instantiation int instantiation = Instantiation.LAZY;
@@ -236,6 +258,12 @@ private Builder(Class<T> anInterface, Class<? super T>... additionalInterfaces)
       Collections.addAll(providedInterfaces, additionalInterfaces);
     }
 
+    /** Set a name for the {@link Component} being built. */
+    public Builder<T> name(@NonNull String name) {
+      this.name = name;
+      return this;
+    }
+
     /** Add a {@link Dependency} to the {@link Component} being built. */
     public Builder<T> add(Dependency dependency) {
       Preconditions.checkNotNull(dependency, "Null dependency");
@@ -288,6 +316,7 @@ private Builder<T> intoSet() {
     public Component<T> build() {
       Preconditions.checkState(factory != null, "Missing required property: factory.");
       return new Component<>(
+          name,
           new HashSet<>(providedInterfaces),
           new HashSet<>(dependencies),
           instantiation,

firebase-components/src/main/java/com/google/firebase/components/ComponentRegistrarProcessor.java

@@ -0,0 +1,32 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.firebase.components;
+
+import java.util.List;
+
+/**
+ * Provides the ability to customize/decorate components as they are requested by {@link
+ * ComponentRuntime}.
+ *
+ * <p>This makes it possible to do validation, change/add dependencies, or customize components'
+ * initialization logic by decorating their {@link ComponentFactory factories}.
+ */
+public interface ComponentRegistrarProcessor {
+
+  /** Default "noop" processor. */
+  ComponentRegistrarProcessor NOOP = ComponentRegistrar::getComponents;
+
+  List<Component<?>> processRegistrar(ComponentRegistrar registrar);
+}

firebase-components/src/main/java/com/google/firebase/components/ComponentRuntime.java

@@ -50,6 +50,7 @@ public class ComponentRuntime extends AbstractComponentContainer implements Comp
   private final List<Provider<ComponentRegistrar>> unprocessedRegistrarProviders;
   private final EventBus eventBus;
   private final AtomicReference<Boolean> eagerComponentsInitializedWith = new AtomicReference<>();
+  private final ComponentRegistrarProcessor componentRegistrarProcessor;
 
   /**
    * Creates an instance of {@link ComponentRuntime} for the provided {@link ComponentRegistrar}s
@@ -62,7 +63,11 @@ public ComponentRuntime(
       Executor defaultEventExecutor,
       Iterable<ComponentRegistrar> registrars,
       Component<?>... additionalComponents) {
-    this(defaultEventExecutor, toProviders(registrars), Arrays.asList(additionalComponents));
+    this(
+        defaultEventExecutor,
+        toProviders(registrars),
+        Arrays.asList(additionalComponents),
+        ComponentRegistrarProcessor.NOOP);
   }
 
   /** A builder for creating {@link ComponentRuntime} instances. */
@@ -73,8 +78,10 @@ public static Builder builder(Executor defaultEventExecutor) {
   private ComponentRuntime(
       Executor defaultEventExecutor,
       Iterable<Provider<ComponentRegistrar>> registrars,
-      Collection<Component<?>> additionalComponents) {
+      Collection<Component<?>> additionalComponents,
+      ComponentRegistrarProcessor componentRegistrarProcessor) {
     eventBus = new EventBus(defaultEventExecutor);
+    this.componentRegistrarProcessor = componentRegistrarProcessor;
 
     List<Component<?>> componentsToAdd = new ArrayList<>();
 
@@ -106,7 +113,7 @@ private void discoverComponents(List<Component<?>> componentsToAdd) {
         try {
           ComponentRegistrar registrar = provider.get();
           if (registrar != null) {
-            componentsToAdd.addAll(registrar.getComponents());
+            componentsToAdd.addAll(componentRegistrarProcessor.processRegistrar(registrar));
             iterator.remove();
           }
         } catch (InvalidRegistrarException ex) {
@@ -218,9 +225,12 @@ private List<Runnable> processSetComponents() {
       if (!lazySetMap.containsKey(entry.getKey())) {
         lazySetMap.put(entry.getKey(), LazySet.fromCollection(entry.getValue()));
       } else {
+        @SuppressWarnings("unchecked")
         LazySet<Object> existingSet = (LazySet<Object>) lazySetMap.get(entry.getKey());
         for (Provider<?> provider : entry.getValue()) {
-          runnables.add(() -> existingSet.add((Provider<Object>) provider));
+          @SuppressWarnings("unchecked")
+          Provider<Object> castedProvider = (Provider<Object>) provider;
+          runnables.add(() -> existingSet.add(castedProvider));
         }
       }
     }
@@ -332,10 +342,17 @@ private void processDependencies() {
     }
   }
 
+  @VisibleForTesting
+  Collection<Component<?>> getAllComponentsForTest() {
+    return components.keySet();
+  }
+
   public static final class Builder {
     private final Executor defaultExecutor;
     private final List<Provider<ComponentRegistrar>> lazyRegistrars = new ArrayList<>();
     private final List<Component<?>> additionalComponents = new ArrayList<>();
+    private ComponentRegistrarProcessor componentRegistrarProcessor =
+        ComponentRegistrarProcessor.NOOP;
 
     Builder(Executor defaultExecutor) {
       this.defaultExecutor = defaultExecutor;
@@ -356,8 +373,14 @@ public Builder addComponent(Component<?> component) {
       return this;
     }
 
+    public Builder setProcessor(ComponentRegistrarProcessor processor) {
+      this.componentRegistrarProcessor = processor;
+      return this;
+    }
+
     public ComponentRuntime build() {
-      return new ComponentRuntime(defaultExecutor, lazyRegistrars, additionalComponents);
+      return new ComponentRuntime(
+          defaultExecutor, lazyRegistrars, additionalComponents, componentRegistrarProcessor);
     }
   }
 }

firebase-components/src/test/java/com/google/firebase/components/ComponentRuntimeTest.java

@@ -26,6 +26,7 @@
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.Executor;
+import java.util.stream.Collectors;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -583,4 +584,32 @@ public void newlyDiscoveredComponent_shouldBecomeAvailableThroughItsDeferred() {
     componentLoader.discoverComponents();
     assertThat(dependsOnDeferredString.value).isEqualTo("hello");
   }
+
+  @Test
+  public void container_withComponentProcessor_shouldDelegateToItForEachComponentRegistrar() {
+    InitTracker initTracker = new InitTracker();
+
+    ComponentFactory<Object> replacedFactory = c -> null;
+    ComponentRegistrarProcessor processor =
+        r ->
+            r.getComponents().stream()
+                .map(c -> ((Component<Object>) c).withFactory(replacedFactory))
+                .collect(Collectors.toList());
+
+    ComponentRuntime runtime =
+        ComponentRuntime.builder(EXECUTOR)
+            .addComponentRegistrar(new ComponentRegistrarImpl(Eagerness.ALWAYS))
+            .addComponent(Component.of(initTracker, InitTracker.class))
+            .setProcessor(processor)
+            .build();
+
+    assertThat(
+            runtime.getAllComponentsForTest().stream()
+                .filter(
+                    c ->
+                        (c.getProvidedInterfaces().contains(ComponentOne.class)
+                            || c.getProvidedInterfaces().contains(ComponentTwo.class)))
+                .allMatch(c -> c.getFactory() == replacedFactory))
+        .isTrue();
+  }
 }

firebase-components/src/test/java/com/google/firebase/components/ComponentTest.java

@@ -195,4 +195,30 @@ public void getFactory_shouldReturnFactorySetInBuilder() {
         Component.builder(TestClass.class).factory(nullFactory).build();
     assertThat(component.getFactory()).isSameInstanceAs(nullFactory);
   }
+
+  @Test
+  public void withFactory_shouldReplaceTheFactorySetInBuilder() {
+    Component<TestClass> component =
+        Component.builder(TestClass.class).factory(nullFactory).build();
+
+    ComponentFactory<TestClass> newFactory = c -> null;
+    assertThat(component.withFactory(newFactory).getFactory()).isSameInstanceAs(newFactory);
+  }
+
+  @Test
+  public void name_shouldDefaultToNull() {
+    Component<TestClass> component =
+        Component.builder(TestClass.class).factory(nullFactory).build();
+
+    assertThat(component.getName()).isNull();
+  }
+
+  @Test
+  public void name_shouldReturnNameSetInBuilder() {
+    String name = "myName";
+    Component<TestClass> component =
+        Component.builder(TestClass.class).name(name).factory(nullFactory).build();
+
+    assertThat(component.getName()).isEqualTo(name);
+  }
 }