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

Question

我有 F1 和 F2 类的对象，我想将它们注入到保留的 Fragment 中。我还有一个 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);
}

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

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

我也尝试在 Fragment 中注入对 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 和F2 依赖项；但它们是 Fragment 范围的依赖项，因此它们应该遵循 Fragment 生命周期而不是 Activity 的。

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

Answer 1

考虑到您保留的片段的寿命比您的活动长，我敢打赌，正确的做法是让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();
    }
}

和

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;
    }
}

编辑：

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();
    }
}