injecting an activity needed member

Question

I need to inject an "RxPermissions" RX Permissions lib instance to my fragment. Its my (basic) fragment class:

public class MapFragment extends Fragment {  
  //an empty ctor

  @Inject
  RxPermissions rxPermissions; //need inject.

  @Override
  public void onAttach(Context context) {
      AndroidSupportInjection.inject(this); //for injection
      super.onAttach(context);
  }

  @Override
  public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    //When i not use injection for rxPermissions -> rxPermissions = new RxPermissions(getActivity());
    if(rxPermission.isGranted(Manifest.permission.ACCESS_FINE_LOCATION)){
       ///TODO: implement isGranted logic
    }
  }
}

Here is my MapFragmentSubComponent and MapFragmentSubModule for inject into MapFragment:

@Subcomponent
public interface MapFragmentSubComponent extends AndroidInjector<MapFragment> {

    @Subcomponent.Builder
    public abstract class Builder extends AndroidInjector.Builder<MapFragment>{

  }
}


@Module(subcomponents = MapFragmentSubComponent.class)
public abstract class MapFragmentSubModule {

   @Binds
   @IntoMap
   @FragmentKey(MapFragment.class)
   abstract AndroidInjector.Factory<? extends Fragment> bindMapFragmentInjectorFactory(MapFragmentSubComponent.Builder builder);

   //Contains here my provider method for example viewmodelfactory provide.

   //I need (i think) provide rxPermissions here. but how ?

  }

And MapFragmentSubModule installed at AppComponent with @Component(modules = {MapFragmentSubmodule.class})

So how can i inject RxPermissions to fragment or other? (ex activity ?)

Update for @Jeff Bowman Jun 29 at 18:39 comment: So. I inject activity hash in MainActivity (it's work) but that's not inherited in MapFragment. Can i resolve this problem with dagger-android lib ? (Or use old fashion style dagger 2 implementation for that problem resolving? ) Here is my error msg:

    error: [Dagger/MissingBinding] [dagger.android.AndroidInjector.inject(T)]   java.lang.Integer cannot be provided without an @Inject constructor or an @Provides-annotated method.
java.lang.Integer is injected at
.ui.main.map.MapFragment.activityHash
.ui.main.map.MapFragment is injected at
dagger.android.AndroidInjector.inject(T)
component path: .component.AppComponent ? .module.BuildersModule_BindMapFragment.MapFragmentSubcomponent

So i need activityHash from MainActivityModule in MapFragment.

Answer 1

If your MapFragmentSubModule is included in an Activity subcomponent using dagger.android, then you'll have access in your MapFragmentSubModule to the specific Activity subclass that you're injecting.

@Module(subcomponents = MapFragmentSubComponent.class)
public abstract class MapFragmentSubModule {
  // ...

  // You probably want @ActivityScope; see below.
  @Provides static RxPermissions provideRxPermissions(YourActivity activity) {
    return new RxPermissions(activity);
  }
}

Note that dagger.android will only be able to inject your subclass YourActivity, not Activity itself. This is partly for consistency: Fragments can be nested inside other Fragments (such that injecting Fragment would be ambiguous if the superclass bindings were automatic). For less-ambiguous bindings, you may want @Binds Activity bindActivity(YourActivity activity).

If you don't have an Activity subcomponent, you'll need to fetch the Activity out of the Fragment, which means installing RxPermissions on the Fragment subcomponent instead.

@Subcomponent(modules = MapFragmentSubComponent.Module.class)
public interface MapFragmentSubComponent extends AndroidInjector<MapFragment> {
  @Subcomponent.Builder
  public abstract class Builder extends AndroidInjector.Builder<MapFragment> {    
  }

  @dagger.Module public abstract class Module {
    @Provides static RxPermissions provideRxPermissions(MapFragment fragment) {
      return new RxPermissions(fragment.getActivity());
    }
  }
}

That said, I assume you'll want the RxPermissions object to be consistent within the Activity, which means using an Activity-scoped subcomponent (creating one if necessary) and annotating your @Provides method with @ActivityScope or whatever you've named your activity subcomponent scope annotation.