Injecting Dependencies From Base Class

In Dagger 1, you could call inject from a base class and have all dependencies satisfied for subclasses:

class BaseActivity extends Activity {
  @Inject Foo foo;

  public void onCreate(Bundle savedInstanceState) {
    objectGraph().inject(this);
  }
}

class MainActivity extends BaseActivity {
  @Inject Bar bar;

  @Override void onCreate(Bundle savedInstanceState) {
    super.onCreate();
    // both foo and bar will be available here
  }
}

This has changes in Dagger 2; injecting from a base class will only satisfy the base class’s dependencies, not it’s subclasses’s.

class BaseActivity extends Activity {
  @Inject Foo foo;

  public void onCreate(Bundle savedInstanceState) {
    component().inject(this);
  }
}

class MainActivity extends BaseActivity {
  @Inject Bar bar;

  @Override void onCreate(Bundle savedInstanceState) {
    super.onCreate();
    // only foo is available here, not bar
  }
}

Is there a recommended pattern for injecting dependencies from a base class, rather than calling inject in each of the subclasses?

[gk5885]

Here’s how members injection methods work:

1. You can make a members injection method for any type that has @Inject anywhere in its class hierarchy. If it doesn’t, you’ll get an error.
2. All @Injected members in the entire type hierarchy will be injected: the argument type and all supertypes
3. No members will be @Injected for subtypes of the argument type.

So, given the following:

final class Dep {
  @Inject Dep() {}
}

class A {
  @Inject Dep a;
}

class B extends A {
  @Inject Dep b;
}

class C extends B {
  @Inject Dep c;
}

@Component
interface TestComponent {
  B injectB(B instance);
}

The following test will pass:

TestComponent component = Dagger_TestComponent.create();
C instance = component.injectB(new C());
assertThat(instance.a).isNotNull();
assertThat(instance.b).isNotNull();
assertThat(instance.c).isNull();

[mcfongtw]

Tried the example posted by @JakeWharton, and member in SubClass was not injected. However, as I explore more in the generated code, that could possibly be done via the following:

abstract class BaseThing {
    @Inject
    String foo;

    public BaseThing() {
        this(DaggerBaseComponent.create());
    }

    public BaseThing(BaseComponent component) {
        component.inject(this);
    }
}
class RealThing extends BaseThing {
    @Inject CharSequence bar;

    public RealThing() {
        this(DaggerBaseComponent.create());
    }

    public RealThing(BaseComponent component) {
        component.inject(this);
    }
}

@Module
class BaseModule {
    @Provides
    String provideString() { return "String!"; }
    @Provides CharSequence provideCharSequence() { return "CharSeq!"; }
}

@Component(modules = BaseModule.class)
interface BaseComponent {
    void inject(BaseThing baseThing);
    void inject(RealThing realThing);
}

public class BaseExample {
    public static void main(String... args) {
        RealThing realThing = new RealThing();

        System.out.println("String? => " + realThing.foo);
        System.out.println("CharSeq? => " + realThing.bar);
    }
}

This way, bar is injected properly.