Constructing dependencies graph asynchronously in Dagger 2

Question

This is a more theoretical question. Please let me know if I'm going in the wrong direction.

Is there any way to load some of graph dependencies asynchronously/in parallel in Dagger 2? Should it be even considered in a context of Dagger ?

My problem is mainly connected with app launch time. A lot of external dependencies like Mixpanel, Crashlytics/Fabric, Retrofit (RestAdapter) cause that the app is warming up longer than 1 second.

What helped me a lot is Lazy<> interface, but the final effect still doesn't satisfy me.

Any ideas?

Example

App has SplashActivity which depends on SplashActivityPresenter, which depends on: Mixpanel, RestAdapter and Crashlytics libraries (and a couple "smaller" objects). Each of them has .init() method which takes a lot of time (Mixpanel initialization takes about 200ms on Nexus 5, Android M. So in result it will take about 2 seconds before user sees Splash screen.

Is there any way to Construct those objects in parallel ?

Answer 1

Keep the graph creation synchronous and defer object creation until subscribed to with Rx's defer. Downstream injections can be notified via a Subject, upon the object's creation.

@Module public static class AppModule{

    @Provides @Singleton
    public Observable<A> provideA(){
        return Observable.defer(
                () -> Observable.just(new A()) 
        );
    }
}

---

public class MainActivity extends AppCompatActivity{

    @Inject Observable<A> aObservable;
    A a;
    AppComponent appComponent;

    @Override
    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);

        if(appComponent == null){ 
            appComponent = ((App) getApplication())
                .getAppComponent(); 
        }
        appComponent.inject(this);

        aObservable.subscribeOn(Schedulers.io())
                   .observeOn(AndroidSchedulers.mainThread())
                   .subscribe(new Action1<A>(){
                       @Override public void call(final A aa){
                           a = aa;
                           Log.d("MainActivity", "a = aa");
                       }
                   });
    }
}

Caveats: must manually check for object !null, or rely on the Subject acting as an eventbus, which would pass down the boolean status of the object that downstream injected objects must wait for.

Answer 2

There's nothing special about Dagger 2's object graph creation. If you want it to be done in a background thread, just call DaggerYourComponent.create() or DaggerYourComponent.Builder.build() on a background thread (use your preferred method to do this - e.g. an AsyncTask).

If you have any @Inject constructors which assume they will be run on the UI thread, then you'll have to modify those, but otherwise you shouldn't have any issues.