Develop Reference

setContentView and Listeners

I'm changing my ContentView of the Activity at some point. (to View2).
After changing it back to View1, the listeners are not more working.
I already tried putting the Listener in the onResume() method.
Is it common anyway to use setContentView() to display e.g. a Progress screen/please wait,...(while an asyncTask is running).
Or should you only have ONE mainView for each Activity? (and replacing the content dynamically).
//EDIT: To be more specific:
I am looking for something like
LinearLayout item = (LinearLayout) findViewById(R.id.mainView);
View child = getLayoutInflater().inflate(R.layout.progress, null);
item.addView(child);
but instead of adding the "progress.xml", it should remove the current layout and ONLY show "progress.xml".
Do I need an "container" and show/hide mainView/progress?
But that doesn't seem very proper to me...
See also code below (stripped)
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.view1);
button.setOnClickListener(new OnClickListener() {
#Override
public void onClick(View v) {
doSomething();
}
});
}
setContentView(R.layout.view2);
[...]
setContentView(R.layout.view1);
//Listener not more working

Thank you all, for your reply. You made me realize, the onClickListeners are getting lost when I remove or replace (using setContentView()) the main view. I ended up this way now:
onCreate:
setContentView(R.layout.parse);
LinearLayout container = (LinearLayout) findViewById(R.id.container);
container.addView(getLayoutInflater().inflate(R.layout.dialog, null));
container.addView(getLayoutInflater().inflate(R.layout.progress, null));
onStartDoingSomething:
findViewById(R.id.dialog).setVisibility(View.INVISIBLE);
findViewById(R.id.progress).setVisibility(View.VISIBLE);
onEndDoingSomehting:
findViewById(R.id.dialog).setVisibility(View.VISIBLE);
findViewById(R.id.progress).setVisibility(View.INVISIBLE);
I might change View.INVISIBLE to View.GONE, like nmr said, but since I have never used View.GONE, I have to check the Android doku first ;)

Assuming you use 'findViewById' to initialize 'button', you would need to do that every time that you do setContentView(R.layout.view1);

You can only have one UI for each Activity, you should create another activity and in its onCreate method set the content view
Steps:
Create Activity
Use the following code to set the content View:
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.view2);
}
Define the Activity in the applications manifest as such :
Create an intent in the first Activity:
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.view1);
Button button = (Button) findViewById(R.id.button);
button.setOnClickListener(new OnClickListener() {
#Override
public void onClick(View v) {
intent();
}
});
}
void intent(){
Intent intent = new Intent();intent.setClass(Activity1.this, Activity2.class);
startActivity(intent);
}
And there you go c:

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
}
});

Issuue while implementing onClickListener

See this simple code,But i am getting Description
The method onClick(View) of type CheckboxActivity must override a superclass method CheckboxActivity.java on my onClick(View v) method.
public class CheckboxActivity extends Activity implements Button.OnClickListener{
/** Called when the activity is first created. */
Button b1;
CheckBox c1, c2;
EditText et1;
#Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
et1 = (EditText) this.findViewById(R.id.text1);
c1 = (CheckBox) findViewById(R.id.check1);
c2 = (CheckBox) findViewById(R.id.check2);
b1 = (Button) findViewById(R.id.button1);
b1.setOnClickListener(this);
}
#Override
public void onClick(View v){
et1.setText("");
if (c1.isChecked())
et1.setText("Android ");
if (c2.isChecked())
et1.setText(et1.getText()+"iPhone ");
}
}
Anyone please help
.

Try:
public class CheckboxActivity extends Activity implements OnClickListener

You delete your onClick() first.
Then change ur first line as
public class CheckboxActivity extends Activity implements OnClickListener
and the import should be
android.view.View.OnClickListener;
Then after your onCreate() do a right click -> Source -> Override/Implemented Methods
the onClick() will be automatically selected in the dialog box. Click ok and type in ur required things into the method.

I don't have sources of Activity and don't have working environment to write code and run javac, so I'm just guessing, please check yourself:
Activity has onClick method already - make anonymous OnClickListener
instance and pass it to the button (or remove inheritance from
Button.OnClickListener and don't forget to call super when view is
not your button). Could be also that contract has different access
level in activity.
Level of language is 1.5 and you can't use annotation #override for interfaces.

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

Android - Two onClick listeners and one button

I have a custom TextView which is clickable. It defines its own onClick handler in order to change its appearance based on clicks. However if I then define a second onClick handler in my activity in order to do something based on the button being clicked, only one of the onClick functions is called. onClick is a void function - is there any way to say I didn't process this click, please pass it on to other onClick handlers?
To be more clear here is the code:
Inside MyCheckButton which extends TextView I have:
setOnClickListener( mClickListener );
private OnClickListener mClickListener = new OnClickListener() {
public void onClick(View v) {
toggle();
}
};
However I include MyCheckButton into my Activity, and of course I need to do something when its clicked so I attach another OnClickListener to it:
MyCheckButton button= (MyCheckButtonButton) findViewById(R.id.cb);
button.setOnClickListener(new OnClickListener(){
#Override
public void onClick(View v) {
// do something in the app
}
});
By calling setOnClickListener twice it appears that I am replacing the original listener so toggle() which changes the appearance is never called. How can I do something in my activity when this button is clicked if it is already using the onClick handler to change its appearance? I thought I would simply see both OnClickListeners getting called.

This is a bit dirty, but the way I would do this if you need multiple listeners is to register one that knows about the other. The first one (the one that's actually registered) will then need to know when to delegate to the other listener based on the conditions of the event. Actually, in reality, there's no real need to have two OnClickListener classes. The second class can implement whatever interface you want. Additionally, there's no need to create a special interface for what you need.
public class MyClickListener implements OnClickListener{
private SomeCustomClass mSecondListener = new SomeCustomClass();
public void onClick(View v){
if (needToForward){
mSecondListener.handleClick(v);
}else{
//handle the click
}
}
}
Then, in your code for your activity, you would do this
MyClickListener lstn = new MyClickListener();
mCheckBox.setOnClickListener(lstn);
Is there a reason this wouldn't work for you?
Alternatively, if you wanted, the second class could also implement the OnClickListener interface.
Additionally, if you need true bubbling, you could define your own interface that supports adding multiple click listeners to an intermediate class that happens to implement the OnClickListener interface. From there, in that class's onClick() method, you would iterate through the registered listeners calling the appropriate method.

A cleaner approach would be to use the CompositeListener pattern.
Taken from:
how can I set up multiple listeners for one event?
You'd have to add this class in your project:
/**
* Aux class to collect multiple click listeners.
*/
class CompositeListener implements OnClickListener {
private List<OnClickListener> registeredListeners = new ArrayList<OnClickListener>();
public void registerListener (OnClickListener listener) {
registeredListeners.add(listener);
}
#Override
public void onClick(View v) {
for(OnClickListener listener:registeredListeners) {
listener.onClick(View v);
}
}
}
Then add this on your MyCheckButton
private CompositeListener clickListener = new CompositeListener();
public MyCheckButton()
{
super.setOnClickListener(clickListener); //multi event listener initialization
}
#Override
public void setOnClickListener(OnClickListener l) {
clickListener.registerListener(l);
}
Both your calls to setOnClickListener would go through this override, get added to the list and get called when the event is fired. Hope it helps.

Since it appears I can only have one onClickListener per View. What I think I have to do is define an interface:
public interface MyOnClickListener {
public void onMyClick(View v);
}
Implement it from my activity and override the onMyClick function to do whatever I want and in the MyCheckButton class I'll need to pass a MyOnClickListener in the constructor save it and call listener.onMyClick inside the onClick handler.
Let me know if theres a better way. I considered using the onTouch handler in either the activity or the MyCheckButton class, but later if I add onTouch or onClick to either one I will get a difficult to notice bug.
My idea doesn't work because I don't know how to get a reference to the activity from my constructor:
public class TVCheckButton extends TextView {
private MyOnClickListener mListener;
public TVCheckButton(Context context, AttributeSet attrs) {
super(context, attrs);
mListener = ???;
}
}

Since only one OnclickListener works on Android 2.1 [I don't know about later versions) make the view private and static and create a static function that can change it e.g.
public class ExampleActivity extends Activity{
private SomeOtherclass someOtherClass;
private static Button b_replay;
public void onCreate(Bundle savedInstanceState){
someOtherClass = new SomeOtherclass();
b_replay = (Button) findViewById(R.id.b_replay);
b_replay.setOnClickListener(someOtherClass);
}
public static void changeReplayText(String text){
b_replay.setText(text);
}
}

A nice generic approach is to use a list of listeners, such as ListenerList and WeakListenerList from the Beryl library.

For some reason I could not use the answers above so here is an alternative:
//I had all of this in one method where I had two buttons, and based on external factors one would be visible and other would not aka 'gone'. So, I had that checked out! Hope it helps someone!!
Button b = (Button) findViewById(R.id.b_reset);
Button breakk = (Button) findViewById(R.id.b_break);
if ((findViewById(R.id.b_reset)).getVisibility() == View.VISIBLE) {
b.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View v) {
//some code and methods...
}
});
} else if ((findViewById(R.id.b_break)).getVisibility() == View.VISIBLE) {
breakk.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View v) {
//some code and methods...
}
});
}

In the first class, define a virtual button:
private static Button myVirtualButton = new Button(context);
... and a public method to register it:
public static void registerMyVirtualButton(Button b) { myVirtualButton = b;}
In the OnClickListener do whatever action is desired, and in the end, softclick the virtual button:
if (myVirtualButton!=null) { myVirtualButton.callOnClick(); }
In the second class, define a button and its OnClickListener with whatever action is additionally desired.
Transmit the button to the first class via registerMyVirtualButton.
Upon clicking the object of the first class, both actions will be executed.

You can attach an OnClick listener to the button in the following way :
Button button= (Button) findViewById(R.id.button1);
button.setOnClickListener(new OnClickListener(){
#Override
public void onClick(View v) {
// do something
}
});
Similarily, your TextView should have it's on OnClick listener.