Stoppen Sie, dass EditText beim Aktivitätsstart den Fokus erhält

Ist das eigentliche Problem, dass Sie nicht wollen, dass es überhaupt einen Fokus hat? Oder Sie möchten nicht, dass die virtuelle Tastatur als Ergebnis der Fokussierung der EditText angezeigt wird? Ich sehe eigentlich kein Problem mit der EditText, die den Fokus beim Start hat, aber es ist definitiv ein Problem, wenn das softInput-Fenster geöffnet ist, wenn der Benutzer nicht explizit aufgefordert hat, sich auf die EditText zu konzentrieren (und als Ergebnis die Tastatur zu öffnen).

Wenn es sich um das Problem der virtuellen Tastatur handelt, lesen Sie die Dokumentation AndroidManifest.xml<activity> -Element .

Android:windowSoftInputMode="stateHidden" - verstecken Sie es immer, wenn Sie die Aktivität eingeben.

oder Android:windowSoftInputMode="stateUnchanged" - nicht ändern (z. B. nicht show, wenn es nicht bereits angezeigt wird, aber wenn es bei der Eingabe der Aktivität geöffnet war, lassen Sie es geöffnet).

Es gibt eine einfachere Lösung. Legen Sie diese Attribute in Ihrem übergeordneten Layout fest:

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

Wenn jetzt die Aktivität beginnt, wird dieses Hauptlayout standardmäßig fokussiert.

Außerdem können wir den Fokus zur Laufzeit von untergeordneten Ansichten entfernen (z. B. nach Abschluss der untergeordneten Bearbeitung), indem Sie den Fokus wieder auf das Hauptlayout setzen, beispielsweise:

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

Guter Kommentar von Guillaume Perrot :

Android:descendantFocusability="beforeDescendants" scheint der .__ zu sein. Standard (ganzzahliger Wert ist 0). Es funktioniert einfach durch das Hinzufügen von Android:focusableInTouchMode="true".

Wir können wirklich sehen, dass die Variable beforeDescendants in der Methode ViewGroup.initViewGroup() (Android 2.2.2) als Standard festgelegt ist. Aber nicht gleich 0. ViewGroup.FOCUS_BEFORE_DESCENDANTS = 0x20000;

Danke an Guillaume.

Die einzige Lösung, die ich gefunden habe, ist:

• Erstellen Sie ein LinearLayout (Ich weiß nicht, ob andere Layouts funktionieren)
• Setze die Attribute Android:focusable="true" und Android:focusableInTouchMode="true"

Und die EditText erhält nach dem Start der Aktivität nicht den Fokus

Das Problem scheint von einer Eigenschaft zu stammen, die ich nur im XML form des Layouts sehen kann.

Stellen Sie sicher, dass Sie diese Zeile am Ende der Deklaration innerhalb der EditText XML-Tags entfernen:

<requestFocus />

Das sollte so etwas geben:

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

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

ich benutzte die Informationen, die von anderen Postern bereitgestellt wurden, und verwendete folgende Lösung:

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

und schließlich in onResume ()

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

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

Versuchen Sie clearFocus () anstelle von setSelected(false). Jede Ansicht in Android ist sowohl fokussierbar als auch auswählbar.

Im Folgenden wird verhindert, dass Edittext den Fokus erhält, wenn er erstellt wird.

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

Sie setzen also fokussierbar in der XML auf false, aber der Schlüssel befindet sich in Java, wodurch Sie den folgenden Listener hinzufügen:

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

Da Sie den Wert false zurückgeben, d. H. Das Ereignis nicht konsumieren, wird das Fokussierungsverhalten normal fortgesetzt.

Ich hatte mehrere Antworten einzeln ausprobiert, aber der Fokus liegt immer noch auf EditText. Ich habe es nur geschafft, es zu lösen, indem ich zwei der folgenden Lösungen zusammen verwendete.

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

(Referenz von Silver https://stackoverflow.com/a/8639921/15695 )

und entfernen

 <requestFocus />

bei EditText 

(Referenz von floydaddict https://stackoverflow.com/a/9681809 )

Keine dieser Lösungen hat für mich funktioniert. So fixiere ich den Autofokus:

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

Einfache Lösung: In AndroidManifest im Activity-Tag verwenden

Android:windowSoftInputMode="stateAlwaysHidden"

Sie können "fokussierbar" und "fokussierbar im Touch-Modus" einfach auf den Wert "true" für die erste TextView der layout setzen. Auf diese Weise wird beim Start der Aktivität die TextView fokussiert, aber aufgrund ihrer Art werden Sie nichts auf den Bildschirm fokussiert sehen und natürlich wird no keyboard angezeigt ...

Folgendes hat für mich in Manifest gearbeitet. Schreiben ,

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

Die einfachste Antwort, fügen Sie dies einfach im übergeordneten Layout des XML ein.

Android:focusable="true" 
Android:focusableInTouchMode="true"

Ich musste den Fokus programmgesteuert aus allen Bereichen löschen. Ich habe gerade die folgenden zwei Anweisungen zu meiner Hauptlayoutdefinition hinzugefügt.

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

Das ist es. Mein Problem wurde sofort behoben. Danke, Silver, dass du mich in die richtige Richtung zeigst.

Fügen Sie Android:windowSoftInputMode="stateAlwaysHidden" im Activity Tag der Manifest.xml-Datei hinzu.

Quelle

Wenn Sie eine andere Sicht auf Ihre Aktivität haben, z. B. eine ListView, können Sie auch Folgendes tun:

ListView.requestFocus(); 

in Ihrer onResume(), um den Fokus von der editText zu erhalten.

Ich weiß, dass diese Frage beantwortet wurde, aber nur eine alternative Lösung bereitstellt, die für mich funktioniert hat :)

Probieren Sie dies vor Ihrem ersten bearbeitbaren Feld aus:

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

Fügen Sie Folgendes in der onCreate-Methode hinzu:

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

Da ich das XML nicht gerne mit etwas verschmutzen möchte, das mit Funktionalität zusammenhängt, habe ich diese Methode entwickelt, die den Fokus "transparent" aus der ersten fokussierbaren Ansicht stiehlt und sich dann bei Bedarf selbst entfernt!

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

Spät, aber vielleicht hilfreich. Erstellen Sie einen Dummy-EditText oben in Ihrem Layout und rufen Sie myDummyEditText.requestFocus() in onCreate() auf.

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

Das scheint sich wie erwartet zu verhalten. Keine Notwendigkeit, Konfigurationsänderungen zu handhaben, usw. Ich brauchte dies für eine Aktivität mit einer langen TextView (Anleitung).

Schreiben Sie diese Zeile in Ihr übergeordnetes Layout ...

 Android:focusableInTouchMode="true"

Ja, ich habe dasselbe getan - ein lineares Layout 'Dummy' erstellen, das den anfänglichen Fokus erhält. Desweiteren stelle ich die 'nächsten' Fokus-IDs ein, damit der Benutzer sie nach einem Bildlauf nicht mehr scharf stellen kann:

<LinearLayout 'dummy'>
<EditText et>

dummy.setNextFocusDownId(et.getId());

dummy.setNextFocusUpId(et.getId());

et.setNextFocusUpId(et.getId());

eine Menge Arbeit, nur um den Blick auf einen Blick loszuwerden .. 

Vielen Dank

Für mich funktionierte auf allen Geräten Folgendes:

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

Setzen Sie dies einfach als Ansicht vor die problematische fokussierte Ansicht, und das ist es.

Dies ist die perfekte und einfachste Lösung. Ich verwende dies immer in meiner App. 

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

Das einfachste, was ich getan habe, ist, mich auf eine andere Ansicht in onCreate zu konzentrieren:

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

Dadurch wurde die Soft-Tastatur angehalten und im EditText blitzte kein Cursor.

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

Schreiben Sie diesen Code in Manifest-Datei in Activity, wo Sie die Tastatur nicht öffnen möchten.

Android:windowSoftInputMode="stateHidden"

Manifest-Datei:

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

Fügen Sie bei onCreate Ihrer Aktivität einfach use clearFocus() zu Ihrem EditText-Element ..__ hinzu. Zum Beispiel

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

Wenn Sie den Fokus auf ein anderes Element umleiten möchten, verwenden Sie requestFocus() für das . Beispiel:

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

Die einfachste Möglichkeit, die Tastatur auszublenden, ist setSoftInputMode 

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

oder Sie können InputMethodManager verwenden und die Tastatur auf diese Weise ausblenden.

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

Wenn Ihre Aktivität geöffnet wird, wird die Tastatur automatisch sichtbar, was zu einer Fokussierung von EditText führt. Sie können die Tastatur deaktivieren, indem Sie die folgende Zeile in Ihr Aktivitäts-Tag in die Datei manifest.xml schreiben.

 Android:windowSoftInputMode="stateAlwaysHidden|adjustPan"

Sie können dies erreichen, indem Sie ein Dummy EditText erstellen, dessen Layoutbreite und -höhe auf 0dp festgelegt ist, und den Fokus auf diese Ansicht anfordern.

<EditText
    Android:id="@+id/editText0"
    Android:layout_width="0dp"
    Android:layout_height="0dp"
    Android:hint="@string/dummy"
    Android:ems="10" 
    >
     <requestFocus />
    </EditText>

Entfernen Sie unbedingt die Zeile "<requestFocus />" aus dem Tag EditText in xml.

<EditText
   Android:id="@+id/input"
   Android:layout_width="fill_parent"
   Android:layout_height="wrap_content">

   <requestFocus /> <!-- remove this line --> 
</EditText>

Ich verwende den folgenden Code, um zu verhindern, dass ein EditText den Fokus stiehlt, wenn meine Schaltfläche gedrückt wird.

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

Verbergen Sie den Bearbeitungstext grundsätzlich und zeigen Sie ihn dann erneut an. Dies funktioniert für mich, da der EditText nicht in der Ansicht ist.

Sie könnten versuchen, es zu verbergen und nacheinander zu zeigen, um zu sehen, ob es dabei hilft, den Fokus zu verlieren.

/** 
 * set focus to top level window
 * disposes descendant focus 
 * disposes softInput 
 * */
public static void topLevelFocus(Context context){
    if(Activity.class.isAssignableFrom(context.getClass())){
        ViewGroup tlView = (ViewGroup) ((Activity) context).getWindow().getDecorView();
        if(tlView!=null){
            tlView.setFocusable(true);
            tlView.setFocusableInTouchMode(true);
            tlView.setDescendantFocusability(ViewGroup.FOCUS_BEFORE_DESCENDANTS);
        }
    }
}

View current = getCurrentFocus();

if (current != null) 
    current.clearFocus();

Am einfachsten ist es, Android:windowSoftInputMode="stateAlwaysHidden" im Activity-Tag der Datei Manifest.xml hinzuzufügen

EditText innerhalb einer ListView funktioniert nicht richtig. Es ist besser, TableLayout mit automatisch generierten Zeilen zu verwenden, wenn Sie EditText verwenden.

versuchen

edit.setInputType(InputType.TYPE_NULL);

edit.setEnabled(false);

Ich hatte ein Problem wie dieses und es lag an meinem Wähler. Der erste Zustand war Fokus, selbst wenn meine Ansicht deaktiviert war, nahm der Fokuszustand an, da er der erste war, der übereinstimmte und ihn verwendete. Sie können den ersten Status folgendermaßen deaktivieren:

<selector xmlns:Android="http://schemas.Android.com/apk/res/Android">


<item Android:drawable="@drawable/text_field_disabled" Android:state_enabled="false"/>
<item Android:drawable="@drawable/text_field_focused" Android:state_focused="true"/>
<item Android:drawable="@drawable/text_field_normal"/>

<EditText
    Android:layout_width="match_parent"
    Android:layout_height="100dp"
    Android:id="@+id/etComments"
    Android:hint="Comments.."
    Android:textSize="14dp"

    Android:focusable="false"

    Android:textStyle="italic"/>

Deaktiviere es in onCreate ()

final KeyListener edtTxtMessageKeyListener = edtTxtMessage.getKeyListener();
edtTxtMessage.setCursorVisible(false);
edtTxtMessage.setKeyListener(null);

Und schließlich aktivieren Sie es in onClick () von EditText

edtTxtMessage.setCursorVisible(true);
edtTxtMessage.setKeyListener(edtTxtMessageKeyListener);

Aber das Problem ist, dass wir zweimal klicken müssen, um OnScreenKeyboard zum ersten Mal zu veröffentlichen.

@Workaround

InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

Versuche dies auch in onClick () :)

Sie können den Fokus auf ein anderes Widget festlegen, indem Sie den Anforderungsfokus verwenden und auch den Code zum Ausblenden der Tastatur verwenden.

entfernen Sie<requestFocus /> aus Ihrem Text in XML-Datei

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

   //`<requestFocus />` /* <-- remove this tags */
</EditText>`

Tun Sie dies und erledigen Sie Ihre Arbeit!

Android:focusable="true"
Android:focusableInTouchMode="true" 

Sie haben Text und Liste bearbeiten. In OnStart/On Create sollten Sie den Fokus auf die Listenansicht setzen: Listview.requestfocus()

Wenn Sie die Tastatur zu Beginn der Aktivität ausblenden möchten. Dann erwähne

Android: windowSoftInputMode = "stateHidden"

Zu dieser Aktivität in der Manifestdatei. Problem wird gelöst.

Prost.

Ich lösche den Fokus mit Submit-Button

// xml file
<LinearLayout
...
Android:id="@+id/linear_layout"
Android:focusableInTouchMode="true"> // 1. make this focusableInTouchMode...
</LinearLayout>

// Activity file
private LinearLayout mLinearLayout; // 2. parent layout element
private Button mButton;

mLinearLayout = findViewById(R.id.linear_layout);
mButton = findViewById(R.id.button);

  mButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mLinearLayout.requestFocus(); // 3. request focus

            }
        });

Ich hoffe das hilft dir :)

fügen Sie in der Manifest-Datei die Zeile hinzu, in der Sie Ihre Aktivität erwähnt haben

Android:windowSoftInputMode="stateAlwaysHidden"

Dies kann erreicht werden, indem EditText geerbt und onTouchEvent überschrieben wird.

class NonFocusableEditText: EditText {

    constructor(context: Context): super(context)
    constructor(context: Context, attrs: AttributeSet?): super(context, attrs)
    constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int): super(context, attrs, defStyleAttr)

    override fun onTouchEvent(event: MotionEvent?): Boolean {
        return if (isFocusable) super.onTouchEvent(event) else false
    }
}

Dann können Sie es in den Layouts wie üblich EditText verwenden:

<com.yourpackage.NonFocusableEditText
        Android:id="@+id/editText"
        Android:layout_width="match_parent"
        Android:layout_height="wrap_content"    
        Android:hint="@string/your_hint"
        Android:imeOptions="actionDone"
        Android:inputType="textNoSuggestions" />