CODEWITHSUNDEEP
androidkotlinretrofitrx-javaandroid-livedata
Walt
Walt

Reputation: 111

Android Kotlin RxJava Retrofit - empty DisposableObserver LiveData

I'm implementing an Android application in Kotlin that uses an API as it's primary source for data. I use Kotlin, RXjava, Retrofit and Dagger to make it work.

But for some reason my person object at the onNext function is empty. Even though I see the http method call data in the Logcat, and it has the correct person object.

I'm requesting a person object from JSON:

{
  "persons": [{
      "personId": 1,
      "personName": "Bert",
      "personAge": 19,
      "isFemale": "false",
      "birthDate": "2000-06-28T00:00:00"
    }
  ]
}

ApiInterface:

@GET("persons")
fun getPerson(@Query("personId") personId: Int): Observable<Person>

PersonRepository:

class PersonRepository @Inject constructor(val apiInterface: ApiInterface) {
  fun getPerson(personId: Int): Observable<Person>{
    return apiInterface.getPerson(personId)
  }
}

Person ViewModel: 

class PersonViewModel @Inject constructor(private val personRepositoy: PersonRepository) : ViewModel() {
  var personResult: MutableLiveData<Person> = MutableLiveData()
  var personError: MutableLiveData<String> = MutableLiveData()
  lateinit var disposableObserver: DisposableObserver<Person>

  fun personResult(): LiveData<Person> {
    return personResult
  }
  fun personError(): LiveData<String> {
    return personError
  }

  fun loadPerson(personId: Int) {
    disposableObserver: object : DisposableObserver<Person>() {
    override fun onComplete() {}

    override fun onNext(person: Person){ //this is empty for some reason
      personResult.postValue(person)
    }

    override fun onError(e: Throwable) {
      personError.postValue(e.message)
    }
  }

  personRepository.getPerson(personId)
  .subscribeOn(Schedulers.newThread())
  .observeOn(AndroidSchedulers.mainThread())
  .subscribe(disposableObserver)
  }

fun disposeElements() {
     if(null !- disposableObserver && !disposableObserver.isDisposed) { 
       disposableObserver.dispose() 
     }
}
}

PersonActivity where the call is made:


@Inject
lateinit var personViewModelFactory: PersonViewModelFactory
lateinit var personViewModel: PersonViewModel

override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_person)
        AndroidInjection.inject(this)

 personViewModel = ViewModelProviders.of(this, personViewModelFactory).get(PersonViewModel::class.java)

 personViewModel.loadPerson(1)
 personViewModel.personResult().observe(this, Observer<Person> {
  //some code that uses it
 }
}

The getPerson call returns the correct person which I can see in the logs, but it doesn't post the value in personResult, like I want. I don't know why.

Edit: Added the Person class as requested. Note that @Json is the Moshi equivalent of @SerializedName from GSON.

data class Person (
  @Json(name = "personId")
  val personId: Int,

  @Json(name = "personName")
  val name: String,

  @Json(name = "personAge")
  val age: Int,

  @Json(name = "isFemale")
  val isFemale: Boolean,

  @Json(name = "birthDate")
  val birthDate: GregorianCalendar

)

Upvotes: 0

Views: 1572

Answers (1)

Sanlok Lee
Sanlok Lee

Reputation: 3494

To avoid mismatch between the JSON response and the actual object to be used, define a intermediate class something like this:

data class PersonResponse(
      @Json(name = "persons")
      val persons: List<Person>
)

Example api class:

@GET("persons")
fun getPerson(@Query("personId") personId: Int): Observable<PersonResponse>    

@GET("persons")
fun getAllPersons(): Observable<PersonResponse>

Example repository class:

fun getPerson(personId: Int): Observable<Person>{
    // Convert PersonResponse -> Person
    return apiInterface.getPerson(personId)
        .doOnNext { value -> Log.d(SOME_LOG_TAG, "onNext: value=$value") }
        .doOnError { error -> Log.d(SOME_LOG_TAG, "onNext: value=${e.getMessage()}") }
        .flatMap { response ->
            // Check if the list contains exactly one Person and throw error if it doesn't
            if (response.persons.size == 1) 
                Observable.just(response.persons[0])
            else
                Observable.error(Throwable("Something's wrong"))
        }
}


fun getAllPerson(): Observable<List<Person>> {
    // Convert PersonResponse -> List<Person>
    return apiInterface.getAllPersons()
        .map { response -> response.persons }
}

As you can see repository code can look quite messy. I suggest making an intermediate layer between your api class and repository class which does all the conversions.

Upvotes: 1

Related Questions