android - samsung - teclado google

Editar texto con teclado numérico de forma predeterminada, pero permitiendo caracteres alfabéticos

Question

Tengo un cuadro Editar texto 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, sí quiero permitir que los usuarios ingresen caracteres alfabéticos también, si es necesario. Usar android:inputType="number" restringe la entrada a los dígitos numéricos solamente. ¿Que opciones tengo?

Answer 1

¿Por qué no tener un botón de alternar 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 esta forma, puede configurar el teclado numérico como predeterminado, luego el usuario puede cambiarlo presionando un botón.

Answer 2

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.

Answer 3

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

Los valores posibles para el android:inputtype son:

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

entonces puedes 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"/>

Answer 4

Como dice Saurav, la mejor manera es cambiar entre QWERTY Keyboard y Numeric Keyborad 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;
    }
});

Answer 5

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 las letras.

Answer 6

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, escriba es number y android mostrará el teclado numérico, pero puede ingresar lo que desee. También puede anular otros métodos como desee.

Answer 7

En este caso, no debe usar ningún filtro de tipo de entrada, simplemente agregue la siguiente línea en su propiedad EditText

android:digits="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 "

Ahora solo a estos personajes se les permitirá ingresar en EditText. El código completo de tu 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">

Answer 8

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" />

Answer 9

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

android:inputType="number|text"

Esto permitirá que el usuario ingrese el texto y el número y contenga la lógica en el xml en lugar de tener código en su actividad o fragmento.

Answer 10

Intento todo el método pero no perfecto. Entonces tengo otra idea. Trabajo perfecto para todo el teclado

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

Answer 11

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

Answer 12

Lamentablemente, esto no es posible, ya que solo se puede establecer un tipo de entrada para EditarTexto. Lo siguiente solo mostrará caracteres alphabatic 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 sugerir es que establezca su tipo de entrada en numérico y simplemente agregue un pequeño botón de cambiar teclado en su formulario cerca del teclado numérico. Y configure su onClick

editText1.setInputType(InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS);

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

Answer 13

Programáticamente es posible con un poco de ajuste al flujo habitual. Primero debes establecer editText como:

editText.setInputType(InputType.TYPE_CLASS_NUMBER);

Entonces tienes que escuchar keyevent. Al presionar una libra, vuelve a establecer InputType en InputType.TYPE_CLASS_TEXT. Esto debería funcionar ya que 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;
              }
         }
     }
}  

Answer 14

Puedes hacer esto programáticamente:

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

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

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

Answer 15

Puedes intentar configurar ---

editText.setRawInputType(Configuration.KEYBOARD_QWERTY);

para más descripción

Answer 16

Puedes seguir la respuesta de Paresh Mayani.

Y en los consejos, puede usar android:inputType="textPhonetic" para el texto y el tipo de inputType en función de la selección del usuario.

Espero que tengas mi punto.

Answer 17

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

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

ARREGLOS NECESARIOS

- Mejor manejo de mostrar u ocultar los botones de selección de entrada

- Probablemente eliminar las sugerencias cuando el tipo de entrada es una carta

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 activity_main.xml : 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>

Answer 18

Esto es lo que estás buscando:

Defina su EditText en 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 al siguiente en su onCreate() :

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

¡Cada vez que haga clic en su EditText ahora, puede ingresar dígitos Y letras ! (El teclado de dígitos se muestra primero)

Answer 19

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

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

• editText.setRawInputType(InputType.TYPE_CLASS_NUMBER)

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

• android:inputType="textPostalAddress"

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