An explanation of the event handling mechanism of Android (ii)-----The event-handling mechanism based on listening

Monitoring-based event handling mechanism preface:

We develop apps that need to interact with the user----that responds to the user's actions.

This involves the Android event-handling mechanism;

Android gives us two sets of powerful processing mechanisms:

① event handling mechanism based on monitoring

② Callback-based event handling mechanism

In this section, we will first introduce the listener-based event handling mechanism

All right, no more nonsense!  

We need to understand the model of the listening processing mechanism first.

Processing model for listening: working with model diagrams:

Text expression:

Event listener consists of three types of objects, event source, event and event listener .

Processing Flow:

Step 1: set up a listener for an event source (component) to listen for user actions

Step 2: user actions that trigger the listener for the event source

Step 3: generate the corresponding event object

Step 4: Pass the event source object as a parameter to the event listener

Step 5: event listener to judge the event object, execute the corresponding event handler (the corresponding event processing method)

Induction:

Event listener mechanism is a delegated event handling mechanism, event source (component) event handler delegate to event listener

Notifies the event listener when an event source has a development event, and performs the appropriate action

form of Use:

Instance:

This is achieved by clicking on the button and displaying the toast information prompt

To demonstrate, the following are the effects that are implemented in different forms, which can be carefully figured out in code

:

① use anonymous inner classes directly as event listeners

PS: Is our usual most commonly used kind, after Setxxxlistener rewrite the corresponding method inside

It's usually a temporary use, not a high reusability.

Code:

XML is a normal button, which does not give a

Mainactivity.java

 PackageCom.jay.example.innerlisten;ImportAndroid.os.Bundle;ImportAndroid.view.View;ImportAndroid.view.View.OnClickListener;ImportAndroid.widget.Button;ImportAndroid.widget.Toast;Importandroid.app.Activity; Public classMainactivityextendsActivity {PrivateButton btnshow; @Overrideprotected voidonCreate (Bundle savedinstancestate) {Super. OnCreate (savedinstancestate);                Setcontentview (R.layout.activity_main); Btnshow=(Button) Findviewbyid (r.id.btnshow); Btnshow.setonclicklistener (NewOnclicklistener () {//Override Click event handling method onclick ()@Override Public voidOnClick (View v) {//Show Toast InformationToast.maketext (Getapplicationcontext (), "You clicked the button", Toast.length_short). Show ();    }        }); }    } 

② using an internal class as an event listener

This is not the same as the anonymous inner class above.

Use advantage: can be reused in this class, direct access to all interface components of the external class

Code:

 PackageCom.jay.example.innerlisten;ImportAndroid.os.Bundle;ImportAndroid.view.View;ImportAndroid.view.View.OnClickListener;ImportAndroid.widget.Button;ImportAndroid.widget.Toast;Importandroid.app.Activity; Public classMainactivityextendsActivity {PrivateButton btnshow; @Overrideprotected voidonCreate (Bundle savedinstancestate) {Super. OnCreate (savedinstancestate);                Setcontentview (R.layout.activity_main); Btnshow=(Button) Findviewbyid (r.id.btnshow); //Direct new an inner class object as a parameterBtnshow.setonclicklistener (NewBtnclicklistener ()); }             //define an inner class, implement the View.onclicklistener interface, and override the OnClick () method    classBtnclicklistenerImplementsView.onclicklistener {@Override Public voidOnClick (View v) {toast.maketext (Getapplicationcontext (),"button is clicked.", Toast.length_short). Show (); }            }}

③ using an external class as an event listener

is to create another Java file that handles the event, which is a rare form of

Because external classes do not have direct access to components in the user interface class, the component is passed into use by constructing methods,

The result is that the code is not concise.

PS: To demonstrate, here by TextView instead of toast display!

：

Code:

Layout is relatively simple, is a button + text box, here does not give a

Also write an external class:

Myclick.java

 PackageCom.jay.example.innerlisten;ImportAndroid.view.View;ImportAndroid.view.View.OnClickListener;ImportAndroid.widget.TextView; Public classMyclickImplementsOnclicklistener {PrivateTextView textshow; //to pass a text box as a parameter     PublicMyclick (TextView txt) {textshow=txt; } @Override Public voidOnClick (View v) {//Text after clicking to set the text box to displayTextshow.settext ("Click on the button!")); }}

Mainactivity.java

 PackageCom.jay.example.innerlisten;ImportAndroid.os.Bundle;ImportAndroid.widget.Button;ImportAndroid.widget.TextView;Importandroid.app.Activity; Public classMainactivityextendsActivity {PrivateButton btnshow; PrivateTextView txtshow; @Overrideprotected voidonCreate (Bundle savedinstancestate) {Super. OnCreate (savedinstancestate);                Setcontentview (R.layout.activity_main); Btnshow=(Button) Findviewbyid (r.id.btnshow); Txtshow=(TextView) Findviewbyid (r.id.textshow); //direct new to an external class and pass TextView as a parameterBtnshow.setonclicklistener (NewMyclick (txtshow)); }     }

④ directly using activity as an event listener

Just let the activity class implement the ~listener event listener interface and define overriding event handler methods in activity

Eg:activity implements the Onclicklistener interface, overriding the OnClick (view) method

When you add the event listener object for a component, you can directly Setxxxlistener (this)

:

Layout file slightly

Mainactivity.java

 PackageCom.jay.example.innerlisten;ImportAndroid.os.Bundle;ImportAndroid.view.View;ImportAndroid.view.View.OnClickListener;ImportAndroid.widget.Button;ImportAndroid.widget.Toast;Importandroid.app.Activity;//let the activity method implement the Onclicklistener interface Public classMainactivityextendsActivityImplementsonclicklistener{PrivateButton btnshow; @Overrideprotected voidonCreate (Bundle savedinstancestate) {Super. OnCreate (savedinstancestate);                Setcontentview (R.layout.activity_main); Btnshow=(Button) Findviewbyid (r.id.btnshow); //write this one directlyBtnshow.setonclicklistener ( This); }    //overriding an abstract method in an interface@Override Public voidOnClick (View v) {toast.maketext (Getapplicationcontext (),"Click on the button", Toast.length_short). Show (); }     }

Analysis of important ontouchevent events

The reason why the Ontouchevent event is explained here is not simply that he is an example of an event monitoring mechanism.

And because his invocation process is special, and because this event is something that we use more in our actual development

All view components override this method, which the application can use to handle touch events on the phone screen.

Method declaration:

Public Boolean ontouchevent (Motionevent event);

Use process:

① for a view (component)Setontouchlistener (New Ontouchlistener ())

② overriding the Ontouch () method

③ because there are three kinds of more commonly used touch states:

Motionevent.action_down: Press the

Motionevent.action_move: Mobile

MOTIONEVENT.ACTION_UP: Let go.

So we usually sort by switch,switch (event.getaction), and then each case ~: Handle the corresponding event

Method Invocation Order Resolution:

By method declaration We know that Ontouchevent returns a Boolean value, either True or False

The difference between the two is whether the external method is called after the method in the Ontouch () is called.

Here's a simple example:

We set the Ontouch (), OnClick (), Onlongclick () Three methods for a button, so what is the order of their calls?

A: There are two types of cases:

① returns true: Call Action_down method When pressed, call the Action_move method after the call, as long as the finger keeps pressing the system will constantly respond to this

method, the reason is (Android is sensitive to touch events, although our fingers feel static, but the fingers are constantly trembling vibration); When our fingers leave

The screen, this time call the Motionevent.action_up method, and then the process is done

② returns false: the same process as above, but the other 2 methods are called when you leave the screen:

If you are short-clicking, then the OnClick () method is called

If you are long-pressed, then the Onlongclick () method is called;

And then it's over.

These two situations above are not difficult to understand

Readers can write their own code to verify, and then view the order information of the call through LOG.I ()

Finally, let's show you

Call the use of the Ontouchevent () OnMove method.

The MoveTo () method uses an instance:

This is used more, the example is still old, in the frame layout that section is given out

Here's a brief introduction to the usage:

We just need to get the position of the current click through the parameter event.

x = Event.getx (); Get the x-coordinate of the click

y = event.gety (); Get the y-coordinate of the click

See the code in detail:

MoveTo Method Usage Examples

An explanation of the event handling mechanism of Android (ii)-----The event-handling mechanism based on listening