I’ve been working hard to update my Android skills by using Dagger, Retrofit, Kotlin and architecture components. I’ve found that a great way to learn about this new world is to build upon two Google sample projects:
These demonstrate different approaches to Jetpack development. I’ve taken what I think are the best ideas from each and combined them to form a new sample project that others may find useful.
In addition, I implemented a design for canceling the underlying web service connection from Retrofit REST calls. I also introduced a means of adding intentional delays into these requests while testing.
Comparing the Samples
Let’s get into the weeds for a moment.
The Github Sample adapts Retrofit Calls into LiveData. The repositories then implement abstract methods from NetworkBoundResource that, in turn, allow the ViewModel to observe the result. In contrast, the I/O conference app relies heavily on Firebase and adds a domain layer with Use Cases to handle “discrete pieces of business logic off the UI thread”.
Dagger setup in Github Browser is contained in the di package while the larger I/O app uses scope annotations and individual Module classes packaged alongside corresponding Fragments and ViewModels.
The I/O app uses helpers, DaggerApplication, DaggerAppCompatActivity and DaggerFragment, and uses the generated binding classes to inflate layouts. Github Browser uses AutoClearedValue to ensure memory is freed when Fragments move to the back stack. Both projects use EventObserver, but Github uses a Resource class instead of I/O app’s similar Result class.
My Favorite Parts
So with that, I mixed-and-matched. I threw out the slick Retrofit Call adapter and NetworkBoundResource in favor of Use Cases. I grabbed the multiple Module files and Dagger helpers from here and the AutoClearedValues and Results from there. Then I rearranged them into a simple example with one app module and 5 top-level packages: data, di, domain, ui and util.
And, Request Cancellation!
The ability to cancel web service requests is essential. Take the example I described in “Navigation Component with a Shapeshifting Fragment“. When a user taps Login, we can disable the button and call a remote service. If they click back before the service responds, we should cancel the request at the network layer. The screen shape-shifts back and the button is re-enabled.
Canceling can be tricky. It must ripple from the Fragment to its ViewModel to the Use Case (ExecutorService) and the Repository (Retrofit2). It should happen on-demand or when exiting the Fragment.
This Demo
This app calls a service I wrote that purposefully delays its response by 3 seconds; this allows for easier testing of cancellation. The service is currently public and returns an increasing userId with each non-canceled request.
Change SignupUseCase to use getSignupDemoFast() for no delay.
Change the build variant to debug_with_delays and there will be a 3 second delay on the client-side before making the service call.
Ingredients:
- ViewModel, LiveData
- Data binding library
- Material design buttons
- Google fonts
- Build variants
- Domain layer (use case)
- Data layer (repository)
MainActivity and Navigation
The layout for MainActivity contains NavHostFragment and sets navGraph to navigation_main.xml. WelcomeFragment is the starting destination. We set up the top app bar, hook up NavController and facilitate the up-arrow by overriding onSupportNavigateUp().
|
1 2 3 4 5 6 |
// main_activity.xml <fragment android:id="@+id/navHostFrame" android:name="androidx.navigation.fragment.NavHostFragment" app:defaultNavHost="true" app:navGraph="@navigation/navigation_main" |
|
1 2 3 4 5 6 7 8 9 |
// MainActivity override fun onCreate(savedInstanceState: Bundle?) { ... setSupportActionBar(binding.toolbar) supportActionBar?.setDisplayHomeAsUpEnabled(true) setupActionBarWithNavController(this, Navigation.findNavController(this, R.id.navHostFrame)) } override fun onSupportNavigateUp() = Navigation.findNavController(this, R.id.navHostFrame).navigateUp() |
WelcomeFragment
This Fragment is pretty simple, but serves a purpose here. Click events for its “Next” button are handled by signupClicked() in its view model. The view model triggers navigation by using an observed Event—read more about the significance of the Event class. The Fragment reacts by placing itself on the back stack and then moving to SignupFragment. We’ll use this later to ensure requests made in SignupFragment are canceled when returning to this screen.
|
1 2 3 4 5 |
// WelcomeFragment override fun onActivityCreated(savedInstanceState: Bundle?) { ... viewModel.navigateToSignup.observe(this, EventObserver { view?.let { view -> Navigation.findNavController(view).navigate(R.id.signupFragment) } }) } |
|
1 2 3 4 5 6 7 8 |
// WelcomeViewModel private val _navigateToSignup: MutableLiveData<Event<Unit>> = MutableLiveData() val navigateToSignup: LiveData<Event<Unit>> get() = _navigateToSignup fun signupClicked() { _navigateToSignup.value = Event(Unit) } |
SignupViewModel
Aside from the navigation piece, SignupFragment is identical to WelcomeFragment. The fun begins in SignupViewModel. When Sign Up is clicked, doSignup() changes the LiveData to Result.Loading. This disables and enables the Sign Up and Cancel buttons. Then, UseCase.invoke() jumps into the spotlight.
The cancel button is handled by doCancelSignup(). It first attempts to cancel any pending tasks launched if the optional local delay value was specified. Then it cancels the HTTP connection using cancelCall() in CancelableCallRepository. We override onCleared() to launch these same steps if the Fragment exits.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
// SignupViewModel private val _result = MediatorLiveData<Result<String>>() val result: LiveData<Result<String>> get() = _result val resultText: LiveData<String> = Transformations.map(_result) { r -> (r as? Result.Success)?.data ?: app.resources.getString(R.string.loading) } init { _result.value = Result.Success(app.resources.getString(R.string.ready)) } fun doSignup() { _result.value = Result.Loading (signupUseCase(Unit, app.resources.getInteger(R.integer.intentional_delay_signup).toLong())).let { useCase -> _result.addSource(useCase) { serviceResult -> _result.removeSource(useCase) _result.value = Result.Success( when (serviceResult) { is Result.Success -> app.resources.getString(R.string.welcome, serviceResult.data?.userId) is Result.Error -> app.resources.getString(R.string.failed, serviceResult.exception.message) else -> "Huh?" } ) } } } fun doCancelSignup() { signupUseCase.cancel() } override fun onCleared() { doCancelSignup() } |
UseCase and DelayedScheduler
Depending on whether a delay is provided, SignupUseCase.execute() will run immediately or be scheduled via ScheduledExecutorService. In the latter case, we hold a reference for possible cancellation later.
|
1 2 3 4 5 6 7 8 9 10 |
// UseCase operator fun invoke(parameters: P, result: MutableLiveData<Result<R>>, delay: Long = 0) { ... scheduledFuture = taskScheduler.execute(delay) { execute(parameters).let { useCaseResult -> scheduledFuture = null result.postValue(Result.Success(useCaseResult)) } } } |
|
1 2 3 4 5 6 7 8 9 |
// DelayedScheduler fun execute(delay: Long = 0, task: () -> Unit): ScheduledFuture<*>? { if (delay <= 0) { executorService.execute(task) } else { scheduledFuture = executorService.schedule(task, delay, TimeUnit.MILLISECONDS) } return scheduledFuture } |
SignupUseCase and CancelableCallRepository
The execute() method of SignupUseCase uses AuthRepository to make our service call. We provide an ID to identify the Retrofit2 Call; it is stored in a map managed by our super Repository class, CancelableCallRepository.
|
1 2 3 4 5 6 7 8 9 10 11 |
// SignupUseCase private val authCallId = UUID.randomUUID()!! override fun execute(parameters: Unit): User? { return repository.getSignupDemoSlow(authCallId) } override fun cancel() { super.cancel() repository.cancelCall(authCallId) } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
// CancelableCallRepository companion object { private val calls = mutableMapOf<UUID, Call<*>>() } fun doCall(id: UUID, call: Call<T>): Any? { calls[id] = call val response = call.execute() calls.remove(id) return (ApiResponse.create(response) as? ApiSuccessResponse)?.body } fun cancelCall(id: UUID?) { calls[id]?.cancel() } |
Retrofit and OkHttpClient
In AppModule, we use addConverterFactory() to allow the JSON service response to be painlessly deserialization via Gson into an instance of User. As demonstrated here, it’s also possible to make Retrofit pause during each request using an OkHttp Interceptor.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// AppModule val client = OkHttpClient.Builder() .addInterceptor { chain -> SystemClock.sleep(2000) chain.proceed(chain.request()) } .sslSocketFactory(context.socketFactory, trustManager) .build() return Retrofit.Builder() .baseUrl("http://example.com/") .addConverterFactory(GsonConverterFactory.create()) .callFactory(client) .build() .create(ApiInterface::class.java) |
Done!
Disclaimer: I haven’t yet used these techniques in production, nor have I done analysis for leaks or performance.
The full source to this project can be found on GitHub.
If you found this useful or have improvements, please let me know below.
Check back for updates.