EditText con teclado numérico por defecto, pero permitiendo caracteres alfabéticos

Tengo un cuadro EditText y quiero que el teclado predeterminado que aparece cuando se selecciona sea el teclado numérico, ya que la mayoría de las veces los usuarios ingresarán números. Sin embargo, quiero permitir que los usuarios también ingresen caracteres alfabéticos, si es necesario. El uso android:inputType="number"restringe la entrada solo a dígitos numéricos. ¿Que opciones tengo?

Defina su EditText en su xml de esta manera:

<EditText 
    android:id="@+id/txtOppCodigoCliente"
    android:inputType="textVisiblePassword"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:maxLength="11"
    android:hint="@string/strCodigoCliente"/>

salida: android: inputType = "textVisiblePassword"

Una fila de números y el resto de letras.

Sugeriría una solución más robusta:

Presente al usuario la posibilidad de elegir el tipo de entrada:

ARREGLOS NECESARIOS

- mejor manejo de mostrar / ocultar los botones de selección de entrada

- probablemente elimine las sugerencias cuando el tipo de entrada sea letra

Aquí está la actividad:

package mobi.sherif.numberstexttextview;

import android.os.Bundle;
import android.app.Activity;
import android.text.InputType;
import android.view.View;
import android.view.View.OnFocusChangeListener;
import android.widget.EditText;

public class MainActivity extends Activity {

    EditText mEdit;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mEdit = (EditText) findViewById(R.id.input);
        mEdit.setOnFocusChangeListener(new OnFocusChangeListener() {

            @Override
            public void onFocusChange(View view, boolean focused) {
                findViewById(R.id.llmenu).setVisibility(focused?View.VISIBLE:View.GONE);
            }
        });
    }

    public void onNumbers(View v) {
        mEdit.setInputType(InputType.TYPE_CLASS_NUMBER);
    }

    public void onLetters(View v) {
        mEdit.setInputType(InputType.TYPE_CLASS_TEXT);
    }

}

Aquí está el xml de la actividad: activity_main.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <ScrollView
        android:id="@+id/scrollview"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:layout_alignWithParentIfMissing="true"
        android:layout_above="@+id/llmenu" >

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content" >

            <EditText
                android:id="@+id/input"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:inputType="number" >

                <requestFocus />
            </EditText>
        </LinearLayout>
    </ScrollView>

    <LinearLayout
        android:id="@+id/llmenu"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"
        android:background="#000000"
        android:padding="0dp" >

        <Button
            android:id="@+id/buttonnumbers"
            android:layout_width="0dp"
            android:onClick="onNumbers"
            android:layout_height="match_parent"
            android:layout_weight="1"
            android:text="Numbers" />

        <Button
            android:id="@+id/buttonletters"
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="1"
            android:onClick="onLetters"
            android:text="Letters" />
    </LinearLayout>

</RelativeLayout>

Esto es lo que busca:

Defina su EditTexten su xml de esta manera:

<EditText
    android:id="@+id/etTest"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:ems="10"
    android:hint="@string/hint">

</EditText>

Y llame siguiendo en su onCreate():

etTest = (EditText) findViewById(R.id.etTest);
etTest.setRawInputType(InputType.TYPE_CLASS_NUMBER);
// Note the "Raw"

Siempre que haga clic en su EditTextahora, puede ingresar dígitos Y letras . (El teclado de dígitos se muestra primero)

Desafortunadamente, esto no es posible, porque solo se puede establecer un inputType para un EditText. Lo siguiente solo mostrará caracteres alfabáticos en los botones.

<EditText
        android:id="@+id/editText1"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:inputType="text|number" />

Sin embargo, lo que puedo sugerirle es que establezca su tipo de entrada en numérico y simplemente agregue un pequeño botón switchKeyboard en su formulario cerca del teclado numérico. Y establecer su onClick

editText1.setInputType(InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS);

para que los usuarios también puedan cambiar a caracteres alfabéticos.

Básicamente, el tipo de entrada EditText se usa para establecer el tipo de entrada en su EditText.

Los posibles valores para el android:inputtypeson:

• texto
• textCapCharacters
• textCapWords
• textCapSentences
• textAutoCorrect
• textAutoComplete
• textMultiLine
• textImeMultiLine
• textNoSuggestions
• textUri
• textEmailAddress
• textEmailSubject
• textShortMessage
• textLongMessage
• textPersonName
• textPostalAddress
• textPassword
• textVisiblePassword
• textWebEditText
• textFilter
• textPhonetic
• número
• numberSigned
• numberDecimal
• teléfono
• fecha y hora
• fecha
• hora

entonces puede usar cualquier valor como se muestra en el ejemplo:

<EditText android:id="@+id/EditText01"
 android:layout_height="wrap_content"
 android:layout_width="fill_parent"
 android:inputType="number"
 android:text="1212223"/>

La tableta Asus tiene esa característica, han personalizado el teclado predeterminado. Y el teclado contiene solo números y alfabetos. Creo que su solución de requisitos es también personalizar el teclado predeterminado

Puede seguir la respuesta de Paresh Mayani.

Y como consejo, puede usar android:inputType="textPhonetic"para inputType Text y Number según la selección del usuario.

Espero que entiendas mi punto.

En OnCreate in Activity haz esto:

    t = (EditText) findViewById(R.id.test);
    t.setKeyListener(new KeyListener() {

        @Override
        public boolean onKeyUp(View view, Editable text, int keyCode, KeyEvent event) {
            return false;
        }

        @Override
        public boolean onKeyOther(View view, Editable text, KeyEvent event) {
            return false;
        }

        @Override
        public boolean onKeyDown(View view, Editable text, int keyCode, KeyEvent event) {
            if (keyCode == 67) { // Handle backspace button =)
                if (text.length() > 0) {
                    t.setText(text.subSequence(0, text.length() - 1));
                    t.setSelection(text.length()-1);
                }
            }
            return false;
        }

        @Override
        public int getInputType() {
            return InputType.TYPE_CLASS_NUMBER;
        }

        @Override
        public void clearMetaKeyState(View view, Editable content, int states) {

        }
    });

En este caso, escribe es numbery Android mostrará el teclado numérico, pero puede ingresar lo que quiera. También puede anular otros métodos si lo desea.

Así es como lo logré ...

android: inputType = "textPhonetic | numberDecimal" android: digits = "/ 0123456789.abcdefghijklmnopqrstuvwxyz"

Solo se permitirán los caracteres especificados por dígitos.

Tenga en cuenta que el teclado que se muestra es el del marcador, no el teclado típico. Para mí, logró lo que necesitaba completamente dentro del XML.

No debe usar ningún filtro inputType en este caso, simplemente agregue la siguiente línea en su propiedad EditText

android:digits="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 "

Ahora solo estos caracteres podrán ingresar en EditText. El código completo de su texto de edición será así:

<EditText
 android:id="@+id/etTest"
 android:layout_width="match_parent"
 android:layout_height="wrap_content"
 android:ems="10"
 android:digits="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 "
 android:hint="@string/hint">

¿Por qué no tener un botón de alternancia que:

• Establece el tipo de entrada para permitir solo valores numéricos
• Establece el tipo de entrada para permitir el uso del teclado QWERTY
• O configure otros tipos de entrada (si es necesario)

De esa manera, puede configurar el teclado numérico por defecto, luego el usuario puede cambiarlo presionando un botón.

Esto no es posible dados los tipos de entrada de Android predeterminados actuales en varios teléfonos.

Hay muchos trucos posibles que funcionan en algunos teclados pero no en otros , como el método común de configurar el tipo de entrada sin procesar que se incluye comúnmente en las respuestas:

• editText.setRawInputType(InputType.TYPE_CLASS_NUMBER)

El mejor consejo que pude encontrar es usar el textPostalAddresstipo de entrada en su XML:

• android:inputType="textPostalAddress"

Desafortunadamente esto no hacer lo que queremos que haga todavía , pero tal vez será en el futuro . La única ventaja de esto es que la metainformación en su cuadro de edición reflejará lo que pretende.

Programáticamente es posible con un pequeño ajuste al flujo habitual. Primero tienes que configurar editText como:

editText.setInputType(InputType.TYPE_CLASS_NUMBER);

Entonces tienes que escuchar el evento clave. Al presionar la libra, configure InputType nuevamente en InputType.TYPE_CLASS_TEXT. Esto debería funcionar como funciona para mí.

editText.setOnKeyListener(new View.OnKeyListener() 
{
     @Override
     public boolean onKey(View v, int keyCode, KeyEvent event) {
     // TODO Auto-generated method stub
     Log.d("KeyBoard", "Keyboard Test Key Hit");

        switch (keyCode) 
        {
              KeyEvent.KEYCODE_POUND:

              if(editText.setInputType(InputType.TYPE_CLASS_TEXT);
              {                             
                   editText.setInputType(InputType.TYPE_CLASS_TEXT);
                   return true;
              }
         }
     }
}  

Puedes intentar configurar ---

editText.setRawInputType(Configuration.KEYBOARD_QWERTY);

para más descripción

En su código para textView, elimine el "texto" en android: inputType.

Debería ser,

<EditText
        android:id="@+id/editText1"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:inputType="number" />

Puedes hacer esto programáticamente:

// Numbers
mEditText.setInputType(InputType.TYPE_CLASS_NUMBER);

// Text
mEditText.setInputType(InputType.TYPE_CLASS_TEXT);

setInputType (tipo int) Establece el tipo de contenido con una constante como se define para inputType.

Como dice Saurav, la mejor manera es cambiar entre el teclado QWERTY y el teclado numérico con un simple oyente:

input.setInputType(InputType.TYPE_CLASS_TEXT);

input.setOnKeyListener(new View.OnKeyListener() {
    @Override
    public boolean onKey(View v, int keyCode, KeyEvent event) {

        switch (keyCode) {
        case 24: // Volumen UP

             input.setInputType(InputType.TYPE_CLASS_NUMBER);
             break;
         case 25: // Volumen DOWN

             input.setInputType(InputType.TYPE_CLASS_TEXT);
             break;
        }
        return true;
    }
});

Intento todo el método pero no perfecto. Entonces tengo otra idea. Funciona perfecto para todos los teclados.

 @Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_reset_password);
    editText.setRawInputType(InputType.TYPE_CLASS_NUMBER);
}
@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);


    // Checks whether a hardware keyboard is available
    if (newConfig.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_NO) {
        Toast.makeText(this, "keyboard visible", Toast.LENGTH_SHORT).show();
        if (editText.isFocused()) {
            editText.setInputType(InputType.TYPE_CLASS_TEXT);
        }

    } else if (newConfig.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_YES) {
        Toast.makeText(this, "keyboard hidden", Toast.LENGTH_SHORT).show();
        if (editText.getInputType() == InputType.TYPE_CLASS_TEXT) {
            editText.setInputType(InputType.TYPE_CLASS_NUMBER);
        }
    }
}

En su diseño xml para EditText agregue este parámetro:

android:inputType="number|text"

Esto permitirá al usuario ingresar tanto texto como número y contiene la lógica en el xml en lugar de tener código en su actividad o fragmento.