User Class.forName instead of ServiceLoader to instantiate Dispatchers.Main on Android

Fixes #1557
Fixes #878

Author: qwwdfsad

kotlinx-coroutines-core/jvm/resources/META-INF/proguard/coroutines.pro

@@ -8,3 +8,7 @@
 -keepclassmembernames class kotlinx.** {
     volatile <fields>;
 }
+
+-assumenosideeffects class kotlinx.coroutines.internal.FastServiceLoader {
+    boolean ANDROID_DETECTED return false;
+}

kotlinx-coroutines-core/jvm/src/CoroutineExceptionHandlerImpl.kt

@@ -22,7 +22,6 @@ private val handlers: List<CoroutineExceptionHandler> = ServiceLoader.load(
         CoroutineExceptionHandler::class.java.classLoader
 ).iterator().asSequence().toList()
 
-
 internal actual fun handleCoroutineExceptionImpl(context: CoroutineContext, exception: Throwable) {
     // use additional extension handlers
     for (handler in handlers) {

kotlinx-coroutines-core/jvm/src/internal/FastServiceLoader.kt

@@ -5,6 +5,13 @@ import java.net.*
 import java.util.*
 import java.util.jar.*
 import java.util.zip.*
+import kotlin.collections.ArrayList
+
+/**
+ * TODO investigate possible java.vendor values for fallbacks
+ * Don't use JvmField here to enable R8 optimizations via "assumenosideeffects"
+ */
+internal val ANDROID_DETECTED = systemProp("java.vendor")?.toLowerCase()?.contains("android") ?: false
 
 /**
  * A simplified version of [ServiceLoader].
@@ -20,7 +27,59 @@ import java.util.zip.*
 internal object FastServiceLoader {
     private const val PREFIX: String = "META-INF/services/"
 
-    internal fun <S> load(service: Class<S>, loader: ClassLoader): List<S> {
+    /**
+     * This method attempts to load [MainDispatcherFactory] in Android-friendly way.
+     *
+     * If we are not on Android, this method fallbacks to a regular service loading,
+     * else we attempt to do `Class.forName` lookup for
+     * `AndroidDispatcherFactory` and `TestMainDispatcherFactory`.
+     * If lookups are successful, we return resulting instances because we know that
+     * `MainDispatcherFactory` API is internal and this is the only possible classes of `MainDispatcherFactory` Service on Android.
+     *
+     * Such intricate dance is required to avoid calls to `ServiceLoader.load` for multiple reasons:
+     * 1) It eliminates disk lookup on potentially slow devices on the Main thread.
+     * 2) Various Android toolchain versions by various vendors don't tend to handle ServiceLoader calls properly.
+     *    Sometimes META-INF is removed from the resulting APK, sometimes class names are mangled, etc.
+     *    While it is not the problem of `kotlinx.coroutines`, it significantly worsens user experience, thus we are workarounding it.
+     *    Examples of such issues are #932, #1072, #1557, #1567
+     *
+     * We also use SL for [CoroutineExceptionHandler], but we do not experience the same problems and CEH is a public API
+     * that may already be injected vis SL, so we are not using the same technique for it.
+     */
+    internal fun loadMainDispatcherFactory(): List<MainDispatcherFactory> {
+        val clz = MainDispatcherFactory::class.java
+        if (!ANDROID_DETECTED) {
+            return load(clz, clz.classLoader)
+        }
+
+        return try {
+            val result = ArrayList<MainDispatcherFactory>()
+            createInstanceOf(clz, "kotlinx.coroutines.android.AndroidDispatcherFactory")?.apply { result.add(this) }
+            createInstanceOf(clz, "kotlinx.coroutines.test.internal.TestMainDispatcherFactory")?.apply { result.add(this) }
+            result
+        } catch (e: Throwable) {
+            // Fallback to the regular SL in case of any unexpected exception
+            load(clz, clz.classLoader)
+        }
+    }
+
+    /*
+     * This method is inline to have a direct Class.forName("string literal") in the byte code to avoid weird interactions with ProGuard/R8.
+     */
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun createInstanceOf(
+        baseClass: Class<MainDispatcherFactory>,
+        serviceClass: String
+    ): MainDispatcherFactory? {
+        return try {
+            val clz = Class.forName(serviceClass, true, baseClass.classLoader)
+            baseClass.cast(clz.getDeclaredConstructor().newInstance())
+        } catch (e: ClassNotFoundException) { // Do not fail during
+            null
+        }
+    }
+
+    private fun <S> load(service: Class<S>, loader: ClassLoader): List<S> {
         return try {
             loadProviders(service, loader)
         } catch (e: Throwable) {

kotlinx-coroutines-core/jvm/src/internal/MainDispatchers.kt

@@ -20,13 +20,11 @@ internal object MainDispatcherLoader {
     private fun loadMainDispatcher(): MainCoroutineDispatcher {
         return try {
             val factories = if (FAST_SERVICE_LOADER_ENABLED) {
-                MainDispatcherFactory::class.java.let { clz ->
-                    FastServiceLoader.load(clz, clz.classLoader)
-                }
+                FastServiceLoader.loadMainDispatcherFactory()
             } else {
-                //We are explicitly using the
-                //`ServiceLoader.load(MyClass::class.java, MyClass::class.java.classLoader).iterator()`
-                //form of the ServiceLoader call to enable R8 optimization when compiled on Android.
+                // We are explicitly using the
+                // `ServiceLoader.load(MyClass::class.java, MyClass::class.java.classLoader).iterator()`
+                // form of the ServiceLoader call to enable R8 optimization when compiled on Android.
                 ServiceLoader.load(
                         MainDispatcherFactory::class.java,
                         MainDispatcherFactory::class.java.classLoader

ui/kotlinx-coroutines-android/android-unit-tests/build.gradle

@@ -6,6 +6,10 @@ repositories {
     google()
 }
 
+test {
+    systemProperty 'java.vendor', 'Android'
+}
+
 dependencies {
     testImplementation 'com.google.android:android:4.1.1.4'
     testImplementation 'com.android.support:support-annotations:26.1.0'

ui/kotlinx-coroutines-android/resources/META-INF/com.android.tools/proguard/coroutines.pro

@@ -3,3 +3,7 @@
 # - META-INF/proguard/coroutines.pro
 
 -keep class kotlinx.coroutines.android.AndroidDispatcherFactory {*;}
+
+-assumenosideeffects class kotlinx.coroutines.internal.FastServiceLoader {
+    boolean ANDROID_DETECTED return false;
+}

ui/kotlinx-coroutines-android/resources/META-INF/com.android.tools/r8-from-1.6.0/coroutines.pro

@@ -3,4 +3,8 @@
 # this results in direct instantiation when loading Dispatchers.Main
 -assumenosideeffects class kotlinx.coroutines.internal.MainDispatcherLoader {
     boolean FAST_SERVICE_LOADER_ENABLED return false;
+}
+
+-assumenosideeffects class kotlinx.coroutines.internal.FastServiceLoader {
+    boolean ANDROID_DETECTED return false;
 }

ui/kotlinx-coroutines-android/resources/META-INF/com.android.tools/r8-upto-1.6.0/coroutines.pro

@@ -3,3 +3,7 @@
 # - META-INF/proguard/coroutines.pro
 
 -keep class kotlinx.coroutines.android.AndroidDispatcherFactory {*;}
+
+-assumenosideeffects class kotlinx.coroutines.internal.FastServiceLoader {
+    boolean ANDROID_DETECTED return false;
+}

ui/kotlinx-coroutines-android/resources/META-INF/proguard/coroutines.pro

@@ -5,3 +5,7 @@
 # - META-INF/com.android.tools/r8-upto-1.6.0/coroutines.pro
 
 -keep class kotlinx.coroutines.android.AndroidDispatcherFactory {*;}
+
+-assumenosideeffects class kotlinx.coroutines.internal.FastServiceLoader {
+    boolean ANDROID_DETECTED return false;
+}