Nsryjdtyk

Before someone starts marking this question as duplicated, let me say that I already checked this post, but it didn't solve my issue.

As the title says, I need to inject two objects from different scopes in other object.
Let's say we have the next situation:

We have a screen where we let a user sign up and then, in the same screen, we do some operation base on a user session (ex: do some sync).

For my project I was planning to use subcomponents. I have the next code (simplified) so far based on this post:

@Singleton

@Component(modules = {AppModule.class})

public interface AppComponent {



  static AppComponent init(MyApplication application) {

    return DaggerAppComponent.builder()

        .appModule(new AppModule(application))

        .build();

  }



  UserSessionComponent plusUserSessionComponent(UserSessionModule userSessionModule);



  void inject(MyApplication application);

}



@Module

public class AppModule {



  private MyApplication myApplication;



  public AppModule(@NonNull MyApplication myApplication) {

    this.myApplication = myApplication;

  }



  @Provides

  @Singleton

  public AppSignUp provideAppSignUp() {

    return new AppSignUp();

  }

}



@UserSessionScope

@Subcomponent(modules = {UserSessionModule.class})

public interface UserSessionComponent {



  static UserSessionComponent init(AppComponent appComponent,

      UserSession userSession) {

    return appComponent.plusUserSessionComponent(userSession);

  }



  void inject(MyApplication myApplication);

}



@Module

public class UserSessionModule {



  private UserSession userSession;



  public UserSessionModule(@NonNull UserSession userSession) {

    this.userSession = userSession;

  }



  @Provides

  @UserSessionScope

  public UserSessionSyncHelper provideUserSession(UserSession userSession) {

    return new UserSessionSyncHelper(userSession);

  }





  @Provides

  @UserSessionScope

  public UserSessionSync provideUserSession(UserSessionSyncHelper userSessionSyncHelper) {

    return new UserSessionSync(userSessionSyncHelper);

  }

}

Now, in order to make it simple now, let's say I have a component (an activity, viewmodel, presenter or whatever) which will have this two dependencies:

public MyActivity extends AppCompatActivity {



  @Inject

  AppSignUp appSignUp;



  @Inject

  UserSessionSync userSessionSync;



  public void onCreate(Bundle savedInstanceState) {

    //to inject appSignUp

    MyApplication.getAppComponent().inject(this);

  }



  public onUserCreated(UserSession userSession) {

    //to inject userSessionSync

    MyApplication.getUserSessionComponent().inject(this);

  }

}

My problem here is that Dagger will complain in the first inject because AppModile does not have userSessionSync. So the question is, how can I solve this issue? Does Dagger have any feature for this scenario?

I could only think in the next solution so far:

Make UserSessionSync independent from Dagger framework and inside

public class UserSessionSync {

  @Inject

  UserSessionSyncHelper userSessionSyncHelper;



  public UserSessionSync(){

    MyApplication.getUserSessionComponent().inject(this)

  }

}

In my opinion, this is not a good way to deal with this problem.

Tried using Dagger-Android, works fine. Also module is not really needed for AppSignUp. @Inject constructor() with @Singleton will do it. Under the hood, it uses subcomponents.

@Module

abstract class AppModule {



    @Module

    companion object {



        @JvmStatic

        @Provides

        @Singleton

        fun providesAppSignUp() = AppSignUp()



    }

}



@Singleton

@Component( modules = [AndroidSupportInjectionModule::class, ActivityBindingModule::class, AppModule::class] )

interface AppComponent : AndroidInjector<MainApplication>



@Module

interface ActivityBindingModule {



    @UserScope

    @ContributesAndroidInjector( modules = [MainActivityModule::class] )

    fun mainActivity() : MainActivity

}



@Module

abstract class MainActivityModule {



    @Module

    companion object {



        @JvmStatic

        @Provides

        @UserScope

        fun providesUserSession() = UserSession()

    }

}



class UserSession



class AppSignUp



@Scope

annotation class UserScope



class MainApplication : DaggerApplication() {



    @Inject

    lateinit var appSignUp : AppSignUp



    override fun applicationInjector(): AndroidInjector<out DaggerApplication> {

        return DaggerAppComponent.builder().build()

    }



}



class MainActivity : DaggerAppCompatActivity() {



    @Inject

    lateinit var appSignUp: AppSignUp



    @Inject

    lateinit var appSignUp1: AppSignUp



    @Inject

    lateinit var userSession: UserSession



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        setContentView(R.layout.activity_main)

    }

}