Android onbackpressed implements interception and pop-up process analysis of return key

Preface

This article mainly solves the blocking of the event when a user clicks the return key in the navigation bar at the bottom of the phone;

This method can still be applied to fragment

onBackPressed()

This is the method of intercepting and returning that comes with the activity;

This event is called whenever we press the return key of the bottom navigation, and we can prevent the destruction of the activity by rewriting it

For example, in the following code, we comment out super directly, and there will be no response when clicking the return key, because we do not respond in a targeted response event.

override fun onBackPressed() {
    // ()
}

onBackPressedDispatcher

fragment does not provide the onBackPressed method, so in most cases, the onBackPressedDispatcher recommended by Android is used to intercept the return key;

Next is a small case of intercepting and returning and popping up windows asking whether to exit;

To facilitate everyone's understanding, the activity is directly used instead of fragment;

First, use the attribute delegate lazy, that is, define an onBackPressedDispatcher variable in a lazy way.

class NoteActivity : AppCompatActivity() {
    private val dispatcher by lazy {
        NoteActivity().onBackPressedDispatcher
    }
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
    }
}

ThenoncreateRegister in the methodonBackPressedDispatcher；

The registration method is to add a callback function to handle the actions during interception, usingaddCallback；

addCallbackThere are two parameters, the first is the context and the second isOnBackPressedCallbackFunction method (the following code uses the lambda form to improve efficiency)

The OnBackPressedCallback function receives a parameter, and we usually fill in true;

It also needs to implement a methodhandleOnBackPressed, this is the place to deal with the corresponding practice

In the handleOnBackPressed method:

• If you want to prevent the return event, do nothing
• If you want to allow return events, use finish to end the activity

override fun onCreate(savedInstanceState: Bundle?) {
    ...
    (
        this,
        object : OnBackPressedCallback(true) {
            override fun handleOnBackPressed() {
                // Construct an AlertDialog, how to use it in detail                (this@NoteActivity).apply {
                    setTitle("Oops！")
                    setMessage("Please write a title, otherwise we can't save it")
                    setIcon(.ic_info)
                    // Click the confirm button and directly use finish to destroy this activity                    setPositiveButton("Exit directly") { dialog, which ->
                        finish()
                    }
                    // If you click Negative, you will do nothing, that is, you will not handle the return event, and it will naturally not be destroyed.                    setNegativeButton("I'll think about it again", null)
                }.show()
            }
        }
    )
}

Finally, trigger the onBackPressedDispatcher in onBackPressed (because the return key click events are intercepted by onBackPressed, and the onBackPressedDispatcher only acts as an assistant)

Pay attention to deleting or commenting on the original super, otherwise you will directly exit if you click the return key, and all your previous efforts will be wasted! ! !

override fun onBackPressed() {
    ()
}

All code display:

package 
import 
import 
import 
import 
import 
import 
import 
import 
import 
import 
class NoteActivity : AppCompatActivity() {
    private lateinit var binding: ActivityNoteBinding
    // Lazy loading    private val dispatcher by lazy {
        NoteActivity().onBackPressedDispatcher
    }
    override fun onCreate(savedInstanceState: Bundle?) {
        (savedInstanceState)
        binding = (layoutInflater)
        setContentView()
        // Register a callback event        (
            this,
            object : OnBackPressedCallback(true) {
                override fun handleOnBackPressed() {
                    (this@NoteActivity).apply {
                        setTitle("Oops！")
                        setMessage("Please write a title, otherwise we can't save it")
                        setIcon(.ic_info)
                        setPositiveButton("Exit directly") { dialog, which ->
                            finish()
                        }
                        setNegativeButton("I'll think about it again", null)
                    }.show()
                }
            }
        )
    }
    // Detect the return key click event    override fun onBackPressed() {
        ()
    }
}

This is the article about the interception and pop-up process analysis of Android onbackpressed's implementation of return keys. For more related Android onbackpressed content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!