1. Simple ItemDecoration
2. Custom ItemDecoration
   1. ItemDecoration based on item position
   2. ItemDecoration without last item
   3. ItemDecoration base on item view type

1. Simple ItemDecoration : DividerItemDecoration

The main use case can be achieved using DividerItemDecoration provided by Android.

DividerItemDecoration(Context context, int orientation)

It creates a divider RecyclerView.ItemDecoration that can be used with a LinearLayoutManager.
@param context […] will be used to access resources.
@param orientation […] should be #HORIZONTAL or #VERTICAL.

What you need is to set the correct orientation, then provide a drawable used to split each item.

Goods

• 4 lines of code
• Provided by Android
• Simple to use

Bads

• As named : limited usage to divide with space or line
• Limited to “infinity” scrolling use case : decoration will be drawn for each item, which means also the last one. Most of the time, we don’t want this.

2. Custom ItemDecoration

For better control and more advanced things we’ll extend RecyclerView.ItemDecoration.

3 methods are available :
- getItemOffsets used to determine spacing between items.
- onDraw used to decorate space between items.
- onDrawOver is same that onDraw but after item itself is drawn.

📖 See official doc : getItemOffsets, onDraw, onDrawOver

🔎 Please note following examples concern #Horizontal use cases. We can do same for #Vertical ones.

2.1. Decoration based on Item POSITION

Simple example to begin with: let’s decorate items on odd adapter position.

Main instruction here is parent.getChildAdapterPosition(view).

It Returns the adapter position that the given child view corresponds to. See complete doc.

⚠️ Not to be confused with the parent’s children positions (parent.children are items displayed on screen).

⚠️ Be careful not to miss RecyclerView.NO_POSITION case : getChildAdapterPosition could return -1.

2.2. Remove last item decoration

This is the most common use case you guys are asking on stackoverflow. It’s a special case of custom ItemDecoration based on items’ adapter position.

Exclude last item if(childAdapterPosition == adapter.itemCount-1).

⚠️ parent.adapter is nullable

🔎 Note that in almost cases, you probably only need spacing between your items (last one excluded). No need to override onDraw method, setting the correct Rect size in getItemsOffsets method is enough.

2.3. Decoration based on item view Type

For this example we have 2 item types illustrated in black and grey. We decorate items with blue and red Drawables depending on item View type (declared in Adapter).

Main instruction here is adapter.getItemViewType(childAdapterPosition). We need to override getItemViewType method in our Adapter.

It returns the view type of the item at position for the purposes of view recycling.[…] Consider using id resources to uniquely identify item view types.

See getItemViewType official doc.

Once you’re able to identify your item View type, you can put the correct spacing, and decorate as you wish 😉.

You can find the full GitHub repo on my GitHub page or just below 😉

NicolasDuponchel/CustomItemDecoration

If it helped follow and 👏 ! Thanks you readers 🙏

This article explains how to use GestureDetector in Android.

All of us have already deal with android touch events with or without success!

Everything begins with a simple setOnClickListener{}, then comes the need to translate, scale, rotate, or do stuff with your View. So, most of android developers (including me of course) would say : “ok let’s create a custom onTouchListener, look events, then identify it and do what I need to do with it!”. Here is an example of what could (but should not) be done:

class CustomTouchListener(private val view: View) : View.OnTouchListener {
    private val actionDownPoint = PointF(0f, 0f)
    private val actionMoovePoint = PointF(0f, 0f)
    private var touchDownTime = 0L

    override fun onTouch(v: View, event: MotionEvent) = when (event.action) {
        MotionEvent.ACTION_DOWN ->
            PointF(event.x, event.y).let {
                actionDownPoint.set(it)
                actionMoovePoint.set(it)
                touchDownTime = System.currentTimeMillis()
                true
            }
        MotionEvent.ACTION_MOVE ->
            PointF(event.x, event.y).let {
                // DO YOUR TRANSLATE ACTION HERE
                actionMoovePoint.set(it)
                true
            }
        MotionEvent.ACTION_UP ->
            PointF(event.x, event.y).let {
                val isTouchDuration = System.currentTimeMillis() - touchDownTime < 200
                val isTouchLength = abs(it.x - actionDownPoint.x) + abs(it.y - actionDownPoint.y) < 25
                val shouldClick = isTouchLength && isTouchDuration
                //OVERRIDE AND SEND CLICK EVENT
                if (shouldClick) view.performClick() 
                true
            }
        else -> false
    }
}

GestureDetector

🤔 That sounds like reinventing the wheel don’t you think? GestureDetector will avoid that loss of time. Let’s see an example:

All that you need is onSingleTapUp and onScroll. In this case you don’t really care about onFling or others don’t you? Yet again, there is nothing to get up to. You can use SimpleGestureDetector which overrides all methods with empty body, and then you only override methods you need.

Now you’ve got your scroll and tap event. GestureDetectorListener is ready, final step is to call it in your view → override onTouchEvent method.

private val gestureDetector =
    GestureDetector(context, MySimpleGestureDetectorListener())

override fun onTouchEvent(event: MotionEvent) =
    gestureDetector.onTouchEvent(event)

Note that GestureDetector also provides OnDoubleTapListener and OnContextClickListener ( What’s onContextClick ? )

Note that if you’re not using androidX yet you could use GestureDetectorCompat

ScaleGestureDetector

Ok guys, something is still lacking. What about zooming events? Just add Scale before! ScaleGestureDetector will do the job.

class MyScaleGestureDetectorListener :
    ScaleGestureDetector.OnScaleGestureListener {

    override fun onScaleBegin(detector: ScaleGestureDetector) =true

    override fun onScaleEnd(detector: ScaleGestureDetector) {}

    override fun onScale(detector: ScaleGestureDetector) = true

}

Here again we could use SimpleOnScaleGestureListener the same way.

GestureDetector + ScaleGestureDetector

What if you want to handle zoom and scroll? Obviously you could create a class which implements both OnGestureListener and OnScaleGestureListener, but here comes the tricky part. You need to handle both listeners events.

Note that android doc calls the detector the following way, but in some case you will need to check if a scale gesture is in progress. See that stackverflow topic.

fun handleTouchEvents(event: MotionEvent) =
    scaleGestureDetector.onTouchEvent(event)
        || gestureDetector.onTouchEvent(event)

CustomGestureDetector

Final code of your custom gesture detector.

Then you pass the context and the Listener as params, and call it in onTouchEvent() in your View.

Note

Thanks to Google, android native zoom (scale detector) is caped to a minimal distance. If your fingers are to close, it will trigger onScaleEnd() 😢 They communicated this aswon't fix ! Get more info on this post.

Over the half year that I have been a member of GoPro team, I had to deal with media edition. Here it comes my experience on android.graphics.Matrix

Rotation, zoom, translation are basic transforms I needed to apply to images or videos. All those can be done with matrix operations, then applying the resulting transform to a TextureView.

Let’s see an example

fun simpleExampleTransform() {
    val matrix = Matrix()
    matrix.preRotate(90f, 0.5f, 0.5f)
    matrix.preTranslate(97f, 4f)
    matrix.preScale(12f, 1f)

    textureView.setTransform(matrix)
}

Functional motivation

As a supporter of functional approach, I would have expected android.graphics.Matrix class’ methods to return the result of the operation as a Matrix object. This is not the case and most of them return a boolean. Thanks to Kotlin extensions I re-wrote the Matrix API (at least methods I needed) to respect functional approach.

3 main transform kotlin extensions

Previous example can be written

fun simpleFunctionalExampleTransform() {
    val center = PointF(0.5f, 0.5f)

    textureView.setTransform(
        Matrix()
            .translate(97f, 4f)
            .scale(12f, 1f, center)
            .rotate(90f, center)
    )
}

Going further

Those methods simplify operations. But in some cases I just need to concat transform matrices. Let’s consider I have 3 different media-editing widgets that give me 3 matrices rotationMatrix, translationMatrix, scaleMatrix. The final transform is the multiplication of those 3 matrices.

fun simpleExampleTransform(
    rotationMatrix: Matrix,
    translationMatrix: Matrix,
    scaleMatrix: Matrix
): Matrix {
    val finalTransform = Matrix()
    finalTransform.preConcat(rotationMatrix)
    finalTransform.preConcat(translationMatrix)
    finalTransform.preConcat(scaleMatrix)
    return finalTransform
}

If you’re not confortable with set / pre / post operations please have a look at that stackoverflow answer.

Same story for concat method, it could look like following

Then, the previous example can be written

fun simpleFunctionalExampleTransform(
    rotationMatrix: Matrix,
    translationMatrix: Matrix,
    scaleMatrix: Matrix
): Matrix = rotationMatrix
    .concat(translationMatrix)
    .concat(scaleMatrix)

Conclusion

All the android.graphics.Matrix could be extended the same way and finally answer the functional approach.

But 2 scale types are missing ! I would like something like

android:scaleType="centerCrop|fitBottom"

android:scaleType="centerCrop|fitTop"

So I created a customImageView with those two new scale types. I reuse the MATRIX type, and then rewrite the setFrame method to redraw the right way.

val drawableRect = when (matrixType) {

    MatrixType.FIT_BOTTOM -> 
        RectF(0f, drawableHeight - x, drawableWidth, drawableHeight)
    
    MatrixType.FIT_TOP -> 
        RectF(0f, 0f, drawableWidth, x)

}

The CustomView full code is here ! 😃

NicolasDuponchel/ScalableImageView

And the Android project is also available on GitHub.

Goal : A minimal elapsed time before an Observable emits its result.

Motivation : For example, displaying a splash screen while performing initialization jobs. For fast devices, those jobs might be too fast to let the users contemplate the wonderful cat picture you placed on this splash screen. 🙀

The first solution

Single.timer(delay, unit) returns a Single that emits a success with 0L value after the given delay.

this.toSingleDefault(Unit) converts the Completable into a Single which when this Completable completes normally, emits the given value through onSuccess.

single1.zipWith(single2) returns a Single that emits the result of applying a specified function to the pair of items emitted by the first and the second Single.

single.ignoreElement() returns a Completable that ignores the success value of this Single and calls onComplete instead on the returned Completable. Note that it does the same that toCompletable() function, but this one is dreprecated, and will be removed in 3.0. 😙

This first solution does the job. But if we take a look at errors handling, we’ll see that this solution may not be the one we expect. In fact when your Completable emits an error, the stream will be broken. Then onError() will directly be called.

The second solution

Observable.timer() does the same that for Singles, but returns an Observable.

completable.toObservable() converts a Completable into an Observable and relays the terminal events to the subscriber.

observable.ignoreElement() does the same that for Singles.

Observable.mergeDelayError(observable1, observable2) is mainly the same that a simple merge. The main difference is that it allows the Observer to receive all successfully emitted items from each of observable1 and observable2 without being interrupted by an error notification from one of them.

With this solution, whatever the emission of your completable, it will be emitted after the wanted elapsed time. 👏

This extension is perfect to manage onAnimationStart, onAnimationRepeat & onAnimationEnd. No need to rewrite an AnimationListener each time ! Just have a look.

With this extension you can easily add animation and precise what to do on animation events.

my_view.playAnimation(
    animResId = R.anim.rotate,
    onAnimationEnd = { your action here }
)

And that’s it ! 😄

In this previous article, I explain how to call a public REST API. This project uses RxKotlin, LiveData, retrofit… It is a simple example of basic MVVM Android app. I asked myself how could I do same on iOS. Let’s have a look !

Running Xcode

Prerequisite : A Macbook with Xcode installed and an iTunes identifier.
Install Xcode and run a new project. Select Single View App. Do not care about CoreData and tests. Believe me, do not choose Objective-C, unless you love pain. Swift is probably the thing that could change android developers’ mind about iOS, especially when you already use Kotlin.

😱 There is no Activity, no Manifest, no res, no Gradle... Don’t panic, it’s gonna be alright !

AppDelegate is the equivalent to your android Application file. You will see that the methods are similar in Android : applicationWillResignActive, applicationDidEnterBackground … with some coments to explain.

ViewController could be your MainActivity. Methods are similar too : viewDidLoad for example is quiet the same that onResume.

Main.storyboard is the ios equivalent to your .xml file but there are some differences.

Assets.xcassets is the folder you could compare to res in Android. By the way iOS do not natively manage .svg files. So forget about your lovely Android vectors.

Info.plist make me think to a mix between the main Gradle file and the manifest.

LaunchScreen.storyboard is the bonus. Do you remember the first time you tried to implement a splash screen ? This file is literally an “iOS splash screen”. No need to do anything more in the code.

Creating a view

Dear Android developers, have you ever tried to drag and drop any UI component to build your views ? If you already succeed once, I beg you to show me how.
Building views in iOS is absolutely different, you can unplug your keyboard ! (ok I am exaggerating a bit, but a very little) Let’s try.

As you can see above, I just need to drag and drop a Label on the Main.storyboard. Then I add some constraints :

• center X
• center Y
• leading (left)
• trailing (right)

The trick is to maintain ctrl while you are dragging the Object to choose on which other component to place constraints. In this case the four constraints are related to the Safe Area. Thanks to iPhoneX and its beautiful notch, iOS introduced this view called Safe Area where you are sure nothing will be hidden.

Tip : Set Lines to 0 if you want your Label to use as much lines as needed.

I confess, I find this way of building views pretty cool ! 🙌 +1 for iOS.

External libs import

As you can see above, I deployed an application but I didn’t write any code line. Let’s go “deeper” through the code. I’m gonna try to call a REST API. That for, I need to import Moya. This lib is a kind of extension of Alamofire and facilitate http networking. Damn there is no Gradle ! How could we import something in the project ?

There is something called pod in iOS which is used to import libs in a project. This is managed by Cocoapod, it is well documented. Moreover this is an open source lib stored on GitHub.

$ sudo gem install cocoapods

I create my Podfile

$ pod init

Save your Podfile in First API call directory. Then navigate to your folder and install your pod as follow

$ pod install

Close Xcode and double click on First API call.xcworkspace. And you are now ready to use your libs.

I find the iOS way to import libs a bit weird on first approach. In Android I just add the line bellow to build.gradle and sync. +1 for Android ! 😙 But there is no doubt, Cocoapods is easy to use, and all libs needed are precised in the Podfile.

Calling REST API

I will now call this Chuck Norris Api. I already explained the structure of its response in this article, so do not hesitate to have a look.

The structure is almost the same that in my android project, I create the following files :

The first file to create is ChuckNorrisApi. It implements the protocol TargetType of Moya. It contains all needed informations about the API (Urls, headers, parameters …).

ChuckNorrisApiService is the file where to precise how to use ChuckNorrisApi. It just contains two methods getJoke(…) which call the API.

ChuckNorrisResponse and Joke are my Objects corresponding to the Json returned by the API. In Kotlin I would have declared data classes, in swift we can use NSObject. Joke and Response will implement ALSwiftyJSONAble protocol which manages Json translation to Object. By the way, it looks like Serializable in Android.

Finally I subscribe to my service in my ViewController.

UI components

Now that API is ready, let’s build a button and display the requested joke on the screen. Remember My Label ? Get back on Main.storyboard, and do same with a button.

Time has come to set my onClickListener and change my label text. I hope you did not put your mouse away guys! 🖱

As you can see above, I just need to drag and drop to reference the label in my ViewController, and same for my button click event. I choose the Touch Up Inside event with the interface builder which I named onNewJokeRequested(). Finally, I just need to call getJoke() and I update the label text with my response.

Permissions

In iOS, android permissions equivalent are set in the Info.plist. To call a public REST API, the needed one are the following :

Run the App

Your app is ready ! cmd+r and let’s see the result.

Conclusion

It is quiet easy to start learning iOS when you are mastering Android. I still have a preference for Kotlin language. I find it more powerful especially with data classes, side effect methods, null check, etc… But I admit iOS and Android os are really close.

For those who would like to go further on this project, please check the github repo !

NicolasDuponchel/ChuckNorris-iOS-API

Simple example, a function converting Int into an Error

enum class ERROR {
    ANDROID,
    NETWORK,
    HUMAN,
    UNICORN,
    FIRE,
    HOMER_SIMPSON,
    BANANA,
    UNKNOWN
}

fun Int.toError() = when (this) {
    22000, 1890 -> ANDROID
    404 -> NETWORK
    1111 -> HUMAN
    999, 888 -> UNICORN
    666 -> FIRE
    123456 -> HOMER_SIMPSON
    8 -> BANANA
    else -> UNKNOWN
}

Let’s focus now on unit test. The first approach would be to write as many tests as there are known error codes. Which means the following code would be written 10 times in our case.

@Test
fun `toError returns ANDROID if code is 22000`() {
    val errorCode = 22000
    val error = errorCode.toError()
    Truth.assert_().that(error).isEqualTo(ANDROID)
}

What if we had to deal with much more error codes ? Junit offers the possibility to parameterize your tests. Let’s have a look at it.

The goal is to write a single unit test and to precise which parameters to use. Then junit does the rest.

@RunWith(Parameterized::class)
class ErrorTranslatorParameterizedTest(
    private val errorCode: Int,
    private val error: ERROR
) {
    companion object {
        @JvmStatic
        @Parameterized.Parameters
        fun errorCode() = listOf(
            arrayOf(22000, ANDROID),
            arrayOf(1890, ANDROID),
            arrayOf(404, NETWORK),
            arrayOf(1111,HUMAN),
            arrayOf(999,UNICORN),
            arrayOf(888,UNICORN),
            arrayOf(666,FIRE),
            arrayOf(123456,HOMER_SIMPSON),
            arrayOf(8, BANANA),
            arrayOf(0, UNKNOWN)
        )
    }

    @Test
    fun `toError returns good values`() =
        assert_().that(errorCode.toError()).isEqualTo(error)
}

And that’s it !

NicolasDuponchel/ParameterizedUnitTest

In my team, we tried out the MVVM architecture with android.arch.lifecycle from Google. No doubt it’s amazing. This article points out how to write ViewModel unit tests.

• Gradle libraries
• Testing LiveData values
• Mocking RxJava with trampoline

Gradle

I use mockito and google truth.

testImplementation "junit:junit:4.12"
testImplementation "com.google.truth:truth:0.36"
testImplementation "org.mockito:mockito-core:2.13.0"
testImplementation "android.arch.core:core-testing:1.1.1"

Testing LiveData values

The right way to test LiveData is to store their values in a particular list, then look over this list and check if the content is correct.

First of all, let’s create our custom Observer to populate the list.

class TestObserver<T> : Observer<T> {

    val observedValues = mutableListOf<T?>()

    override fun onChanged(value: T?) {
        observedValues.add(value)
    }
}

Then, the extension function to use it.

fun <T> LiveData<T>.testObserver() = TestObserver<T>().also {
    observeForever(it)
}

A specific TestRule is required for testing architecture components : InstantTaskExecutorRule. Finally here is the test.

@get:Rule
val mockitoRule = MockitoJUnit.rule()

@get:Rule
val taskExecutorRule = InstantTaskExecutorRule()

@InjectMocks
lateinit var classUnderTest: YourViewModel

@Test
fun `init method sets liveData value to empty list`() {
    val liveDataUnderTest = classUnderTest.liveData.testObserver()

    Truth.assert_()
        .that(liveDataUnderTest.observedValues)
        .isEqualTo(listOf(emptyList<String>()))
}

Cool isn’t it ? But why do we need a List to store nothing ? Let’s go deeper and have a look at the following example. It is an installation and the screen takes 3 states.

@Test
fun `onInstall set correct screen states`() {
    val liveDataUnderTest = classUnderTest.screenState.testObserver()

    classUnderTest.onInstall()

    Truth.assert_()
        .that(liveDataUnderTest.observedValues)
        .isEqualTo(listOf(INITIAL, LOADING, INSTALLED))
}

Testing Rx methods

Now that we’ve done with LiveData values, let’s have a look at Rx. If we try to run the previous test with onInstall() which use Rx, we face to this error :

java.lang.AssertionError: Not true that <[INITIAL]> is equal to <[INITIAL, LOADING, INSTALLED]>

The task is executed on parallel with io Scheduler. That’s why the test execution is faster than the operation on background. The values LOADING and INSTALLED have no time to be set before the test ends.

What’s beautiful with RxJava is that everything your may need already exists. To achieve unit testing, there’s a specific scheduler called Trampoline. All jobs that subscribes to it will be queued and excuted one by one. Let’s create a new TestRule to use it.

class RxSchedulerRule : TestRule {

    override fun apply(base: Statement, description: Description) =
        object : Statement() {
            override fun evaluate() {
                RxAndroidPlugins.reset()
                RxAndroidPlugins.setInitMainThreadSchedulerHandler { SCHEDULER_INSTANCE }

                RxJavaPlugins.reset()
                RxJavaPlugins.setIoSchedulerHandler { SCHEDULER_INSTANCE }
                RxJavaPlugins.setNewThreadSchedulerHandler { SCHEDULER_INSTANCE }
                RxJavaPlugins.setComputationSchedulerHandler { SCHEDULER_INSTANCE }

                base.evaluate()
            }
        }

    companion object {
        private val SCHEDULER_INSTANCE = Schedulers.trampoline()
    }
}

Just need to add this TestRule to the test.

@get:Rule
val rxSchedulerRule = RxSchedulerRule()

Process finished with exit code 0

For those who would be more curious, I wrote this article using a previous MVVM project on which I added some unit tests. You can find it on GitHub here.

If you search a way to start learning Rx ? This article is for you !

I wrote Medium stories telling some Rx Java tips I found useful (logging, errors, timeout, retry …) But I realized I never mentioned the basics. Let’s start from the beginning. I wont try to reword the Rx documentation, but tell about my own reactive programming experience with Rx.

What is Rx ?

It is an API for asynchronous programming with observable streams.

If I would quickly illustrate Rx I would take the image of a roller coaster with marbles. Rx permits to change the rails directions and the marbles’ type, color, form etc. We can observe this roller coaster’s finishing line and catch the marbles.

We can use it in many languages like Python, Kotlin, Swift, Java, JS, PHP… I’m a mobile developper so my experience belong to Rx Java & Kotlin on Android framework. But whatever, the principe is still the same.

Why should I use Rx ?

For a powerful, readable and minimal code

When should I use Rx ?

Every time I make an asynchronous operation.

Base reactive interfaces

Before starting with some examples, here is the very first thing to know : Rx base reactive types.

Rx base reactive types are Observable, Single, Completable, and Maybe.

Those 4 could be assimilated to roller coasters and their emissions to marbles.

• Completable emits no item, just a “I’ve got the job done”.
• Single emits a single one item.
• Observable can emit few elements.
• Maybe is a union between Single and Completable. It emits one or no item.

Notice that since Rx 2, reactive types does not accept nullable values. This also means that tey will never emit null.

Basic Hello World example

Let’s build a simple HelloWorld using Rx. We need 2 things to make it works :

• The observable that will emit a String “HelloWorld”
• The observer that will subscribe to the observable emission.

To create an observable instance, we basically use just operator. It converts an item into an observable that emits that item. Our result is a single “Hello world” String, so the observable source would be a Single.

Single.just( "Hello World" )

Now that we have an observable ready, we just need to subscribe to it’s emission.

fun helloWorld() {
    val observable = Single.just("Hello World")

    observable.subscribeBy(
            onSuccess = { print(it) },
            onError = { }
    )
}

Moreover, we can choose the thread which will take the subscription responsibility, so basically we choose a non-UI Thread. Then when our observable emits a result, we will observe it on the main Thread to update UI.

observable
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribeBy(
                onSuccess = { print(it)},
                onError = {}
        )

Of course this example do not really matter because there’s no need of asynchronous task to write a HelloWorld ! But now that you’ve got the very basic framework, let’s try little more complex examples.

I built a simple Android app to illustrate the following ( Completable, Single and Observable) examples. Here is the GitHub repo. I implemented all those with an Activity and its ViewModel using LiveData.

NicolasDuponchel/RxBasics

Completable example

This time, we won’t care about task’s result. What matters is simply that our job succeed (or not). The most simple example I found to illustrate Completable consists on simulating an installation of something (doesn’t matter what). So let’s simulate an installation that takes 3 seconds.

Completable.timer(3, SECONDS)
.subscribeBy(
        onComplete = { toast("Fake installation succeed") },
        onError = { toast("Let me guess this never happen") }
)

Cool don’t you think ? Hum… I know you want to do stuff more interesting am I wrong ? So to deal with real asynchronous task with more fun, I suggest to try this RESTful public api that returns a random joke. Let’s see how Rx could help.

API call prerequisite

This paragraph explains quickly how to call a REST API on Android. Just skip it if you cannot wait to deal with Rx !

{ 
    "type": "success",
    "value": {
        "id": 530,
        "joke": "Chuck Norris can dereference NULL.",
        "categories": ["nerdy"] 
    }
}

Here is the Json result. Let’s create a Joke class and get it from the api. Then the basics to call this URL with Retrofit :

private fun createService(): ApiService = Retrofit.Builder()
        .baseUrl("http://api.icndb.com/")
        .addConverterFactory(GsonConverterFactory.create(gson))
        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
        .build()
        .create(ApiService::class.java)

interface ApiService {
    @GET("jokes/random")
    fun randomJoke(): Single<ApiResponse>
}

data class ApiResponse(
        @SerializedName("type") val type: String,
        @SerializedName("value") val joke: Joke)

data class Joke(
        @SerializedName("id") val jokeId: Int,
        @SerializedName("joke") val jokeText: String)

Single example

Api’s call is now ready, let’s create and subscribe to Single<Joke>. Notice that randomJoke() returns a Single<ApiResponse>, I use map operator to change it to Single<Joke>.

fun displayJoke() {
    val apiService = createService()

    val jokeObservable: Single<Joke> =
            apiService.randomJoke().map { it.joke }

    jokeObservable
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribeBy(
                    onSuccess = { print(it.jokeText) },
                    onError = { print(it) }
            )
}

Why not to add loaders to highlight the background execution ? Methods doOnSubscribe and doFinally can be used to call specified action before subscription and after onSuccess or onError.

jokeObservable
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .doOnSubscribe(joke_loader.show())
        .doFinally(joke_loader.hide())
        .subscribeBy(
                onSuccess = { print(it.jokeText) },
                onError = { print(it) }
        )

Cool isn’t it ? Now that we’ve seen the very tip of the Rx iceberg, I suggest to have a look at Observable.

Observable example

To deal with Observable emission, I suggest to reuse the previous example but this time we could ask for some random jokes in a single flux. Let’s convert the previous Single into an Observable with toObservable. Then, now that we have a “multi-elements” emission, repeat(count)method will help. “It returns an Observable that repeats the sequence of items emitted by the source ObservableSource at most {count} times.”

val jokesObservable = jokeApiService.randomJoke()
        .map { it.joke }
        .toObservable()
        .repeat(3)

What’s different now ? The emission is constituted of 3 jokes. And by subscribing to an Observable, each time it emits a result, the onNext method is called with it as Joke.

jokesObservable.subscribeBy(
        onNext = { println(it.jokeText) },
        onComplete = { println("job done")},
        onError = { println(it.message) }
)

This code will print (if no error is encountered) :

jokeText1
jokeText2
jokeText3
job done

You’ve got now the basics of Rx reactive programming! For technologie lovers, I would affirm that the best app I used to deal with is Rx Kotlin app, build on MVVM using LiveData. Please have a look at the all project on GitHub.

Thanks for reading !

For those who want to learn how to unit test ViewModel in MVVM architecture : see this article.