Como parar o EditText de ganhar foco na inicialização da atividade no Android

Eu tenho um Activityno Android, com dois elementos:

1. EditText
2. ListView

Quando Activityinicio, o EditTextfoco de entrada é imediatamente (cursor piscando). Não quero que nenhum controle tenha foco de entrada na inicialização. Eu tentei:

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

Sem sorte Como convencer a EditTextnão selecionar a si mesma quando Activityiniciar?

Excelentes respostas de Luc e Mark, no entanto, está faltando um bom exemplo de código. Adicionar a tag android:focusableInTouchMode="true"e o android:focusable="true"layout pai (por exemplo, LinearLayoutou ConstraintLayout), como no exemplo a seguir, corrigirá o 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"/>

O problema real é que você simplesmente não quer que ele tenha foco? Ou você não deseja que ele mostre o teclado virtual como resultado do foco no EditText? Realmente não vejo um problema com o EditTextfoco no início, mas é definitivamente um problema abrir a janela softInput quando o usuário não solicitou explicitamente o foco EditText(e, como resultado, abriu o teclado).

Se for o problema do teclado virtual, consulte a documentação do AndroidManifest.xml elemento <atividade> .

android:windowSoftInputMode="stateHidden" - sempre oculte ao entrar na atividade.

ou android:windowSoftInputMode="stateUnchanged"- não mude (por exemplo, não o mostre se ainda não estiver sendo exibido, mas se estava aberto ao entrar na atividade, deixe-o aberto).

Existe uma solução mais simples. Defina estes atributos no seu layout pai:

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

E agora, quando a atividade iniciar, esse layout principal terá foco por padrão.

Além disso, podemos remover o foco das visualizações filho em tempo de execução (por exemplo, depois de terminar a edição filho), dando o foco ao layout principal novamente, desta forma:

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

Bom comentário de Guillaume Perrot :

android:descendantFocusability="beforeDescendants"parece ser o padrão (o valor inteiro é 0). Funciona apenas adicionando android:focusableInTouchMode="true".

Realmente, podemos ver que o beforeDescendantsconjunto é o padrão no ViewGroup.initViewGroup()método (Android 2.2.2). Mas não é igual a 0.ViewGroup.FOCUS_BEFORE_DESCENDANTS = 0x20000;

Graças a Guillaume.

A única solução que encontrei é:

• Crie um LinearLayout (não sei se outros tipos de layout funcionarão)
• Defina os atributos android:focusable="true"eandroid:focusableInTouchMode="true"

E EditTexteles não terão o foco depois de iniciar a atividade

O problema parece vir de uma propriedade que eu só posso ver no XML formlayout.

Certifique-se de remover esta linha no final da declaração dentro das EditTexttags XML:

<requestFocus />

Isso deve dar algo assim:

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

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

usando as informações fornecidas por outros pôsteres, usei a seguinte solução:

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

em 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, finalmente, em onResume ()

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

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

Tente clearFocus () em vez de setSelected(false). Todas as visualizações no Android têm foco e seleção, e acho que você deseja apenas clarear o foco.

O seguinte impedirá o edittext de focar quando criado, mas agarre-o quando você os tocar.

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

Portanto, você define focusable como false no xml, mas a chave está no java, à qual você adiciona o seguinte ouvinte:

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

Como você está retornando falso, ou seja, não está consumindo o evento, o comportamento de foco continuará como normal.

Eu tentei várias respostas individualmente, mas o foco ainda está no EditText. Só consegui resolvê-lo usando duas das soluções abaixo juntas.

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

(Referência da Silver https://stackoverflow.com/a/8639921/15695 )

e remova

 <requestFocus />

em EditText

(Referência de floydaddict https://stackoverflow.com/a/9681809 )

Resposta tardia, porém mais simples, basta adicionar isso no layout pai do XML.

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

Voto a favor se isso ajudou! Happy Coding :)

Nenhuma dessas soluções funcionou para mim. A maneira como corrigi o foco automático era:

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

Solução simples: uso de tags AndroidManifestinActivity

android:windowSoftInputMode="stateAlwaysHidden"

Você pode apenas definir "focalizável" e "focalizável no modo de toque" para o valor verdadeiro no primeiro TextViewdo layout. Desta forma, quando a atividade começa a TextViewserá focada mas, devido à sua natureza, você vai ver nada focada na tela e, é claro, haverá nenhum teclado exibido ...

O seguinte funcionou para mim Manifest. Escreva ,

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

Eu precisava limpar o foco de todos os campos programaticamente. Acabei de adicionar as duas instruções a seguir à minha definição de layout principal.

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

É isso aí. Corrigido meu problema instantaneamente. Obrigado, Silver, por me apontar na direção certa.

Adicione android:windowSoftInputMode="stateAlwaysHidden"a tag de atividade do Manifest.xmlarquivo.

Fonte

Se você tiver outra visão da sua atividade como a ListView, também poderá:

ListView.requestFocus(); 

no seu onResume()para agarrar o foco do editText.

Eu sei que esta pergunta foi respondida, mas apenas fornecendo uma solução alternativa que funcionou para mim :)

Tente isso antes do seu primeiro campo editável:

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

Adicione o seguinte no onCreatemétodo:

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

Como não gosto de poluir o XML com algo relacionado à funcionalidade, criei esse método que "transparentemente" rouba o foco da primeira exibição focalizável e depois se remove quando necessário!

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

Tarde, mas talvez útil. Criar um EditText manequim no topo do seu layout em seguida, chamar myDummyEditText.requestFocus()nosonCreate()

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

Isso parece se comportar como eu esperava. Não há necessidade de lidar com alterações na configuração, etc. Eu precisava disso para uma Atividade com um TextView longo (instruções).

Escreva esta linha no seu Layout pai ...

 android:focusableInTouchMode="true"

Sim, eu fiz a mesma coisa - crie um layout linear 'fictício' que obtenha o foco inicial. Além disso, defino os 'próximos' IDs de foco para que o usuário não possa mais focá-lo depois de rolar uma vez:

<LinearLayout 'dummy'>
<EditText et>

dummy.setNextFocusDownId(et.getId());

dummy.setNextFocusUpId(et.getId());

et.setNextFocusUpId(et.getId());

muito trabalho apenas para se livrar do foco em uma exibição ..

obrigado

Para mim, o que funcionou em todos os dispositivos é o seguinte:

    <!-- 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 colocar isso como uma visão antes da visão focada problemática, e é isso.

A coisa mais simples que fiz foi focar em outra visualização no onCreate:

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

Isso interrompeu o teclado virtual e não havia cursor piscando no EditText.

Esta é a solução perfeita e mais fácil. Sempre uso isso no meu aplicativo.

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

Escreva esse código dentro do Manifestarquivo em Activityque você não deseja abrir o teclado.

android:windowSoftInputMode="stateHidden"

Arquivo de manifesto:

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

Na onCreatesua Atividade, basta adicionar uso clearFocus()ao seu elemento EditText. Por exemplo,

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

E se você quiser desviar o foco para outro elemento, use requestFocus()isso. Por exemplo,

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

Eu uso o código a seguir para impedir que um EditText roube o foco quando meu botão é pressionado.

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

Basicamente, oculte o texto de edição e mostre-o novamente. Isso funciona para mim, pois o EditText não é em exibição, portanto, não importa se está sendo exibido.

Você pode tentar ocultar e mostrá-lo em sucessão para ver se isso ajuda a perder o foco.