Come impedire a EditText di focalizzarsi all'avvio dell'attività in Android

Ne ho uno Activityin Android, con due elementi:

1. EditText
2. ListView

Quando il mio Activityinizia, EditTextimmediatamente ha il focus di input (cursore lampeggiante). Non voglio alcun controllo che abbia lo stato attivo all'avvio. Provai:

EditText.setSelected(false);
EditText.setFocusable(false);

Senza fortuna. Come posso convincere EditTexta non selezionarsi quando si Activityavvia?

Ottime risposte da Luc e Mark ma manca un buon esempio di codice. L'aggiunta del tag android:focusableInTouchMode="true"e android:focusable="true"al layout principale (ad es. LinearLayoutO ConstraintLayout) come nell'esempio seguente risolverà il 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"/>

Il vero problema è che non vuoi che si concentri? O non vuoi che mostri la tastiera virtuale come risultato della messa a fuoco del EditText? Non vedo davvero un problema con il EditTextfocus sull'avvio, ma è sicuramente un problema avere la finestra softInput aperta quando l'utente non ha esplicitamente richiesto di concentrarsi sul EditText(e di conseguenza aprire la tastiera).

Se è il problema della tastiera virtuale, consultare la documentazione AndroidManifest.xml dell'elemento <attività> .

android:windowSoftInputMode="stateHidden" - nascondilo sempre quando entri nell'attività.

oppure android:windowSoftInputMode="stateUnchanged"- non modificarlo (ad es. non mostrarlo se non è già mostrato, ma se era aperto quando si entra nell'attività, lasciarlo aperto).

Esiste una soluzione più semplice. Imposta questi attributi nel layout principale:

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

E ora, quando inizia l'attività, questo layout principale verrà attivato per impostazione predefinita.

Inoltre, possiamo rimuovere lo stato attivo dalle viste figlio in fase di esecuzione (ad esempio, dopo aver terminato la modifica figlio) dando nuovamente lo stato attivo al layout principale, in questo modo:

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

Buon commento di Guillaume Perrot :

android:descendantFocusability="beforeDescendants"sembra essere il valore predefinito (il valore intero è 0). Funziona solo aggiungendo android:focusableInTouchMode="true".

In realtà, possiamo vedere che il beforeDescendantsset è predefinito nel ViewGroup.initViewGroup()metodo (Android 2.2.2). Ma non uguale a 0.ViewGroup.FOCUS_BEFORE_DESCENDANTS = 0x20000;

Grazie a Guillaume.

L'unica soluzione che ho trovato è:

• Crea un LinearLayout (non so se altri tipi di layout funzioneranno)
• Impostare gli attributi android:focusable="true"eandroid:focusableInTouchMode="true"

E il EditTextnon otterrà il focus dopo aver iniziato l'attività

Il problema sembra provenire da una proprietà che posso vedere solo nel XML formlayout.

Assicurati di rimuovere questa riga alla fine della dichiarazione all'interno dei EditTexttag XML:

<requestFocus />

Questo dovrebbe dare qualcosa del genere:

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

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

usando le informazioni fornite da altri poster, ho usato la seguente soluzione:

nel layout XML

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

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

e infine, in onResume ()

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

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

Prova clearFocus () invece di setSelected(false). Ogni vista in Android ha sia focalizzabilità che selezionabilità, e penso che tu voglia semplicemente chiarire il focus.

Quanto segue impedirà a edittext di focalizzarsi quando viene creato, ma lo afferri quando lo tocchi.

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

Quindi imposta focusable su false in xml, ma la chiave è in java, che aggiungi il seguente listener:

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

Poiché stai restituendo false, ovvero non stai consumando l'evento, il comportamento di messa a fuoco procederà come di consueto.

Avevo provato diverse risposte individualmente, ma il focus è ancora su EditText. Sono riuscito a risolverlo solo usando due delle seguenti soluzioni insieme.

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

(Riferimento da Silver https://stackoverflow.com/a/8639921/15695 )

e rimuovi

 <requestFocus />

a EditText

(Riferimento da floydaddict https://stackoverflow.com/a/9681809 )

Risposta tardiva ma più semplice, basta aggiungerla nel layout principale dell'XML.

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

Valuta se ti ha aiutato! Happy Coding :)

Nessuna di queste soluzioni ha funzionato per me. Il modo in cui ho risolto l'autofocus è stato:

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

Soluzione semplice: in AndroidManifestin Activitytag utilizza

android:windowSoftInputMode="stateAlwaysHidden"

Puoi semplicemente impostare "focalizzabile" e "attivabile in modalità touch" per dare valore vero al primo TextViewdei layout. In questo modo quando l'attività inizia la messa TextViewa fuoco sarà focalizzata ma, per sua natura, non vedrai nulla di focalizzato sullo schermo e, naturalmente, non verrà visualizzata alcuna tastiera ...

Quanto segue ha funzionato per me Manifest. Scrivi ,

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

Avevo bisogno di cancellare la messa a fuoco da tutti i campi a livello di codice. Ho appena aggiunto le seguenti due affermazioni alla mia definizione di layout principale.

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

Questo è tutto. Risolto il mio problema all'istante. Grazie, Silver, per avermi indicato nella giusta direzione.

Aggiungi android:windowSoftInputMode="stateAlwaysHidden"il tag attività del Manifest.xmlfile.

fonte

Se hai un'altra visione della tua attività come una ListView, puoi anche fare:

ListView.requestFocus(); 

nel tuo onResume()per attirare l'attenzione dal editText.

So che a questa domanda è stata data una risposta, ma solo fornendo una soluzione alternativa che ha funzionato per me :)

Prova questo prima del tuo primo campo modificabile:

<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();

Aggiungi il seguente onCreatemetodo:

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

Essendo che non mi piace inquinare l'XML con qualcosa che è legato alla funzionalità, ho creato questo metodo che "in modo trasparente" ruba il focus dalla prima vista focalizzabile e quindi si assicura di rimuoverlo quando necessario!

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

In ritardo, ma forse utile. Creare un EditText manichino nella parte superiore del vostro layout quindi chiamare myDummyEditText.requestFocus()inonCreate()

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

Sembra che si comporti come mi aspetto. Non è necessario gestire le modifiche alla configurazione, ecc. Ne avevo bisogno per un'attività con un lungo TextView (istruzioni).

Scrivi questa riga nel layout principale ...

 android:focusableInTouchMode="true"

Sì, ho fatto la stessa cosa: ho creato un layout lineare "fittizio" che ha il focus iniziale. Inoltre, ho impostato gli ID di messa a fuoco "successivi" in modo che l'utente non possa più metterlo a fuoco dopo averlo fatto scorrere una volta:

<LinearLayout 'dummy'>
<EditText et>

dummy.setNextFocusDownId(et.getId());

dummy.setNextFocusUpId(et.getId());

et.setNextFocusUpId(et.getId());

molto lavoro solo per sbarazzarsi della messa a fuoco su una vista ..

Grazie

Per me, ciò che ha funzionato su tutti i dispositivi è questo:

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

Basta mettere questo come una vista prima della vista focalizzata problematica, e il gioco è fatto.

La cosa più semplice che ho fatto è concentrarmi su un'altra vista in onCreate:

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

Ciò ha impedito la comparsa della tastiera software e non era presente alcun cursore nell'EditText.

Questa è la soluzione perfetta e più semplice. La utilizzo sempre nella mia app.

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

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

Scrivi questo codice all'interno del Manifestfile nel punto in Activitycui non desideri aprire la tastiera.

android:windowSoftInputMode="stateHidden"

File manifest:

 <?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>

Alla onCreatetua attività, aggiungi solo l'uso clearFocus()sul tuo elemento EditText. Per esempio,

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

E se vuoi spostare l'attenzione su un altro elemento, usalo requestFocus(). Per esempio,

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

Uso il seguente codice per impedire a un EditText di rubare lo stato attivo quando viene premuto il mio pulsante.

addButton.setOnClickListener(new OnClickListener() {
    public void onClick(View v) {
        View focused = internalWrapper.getFocusedChild();
        focused.setVisibility(GONE);
        v.requestFocus();
        addPanel();
        focused.setVisibility(VISIBLE);
    }
});

Fondamentalmente, nascondi il testo di modifica e poi mostralo di nuovo. Questo funziona per me come EditText non lo è in vista, quindi non importa se sta mostrando.

Potresti provare a nasconderlo e mostrarlo in successione per vedere se questo aiuta a perdere la concentrazione.