Hoe sluit/verberg je het zachte Android-toetsenbord programmatisch?

Ik heb een EditText en een Button in mijn lay-out.

Nadat ik in het bewerkingsveld heb geschreven en op de Button heb geklikt, wil ik het virtuele toetsenbord verbergen als ik het buiten het toetsenbord aanraak. Ik neem aan dat dit een eenvoudig stukje code is, maar waar kan ik er een voorbeeld van vinden?


Antwoord 1, autoriteit 100%

Om deze waanzin te helpen verduidelijken, wil ik beginnen met mijn excuses aan te bieden namens alle Android-gebruikers voor Google’s ronduit belachelijke behandeling van het zachte toetsenbord. De reden dat er zoveel antwoorden zijn, elk verschillend, voor dezelfde simpele vraag is dat deze API, net als vele andere in Android, verschrikkelijk ontworpen is. Ik kan geen beleefde manier bedenken om het te zeggen.

Ik wil het toetsenbord verbergen. Ik verwacht Android de volgende verklaring te geven: Keyboard.hide(). Het einde. Heel erg bedankt. Maar Android heeft een probleem. U moet de InputMethodManager gebruiken om het toetsenbord te verbergen. OK, prima, dit is de API van Android voor het toetsenbord. MAAR! U moet een Context hebben om toegang te krijgen tot de IMM. Nu hebben we een probleem. Ik wil misschien het toetsenbord verbergen voor een statische of hulpprogrammaklasse die geen gebruik of behoefte heeft aan Context. of En VEEL erger, de IMM vereist dat je specificeert voor welk View (of erger nog, welk Window) je het toetsenbord wilt verbergen.

Dit is wat het verbergen van het toetsenbord zo uitdagend maakt. Beste Google: als ik het recept voor een cake zoek, is er geen RecipeProvider op aarde die zou weigeren me het recept te geven, tenzij ik eerst antwoord WIE de cake zal worden gegeten EN waar het wordt gegeten!!

Dit trieste verhaal eindigt met de lelijke waarheid: om het Android-toetsenbord te verbergen, moet je twee vormen van identificatie opgeven: een Context en een View of een Window.

Ik heb een statische hulpprogramma-methode gemaakt die het werk ZEER solide kan doen, op voorwaarde dat je het aanroept vanuit een Activity.

public static void hideKeyboard(Activity activity) {
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    //Find the currently focused view, so we can grab the correct window token from it.
    View view = activity.getCurrentFocus();
    //If no view currently has focus, create a new one, just so we can grab a window token from it
    if (view == null) {
        view = new View(activity);
    }
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

Houd er rekening mee dat deze hulpprogrammamethode ALLEEN werkt wanneer deze wordt aangeroepen vanuit een Activity! De bovenstaande methode roept getCurrentFocus van de doel Activity aan om het juiste venstertoken op te halen.

Maar stel dat u het toetsenbord wilt verbergen voor een EditText die wordt gehost in een DialogFragment? U kunt de bovenstaande methode daarvoor niet gebruiken:

hideKeyboard(getActivity()); //won't work

Dit werkt niet omdat je een verwijzing doorgeeft naar de host Activity van het Activity, die geen gerichte controle heeft terwijl het Fragment wordt weergegeven! Wauw! Dus om het toetsenbord te verbergen voor fragmenten, neem ik mijn toevlucht tot het lagere, algemenere en lelijkere:

public static void hideKeyboardFrom(Context context, View view) {
    InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

Hieronder vindt u aanvullende informatie die is verkregen door meer tijd te verspillen aan het zoeken naar deze oplossing:

Over windowSoftInputMode

Er is nog een ander twistpunt om rekening mee te houden. Android wijst standaard automatisch de eerste focus toe aan de eerste EditText of focusbare controle in je Activity. Hieruit volgt natuurlijk dat de InputMethod (meestal het zachte toetsenbord) zal reageren op de focusgebeurtenis door zichzelf te tonen. Het kenmerk windowSoftInputMode in AndroidManifest.xml, indien ingesteld op stateAlwaysHidden, instrueert het toetsenbord om deze automatisch toegewezen initiële focus te negeren.

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

Bijna ongelooflijk lijkt het alsof het niets doet om te voorkomen dat het toetsenbord opengaat wanneer je de besturing aanraakt (tenzij focusable="false" en/of focusableInTouchMode="false" zijn toegewezen aan de besturing). Blijkbaar is de instelling windowSoftInputMode alleen van toepassing op automatische focusgebeurtenissen, niet op focusgebeurtenissen die worden geactiveerd door aanraakgebeurtenissen.

Daarom heeft stateAlwaysHidden inderdaad een ZEER slechte naam. Het zou misschien in plaats daarvan ignoreInitialFocus moeten heten.


UPDATE: meer manieren om een ​​venstertoken te krijgen

Als er geen gerichte weergave is (dat kan bijvoorbeeld gebeuren als je net fragmenten hebt gewijzigd), zijn er andere weergaven die een nuttig venstertoken opleveren.

Dit zijn alternatieven voor de bovenstaande code if (view == null) view = new View(activity); Deze verwijzen niet expliciet naar uw activiteit.

Binnen een fragmentklasse:

view = getView().getRootView().getWindowToken();

Gegeven een fragment Activity als parameter:

view = fragment.getView().getRootView().getWindowToken();

Uitgaande van uw inhoud:

view = findViewById(android.R.id.content).getRootView().getWindowToken();

UPDATE 2: Duidelijke focus om te voorkomen dat het toetsenbord opnieuw wordt weergegeven als je de app vanaf de achtergrond opent

Voeg deze regel toe aan het einde van de methode:

view.clearFocus();


Antwoord 2, autoriteit 91%

Je kunt Android dwingen het virtuele toetsenbord te verbergen met de InputMethodManager, bellend met hideSoftInputFromWindow, waarbij u het token van het venster met uw gerichte weergave doorgeeft.

// Check if no view has focus:
View view = this.getCurrentFocus();
if (view != null) {  
    InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

Hierdoor wordt het toetsenbord in alle situaties verborgen. In sommige gevallen wil je InputMethodManager.HIDE_IMPLICIT_ONLY doorgeven als de tweede parameter om ervoor te zorgen dat je het toetsenbord alleen verbergt wanneer de gebruiker het niet expliciet dwingt om te verschijnen (door het menu ingedrukt te houden).

Opmerking: Als je dit in Kotlin wilt doen, gebruik dan:
context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager

Kotlin-syntaxis

// Only runs if there is a view that is currently focused
this.currentFocus?.let { view ->
    val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
    imm?.hideSoftInputFromWindow(view.windowToken, 0)
}

Antwoord 3, autoriteit 35%

Ook handig om het soft-toetsenbord te verbergen is:

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

Dit kan worden gebruikt om het soft-toetsenbord te onderdrukken totdat de gebruiker de editText View daadwerkelijk aanraakt.


Antwoord 4, autoriteit 16%

Ik heb nog een oplossing om het toetsenbord te verbergen:

InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);

Geef hier HIDE_IMPLICIT_ONLY door op de positie van showFlag en 0 op de positie van hiddenFlag. Het zal het zachte toetsenbord krachtig sluiten.


Antwoord 5, autoriteit 7%

De oplossing van Meier werkt ook voor mij. In mijn geval is het bovenste niveau van mijn app een tabhost en ik wil het trefwoord verbergen wanneer ik van tab wissel – ik krijg het venstertoken van de tabhost View.

tabHost.setOnTabChangedListener(new OnTabChangeListener() {
    public void onTabChanged(String tabId) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(tabHost.getApplicationWindowToken(), 0);
    }
}

Antwoord 6, autoriteit 7%

Probeer deze onderstaande code in onCreate()

EditText edtView = (EditText) findViewById(R.id.editTextConvertValue);
edtView.setInputType(InputType.TYPE_NULL);

Antwoord 7, autoriteit 6%

Bijwerken:
Ik weet niet waarom deze oplossing niet meer werkt (ik heb net getest op Android 23). Gebruik in plaats daarvan de oplossing van Saurabh Pareek. Hier is het:

InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
//Hide:
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
//Show
imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

Oud antwoord:

//Show soft-keyboard:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
//hide keyboard :
 getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

Antwoord 8, autoriteit 4%

protected void hideSoftKeyboard(EditText input) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(input.getWindowToken(), 0);    
}

Antwoord 9, autoriteit 4%

Als alle andere antwoorden hier niet werken zoals je zou willen, is er een andere manier om het toetsenbord handmatig te bedienen.

Maak een functie waarmee enkele van de eigenschappen van EditText worden beheerd:

public void setEditTextFocus(boolean isFocused) {
    searchEditText.setCursorVisible(isFocused);
    searchEditText.setFocusable(isFocused);
    searchEditText.setFocusableInTouchMode(isFocused);
    if (isFocused) {
        searchEditText.requestFocus();
    }
}

Zorg er dan voor dat onFocus van de EditText u het toetsenbord opent/sluit:

searchEditText.setOnFocusChangeListener(new OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (v == searchEditText) {
            if (hasFocus) {
                // Open keyboard
                ((InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(searchEditText, InputMethodManager.SHOW_FORCED);
            } else {
                // Close keyboard
                ((InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(searchEditText.getWindowToken(), 0);
            }
        }
    }
});

Nu, wanneer je het toetsenbord handmatig wilt openen, bel:

setEditTextFocus(true);

En voor het afsluitende gesprek:

setEditTextFocus(false);

Antwoord 10, autoriteit 3%

Saurabh Pareek heeft tot nu toe het beste antwoord.

Je kunt echter net zo goed de juiste vlaggen gebruiken.

/* hide keyboard */
((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
    .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
/* show keyboard */
((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
    .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY);

Voorbeeld van echt gebruik

/* click button */
public void onClick(View view) {      
  /* hide keyboard */
  ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
      .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
  /* start loader to check parameters ... */
}
/* loader finished */
public void onLoadFinished(Loader<Object> loader, Object data) {
    /* parameters not valid ... */
    /* show keyboard */
    ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
        .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY);
    /* parameters valid ... */
}

Antwoord 11, autoriteit 3%

van zo zoeken, hier vond ik een antwoord dat voor mij werkt

// Show soft-keyboard:
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
// Hide soft-keyboard:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

Antwoord 12, autoriteit 3%

Het korte antwoord

Bel in uw OnClick-luisteraar de onEditorAction van de EditText aan met IME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        someEditText.onEditorAction(EditorInfo.IME_ACTION_DONE)
    }
});

De drill-down

Ik vind dat deze methode beter, eenvoudiger en beter aansluit bij het ontwerppatroon van Android.
In het eenvoudige voorbeeld hierboven (en meestal in de meeste voorkomende gevallen) heb je een EditText die focus heeft/had en het was meestal ook degene die het toetsenbord in de eerste plaats aanriep (het is zeker in staat om het aan te roepen in veel voorkomende scenario’s). Op dezelfde manier zou het degene moeten zijn die het toetsenbord loslaat, meestal kan dat worden gedaan door een ImeAction. Kijk eens hoe een EditText met android:imeOptions="actionDone" zich gedraagt, je wilt hetzelfde gedrag op dezelfde manier bereiken.


Controleer dit gerelateerde antwoord


Antwoord 13, autoriteit 2%

Dit zou moeten werken:

public class KeyBoard {
    public static void show(Activity activity){
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        imm.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); // show
    }
    public static void hide(Activity activity){
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); // hide
    }
    public static void toggle(Activity activity){
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        if (imm.isActive()){
            hide(activity); 
        } else {
            show(activity); 
        }
    }
}
KeyBoard.toggle(activity);

Antwoord 14, autoriteit 2%

Ik gebruik een aangepast toetsenbord om een ​​Hex-nummer in te voeren, dus ik kan het IMM-toetsenbord niet laten verschijnen…

In v3.2.4_r1 is setSoftInputShownOnFocus(boolean show) toegevoegd om het weer te regelen of niet om het toetsenbord weer te geven wanneer een TextView focus krijgt, maar het is nog steeds verborgen, dus reflectie moet worden gebruikt:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    try {
        Method method = TextView.class.getMethod("setSoftInputShownOnFocus", boolean.class);
        method.invoke(mEditText, false);
    } catch (Exception e) {
        // Fallback to the second method
    }
}

Voor oudere versies kreeg ik zeer goede resultaten (maar verre van perfect) met een OnGlobalLayoutListener, toegevoegd met behulp van een ViewTreeObserver vanuit mijn root-weergave en vervolgens controleren als het toetsenbord er zo uitziet:

@Override
public void onGlobalLayout() {
    Configuration config = getResources().getConfiguration();
    // Dont allow the default keyboard to show up
    if (config.keyboardHidden != Configuration.KEYBOARDHIDDEN_YES) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(mRootView.getWindowToken(), 0);
    }
}

Deze laatste oplossing kan het toetsenbord een fractie van een seconde laten zien en knoeit met de selectiegrepen.

Als het toetsenbord op volledig scherm verschijnt, wordt onGlobalLayout niet aangeroepen. Om dat te voorkomen, gebruikt u TextView#setImeOptions(int) of in de TextView XML-declaratie:

android:imeOptions="actionNone|actionUnspecified|flagNoFullscreen|flagNoExtractUi"

Update: ik heb net gevonden wat dialogen gebruiken om het toetsenbord nooit te tonen en werkt in alle versies:

getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
        WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);

Antwoord 15, autoriteit 2%

public void setKeyboardVisibility(boolean show) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if(show){
        imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
    }else{
        imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(),0);
    }
}

Antwoord 16

Ik heb meer dan twee dagen besteed aan het doornemen van alle oplossingen die in de thread zijn gepost en heb ontdekt dat ze op de een of andere manier ontbreken. Mijn exacte vereiste is om een ​​knop te hebben die met 100% betrouwbaarheid het schermtoetsenbord toont of verbergt. Wanneer het toetsenbord zich in de verborgen staat bevindt, zou het niet opnieuw moeten verschijnen, ongeacht op welke invoervelden de gebruiker klikt. Wanneer het zich in de zichtbare staat bevindt, zou het toetsenbord niet moeten verdwijnen, ongeacht op welke knoppen de gebruiker klikt. Dit moet werken op Android 2.2+ tot aan de nieuwste apparaten.

Je kunt een werkende implementatie hiervan zien in mijn app schone RPN.

Na het testen van veel van de voorgestelde antwoorden op een aantal verschillende telefoons (inclusief froyo- en peperkoekapparaten) werd het duidelijk dat Android-apps betrouwbaar:

  1. Verberg het toetsenbord tijdelijk. Het zal opnieuw verschijnen wanneer een gebruiker
    stelt een nieuw tekstveld scherp.
  2. Toon het toetsenbord wanneer een activiteit begint
    en zet een vlag op de activiteit om aan te geven dat het toetsenbord dat moet doen
    altijd zichtbaar zijn. Deze vlag kan alleen worden gezet wanneer een activiteit is
    initialiseren.
  3. Markeer een activiteit om nooit te laten zien of het gebruik van de
    toetsenbord. Deze vlag kan alleen worden gezet wanneer een activiteit is
    initialiseren.

Voor mij is het tijdelijk verbergen van het toetsenbord niet voldoende. Op sommige apparaten verschijnt het opnieuw zodra een nieuw tekstveld wordt gefocust. Omdat mijn app meerdere tekstvelden op één pagina gebruikt, zorgt het focussen van een nieuw tekstveld ervoor dat het verborgen toetsenbord weer verschijnt.

Helaas werken item 2 en 3 op de lijst alleen betrouwbaar als er een activiteit wordt gestart. Zodra de activiteit zichtbaar is geworden, kunt u het toetsenbord niet permanent verbergen of tonen. De truc is om uw activiteit daadwerkelijk opnieuw te starten wanneer de gebruiker op de schakelknop op het toetsenbord drukt. In mijn app wordt de volgende code uitgevoerd wanneer de gebruiker op de schakeltoetsenbordknop drukt:

private void toggleKeyboard(){
    if(keypadPager.getVisibility() == View.VISIBLE){
        Intent i = new Intent(this, MainActivity.class);
        i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
        Bundle state = new Bundle();
        onSaveInstanceState(state);
        state.putBoolean(SHOW_KEYBOARD, true);
        i.putExtras(state);
        startActivity(i);
    }
    else{
        Intent i = new Intent(this, MainActivity.class);
        i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
        Bundle state = new Bundle();
        onSaveInstanceState(state);
        state.putBoolean(SHOW_KEYBOARD, false);
        i.putExtras(state);
        startActivity(i);
    }
}

Hierdoor wordt de huidige activiteit opgeslagen in een bundel, waarna de activiteit wordt gestart, waarbij een boolean wordt weergegeven die aangeeft of het toetsenbord moet worden weergegeven of verborgen.

Binnen de onCreate methode wordt de volgende code uitgevoerd:

if(bundle.getBoolean(SHOW_KEYBOARD)){
    ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(newEquationText,0);
    getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
}
else{
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
            WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
}

Als het zachte toetsenbord moet worden weergegeven, wordt de InputMethodManager gevraagd het toetsenbord weer te geven en krijgt het venster de opdracht om de zachte invoer altijd zichtbaar te maken. Als het zachte toetsenbord verborgen moet zijn, is de WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM ingesteld.

Deze aanpak werkt betrouwbaar op alle apparaten waarop ik heb getest – van een 4 jaar oude HTC-telefoon met Android 2.2 tot een Nexus 7 met 4.2.2. Het enige nadeel van deze aanpak is dat je voorzichtig moet zijn met de terugknop. Omdat mijn app in wezen maar één scherm heeft (het is een rekenmachine), kan ik onBackPressed() negeren en terugkeren naar het startscherm van het apparaat.


Antwoord 17

Als alternatief voor deze allesomvattende oplossing, als u het zachte toetsenbord van overal zonder een verwijzing naar het (EditText)-veld dat werd gebruikt om het toetsenbord te openen, maar toch wilde doen als het veld gefocust was, zou je dit kunnen gebruiken (vanuit een Activiteit):

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

Antwoord 18

Dankzij dit SO-antwoord heb ik het volgende afgeleid dat in mijn geval goed werkt bij het scrollen door de fragmenten van een ViewPager…

private void hideKeyboard() {   
    // Check if no view has focus:
    View view = this.getCurrentFocus();
    if (view != null) {
        InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
}
private void showKeyboard() {   
    // Check if no view has focus:
    View view = this.getCurrentFocus();
    if (view != null) {
        InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
    }
}

Antwoord 19

Bovenstaande antwoorden werken voor verschillende scenario’s, maar Als je het toetsenbord in een weergave wilt verbergen en moeite hebt om de juiste context te krijgen, probeer dan dit:

setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        hideSoftKeyBoardOnTabClicked(v);
    }
}
private void hideSoftKeyBoardOnTabClicked(View v) {
    if (v != null && context != null) {
        InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(v.getApplicationWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
}

en om de context op te halen uit de constructor:)

public View/RelativeLayout/so and so (Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    this.context = context;
    init();
}

Antwoord 20

Als u het zachte toetsenbord wilt sluiten tijdens een unit- of functionele test, kunt u dit doen door op de “terug-knop” van uw test te klikken:

// Close the soft keyboard from a Test
getInstrumentation().sendKeyDownUpSync(KeyEvent.KEYCODE_BACK);

Ik plaats “terug-knop” tussen aanhalingstekens, aangezien het bovenstaande de onBackPressed() voor de betreffende activiteit niet activeert. Het sluit gewoon het toetsenbord.

Zorg ervoor dat u even pauzeert voordat u verder gaat, aangezien het even duurt om de terugknop te sluiten, zodat volgende klikken op weergaven, enz. pas na een korte pauze worden geregistreerd (1 seconde is lang genoeg).


Antwoord 21

Zo doe je het in Mono voor Android (ook bekend als MonoDroid)

InputMethodManager imm = GetSystemService (Context.InputMethodService) as InputMethodManager;
if (imm != null)
    imm.HideSoftInputFromWindow (searchbox.WindowToken , 0);

Antwoord 22

Dit werkte voor mij voor al het bizarre toetsenbordgedrag

private boolean isKeyboardVisible() {
    Rect r = new Rect();
    //r will be populated with the coordinates of your view that area still visible.
    mRootView.getWindowVisibleDisplayFrame(r);
    int heightDiff = mRootView.getRootView().getHeight() - (r.bottom - r.top);
    return heightDiff > 100; // if more than 100 pixels, its probably a keyboard...
}
protected void showKeyboard() {
    if (isKeyboardVisible())
        return;
    InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if (getCurrentFocus() == null) {
        inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
    } else {
        View view = getCurrentFocus();
        inputMethodManager.showSoftInput(view, InputMethodManager.SHOW_FORCED);
    }
}
protected void hideKeyboard() {
    if (!isKeyboardVisible())
        return;
    InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View view = getCurrentFocus();
    if (view == null) {
        if (inputMethodManager.isAcceptingText())
            inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_NOT_ALWAYS, 0);
    } else {
        if (view instanceof EditText)
            ((EditText) view).setText(((EditText) view).getText().toString()); // reset edit text bug on some keyboards bug
        inputMethodManager.hideSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
}

Antwoord 23

Eenvoudige en gemakkelijk te gebruiken methode, bel gewoon hideKeyboardFrom(YourActivity.this); om het toetsenbord te verbergen

/**
 * This method is used to hide keyboard
 * @param activity
 */
public static void hideKeyboardFrom(Activity activity) {
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}

Antwoord 24

Voeg toe aan je activiteit android:windowSoftInputMode="stateHidden" in manifestbestand. Voorbeeld:

<activity
            android:name=".ui.activity.MainActivity"
            android:label="@string/mainactivity"
            android:windowSoftInputMode="stateHidden"/>

Antwoord 25

Voor open toetsenbord:

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(edtView, InputMethodManager.SHOW_IMPLICIT);

Voor toetsenbord sluiten/verbergen:

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

Antwoord 26

Gebruik deze geoptimaliseerde code gewoon in uw activiteit:

if (this.getCurrentFocus() != null) {
    InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}

Antwoord 27

Ik heb het geval dat mijn EditText zich ook in een AlertDialog kan bevinden, dus het toetsenbord moet bij het sluiten gesloten zijn. De volgende code lijkt overal te werken:

public static void hideKeyboard( Activity activity ) {
    InputMethodManager imm = (InputMethodManager)activity.getSystemService( Context.INPUT_METHOD_SERVICE );
    View f = activity.getCurrentFocus();
    if( null != f && null != f.getWindowToken() && EditText.class.isAssignableFrom( f.getClass() ) )
        imm.hideSoftInputFromWindow( f.getWindowToken(), 0 );
    else 
        activity.getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN );
}

Antwoord 28

Werkt elke keer als een magische aanraking

private void closeKeyboard() {
    InputMethodManager inputManager = (InputMethodManager)getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
    inputManager.hideSoftInputFromWindow(getActivity().getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
private void openKeyboard() {
    InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
    if(imm != null){
        imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
    }
}

Antwoord 29

Kotlin Version via Extension Function

Met de kotlin-uitbreidingsfuncties zou het zo eenvoudig zijn om het zachte toetsenbord te tonen en te verbergen.

ExtensionFunctions.kt

import android.app.Activity
import android.view.View
import android.view.inputmethod.InputMethodManager
import android.widget.EditText
import androidx.fragment.app.Fragment
fun Activity.hideKeyboard(): Boolean {
    return (getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager)
        .hideSoftInputFromWindow((currentFocus ?: View(this)).windowToken, 0)
}
fun Fragment.hideKeyboard(): Boolean {
    return (context?.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager)
        .hideSoftInputFromWindow((activity?.currentFocus ?: View(context)).windowToken, 0)
}
fun EditText.hideKeyboard(): Boolean {
    return (context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager)
        .hideSoftInputFromWindow(windowToken, 0)
}
fun EditText.showKeyboard(): Boolean {
    return (context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager)
        .showSoftInput(this, 0)
}

Gebruik

In uw Activity of Activity is hideKeyboard() nu duidelijk toegankelijk en kan het worden aangeroepen vanuit een instantie van EditText vind ik leuk:

editText.hideKeyboard()

Antwoord 30

public static void hideSoftKeyboard(Activity activity) {
    InputMethodManager inputMethodManager = (InputMethodManager)  activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}

na die oproep op onTouchListener:

findViewById(android.R.id.content).setOnTouchListener(new OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        Utils.hideSoftKeyboard(activity);
        return false;
    }
});

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes