Building an Android Instant App with Application Component from Dagger

Question

I'm currently experimenting with InstantApps and would like to include dagger into my project.

I'm facing an issue setting up an application AppComponent. My application component includes all the feature dagger modules of my app.

I basically have:

One Base app module containing my Application class
Multiple features with each a dagger Module per Activity, all with Base as a dependency.
One app module and instant module both importing all the features and the base app module.

I'm trying to figure out the setup before adding the Instant App module.

From InstantApps documentation and project examples. It seems like the Application class needs to be in Base. From the Dagger documentation, to setup dagger:

 DaggerYourAppComponent.create().inject(this);

Should be included in your application class. However, this seems to be impossible as the AppComponent needs to reference all the feature dagger modules.

My questions are:

Where should I add my AppComponent dagger module?
Should I keep my application in the app module and not in Base?
Any GitHub repo or documentation around Dagger with Instant Apps?

Thank you

From this [InstantApps Compatible Libraries](https://developer.android.com/topic/instant-apps/prepare.html#identify_tested_compatible_libraries) link, maybe Dagger isn't just supported yet... — Quentin Colle, Jul 28 '17 at 18:31
That link is meant for only Google libraries, not 3rd-party. — TWL, Jul 31 '17 at 15:28
can you check this url https://github.com/ragdroid/instant-app-dagger might it help you. — Prags, Jan 31 '18 at 07:37

score 14 · Answer 1 · answered Jul 29 '17 at 05:20

14

Dagger2 is very much supported with Instant apps. You can create Component classes for each feature module and a corresponding Dagger provider class to expose the component class instance for each feature module.
Each module component class can declare inject methods for the classes contained only in that feature module.
In addition you can also have a Application component class in the base module for application wide injection.
The application component class can be instantiated in the Application class included in the base module and exposed to other feature modules via static method in the application class.

Here is a sample code of Dagger2 injection with Instant apps to make things clearer. https://github.com/willowtreeapps/android-instant-apps-demo

answered Jul 29 '17 at 05:20

Vishy

548
7
17

Thank you for this @Vishy. I think you are right, I need one component per feature. However, I'm still looking for a sample that uses the android dagger support and with the `AndroidInjection.inject(MyActivity.this)` and AndroidInjector from [here](https://google.github.io/dagger/android.html). Any plan on updating your sample? – Quentin Colle Dec 11 '17 at 20:00
To be more specific, at step 3 of the [tutorial](https://google.github.io/dagger/android.html#injecting-activity-objects): `@Component(modules = {..., YourActivityModule.class}) interface YourApplicationComponent {}` This step isn't doable because my application component has no visibility on the `ActivityModule` as it's in a feature module. – Quentin Colle Dec 11 '17 at 22:36
@QuentinColle Did you find any samples for AndroidInjection.inject(this)?. I got stuck while injecting activity in feature module. Please suggest. – chain Apr 18 '18 at 09:17

score 3 · Answer 2 · answered Feb 17 '18 at 20:09

I wrote an article about this with many details: Dagger2 for Modular Architecture, but following the short answer.

You have to use Dagger2 in a different way. Instead of using a module or subcomponent for each feature module, you need to use a component with a dependency to the base AppComponent.

In a single module we are usually do something like this:

@Singleton
@Component(modules = arrayOf(NetworkModule::class, RepositoryModule::class, 
                     SubcomponentModule::class))
interface ApplicationComponent : AndroidInjector<MyApplication> {
  val userRepository: UserRepository
  val apiService: ApiService
}

@Module
object NetworkModule {
  @Provides
  @Singleton
  @JvmStatic
  fun provideApiService(okHttp: OkHttp): ApiService {
    return ApiSerive(okHttp)
  }
 }

But as you said you don't have access to SubComponentModule that could be in another module or reference dagger modules in another feature module.

You can just create a new dagger module in a feature module depending on ApplicationComponent like this:

@Browser
@Component(modules = [(BrowserModule::class)],
      dependencies = [(AppComponent::class)])
interface BrowserComponent : AndroidInjector<AppCompatActivity> {
  @Component.Builder
  abstract class Builder: AndroidInjector.Builder<AppCompatActivity>(){
    /**
    *  explicity declare to Dagger2
    * that this builder will accept an AppComponent instance
    **/
    abstract fun plus(component: AppComponent): Builder
  }
}

And the corresponding feature activity will build the component:

class BrowserActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    DaggerBrowserComponent
        .builder()
        /**
         * we have to provide an instance of the AppComponent or
         * any other dependency for this component
         **/
        .plus((application as MyApplication).component)
        .build()
        .inject(this)
  }
}

Building an Android Instant App with Application Component from Dagger

2 Answers2

Linked