Trying to parse this second sentence from the hilt guide on android docs: "Doing manual dependency injection requires you to construct every class and its dependencies by hand, and to use containers to reuse and manage dependencies." Is it just me or does the second half of that sentence not make sense?

Scenario I have an Activity called Activity1, then inside has a Fragment1 all have the

@ContributeAndroidInjection

and then if my Activity2 wants to inject Fragment1 Why I need to implement HasAndroidInjector and do the

@Inject lateinit var androidInjector: DispatchingAndroidInjector<Any>
override fun androidInjector(): AndroidInjector<Any> = androidInjector

to be able to use a Fragment that is already with

@ContributeAndroidInjection

? If I remove this two lines it says :

RunTimeException:Unable to resume activity {MyActivity}: java.lang.IllegalArgumentException: No injector factory bound for Class<MyClass>

I thought that if I have this:

@ContributesAndroidInjector(
 modules = [ FragmentProvider::class]
)
fun bindMyActivity2: Activity2

It would work anyways, because I've add as a modules a module that has inside the

@ContributesAndroidInjector

with that Fragment... Is it because I need that `hasAndroidInjector`when I want to provide injection into a inner Fragment?

Yep. But dagger reflect has partial reflection or full reflection. I'm using full reflection.

Anybody who can give me a hint on what I am doing wrong here? Using Hilt though https://stackoverflow.com/q/64739048/8914336

Do I need to replace all `implementarion`s with `api`s for hilt to work properly in a multi-module project ? I don't have any feature modules and am trying to closely follow the way chrisbanes/tivi has been implemented but I'm getting "XYZ does not represent a declared type" error Link to my example implementation: https://github.com/Kshitij09/HiltMultiModuleExample

Is it possible to use hilt and have provision methods? I'm assuming since we don't create things like ApplicationComponent anymore, we don't actually have access to use provision methods anymore and we have to use field injection instead?

Hi Dagger Experts. I have a common question about the annotation processor of dagger. my project is a multi module with a lot of features. and every feature has an activity (annotated with @AndroidEntryPoint). do i have to run annotation processing in every feature module

kapt(...)

another example is when i annotate a constructor of a class with @Inject in a library oder feature module, do i also have to run the annotation processor in each of this modules i am asking because then i have to run annotation processing in nearly every module which is not really performant

Hello everyone 🖐️! Question, Im getting into a feature modularization architecture with pure dagger, no dagger-android, no hilt, just dagger. While my modules grow my application class is starting to look like this:

class MyApp(): Application(), LoginComponentProvider, RegisterComponentProvider, RecoverPasswordComponentProvider  {

    // Reference to the application graph that is used across the whole app
    val appComponent by lazy {
        // Creates an instance of AppComponent using its Factory constructor
        // We pass the applicationContext that will be used as Context in the graph
        DaggerMyAppComponent.factory().create(applicationContext)
    }

    override fun provideLoginComponent(): LoginComponent {
        return appComponent
            .loginComponent()
            .create()
    }

    override fun provideRegisterComponent(): RegisterComponent {
        return appComponent
            .registerComponent()
            .create()
    }

    override fun provideRecoverPasswordComponent(): RecoverPasswordComponent {
        return appComponent
            .recoverPasswordComponent()
            .create()
    }
    ... On every new feature module I will have to implement its provider
}

Is any pattern or better way to improve this? Im doing this based on the official documentaton for dagger in android https://developer.android.com/training/dependency-injection/dagger-multi-module

Is it possible to create an annotation so that whenever I use that annotation it gives me an item. I'm trying to do something like this

class MyClass @Inject constructor(
  @Tablet isTablet: Boolean
)

Then in my module I have something like

@Provides
@Tablet
fun provideIsTablet(context: Context): Boolean = someWayToTellIfTablet

Is there a way to create an annotation like this without have to use

@Named("Tablet")

Looking at hilt docs and they say "*Predefined bindings* to represent Android classes such as 

Application

 or 

Activity

." Can anyone explain what that means? Edit: I think this is part of the lingo of dagger that I haven't picked up yet, but it seems like it's pretty widely accepting that "bindings" in the context of dagger means "types that are available to you". If so... Bindings for Application or Activity... do they actually mean Context?

Working with dagger on a larger team. What do you all do to ease "onboarding" of someone that is familiar with dagger but we have so many Types available to inject, it can be hard to find. Do you recommend just listing out what "bindings" are available? Or is there something else that's clever that I haven't thought of?

This message was deleted.

Does anyone know what needs to be added to

build.gradle

file to enable kapt to work properly when using JDK 15 to build? I keep getting this error `package javax.annotation.processing does not exist import javax.annotation.processing.Generated`whenever I try to build. My config is the following:

plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'kotlin-kapt'
}

kapt {
    javacOptions {
        option("-source", "8")
        option("-target", "8")
    }
}

android {
    compileSdkVersion 30
    defaultConfig {
        applicationId "com.ndoglio.daggerkapt"
        minSdkVersion 23
        targetSdkVersion 30
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), '<http://proguard-rules.pro|proguard-rules.pro>'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = '1.8'
    }
}

dependencies {
    implementation 'androidx.core:core-ktx:1.3.2'
    implementation 'androidx.appcompat:appcompat:1.2.0'
    implementation 'com.google.android.material:material:1.2.1'
    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'

    implementation 'com.google.dagger:dagger:2.30.1'
    kapt 'com.google.dagger:dagger-compiler:2.30.1'
}

Thread about what’s new in Dagger/Hilt 2.31. Hope it helps 🙂 https://twitter.com/manuelvicnt/status/1351151438748123142

Hi all. I'm trying a very simple example with an

@AssistedInject

class.

class CalculatorImpl @AssistedInject constructor(
    private val logger: Logger,
    @Assisted private val increment: Int
) : Calculator {

  override fun addOne(a: Int) = a.inc().apply {
    logger.log("New value is $this")
  }
}

The

@AssistedFactory

is the following

@AssistedFactory
interface CalculatorImplFactory {

  fun create(
      inc: Int
  ): CalculatorImpl
}

When I try to inject the

CalculatorImplFactory

in an Activity like this

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {

  @Inject
  lateinit var calculatorFactory: CalculatorImplFactory
  // ...
}

When I build I get a

CalculatorImplFactory cannot be provided without an @Provides-annotated method.

The documentations says that

Dagger will create the implementation for the assisted factory and provide a binding for it.

but this doesn't seem to be true. What am I missing? Thanks

Hi everyone, I'm currently stuck in a "simple" use case using Hilt: I want a Retrofit service singleton, which takes an OkHttpClient. The OkHttpClient has an interceptor, which uses the Retrofit service singleton (to make a certain request inside the interceptor) The problem is: -> The OkHttpClient takes a Retrofit as argument -> The Retrofit takes an OkHttpClient as argument Cheers

Getting an error between a Provider written in java, and an @inject written in Kotlin. I need to do field injection, and so I have

@Inject var taxes: Taxes? = null

Unfortunately it needs to be nullable as the provider is nullable, but I get an error saying Dagger does not support injection into private fields... which leads me to do

@set:Inject var taxes: Taxes? = null

and everything works. I could have sworn that this "workaround" wasn't needed for latest versions of dagger. Am I missing something?

What is the proper way to have a singleton while using assisted injection. I mean same

@Assisted

parameter should return same object.

Hello. I have a simple setup where I have my app and another gradle module. All of this works fine. Now I created a dagger module with a @Binds @IntoSet in both my app module and my other gradle module. But now, only the app modules @Binds @IntoSet gets loaded in my app, not the gradle modules. Is there something I'm missing here on how to get this second dagger module to be provided correctly?

Hi, Does anyone here have experience or relevant resources for mocking dagger related dependencies while unit testing in a multi-module clean architecture-based project? Kinda stuck with it here. 😅

Hi everyone! Hilt is in Beta now 🚀 https://github.com/google/dagger/releases/tag/dagger-2.33

Hello, everyone! 😊 Is there any gotcha with Hilt + Instrumented Tests? I’m following the Hilt Testing documentation and the Crane sample and can’t make it work at all! If I run with

--debug

it only gives me the default:

Execution failed for task ':app:kaptDebugAndroidTestKotlin'.
> A failure occurred while executing org.jetbrains.kotlin.gradle.internal.KaptExecution
> java.lang.reflect.InvocationTargetException (no error message)

I’m migrating from Koin to Hilt but this is blocking me once I want to do some end to end tests in my application. Thanks a lot in advance! ❤️

Hello 👋 Is there a Dagger way to provide a ViewModel to a Composable Screen ? I'm not using Hilt so I don't have the

@HiltViewModel

annotation. How would you achieve it only with Dagger ?

Is it permitted to write extension methods/properties on a custom component? I.e im using this to reduce the verbosity of accessing an entrypoint.

val AuthenticatedComponent.entryPoint: AuthenticatedComponentEntryPoint
    get(): AuthenticatedComponentEntryPoint {
        return EntryPoints.get(this, AuthenticatedComponentEntryPoint::class.java)
    }

And then I can inject with:

private val myRepository = authManager.component!!.entryPoint.getMyRepository()

Edit: Just realized EntryPoints are specific to Hilt and this is a dagger channel

Is it possible to use 

@ApplicationContext

 in DFM (dynamic feature module)? or should we provide application context manually? If we need to provide manually in DFM, is there any reference you guys can point me out?

DFM - error: [Dagger/MissingBinding] @dagger.hilt.android.qualifiers.ApplicationContext android.content.Context cannot be provided without an @Provides-annotated method.

opened an issue here: https://github.com/google/dagger/issues/2477

I have a class that can be constructor injected, however if I want to install it in a specific component a also scope it, should I put it in a module and

@Provides

it?

Do I need to include dependencies inside the :app module that are provided as @ Singleton from another module? https://stackoverflow.com/questions/66724358/do-i-need-to-include-dependencies-inside-the-app-module-that-are-provided-as-s

How scope a database to a logged in user using Hilt? The problem is that a database should also be kind of singleton scoped but also scoped to a new user when logging out and in.