Expose ribActionEvents stream

android/demos/rib-workers/src/main/kotlin/com/uber/rib/workers/root/logger/ApplicationLevelWorkerLogger.kt

@@ -44,6 +44,8 @@ object ApplicationLevelWorkerLogger {
 
   @OptIn(DelicateCoroutinesApi::class)
   fun start() {
+    RibEvents.allowRibActionEmissions()
+
     GlobalScope.launch {
       RibEvents.ribActionEvents
         .filter { it.ribComponentType == RibComponentType.DEPRECATED_WORKER }

android/libraries/rib-base/src/main/kotlin/com/uber/rib/core/Interactor.kt

@@ -37,7 +37,7 @@ import kotlinx.coroutines.rx2.asObservable
  * @param <P> the type of [Presenter].
  * @param <R> the type of [Router].
  */
-public abstract class Interactor<P : Any, R : Router<*>>() : InteractorType {
+public abstract class Interactor<P : Any, R : Router<*>>() : InteractorType, RibComponent {
   @Inject public lateinit var injectedPresenter: P
   internal var actualPresenter: P? = null
   private val _lifecycleFlow = MutableSharedFlow<InteractorEvent>(1, 0, BufferOverflow.DROP_OLDEST)

android/libraries/rib-base/src/main/kotlin/com/uber/rib/core/Presenter.kt

@@ -33,7 +33,7 @@ import org.checkerframework.checker.guieffect.qual.UIEffect
  * practice this caused confusion: if both a presenter and interactor can perform complex rx logic
  * it becomes unclear where you should write your bussiness logic.
  */
-public abstract class Presenter : ScopeProvider {
+public abstract class Presenter : ScopeProvider, RibComponent {
   private val _lifecycleFlow = MutableSharedFlow<PresenterEvent>(1, 0, BufferOverflow.DROP_OLDEST)
   public open val lifecycleFlow: SharedFlow<PresenterEvent>
     get() = _lifecycleFlow

android/libraries/rib-base/src/main/kotlin/com/uber/rib/core/RibComponentType.kt

@@ -15,11 +15,11 @@
  */
 package com.uber.rib.core
 
+public interface RibComponent
+
 public enum class RibComponentType {
   ROUTER,
   PRESENTER,
   INTERACTOR,
   DEPRECATED_WORKER,
-
-  /** RIB_COROUTINE_WORKER -> To be added on next releases */
 }

android/libraries/rib-base/src/main/kotlin/com/uber/rib/core/RibCoroutineWorker.kt

@@ -43,7 +43,8 @@ import kotlinx.coroutines.supervisorScope
 import kotlinx.coroutines.withContext
 
 /** A manager or helper class bound to a [CoroutineScope] by using a binder like [bind]. */
-public fun interface RibCoroutineWorker {
+public fun interface RibCoroutineWorker : RibComponent {
+
   /** Called when worker is started. Children coroutines can be launched in [scope]. */
   public suspend fun onStart(scope: CoroutineScope)
 

android/libraries/rib-base/src/main/kotlin/com/uber/rib/core/RibEvents.kt

@@ -33,12 +33,24 @@ public object RibEvents {
   @JvmStatic
   public val ribActionEvents: Observable<RibActionInfo> = mutableRibDurationEvents.asObservable()
 
+  private var areRibActionEmissionsAllowed = false
+
+  /**
+   * To be called before start observing/collecting on [ribActionEvents] (usually at your earliest
+   * application point)
+   */
+  @JvmStatic
+  public fun allowRibActionEmissions() {
+    this.areRibActionEmissionsAllowed = true
+  }
+
   /**
    * @param eventType [RibEventType]
    * @param child [Router]
    * @param parent [Router] and null for the root ribs that are directly attached to
    *   RibActivity/Fragment
    */
+  @JvmStatic
   public fun emitRouterEvent(eventType: RibEventType, child: Router<*>, parent: Router<*>?) {
     mutableRouterEvents.tryEmit(RibRouterEvent(eventType, child, parent))
   }
@@ -48,39 +60,48 @@ public object RibEvents {
    * for each RIB component.
    *
    * @param ribAction The related RIB action type. e.g. didBecomeActive, willLoad, etc
-   * @param ribCallerClassType Related RIB component class type
+   * @param ribComponent Related RIB component
    * @param ribComponentType The RIB component type (e.g. Interactor, Router, Presenter, Worker)
    * @param ribEventType RIB event type (e.g. ATTACH/DETACH)
    */
-  internal inline fun <T : Any> triggerRibActionAndEmitEvents(
-    ribCallerClassType: T,
+  internal inline fun triggerRibActionAndEmitEvents(
+    ribComponent: RibComponent,
     ribComponentType: RibComponentType,
     ribEventType: RibEventType,
     ribAction: () -> Unit,
   ) {
-    val ribClassName = ribCallerClassType.asQualifiedName()
-    ribClassName?.emitRibEventAction(ribComponentType, ribEventType, RibActionState.STARTED)
+    emitRibEventActionIfNeeded(ribComponent, ribComponentType, ribEventType, RibActionState.STARTED)
     ribAction()
-    ribClassName?.emitRibEventAction(ribComponentType, ribEventType, RibActionState.COMPLETED)
+    emitRibEventActionIfNeeded(
+      ribComponent,
+      ribComponentType,
+      ribEventType,
+      RibActionState.COMPLETED,
+    )
   }
 
-  private fun Any.asQualifiedName(): String? = javaClass.kotlin.qualifiedName
-
   /**
    * Emits emission of ATTACHED/DETACHED events for each RIB component.
    *
    * @param ribComponentType The RIB component type (e.g. Interactor, Router, Presenter)
    * @param ribEventType RIB event type (e.g. ATTACH/DETACH)
    * @param ribActionState: RibActionType,
    */
-  private fun String.emitRibEventAction(
+  private fun emitRibEventActionIfNeeded(
+    ribComponent: RibComponent,
     ribComponentType: RibComponentType,
     ribEventType: RibEventType,
     ribActionState: RibActionState,
   ) {
+    if (!areRibActionEmissionsAllowed) {
+      // Unless specified explicitly via [RibEvents.allowRibActionEmissions] there is no need
+      // to create unnecessary objects if no one is observing/collecting RibAction events
+      return
+    }
+
     val ribActionInfo =
       RibActionInfo(
-        this,
+        ribComponent.javaClass.name,
         ribComponentType,
         ribEventType,
         ribActionState,

android/libraries/rib-base/src/main/kotlin/com/uber/rib/core/Router.kt

@@ -34,7 +34,7 @@ protected constructor(
   public open val interactor: I,
   private val ribRefWatcher: RibRefWatcher,
   private val mainThread: Thread,
-) {
+) : RibComponent {
   private val children: MutableList<Router<*>> = CopyOnWriteArrayList()
   private val interactorGeneric: Interactor<*, *>
     get() = interactor as Interactor<*, *>

android/libraries/rib-base/src/main/kotlin/com/uber/rib/core/Worker.kt

@@ -38,7 +38,7 @@ import kotlinx.coroutines.CoroutineDispatcher
     """,
   replaceWith = ReplaceWith("RibCoroutineWorker"),
 )
-public interface Worker {
+public interface Worker : RibComponent {
 
   /**
    * When overriden, will specify on which [CoroutineContext] the [Worker] will be bound via

android/libraries/rib-base/src/test/kotlin/com/uber/rib/core/InteractorAndRouterTest.kt

@@ -49,6 +49,7 @@ class InteractorAndRouterTest {
     }
     interactor = TestInteractor(childInteractor)
     router = TestRouter(interactor, component)
+    RibEvents.allowRibActionEmissions()
   }
 
   @Test
@@ -67,7 +68,7 @@ class InteractorAndRouterTest {
         RibEventType.ATTACHED,
         RibComponentType.INTERACTOR,
         RibActionState.COMPLETED,
-        "com.uber.rib.core.InteractorAndRouterTest.TestInteractor",
+        "com.uber.rib.core.InteractorAndRouterTest${'$'}TestInteractor",
       )
     verify(childInteractor).dispatchAttach(null)
   }

android/libraries/rib-base/src/test/kotlin/com/uber/rib/core/WorkerBinderTest.kt

@@ -31,6 +31,7 @@ import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.advanceUntilIdle
 import kotlinx.coroutines.test.runTest
+import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -59,6 +60,11 @@ class WorkerBinderTest(private val adaptFromRibCoroutineWorker: Boolean) {
   private val interactor = FakeInteractor<Presenter, Router<*>>()
   private val ribActionInfoObserver = TestObserver<RibActionInfo>()
 
+  @Before
+  fun setUp() {
+    RibEvents.allowRibActionEmissions()
+  }
+
   @Test
   fun bind_whenInteractorAttached_shouldStartWorker() {
     val lifecycle = BehaviorRelay.createDefault(InteractorEvent.ACTIVE)