// If you're using Kotlin
apply plugin: 'kotlin-kapt'

dependencies {
  // ...all the libs...

  // Dagger
  def dagger_version = "2.15"
  // Required
  implementation "com.google.dagger:dagger-android:$dagger_version"
  kapt "com.google.dagger:dagger-android-processor:$dagger_version"

  // Required if you use anything prefixed with AppCompat or from the support library
  implementation "com.google.dagger:dagger-android-support:$dagger_version"
  kapt "com.google.dagger:dagger-compiler:$dagger_version"

  // Required if you care about testing, and of course you care about testing. Required.
  kaptAndroidTest "com.google.dagger:dagger-compiler:$dagger_version"
  kaptAndroidTest "com.google.dagger:dagger-android-processor:$dagger_version"
}

// open because we will have a DebugMainApplication for testing
open class MainApplication : Application(), HasActivityInjector {

  // Required by HasActivityInjector, and injected below
  @Inject
  protected lateinit var dispatchingAndroidInjector: DispatchingAndroidInjector<Activity>
  override fun activityInjector() = dispatchingAndroidInjector

  override fun onCreate() {
    super.onCreate()
    initDagger()
  }

  private fun initDagger() {
    DaggerMainApplication_MainApplicationComponent.builder()
      .app(this)
      .build()
      .inject(this)
  }

  // Doesn't need to be a nested class. I could also put this in its own file or,
  // this being Kotlin, in the same file but at the top level.
  @Singleton
  @Component(modules = [
    // provided by dagger.android, necessary for injecting framework classes
    AndroidSupportInjectionModule::class,

    // Defines a series of Subcomponents that bind "screens" (Activities, etc)
    ScreenBindingModule::class,
  ])
  interface MainApplicationComponent {
    fun inject(app: MainApplication)

    @Component.Builder
    interface Builder {
      fun build(): MainApplicationComponent
      @BindsInstance fun app(app: Context): Builder
    }
  }
}

// Don't worry, it'll get bigger!
@Module abstract class ScreenBindingModule {
  @ActivityScoped // optional
  @ContributesAndroidInjector(modules = [MainActivityModule::class])
  abstract fun mainActivity(): MainActivity
}

// We can define this anywhere we like, but it's convenient to include
// in the same file as the class being injected
// An object because I want to provide a static function, and it's Kotlin
@Module object MainActivityModule {
  // static because dagger can call this method like MainActivityModule.provideText(),
  // rather than new MainActivityModule().provideText()
  @Provides @JvmStatic fun provideText() = "Why, hello there!"
}

class MainActivity : AppCompatActivity() {

  @Inject lateinit var text: String

  override fun onCreate(savedInstanceState: Bundle?) {
    AndroidInjection.inject(this)
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    textView.text = text
  }
}

class DebugMainApplication : MainApplication() {
  fun setTestComponent(component: MainApplicationComponent) {
    component.inject(this)
  }
}

<?xml version="1.0" encoding="utf-8"?>
<manifest
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.autonomousapps.daggerdotandroid">

    <application
        android:name="com.autonomousapps.daggerdotandroid.DebugMainApplication"
        android:label="@string/app_name"
        tools:ignore="AllowBackup,GoogleAppIndexingWarning"
        tools:replace="android:name,android:label"/>

</manifest>

class MainActivityTest {

  // Rules are one place where Kotlin code is uglier and more verbose than Java
  @get:Rule private var activityTestRule = ActivityTestRule(
    MainActivity::class.java,
    false,
    false
  )

  // Here we define a test component that extends our production component
  @Component(modules = [
    // Inheriting components don't inherit annotations, so we need to re-declare
    // that we want to inject framework classes
    AndroidSupportInjectionModule::class,

    // A test module defined below
    TestMainActivityModule::class
  ])
  interface TestMainApplicationComponent : MainApplication.MainApplicationComponent {

    @Component.Builder
    interface Builder {
      @BindsInstance fun app(app: MainApplication): Builder

      // This is the fruit of all our labor. We can now provide our custom text
      // (or anything more interesting!) into our dependency graph
      @BindsInstance fun text(text: String): Builder
      fun build(): TestMainApplicationComponent
    }
  }

  // This is basically the mirror image of ScreenBindingModule, but instead of
  // providing an abstract function for EVERY screen, we only need to provide
  // one for the screens that will get injected in our test
  @Module abstract class TestMainActivityModule {
    @ContributesAndroidInjector abstract fun mainActivity(): MainActivity
  }

  @Before fun setup() {
    val app = InstrumentationRegistry.getTargetContext().applicationContext as DebugMainApplication
    val mainComponent = DaggerMainActivityTest_TestMainApplicationComponent.builder()
      .app(app)

      // Neat!
      .text("I'm a test!")
      .build()
    app.setTestComponent(mainComponent)

    activityTestRule.launchActivity(null)
  }

  @Test fun verifyText() {
    onView(withText("I'm a test!")).check(matches(isDisplayed()))
  }
}