Appeler la fonction de suspension Kotlin dans une classe Java

Question

Supposons que nous ayons la fonction de suspension suivante :

suspend fun doSomething(): List<MyClass> { ... }

Si je veux appeler cette fonction dans l'une de mes classes Java existantes (que je ne suis pas en mesure de convertir en Kotlin pour l'instant) et obtenir sa valeur de retour, je dois fournir un fichier de type Continuation<? super List<MyClass>> comme son paramètre (évidemment).

Ma question est la suivante : comment puis-je en mettre un en place ? Spécialement son getContext getter.

Answer 1

D'abord, ajoutez org.jetbrains.kotlinx:kotlinx-coroutines-jdk8 à vos dépendances. Dans votre fichier Kotlin, définissez la fonction asynchrone suivante qui correspond au style Java d'écriture des API asynchrones :

fun doSomethingAsync(): CompletableFuture<List<MyClass>> =
    GlobalScope.future { doSomething() }

Maintenant, utilisez doSomethingAsync de Java de la même manière que vous utilisez d'autres API asynchrones dans le monde Java.

Answer 2

Si vous ne voulez pas utiliser org.jetbrains.kotlinx:kotlinx-coroutines-jdk8 J'ai une nouvelle idée.

Ecrivez le code ci-dessous dans votre projet kotlin.

    @JvmOverloads
    fun <R> getContinuation(onFinished: BiConsumer<R?, Throwable?>, dispatcher: CoroutineDispatcher = Dispatchers.Default): Continuation<R> {
        return object : Continuation<R> {
            override val context: CoroutineContext
                get() = dispatcher

            override fun resumeWith(result: Result<R>) {
                onFinished.accept(result.getOrNull(), result.exceptionOrNull())
            }
        }
    }

Je l'écris dans mon Coroutines classe

Ensuite, vous pouvez appeler votre fonction de suspension comme :

            Coroutines coroutines = new Coroutines();
            UserUtils.INSTANCE.login("user", "pass", coroutines.getContinuation(
                    (tokenResult, throwable) -> {
                        System.out.println("Coroutines finished");
                        System.out.println("Result: " + tokenResult);
                        System.out.println("Exception: " + throwable);
                    }
            ));

La fonction login() est une fonction de suspension.
suspend fun login(username: String, password: String): TokenResult

Pour votre code, vous pouvez :

doSomething(getContinuation((result, throwable) -> { 
       //TODO
}));

Answer 3

Pour les coroutines 1.3.0, utilisez ceci :

BuildersKt.launch(GlobalScope.INSTANCE,
                Dispatchers.getMain(),//context to be ran on
                CoroutineStart.DEFAULT,
                (coroutineScope, continuation) -> suspendFunction(arguments)
        );

Pour java < 8 :

BuildersKt.launch(
        GlobalScope.INSTANCE,
        Dispatchers.getMain(),//context to be ran on
        CoroutineStart.DEFAULT,
        new Function2<CoroutineScope, Continuation<? super Unit>, Unit/*or your return type here*/>() {
            @Override
            public Unit/*or your return type here*/ invoke(CoroutineScope coroutineScope, Continuation<? super Unit> continuation) {
                //do what you want
                return Unit.INSTANCE; //or something with the defined type
            }
        }
);

Mon fichier gradle :

implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.3.50"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.0"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.0"

Kotlin utilise des classes statiques pour les fonctions d'extension, launch est une fonction d'extension, elle est donc définie dans BuildersKt. Le premier paramètre est la cible de la fonction d'extension, les autres sont les paramètres des fonctions d'extension.