android remove - Interrompe EditText dalla messa a fuoco all'avvio dell'attività




focus force (25)

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

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

E ora, quando l'attività inizia, questo layout principale otterrà il focus di default.

Inoltre, è possibile rimuovere l'attenzione dalle viste secondarie in fase di esecuzione (ad esempio, dopo aver terminato la modifica dei figli) dando di nuovo il focus 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 i beforeDescendants impostati come predefiniti nel metodo ViewGroup.initViewGroup() (Android 2.2.2). Ma non uguale a 0. ViewGroup.FOCUS_BEFORE_DESCENDANTS = 0x20000;

Grazie a Guillaume.

Ho un'attività in Android, con due elementi:

  1. EditText
  2. ListView

All'avvio della mia Activity , EditText ha immediatamente il focus di input (cursore lampeggiante). Non voglio che nessun controllo abbia il focus di input all'avvio. Provai:

EditText.setSelected(false);

Senza fortuna. Come posso convincere EditText a non selezionare se stesso all'avvio Activity ?


L'unica soluzione che ho trovato è:

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

E EditText non si focalizzerà dopo l'avvio dell'attività


Aggiungi seguendo nel metodo onCreate :

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

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

Se si tratta del problema della tastiera virtuale, consultare la documentazione dell'elemento <activity> di AndroidManifest.xml .

android:windowSoftInputMode="stateHidden" - nasconde sempre quando si accede all'attività.

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


Essendo che non mi piace inquinare l'XML con qualcosa che riguarda la funzionalità, ho creato questo metodo che "in modo trasparente" ruba l'attenzione dalla prima vista focalizzabile e quindi si assicura di rimuovere se stessa 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;
}

utilizzando le informazioni fornite da altri poster, ho utilizzato 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();
}

Questa è la soluzione perfetta e più semplice. Lo uso sempre nella mia app.

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

Aggiungi android:windowSoftInputMode="stateAlwaysHidden" nel tag di attività del file Manifest.xml .

Source


Se hai un'altra vista sulla tua attività come un ListView , puoi anche fare:

ListView.requestFocus(); 

nel tuo onResume() per catturare l'attenzione da editText .

So che questa domanda ha avuto risposta, ma ho appena fornito una soluzione alternativa che ha funzionato per me :)


In ritardo, ma forse utile. Crea un fittizio EditText nella parte superiore del tuo layout quindi chiama myDummyEditText.requestFocus() in onCreate()

<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. Avevo bisogno di questo per un'attività con una lunga TextView (istruzioni).


Il seguente ha funzionato per me in Manifest . Scrivi ,

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

Soluzione semplice: in AndroidManifest nell'utilizzo del tag Activity

android:windowSoftInputMode="stateAlwaysHidden"

Prova clearFocus() invece di setSelected(false) . Ogni vista in Android ha sia focusability e selettività, e penso che tu voglia semplicemente cancellare l'attenzione.


Avevo provato diverse risposte individualmente ma il focus è ancora su EditText. Sono riuscito a risolverlo solo utilizzando due delle soluzioni sottostanti.

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

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

e rimuovere

 <requestFocus />

su EditText

(Riferimento da floydaddict share )


Quanto segue impedirà a edittext di mettere a fuoco quando viene creato, ma afferralo quando lo tocchi.

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

Quindi puoi impostare focusable su false in xml, ma la chiave è in java, a cui 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, cioè non consumando l'evento, il comportamento di messa a fuoco procederà normalmente.


Su onCreate della tua attività, aggiungi semplicemente clearFocus() sull'elemento EditText. Per esempio,

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

E se vuoi deviare lo stato attivo su un altro elemento, usa requestFocus() su quello. Per esempio,

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

La risposta più semplice, è sufficiente aggiungerla nel layout principale dell'XML.

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

Sì, ho fatto la stessa cosa: creare un layout lineare "fittizio" che ottenga l'attenzione iniziale. Inoltre, ho impostato gli ID del focus "successivo" in modo che l'utente non possa più focalizzarlo dopo averlo fatto scorrere una volta:

<LinearLayout 'dummy'>
<EditText et>

dummy.setNextFocusDownId(et.getId());

dummy.setNextFocusUpId(et.getId());

et.setNextFocusUpId(et.getId());

un sacco di lavoro solo per sbarazzarsi di messa a fuoco su una vista ..

Grazie


Scrivi questo codice all'interno del file Manifest nell'attività in cui 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>

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 vista prima della vista focalizzata problematica, e il gioco è fatto.


La cosa più semplice che ho fatto è focalizzare l'attenzione su un'altra vista su onCreate:

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

Questo ha fermato la tastiera morbida in arrivo e non c'era nessun cursore lampeggiante in EditText.


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

Puoi semplicemente impostare "focusable" e "focusable in touch mode" per il valore true sulla prima TextView del layout . In questo modo, quando l'attività inizia, TextView sarà focalizzato ma, per la sua natura, non vedrai nulla focalizzato sullo schermo e, ovviamente, non verrà visualizzata alcuna tastiera ...


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

Questo farà il tuo lavoro:

android:windowSoftInputMode="stateHidden"







android listview android-edittext