Something wrong with multiple Global scopes - kotlin

Question

I've an app that is have 3 GlobalScopes:
First reading a stream from url, and return InputStream
Second, start after the completion of the first one, save the InputStream in the device, and return the saved file uri
Third, start after the completion of the second one, and do some processing with the file
I've something wrong in the second scope, as the file is not saved, my full code is below:
MainActivity
package com.example.dl
import android.graphics.Bitmap
import android.net.Uri
import android.os.Bundle
import android.util.Log
import android.view.View
import androidx.appcompat.app.AppCompatActivity
import com.example.dl.databinding.ActivityMainBinding
import kotlinx.coroutines.*
import java.io.File
import java.io.InputStream
import java.net.URL
import java.util.*
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
val view = binding.root
setContentView(view)
// setContentView(R.layout.activity_main)
val context = this
val urlFile:URL = URL( "https://drive.google.com/uc?export=download&id="+
"1kRtYw3_Yd7he0HjbgNlAAl9we9tQEGvm")
// show image url in text view
binding.tvDownload.text = urlFile.toString()
val tag = "Main Activity"
Log.i(tag, "Trying t get stream")
binding.button.setOnClickListener {
it.isEnabled = false // disable button
binding.progressBar.visibility = View.VISIBLE
// GlobalScope 1
// async task to get / download bitmap from url
val result: Deferred<InputStream?> = GlobalScope.async {
urlFile.toStream(context)
}
// GlobalScope 2
val saved: Deferred<Uri?> = GlobalScope.async {
// get the downloaded bitmap
val fileStream : InputStream? = result.await()
// if downloaded then saved it to internal storage
Log.i(tag, "Stream collected, trying to save it") // <--- This is printing on the LogCat
fileStream?.saveToInternalStorage(context) // <-- This looks not to be executed!
}
// GlobalScope 3
GlobalScope.launch(Dispatchers.Main) {
val savedUri : Uri? = saved.await() // <-- This looks not to be executed!
Log.i(tag, "Stream saved")
val execFile = File(savedUri.toString())
Log.i(tag, "Setting file executable")
// execFile?.setExecutable(true)
Log.i(tag, "Running executable file")
// Runtime.getRuntime().exec(savedUri.toString())
// display saved bitmap to image view from internal storage
binding.imageView.setImageURI(savedUri)
// show bitmap saved uri in text view
binding.tvSaved.text = savedUri.toString()
it.isEnabled = true // enable button
binding.progressBar.visibility = View.INVISIBLE
}
}
}
}
The function that is running in the first scope is:
package com.example.dl
import android.content.Context
import android.util.Log
import java.io.*
import java.net.HttpURLConnection
import java.net.URL
// extension function to get / download bitmap from url
fun URL.toStream(context : Context): InputStream? {
return try {
val tag = "Getting stream"
Log.i(tag, "Reading the stream from the web")
//this is the name of the local file you will create
val u = URL(this.toString())
val c = u.openConnection() as HttpURLConnection
c.requestMethod = "GET"
c.doOutput = true
c.connect()
c.inputStream
} catch (e: IOException){
null
}
}
The function that is running in the second scope, whihc looks to be no reached or not working properly, is:
package com.example.dl
import android.content.Context
import android.content.ContextWrapper
import android.net.Uri
import android.util.Log
import android.widget.Toast
import java.io.*
// extension function to save an image to internal storage
fun InputStream.saveToInternalStorage(context: Context): Uri?{
val tag = "Saving stream"
Log.i(tag, "Saving the stream from the web")
val targetFileName: String? = "server"
val wrapper = ContextWrapper(context)
var file = wrapper.getDir("images", Context.MODE_PRIVATE)
// create a file to save the downloaded one
file = File(file, targetFileName)
// get the file output stream
val stream: OutputStream = FileOutputStream(file)
Toast.makeText(context, "downloading", Toast.LENGTH_LONG).show()
var len1 = 0
return try {
// this.copyTo(stream)
var size: Long = 0
val buffer = ByteArray(1024)
Log.i(tag, "stream size ${this.readBytes().size}")
while (this.read(buffer).also { len1 = it } > 0) {
stream.write(buffer, 0, len1)
size += len1;
Log.i(tag, "file saved $size")
}
// flush the stream
stream.flush()
// close stream
stream.close()
this.close()
Log.i(tag, "file saved")
// compress bitmap
// compress(Bitmap.CompressFormat.JPEG, 100, stream)
// return the saved image uri
Uri.parse(file.absolutePath)
} catch (e: IOException){ // catch the exception
e.printStackTrace()
null
}
}
UPDATE
Updated my code based on the commint given about GlobalScope, still getting same result
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
val view = binding.root
setContentView(view)
// setContentView(R.layout.activity_main)
val context = this
val urlFile:URL = URL( "https://drive.google.com/uc?export=download&id="+
"1kRtYw3_Yd7he0HjbgNlAAl9we9tQEGvm")
// show image url in text view
binding.tvDownload.text = urlFile.toString()
binding.button.setOnClickListener {
it.isEnabled = false // disable button
binding.progressBar.visibility = View.VISIBLE
// DownloadExe(context)
val tag = "Main Activity"
Log.i(tag, "Trying t get stream")
runBlocking {
Log.i(tag, "Collect stream")
val download = async(context = Dispatchers.IO) { urlFile.toStream(context) }
val fileStream : InputStream? = download.await()
Log.i(tag, "Stream collected, trying to save it")
val save = async(context = Dispatchers.IO) {
fileStream?.saveToInternalStorage(context) // <-- Not working
}
val savedUri : Uri? = save.await()
Log.i(tag, "Stream saved, trying to get path")
val execFile = File(savedUri.toString())
Log.i(tag, "Setting file executable")
// execFile?.setExecutable(true)
Log.i(tag, "Running executable file")
// Runtime.getRuntime().exec(savedUri.toString())
// display saved bitmap to image view from internal storage
// binding.imageView.setImageURI(savedUri)
// show bitmap saved uri in text view
binding.tvSaved.text = savedUri.toString()
it.isEnabled = true // enable button
binding.progressBar.visibility = View.INVISIBLE
}
}
}
}
I got in the catlog:
I/Choreographer: Skipped 632 frames! The application may be doing too much work on its main thread.
So, I changed my code to:
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
val view = binding.root
setContentView(view)
// setContentView(R.layout.activity_main)
val context = this
val urlFile:URL = URL( "https://drive.google.com/uc?export=download&id="+
"1kRtYw3_Yd7he0HjbgNlAAl9we9tQEGvm")
// show image url in text view
binding.tvDownload.text = urlFile.toString()
binding.button.setOnClickListener {
it.isEnabled = false // disable button
binding.progressBar.visibility = View.VISIBLE
// DownloadExe(context)
val tag = "Main Activity"
Log.i(tag, "Trying t get stream")
var savedUri : Uri?
object : Thread() {
override fun run() {
runBlocking {
Log.i(tag, "Collect stream")
val download = async(context = Dispatchers.IO) { urlFile.toStream(context) }
val fileStream : InputStream? = download.await()
Log.i(tag, "Stream collected, trying to save it")
val save = async(context = Dispatchers.IO) {
fileStream?.saveToInternalStorage(context) // <-- Not working
}
savedUri = save.await()
Log.i(tag, "Stream saved, trying to get path")
val execFile = File(savedUri.toString())
Log.i(tag, "Setting file executable")
// execFile?.setExecutable(true)
Log.i(tag, "Running executable file")
// Runtime.getRuntime().exec(savedUri.toString())
// display saved bitmap to image view from internal storage
// binding.imageView.setImageURI(savedUri)
}
try {
// code runs in a thread
runOnUiThread {
// show bitmap saved uri in text view
binding.tvSaved.text = savedUri.toString()
it.isEnabled = true // enable button
binding.progressBar.visibility = View.INVISIBLE
}
} catch (ex: Exception) {
Log.i("---", "Exception in thread")
}
}
}.start()
}
}
}
But still getting the same, any my cat og is:
I/Main Activity: Trying t get stream
I/Main Activity: Collect stream
I/Getting stream: Reading the stream from the web
I/Main Activity: Stream collected, trying to save it
I/Main Activity: Stream saved, trying to get path
Setting file executable
Running executable file
W/BpBinder: Slow Binder: BpBinder transact took 227ms, interface=android.view.IWindowSession, code=5 oneway=false
W/System: A resource failed to call end.

Answer 1

This doesn't really solve your specific issue concretely, but I wanted to share how your use of coroutines could be cleaner, which might help track down the problem. As I mentioned in the comment, I think your URL.toStream extension function is likely returning null, so that would be the place to start with your debugging.
You don't need three separate coroutines because you have a sequence of tasks that you want to run in order. So they can be in a single coroutine. One of the main benefits of coroutines is that you can run sequential asynchronous code using a syntax that looks synchronous.
You should use lifecycleScope to run your coroutine, add it as.
dependencies {
implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.3.1"
}
One of the main points of a CoroutineScope is to provide a way to easily cancel all coroutines associated with some lifecycle of your application flow. In this case, you would want to cancel the coroutine when the Activity or Fragment goes away, so the pre-existing lifecycleScope is the natural choice. It is set up by the Android framework to automatically cancel all the coroutines it has launched if the Activity is destroyed while they are still running.
It should be extremely rare to ever use runBlocking, since it blocks the current thread while the coroutine is running, defeating the purpose of using coroutines. It's main purpose is in a JVM app's main function to make the whole app wait for all the coroutines to finish before shutting down. Or it can be used for unit tests. The only reason I can think of for it to ever appear in an Android application is if you have a module that is using Java 8 concurrency that you don't want to migrate to coroutines, but it's calling suspend functions from a library from a background thread.
lifecycleScope runs on the Main dispatcher. You only have to wrap blocking calls in withContext.
binding.button.setOnClickListener { button ->
lifecycleScope.launch {
button.isEnabled = false // disable button
binding.progressBar.visibility = View.VISIBLE
// perform these tasks off the main thread
val savedUri : Uri? = withContext(Dispatchers.IO) {
// get / download bitmap from url
val fileStream : InputStream? = urlFile.toStream(context)
Log.i(tag, "Stream $fileStream collected, trying to save it") // I put the reference in your log so if it is null you'll see.
fileStream?.saveToInternalStorage(context)
}
// You need to check for null. Otherwise savedUri.toString() gives you the String "null"
if (savedUri == null) {
Log.e(tag, "URI was null. Nothing to save")
return#launch
}
val execFile = File(savedUri.toString())
Log.i(tag, "Stream saved")
// Log.i(tag, "Setting file executable")
// execFile?.setExecutable(true)
// Log.i(tag, "Running executable file")
// Runtime.getRuntime().exec(savedUri.toString())
// display saved bitmap to image view from internal storage
binding.imageView.setImageURI(savedUri)
// show bitmap saved uri in text view
binding.tvSaved.text = savedUri.toString()
button.isEnabled = true // enable button
binding.progressBar.visibility = View.INVISIBLE
}
}