On PC I can add a onKeyListener for a JTextField to listen keyReleased event. On Android I've used addTextChangedListener.
I have two EditText fields in my Android application. Editing one will affect the other. This will cause the program to fail in stack overflow error.
How can I listen for the phone's keyboard instead of changes in the EditText field? I don't want the program to invoke the listener because of the infinite loop caused by the listener.
Attach a onFocusChangedListener and add the TextChangedListener when a EditText has focus and remove it when it loses focus.
Something like this:
EditText1.setOnFocusChangeListener(new OnFocusChangeListener() {
public void onFocusChange(View v, boolean hasFocus) {
if(hasFocus){
((EditText) v).addTextChangedListener(new TextWatcher() {
public void onTextChanged(CharSequence s, int start, int before, int count) {
//
}
public void beforeTextChanged(CharSequence s, int start, int count,
int after) {
//
}
public void afterTextChanged(Editable s) {
// affect EditText2
}
});
}
if(!hasFocus){
((EditText) v).removeTextChangedListener();
}
}
});
}
});
The same for EditText2
First of all, I would create one text change listener, something like SynchronizingWatcher and attach it to both EditTexts. Then, when you receive a text change event, before updating other text edits, just unregister old listeners, update text and enable listeners again:
class SynchronizingWatcher implements TextWatcher {
Set<EditText> synchronizedViews = new HashSet<EditText>();
public void watchView(EditText view) {
view.addTextChangedListener(this);
synchronizedViews.add(view);
}
public void afterTextChanged(Editable s) {
for (EditText editText : synchronizedViews) {
editText.removeTextChangeListener(this);
editText.setText(s); // Of course you can do something more complicated here.
editText.addTextChangeListener(this);
}
}
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
// Don't care.
}
public void onTextChanged(CharSequence s, int start, int before, int count) {
// Don't care.
}
}
...
// Somewhere in your activity:
SyncrhonizingWatcher synchronizingWatcher = new SynchronizingWatcher();
synchronizingWatcher.watchView(myEditText1);
synchronizingWatcher.watchView(myEditText1);
Another solution: provide your own KeyListener that decorates existing KeyListener (you can get existing key listener with editText.getKeyListener() and set your decorator with editText.setKeyListener(). Your decorator would also update other edit texts in onKeyUp(). But I would try to stay away from messing with that stuff.
Related
I have this app I'm working on, which sends requests to a server whenever text changes in the EditText. And it works fine as it is.
The problem is, that if I send a request every time the edittext changes, it will be a lot of requests in the end. And I don't want to use a "send" button.
I want something the works something like this:
If the user types in the edittext, some timer goes on. And if the timer reaches x seconds, it executes the request. But the timer resets if the user types again.
In this way, the request is only sent, once the user has stopped typing.
You might know some better way, and I'd be glad to hear it.
Thanks in advance :D
One method would be to use myEditText.addTextChangedListener(...) and use a TextWatcher to know when the text changes.
Then in the onTextChanged() method you can post a delayed runnable using a Handler to send the current text to your server if they don't type anything further.
Here is what this roughly looks like:
private Handler handler = new Handler();
private Runnable postToServerRunnable = new Runnable() {
#Override
public void run() {
// TODO: PUT CODE HERE TO HANDLE CURRENT VALUE OF EDIT TEXT AND SEND TO SERVER
}
};
private TextWatcher textWatcher = new TextWatcher() {
#Override
public void afterTextChanged(Editable arg0) {}
#Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
#Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
// remove existing callback (timer reset)
handler.removeCallbacks(postToServerRunnable);
// 500 millisecond delay. Change to whatever delay you want.
handler.postDelayed(postToServerRunnable, 500);
}
};
There is this is method called EditText.edittext.addtextchangedlistener . add this listener to your edittext and override the methods like this.
#Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
#Override
public void beforeTextChanged(CharSequence s, int start, int count,
int after) {
}
#Override
public void afterTextChanged(Editable s) {
called after the The complete Text is changed// this is what i think you should use
}
I hope this is helpful . ThankYou.
I am trying to build a simple converter code(convert feet to mtr) in Android. I am able to do this but only when user clicks some button. Now I want to modify it such that it starts to convert as and when the user gives input(Something like google converter). Is there any way to do this in Android?
Thanks in advance.
Add the listener to your edittext:
yourEditText.addTextChangedListener(addTextWatcher);
Add the TextWatcher interface:
private TextWatcher addTextWatcher = new TextWatcher() {
#Override
public void onTextChanged(CharSequence sequence, int start, int before, int count) {
// here is where you could grab the contents of the edittext
// input each time a character is entered, and pass the value
// off to your unit conversion code. Careful to check for
// numerals/decimals only, or to set the proper inputType in
// your xml.
}
#Override
public void beforeTextChanged(CharSequence sequence, int start, int count, int after) {
}
#Override
public void afterTextChanged(Editable sequence) {
}
};
I'm trying to work with a MultiAutocompleteTextView in such way that whenever I type a character in the textview, an event will be fired OR after 2-3 elements have been typed, fire the event again.
The reason I work with multiautocomplete is because I also need the autocompletion feature .
Is there such an event that can be triggered after every character or 2-3 characters typed? Thanks!
Yes you can use add a TextWatcher and TextChangedListener to your edit Text like this:
myEditText.addTextChangedListener(new TextWatcher() {
#Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
//check count or count in edit text and do something
}
#Override
public void afterTextChanged(Editable arg0) {
}
#Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
});
http://developer.android.com/reference/android/text/TextWatcher.html
private TextWatcher billEditTextWatcher = new TextWatcher()
{
// called when the user enters a number
#Override
public void onTextChanged(CharSequence s, int start,
int before, int count)
{
// convert billEditText's text to a double
try
{
currentBillTotal = Double.parseDouble(s.toString());
} // end try
catch (NumberFormatException e)
{
currentBillTotal = 0.0; // default if an exception occurs
} // end catch
// update the standard and custom tip EditTexts
updateStandard(); // update the 10, 15 and 20% EditTexts
updateCustom(); // update the custom tip EditTexts
} // end method onTextChanged
#Override
public void afterTextChanged(Editable s)
{
} // end method afterTextChanged
#Override
public void beforeTextChanged(CharSequence s, int start, int count,
int after)
{
} // end method beforeTextChanged
}; // end billEditTextWatcher
This is a segment of a code from a tip calculator app written by a professional. Can someone explain how this works?
Usually I just write the following to create a new object.
TextWatcher billEditTextWatcher = new TextWatcher();
I understand what the private does. But how come there are methods in the creation of the new object? Is it basically doing what it says? overriding the original methods in the TextWatcher class?
I hope this question makes sense because I'm quiet confused.
Thanks in advance!
This is an example of an anonymous class in Java. You don't have any TextWatcher java file, and you declare the content of the class while initializing it.
http://docs.oracle.com/javase/tutorial/java/javaOO/anonymousclasses.html
As name is indicating TextWatcher will sense all event of EditText
Like when you are writing something in Editable area.
Its have following callback(Watching state.)
Key Pressed - beforeTextChanged();
Key Down - afterTextChanged();
Text Change - onTextChanged();
All the callback method contain their relative data which passed by event generator. like which is key is pressed , Unicode(ASCII) of Key etc.
Basically, a TextWatcher is used to keep watch on EditText or MultiLine EditText while entering data into it. We can perform operation and keep watch on which characters are being entered or how many characters are being entered in the EditText.
Technical Description:
If you want to use TextWatcher then you need to resister your EditText with TextWather object.
e.g.
EditText editTextPassword; // Some EditText object.
TextWatcher billEditTextWatcher = new TextWatcher(); // TextWather object creation
editTextPassword.addTextChangedListener(billEditTextWatcher ); // EditText registation with Textwather object.
By default all call back of TextWather are empty that's that why you need yo give your definition of all callback according to your requirement.
private TextWatcher billEditTextWatcher = new TextWatcher()
{
#Override
public void onTextChanged(CharSequence s, int start, int before, int count)
{
// you code is here while onTextChanged.
}
#Override
public void afterTextChanged(Editable s)
{
you code is here while afterTextChanged.
}
#Override
public void beforeTextChanged(CharSequence s, int start, int count,
int after)
{
// you code is here while beforeTextChanged.
}
};
I am creating a comma seperated file and don't want to give the user a way to confuse the app.
Following what RoToRa said, you can delimitate the file using tabs instead.
If you do want to disallow commas, you can add a TextWatcher to modify the string before it is posted to the GUI:
EditText text;
private void foo()
{
text.addTextChangedListener(new TextWatcher()
{
public void onTextChanged(CharSequence s, int start, int before, int count)
{
}
public void beforeTextChanged(CharSequence s, int start, int count, int after)
{
}
public void afterTextChanged(Editable s)
{
// modify string here
}
});
}
Just check the addTextChangedListener(TextWatcher watcher) method - add the listener, which will check the editText field when it changes.