update

Author: VinayGuthal

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

@@ -49,6 +49,7 @@ public class ComponentRuntime implements ComponentContainer, ComponentLoader {
   private final Map<Qualified<?>, Provider<?>> lazyInstanceMap = new HashMap<>();
   private final Map<Qualified<?>, LazySet<?>> lazySetMap = new HashMap<>();
   private final List<Provider<ComponentRegistrar>> unprocessedRegistrarProviders;
+  private final List<Component<?>> processedComponents = new ArrayList<>();
   private final EventBus eventBus;
   private final AtomicReference<Boolean> eagerComponentsInitializedWith = new AtomicReference<>();
   private final ComponentRegistrarProcessor componentRegistrarProcessor;
@@ -107,6 +108,8 @@ private void discoverComponents(List<Component<?>> componentsToAdd) {
     // instead of executing such code in the synchronized block below, we store it in a list and
     // execute right after the synchronized section.
     List<Runnable> runAfterDiscovery = new ArrayList<>();
+    List<Component<?>> componentsAdding = new ArrayList<>();
+    Set<String> existingInterfaces = new HashSet<>();
     synchronized (this) {
       Iterator<Provider<ComponentRegistrar>> iterator = unprocessedRegistrarProviders.iterator();
       while (iterator.hasNext()) {
@@ -122,16 +125,41 @@ private void discoverComponents(List<Component<?>> componentsToAdd) {
           Log.w(ComponentDiscovery.TAG, "Invalid component registrar.", ex);
         }
       }
+      for (int i = 0; i < processedComponents.size(); i++) {
+        Object[] interfaces = processedComponents.get(i).getProvidedInterfaces().toArray();
+        for (Object anInterface : interfaces) {
+          if (anInterface.toString().contains("kotlinx.coroutines.CoroutineDispatcher")) {
+            existingInterfaces.add(anInterface.toString());
+          }
+        }
+      }
+      for (int i = 0; i < componentsToAdd.size(); i++) {
+        Object[] interfaces = componentsToAdd.get(i).getProvidedInterfaces().toArray();
+        boolean addComponent = true;
+        for (Object anInterface : interfaces) {
+          String interfaceString = anInterface.toString();
+          if (interfaceString.contains("kotlinx.coroutines.CoroutineDispatcher")) {
+            if (existingInterfaces.contains(interfaceString)) {
+              addComponent = false;
+            } else {
+              existingInterfaces.add(interfaceString);
+            }
+          }
+        }
+        if (addComponent) {
+          componentsAdding.add(componentsToAdd.get(i));
+        }
+      }
 
       if (components.isEmpty()) {
-        CycleDetector.detect(componentsToAdd);
+        CycleDetector.detect(componentsAdding);
       } else {
         ArrayList<Component<?>> allComponents = new ArrayList<>(this.components.keySet());
-        allComponents.addAll(componentsToAdd);
+        allComponents.addAll(componentsAdding);
         CycleDetector.detect(allComponents);
       }
 
-      for (Component<?> component : componentsToAdd) {
+      for (Component<?> component : componentsAdding) {
         Lazy<?> lazy =
             new Lazy<>(
                 () ->
@@ -142,7 +170,8 @@ private void discoverComponents(List<Component<?>> componentsToAdd) {
         components.put(component, lazy);
       }
 
-      runAfterDiscovery.addAll(processInstanceComponents(componentsToAdd));
+      runAfterDiscovery.addAll(processInstanceComponents(componentsAdding));
+      processedComponents.addAll(componentsAdding);
       runAfterDiscovery.addAll(processSetComponents());
       processDependencies();
     }