Dagger 2 - How to establish sibling dependency via Subcomponent or Component Dependency - dagger-2

Question

Background
As per docs dependency between sibling subcomponents is not possible so, the other way left is Component Dependency. I'm trying to encapsulate "Repository" class so that UI can only access the instance of "Repository", not implementation details of "Repository". I mean nothing from ApiModule should be exposed.
ApiModule
#Module
class ApiModule {
#Provides
fun provideConnection(): Connection = //....
}
RepositoryModule
#Module (
includes = [
ApiModule::class
]
)
abstract class RepositoryModule {
#Provides
fun providesRepository(connection Connection): Repository = //.....
}
AppComponent
#Component (modules = [
AppModule::class,
RepositoryModule::class
])
interface AppComponent{
#Component.Builder
interface Builder {
#BindsInstance
fun application(application: Application): Builder
fun build(): AppComponent
}
}
Problem
Now, if I create a subcomponent (let's say ActivitySubComponent) of AppComponent, all binding in RepositoryModule and ApiModule modules will be exposed to that subcomponent. Though, I want only provided "Repository" to be accessible from ActivitySubComponent
Proposed Solution
Create RepositoryComponenet and ActivityComponent components make AppComponenet their dependency:
AppComponent
#Component (modules = [
AppModule::class
])
interface AppComponent{
#Component.Builder
interface Builder {
#BindsInstance
fun application(application: Application): Builder
fun build(): AppComponent
}
}
ActivityComponent
#Component(dependencies = [AppComponent::class], modules = [ActivityModule::class])
interface ActivityComponent {
fun inject(mainActivity: MainActivity)
#Component.Builder
interface Builder{
fun appComponent(appComponent: AppComponent): Builder
fun build(): ActivityComponent
}
}
RepositoryComponent
#Component(dependencies = [AppComponent::class], modules = [RepositoryModule::class])
interface RepositoryComponent {
}
The problem is how do I expose "Repository" instance into sibling ActivityComponent's bindings or #Inject into MainActivity? Any explanation, proposal to change my configuration or links to articles that may potentially solve my problem is appreciated.

Answer 1

If I understand your problem correctly, you don't want to expose all dependencies from AppComponent to its child components. As component documentation says (section Component dependencies),
Note that only the bindings exposed as provision methods are available through component dependencies.
you should use Component dependencies for this purpose.
Working example is below
class Connection
interface Repository
#Module
object AppModule {
#Provides
#Singleton
fun provideConnection() = Connection()
}
#Module(includes = [AppModule::class])
object RepositoryModule {
#Provides
#Singleton
fun provideRepository(connection: Connection) = object : Repository {}
}
#Singleton
#Component(modules = [AppModule::class, RepositoryModule::class])
interface AppComponent {
val repository: Repository
}
#Scope
#MustBeDocumented
#kotlin.annotation.Retention
annotation class ActivityScope
#ActivityScope
#Component(dependencies = [AppComponent::class])
interface ActivityComponent {
fun inject(activity: FakeActivity)
}
class FakeActivity {
#Inject
lateinit var repository: Repository
// uncomment this and code won't compile because connection isn't explicitly exposed in AppComponent
// #Inject
// lateinit var connection: Connection
}
fun main() {
val appComponent = DaggerAppComponent.create()
val activityComponent = DaggerActivityComponent.builder().appComponent(appComponent).build()
val fakeActivity = FakeActivity()
activityComponent.inject(fakeActivity)
println("hash: ${fakeActivity.repository}")
println("hash: ${appComponent.repository}")
}
I used scopes because I suppose you want just one instance of Repository per Application. If something is not clear, let me know.