I want to set animation on ImageView when user put more than 3 characters. I wrote a code to do this. Main problem is when I keep putting more than 3 characters the animation starts again from 0 position always when new character is added, so it doesn't looks good.
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_new_user_first);
initViews();
imageButtonNext.setEnabled(false);
horizontalScrollView.post(() -> horizontalScrollView.scrollTo(0, 0));
horizontalScrollView.setOnTouchListener((v, event) -> true);
editTextEnterName.addTextChangedListener(nameTextWatcher);
pulse = AnimationUtils.loadAnimation(NewUserFirst.this, R.anim.pulse);
imageButtonNext.setOnClickListener(view -> {
intent = new Intent(this, NewUserSecond.class);
startActivity(intent);
});
}
public void buttonAnimation(){
if(buttonBoolean){
imageButtonNext.setAnimation(pulse);
imageButtonNext.setColorFilter(ContextCompat.getColor(NewUserFirst.this, R.color.accent));
imageButtonNext.setEnabled(true);
} else {
imageButtonNext.clearAnimation();
imageButtonNext.setColorFilter(ContextCompat.getColor(NewUserFirst.this, R.color.gray));
imageButtonNext.setEnabled(false);
}
}
private final TextWatcher nameTextWatcher = new TextWatcher() {
#Override
public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
}
#Override
public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
nameInput = editTextEnterName.getText().toString().trim();
if (nameInput.length() >= 3) {
buttonBoolean = true;
} else {
buttonBoolean = false;
}
}
#Override
public void afterTextChanged(Editable editable) {
buttonAnimation();
}
};
So the question is, what changes I need to make in my code to set animation, and do not renew it every time when add next character.
Here is the answer:
public void buttonAnimation(){
if(buttonBoolean){
if (!imageButtonNext.isEnabled()) {
imageButtonNext.setAnimation(pulse);
imageButtonNext.setColorFilter(ContextCompat.getColor(this, R.color.accent));
imageButtonNext.setEnabled(true);
}
} else {
imageButtonNext.clearAnimation();
imageButtonNext.setColorFilter(ContextCompat.getColor(this, R.color.gray));
imageButtonNext.setEnabled(false);
}
}
We need to add if statement in animation method. Program check animation is currently enabled, when yes, program do nothing. Result is animation triggered once live his own life until we modify edittext to length less than 3.
I was creating user interface where user have to enter the mobile number in EditText. maxLength of that EditText is 10. Now I want when 10 digits entered by the user the keyboard automatically get hide. How to implement this. I already searched on google but not a single code worked for me. Below is my XML & Fragment code.
XML Code
<EditText
android:id="#+id/editTextPhone"
style="#style/EditText"
android:background="#drawable/border_design"
android:inputType="phone"
android:hint="#string/editText_phone_hint"
android:maxLength="10"
android:drawableLeft="#drawable/phone"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
Fragment Code
public class MobileNumberFragment extends Fragment {
String mobileNumber;
editTextNumber = (EditText) view.findViewById(R.id.editTextPhone);
protected boolean isValidNumber(String registerMobileNumber) {
if (registerMobileNumber != null && registerMobileNumber.length() == 10) {
return true;
}
return false;
}
private void SendOtp() {
mobileNumber = editTextNumber.getText().toString().trim();
if (!isValidNumber(mobileNumber)) //Condition so that no edit-text will remain empty
{
editTextNumber.setError("Enter the Valid Mobile Number");
editTextNumber.requestFocus();
return;
} else {
buttonSendOtp.setText("Processing...");
}
}
You can force Android to hide the virtual keyboard using the InputMethodManager, calling hideSoftInputFromWindow, passing in the token of the window containing your focused view.
// Check if no view has focus:
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
txtName = (EditText)findViewById(R.id.txtName);
txtName.addTextChangedListener(new TextWatcher() {
#Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
#Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
#Override
public void afterTextChanged(Editable s) {
if(s.toString().length() == 10){
HideKeyboardFormUser();
}
}
});
}
public void HideKeyboardFormUser(){
View view = getCurrentFocus();
InputMethodManager hideKeyboard = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
hideKeyboard.hideSoftInputFromWindow( view.getWindowToken(), 0);
}
}
This will force the keyboard to be hidden in all situations. In some cases you will want to pass in InputMethodManager.HIDE_IMPLICIT_ONLY as the second parameter to ensure you only hide the keyboard when the user didn't explicitly force it to appear (by holding down menu).
editTextNumber.addTextChangedListener(new TextWatcher() {
#Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
#Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
#Override
public void afterTextChanged(Editable s) {
if (s.toString().length() >= 10) {
editTextNumber.setVisibility(View.GONE);
} else {
editTextNumber.setVisibility(View.VISIBLE);
}
}
});
You need to add a TextWatcher listener to the EditText, and hide the keyboard once the length reached 10.
editTextNumber = (EditText) view.findViewById(R.id.editTextPhone);
editTextNumber.addTextChangedListener(new TextWatcher() {
#Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
#Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
if (s.length() == 10){
hideSoftKeyboard(requireActivity());
}
}
#Override
public void afterTextChanged(Editable s) {
}
});
public void hideSoftKeyboard(Activity activity) {
InputMethodManager inputMethodManager =
(InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
View currentFocus = activity.getCurrentFocus();
if (inputMethodManager != null) {
IBinder windowToken = activity.getWindow().getDecorView().getRootView().getWindowToken();
inputMethodManager.hideSoftInputFromWindow(windowToken, 0);
inputMethodManager.hideSoftInputFromWindow(windowToken, InputMethodManager.HIDE_NOT_ALWAYS);
if (currentFocus != null) {
inputMethodManager.hideSoftInputFromWindow(currentFocus.getWindowToken(), 0);
}
}
}
I have an EditText box where the user can enter input. I need to display the input text in a TextView (which is placed below the EditText) while the user inputting the text.
Example:
If the user is entering any characters in EditText box, I need to display the same characters in TextView. In the same way, If the user deletes any character from EditText, I need to remove the same character from TextView. (Ultimately, I want to change TextView's text on change of EditText's text). I hope my requirement is clear now. How can I achieve this? Please guide me.
Add TextWatcher to your Edittext. in afterTextChanged() do your operation.
http://developer.android.com/reference/android/text/TextWatcher.html
TextWatcher inputTextWatcher = new TextWatcher() {
public void afterTextChanged(Editable s) {
textview.setText(s.toString());
}
public void beforeTextChanged(CharSequence s, int start, int count, int after){
}
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
};
editText.addTextChangedListener(inputTextWatcher);
edtText.addTextChangedListener(new TextWatcher() {
#Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
// TODO Auto-generated method stub
}
#Override
public void beforeTextChanged(CharSequence s, int start, int count,
int after) {
// TODO Auto-generated method stub
}
#Override
public void afterTextChanged(Editable s) {
// TODO Auto-generated method stub
if (!edtText.getText().toString().equalsIgnoreCase("")){
// here textview.setText(edtText.getText());
}
}
});
}
You should overwrite this method :
editText.addTextChangedListener(new TextWatcher() {
#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) {
if(editText.getText().length() >= 0) {
textView.setText(editText.getText().toString())
}
}
});
The solution is to add TextWatcher to the EditText by using addTextChangedListener() function. In TextWatcher you'll need to write transformation / validation logic inside one of 3 functions afterTextChanged(), beforeTextChanged(), onTextChanged() depending on when you want to perform those actions.
Using Kotlin you would do something like that:
editText.addTextChangedListener(object : android.text.TextWatcher {
override fun afterTextChanged(s: Editable?) {
}
override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
}
override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
s?.let { textView.text = s.toString() }
}
})
I have a situation, where there are two fields. field1 and field2. All I want
to do is empty field2 when field1 is changed and vice versa. So at the end only
one field has content on it.
field1 = (EditText)findViewById(R.id.field1);
field2 = (EditText)findViewById(R.id.field2);
field1.addTextChangedListener(new TextWatcher() {
public void afterTextChanged(Editable s) {}
public void beforeTextChanged(CharSequence s, int start,
int count, int after) {
}
public void onTextChanged(CharSequence s, int start,
int before, int count) {
field2.setText("");
}
});
field2.addTextChangedListener(new TextWatcher() {
public void afterTextChanged(Editable s) {}
public void beforeTextChanged(CharSequence s, int start,
int count, int after) {
}
public void onTextChanged(CharSequence s, int start,
int before, int count) {
field1.setText("");
}
});
It works fine if I attach addTextChangedListener to field1 only, but when
I do it for both fields the app crashes. Obviously because they try to change
each other indefinitely. Once field1 changes it clears field2 at this moment
field2 is changed so it will clear field1 and so on...
Can someone suggest any solution?
You can add a check to only clear when the text in the field is not empty (i.e when the length is different than 0).
field1.addTextChangedListener(new TextWatcher() {
#Override
public void afterTextChanged(Editable s) {}
#Override
public void beforeTextChanged(CharSequence s, int start,
int count, int after) {
}
#Override
public void onTextChanged(CharSequence s, int start,
int before, int count) {
if(s.length() != 0)
field2.setText("");
}
});
field2.addTextChangedListener(new TextWatcher() {
#Override
public void afterTextChanged(Editable s) {}
#Override
public void beforeTextChanged(CharSequence s, int start,
int count, int after) {
}
#Override
public void onTextChanged(CharSequence s, int start,
int before, int count) {
if(s.length() != 0)
field1.setText("");
}
});
Documentation for TextWatcher here.
Also please respect naming conventions.
In Kotlin simply use KTX extension function:
(It uses TextWatcher)
yourEditText.doOnTextChanged { text, start, count, after ->
// action which will be invoked when the text is changing
}
import core-KTX:
implementation "androidx.core:core-ktx:1.2.0"
I know this is old but someone might come across this again someday.
I had a similar problem where I would call setText on a EditText and onTextChanged would be called when I didn't want it to. My first solution was to write some code after calling setText() to undo the damage done by the listener. But that wasn't very elegant.
After doing some research and testing I discovered that using getText().clear() clears the text in much the same way as setText(""), but since it isn't setting the text the listener isn't called, so that solved my problem. I switched all my setText("") calls to getText().clear() and I didn't need the bandages anymore, so maybe that will solve your problem too.
Try this:
Field1 = (EditText)findViewById(R.id.field1);
Field2 = (EditText)findViewById(R.id.field2);
Field1.addTextChangedListener(new TextWatcher() {
public void afterTextChanged(Editable s) {}
public void beforeTextChanged(CharSequence s, int start,
int count, int after) {
}
public void onTextChanged(CharSequence s, int start,
int before, int count) {
Field2.getText().clear();
}
});
Field2.addTextChangedListener(new TextWatcher() {
public void afterTextChanged(Editable s) {}
public void beforeTextChanged(CharSequence s, int start,
int count, int after) {
}
public void onTextChanged(CharSequence s, int start,
int before, int count) {
Field1.getText().clear();
}
});
If you are using Kotlin for Android development then you can add TextChangedListener() using this code:
myTextField.addTextChangedListener(object : TextWatcher{
override fun afterTextChanged(s: Editable?) {}
override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
})
var filenameText = findViewById(R.id.filename) as EditText
filenameText.addTextChangedListener(object : TextWatcher {
override fun afterTextChanged(s: Editable?) {
filename = filenameText.text.toString()
Log.i("FileName: ", filename)
}
override fun beforeTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {}
override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
})
A bit late of a answer, but here is a reusable solution:
/**
* An extension of TextWatcher which stops further callbacks being called as
* a result of a change happening within the callbacks themselves.
*/
public abstract class EditableTextWatcher implements TextWatcher {
private boolean editing;
#Override
public final void beforeTextChanged(CharSequence s, int start,
int count, int after) {
if (editing)
return;
editing = true;
try {
beforeTextChange(s, start, count, after);
} finally {
editing = false;
}
}
protected abstract void beforeTextChange(CharSequence s, int start,
int count, int after);
#Override
public final void onTextChanged(CharSequence s, int start,
int before, int count) {
if (editing)
return;
editing = true;
try {
onTextChange(s, start, before, count);
} finally {
editing = false;
}
}
protected abstract void onTextChange(CharSequence s, int start,
int before, int count);
#Override
public final void afterTextChanged(Editable s) {
if (editing)
return;
editing = true;
try {
afterTextChange(s);
} finally {
editing = false;
}
}
public boolean isEditing() {
return editing;
}
protected abstract void afterTextChange(Editable s);
}
So when the above is used, any setText() calls happening within the TextWatcher will not result in the TextWatcher being called again:
/**
* A setText() call in any of the callbacks below will not result in TextWatcher being
* called again.
*/
public class MyTextWatcher extends EditableTextWatcher {
#Override
protected void beforeTextChange(CharSequence s, int start, int count, int after) {
}
#Override
protected void onTextChange(CharSequence s, int start, int before, int count) {
}
#Override
protected void afterTextChange(Editable s) {
}
}
I wrote my own extension for this, very helpful for me. (Kotlin)
You can write only like that :
editText.customAfterTextChanged { editable ->
//You have accessed the editable object.
}
My extension :
fun EditText.customAfterTextChanged(action: (Editable?)-> Unit){
this.addTextChangedListener(object : TextWatcher {
override fun beforeTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {}
override fun onTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {}
override fun afterTextChanged(editable: Editable?) {
action(editable)
}
})}
I have also faced the same problem and keep on getting stackOverflow exceptions, and I come with the following solution.
edt_amnt_sent.addTextChangedListener(new TextWatcher() {
#Override
public void afterTextChanged(Editable s) {
if (skipOnChange)
return;
skipOnChange = true;
try {
//method
} catch (NumberFormatException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
skipOnChange = false;
}
}
});
edt_amnt_receive.addTextChangedListener(new TextWatcher() {
#Override
public void afterTextChanged(Editable s) {
if (skipOnChange)
return;
skipOnChange = true;
try {
//method
} catch (NumberFormatException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
skipOnChange = false;
}
}
});
declared initially boolean skipOnChange = false;
You can also use the hasFocus() method:
public void onTextChanged(CharSequence s, int start,
int before, int count) {
if (Field2.hasfocus()){
Field1.setText("");
}
}
Tested this for a college assignment I was working on to convert temperature scales as the user typed them in. Worked perfectly, and it's way simpler.
check String before set another EditText to empty. if Field1 is empty then why need to change again to ( "" )? so you can check the size of Your String with s.lenght() or any other solution
another way that you can check lenght of String is:
String sUsername = Field1.getText().toString();
if (!sUsername.matches(""))
{
// do your job
}
editText.addTextChangedListener(new TextWatcher() {
#Override
public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
}
#Override
public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
if (noteid != -1) {
MainActivity.notes.set(noteid, String.valueOf(charSequence));
MainActivity.arrayAdapter.notifyDataSetChanged();
}
}
#Override
public void afterTextChanged(Editable editable) {
}
});
in this code noteid is basically arguments taken back which is being putted into the indent or passed through the indent.
Intent intent = getIntent();
noteid = intent.getIntExtra("noteid", -1);
the code on the downside is basically the extra code ,if you want to understand more clearly.
how to make the menu or insert the menu in our code ,
create the menu folder this the folder created by going into the raw
->rightclick->
directory->name the folder as you wish->
then click on the directory formed->
then click on new file and then name for file as you wish ie the folder name file
and now type the 2 lines code in it and see the magic.
new activity code named as NoteEditor.java for editing purpose,my app is basicley the note app.
package com.example.elavi.notes;
import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.text.Editable;
import android.text.TextWatcher;
import android.widget.EditText;
import android.widget.Toast;
import static android.media.CamcorderProfile.get;
public class NoteEditorActivity extends AppCompatActivity {
EditText editText;
int noteid;
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_note_editor);
editText = findViewById(R.id.editText);
Intent intent = getIntent();
noteid = intent.getIntExtra("noteid", -1);
if (noteid != -1) {
String text = MainActivity.notes.get(noteid);
editText.setText(text);
Toast.makeText(getApplicationContext(),"The arraylist content is"+MainActivity.notes.get(noteid),Toast.LENGTH_SHORT).show();
}
else
{
Toast.makeText(getApplicationContext(),"Here we go",Toast.LENGTH_SHORT).show();
MainActivity.notes.add("");
noteid=MainActivity.notes.size()-1;
}
editText.addTextChangedListener(new TextWatcher() {
#Override
public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
}
#Override
public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
if (noteid != -1) {
MainActivity.notes.set(noteid, String.valueOf(charSequence));
MainActivity.arrayAdapter.notifyDataSetChanged();
}
}
#Override
public void afterTextChanged(Editable editable) {
}
});
}
}
We can remove the TextWatcher for a field just before editing its text then add it back after editing the text.
Declare Text Watchers for both field1 and field2 as separate variables to give them a name: e.g. for field1
private TextWatcher Field_1_Watcher = new TextWatcher() {
#Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
#Override
public void afterTextChanged(Editable s) {
}
#Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
};
then add the watcher using its name:
field1.addTextChangedListener(Field_1_Watcher) for field1, and
field2.addTextChangedListener(Field_2_Watcher) for field2
Before changing the field2 text remove the TextWatcher:
field2.removeTextChangedListener(Field_2_Watcher)
change the text:
field2.setText("")
then add the TextWatcher back:
field2.addTextChangedListener(Field_2_Watcher)
Do the same for the other field
Another solution that may help someone. There are 2 EditText which change instead of each other after editing. By default, it led to cyclicity.
use variable:
Boolean uahEdited = false;
Boolean usdEdited = false;
add TextWatcher
uahEdit = findViewById(R.id.uahEdit);
usdEdit = findViewById(R.id.usdEdit);
uahEdit.addTextChangedListener(new TextWatcher() {
#Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
if (!usdEdited) {
uahEdited = true;
}
}
#Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
String tmp = uahEdit.getText().toString();
if(!tmp.isEmpty() && uahEdited) {
uah = Double.valueOf(tmp);
usd = uah / 27;
usdEdit.setText(String.valueOf(usd));
} else if (tmp.isEmpty()) {
usdEdit.getText().clear();
}
}
#Override
public void afterTextChanged(Editable s) {
uahEdited = false;
}
});
usdEdit.addTextChangedListener(new TextWatcher() {
#Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
if (!uahEdited) {
usdEdited = true;
}
}
#Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
String tmp = usdEdit.getText().toString();
if (!tmp.isEmpty() && usdEdited) {
usd = Double.valueOf(tmp);
uah = usd * 27;
uahEdit.setText(String.valueOf(uah));
} else if (tmp.isEmpty()) {
uahEdit.getText().clear();
}
}
#Override
public void afterTextChanged(Editable s) {
usdEdited = false;
}
});
Don't criticize too much. I am a novice developer
etSearch.addTextChangedListener(object : TextWatcher {
override fun beforeTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {
TODO("Not yet implemented")
}
override fun onTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {
TODO("Not yet implemented")
}
override fun afterTextChanged(p0: Editable?) {
TODO("Not yet implemented")
}
})
you use this
I have provided latest method for textchangelistner
edMsg.addTextChangedListener(new TextWatcher() {
#Override
public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
}
#Override
public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
if (i2 == 0){
////Edit text blanked
}
String msg = charSequence.toString();/// your text on changed in edit text
}
#Override
public void afterTextChanged(Editable editable) {
}
});
editText.addTextChangedListener(new TextWatcher()
{
#Override
public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2)
{
}
#Override
public void onTextChanged(CharSequence chr, int i, int i1, int i2)
{
//Check char sequence is empty or not
if (chr.length() > 0)
{
//Your Code Here
}
}
#Override
public void afterTextChanged(Editable editable)
{
}
});
Add background dynamically in onCreate method:
getWindow().setBackgroundDrawableResource(R.drawable.background);
also remove background from XML.
I created an HashMap<String, String> that i populated beforehand.
And i want my AutoCompleteTextView to tell me, as i'm typing if it's in the HashMap or not. Here's my code so far :
autocomplete.addTextChangedListener(new TextWatcher() {
#Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
if(s.length() > 0){
if (map_clients.containsKey(s)){
Toast.makeText(context, "He's here", Toast.LENGTH_SHORT).show();
}
else {
Toast.makeText(context, "He's not here", Toast.LENGTH_SHORT).show();
}
}
else {
}
}
#Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
#Override
public void afterTextChanged(Editable s) {
}
});
It always tell me "He's not here" even when i type the text fully or when i select it from the autocompletion.
You need to use a TreeMap to store your data, then it is sorted, and from there you can look for the best fit from your code.
Your other option is to use a SortedList or array and use binarySearch implementations for speed.
autocomplete.addTextChangedListener(new TextWatcher() {
#Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
if(s.length() > 0){
text = s.toString();
if(map_clients.containsKey(text)){
Toast.makeText(context, "He's here", Toast.LENGTH_SHORT).show();
}else{
Toast.makeText(context, "He's not here", Toast.LENGTH_SHORT).show();
}
}else{
}
}
#Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
#Override
public void afterTextChanged(Editable s) {
}
});
I've changed it to text = s.toString();
I think it's because i put my HashMap in < String, String > and not CharSequence.