How do I request injection in Android Fragments and Services?

Question

I'm following this tutorial to add Dagger 2 to my Android project.

After doing setup and creating the modules and components I can add the dependencies in an Activity like this:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_account);
    ButterKnife.bind(this);
    ((AppController) getApplication()).getNetComponent().inject(this);
}

I am struggling in how to inject dependencies in a Fragment and IntentService?

public class FragmentBrandList extends ListFragment {
}

In this class which @Override method should I request injection in and what will be the code for this?

You need to declare a Module for each Activity, Fragment, Service, and so on — Chisko, Dec 23 '16 at 15:21
I want to inject same getNetComponent() in fragment, whatever i have injected in activity. — Devesh Agrawal, Dec 23 '16 at 15:23
Let's clarify this question a bit. You are asking which lifecycle method to inject inside for Fragments and Sercices right? Like in Activity you call inject inside `onCreate()` — David Rawson, Dec 23 '16 at 19:20
@DeveshAgrawal it would be nice to at least acknowledge any answer. Looking at you questions history, one can quickly notice you are not thankful enough (if even a bit) to the community. — Chisko, Dec 23 '16 at 21:25

score 22 · Answer 1 · edited Feb 09 '19 at 17:04

In this class which @Override method i should use and what will be the code to add dependency in fragment?

The correct place to call injection inside a Fragment is onAttach(Context context). This is stated in the where to inject section of the Dagger 2 user guide here

@Override
public void onAttach(Context context) {
    ((AppController) context.getApplicationContext()).getNetComponent().inject(this);
    super.onAttach(context);
}

The correct place to call injection inside a Service is onCreate()

@Override 
public void onCreate() {
    ((AppController) getApplication()).getNetComponent().inject(this);
    super.onCreate();

}

Note that in both cases the request for injection comes before the call to super.onCreate(). The Dagger user guide explains it like this:

It is crucial to call AndroidInjection.inject() before super.onCreate() in an Activity, since the call to super attaches Fragments from the previous activity instance during configuration change, which in turn injects the Fragments. In order for the Fragment injection to succeed, the Activity must already be injected. For users of ErrorProne, it is a compiler error to call AndroidInjection.inject() after super.onCreate().

In other words:

The Activity super.onCreate() call re-attaches Fragments from a previous instance
This super call in cause Fragments to be re-injected (since Fragments are injected in onAttach)
Fragments should be injected after their Activity is injected, therefore request injection in your Activity before calling super.onCreate().

You can always check where to inject by looking at the relevant source code for the com.google.dagger:dagger-android classes like DaggerFragment and DaggerService. See the GitHub repo here

For your specific example, please make sure you have added the new injection sites to the NetComponent:

void inject(FragmentBrandList frag);

void inject(BrandListService service);

The "where to inject" link you posted indicates that inject must be called as early as possible before the super., and comment on that? — MoGa, Feb 14 '18 at 20:20
@MoGa hey! thanks for pointing the mistake out - I updated my answer — David Rawson, Feb 14 '18 at 23:17
@user3294126 this was in the OP's code so you'll have to ask him/her — David Rawson, Mar 21 '18 at 21:11

write2sv · Answer 2 · 2016-12-23T19:14:19.300

Step 1: Create your ApplicationModule

@Module
public class ApplicationModule {

    private final DIApplication application;

    public ApplicationModule(DIApplication application) {
        this.application = application;
    }

    @Provides @Singleton
    public DIApplication provideApplication() {
        return application;
    }

    @Provides @Singleton
    public DogModel provideDogModel() {
        return new DogModelImpl("Scooby-doo");
    }

}

Step 2: Create your ApplicationComponent:

@Singleton
@Component(modules = {ApplicationModule.class})
public interface ApplicationComponent {
    void inject(DIApplication application);

    void inject(BaseActivity activity);
    void inject(BaseFragment fragment);

    void inject(DogSyncService service);
}

Step 3: Create a DI Class:

public class DependencyInjector {

    private static ApplicationComponent applicationComponent;

    public static void initialize(DIApplication diApplication) {
        applicationComponent = DaggerApplicationComponent.builder()
                .applicationModule(new ApplicationModule(diApplication))
                .build();
    }

    public static ApplicationComponent applicationComponent() {
        return applicationComponent;
    }

    private DependencyInjector(){}
}

Final Step: Inject anywhere using:

DependencyInjector.applicationComponent()

Your question inspired me to create a Demo project that shows Activity, Fragment and Service injection using Dagger2. Here is the git: https://github.com/write2sv/AndroidDIDagger2/tree/master/app/src/main/java/work/shaggy/didemo

score 1 · Answer 3 · answered Apr 28 '17 at 10:00

1

I did it using ((AppController) getActivity().getApplication()).getNetComponent().inject(this);

in Fragment.onCreate() method.

answered Apr 28 '17 at 10:00

Rumid

1,627
2
21
39

what is AppController? – user3294126 Mar 21 '18 at 21:08

score 1 · Answer 4 · answered Feb 02 '19 at 21:10

1

((MyApp) context.getApplicationContext()).getApplicationComponent().inject(MyFragment.this);

I added this in onAttach(Context context) method of the fragment.

answered Feb 02 '19 at 21:10

Adi

4,149
4
25
41

EpicPandaForce · Answer 5 · 2016-12-23T21:19:33.413

0

You really just need to include the injector method for whatever you want to inject.

@Singleton
@Component
public interface AppComponent {
    void inject(MainActivity activity);
    void inject(FragmentBrandList fragmentBrandList);
}

edited Dec 23 '16 at 21:19

answered Dec 23 '16 at 15:55

EpicPandaForce

79,669
27
256
428

score -1 · Answer 6 · edited Apr 08 '19 at 11:27

You can use autodagger2 to avoid having to write all that boilerplate. I use this architecture quite often:

build.gradle

apt 'com.github.lukaspili.autodagger2:autodagger2-compiler:1.1'
compile 'com.github.lukaspili.autodagger2:autodagger2:1.1'

YourApp.java

@AutoComponent( modules = YourApp.YourAppModule.class )
public class YourApp extends Application {

    private static YourApp instance;
    private YourAppComponent component;

    public YourAppComponent getComponent() {
        return this.component;
    }

    @Override
    public void onCreate() {
        super.onCreate();

        setupComponent();
    }

    private void setupComponent() {
        component = DaggerYourAppComponent.builder()
                .yourAppModule(new YourAppModule(instance))
                .build();
    }


    @dagger.Module
    public static class YourAppModule {
        private YourApp app;

        YourAppModule(YourAppApp application) {
            this.app = application;
        }

        @Provides @AutoExpose(YourApp.class)
        Application provideApplication() {
            return app;
        }

        @Provides @AutoExpose(PoswalaApp.class)
        Context provideContext() {
            return app;
        }

        @Provides @AutoExpose(YourApp.class)
        Retrofit provideApiAdapter() {
            return ApiService.getServiceInstance();
        }
    }
}

YourActivity.java

@AutoComponent(
    dependencies = YourApp.class,
    modules = YourActivity.YourActivityModule.class
)

public class YourActivity extends BaseActivity implements YourActivityView {

    private YourActivityComponent component;
    @Inject MyPresenter presenter

    // This is an abstract method from BaseActivity
    @Override
    protected void setupComponent(YourAppComponent appComponent) {
        component = DaggerYourActivityComponent.builder()
                .yourAppComponent(((YourApp) getApplication()).getComponent())
                .yourActivityModule(new YourctivityModule(this))
                .build();
    }

    @Override
    protected MyPresenter getPresenter() {
        return presenter;
    }


    @dagger.Module
    public static class YourActivityModule {

        private YourActivityView view;

        YourActivityModule(YourActivityView view) {
            this.view = view;
        }


        @Provides @AutoExpose(YourActivity.class)
        YourActivityView provideView() {
            return view;
        }

        // Your other dependencies
    }
}

Quick explanation:

Your app's module will have to a "universal" dependency, but this way you can achieve using several modules for a class. You just need to customize the

@AutoComponent(
    dependencies = YourApp.class,
    modules = { YourActivity.YourActivityModule.class, YourFragment.YourFragmentModule.class }
)

block. You can add as many modules as you like using that syntax.

Hope this helps you

How do I request injection in Android Fragments and Services?

6 Answers6