如何从后台线程在 UI 线程上运行并等待结果？

Question

I have a third party library that periodically queries my video player (ExoPlayer) for information such as current position in the video. This third party library runs on a background thread. Problem is, the ExoPlayer instance is not allowed to be accessed by a background thread.

One of my ideas was to use coroutines to force a switch to the main thread before accessing the ExoPlayer instance. Something like this (note that this is called from multiple places, both on main and background threads):

suspend fun getCurrentPosition(): Long {
    if (Looper.myLooper() != Looper.getMainLooper()) {
        // On a background thread, switch to main thread and return current position
        return withContext(Dispatchers.Main) {
            exoPlayerInstance.currentPosition
        }
    } else {
        // Already on main thread, no need to switch threads
        return exoPlayerInstance.currentPosition
    }
}

Then I would call this with runBlocking like so:

runBlocking { videoPlayerWrapper.getCurrentPosition() }

runBlocking is used because the third party library expects an instant result.

This works sometimes but other times my app is completely locking up. Any idea what might be wrong? Any alternative solutions?

Answer 1

runBlocking is a suspend function that blocks current thread until coroutine launched is completed. I guess that you are blocking main thread with this call. I suggest you to use a function like this.

  fun getCurrentPosition() = runBlocking(Dispatchers.Main.immediate) {
      exoPlayerInstance.currentPosition
  }

The Dispatchers.Main.immediate switches context only if current thread is not the main thread.

Answer 2

Then I would call this with runBlocking like so:

runBlocking { videoPlayerWrapper.getCurrentPosition() }

By definition runBlocking will block the current Thread until the coroutine completes. From the runBlocking docs :

Runs a new coroutine and blocks the current thread interruptibly until its completion. This function should not be used from a coroutine. It is designed to bridge regular blocking code to libraries that are written in suspending style, to be used in main functions and in tests.

This effectively means that your UI will freeze if you are calling runBlocking from the main Thread . My guess is that sometimes videoPlayerWrapper.getCurrentPosition() returns fast enough for you not to notice that is actually blocking.

This third party library runs on a background thread. Problem is, the ExoPlayer instance is not allowed to be accessed by a background thread.

It seems to me that there is a design flaw here. Rather than the library trying to get a hold of the Exoplayer instance, the library should establish a contract for the consumer to provide the position. If using coroutines, the library could require a Flow<Int> that emits the current position as the position changes.