Android Coroutines in SyncAdapter being Interrupted

I'm having a tough time figuring out why do I observe InterruptedExceptions in the SyncAdapter#onPerformSync method.

Brief intro

My project originally contained only Java code and had a working SyncAdapter pattern implemented. In the onPerfromSync method I did the following operations for each resource that I needed to sync:

• query local sqlite database
• send data to web server over HTTP
• save data to local sqlite database

As the project progressed I introduced Kotlin and Coroutines and decided to use them in the SyncAdapter. Most of the resources kept the existing logic, and for a few I decided to use Coroutines. I had to bridge the onPerformSync method with a CoroutineScope so that I can launch coroutines. After doing so I started observing InterruptedExceptions occurring.

Code before (no exceptions)

class MySyncAdapter extends AbstractThreadedSyncAdapter {
   ...

   @Override
   public void onPerformSync(...) {
       syncResourceX();
       syncResourceY();
   }

   private void syncResourceX() {
      // query db
      // send to server
      // store locally
   }
}

Code After (with exceptions)

class MySyncAdapter(...): AbstractThreadedSyncAdapter(...) {
   ...

   override fun onPerformSync(...) {
      runBlocking {
              syncResourceX();
              syncResourceY();
      }
   }

   private suspend fun syncResourceX() {
      // query db
      // send to server
      // store locally
   }
}

After this refactoring I started receiving InterruptedExceptions where runBlocking is being invoked.

Initially I thought this might be due to not performing network operations on the current thread as the docs of the sync adapter state that the system monitors network traffic and might interrupt the sync process if no traffic is generated. But runBlocking should cause any network requests to be executed on the current thread right?

After which I started thinking that this process has existed in the Java code as well. It's just that there is nothing to report the interruption of the sync process. It is up until I started using coroutines and runBlocking that this problem has revealed it self. Or so I think now.

Question:

Any thoughts or explanations why I previously did not observe InterruptedException with the Java code and do observe InterruptedException with the Kotlin code is more than welcome.

Notes

• I haven't overriden onSyncCanceled
• The sync process usually takes less then 20 seconds to complete