Android how to use Kotlin-Coroutine in Java?

Question

Recently I am learning kotlin-coroutine by following this CodeLabs tutorial. After some hands on, I was wondering if I could the same code in java. So first I wrote a simple kotlin code in MyKotlinFragment.kt file like this:

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch

// ... some codes

    private fun myKoroutineDemo(){
        GlobalScope.launch {
            val result1:Int = foo();
            val result2:Int = bar();
            val result3 = result1 + result2;
            Log.e(TAG, ""+result3);
        }
    }

    suspend fun foo():Int{
        delay(2000);
        var result = 2+2;
        delay(500);
        return result;
    }

    suspend fun bar():Int{
        delay(2000);
        var result = 7-2;
        delay(500);
        return result;

    }

And called myKotlinDemo() in my fragment; it works.

Next I opended a java file named MyCoroutineFragment.java in the same project but I can't make it work.

import kotlinx.coroutines.delay;     
import kotlinx.coroutines.launch;   // delay and launch imports arenot fount and so they are red

private suspend int foo(){ return 2 + 2; }
// the `suspend` keyword is not found by android studio, same with the bar method

private void myCoroutineDemo(){
  // GlobalScope.launch don't show up here, 
}

I can't convert the first file into Java. How can I fix this?

If it is impossible to convert, why and how else can I use coroutine in Java?

There is no way to fix it. You cannot use coroutines from Java; they are a language feature only in Kotlin. — Louis Wasserman, Apr 16 '20 at 15:07

score 3 · Accepted Answer · edited Nov 23 '21 at 05:07

3

For coroutines in Java question, check this question on stackOverflow.

But in my hummble opinion, use other tools for asynchronous call (e.g. RXjava). You gonna suffer from callbacks but I think it will be fine.

But be aware not to use AsyncTask as it's now deprecated.

edited Nov 23 '21 at 05:07

Nimantha

6,405
6
28
69

answered Apr 16 '20 at 14:29

MustafaKhaled

1,343
9
25

score -2 · Answer 2 · edited Mar 26 '21 at 13:58

For simple background tasks, I recommend using the async class Runnable.

Example call:

mRunnable = Runnable {
    // May or may not run on the UI Thread, depending on the way you call the Handler.
}

Handler mHandler = new Handler();
// Run it using "mHandler.run()". Or run it delayed:
mHandler.postDelayed(
    mRunnable, // Runnable
    1000 // Delay in milliseconds
)

Alternative would be to use a real thread, which you can create on the fly, or create a class and inherit from Thread:

Thread thread = new Thread() {
    @Override
    public void run() {
        try {
            // Does not run on UI thread (non-blocking)
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
};

thread.start();

The exact reason why coroutines were invented is to avoid this spaghetti-code and uncertain multi-threading. — Roman Truba, Apr 08 '21 at 00:21

Android how to use Kotlin-Coroutine in Java?

2 Answers2