Dagger 2 scope i subcomponents

Staram się, aby moja aplikacja była lepsza i Kod był łatwiejszy do utrzymania za pomocą Dagger2 wpadłem na ogólny pomysł, ale nadal nie mogę dowiedzieć się, jak zakresy są zarządzane przez Dagger2 Wstrzyknąłem sztylet do mojego projektu(brzmi zabawnie). Stworzyłem komponent ApplicationComonent i sprawdza się on doskonale w moim projekcie. Oto Mój kod.

@Singleton
@Component(modules = {
        ApplicationModule.class,
        ThreadingModule.class,
        NetworkModule.class,
        DatabaseModule.class,
        ServiceModule.class,
        ParseModule.class,
        PreferencesSessionModule.class})

public interface ApplicationComponent {
    ActivityComponent activityComponent(ActivityModule activityModule);

    void inject(BaseActivity baseActivity);

    void inject(MainAppActivity mainAppActivity);

    void inject(MyApplication application);

    void inject(BaseFragment baseFragment);

    void inject(MyService service);

    void inject(RegistrationIntentService service);
}

Tworzę swoją instancję komponentu w klasie MyApplication w ten sposób

private void initializeAndInjectComponent() {
        mApplicationComponent =
                DaggerApplicationComponent
                        .builder()
                        .threadingModule(new ThreadingModule(1))
                        .applicationModule(new ApplicationModule(this))
                        .networkModule(new NetworkModule(
                                MyService.API_SERVER_BASE_URL,
                                MyService.TIMEOUT))
                        .build();
        mApplicationComponent.inject(this);
    }

I mogę uzyskać składnik w celu wstrzyknięcia w moim Activities

    MyApplication application = MyApplication.get(this);
    application.getApplicationComponent().inject(this);

Wszystko działa doskonale.

Aby dodać każdą metodę, a także klasę modułu jest adnotowana za pomocą @Singleton scope, wszystkie moduły związane z ApplicationComponent

Teraz chcę ulepszyć zależności I widziałem wiele przykładów z niestandardowymi zakresami, takimi jak @PerActivity, @PerFragment. Mam wiele pytań, ale o to później.

Więc stworzyłem ActivityComponent

@PerActivity
@Subcomponent(
        modules = {
                NetworkServiceModule.class,
                ActivityModule.class,
                PermissionModule.class
        })
public interface ActivityComponent {
    Activity activity();

    void inject(BaseActivity baseActivity);
}

Wszystkie moduły wyglądają tak

@PerActivity
@Module
public class ActivityModule {
    private Activity mActivity;

    public ActivityModule(Activity activity) {
        this.mActivity = activity;
    }

    @Provides
    @PerActivity
    Activity provideActivity() {
        return this.mActivity;
    }
}

Mam następujące zależności w moim BaseActivity

// Dependencies from ApplicationComponent
    @Inject
    protected ApplicationSettingsManager mApplicationSettingsManager;
    @Inject
    protected ScheduledThreadPoolExecutor mPoolExecutor;
// Dependencies from ActivityComponent
    @Inject
    protected SpiceManager mSpiceManager;
    @Inject
    protected PermissionController mPermissionController;

I w mojej onCreate() metodzie Wstrzykuję w następujący sposób

    MyApplication application = MyApplication.get(this);
    application.getApplicationComponent().activityComponent(new ActivityModule(this)).inject(this);

Przed utworzeniem subkomponentu ActivityComponent było to

   MyApplication application = MyApplication.get(this);
        application.getApplicationComponent().inject(this);

Teraz mam błąd

Error:(34, 10) error: com.octo.android.robospice.SpiceManager cannot be provided without an @Inject constructor or from an @Provides- or @Produces-annotated method.
BaseActivity.mSpiceManager
[injected field of type: com.octo.android.robospice.SpiceManager mSpiceManager]

Wszystko oprócz @Singleton jest ignorowane przez Dagger 2, mam rację ? Nie rozumiem, jak zarządza się życiem komponentu ? Mam tylko jeden pomysł

1. Gdy używasz @Singleton adnotacja dagger tworzy obiekt w jakiejś puli statycznej które będą istniały podczas całego cyklu życia aplikacji i zostaną zniszczone, gdy instancja JVM (dalvik VM, ART)zostanie zniszczona.

2. Gdy używasz innych adnotacji, tylko dla Ciebie jako programisty, aby lepiej zachować kod, @PerActivity, @PerFragment to tylko niestandardowe adnotacje nic więcej. I jeśli umieścisz @PerFragment komponent w klasie aplikacji, będzie on żył tak długo, jak długo będzie żył. Mam rację ?

3. Więc rozumiem to w ten sposób, jeśli dagger znajdzie @Singleton adnotacja dodaje statyczne odniesienie do komponentu, gdy jest tworzony po raz pierwszy, a w przypadku jakiejkolwiek innej adnotacji nie zawiera odniesienia do komponentu.

Byłbym bardzo wdzięczny za każdą pomoc w problemach opisanych powyżej.

UPDATE

Dziękuję David Medenjak za świetną odpowiedź, mam dużo lepsze zrozumienie Dagger2.

Właśnie znalazłem problem, o ile używam osobnego komponentu Activity, zapomniałem o dwie linie w ApplicationComponent i zmiana inejction w moim MainActivity na ActivityComponent zamiast ApplicationComponent, więc na pewno nie może rozwiązać zależności od subkomponentu.

 void inject(BaseActivity baseActivity);

 void inject(MainAppActivity mainAppActivity);

Teraz wszystko działa idealnie, Lubię {[10] } i oddzielną architekturę.