So in that case, buildUserCaseObservable is no longer useful and you will have to pass them via setter (with defensive code and failing fast in case all the dynamic parameters are not satisfied).
I used this approach due to dagger instantiating my objects thus, being able to pass the user id via module constructor parameter.

@android10 yes that's true, but how do you pass dynamics parameters for login process for example? I mean in this case there isn't a predefined parameter but you must setup the submitted details? Which is your approach on this? I know that this is a question but it's really interesting to give us an example.

For this case the Dagger module must be dynamic so I suppose that there is 3 solutions (I think):

1. PerFragment modules something like that:

@PerFragment
@Component(dependencies = ApplicationComponent.class, modules = FragmentModule.class)
public interface FragmentComponent {
  //Exposed to sub-graphs.
  Fragment fragment();
}

@Module
public class FragmentModule {
  private final Fragment fragment;

  public FragmentModule(Fragment fragment) {
    this.fragment = fragment;
  }

  @Provides @PerFragment Fragment fragment() {
    return this.fragment;
  }
}

@PerFragment
@Component(dependencies = ApplicationComponent.class, modules = {FragmentModule.class, LoginFragmentModule.class})
public interface LoginFragmentComponent extends FragmentComponent {

  void inject(UserLoginFragment userLoginFragment);

}

@Module
public class LoginFragmentModule {

  private String username = "";
  private String password = "";


  public LoginFragmentModule(String username, String password) {
    this.username = username;
    this.password = password;
  }

  @Provides @PerFragment @Named("userLogin") UseCase provideUserLoginUseCase(
      UserRepository userRepository, ThreadExecutor threadExecutor,
      PostExecutionThread postExecutionThread) {
    return new UserLogin(username, password,userRepository, threadExecutor, postExecutionThread);
  }
}

2. Observer to get the changes and re-initialises the Activity dagger module.
3. Or to change dynamically the component into the Fragment during the action. For example I can do into the fragment this one as below! Not sure if it will work but with this one we are re-creating the component during the action. Basically this will be done in every case (for @PerFragment also)

DaggerUserComponent.builder()
        .applicationComponent(getApplicationComponent())
        .activityModule(getActivityModule())
        .userModule(new UserModule(username, pass))
        .build();

or ????

There is a problem only this because you can't use multiple scopes for example for data mappers. So we must remove scopre for datamappers for example in order to be able to seen into the both scopes! Right? Any other suggestions maybe cleaner than this one?

@android10 please when you have free time it will be nice to give us a better approach by your side.

@android10 I know that is closed this issues but I want to know if our approach is acceptable.

Currently we have multiple forms so for example I have an invite form with multiple attrs.

Let's Say I have InviteActivity InviteView InvitePresenter InviteComponent in their referral package explicitly.

In my InviteModule of dagger I have something like this:

/**
 * Dagger module that provides user related collaborators.
 */
@Module public class InviteModule {

  private String email;
  private String businessName;

  public InviteModule() {
  }

  public InviteModule(String email, String businessName) {
    this.email = email;
    this.businessName = businessName;
  }

  @Provides @PerActivity @Named("userLogin") UseCase provideInviteBusinessUseCase(InviteBusiness sendInviteBusiness) {
    return new InviteBusiness(this.email, this.businessName, UserRepository, threadExecutor,
        postExecutionThread);
  }
}

In the InviteComponent I have this

@PerActivity
@Component(dependencies = ApplicationComponent.class, modules = {
    ActivityModule.class, UserModule.class
})
public interface InviteComponent extends ActivityComponent {

  void inject(InviteBusinessFragment inviteBusinesssFragment);

  void plus(InviteModule userModule);
}

So on click of the form I am just doing this:

this.getComponent(InviteComponent.class).plus(new InviteModule(textemail, textBusinessName);

in order to use the attributes into the UseCase. Any suggestion for a different approach?

@spirosoik Does the solution example in your last comment works nice with your needs ?

@MehdiChouag It's easier to keep the abstraction as it is with buildUseCaseObservable() but you can use this. Remember that in this method you must pass a Domain model not simple parameters.

protected abstract Observable buildUseCaseObservable(Object...param);

or you can re-create the component during login

DaggerUserComponent.builder()
        .applicationComponent(getApplicationComponent())
        .activityModule(getActivityModule())
        .userModule(new UserModule(user))
        .build();

Another way is to use @PerFragment scope

I am suggesting the first solution.

@android10 @lalongooo if you have a better solution than the first one, I would love to listen.

@spirosoik For me the first solution seems to be more appropriate.

Rather using Object, we may using template for parameters, like :

public abstract class UseCase<T> {
...
protected abstract Observable buildUseCaseObservable(@Nullable T... params);

public void execute(Subscriber UseCaseSubscriber, @Nullable T... params) {
    mSubscription = buildUseCaseObservable(params).subscribeOn(mExecutionThread.getScheduler())
        .observeOn(mPostExecutionThread.getScheduler())
        .subscribe(UseCaseSubscriber);
  }
...
}

And using it like this :

public class LoginAccountUseCase extends UseCase<String> {
@Override
  protected Observable buildUseCaseObservable(String... params) {
    return mAccountRepository.login(params[0], params[1]);
  }
}

@MehdiChouag Yes of course I just send you the logic. This is depends in your case but as I said before it will be nice to use domain models to use cases, not plain params.

For example I am passing into the UseCase a UserModel which I am transforming this into User domain model or for credentials you can have a different object for this.

@spirosoik Can we avoid to create a UserModel then transforming into a User domain ?
And instead directly use the User domain, that wouldn't break dependency rules.

@MehdiChouag Yes there is a great discussion (you are in) on this subject and I will support @android10 on this that each layer must have the View Models and each layer should have its model to deal with in order to avoid coupling between layers. It's clear that you are breaking the dependency.