Cómo evitar que EditText se enfoque en el inicio de la actividad en Android

Excelentes respuestas de Luc y Mark, sin embargo, falta una buena muestra de código. Agregar la etiqueta android:focusableInTouchMode="true" y android:focusable="true" al diseño principal (p. ej. LinearLayout or ConstraintLayout) como el siguiente ejemplo solucionará el problema.

<!-- Dummy item to prevent AutoCompleteTextView from receiving focus -->
<LinearLayout
    android:focusable="true" 
    android:focusableInTouchMode="true"
    android:layout_width="0px" 
    android:layout_height="0px"/>

<!-- :nextFocusUp and :nextFocusLeft have been set to the id of this component
to prevent the dummy from receiving focus again -->
<AutoCompleteTextView android:id="@+id/autotext"
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content"
    android:nextFocusUp="@id/autotext" 
    android:nextFocusLeft="@id/autotext"/>

¿El problema real es que simplemente no quieres que se enfoque en absoluto? O no quiere que muestre el teclado virtual como resultado de enfocar el EditText? Realmente no veo un problema con el EditText tener el foco en el inicio, pero definitivamente es un problema tener la ventana softInput abierta cuando el usuario no solicitó explícitamente enfocarse en el EditText (y abre el teclado como resultado).

Si es el problema del teclado virtual, consulte el AndroidManifest.xml elemento documentación.

android:windowSoftInputMode="stateHidden" - Ocultarlo siempre al entrar en la actividad.

or android:windowSoftInputMode="stateUnchanged" - no lo cambie (por ejemplo, no Mostrar si aún no se muestra, pero si estaba abierto al ingresar a la actividad, déjelo abierto).

Existe una solución más sencilla. Establezca estos atributos en su diseño principal:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/mainLayout"
    android:descendantFocusability="beforeDescendants"
    android:focusableInTouchMode="true" >

Y ahora, cuando la actividad comience, este diseño principal se enfocará de forma predeterminada.

Además, podemos quitar el foco de las vistas secundarias en tiempo de ejecución (por ejemplo, después de terminar la edición secundaria) dando el foco al diseño principal nuevamente, así:

findViewById(R.id.mainLayout).requestFocus();

Buen comentario a partir de octubre XNUMX Guillermo Perrot:

android:descendantFocusability="beforeDescendants" parece ser el predeterminado (el valor entero es 0). Funciona con solo agregar android:focusableInTouchMode="true".

Realmente, podemos ver que el beforeDescendants establecido como predeterminado en el ViewGroup.initViewGroup() método (Android 2.2.2). Pero no igual a 0. ViewGroup.FOCUS_BEFORE_DESCENDANTS = 0x20000;

Gracias a Guillaume.

La única solución que encontré es:

• Créar un diseño lineal (No sé si funcionarán otros tipos de diseños)
• Establecer los atributos android:focusable="true" y android:focusableInTouchMode="true"

En los EditText no se enfocará después de comenzar la actividad

El problema parece provenir de una propiedad que solo puedo ver en el XML form del diseño.

Asegúrese de eliminar esta línea al final de la declaración dentro del EditText Etiquetas XML:

<requestFocus />

Eso debería dar algo así:

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

   //<requestFocus /> /* <-- without this line */
</EditText>

Utilizando la información proporcionada por otros carteles, utilicé la siguiente solución:

en el XML de diseño

<!-- Dummy item to prevent AutoCompleteTextView from receiving focus -->
<LinearLayout
    android:id="@+id/linearLayout_focus"
    android:focusable="true"
    android:focusableInTouchMode="true"
    android:layout_width="0px"
    android:layout_height="0px"/>

<!-- AUTOCOMPLETE -->
<AutoCompleteTextView
    android:id="@+id/autocomplete"
    android:layout_width="200dip"
    android:layout_height="wrap_content"
    android:layout_marginTop="20dip"
    android:inputType="textNoSuggestions|textVisiblePassword"/>

en onCreate ()

private AutoCompleteTextView mAutoCompleteTextView;
private LinearLayout mLinearLayout;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.mylayout);

    //get references to UI components
    mAutoCompleteTextView = (AutoCompleteTextView) findViewById(R.id.autocomplete);
    mLinearLayout = (LinearLayout) findViewById(R.id.linearLayout_focus);
}

y finalmente, en onResume ()

@Override
protected void onResume() {
    super.onResume();

    //do not give the editbox focus automatically when activity starts
    mAutoCompleteTextView.clearFocus();
    mLinearLayout.requestFocus();
}

Intente clearFocus () en lugar de setSelected(false). Cada vista en Android tiene tanto capacidad de enfoque como de selección, y creo que solo desea aclarar el enfoque.

Lo siguiente evitará que el texto de edición se enfoque cuando se crea, pero agárrelo cuando lo toque.

<EditText
    android:id="@+id/et_bonus_custom"
    android:focusable="false" />

Por lo tanto, establece focusable en falso en el xml, pero la clave está en java, al que agrega el siguiente oyente:

etBonus.setOnTouchListener(new View.OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        v.setFocusable(true);
        v.setFocusableInTouchMode(true);
        return false;
    }
});

Debido a que está devolviendo falso, es decir, no consumiendo el evento, el comportamiento de enfoque procederá normalmente.

Probé varias respuestas individualmente, pero el enfoque todavía está en EditText. Solo logré resolverlo usando dos de las siguientes soluciones juntas.

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:id="@+id/mainLayout"
  android:descendantFocusability="beforeDescendants"
  android:focusableInTouchMode="true" >

(Referencia de Silver https://stackoverflow.com/a/8639921/15695 )

y quitar

 <requestFocus />

en EditText

(Referencia de floydaddict https://stackoverflow.com/a/9681809 )

Respuesta tardía pero más simple, solo agregue esto en el diseño principal del XML.

android:focusable="true" 
android:focusableInTouchMode="true"

¡Vota si te ayudó! Codificación feliz :)

Ninguna de estas soluciones funcionó para mí. La forma en que arreglo el enfoque automático fue:

<activity android:name=".android.InviteFriendsActivity" android:windowSoftInputMode="adjustPan">
    <intent-filter >
    </intent-filter>
</activity>

Solución simple: en AndroidManifest in Activity uso de etiquetas

android:windowSoftInputMode="stateAlwaysHidden"

Puedes simplemente configurar "enfocable" y "enfocable en modo táctil" para valorar verdadero en el primero TextView de la layout. De esta forma cuando la actividad comienza el TextView estará enfocado pero, por su naturaleza, no verá nada enfocado en la pantalla y, por supuesto, habrá no teclado mostrado ...

Lo siguiente funcionó para mí en Manifest. Escribir ,

<activity
android:name=".MyActivity"
android:windowSoftInputMode="stateAlwaysHidden"/>

Necesitaba despejar el enfoque de todos los campos mediante programación. Acabo de agregar las siguientes dos declaraciones a mi definición de diseño principal.

myLayout.setDescendantFocusability(ViewGroup.FOCUS_BEFORE_DESCENDANTS);
myLayout.setFocusableInTouchMode(true);

Eso es. Arreglado mi problema al instante. Gracias, Silver, por indicarme la dirección correcta.

Añada android:windowSoftInputMode="stateAlwaysHidden" en la etiqueta de actividad del Manifest.xml archivo.

Fuente

Si tiene otra vista de su actividad como un ListView, también puedes hacer:

ListView.requestFocus(); 

en tu onResume() para captar el foco de la editText.

Sé que esta pregunta ha sido respondida, pero solo proporciono una solución alternativa que funcionó para mí :)

Pruebe esto antes de su primer campo editable:

<TextView  
        android:id="@+id/dummyfocus" 
        android:layout_width="fill_parent"
        android:layout_height="wrap_content" 
        android:text="@string/foo"
        />

----

findViewById(R.id.dummyfocus).setFocusableInTouchMode(true);
findViewById(R.id.dummyfocus).requestFocus();

Agregar siguientes en onCreate método:

this.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

Dado que no me gusta contaminar el XML con algo relacionado con la funcionalidad, creé este método que "de forma transparente" roba el foco de la primera vista enfocable y luego se asegura de eliminarse cuando sea necesario.

public static View preventInitialFocus(final Activity activity)
{
    final ViewGroup content = (ViewGroup)activity.findViewById(android.R.id.content);
    final View root = content.getChildAt(0);
    if (root == null) return null;
    final View focusDummy = new View(activity);
    final View.OnFocusChangeListener onFocusChangeListener = new View.OnFocusChangeListener()
    {
        @Override
        public void onFocusChange(View view, boolean b)
        {
            view.setOnFocusChangeListener(null);
            content.removeView(focusDummy);
        }
    };
    focusDummy.setFocusable(true);
    focusDummy.setFocusableInTouchMode(true);
    content.addView(focusDummy, 0, new LinearLayout.LayoutParams(0, 0));
    if (root instanceof ViewGroup)
    {
        final ViewGroup _root = (ViewGroup)root;
        for (int i = 1, children = _root.getChildCount(); i < children; i++)
        {
            final View child = _root.getChildAt(i);
            if (child.isFocusable() || child.isFocusableInTouchMode())
            {
                child.setOnFocusChangeListener(onFocusChangeListener);
                break;
            }
        }
    }
    else if (root.isFocusable() || root.isFocusableInTouchMode())
        root.setOnFocusChangeListener(onFocusChangeListener);

    return focusDummy;
}

Escriba esta línea en su Diseño para padres ...

 android:focusableInTouchMode="true"

Tarde, pero quizás útil. Cree un EditText ficticio en la parte superior de su diseño y luego llame myDummyEditText.requestFocus() in onCreate()

<EditText android:id="@+id/dummyEditTextFocus" 
android:layout_width="0px"
android:layout_height="0px" />

Eso parece comportarse como esperaba. No es necesario manejar cambios de configuración, etc. Necesitaba esto para una actividad con un TextView extenso (instrucciones).

Sí, hice lo mismo: creé un diseño lineal 'ficticio' que obtiene el enfoque inicial. Además, configuré las ID de enfoque 'siguiente' para que el usuario no pueda enfocarlo más después de desplazarse una vez:

<LinearLayout 'dummy'>
<EditText et>

dummy.setNextFocusDownId(et.getId());

dummy.setNextFocusUpId(et.getId());

et.setNextFocusUpId(et.getId());

mucho trabajo solo para deshacerse del enfoque en una vista ..

Muchas Gracias

Para mí, lo que funcionó en todos los dispositivos es esto:

    <!-- fake first focusable view, to allow stealing the focus to itself when clearing the focus from others -->

    <View
    android:layout_width="0px"
    android:layout_height="0px"
    android:focusable="true"
    android:focusableInTouchMode="true" />

Simplemente coloque esto como una vista antes de la vista enfocada problemática, y eso es todo.

<TextView
    android:id="@+id/TextView01"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:layout_weight="1"
    android:singleLine="true"
    android:ellipsize="marquee"
    android:marqueeRepeatLimit="marquee_forever"
    android:focusable="true"
    android:focusableInTouchMode="true"
    style="@android:style/Widget.EditText"/>

Lo más simple que hice fue poner el foco en otra vista en onCreate:

    myView.setFocusableInTouchMode(true);
    myView.requestFocus();

Esto detuvo la aparición del teclado en pantalla y no había ningún cursor parpadeando en EditText.

Esta es la solución perfecta y más fácil. Siempre la uso en mi aplicación.

getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);

Escribe este código dentro Manifest presentar en el Activity donde no desea abrir el teclado.

android:windowSoftInputMode="stateHidden"

Archivo de manifiesto:

 <?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.projectt"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="24" />

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
         <activity
            android:name=".Splash"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity
            android:name=".Login"
            **android:windowSoftInputMode="stateHidden"**
            android:label="@string/app_name" >
        </activity>

    </application>

</manifest>

At onCreate de su actividad, solo agregue el uso clearFocus() en su elemento EditText. Por ejemplo,

edittext = (EditText) findViewById(R.id.edittext);
edittext.clearFocus();

Y si desea desviar el foco a otro elemento, use requestFocus() en ese. Por ejemplo,

button = (Button) findViewById(R.id.button);
button.requestFocus();

La forma más fácil de ocultar el teclado es usar setSoftInputMode

getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

o puede usar InputMethodManager y ocultar el teclado como este.

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(myEditText.getWindowToken(), 0);