Argthtjtr

I have an object class in Kotlin which is a manager - let's call it KManager - that manager is inside an independent module (moduleA). There is another module (moduleB) where I'm using KManager.

Rule: moduleB knows about moduleA, but moduleA shouldn't know anything about moduleB.

I created like a bridge (interface) to communicate moduleA with moduleB, because of there is some shared logic that needs to run in both sides. The interface is declared in the KManager as:

//moduleA

object KManager {



    var bridgeShared: BridgeShared? = null

    ....

}

Interface:

interface BridgeShared {

    fun foo()

}

Now, I have a class in the moduleB where implements BridgeShared. When the app starts I'm initializing bridgeShared like this:

//moduleB

class BridgeSharedImpl : BridgeShared {



        KManager.bridgeShared = this

        ....

}

I'm getting KManager.bridgeShared in the moduleB and executing the interface's functions in another classes, something like:

KManager.bridgeShared.foo()

The question here is, is it harmful to have a listener declared inside an object Kotlin class and grab it whenever I need it?

NOTE: No real names used here, just to describe the scenario.

UPDATE:

Extra Steps:

moduleA receives like an external event, it is processed and then the result is received by the "Observer" who subscribed to the BridgeShared listener, that "Observer" is the moduleB but moduleA doesn't care about it (the rule).

moduleB

class BridgeSharedImpl : BridgeShared {



   KManager.bridgeShared = this



   override fun eventProcessed() {

      //stuff

   }



   override fun fetchData() {

     //stuff

   }



   fun callAnotherFunction1() {

     KManager.anotherFunction1()

   }

}

moduleA

interface BridgeShared {

    fun eventProcessed()

    fun fetchedData()

}



object KManager {



    var bridgeShared: BridgeShared? = null



    fun anotherFunction1() {

      //not-related to BridgeShared, called from outside

    }



    fun anotherFunction2() {

      //not-related to BridgeShared, called from outside

    }

}



class EventProcessor {



  fun eventReceived() {

    //stuff

    KManager.bridgeShared?.eventProcessed()

  }  



}



class DataFetcher {



  fun dataReceived() {

    //stuff

    KManager.bridgeShared?.fetchedData()

  }  



}

On the other hand, I'm taking advantage of KManager.bridgeShared in the moduleB to call the same functions inside the same moduleB because I don't have access to the instance of BridgeSharedImpleverywhere, just where it was instantiated.

Now, the moduleB uses the KManager singleton to execute other functions not related to the BridgeShared.

Based on the recommendations, I applied the Factory solution to avoid saving the BridgeShared inside a Singleton.

moduleA

class BridgeFactory(private val bridgeShared: BridgeShared) {



    companion object {



        lateinit var bridgeFactory: BridgeFactory



        fun initialize(bridgeShared: BridgeShared) {

            bridgeFactory = BridgeFactory(emmaShared)

        }

    }



    fun eventProcessor(): EventProcessor {

        return EventProcessor(bridgeShared)

    }



    fun dataFetcher(): DataFetcher {

        return DataFetcher(bridgeShared)

    }



}



class EventProcessor(private val bridgeShared: BridgeShared) {



  fun eventReceived() {

    //stuff

    bridgeShared.eventProcessed()

  }  



}



class DataFetcher(private val bridgeShared: BridgeShared) {



  fun dataReceived() {

    //stuff

    bridgeShared.fetchedData()

  }  



}

moduleB

class BridgeSharedImpl : BridgeShared {



    init {

        BridgeFactory.initialize(this)

    }



   override fun eventProcessed() {

      //stuff

   }



   override fun fetchData() {

     //stuff

   }



}