Apollo Config Module :

AppModule.kt

@Module(includes = [ViewModelModule::class])
class AppModule {

    @Provides
    @Singleton
    fun provideCacheStore(application: Application): DiskLruHttpCacheStore {
        val file = File(application.cacheDir.toURI())
        val size = 1024 * 1024
        return DiskLruHttpCacheStore(file, size.toLong())
    }

    @Provides
    @Singleton
    @Named("Interceptor")
    fun provideApolloClient(okHttpClient: OkHttpClient, cacheStore: DiskLruHttpCacheStore): ApolloClient {
        return ApolloClient.builder()
                .serverUrl(Constants.URL)
                .okHttpClient(okHttpClient)
                .httpCache(ApolloHttpCache(cacheStore))
                .build()
    }

    @Provides
    @Singleton
    @Named("NoInterceptor")
    fun provideApolloClientNoInterceptor(httpLoggingInterceptor: HttpLoggingInterceptor,
                                         cacheStore: DiskLruHttpCacheStore
    ): ApolloClient {
        return ApolloClient.builder()
                .serverUrl(Constants.URL)
                .okHttpClient(OkHttpClient()
                        .newBuilder()
                        .addInterceptor(httpLoggingInterceptor)
                        .build())
                .httpCache(ApolloHttpCache(cacheStore))
                .build()
    }

    @Provides
    @Singleton
    fun provideOkHttpClient(
            customInterceptor: CustomInterceptor,
            httpLoggingInterceptor: HttpLoggingInterceptor
    ): OkHttpClient {
        return OkHttpClient()
                .newBuilder()
                .connectTimeout(1, TimeUnit.MINUTES)
                .writeTimeout(1, TimeUnit.MINUTES)
                .readTimeout(1, TimeUnit.MINUTES)
                .addInterceptor(httpLoggingInterceptor)
                .addInterceptor(customInterceptor)
                .build()
    }


    @Provides
    @Singleton
    fun provideHeaderInterceptor(preferencesHelper: PreferencesHelper): CustomInterceptor {
        return CustomInterceptor(preferencesHelper)
    }

    @Provides
    @Singleton
    fun provideHttpLoggingInterceptor(): HttpLoggingInterceptor {
        val interceptor = HttpLoggingInterceptor()
        if (BuildConfig.DEBUG) {
            interceptor.level = HttpLoggingInterceptor.Level.BODY
        }
        //interceptor.level = HttpLoggingInterceptor.Level.BODY
        return interceptor
    }

    @Provides
    @Singleton
    fun provideApiHelper(appApiHelper: AppApiHelper): ApiHelper {
        return appApiHelper
    }

    @Provides
    @Singleton
    fun provideContext(application: Application): Context {
        return application
    }

    @Provides
    @Singleton
    fun provideDataManager(appDataManager: AppDataManager): DataManager {
        return appDataManager
    }

    @Provides
    fun providePreferenceName(): String {
        return Constants.PREF_NAME
    }

    @Provides
    @Singleton
    fun providePreferencesHelper(appPreferencesHelper: AppPreferencesHelper): PreferencesHelper {
        return appPreferencesHelper
    }

    @Provides
    @Singleton
    fun provideFirebaseInstance(): FirebaseInstanceId {
        return FirebaseInstanceId.getInstance()
    }

    @Provides
    fun provideScheduler(): Scheduler {
        return AppScheduler()
    }

    @Provides
    @Singleton
    fun provideResource(resourceProvider: ResourceProvider): BaseResourceProvider {
        return resourceProvider
    }

     @Provides
    @Singleton
    fun provideAppDatabase(context: Context): AppDatabase {
        return Room.databaseBuilder(context, AppDatabase::class.java, Constants.DB_NAME)
                .fallbackToDestructiveMigration()
                .allowMainThreadQueries()
                .build()
    }

    @Provides
    @Singleton
    fun provideDbHelper(appDbHelper: AppDbHelper): DbHelper {
        return appDbHelper
    }
}