Vraag Sluit / verberg het Android Soft Keyboard


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

Na het schrijven in het bewerkingsveld en klikken op de Button, Ik wil het virtuele toetsenbord verbergen. Ik neem aan dat dit een eenvoudig stukje code is, maar waar kan ik er een voorbeeld van vinden?


3085


oorsprong


antwoorden:


Om deze waanzin te verduidelijken, zou ik willen beginnen met mijn verontschuldigingen namens alle Android-gebruikers voor de ronduit belachelijke behandeling van het zachte toetsenbord door Google. De reden dat er zoveel verschillende antwoorden zijn, voor dezelfde simpele vraag, is omdat deze API, zoals vele anderen in Android, vreselijk is ontworpen. Ik kan geen beleefde manier bedenken om het te zeggen.

Ik wil het toetsenbord verbergen. Ik verwacht Android de volgende verklaring te bieden: Keyboard.hide(). Het einde. Veel dank. Maar Android heeft een probleem. U moet de gebruiken InputMethodManager om het toetsenbord te verbergen. OK, goed, dit is de API van Android op het toetsenbord. MAAR! U bent verplicht om een Context om toegang te krijgen tot de IMM. Nu hebben we een probleem. Ik wil het toetsenbord misschien verbergen voor een statische of utiliteitsklasse die geen gebruik of noodzaak heeft Context. of EN VEER erger, de IMM vereist dat u aangeeft wat View (of erger nog, wat Window) u het toetsenbord VAN wilt verbergen.

Dit is wat het toetsenbord zo moeilijk maakt om te verbergen. Beste Google: als ik het recept voor een cake opzoek, is er geen RecipeProvider op aarde die zou weigeren mij van het recept te voorzien, tenzij ik eerst antwoord WIE de cake zal worden gegeten door EN waar het zal worden gegeten !!

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

Ik heb een statische hulpprogramma-methode gemaakt die het werk ZEER stevig kan uitvoeren, op voorwaarde dat je dit 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 utilitymethode ALLEEN werkt wanneer deze wordt aangeroepen vanuit een Activity! De bovenstaande methode roept getCurrentFocus van het doelwit Activity om het juiste vensterfiche te halen.

Maar stel dat je het toetsenbord wilt verbergen voor een EditText gehost in een DialogFragment? U kunt de bovenstaande methode hiervoor niet gebruiken:

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

Dit werkt niet omdat je een verwijzing naar de Fragmentzijn gastheer Activity, die geen gerichte controle zal hebben terwijl de Fragment wordt getoond! Wauw! Dus, om het toetsenbord te verbergen voor fragmenten, neem ik een toevlucht tot het lagere niveau, meer gebruikelijk en lelijker:

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

Hieronder is wat extra informatie verzameld uit meer tijd verspild aan het achtervolgen van deze oplossing:

Over windowSoftInputMode

Er is nog een ander twistpunt waar je je bewust van moet zijn. Standaard wijst Android de eerste focus automatisch toe aan de eerste EditText of focuseerbare controle in uw Activity. Hieruit volgt vanzelf dat de InputMethod (meestal het zachte toetsenbord) reageert op de focusgebeurtenis door zichzelf te tonen. De windowSoftInputMode attribuut in AndroidManifest.xml, indien ingesteld op stateAlwaysHidden, geeft het toetsenbord de opdracht om deze automatisch toegewezen beginfocus te negeren.

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

Bijna ongelooflijk lijkt het niets te doen om te voorkomen dat het toetsenbord opent wanneer u de knop 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 om gebeurtenissen te focussen die worden geactiveerd door aanraakgebeurtenissen.

daarom stateAlwaysHidden is inderdaad HEEL slecht genoemd. Het zou misschien moeten worden genoemd ignoreInitialFocus in plaats daarvan.

Ik hoop dat dit helpt.


UPDATE: meer manieren om een ​​venster te krijgen

Als er geen gefocuste weergave is (bijvoorbeeld kan gebeuren als u net fragmenten hebt gewijzigd), zijn er andere weergaven die een nuttig venster-token opleveren.

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

In een fragmentklasse:

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

Gegeven een fragment fragment als een parameter:

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

Beginnend met uw inhoudsstructuur:

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

UPDATE 2: focus wissen om te voorkomen dat het toetsenbord opnieuw wordt weergegeven als u de app op de achtergrond opent

Voeg deze regel toe aan het einde van de methode:

view.clearFocus();


1008



Je kunt Android forceren om het virtuele toetsenbord te verbergen met behulp van de InputMethodManager, bellen hideSoftInputFromWindow, het token doorgeven van het venster met uw gefocuste weergave.

// 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 gedwongen om in alle situaties te worden verborgen. In sommige gevallen zul je willen doorgeven InputMethodManager.HIDE_IMPLICIT_ONLY als de tweede parameter om ervoor te zorgen dat u alleen het toetsenbord verbergt wanneer de gebruiker het niet expliciet heeft gedwongen te verschijnen (door het menu ingedrukt te houden).

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


4171



Ook nuttig voor het verbergen van het soft-keyboard 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-weergave daadwerkelijk aanraakt.


741



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

Hier ga je voorbij HIDE_IMPLICIT_ONLY op de positie van showFlag en 0 op de positie van hiddenFlag. Het zal het zachte toetsenbord krachtig afsluiten.


294



De oplossing van Meier werkt ook voor mij. In mijn geval is het hoogste niveau van mijn app een tabHost en ik wil het sleutelwoord verbergen bij het wisselen van tabbladen - ik krijg het venster token 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);
    }
}

128



Probeer deze onderstaande code in onCreate()

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

115



Bijwerken: Ik weet niet waarom deze oplossing niet meer werkt (ik heb het net getest op Android 23). Gebruik alstublieft de oplossing van Saurabh Pareek in plaats daarvan. 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);

107



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

63