How to pass null to an Observable with nullable type in RxJava 2 and Kotlin

To implement the solution mentioned in the nhaarman's answer, you can use the util class Optional (doc) from the Android SDK which was added in API level 24.

If your app's minSdkVersion less than 24 then you still need to implement it by yourself.

Since RxJava 2 does not support null values, there are some other acceptable solutions you can use:

• Work with a custom or third party wrapper library of Optionals like some of the posted answers suggest. When I got rid of Java in favour of Kotlin, Optionals went away in the same package since Kotlin per se supports nullability as part of its type System. Just by this change the code was much more clearer, and I personally don't want to get Optionals back in my code as long as I can avoid them.
• Emit Any class instances with your subject type. For example you could create an Empty.INSTANCE enum class which would emulate the null value and then filter by the enum class.

• The last one is the one I use and prefer being a variant of the previous solution and is based on specialisations. Our friends of JetBrains always emphasise that classes are very cheap in Kotlin, so this would be a quick example to distinguish logged users and not logged ones:

  abstract class SessionUser
  sealed class LoggedUser(val username: String, val password: String) : SessionUser()
  sealed class LogoutUser : SessionUser()
  
  private val user = BehaviorSubject.create<SessionUser>()
  private val loggedUser = 
     user.filter { it is LoggedUser }.cast(LoggedUser::class.java)
  
  fun login(username: String, password: String) {
     user.onNext(LoggedUser(username, password))
  }
  
  fun logout() {
     user.onNext(LogoutUser())
  }
  

I've taken an approach similar to Optional<User> and UserEnvelope. I make a simple User class and a ReifiedUser class that inherits from it. The User class has a companion object that has a NONE instance. The BehaviorSubject is instantiated with the User.NONE instance. It looks something like this:

open class User {
    companion object {
        val NONE = User()
    }
}

class ReifiedUser(
        @field:JsonProperty(J.FirstName) val firstName: String,
        @field:JsonProperty(J.LastName) val lastName: String
) : User()

My BehaviorSubject is instantiated like this:

val activeUser: BehaviorSubject<User> = BehaviorSubject.createDefault(User.NONE)

And wherever I need to use activeUser I either flatMap it to Observable.empty() if it's NONE or just figure out what it is and what to do in the subscriber.

I don't like mixing java Optional with kotlin nullable because mixing map and let gets really confusing and ugly. This way it's very obvious what's going on.

I think it makes more sense to write a container class such as Result. An example of that would be

data class Result<T>(value: T?, error: Throwable?)

Usage

Observable.create { observer ->
   upstreamService.listen(object: UpstreamListener {
     onSuccess(data: User) {
       observer.onSuccess(Result(data))
     }
     onError(exception: Throwable) {
       observer.onSuccess(Result(null, exception))
     }
   }
}