Dispatch

val presenter=MyPresenter(MainCoroutineScope())classMyPresenter @Inject constructor(/**  * Defaults to the Main dispatcher*/valcoroutineScope:MainCoroutineScope) {funloopSomething()= coroutineScope.launchDefault {  }suspendfunupdateSomething()= withMainImmediate {  }}

classMyTest {  @Testfun`no setting the main dispatcher`()= runBlockingProvidedTest {// automatically use TestCoroutineDispatcher for every dispatcher typeval presenter=MyPresenter(coroutineScope=this)// this call would normally crash due to the main looper    presenter.updateSomething()  }}

Contents

Injecting dispatchers

interfaceDispatcherProvider :CoroutineContext.Element {overrideval key:CoroutineContext.Key<*> get()=Keyval default:CoroutineDispatcherval io:CoroutineDispatcherval main:CoroutineDispatcherval mainImmediate:CoroutineDispatcherval unconfined:CoroutineDispatchercompanionobject Key : CoroutineContext.Key<DispatcherProvider>}val someCoroutineScope=CoroutineScope(Job()+Dispatchers.Main+DispatcherProvider())

Types and Factories

val mainScope=MainCoroutineScope()val someUIClass=SomeUIClass(mainScope)classSomeUIClass(valcoroutineScope:MainCoroutineScope) {funfoo()= coroutineScope.launch {// because of the dependency type,// we're guaranteed to be on the main dispatcher even though we didn't specify it  }}

Referencing dispatchers

Builder Extensions

classMyClass(valcoroutineScope:IOCoroutineScope) {funaccessMainThread()= coroutineScope.launchMain {// we're now on the "main" thread as defined by the interface  }}

Android Lifecycle

importdispatch.android.lifecycle.*importdispatch.core.*importkotlinx.coroutines.flow.*classMyActivity :Activity() {init {    dispatchLifecycleScope.launchOnCreate {          viewModel.someFlow.collect {            channel.send("$it")          }        }  }}

Android Espresso

classIdlingCoroutineScopeRuleWithLifecycleSample {val customDispatcherProvider=IdlingDispatcherProvider()  @JvmField  @Ruleval idlingRule=IdlingDispatcherProviderRule {IdlingDispatcherProvider(customDispatcherProvider)  }/**  * If you don't provide CoroutineScopes to your lifecycle components via a dependency injection framework,  * you need to use the `dispatch-android-lifecycle-extensions` and `dispatch-android-viewmodel` artifacts  * to ensure that the same `IdlingDispatcherProvider` is used.*/  @BeforefunsetUp() {LifecycleScopeFactory.set {MainImmediateCoroutineScope(customDispatcherProvider)    }ViewModelScopeFactory.set {MainImmediateCoroutineScope(customDispatcherProvider)    }  }  @TestfuntestThings()= runBlocking {// Now any CoroutineScope which uses the DispatcherProvider// in TestAppComponent will sync its "idle" state with Espresso  }}

Android ViewModel

importdispatch.android.viewmodel.*importkotlinx.coroutines.flow.*importtimber.log.*classMyViewModel :CoroutineViewModel() {init {MyRepository.someFlow.onEach {Timber.d("$it")    }.launchIn(viewModelScope)  }}

Testing

classTestDispatcherProvider(overridevaldefault:CoroutineDispatcher =TestCoroutineDispatcher(),overridevalio:CoroutineDispatcher =TestCoroutineDispatcher(),overridevalmain:CoroutineDispatcher =TestCoroutineDispatcher(),overridevalmainImmediate:CoroutineDispatcher =TestCoroutineDispatcher(),overridevalunconfined:CoroutineDispatcher =TestCoroutineDispatcher()) : DispatcherProvider

val testScope=TestProvidedCoroutineScope()val someUIClass=SomeUIClass(testScope)classSomeUIClass(valcoroutineScope:MainCoroutineScope) {funfoo()= coroutineScope.launch {// ...  }}

classSubject {// this would normally be a hard-coded reference to Dispatchers.MainsuspendfunsayHello()= withMain {  }}@Testfun`sayHello should say hello`()= runBlockingProvided {val subject=SomeClass(this)// uses "main" TestCoroutineDispatcher safely with no additional setup  subject.getSomeData() shouldPrint"hello"}

Modules

Full Gradle Config

repositories {  mavenCentral()}dependencies {/*  production code*/// core coroutines  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.0")  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.0")// a BOM ensures that all artifacts used from the library are of the same version  implementation(platform("com.rickbusarow.dispatch:dispatch-bom:1.0.0-beta10"))// everything provides :core via "api", so you only need this if you have no other "implementation" dispatch artifacts  implementation("com.rickbusarow.dispatch:dispatch-core")// LifecycleCoroutineScope for Android Fragments, Activities, etc.  implementation("com.rickbusarow.dispatch:dispatch-android-lifecycle")// lifecycleScope extension function with a settable factory.  Use this if you don't DI your CoroutineScopes// This provides :dispatch-android-lifecycle via "api", so you don't need to declare both  implementation("com.rickbusarow.dispatch:dispatch-android-lifecycle-extensions")// ViewModelScope for Android ViewModels  implementation("com.rickbusarow.dispatch:dispatch-android-viewmodel")/*  jvm testing*/// core coroutines-test  testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.5.0")// you only need this if you don't have the -junit4 or -junit5 artifacts  testImplementation("com.rickbusarow.dispatch:dispatch-test")// CoroutineTestRule and :dispatch-test// This provides :dispatch-test via "api", so you don't need to declare both// This can be used at the same time as :dispatch-test-junit5  testImplementation("com.rickbusarow.dispatch:dispatch-test-junit4")// CoroutineTest, CoroutineTestExtension, and :dispatch-test// This provides :dispatch-test via "api", so you don't need to declare both// This can be used at the same time as :dispatch-test-junit4  testImplementation("com.rickbusarow.dispatch:dispatch-test-junit5")/*  Android testing*/// core android  androidTestImplementation("androidx.test:runner:1.3.0")  androidTestImplementation("androidx.test.espresso:espresso-core:3.3.0")// IdlingDispatcher, IdlingDispatcherProvider, and IdlingCoroutineScope  androidTestImplementation("com.rickbusarow.dispatch:dispatch-android-espresso")}

License

Copyright (C) 2021 Rick BusarowLicensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License at     http://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.