Hey guys! I’m struggling with

withContext

in production code (as opposite to hello world examples)… Where do you put

withContext

in your code? Is it inside suspending function body, or at the call site? Also, if you have nested suspending functions, let’s say a typical android app with ViewModel > Repository > DataSource, where DataSource contains suspending functions - where do you put

withContext

? Is there any official guidelines for this?

I tend to put it in the body of a

suspend

function, around the block of code that may be blocking (e.g. network access or something).

The general rule is you just put it wherever you need to change into another context. For example, before a blocking file read / network access, I do

withContext(<http://Dispatchers.IO|Dispatchers.IO>) { readFile() }

class DataStoreImpl(private val context: CoroutineContext, private val service: NetworkService) : DataStore {
    ...
    suspend override fun getData() : MyResult = withContext(context) {
        val nwData = service.getData() // blocking call
        val data : MyResult = ... ... nwData ...
        data
    }
    ...
}

And you’d provide

<http://Dispatchers.IO|Dispatchers.IO>

for the

context

property.

You do it closer to the actual code that needs it. A repository for example may make network requests, file operations and heavy parsing. It would switch to IO for the former two and Default for the latter. Outside of the repository you can't (shouldn't) know what you need because of abstraction.

^^^ Applying SOLID principles 🙂

Ok, so if my DataSource has a suspend function that uses Firebase Storage (which is callback based), you think the best way of doing it would be like this?

class DataSource {
  suspend fun getFile(...) = withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
      suspendCoroutine {
          // firebase code...
      }
  }
}

you don't need

<http://Dispatchers.IO|Dispatchers.IO>

if it's callback based

But you want to use coroutines to avoid callbacks 🙂

yes, wrapping it with

suspendCoroutine

is the right call

Ah yes, of course… 🙂

So is my whole snippet correct or not? ’cause I’m confused now ;D

Looks good! Does firebase use a callback?

…Or shall I skip withContext in this case?

drop the

withContext

-- it's not necessary in this case, because it's for blocking code. if you suspend, you don't need to be in that context

Using withContext, in your example, would be for blockig code. Yours doesn’t block, like Kenzie said.

Hmmm, you got me… I thought that this “waiting” for callback to be called also blocks the thread.

How does the firebase code look like?

@streetsofboston yeah, I’m doing it

Ah… good. No, that is not necessary. Sometimes, e.g. with some Bluetooth stuff, you must even call the callback registration functions on a particular thread (or on the same thread). Then you’d use

withContext

as well.

My code looks something like this:

class DataSource {
  suspend fun getFile(...) = withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
      suspendCoroutine {
          firebase.getFile(...)
            .addOnSuccessListener { resume(it) }
            .addOnFailureListener { resumeWithException(it) }
      }
  }
}

Yep;

firebase

doesn’t require its methods to be called on a particular thread, they can be called from any thread. You won’t need

withContext

.

Ok, thanks a lot guys! I really appreciate it 👍