Develop Reference

setOnclickListener vs Activity implements View.OnClickListener

I am trying to implement OnClick behaviour on my application view. As I am new to android and will like to know if passing this to while implementing View.OnClickListener interface will be better choice or using setOnclickListener Anonymous class to widget. As to me what I feel is that passing this may cause the whole activity and its child elements to the particular widget so having more memory consumption and so to avoid memory leak which is the best approach to go with.

Actually when we implement OnClickListener because we have more than one or two click item. like if i have 10 buttons in a single layout and i write each click listener as:
button1.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View view) {
}
});
button2setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View view) {
}
});
button3.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View view) {
}
});
Its not a good programming practice thats why we implement OnClickListener and write all the click listeners in onClick().
so it looks easy to you for making any changes in future.
else if you have single button then you can use setOnClickListener().
There is not too much difference between these two. Its all about good coding practice in android. :)

You can also use
android:onClick = "ButtonOne"
attribute in xml file.its easy !!

How to implement click event in BaseActivity in android

I am implementing common header in all activity.I want to implement click event for header.can anybody tell how to implement click event in BaseActivity(Parent Activity) in android.I am getting reference in parent activity .Is it possible to implement click using setOnClickListener in parent activity?
txtHeading =(TextView)findViewById(R.id.txtHeading);
I want to implement click event for textview in parent activity
Any help would be highly appreciated

I usually create some helper method on the parent activity
public void setHeaderOnClick(View.onClickListener clickListener){
txtHeading =(TextView)findViewById(R.id.txtHeading);
txtHeading.setOnClickListener(clickListener);
}
when on the fragment, you can use
((YourActivityName)getActivity()).setHeaderOnClick(new View.OnClickListener() {
#Override
public void onClick(View v) {
//method here
}
});
hope it helps

yes you can do it like...
1.)in your header a xml in the textView set these properties.
android:clickable="true"
android:onClick="onClick"
2.) write the direct public void onClick() in your BaseActivity Like
public void onClick(View v){
if(v.getId() == R.id.txtHeading){
}
}
it will working charm yes after doing these steps don't find your text view component in BaseActivity.

Dynamically adding buttons in android, how to add onClick to xml

Here's the situation: I have an activity that dynamically generates a bunch of randomized custom imagebuttons and adds them to TableRows, in a TableView, in my xml. This activity also has a method that I want to call when one/any of these buttons is clicked. The buttons have variables inside them; the method gets these variables and sets them into a TextView (in the same activity) so I figure all the buttons can use this one method. If these buttons were defined in the XML I would just use android:onClick="displayCell" to specify the method, but they aren't. Is there a way to just set onClick for these buttons as I'm generating them in the activity or do I have to use
button.setOnClickListener(new OnClickListener(){....});
and go through a bunch of hassle as I've seen in some of the answers around here? The problem I have with that is that I can't seem to call my method from inside onClick because the argument of the method (the button) is not final (I'm making a bunch of 'button' in a loop so I don't think it can be):
button.setOnClickListener(new OnClickListener(){
public void onClick(View q){
button.getActivity().displayCell(button);//I want to do something like this but this obviously doesn't work
}
});

You can have the Activity implement OnClickListener and then (assuming you are in the activity):
button.setOnClickListener(this);

Yes as comodoro states, or make your onClickLIstener a member variable of your class, don't do a "new" on each button.
private OnClickListener mOnClickListener = new OnClickListener() {...};
and when creating your buttons:
button.setOnClickListener(mOnClickListener);
The onClick() function in your listener will be passed the View of the button itself. You can access the buttons variables, etc, from this function.
public void onClick(View v)
{
ImageButton button = (ImageButton)v;
// and access your button data via button object...
}

A solution to this could be :
Create different instances of buttons .(So you can make them final)
Use setId() method to give them an integer ID (to refer to them later).You can store the ID's in an a Listto refer them later on.
Define their onClickListeners right after you create it.

Try using a class that inherits from button and add there the OnClickListener. Like this:
class MyButton extends Button {
OnClickListener clicker = new OnClickListener() {
public void onClick(View v) {
displayCell(v);
}
};
}

What do I use as a parameter for the setOnClickListener() method?

I'm trying to make multiple OnClickListener methods for 5 buttons in my program, and I've been able to declare them, and I made a switch using the xml id of what was clicked, but I need a parameter for the setOnClickListener method when I call it, and all that will work is null. I have also tried passing in this, so the method has context.
Here's some of the code:
add.setOnClickListener(null);
sub.setOnClickListener(null);
mult.setOnClickListener(null);
div.setOnClickListener(null);
equal.setOnClickListener(null);

The parameter has to be an instance of some object that implements the OnClickListener interface. One way to do it is to use an anonymous inner class:
add.setOnClickListener(new OnClickListener{
public void onClick(View view){
//your event handler code here
}
});
another way is to make your class implement OnClickListener --do that by changing your declaration to look like:
public class MyActivity extends Activity implements OnClickListener{
then define an implementation for the onClick method:
public void onClick(View view){
if(view == add){
//handle add button click
}else if (view == sub){
//handle sub button click
}
//etc
}
then to install the listener you could do:
add.setOnClickListener(this);

You are supposed to pass View.OnClickListener to this function, which is a listener that will get called once the button is clicked.
To do that, you can either:
Declare this listener in the layout XML, with the button, as specified in Button 4 in this site.
Create an instance of View.OnClickListener and pass it to setOnClickListener method as in the example below (Taken from android site which is a great source):
// Create an anonymous implementation of OnClickListener
private OnClickListener mCorkyListener = new OnClickListener() {
public void onClick(View v) {
// do something when the button is clicked
}
};
protected void onCreate(Bundle savedValues) {
...
// Capture our button from layout
Button button = (Button)findViewById(R.id.corky);
// Register the onClick listener with the implementation above
button.setOnClickListener(mCorkyListener);
...
}
Since View.OnClickListener is an interface, your activity may implement it as well, and be itself the listener, in this case, you will pass the activity instance(this) to the setOnClickListener method, but this is just one option, and not that recommended IMHO.

Coming from a .NET background, I struggled with the same thing at first. It's just a different syntax than .NET as java doesn't support properties, or events like I was used to. Here's a simple example of how to do this using a class level click listener variable...
#Override
private void onCreate(Bundle bundle) {
myButton.setOnClickListener(this.genericButtonListener);
}
private OnClickListener genericButtonListener = new OnClickListener() {
#Override
public void onClick(View v) {
//v represents your button
}
};

You need a concrete class here. For example:
imageView.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View v) {
// your code here
}
});

If you look at documentation, you will notice it takes View.OnClickListener as parameter. If you need five separate listeners, which you are not going to use anywhere else, you can pass an anonymous class implementing onClick(View v), like this
add.setOnClickListener(new View.OnClickListener(){
#Override
public void onClick(View v){
//do required actions here
}
});

When to implement Activity-wide click event?

I usually implement click event bound to a certain visual element, like
final Button button = (Button) findViewById(R.id.button_id);
button.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
// Perform action on click
}
});
Often I see examples where they use Activity-wide onclick (implementing View.OnClickListener) and then they do not create View.OnClickListener for each element but rather just pass this, like
public class MyClass extends Activity implements View.OnClickListener {
//...
someUIElement.setOnClickListener(this);
public void onClick(View view) {
//TODO implement this
}
}
When should I use such Activity-wide OnClick events? Are both ways the same

Hi Please check may be helpful
How to handle button clicks using the XML onClick within Fragments
http://developer.android.com/guide/topics/ui/ui-events.html
http://developer.android.com/reference/android/widget/Button.html