Android 上的 Dagger 2：在 Activity 和保留的 Fragment 中注入相同的依赖项

我有类的对象F1 and F2我想注入保留的片段。我也有一个类对象A这取决于 Activity，我希望将其注入到该 Activity 以及附加到该 Activity 的片段管理器的保留片段中。我写了下面的代码。首先，Activity依赖的模块：

@Module
public class MainActivityModule {
    private Activity mActivity;

    public MainActivityModule(Activity activity) {
        mActivity = activity;
    }

    @Provides
    @ActivityScope
    public A provideA() {
        return new A(mActivity);
    }
}

然后，相应的组件，必须使A对象可用于其依赖组件：

@ActivityScope
@Component(modules = {MainActivityModule.class})
public interface MainActivityComponent {
    void inject(MainActivity activity);

    // make the A object available to dependent components
    A getA();
}

我还写了Fragment相关的模块：

@Module
public class FragmentModule {
    @Provides
    @FragmentScope
    public F1 provideF1() {
        return new F1();
    }

    @Provides
    @FragmentScope
    public F2 provideF2() {
        return new F2();
    }
}

及其相应的组件：

@FragmentScope
@Component(modules = {FragmentModule.class}, dependencies = {MainActivityComponent.class})
public interface FragmentComponent {
    void inject(MyFragment presenter);
}

最后，我注入依赖A在 Activity 中，我还需要对其调用特定的生命周期方法。 Activity还提供了获取组件的方法，以便Fragment在构建自己的组件时能够使用它：

// in MainActivity.onCreate
mActivityComponent = DaggerMainActivityComponent.builder()
        .mainActivityModule(new MainActivityModule(this))
        .build();
mActivityComponent.inject(this);
mA.onCreate();

我尝试注入依赖项A, F1, F2也在片段中：

// in MyFragment.onCreate
FragmentComponent component = DaggerFragmentComponent.builder()
        .fragmentModule(new FragmentModule())
        .mainActivityComponent(((MainActivity) getActivity()).getComponent())
        .build();
component.inject(this);

然而，由于 Fragment 被保留，当 Activity 被系统销毁并重新创建以响应配置更改（例如设备旋转）时，Fragment 会保留对旧活动的引用A实例，而新的 Activity 已正确重新创建了一个新的A实例来配合它。为了解决这个问题，我必须创建FragmentComponent并注入依赖项MyFragment.onActivityCreated而不是MyFragment.onCreate。另一方面，这意味着F1 and F2每次销毁并重新创建 Activity 时都会重新创建依赖项；但它们是 Fragment 范围内的依赖项，因此它们应该遵循 Fragment 生命周期而不是 Activity 的生命周期。

因此，我的问题如下：是否可以在保留的片段中注入不同范围的依赖项？理想情况下，F1 and F2依赖项应该被注入MyFragment.onCreate, while A依赖项应该注入MyFragment.onActivityCreated。我尝试使用两个不同的组件，但似乎无法执行部分注入。目前，我最终添加了片段的显式重新分配A依赖于MyFragment.onActivityCreated，但这并不是真正的注入，你知道。这可以用更好的方式来完成吗？

考虑到您保留的片段比您的活动寿命更长，我敢打赌，执行此操作的正确方法是使FragmentScope包含ActivityScope，反之则不然。

这意味着你的 FragmentComponent 会有

@FragmentScope
@Component(modules = {FragmentModule.class})
public interface FragmentComponent {
    void inject(MyFragment presenter);
}

你的 Activity 组件将会有

@ActivityScope
@Component(dependencies = {FragmentComponent.class}, modules = {MainActivityModule.class})
public interface MainActivityComponent extends FragmentComponent { //provision methods
    void inject(MainActivity activity);

    // make the A object available to dependent components
    A getA();
}

如果您的Fragment注入的类不依赖 Activity 模块作为依赖项。

这可以通过类似的事情来完成

public class MainActivity extends AppCompatActivity {

    private MainActivityComponent mainActivityComponent;

    private MyFragment myFragment;

    @Override
    public void onCreate(Bundle saveInstanceState) {
         super.onCreate(saveInstanceState);
         setContentView(R.layout.activity_main);

         if(saveInstanceState == null) { // first run
             myFragment = new MyFragment(); //headless retained fragment
             getSupportFragmentManager()
                .beginTransaction()
                .add(myFragment, MyFragment.class.getName()) //TAG
                .commit();
         } else {
             myFragment = (MyFragment)(getSupportFragmentManager()
                               .findFragmentByTag(MyFragment.class.getName()));
         }
    }

    @Override
    public void onPostCreate() {
         mainActivityComponent = DaggerMainActivityComponent.builder()
              .fragmentComponent(myFragment.getComponent())
              .build();
    }
}

And

public class MyFragment extends Fragment {
    public MyFragment() {
         this.setRetainInstance(true);
    }

    private FragmentComponent fragmentComponent;

    @Override
    public void onCreate(Bundle saveInstanceState) {
        super.onCreate(saveInstanceState);
        this.fragmentComponent = DaggerFragmentComponent.create();
    }

    public FragmentComponent getFragmentComponent() {
        return fragmentComponent;
    }
}

EDIT:

public class MyFragment extends Fragment {
    public MyFragment() {
         this.setRetainInstance(true);
         this.fragmentComponent = DaggerFragmentComponent.create();
    }

    private FragmentComponent fragmentComponent;

    public FragmentComponent getFragmentComponent() {
        return fragmentComponent;
    }
}

public class MainActivity extends AppCompatActivity {

    private MainActivityComponent mainActivityComponent;

    private MyFragment myFragment;

    @Inject
    A mA;

    @Override
    public void onCreate(Bundle saveInstanceState) {
         super.onCreate(saveInstanceState);
         setContentView(R.layout.activity_main);

         if(saveInstanceState == null) { // first run
             myFragment = new MyFragment(); //headless retained fragment
             getSupportFragmentManager()
                .beginTransaction()
                .add(myFragment, MyFragment.class.getName()) //TAG
                .commit();
         } else {
             myFragment = (MyFragment)(getSupportFragmentManager().findFragmentByTag(MyFragment.class.getName()));
         }
         mainActivityComponent = DaggerMainActivityComponent.builder()
              .fragmentComponent(myFragment.getComponent())
              .build();
         mainActivityComponent.inject(this);
         mA.onCreate();
    }
}