Merge pull request #3124 from Isira-Seneviratne/Scope_extensions

Use lifecycle coroutine scope extensions.

app/src/main/java/com/github/libretube/ui/dialogs/AddToPlaylistDialog.kt

@@ -18,8 +18,6 @@ import com.github.libretube.extensions.toastFromMainThread
 import com.github.libretube.ui.models.PlaylistViewModel
 import com.github.libretube.util.PlayingQueue
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 
 /**
@@ -76,16 +74,18 @@ class AddToPlaylistDialog(
                 binding.addToPlaylist.setOnClickListener {
                     val index = binding.playlistsSpinner.selectedItemPosition
                     viewModel.lastSelectedPlaylistId = response[index].id!!
+                    dialog?.hide()
+                    lifecycleScope.launch {
                         addToPlaylist(response[index].id!!)
                         dialog?.dismiss()
                     }
                 }
             }
         }
+    }
 
-    private fun addToPlaylist(playlistId: String) {
+    private suspend fun addToPlaylist(playlistId: String) {
         val appContext = context?.applicationContext ?: return
-        CoroutineScope(Dispatchers.IO).launch {
         val streams = when {
             videoId != null -> listOf(
                 RetrofitInstance.api.getStreams(videoId).toStreamItem(videoId)
@@ -98,13 +98,12 @@ class AddToPlaylistDialog(
         } catch (e: Exception) {
             Log.e(TAG(), e.toString())
             appContext.toastFromMainThread(R.string.unknown_error)
-                return@launch
+            return
         }
         appContext.toastFromMainThread(
             if (success) R.string.added_to_playlist else R.string.fail
         )
     }
-    }
 
     private fun Fragment?.runOnUiThread(action: () -> Unit) {
         this ?: return

app/src/main/java/com/github/libretube/ui/dialogs/CreatePlaylistDialog.kt

@@ -4,12 +4,12 @@ import android.app.Dialog
 import android.os.Bundle
 import android.widget.Toast
 import androidx.fragment.app.DialogFragment
+import androidx.lifecycle.lifecycleScope
 import com.github.libretube.R
 import com.github.libretube.api.PlaylistsHelper
 import com.github.libretube.databinding.DialogCreatePlaylistBinding
 import com.github.libretube.extensions.toastFromMainThread
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -28,17 +28,19 @@ class CreatePlaylistDialog(
             val appContext = context?.applicationContext
 
             playlistUrl?.queryParameter("list")?.let {
-                CoroutineScope(Dispatchers.IO).launch {
+                lifecycleScope.launch {
-                    val playlistId = PlaylistsHelper.clonePlaylist(requireContext(), it)?.also {
+                    requireDialog().hide()
-                        withContext(Dispatchers.Main) {
+                    val playlistId = withContext(Dispatchers.IO) {
-                            onSuccess.invoke()
+                        PlaylistsHelper.clonePlaylist(requireContext(), it)
                     }
+                    if (playlistId != null) {
+                        onSuccess()
                     }
                     appContext?.toastFromMainThread(
                         if (playlistId != null) R.string.playlistCloned else R.string.server_error
                     )
-                }
                     dismiss()
+                }
             } ?: run {
                 Toast.makeText(context, R.string.invalid_url, Toast.LENGTH_SHORT).show()
             }
@@ -53,16 +55,16 @@ class CreatePlaylistDialog(
             binding.createNewPlaylist.setOnClickListener(null)
             val listName = binding.playlistName.text.toString()
             if (listName != "") {
-                CoroutineScope(Dispatchers.IO).launch {
+                lifecycleScope.launch {
-                    val playlistId = PlaylistsHelper.createPlaylist(
+                    requireDialog().hide()
-                        listName,
+                    val playlistId = withContext(Dispatchers.IO) {
-                        requireContext().applicationContext
+                        PlaylistsHelper.createPlaylist(listName, requireContext())
-                    )
-                    withContext(Dispatchers.Main) {
-                        if (playlistId != null) onSuccess.invoke()
                     }
+                    if (playlistId != null) {
+                        onSuccess()
                     }
                     dismiss()
+                }
             } else {
                 Toast.makeText(context, R.string.emptyPlaylistName, Toast.LENGTH_LONG).show()
             }

app/src/main/java/com/github/libretube/ui/dialogs/RenamePlaylistDialog.kt

@@ -1,20 +1,22 @@
 package com.github.libretube.ui.dialogs
 
 import android.app.Dialog
+import android.content.DialogInterface
 import android.os.Bundle
 import android.text.InputType
 import android.util.Log
 import android.widget.Toast
 import androidx.fragment.app.DialogFragment
+import androidx.lifecycle.lifecycleScope
 import com.github.libretube.R
 import com.github.libretube.api.PlaylistsHelper
 import com.github.libretube.databinding.DialogTextPreferenceBinding
 import com.github.libretube.extensions.TAG
 import com.github.libretube.extensions.toastFromMainThread
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 class RenamePlaylistDialog(
     private val playlistId: String,
@@ -29,7 +31,11 @@ class RenamePlaylistDialog(
         return MaterialAlertDialogBuilder(requireContext())
             .setTitle(R.string.renamePlaylist)
             .setView(binding.root)
-            .setPositiveButton(R.string.okay) { _, _ ->
+            .setPositiveButton(R.string.okay, null)
+            .setNegativeButton(R.string.cancel, null)
+            .show()
+            .apply {
+                getButton(DialogInterface.BUTTON_POSITIVE).setOnClickListener {
                     val input = binding.input.text.toString()
                     if (input == "") {
                         Toast.makeText(
@@ -37,13 +43,17 @@ class RenamePlaylistDialog(
                             R.string.emptyPlaylistName,
                             Toast.LENGTH_SHORT
                         ).show()
-                    return@setPositiveButton
+                        return@setOnClickListener
                     }
-                if (input == currentPlaylistName) return@setPositiveButton
+                    if (input == currentPlaylistName) return@setOnClickListener
                     val appContext = requireContext().applicationContext
-                CoroutineScope(Dispatchers.IO).launch {
+
+                    lifecycleScope.launch {
+                        requireDialog().hide()
                         val success = try {
-                        PlaylistsHelper.renamePlaylist(playlistId, binding.input.text.toString())
+                            withContext(Dispatchers.IO) {
+                                PlaylistsHelper.renamePlaylist(playlistId, input)
+                            }
                         } catch (e: Exception) {
                             Log.e(TAG(), e.toString())
                             e.localizedMessage?.let { appContext.toastFromMainThread(it) }
@@ -54,9 +64,9 @@ class RenamePlaylistDialog(
                         } else {
                             appContext.toastFromMainThread(R.string.server_error)
                         }
+                        dismiss()
+                    }
                 }
             }
-            .setNegativeButton(R.string.cancel, null)
-            .show()
     }
 }

app/src/main/java/com/github/libretube/ui/fragments/CommentsRepliesFragment.kt

@@ -8,6 +8,7 @@ import android.view.ViewGroup
 import androidx.core.view.updatePadding
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.lifecycleScope
 import androidx.recyclerview.widget.LinearLayoutManager
 import com.github.libretube.api.JsonHelper
 import com.github.libretube.api.RetrofitInstance
@@ -19,7 +20,6 @@ import com.github.libretube.extensions.TAG
 import com.github.libretube.ui.adapters.CommentsAdapter
 import com.github.libretube.ui.extensions.filterNonEmptyComments
 import com.github.libretube.ui.models.CommentsViewModel
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -89,7 +89,7 @@ class CommentsRepliesFragment : Fragment() {
         nextPage: String,
         onFinished: (CommentsPage) -> Unit
     ) {
-        CoroutineScope(Dispatchers.IO).launch {
+        lifecycleScope.launch(Dispatchers.IO) {
             if (isLoading) return@launch
             isLoading = true
             repliesPage = try {

app/src/main/java/com/github/libretube/ui/fragments/PlayerFragment.kt

@@ -109,7 +109,6 @@ import java.io.IOException
 import java.util.*
 import java.util.concurrent.Executors
 import kotlin.math.abs
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
@@ -656,7 +655,7 @@ class PlayerFragment : Fragment(R.layout.fragment_player), OnlinePlayerOptions {
             }
 
             if (PlayingQueue.isEmpty()) {
-                CoroutineScope(Dispatchers.IO).launch {
+                lifecycleScope.launch(Dispatchers.IO) {
                     if (playlistId != null) {
                         PlayingQueue.insertPlaylist(playlistId!!, streams.toStreamItem(videoId!!))
                     } else if (channelId != null) {
@@ -721,7 +720,7 @@ class PlayerFragment : Fragment(R.layout.fragment_player), OnlinePlayerOptions {
      * fetch the segments for SponsorBlock
      */
     private fun fetchSponsorBlockSegments() {
-        CoroutineScope(Dispatchers.IO).launch {
+        lifecycleScope.launch(Dispatchers.IO) {
             runCatching {
                 val categories = PlayerHelper.getSponsorBlockCategories()
                 if (categories.isEmpty()) return@runCatching

app/src/main/java/com/github/libretube/ui/models/CommentsViewModel.kt

@@ -3,16 +3,15 @@ package com.github.libretube.ui.models
 import android.util.Log
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
 import com.github.libretube.api.RetrofitInstance
 import com.github.libretube.api.obj.CommentsPage
 import com.github.libretube.extensions.TAG
 import com.github.libretube.ui.extensions.filterNonEmptyComments
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 
 class CommentsViewModel : ViewModel() {
-    private val scope = CoroutineScope(Dispatchers.IO)
     private var isLoading = false
 
     val commentsPage = MutableLiveData<CommentsPage?>()
@@ -25,7 +24,7 @@ class CommentsViewModel : ViewModel() {
 
     fun fetchComments() {
         videoId ?: return
-        scope.launch {
+        viewModelScope.launch(Dispatchers.IO) {
             isLoading = true
             val response = try {
                 RetrofitInstance.api.getComments(videoId!!)
@@ -42,7 +41,7 @@ class CommentsViewModel : ViewModel() {
 
     fun fetchNextComments() {
         if (isLoading || nextPage == null || videoId == null) return
-        scope.launch {
+        viewModelScope.launch(Dispatchers.IO) {
             isLoading = true
             val response = try {
                 RetrofitInstance.api.getCommentsNextPage(videoId!!, nextPage!!)

app/src/main/java/com/github/libretube/ui/preferences/MainSettings.kt

@@ -4,6 +4,7 @@ import android.os.Bundle
 import androidx.annotation.StringRes
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.commitNow
+import androidx.lifecycle.lifecycleScope
 import androidx.preference.Preference
 import com.github.libretube.BuildConfig
 import com.github.libretube.R
@@ -12,9 +13,9 @@ import com.github.libretube.ui.activities.SettingsActivity
 import com.github.libretube.ui.base.BasePreferenceFragment
 import com.github.libretube.ui.dialogs.UpdateAvailableDialog
 import com.google.android.material.snackbar.Snackbar
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 class MainSettings : BasePreferenceFragment() {
     override val titleResourceId: Int = R.string.settings
@@ -84,10 +85,12 @@ class MainSettings : BasePreferenceFragment() {
 
         // checking for update: yes -> dialog, no -> snackBar
         update?.setOnPreferenceClickListener {
-            CoroutineScope(Dispatchers.IO).launch {
+            lifecycleScope.launch {
                 // check for update
                 val updateInfo = try {
+                    withContext(Dispatchers.IO) {
                         RetrofitInstance.externalApi.getUpdateInfo()
+                    }
                 } catch (e: Exception) {
                     showSnackBar(R.string.unknown_error)
                     return@launch

app/src/main/java/com/github/libretube/ui/sheets/BaseBottomSheet.kt

@@ -4,10 +4,12 @@ import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
+import androidx.lifecycle.lifecycleScope
 import androidx.recyclerview.widget.LinearLayoutManager
 import com.github.libretube.databinding.BottomSheetBinding
 import com.github.libretube.obj.BottomSheetItem
 import com.github.libretube.ui.adapters.BottomSheetAdapter
+import kotlinx.coroutines.launch
 
 open class BaseBottomSheet : ExpandedBottomSheet() {
     private lateinit var items: List<BottomSheetItem>
@@ -30,19 +32,17 @@ open class BaseBottomSheet : ExpandedBottomSheet() {
         binding.optionsRecycler.adapter = BottomSheetAdapter(items, listener)
     }
 
-    fun setItems(items: List<BottomSheetItem>, listener: ((index: Int) -> Unit)?) = apply {
+    fun setItems(items: List<BottomSheetItem>, listener: (suspend (index: Int) -> Unit)?) = apply {
         this.items = items
         this.listener = { index ->
+            lifecycleScope.launch {
+                dialog?.hide()
                 listener?.invoke(index)
-            dialog?.dismiss()
+                dismiss()
+            }
         }
     }
 
-    fun setSimpleItems(titles: List<String>, listener: ((index: Int) -> Unit)?) = apply {
+    fun setSimpleItems(titles: List<String>, listener: (suspend (index: Int) -> Unit)?) =
-        this.items = titles.map { BottomSheetItem(it) }
+        setItems(titles.map { BottomSheetItem(it) }, listener)
-        this.listener = { index ->
-            listener?.invoke(index)
-            dialog?.dismiss()
-        }
-    }
 }

app/src/main/java/com/github/libretube/ui/sheets/ChannelOptionsBottomSheet.kt

@@ -11,7 +11,8 @@ import com.github.libretube.helpers.BackgroundHelper
 import com.github.libretube.helpers.NavigationHelper
 import com.github.libretube.obj.ShareData
 import com.github.libretube.ui.dialogs.ShareDialog
-import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 
 /**
  * Dialog with different options for a selected video.
@@ -41,7 +42,7 @@ class ChannelOptionsBottomSheet(
                 }
                 getString(R.string.play_latest_videos) -> {
                     try {
-                        val channel = runBlocking {
+                        val channel = withContext(Dispatchers.IO) {
                             RetrofitInstance.api.getChannel(channelId)
                         }
                         channel.relatedStreams.firstOrNull()?.url?.toID()?.let {
@@ -57,7 +58,7 @@ class ChannelOptionsBottomSheet(
                 }
                 getString(R.string.playOnBackground) -> {
                     try {
-                        val channel = runBlocking {
+                        val channel = withContext(Dispatchers.IO) {
                             RetrofitInstance.api.getChannel(channelId)
                         }
                         channel.relatedStreams.firstOrNull()?.url?.toID()?.let {

app/src/main/java/com/github/libretube/ui/sheets/PlaylistOptionsBottomSheet.kt

@@ -8,7 +8,6 @@ import com.github.libretube.db.DatabaseHolder
 import com.github.libretube.enums.PlaylistType
 import com.github.libretube.enums.ShareObjectType
 import com.github.libretube.extensions.awaitQuery
-import com.github.libretube.extensions.query
 import com.github.libretube.extensions.toID
 import com.github.libretube.extensions.toastFromMainThread
 import com.github.libretube.helpers.BackgroundHelper
@@ -16,10 +15,8 @@ import com.github.libretube.obj.ShareData
 import com.github.libretube.ui.dialogs.DeletePlaylistDialog
 import com.github.libretube.ui.dialogs.RenamePlaylistDialog
 import com.github.libretube.ui.dialogs.ShareDialog
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
-import kotlinx.coroutines.runBlocking
 
 class PlaylistOptionsBottomSheet(
     private val playlistId: String,
@@ -55,29 +52,27 @@ class PlaylistOptionsBottomSheet(
             when (optionsList[which]) {
                 // play the playlist in the background
                 getString(R.string.playOnBackground) -> {
-                    runBlocking {
+                    val playlist = withContext(Dispatchers.IO) {
-                        val playlist = PlaylistsHelper.getPlaylist(playlistId)
+                        PlaylistsHelper.getPlaylist(playlistId)
-                        if (playlist.relatedStreams.isEmpty()) return@runBlocking
+                    }
+                    playlist.relatedStreams.firstOrNull()?.let {
                         BackgroundHelper.playOnBackground(
-                            context = requireContext(),
+                            requireContext(),
-                            videoId = playlist.relatedStreams[0].url!!.toID(),
+                            it.url!!.toID(),
                             playlistId = playlistId
                         )
                     }
                 }
                 // Clone the playlist to the users Piped account
                 getString(R.string.clonePlaylist) -> {
-                    val appContext = context?.applicationContext
+                    val context = requireContext()
-                    CoroutineScope(Dispatchers.IO).launch {
+                    val playlistId = withContext(Dispatchers.IO) {
-                        val playlistId = PlaylistsHelper.clonePlaylist(
+                        PlaylistsHelper.clonePlaylist(context, playlistId)
-                            requireContext().applicationContext,
+                    }
-                            playlistId
+                    context.toastFromMainThread(
-                        )
-                        appContext?.toastFromMainThread(
                         if (playlistId != null) R.string.playlistCloned else R.string.server_error
                     )
                 }
-                }
                 // share the playlist
                 getString(R.string.share) -> {
                     val shareDialog = ShareDialog(playlistId, ShareObjectType.PLAYLIST, shareData)
@@ -87,7 +82,7 @@ class PlaylistOptionsBottomSheet(
                 getString(R.string.deletePlaylist) -> {
                     DeletePlaylistDialog(playlistId, playlistType) {
                         // try to refresh the playlists in the library on deletion success
-                        onDelete.invoke()
+                        onDelete()
                     }.show(parentFragmentManager, null)
                 }
                 getString(R.string.renamePlaylist) -> {
@@ -95,22 +90,18 @@ class PlaylistOptionsBottomSheet(
                         .show(parentFragmentManager, null)
                 }
                 else -> {
-                    CoroutineScope(Dispatchers.IO).launch {
+                    withContext(Dispatchers.IO) {
                         if (isBookmarked) {
-                            query {
+                            DatabaseHolder.Database.playlistBookmarkDao().deleteById(playlistId)
-                                DatabaseHolder.Database.playlistBookmarkDao()
-                                    .deleteById(playlistId)
-                            }
                         } else {
                             val bookmark = try {
                                 RetrofitInstance.api.getPlaylist(playlistId)
                             } catch (e: Exception) {
-                                return@launch
+                                return@withContext
                             }.toPlaylistBookmark(playlistId)
                             DatabaseHolder.Database.playlistBookmarkDao().insertAll(bookmark)
                         }
                     }
-                    dismiss()
                 }
             }
         }

app/src/main/java/com/github/libretube/ui/sheets/VideoOptionsBottomSheet.kt

@@ -18,9 +18,8 @@ import com.github.libretube.ui.dialogs.DownloadDialog
 import com.github.libretube.ui.dialogs.ShareDialog
 import com.github.libretube.ui.fragments.SubscriptionsFragment
 import com.github.libretube.util.PlayingQueue
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 /**
  * Dialog with different options for a selected video.
@@ -75,29 +74,25 @@ class VideoOptionsBottomSheet(
                     shareDialog.show(parentFragmentManager, ShareDialog::class.java.name)
                 }
                 getString(R.string.play_next) -> {
-                    CoroutineScope(Dispatchers.IO).launch {
                     try {
-                            PlayingQueue.addAsNext(
+                        val streamItem = withContext(Dispatchers.IO) {
-                                RetrofitInstance.api.getStreams(videoId)
+                            RetrofitInstance.api.getStreams(videoId).toStreamItem(videoId)
-                                    .toStreamItem(videoId)
+                        }
-                            )
+                        PlayingQueue.addAsNext(streamItem)
                     } catch (e: Exception) {
                         e.printStackTrace()
                     }
                 }
-                }
                 getString(R.string.add_to_queue) -> {
-                    CoroutineScope(Dispatchers.IO).launch {
                     try {
-                            PlayingQueue.add(
+                        val streamItem = withContext(Dispatchers.IO) {
-                                RetrofitInstance.api.getStreams(videoId)
+                            RetrofitInstance.api.getStreams(videoId).toStreamItem(videoId)
-                                    .toStreamItem(videoId)
+                        }
-                            )
+                        PlayingQueue.add(streamItem)
                     } catch (e: Exception) {
                         e.printStackTrace()
                     }
                 }
-                }
                 getString(R.string.mark_as_watched) -> {
                     val watchPosition = WatchPosition(videoId, Long.MAX_VALUE)
                     CoroutineScope(Dispatchers.IO).launch {