问题

Proper way to launch a coroutine from a click event in a fragment is not to use GlobalScope.launch. Fragment's shorter lifecycle suggests avoiding it to prevent potential memory issues. Instead, launch the coroutine directly from the click event handler since no parent functions are involved.

答案1

得分: 37

You need a job to handle the coroutine cancelation to prevent leaks:

//inside Fragment
需要一个job来处理协程取消以防止泄漏：

//在Fragment内部

val job = Job()
val uiScope = CoroutineScope(Dispatchers.Main + job)

//late in the button click
//在按钮点击事件后

button.setOnClickListener{
  uiScope.launch(Dispatchers.IO){
    //asyncOperation
    //异步操作
    withContext(Dispatchers.Main){
      //ui operation
      //UI操作
    }
  }
}

//later in onDestroy:
//稍后在onDestroy中：

override fun onDestroy(){
  job.cancel()
  super.onDestroy()
}

You can also use LifecycleScope extension from Google:

你还可以使用Google的生命周期范围扩展：

class MyFragment: Fragment() {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        lifecycleScope.launch {
            val params = TextViewCompat.getTextMetricsParams(textView)
            val precomputedText = withContext(Dispatchers.Default) {
                PrecomputedTextCompat.create(longTextContent, params)
            }
            TextViewCompat.setPrecomputedText(textView, precomputedText)
        }
    }
}

Edit, in case you would re-fire another operation. Just use the same scope:

如果您需要重新启动另一个操作，请使用相同的作用域：

//let's assume you have a second button
//假设您有第二个按钮

button2.setOnClickListener{
  uiScope.launch(Dispatchers.IO){
    //perform second operation
    //执行第二个操作
  }
}

//inside Fragment
val job = Job()
val uiScope = CoroutineScope(Dispatchers.Main + job)


//late in the button click

button.setOnClickListener{
  uiScope.launch(Dispatchers.IO){
    //asyncOperation
    withContext(Dispatchers.Main){
     //ui operation
   }

  }
}

//later in on destroy:

override fun onDestroy(){
  job.cancel()
  super.onDestroy()
}

class MyFragment: Fragment() {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        lifecycleScope.launch {
            val params = TextViewCompat.getTextMetricsParams(textView)
            val precomputedText = withContext(Dispatchers.Default) {
                PrecomputedTextCompat.create(longTextContent, params)
            }
            TextViewCompat.setPrecomputedText(textView, precomputedText)
        }
    }
}

//let's assume you have a second button

button2.setOnClickListener{
  uiScope.launch(Dispatchers.IO){
    //perform second operation
  }
}

答案2

得分: 2

GlobalScope.launch 用于启动一个协程，该协程应该在应用程序的整个生命周期内保持在内存中。

这并不一定如此，它可以用于与用户可以导航离开的应用程序的活动或阶段无关的任何协程。例如，您可以启动一个任务，向服务器发送单向消息。它可能很快就会完成，无论用户以后做什么，都希望它完成。

如果我使用 GlobalScope.launch，它是否会阻止片段被垃圾回收？

只有当协程保留对片段或其一部分的引用，并且只有当它有可能运行很长时间时才会如此。

具体来说，在点击事件中通常要执行的操作是执行涉及后端（即网络）的某些操作，然后更新UI。显然，这可能需要很长时间（特别是在网络不佳的情况下），并且它保留对稍后要操作的UI元素的引用。这应该绑定到片段的生命周期。

从片段中的点击事件启动协程的正确方法是什么？

最简单的方法如下，遵循官方文档：

class MyFragment : Fragment, CoroutineScope by MainScope {

    override fun onDestroy() {
        cancel() // extension on CoroutineScope
    }
    
    ... 剩下的片段代码 ...
}

这捕获了以前必须手动编写的惯用法（如本答案中所见）。

class MyFragment : Fragment, CoroutineScope by MainScope {

    override fun onDestroy() {
        cancel() // extension on CoroutineScope
    }
    
    ... rest of your fragment code ...
}

答案3

得分: 1

class JobFragment : Fragment() {

    private val job = Job()
    private val uiScope = CoroutineScope(Dispatchers.Main + job)
    private var button: Button? = null

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        // 为此片段充气布局
        return inflater.inflate(R.layout.fragment_job, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        button = view.findViewById(R.id.button)
        button?.setOnClickListener {
            uiScope.launch(Dispatchers.IO) {
                val fun1 = async { followers1() }
                val fun2 = async { followers2() }
                Log.e("Test1", "${fun1.await()}")
                Log.e("Test2", "${fun2.await()}")
                withContext(Dispatchers.Main) {
                    // UI 操作
                }
            }
        }
    }

    private fun followers1() {
        println("Followers Testing...")
    }

    private fun followers2() {
        println("Followers Testing...")
    }

    override fun onDestroy() {
        job.cancel()
        super.onDestroy()
    }
}

<details>
<summary>英文:</summary>

class JobFragment : Fragment() {

private val job = Job()
private val uiScope = CoroutineScope(Dispatchers.Main + job)
private var button : Button?= null
override fun onCreateView(
    inflater: LayoutInflater, container: ViewGroup?,
    savedInstanceState: Bundle?
): View? {
    // Inflate the layout for this fragment
    return inflater.inflate(R.layout.fragment_job, container, false)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)
    button = view.findViewById(R.id.button)
    button?.setOnClickListener{
        uiScope.launch(Dispatchers.IO){
            val fun1 = async { followers1() }
            val fun2 = async { followers2() }
            Log.e("Test1", "${fun1.await()}", )
            Log.e("Test2", "${fun2.await()}", )
            withContext(Dispatchers.Main){
                //ui operation
            }
        }
    }
}
private fun followers1() {
    println("Followers Testing...")
}
private fun followers2() {
    println("Followers Testing...")
}
override fun onDestroy(){
    job.cancel()
    super.onDestroy()
}

}

[![enter image description here][1]][1]


  [1]: https://i.stack.imgur.com/IquxM.png

</details>