I'm trying to get a character count of an EditText (numberRoom). When user would insert 8 characters button should switch from state Disabled and color 0xBBFFFFFF to state Enabled and color 0xFFFFFFFF.
I've tried few method and I think the best one I've found is that one below. However button has state Enabled and color 0xFFFFFFFF even when input is empty. What's wrong there?
public class Join_room_screen extends Activity {
EditText numberRoom;
Button goToRoom;
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.joinroom);
numberRoom = (EditText) findViewById(R.id.roomNumber);
goToRoom = (Button) findViewById(R.id.goToRoom);
TextWatcher watcher = new LocalTextWatcher();
goToRoom.addTextChangedListener(watcher);
updateButtonState();
}
void updateButtonState() {
boolean enabled = checkEditText(numberRoom);
goToRoom.setBackgroundColor(0xFFFFFFFF);
goToRoom.setEnabled(enabled);
}
private boolean checkEditText(EditText edit) {
return ((edit.getText().toString()).length() == 8 );
}
private class LocalTextWatcher implements TextWatcher {
public void afterTextChanged(Editable s) {
updateButtonState();
}
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
}
}
However in properties I've
In this function the enabled variable is never used so the background colour and enabled states are always set.
void updateButtonState() {
boolean enabled = checkEditText(numberRoom);
goToRoom.setBackgroundColor(0xFFFFFFFF);
goToRoom.setEnabled(enabled);
}
I would replace with something like
void updateButtonState() {
boolean enabled = checkEditText(numberRoom);
if (enabled) {
goToRoom.setBackgroundColor(0xFFFFFFFF);
goToRoom.setEnabled(enabled);
} else {
//change them back to disabled state
}
}
You have one problem in updateButtonState(), it always sets one color to your button. I see, you have already solved that.
The other problem is that you set TextChangeListener not to an EditText, but somewhy to a Button.
The EditText should be watched.
numberRoom.addTextChangedListener(watcher);
instead of
goToRoom.addTextChangedListener(watcher);
Related
Code
Button mButton;
int mDefaultColor;
mButton = (Button)findViewById(R.id.buttontextcolorsent);
mDefaultColor = ContextCompat.getColor(Customise.this,R.color.white);
mButton.setBackgroundColor(mDefaultColor);
mButton.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View v) {
openColorPicker();
}
});
}
private void openColorPicker() {
AmbilWarnaDialog colorPicker = new AmbilWarnaDialog(this, mDefaultColor, new AmbilWarnaDialog.OnAmbilWarnaListener() {
#Override
public void onCancel(AmbilWarnaDialog dialog) {
}
#Override
public void onOk(AmbilWarnaDialog dialog, int color) {
mDefaultColor = color;
mButton.setBackgroundColor(mDefaultColor);
}
});
colorPicker.show();
}
}
This is a popular library called ambil warna which shows a colorpicker... when a user picks the color it successfully changes the color of the button... but the problem is its not permanent... like if the user exits and enters the activity again the button will turn back to its original default color... so how do i make this change permanent? and i dont want to use any kind of server database... so is it possible to make this change using SQLlite? or is there any other way?
You could just store the selected color to SharedPreferences.
PreferencaManager.getDefaultSharedPreferences()
.edit()
.putInt("button_color", newHighScore)
.apply()
How to use custom image instead of '*' in edittext password field?
see image:
Any answer or hint will be greatly appreciated.
The answer comes from this tutorial and it covers a behaviour when a user:
enters into the login screen, keyboard will open automatically.
tries to enter value in it then textbox background changes to textbox with star background.
tries to cancel/delete the input value by using back key on keyboard then textbox background will change to textbox without star background.
First of all you have to create two drawables:
Then, according to this approach, you have to implement addTextChangedListener method on your EditText. After that, as a parameter, you create a new instance of a TextWatcher class and you implement its methods:
etxtPin1.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) {
if(etxtPin1.getText().toString().trim().length()==1){
etxtPin1.clearFocus();
etxtPin2.requestFocus();
etxtPin1.setBackgroundResource(R.drawable.pin_txt_bg_star);
}
}
});
Then, you have to implement setOnKeyListener and its method onKey:
this.etxtPin1.setOnKeyListener(new View.OnKeyListener() {
public boolean onKey(View paramView, int paramInt, KeyEvent paramKeyEvent) {
if ((paramKeyEvent.getAction() == KeyEvent.ACTION_DOWN)&&(paramInt == 67) && (LoginActivity.this.etxtPin2.getText().length() == 0)) {
etxtPin1.requestFocus();
etxtPin1.setBackgroundResource(R.drawable.pin_txt_bg);
etxtPin1.setText("");
}
return false;
}
});
Another approach: create you own class which extends PasswordTransformationMethod.
public class MyPasswordTransformationMethod extends PasswordTransformationMethod {
#Override
public CharSequence getTransformation(CharSequence source, View view) {
return new PasswordCharSequence(source);
}
private class PasswordCharSequence implements CharSequence {
private CharSequence mSource;
public PasswordCharSequence(CharSequence source) {
mSource = source; // Store char sequence
}
public char charAt(int index) {
return '*'; // This is the important part
}
public int length() {
return mSource.length(); // Return default
}
public CharSequence subSequence(int start, int end) {
return mSource.subSequence(start, end); // Return default
}
}
};
Reference: In android how to show asterisk (*) in place of dots in EditText having inputtype as textPassword?
I think simple way is, you have to define 6-edittext in xml layout.
and set width and height with custom background resorces.
Like,
<?xml version="1.0" encoding="utf-8"?>
<solid android:color="#FFFFFF" />
<stroke
android:width="1dp"
android:color="#9999" />
<corners
android:bottomLeftRadius="1dp"
android:bottomRightRadius="1dp"
android:topLeftRadius="1dp"
android:topRightRadius="1dp" />
and read all edittext value.
I am not sure but it will help you.
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.
}
};
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.
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.