An article about ButterKnife to make the code more concise

Preface

Android developers all know that each time you initialize a control and set the corresponding events, the process is long and disgusting. Let's review the past together. In those years, we initialized the control like this:

 // Every time I write a initView() method
 tvContent = (TextView) findViewById(R.id.btn_content);
 // When the project was big, the stuff in here used to occupy half of the space... It was miserable.
 // Of course, I have encapsulated methods to avoid various findViewById, but it is still the same...

In those years, we set up events like this:

 tvContent.setOnClickListener(this);
 // Of course, LZ's habit is still to throw it into initView, allowing them to indulge themselves~

But, young man, as an Android developer, can you continue to endure this unbearable destruction? The answer is of course no!

Then, let's bring you a magic tool to help us develop efficiently and quickly~

ButterKnife First Look

ButterKnife is also nicknamed the Butter Knife. As for why it is nicknamed this, you can see the icon captured from the official website below~

A tablecloth, a plate, a little Android robot-shaped butter, and a knife. These are collectively called a butter knife. (I said, I was confused for a long time and couldn't figure out what a butter knife is, but now I know.) The simple explanation below the icon is to provide binding fields and methods for Android views. In other words, we can use this knife to replace the trivial initialization in the future~

If you are interested, you can also go to the official website to have a look. Below is the official website address and GitHub address with the API address attached.

Official address: http://jakewharton.github.io/butterknife/

GitHub address: https://github.com/JakeWharton/butterknife

API access address: http://jakewharton.github.io/butterknife/javadoc/

After a brief understanding, let's get some practical tips. Otherwise, it's not fair.

First of all, we need to understand that ButterKnife is an open source library created by Android master Jake Wharton. Its function is to simplify the amount of code by annotating the method of binding views (reducing the amount of code we wrote when findingViewById and setting events).

When we use something, we must know what its advantages are? What convenience can I get from using it? Then, let's see what advantages this "butter knife" has, so that it can simplify some of our codes?

ButterKnife Advantages

1. Powerful View binding, Click event processing function and resource content, simplify code and improve development efficiency;

2. Conveniently handle the ViewHolder binding problem in the Adapter;

3. It will not affect the efficiency of APP during operation and is easy to use and configure;

4. The code is clear and readable.

After understanding the advantages of ButterKnife, out of curiosity, let's see what aspects it supports. In other words, in what cases can we use ButterKnife to reduce the amount of code we have in our development process?

ButterKnife usage scenarios

• View binding: for example, initializing controls;
• Resource binding: such as color, string, etc.;
• Non-Activity binding: This is when using fragment;
• View List binding: ViewHolder in Adapter, the specific usage will be explained below;
• Listener binding: This is easy to understand, that is, the events that the control needs to listen to at ordinary times.

ButterKnife Syntax

1. Activity fragment binding and fragment unbinding

To use ButterKnife, after a simple configuration, we also need to bind it in onCreate() in Activity, as follows:

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 //Must be bound after setContentView()
        ButterKnife.bind(this);
 }

If you use fragment, the official binding and unbinding are as follows:

 public class FancyFragment extends Fragment {
  @BindView(R.id.button1) Button button1;
  @BindView(R.id.button2) Button button2;
 private Unbinder unbinder; 
 
 @Override public   View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
 View   view = inflater.inflate(R.layout.fancy_fragment, container, false );
 // Binding
    unbinder = ButterKnife.bind(this, view );
 // TODO Use fields...
 return   view ;
 } 
 
  @Override public void onDestroyView() {
 super.onDestroyView();
 // Unbind
 unbinder.unbind();
 }
 }

After binding, let's take a look at several commonly used listeners. How do we write related events after using ButterKnife? Don't worry, read on~

2. Click Event

First, let's take a look at what useful information we can get from the code provided by others on the surface

First of all, it is clear that targetType is View, setter is setOnClickListener, type is the click event encapsulated by ButterKnife (butterknife.internal.DebouncingOnClickListener), and the method has two parameters named doClick and parameters of View type; and the following interface requires us to pass an id.

After a brief understanding, we derived three ways of writing, as follows:

 //Writing 1
 @OnClick(control ID)
 void method name() {
 //Business logic operation
 } 
    
 //Writing 2
 @OnClick(control ID)
 void method name (control type) {
 //Business logic operation
 } 
    
 //Writing 3
 @OnClick(control ID)
 void method name ( View   view ) {
 //Business logic operation
 }

You can write them one by one as specified above, or you can bind multiple ones, such as the following writing method provided by the official website:

3. Long press event

We still look at how others write and see what we can learn.

Compared with the single click event, the long press event has an additional returnType (return value), and the default value is false. So, the writing method is as follows~

 // Method 1
 boolean method name(){
 //Business logic operation
 return   false ;
 } 
    
 // Method 2
 boolean method name (control type) {
 //Business logic operation
 return   false ;
 } 
 
 // Method 3
 boolean method name ( View   view ){
 //Business logic operation
 return   false ;
 }

4. Checked change event

Old rules:

Changes, in general, will provide us with an identifier to facilitate us to handle different logic according to different states, so...

 //Writing 1
 @OnCheckedChanged(control ID)
    void radioButtonCheckChange(boolean isl) {
 // Business logic
 } 
     
 //Writing 2
 @OnCheckedChanged(control ID)
 void radioButtonCheckChange(control type, boolean isl) {
 // Business logic
 }

5. Listen for button events in the lower right corner of the soft keyboard

Old rules:

So...After the above, you can know that we only need to focus on parameters and whether it is returnType.

 //Writing 1
 @OnEditorAction(control ID)
 boolean methodName() {
 //Business logic operation
 return   false ;
 } 
 
 //Writing 2
 // code: status code
 @OnEditorAction(control ID)
    boolean EditTextAction( int code) {
 //Business logic operation
 return   false ;
 } 
 
 //Writing 3
 //KeyEvent
 @OnEditorAction(control ID)
    boolean EditTextAction(KeyEvent keyEvent) {
 //Business logic operation
 return   false ;
 } 
 
 //Writing 4
 @OnEditorAction(control ID)
    boolean EditTextAction( int code, KeyEvent keyEvent) {
 //Business logic operation
 return   false ;
 } 
 
 //Writing 5
 @OnEditorAction(control ID)
    boolean EditTextAction(TextView textView, int code, KeyEvent keyEvent) {
 //Business logic operation
 return   false ;
 }

6. EditText content change listener event

Since the source code is long and it is not convenient to take screenshots, part of the code is intercepted for analysis, as follows:

 @Target(METHOD)
 @Retention(CLASS)
 @ListenerClass(
    targetType = "android.widget.TextView" ,
    setter = "addTextChangedListener" ,
    remover = "removeTextChangedListener" ,
 type = "android.text.TextWatcher" , ---> Here we also do the same processing as before for TextWatcher ggg  
 callbacks = OnTextChanged.Callback.class ---> Custom enumeration, identifying the current operation by enumeration type 666  
 )
 public @interface OnTextChanged {
  /** View IDs to which the method will be bound. */
 @IdRes int [] value() default { View .NO_ID }; ---> ID needs to be passed in   
 
  /** Listener callback to which the method will be bound. */
 Callback callback() default Callback.TEXT_CHANGED; ---> unchanged state   
 
  /** {@link TextWatcher} callback methods. */
 enum Callback { ---> There are three types of enumerations: Unchanged Before Change After Change  
    /** {@link TextWatcher#onTextChanged(CharSequence, int , int , int )} */
 @ListenerMethod(
 name = "onTextChanged" , ---> Currently marked as unchanged  
 parameters = {
 "java.lang.CharSequence" , ---> user input characters  
 "int" , ---> change the previous number  
 "int" , ---> When testing, it returns 0, but I don't understand what it means  
 "int"    ---> Based on the print results, I guess this should be the number of contents added each time  
 }
 )
 TEXT_CHANGED, 
 
    /** {@link TextWatcher#beforeTextChanged(CharSequence, int , int , int )} */
 @ListenerMethod(
 name = "beforeTextChanged" , ---> Current mark is before change  
 parameters = {
 "java.lang.CharSequence" , ---> user input characters  
 "int" , ---> change the previous number  
 "int" ,
 "int"  
 }
 )
 BEFORE_TEXT_CHANGED, 
 
    /** {@link TextWatcher#afterTextChanged(android.text.Editable)} */
 @ListenerMethod(
 name = "afterTextChanged" , ---> currently marked as after change  
        parameters = "android.text.Editable"    ---> User input characters  
 )
 AFTER_TEXT_CHANGED, ---> This is the focus of our attention. We only need to monitor this and do relevant processing each time.  
 }

From the above, we know that regarding the EditText content change event, our focus is only on whether the changed content format (number) meets the project requirements, and other things can be temporarily ignored, thus deriving the following writing:

 // Listen after content changes
 // Editable editable: user input characters
 @OnTextChanged(value = control ID, callback = listener type, the value after change is: OnTextChanged.Callback.AFTER_TEXT_CHANGED)
    void editTextChangeAfter(Editable editable) {
 // Business logic
 } 
 
 // Listen before content changes
 @OnTextChanged(value = control ID, callback = listener type, value before change: OnTextChanged.Callback.BEFORE_TEXT_CHANGED)
    void editTextChangeBefore(CharSequence s, int start) {
 // Business logic
 } 
 
 // The content has not changed.
 @OnTextChanged(value = control ID, callback = listener type, value: OnTextChanged.Callback.TEXT_CHANGED)
    void editTextChange(CharSequence s, int start) {
 // Business logic
 }

7. Focus Listener Event

Old rules:

It can be seen from this that:

 @OnFocusChange(control ID)
    void editTextFocus(boolean isl){
 // Business logic
 }

8. Touch monitoring events

Old rules:

The writing method is as follows:

 @OnTouch(control ID)
    boolean imageView(MotionEvent event){
 // Business logic
 return   false ;
 }

9. Item click listener event

Old rules:

so...

 @OnItemClick(control ID)
    void listItemClick( int position){
 // Business logic
 }

10. Item long press listener event

Old rules:

so...

 @OnItemLongClick(R.id.listView)
    boolean listItemLongClick( int position) {
 Toast.makeText(this, "OnItemLongClick---Clicked the " + position + " , Toast.LENGTH_SHORT).show();
 return   true ;
 }

ButterKnife Use Notes

1.Activity ButterKnife.bind(this) must be after setContentView(), and after the parent class is bound, the subclass does not need to bind again;

2. When used in Fragment, you need to pass in the view: Fragment ButterKnife.bind(this, mRootView);

3. The attribute layout cannot be modified with private or static, otherwise an error will be reported;

4. setContentView() cannot be implemented through annotations. (Some other annotation frameworks can)

Through the brief introduction above, I believe everyone has a preliminary understanding of this knife. So how can we improve our code by using this knife in Android Studio? Let's continue to look down.

Android Studio uses ButterKnife to prepare for operation

If you want to use ButterKnife in Android Studio, you first need to download and install the ButterKnife plug-in, and then use it after a simple configuration~

Step 1: Integrate ButterKnife plugin into Android Studio

1. Click File ---> Settings... ---> Select Plugins (You can also use the shortcut key Ctrl+Alt+S)

2. Enter ButterKnife, select "Android ButterKnife Zelezny", click Install (LZ has already installed it here), and then Android Studio will prompt you to restart AS, just confirm it.

3. After the above two simple steps, our Android Studio has acquired a new skill, that is: support for ButterKnife plug-in!

Step 2: Configure ButterKnife

1. Before use, we need to perform a simple configuration of ButterKnife (introduce 'com.jakewharton:butterknifecompiler:8.5.1', ​​'com.jakewharton:butterknife:8.5.1' for our project). The introduction process is as follows:

2. After the introduction is completed, let's try it out first~

In onCreate in MainActivity, right-click layout, select Generate..., Generate ButterKnife Injections, select the controls to use the annotation, and click Confirm.

One-click visual operation, convenient and fast~ After the above configuration, we can use ButterKnife to our heart's content in the project~

A part of knife skills, playing with common event monitoring

1. Add several common controls to the MainActivity layout. Right-click the layout, select Generate..., Generate ButterKnife Injections, select the controls to use annotations, and click Confirm to generate the foundation for our next demonstration (which will be changed later), as shown in the following figure~

Next, I will demonstrate the use of related events and play with the butter knife little by little.

1. Click event (taking TextView as an example)

The code is as follows:

 @OnClick(R.id.text)
 void textClick() {
 Toast.makeText(MainActivity.this, "TextView's click event triggers... (no parameter - default)" , Toast.LENGTH_SHORT).show();
 } 
 
 @OnClick(R.id.text)
    void textClick(TextView textView){
 Toast.makeText(MainActivity.this, "TextView's click event triggers...(TextView)" , Toast.LENGTH_SHORT).show();
 } 
 
 @OnClick(R.id.text)
 void textClick( View   view ){
 Toast.makeText(MainActivity.this, "TextView's click event triggers...(View)" , Toast.LENGTH_SHORT).show();
 }

Operation results display:

2. Long press event (taking Button as an example)

The code is as follows:

 @OnLongClick(R.id.button)
    boolean buttonLongClick(){
 Toast.makeText(MainActivity.this, "Button's long press event triggers... (no parameter - default)" , Toast.LENGTH_SHORT).show();
 return   false ;
 } 
 
 // @OnLongClick(R.id.button)
 // boolean buttonLongClick(Button button){
 // Toast.makeText(MainActivity.this, "Button's long press event triggers...(TextView)" , Toast.LENGTH_SHORT).show();
 // return   false ;
 // } 
 
 // @OnLongClick(R.id.button)
 // boolean buttonLongClick( View   view ){
 // Toast.makeText(MainActivity.this, "Button's long press event triggers...(View)" , Toast.LENGTH_SHORT).show();
 // return   false ;
 // }

The results are as follows:

Here you may ask, why did you comment out the following, does it mean it cannot be used? Indeed, there is no comment at the beginning, and an exception occurs during operation, as shown below:

 Multiple listener methods with   return value specified for ID：2131165193

LZ understands that this monitor will only return the corresponding monitor for ID (2131165193), that is, one-to-one correspondence! So... There is no room for two tigers in one mountain, unless one is male and the other is female~

3. Checked change event (taking CheckBox as an example)

The code is as follows:

 @OnCheckedChanged(R.id.checkBox)
    void radioButtonCheckChange(boolean isl) {
        Toast.makeText(MainActivity.this, "CheckBox...(no parameters)" + isl, Toast.LENGTH_SHORT).show();
 } 
 
    @OnCheckedChanged(R.id.checkBox)
    void radioButtonCheckChange(CheckBox checkBox,boolean isl) {
        Toast.makeText(MainActivity.this, "CheckBox...(CheckBox)" + isl, Toast.LENGTH_SHORT).show();
 }

The results are as follows:

4. Listen for the button event in the lower right corner of the soft keyboard

The code is as follows:

 // @OnEditorAction(R.id.tv_editor_action)
 // boolean EditTextAction() {
 // Toast.makeText(MainActivity.this, "Click---Leading to Heaven No Parameters" , Toast.LENGTH_SHORT).show();
 // return   false ;
 // } 
 
 // @OnEditorAction(R.id.tv_editor_action)
 // boolean EditTextAction( int code) {
 // Toast.makeText(MainActivity.this, "Click---to the heaven code:" +code, Toast.LENGTH_SHORT).show();
 // return   false ;
 // } 
 
 // @OnEditorAction(R.id.tv_editor_action)
 // boolean EditTextAction(KeyEvent keyEvent) {
 // Toast.makeText(MainActivity.this, "Click---Leading to Heaven KeyEvent:" +keyEvent, Toast.LENGTH_SHORT).show();
 // return   false ;
 // } 
 
 // @OnEditorAction(R.id.tv_editor_action)
 // boolean EditTextAction( int code, KeyEvent keyEvent) {
 // Toast.makeText(MainActivity.this, "Click---to the heaven code:" +code+ " KeyEvent:" +keyEvent, Toast.LENGTH_SHORT).show();
 // return   false ;
 // } 
 
    @OnEditorAction(R.id.tv_editor_action)
    boolean EditTextAction(TextView textView, int code, KeyEvent keyEvent) {
 Toast.makeText(MainActivity.this, textView.getText().toString()+ "Click---to the heaven code:" +code+ "KeyEvent:" +keyEvent, Toast.LENGTH_SHORT).show();
 return   false ;
 }

Running effect:

5. EditText content change listener event

The code is as follows:

 @OnTextChanged(value = R.id.editText, callback = OnTextChanged.Callback.AFTER_TEXT_CHANGED)
    void editTextChangeAfter(Editable editable) {
 Toast.makeText(MainActivity.this, "Changed content:" +editable.toString(), Toast.LENGTH_SHORT).show();
 System. out .println( "After change --- the content is: " + editable.toString());
 } 
 
    @OnTextChanged(value = R.id.editText, callback = OnTextChanged.Callback.BEFORE_TEXT_CHANGED)
    void editTextChangeBefore(CharSequence s, int start, int before, int   count ) {
 Toast.makeText(MainActivity.this, "Edit content:" +s+ ", number before start:" +start, Toast.LENGTH_SHORT).show();
 System. out .println( "Before change --- content: " +s+ ", number before start: " +start+ ", : " +before+ ", " + count );
 } 
 
    @OnTextChanged(value = R.id.editText, callback = OnTextChanged.Callback.TEXT_CHANGED)
    void editTextChange(CharSequence s, int start, int before, int   count ) {
 Toast.makeText(MainActivity.this, "Edit content:" +s+ ", number before start:" +start, Toast.LENGTH_SHORT).show();
 System. out .println( "Unedited --- Content: " +s+ ", number before start: " +start+ ", " +before+ ", " + count );
 }

The results are as follows:

6. Focus monitoring events

The code is as follows:

 @OnFocusChange(R.id.editTextFocus)
    void editTextFocus(boolean isl) {
 if (isl) {
 Toast.makeText(MainActivity.this, "Get focus" + isl, Toast.LENGTH_SHORT).show();
 } else {
 Toast.makeText(MainActivity.this, "lost focus" + isl, Toast.LENGTH_SHORT).show();
 }
 }

The results are as follows:

7. Touch monitoring events

The code is as follows:

 @OnTouch(R.id.imageView)
    boolean imageView(MotionEvent event){
        System. out .println(event);
 return   false ;
 }

The results are as follows:

 04-10 11:47:04.504 32627-32627/cn.hlq.butterknifestudyI/System. out : MotionEvent { action =ACTION_DOWN, actionButton=0, id[0]=0, x[0]=189.8265, y[0]=148.42676, toolType[0]=TOOL_TYPE_FINGER, buttonState=0, metaState=0, flags=0x0, edgeFlags=0x0, pointerCount=1, historySize=0, eventTime=6743683, downTime=6743683, deviceId=1, source=0x1002 }

8. Item click and long press listener events

The code is as follows:

 @OnItemClick(R.id.listView)
  void listItemClick( int position){
 Toast.makeText(this, "OnItemClick---Clicked the" +position+ "item" , Toast.LENGTH_SHORT).show();
 } 
 
  @OnItemLongClick(R.id.listView)
  boolean listItemLongClick( int position) {
 Toast.makeText(this, "OnItemLongClick---Clicked the " + position + " , Toast.LENGTH_SHORT).show();
 return   true ;
 }

The results are as follows:

Presumably, everyone has mastered the basic use of this set of knife skills through the above. As mentioned above, you can also modify the Adapter to save some coding in the development process. Let's take a look at it together~

The second step of knife skills: using Adapter

Create an item_layout for the next demonstration~

 <?xml version= "1.0" encoding= "utf-8" ?>
 <LinearLayout xmlns:android= "http://schemas.android.com/apk/res/android"  
              android:layout_width= "match_parent"  
              android:layout_height= "wrap_content"  
              android:orientation= "horizontal" > 
 
 <TextView
        android:id= "@+id/item_username"  
        android:layout_width= "0dp"  
        android:layout_height= "wrap_content"  
        android:layout_gravity= "center_vertical"  
        android:layout_weight= "1" /> 
 
 <TextView
        android:id= "@+id/item_userPwd"  
        android:layout_width= "0dp"  
        android:layout_height= "wrap_content"  
        android:layout_gravity= "center_vertical"  
        android:layout_weight= "1" /> 
 
 </LinearLayout>

Very simple, nothing much, next look at the adapter~

 package cn.hlq.butterknifestudy.adapter; 
 
 import android.content.Context;
 import android.view.LayoutInflater ;
 import android. view . View ;
 import android.view.ViewGroup ;
 import android.widget.BaseAdapter;
 import android.widget.TextView; 
 
 import java.util.ArrayList;
 import java.util.List; 
 
 import butterknife.BindView;
 import butterknife.ButterKnife;
 import cn.hlq.butterknifestudy.R;
 import cn.hlq.butterknifestudy.model.Student; 
 
 /**
 * Created by HLQ on 2017/4/11 0011.
 */ 
 
 public class ListViewAdapter extends BaseAdapter { 
 
 private Context context;
    private List<Student> stuList = new ArrayList<Student>(); 
 
 public ListViewAdapter(Context context, List<Student> stuList) {
        this.context = context;
        this.stuList = stuList;
 } 
 
 @Override
 public   int getCount() {
 return stuList != null ? stuList. size () : 0;
 } 
 
 @Override
 public Object getItem( int position) {
 return stuList != null ? stuList.get(position) : null ;
 } 
 
 @Override
 public long getItemId( int position) {
 return position;
 } 
 
 @Override
 public   View getView( int position, View convertView, ViewGroup parent) {
        ViewHolder viewHolder = null ;
        if (viewHolder == null ) {
            convertView = LayoutInflater. from (context).inflate(R.layout.item_listview_show, null );
            viewHolder = new ViewHolder(convertView);
            convertView.setTag(viewHolder);
 } else {
            viewHolder = (ViewHolder) convertView.getTag();
 }
        Student stu = stuList.get(position);
        viewHolder.itemUsername.setText(stu.getUserName());
        viewHolder.itemUserPwd.setText(stu.getUserPwd());
 return convertView;
 } 
 
 static class ViewHolder {
        @BindView(R.id.item_username)
        TextView itemUsername;
        @BindView(R.id.item_userPwd)
 TextView itemUserPwd; 
 
 ViewHolder( View   view ) {
            ButterKnife.bind(this, view );
 }
 }
 }

The running results are:

Here is a little secret for you. You can directly right-click the layout and choose to automatically create a ViewHolder when generating annotations, as shown below:

Isn't it quite convenient? Here, by the way, let me introduce how to use this knife to play with resource content.

 // Initialize the specified default value
    @BindString(R.string.app_test)
 String titleContent; 
 
    lvTitle.setText(titleContent);

The results are as follows:

[[194039]]

In addition to the above, the knife skills also include the following support. If you are interested, you can learn it yourself. It is not difficult.

And the official also provides some basic usage, as follows:

BaseActivity encapsulation of the Knife Technique Trilogy further simplifies the code

Usually we will encapsulate a BaseActivity, write common content in it, and then the activity inherits this BaseActivity. Similarly, we can also initialize it here to avoid multiple initializations. See the following code~

 package com.heliquan.butterknife.base; 
 
 import android.app.Activity;
 import android.content.Context;
 import android.os.Bundle;
 import android.support.annotation.LayoutRes;
 import android.view.KeyEvent ;
 import android. view . View ;
 import android.view.ViewGroup ; 
 
 import butterknife.ButterKnife;
 import butterknife.Unbinder; 
 
 /**
 * created by heliquan on April 14, 2017
 */
 public abstract class BaseActivity extends Activity { 
 
    private Unbinder unbinder; 
 
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
 // The three methods of setContentView() must be rewritten, otherwise the subclass inheritance will be invalid. The specific reasons are not deeply understood
        setContentView(getContentViewId());
        unbinder = ButterKnife.bind(this);
 } 
 
 @Override
 public void setContentView(@LayoutRes int layoutResID) {
        super.setContentView(layoutResID);
        unbinder = ButterKnife.bind(this);
 } 
 
 @Override
 public void setContentView( View   view ) {
        super.setContentView( view );
        unbinder = ButterKnife.bind(this);
 } 
 
 @Override
 public void setContentView( View   view , ViewGroup.LayoutParams params) {
        super.setContentView( view , params);
        unbinder = ButterKnife.bind(this);
 } 
 
 /**
 * Get content id
 */
    protected abstract int getContentViewId(); 
 
 /**
 * Initialize View  
 */
    protected abstract void initView(); 
 
 @Override
    protected void onDestroy() {
 super.onDestroy();
 unbinder.unbind();
 } 
 
 /**
 * Return resource content based on id
 *
 * @param context
 * @param strId
 * @return  
 */
    protected String getStrResource(Activity activity, int strId) {
 return activity.getResources().getString(strId);
 } 
 
 /**
 * Listen for the return button and click it to return to finish the current page
 *
 * @param keyCode
 * @param event
 * @return  
 */
 @Override
 public boolean onKeyDown( int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
 finish();
 return   true ;
 }
 return super.onKeyDown(keyCode, event);
 }
 }

Conclusion

Seeing this, I believe everyone has basically understood this set of knife skills and can basically use it. Thank you for watching. If you have any questions, welcome to communicate~