Android: mostra automaticamente la tastiera virtuale quando lo stato attivo è su un EditText


341

Sto mostrando una casella di input utilizzando AlertDialog. L' EditTextinterno della finestra stessa viene automaticamente messo a fuoco quando chiamo AlertDialog.show(), ma la tastiera non viene mostrata automaticamente.

Come faccio a mostrare automaticamente la tastiera virtuale quando viene visualizzata la finestra di dialogo? (e non esiste una tastiera fisica / hardware). Simile a come quando premo il pulsante Cerca per invocare la ricerca globale, viene automaticamente visualizzata la tastiera virtuale.


1
Questo dovrebbe avvenire automaticamente, come da commento di Ted di seguito. Controlla prima quello!
Cheezmeister,

Questa risposta è molto semplice e funziona bene: stackoverflow.com/a/8018630/89818
caw


1
Sono tornato a questa risposta più volte nel corso degli anni. È sempre all'interno di una finestra di dialogo che ho questo problema, mai frammento o attività.
tir38,

Possibile duplicato di Chiudi / nascondi la tastiera
virtuale

Risposte:


305

È possibile creare un listener di focus su EditTexton AlertDialog, quindi ottenere quello AlertDialogdi Window. Da lì puoi mostrare la tastiera virtuale chiamando setSoftInputMode.

final AlertDialog dialog = ...;

editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        }
    }
});

5
Come lo farei usando AlertDialog.Builder? ... avviso AlertDialog.Builder finale = nuovo AlertDialog.Builder (Main.this);
Stephen

6
@Stephen è possibile ottenere la finestra di dialogo dal builder utilizzando final AlertDialog dialog = builder.create()e quindi shownella finestra di dialogo anziché dal builder.
martedì

30
RITROVO IL MIO COMMENTO SOPRA Ho scoperto che se non riesci a focalizzare correttamente, dai un'occhiata al tuo XML! Se vedi il tag <requestFocus> </requestFocus> , rimuovilo. Sembra che il tag attiverà l'EditText e quindi il tuo listener non verrà attivato poiché l'EditText ha già lo stato attivo.
Ted

11
Come non farlo se il dispositivo ha una tastiera hardware? Sembra che questo sia fastidioso per quegli utenti.
MXC

8
Davvero non capisco perché questo non sia il comportamento predefinito nell'SDK. Se una vista che richiede l'immissione di testo mostra un cursore lampeggiante, perché qualcuno non vorrebbe vedere la tastiera per inserire il testo? Mi sembra così sbagliato un UX
Christian García,

240

Per mostrare l'uso della tastiera:

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

Per nascondere l'uso della tastiera:

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

3
Funziona particolarmente bene quando si desidera mostrare / nascondere la tastiera software in base alla commutazione della visibilità di una vista nel layout tra VISIBILE e GONE.
PacificSky

38
Suggerirei invece di utilizzare il flag SHOW_IMPLICIT, poiché significa che la modifica dell'attività o dell'applicazione nasconderà automaticamente la tastiera come previsto.
drspaceboo,

6
@drspaceboo L'uso di SHOW_IMPLICIT non funziona affatto per me, devo usare SHOW_FORCED, non sono sicuro del perché ...
Yoann Hercouet,

1
Quando deve essere eseguito il codice sopra? Ho provato a farlo poco dopo aver aggiunto il mio layout al suo genitore. Non ha funzionato. Ma se l'ho fatto dopo che il layout era in circolazione da un po ', funzionava. Quindi c'è un callback che mi dirà "Se provi a mostrare la tastiera adesso, funzionerà davvero"?
William Jockusch,

1
toggleSoftInput (InputMethodManager.SHOW_FORCED, 0) attiva o disattiva la tastiera virtuale. Se vuoi assicurarti che appaia la tastiera, puoi usare imm.showSoftInput (view, InputMethodManager.SHOW_IMPLICIT) invece, dove view è la View che otterrà l'input.
PJ_Finnegan,

111

È possibile richiedere una tastiera software subito dopo aver creato la finestra di dialogo (test su SDK - r20)

// create dialog
final AlertDialog dialog = ...; 

// request keyboard   
dialog.getWindow().setSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

Per chiunque si chieda, questo metodo non apre la tastiera virtuale quando è collegata una tastiera hardware. Ho appena provato con un cavo USB On-The-Go. Perfetto!
13rac1,

Questo non fa nulla per me.
JohnyTex,

Non ho una tastiera hardware. Forse configurazione (?)
JohnyTex

25

Ho avuto lo stesso problema e l'ho risolto con il seguente codice. Non sono sicuro di come si comporterà su un telefono con tastiera hardware.

// TextEdit
final EditText textEdit = new EditText(this);

// Builder
AlertDialog.Builder alert = new AlertDialog.Builder(this);
alert.setTitle("Enter text");
alert.setView(textEdit);

alert.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        String text = textEdit.getText().toString();
        finish();
    }
});

alert.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        finish();
    }
});

// Dialog
AlertDialog dialog = alert.create();
dialog.setOnShowListener(new OnShowListener() {

    @Override
    public void onShow(DialogInterface dialog) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(textEdit, InputMethodManager.SHOW_IMPLICIT);
    }
});

dialog.show();

È nel livello API della classe Dialog 8.
tidbeck,

deve essere stato rimosso in seguito: /
Jacek Kwiecień il

@Xylian è ancora nella documentazione Dialog.setOnShowListener ()
tidbeck


18
<activity
    ...
    android:windowSoftInputMode="stateVisible" >
</activity>

o

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

Grazie mille, è stato fantastico, in realtà li ho usati entrambi per risolvere il mio problema, ho avuto una situazione in cui se l'utente è in modalità Aggiungi, quindi è necessario mostrare la tastiera all'avvio dell'attività e per la modalità di aggiornamento non è richiesta la tastiera per impostazione predefinita. Quindi in manifest per attività ho impostato stateHiddene quando rilevo che l'utente sta creando un nuovo elemento, ho visualizzato la tastiera utilizzando la riga di codice che hai menzionato. :) Ancora grazie.
PHP Avenger,

Viene visualizzato il messaggio "Impossibile risolvere getWindow ()". ho provato a mettere "questo". e altre cose prima. voglio ottenere la tastiera senza usare un edittext, semplicemente facendo clic in una certa parte dello schermo.
Androidcoder,

1
@Androidcoder, fa parte dell'attività, quindi aggiungi qualcosa di simile ((Activity) context).getWindow().....
CoolMind

15

Gli snippet di codice provenienti da altre risposte funzionano, ma non è sempre ovvio dove inserirli nel codice, soprattutto se si sta utilizzando un tutorial di dialogo ufficialeAlertDialog.Builder seguito e perché non utilizza o .final AlertDialog ...alertDialog.show()

alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

È preferibile

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

Poiché SOFT_INPUT_STATE_ALWAYS_VISIBLE nasconderà la tastiera se lo stato attivo si sposta dall'EditText, dove SHOW_FORCED manterrà la tastiera visualizzata fino a quando non viene esplicitamente ignorata, anche se l'utente torna alla schermata iniziale o visualizza le app recenti.

Di seguito è riportato un codice funzionante per un AlertDialog creato utilizzando un layout personalizzato con un EditText definito in XML. Imposta inoltre la tastiera per avere un tasto "go" e consente di attivare il pulsante positivo.

alert_dialog.xml:

<RelativeLayout
android:id="@+id/dialogRelativeLayout"
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content" >

    <!-- android:imeOptions="actionGo" sets the keyboard to have a "go" key instead of a "new line" key. -->
    <!-- android:inputType="textUri" disables spell check in the EditText and changes the "go" key from a check mark to an arrow. -->
    <EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="4dp"
        android:layout_marginRight="4dp"
        android:layout_marginBottom="16dp"
        android:imeOptions="actionGo"
        android:inputType="textUri"/>

</RelativeLayout>

AlertDialog.java:

import android.app.Activity;
import android.app.Dialog;
import android.content.DialogInterface;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v4.app.DialogFragment;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatDialogFragment;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.WindowManager;
import android.widget.EditText;

public class CreateDialog extends AppCompatDialogFragment {
    // The public interface is used to send information back to the activity that called CreateDialog.
    public interface CreateDialogListener {
        void onCreateDialogCancel(DialogFragment dialog);    
        void onCreateDialogOK(DialogFragment dialog);
    }

    CreateDialogListener mListener;

    // Check to make sure that the activity that called CreateDialog implements both listeners.
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        try {
            mListener = (CreateDialogListener) activity;
        } catch (ClassCastException e) {
            throw new ClassCastException(activity.toString() + " must implement CreateDialogListener.");
        }
    }

    // onCreateDialog requires @NonNull.
    @Override
    @NonNull
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(getActivity());
        LayoutInflater customDialogInflater = getActivity().getLayoutInflater();

        // Setup dialogBuilder.
        alertDialogBuilder.setTitle(R.string.title);
        alertDialogBuilder.setView(customDialogInflater.inflate(R.layout.alert_dialog, null));
        alertDialogBuilder.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                mListener.onCreateDialogCancel(CreateDialog.this);
            }
        });
        alertDialogBuilder.setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                mListener.onCreateDialogOK(CreateDialog.this);
            }
        });

        // Assign the resulting built dialog to an AlertDialog.
        final AlertDialog alertDialog = alertDialogBuilder.create();

        // Show the keyboard when the dialog is displayed on the screen.
        alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

        // We need to show alertDialog before we can setOnKeyListener below.
        alertDialog.show();

        EditText editText = (EditText) alertDialog.findViewById(R.id.editText);

        // Allow the "enter" key on the keyboard to execute "OK".
        editText.setOnKeyListener(new View.OnKeyListener() {
            public boolean onKey(View v, int keyCode, KeyEvent event) {
                // If the event is a key-down event on the "enter" button, select the PositiveButton "OK".
                if ((event.getAction() == KeyEvent.ACTION_DOWN) && (keyCode == KeyEvent.KEYCODE_ENTER)) {
                    // Trigger the create listener.
                    mListener.onCreateDialogOK(CreateDialog.this);

                    // Manually dismiss alertDialog.
                    alertDialog.dismiss();

                    // Consume the event.
                    return true;
                } else {
                    // If any other key was pressed, do not consume the event.
                    return false;
                }
            }
        });

        // onCreateDialog requires the return of an AlertDialog.
        return alertDialog;
    }
}

11

Bene, questo è un post piuttosto vecchio, c'è ancora qualcosa da aggiungere.
Questi sono 2 metodi semplici che mi aiutano a tenere la tastiera sotto controllo e funzionano perfettamente:

Mostra tastiera

public void showKeyboard() {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View v = getCurrentFocus();
    if (v != null)
        imm.showSoftInput(v, 0);
}

Nascondi tastiera

public void hideKeyboard() {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View v = getCurrentFocus();
    if (v != null)
        imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
}

Che cosa è getCurrentFocus()?
CoolMind

Vedo, questo è un metodo di un Activity.
CoolMind,

10

Permettetemi di indicare alcune informazioni aggiuntive alla soluzione di Yuku, perché ho trovato difficile farlo funzionare! Come ottengo l'oggetto AlertDialog dal mio AlertDialog.Builder? Bene, è il risultato della mia alert.show()esecuzione:

final AlertDialog.Builder alert = new AlertDialog.Builder(getActivity());
final EditText input = new EditText(getActivity());
alert.setView(input);

// do what you need, like setting positive and negative buttons...

final AlertDialog dialog = alert.show();

input.setOnFocusChangeListener(new OnFocusChangeListener() {
   @Override
   public void onFocusChange(View v, boolean hasFocus) {
      if(hasFocus) {
         dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
      }
   }
});

7

Dai un'occhiata a questa discussione che gestisce manualmente nascondere e mostrare l'IME. Tuttavia, la mia sensazione è che se un focus EditTextnon sta facendo apparire l'IME è perché stai chiamando il AlertDialog.show()tuo OnCreate()o qualche altro metodo che viene evocato prima che lo schermo venga effettivamente presentato. Spostarlo in OnPostResume()dovrebbe risolverlo in quel caso credo.


6

Sì, puoi farcela setOnFocusChangeListener, ti aiuterà.

editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        }
    }
});

4

So che questa domanda è vecchia, penso che usare una funzione di estensione sia un modo più carino per mostrare la tastiera per un testo di modifica

ecco il metodo che uso per mostrare la tastiera per un edittext.

codice kotlin: basta chiamareedittext.showKeyboard()

fun EditText.showKeyboard() {
  post {
    requestFocus()
    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
  }
}

il codice java:

public static void showKeyboard(EditText editText) {
    editText.post(new Runnable() {
      @Override
      public void run() {
        editText.requestFocus();
        InputMethodManager imm = (InputMethodManager) editText.getContext()
            .getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(editText, InputMethodManager.SHOW_IMPLICIT);
      }
    });
  }

3

Se qualcuno sta ottenendo:

Impossibile fare un riferimento statico al metodo non statico getSystemService (String) dal tipo Activity

Prova ad aggiungere un contesto alla chiamata getSystemService.

Così

InputMethodManager imm = 
(InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

1

La domanda originale riguarda le finestre di dialogo e il mio EditText è su una vista normale. Comunque, sospetto che questo dovrebbe funzionare anche per la maggior parte di voi. Quindi, ecco cosa funziona per me (il metodo più votato sopra suggerito non ha fatto nulla per me). Ecco un EditView personalizzato che lo fa (la sottoclasse non è necessaria, ma l'ho trovata comoda per i miei scopi in quanto volevo anche catturare lo stato attivo quando la vista diventa visibile).

Questo è in realtà in gran parte lo stesso della risposta tidbecks. In realtà non ho notato per niente la sua risposta dato che aveva zero voti. Quindi stavo per commentare il suo post, ma sarebbe stato troppo lungo, quindi ho finito comunque di pubblicare questo post. tidbeck sottolinea che non è sicuro di come funzioni con i dispositivi dotati di tastiere. Posso confermare che il comportamento sembra essere esattamente lo stesso in entrambi i casi. Essendo tale che in modalità verticale la tastiera del software viene visualizzata e in orizzontale non lo fa. Far scorrere la tastiera fisica o meno non fa differenza sul mio telefono.

Perché, ho trovato personalmente il comportamento un po 'ho imbarazzante optato per l'utilizzo di: InputMethodManager.SHOW_FORCED. Funziona come volevo che funzionasse. La tastiera diventa visibile indipendentemente dall'orientamento, tuttavia, almeno sul mio dispositivo non si apre se la tastiera hardware è stata fatta scorrere.

import android.app.Service;
import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

public class BringOutTheSoftInputOnFocusEditTextView extends EditText {

    protected InputMethodManager inputMethodManager;

    public BringOutTheSoftInputOnFocusEditTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init();
    }

    public BringOutTheSoftInputOnFocusEditTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public BringOutTheSoftInputOnFocusEditTextView(Context context) {
        super(context);
        init();
    }

    private void init() {
        this.inputMethodManager = (InputMethodManager)getContext().getSystemService(Service.INPUT_METHOD_SERVICE);
        this.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View v, boolean hasFocus) {
                if (hasFocus) {
                    BringOutTheSoftInputOnFocusEditTextView.this.inputMethodManager.showSoftInput(BringOutTheSoftInputOnFocusEditTextView.this, InputMethodManager.SHOW_FORCED);
                }
            }
        });
    }

    @Override
    protected void onVisibilityChanged(View changedView, int visibility) {
        super.onVisibilityChanged(changedView, visibility);
        if (visibility == View.VISIBLE) {
            BringOutTheSoftInputOnFocusEditTextView.this.requestFocus();
        }
    }

}

1

Il problema sembra essere che, poiché il luogo in cui si inserisce il testo è inizialmente nascosto (o nidificato o qualcosa del genere), AlertDialog sta impostando automaticamente la bandiera WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IMo in WindowManager.LayoutParams.FLAG_NOT_FOCUSABLEmodo che le cose non attivino un input morbido per essere mostrato.

Il modo in cui risolvere questo problema è aggiungere quanto segue:

(...)
// Create the dialog and show it
Dialog dialog = builder.create()
dialog.show();

// After show (this is important specially if you have a list, a pager or other view that uses a adapter), clear the flags and set the soft input mode
dialog.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

1

prova e usa:

editText.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY);

1

Per mostrare la tastiera, per me, ho dovuto fare quanto segue

Android TextField: imposta focus + soft input a livello di codice

Essenzialmente la soluzione è la seguente

@Override
public void onResume() {
    super.onResume();
    //passwordInput.requestFocus(); <-- that doesn't work
    passwordInput.postDelayed(new ShowKeyboard(), 325); //250 sometimes doesn't run if returning from LockScreen
}

dove ShowKeyboardsi trova

private class ShowKeyboard implements Runnable {
    @Override
    public void run() {
        passwordInput.setFocusableInTouchMode(true);
        //passwordInput.requestFocusFromTouch(); //this gives touch event to launcher in background -_-
        passwordInput.requestFocus();
        getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        ((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(passwordInput, 0);
    }
}

Dopo un input riuscito, mi assicuro anche di nascondere la tastiera

getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);
((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE))
                    .hideSoftInputFromWindow(getView().getWindowToken(), 0);

1

Inserisci questi metodi nella tua classe Util e usali ovunque.

Kotlin

fun hideKeyboard(activity: Activity) {
    val view = activity.currentFocus
    val methodManager = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.hideSoftInputFromWindow(view!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

private fun showKeyboard(activity: Activity) {
    val view = activity.currentFocus
    val methodManager = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

Giava

public static void hideKeyboard(Activity activity) {
    View view = activity.getCurrentFocus();
    InputMethodManager methodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert methodManager != null && view != null;
    methodManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}

private static void showKeyboard(Activity activity) {
    View view = activity.getCurrentFocus();
    InputMethodManager methodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert methodManager != null && view != null;
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
}

1

Ho creato simpatiche funzioni di estensione di kotlin-esqe nel caso qualcuno fosse interessato

fun Activity.hideKeyBoard() {
    val view = this.currentFocus
    val methodManager = this.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.hideSoftInputFromWindow(view!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

fun Activity.showKeyboard() {
    val view = this.currentFocus
    val methodManager = this.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

0

Questo è un buon esempio per te:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <ScrollView
        android:id="@+id/scrollID"
        android:layout_width="fill_parent"
        android:layout_height="0dip"
        android:layout_weight="1" >

        <LinearLayout
            android:id="@+id/test"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical" >
        </LinearLayout>
    </ScrollView>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:baselineAligned="true"
        android:orientation="horizontal"
        android:paddingBottom="5dp"
        android:paddingLeft="5dp"
        android:paddingRight="5dp"
        android:weightSum="1" >

        <EditText
            android:id="@+id/txtInpuConversation"
            android:layout_width="0dip"
            android:layout_height="wrap_content"
            android:layout_weight="0.5"
            android:hint="@string/edt_Conversation" >

            <requestFocus />
        </EditText>

        <Button
            android:id="@+id/btnSend"
            android:layout_width="0dip"
            android:layout_height="wrap_content"
            android:layout_weight="0.5"
            android:text="@string/btn_Conversation" />
    </LinearLayout>

</LinearLayout>

0

Perché questa risposta - Perché la soluzione sopra mostrerà la tua tastiera ma non svanirà se fai clic in un altro punto EditText. Quindi devi fare qualcosa per far scomparire il keybaord quandoEditText perde la concentrazione.

È possibile ottenere ciò procedendo come segue:

  1. Rendi la vista padre (vista contenuto della tua attività) cliccabile e focalizzabile aggiungendo i seguenti attributi

        android:clickable="true" 
        android:focusableInTouchMode="true" 
  2. Implementare un metodo hideKeyboard ()

        public void hideKeyboard(View view) {
            InputMethodManager inputMethodManager =(InputMethodManager)getSystemService(Activity.INPUT_METHOD_SERVICE);
            inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(),InputMethodManager.HIDE_IMPLICIT_ONLY );
        }
  3. Infine, imposta onFocusChangeListener del tuo edittext.

        edittext.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View v, boolean hasFocus) {
                if (!hasFocus) {
                    hideKeyboard(v);
                }
            }
        });

0

Questo è un po 'complicato. L'ho fatto in questo modo e ha funzionato.

1. Alla prima chiamata per nascondere l'ingresso soft dalla finestra. Ciò nasconderà l'input software se la tastiera software è visibile o non farà nulla in caso contrario.

2.Mostra la tua finestra di dialogo

3. Quindi chiama semplicemente per attivare / disattivare l'input soft.

codice:

InputMethodManager inputManager = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); 
//hiding soft input
inputManager.hideSoftInputFromWindow(findViewById(android.R.id.content).getWind‌​owToken(), 0);
//show dialog
yourDialog.show();
//toggle soft input
inputManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,InputMethodManager.SHOW_IMPLICIT);

0

Prova questo

SomeUtils.java

public static void showKeyboard(Activity activity, boolean show) {
    InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);

    if(show)
        inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
    else
        inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY,0);
}

0

Ho provato molti ma questo è ciò che ha funzionato per me (Kotlin):

        val dialog = builder.create()
        dialog.setOnShowListener {
            nameEditText.requestFocus()
            val s = ContextCompat.getSystemService(requireContext(), InputMethodManager::class.java)
            s?.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0)
        }

        dialog.setOnDismissListener {
            val s = ContextCompat.getSystemService(requireContext(), InputMethodManager::class.java)
            s?.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0)
        }

        dialog.show()

0

Guardando https://stackoverflow.com/a/39144104/2914140 ho semplificato un po ':

// In onCreateView():
view.edit_text.run {
    requestFocus()
    post { showKeyboard(this) }
}

fun showKeyboard(view: View) {
    val imm = view.context.getSystemService(
        Context.INPUT_METHOD_SERVICE) as InputMethodManager?
    imm?.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

È meglio di https://stackoverflow.com/a/11155404/2914140 :

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

perché quando si preme il pulsante Home e si passa alla schermata principale, la tastiera rimarrà aperta.


-1
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

Lo chiamo in onCreate () per mostrare automaticamente la tastiera, quando sono entrato nell'attività.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.