Null object for @Inject field

Question

I'm following an MVC pattern for my Android application and have ran into this issue a few times and have had to work around it. When my application is able to create an injected object using the @Inject annotation on a field, that objects @Inject fields are null, usually causing a crash. For instance, I have controller classes that will handle logic and flow. Any Fragments/Activities will callback to their controller to notify of a user interaction / state change. However, the injected instance of Controller is usually null.

I'll give a simple example to illustrate. Below, the Controller is having an injected activity created, then using that to start flow by adding a Fragment. That dependency is handled but the Activities dependency on the controller is not (i.e. null).

Simple Controller class to handle business logic and flow:

public class SomeController {
    @Inject
    SomeActivity someActivity;

    private SomeComponent component;

    private final Application app;

    @Inject
    public SomeController(Application app) {
        this.app = app;
    }

    private void startActivity() {
        component = Dagger_SomeComponent().builder()
             .someModule(app)
             .build();

        someActivity.getFragmentManager().beginTransaction().
            .add(R.id.content, SomeFragment.class, null)
            .commit();
    }

    public void activityStarted() {
        //callback when Activity is ready...
    }
}

The simple activity that handles user interaction and calls back to the controller to perform some business logic:

public class SomeActivity extends Activity {

    @Inject
    SomeController controller;

    private void controllerCallback() {
          //notify controller of something here...
    }
}

Simple Module class for injecting objects into graph:

@Module
public class SomeModule {

    private Application app;

    public SomeModule(Application app) {
         this.app = app;
    }

    @Provides
    @Singleton
    SomeController provideSomeController( return new SomeController(app); )

    @Provides
    SomeActivity provideSomeActivity( return new SomeActivity();)
}

Simple Component class for providing methods to consume objects:

@Component
public interface SomeComponent {

    void addController(SomeController controller);

    SomeController controller();

    SomeActivity activity();
}

Answer 1

I believe a few things are missed in your example:

1) Dagger2 Component is a bridge between some modules that provides dependencies and some injection points that "consumes" dependencies. Your Component should have at least one linked module and annotation should looks like:

@Component(modules = SomeModule.class)

2) SomeActivity instantiation in the module with 'new' operator has no sense. Ok, you can create the Activity object, but who will manage it's state, call it's lifecycle methods etc? If you really want to pass a reference of existing Activity as dependency - it's possible, but in a different way. For example, create application level module(s) & component, and a separate activity level module & component, passing existing Activity reference as module constructor argument.

3) Activities are created by Android framework, therefore you should use field injection in activities. Add to your Component a line like:

void inject(SomeActivity activity);

And place the code that creates a Component into Activity. For example to onCreate():

SomeComponent component = Dagger_SomeComponent().builder()
         .someModule(getApplication())
         .build()
         .inject(this);

4) Please try to avoid @Singleton annotations at the beginning. By first make sure that all dependencies you're declared are satisfied and you haven't nulls anymore. Next you can check some existing Dagger2 open source projects to make right scope annotations.

Answer 2

I ran into this problem, and resolved it using this accepted answer.

TLDR: I had to add inject() methods in the Component for exact types, not just inject(SomeSuperclass foo)

Basically, I had an Activity that needed injecting:

class SubActivity extends BaseActivity {
    @Inject Type someVar;

    @Override
    protected void onCreate(Bundle bundle) {
       getComponent().inject(this);
    }
}

But my component looked like:

@Component
public interface MyComponent {
    void inject(BaseActivity activity); // This allows SubActivity to compile but messes up injection
}

Solution: Add inject methods for the exact subtype:

@Component
public interface MyComponent {
    void inject(BaseActivity activity);
    void inject(SubActivity activity); //<-- This solved it
}

Answer 3

In my case, depends-on="bean1" was within property-placeholder in application-context was causing the issue. I used @PostConstruct to make injection work.