Heya all, I’ve got one beginner Rx question (sorry about it) which really confuses me… I’ve got reactive

Completable

flow for login, and at some point in the middle I need to call

AppAuth

library to

performTokenRequest

. That library uses callbacks for results, so I’m curious how to adapt it to my architecture? Idea is that when callback is successful I resume with

doOnSuccess

or

doNext

to the next

Completable

function.

private fun login(
authorisationResponse: AuthorisationResponse
): Completable {
  return Completable.defer {
	// do some validations..
	if (authorisationResponse == null) {
	    return@defer Completable.error(...)
	}

	// app auth stuff
	val tokenRequest = authorizationResponse.createTokenExchangeRequest()
	val clientAuthentication ....

	// performing token request, AppAuth library works with callbacks, so I'm
	// curious how to "pause" my Rx flow until I get result from that callback
	// and then I need to continue completable

	return@defer ??? 
	  authorisationService.performTokenRequest(tokenRequest,clientAuthentication)
	{ response, ex -> 
		// callbacks
		if (response != null) {
			//... I'm going to save token here
            authStateManager.saveToken(response)
		}

	.doOnSuccess or .doNext (continueLoginFlow)
  }
}

private fun continueLoginFlow(): Completable {
    return authStateManager.getToken()
           .map { ... }
           .flatMap { ... }
           .doOnSuccess { ... } 
           ...

	...
}

Completable.defer will not help in this case, defer is useful just for lazy creation of Completables from existing result. You need Completable.create, see doc, it will give you emitter which you should notify from your callback, it allows wrap non-rx async code to rx primitives (Completable in your case)

Hi @gildor thanks for looking into it, could you please explain how to wrap callback result into Single? Sorry for my lack of knowledge, further Rx research is next on my learning Todo… I know this doesn’t make sense but it compiles 😄

return@defer Single.just(
     authorizationService.performTokenRequest(tokenRequest, clientAuthentication) { response, ex ->
         if (response != null) {
              authStateManager.updateAfterTokenResponse(response, null)
          }
       }).doOnSuccess {
           continueLoginFlow()
       }.ignoreElement()

Yes, it true for all Rx primitives, use create method

I’m not sure, I’m implementing AppAuth library, so I don’t wanna do too much coupling https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationService.java

I don’t see any coupling with my example, it just an extension function, it can be private in class where you use it

Oke, thanks for your suggestions 🙂 I’m doing some refactoring of legacy code, that’s why I’m a bit confused here, and doing it step by step

ehh, their implementation of service is really not optimal, no cancellation, everything based on AsyncTasks, oh gosh

We also had slightly modified implementation of it, but since the guy who wrote it isn’t anymore around I’ve decided to go stock, it’s simpler for other team members and maintenance wise…