Masquer par programme le clavier logiciel Android en cliquant sur un bouton et en touchant l'extérieur

Gestion du clavier logiciel Android

Travailler avec des applications Android nécessite souvent une saisie de l'utilisateur via le clavier virtuel. Dans les scénarios où vous avez un EditText et un Button dans votre mise en page, il devient essentiel de gérer efficacement le clavier. Plus précisément, après avoir saisi du texte et cliqué sur le bouton, vous souhaiterez peut-être masquer le clavier pour améliorer l'expérience utilisateur.

Cet article fournira un exemple simple et pratique de la façon de fermer le clavier logiciel Android par programme lorsque l'utilisateur interagit avec des zones en dehors du clavier. En suivant les étapes décrites, vous pouvez améliorer la convivialité et l'interface de votre application Android.

Comprendre la mise en œuvre

Les scripts fournis montrent comment masquer par programme le clavier logiciel Android lors de l'interaction avec l'interface utilisateur, en particulier après avoir saisi du texte dans un EditText champ et en cliquant sur un Button. Les exemples Java et Kotlin utilisent plusieurs composants et méthodes Android clés. Les deux scripts commencent par importer les classes nécessaires telles que Activity, Context, InputMethodManageret divers composants de l'interface utilisateur. Dans le onCreate méthode, findViewById est utilisé pour relier le EditText et Button de la mise en page au code. Le setOnClickListener La méthode est ensuite définie sur le bouton pour déclencher le dix fonction lorsque vous cliquez dessus.

Dans les deux implémentations, le dix la fonction utilise getSystemService pour récupérer le InputMethodManager service. La méthode hideSoftInputFromWindow est alors appelé avec le getWindowToken de la EditText pour masquer le clavier logiciel. De plus, le onTouchEvent La méthode est remplacée pour garantir que le clavier est masqué lorsque l'utilisateur touche en dehors du champ de saisie. Cette approche améliore l'expérience utilisateur en empêchant le clavier d'obstruer inutilement la vue. En utilisant ces méthodes et en gérant les événements tactiles de manière appropriée, les scripts gèrent efficacement le comportement du clavier logiciel dans une application Android.

Masquage du clavier logiciel Android lors du clic et du toucher du bouton en dehors du champ de saisie

Utiliser Java dans le développement Android

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.Button;
import android.widget.EditText;
 
public class MainActivity extends Activity {
    private EditText editText;
    private Button button;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        editText = findViewById(R.id.editText);
        button = findViewById(R.id.button);
 
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                hideKeyboard();
            }
        });
    }
 
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        hideKeyboard();
        return super.onTouchEvent(event);
    }
 
    private void hideKeyboard() {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
    }
}

Gestion du rejet du clavier logiciel dans Android à l'aide de Kotlin

Utiliser Kotlin pour le développement d'applications Android

import android.app.Activity
import android.content.Context
import android.os.Bundle
import android.view.MotionEvent
import android.view.View
import android.view.inputmethod.InputMethodManager
import android.widget.Button
import android.widget.EditText
 
class MainActivity : Activity() {
    private lateinit var editText: EditText
    private lateinit var button: Button
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
 
        editText = findViewById(R.id.editText)
        button = findViewById(R.id.button)
 
        button.setOnClickListener { hideKeyboard() }
    }
 
    override fun onTouchEvent(event: MotionEvent): Boolean {
        hideKeyboard()
        return super.onTouchEvent(event)
    }
 
    private fun hideKeyboard() {
        val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        imm.hideSoftInputFromWindow(editText.windowToken, 0)
    }
}

Explorer les techniques avancées de gestion du clavier

Au-delà des méthodes de base permettant de masquer le clavier logiciel Android, les développeurs peuvent mettre en œuvre des techniques plus avancées pour améliorer l'expérience utilisateur. Une de ces méthodes consiste à utiliser TouchListeners sur plusieurs composants de l'interface utilisateur pour détecter les événements tactiles et masquer le clavier en conséquence. Cette approche garantit que le clavier est masqué chaque fois que l'utilisateur interagit avec une partie de l'écran en dehors de l'écran. EditText. De plus, la gestion de la visibilité du clavier peut être couplée à une logique de mise au point, dans laquelle le focus est détourné du clavier. EditText vers un autre composant, invitant le clavier à se masquer automatiquement.

Une autre technique consiste à utiliser le View.OnFocusChangeListener sur le EditText. Cet auditeur peut détecter quand le EditText perd le focus et masque ensuite le clavier. Cette méthode est particulièrement utile dans les formulaires ou les applications de saisie de données où plusieurs champs de saisie sont impliqués. De plus, pour une expérience utilisateur plus fluide, les développeurs peuvent utiliser SoftKeyboardStateWatcher, une implémentation personnalisée qui suit les changements d'état de visibilité du clavier et répond en conséquence. En intégrant ces techniques avancées, les développeurs peuvent créer des applications Android plus intuitives et conviviales.

Foire aux questions sur la gestion du clavier logiciel Android

1. Comment puis-je détecter quand le clavier est affiché ou masqué ?
2. Vous pouvez utiliser un SoftKeyboardStateWatcher pour suivre les changements de visibilité du clavier.
3. Est-il possible de masquer automatiquement le clavier lorsqu'un utilisateur fait défiler l'écran ?
4. Oui, vous pouvez mettre en œuvre un OnScrollListener sur la vue de défilement pour masquer le clavier pendant le défilement.
5. Puis-je afficher le clavier par programme lorsqu'un EditText est concentré?
6. Oui, utilisez InputMethodManager.showSoftInput pour afficher le clavier lorsque le EditText gagne en concentration.
7. Comment masquer le clavier lorsque l’utilisateur appuie sur le bouton retour ?
8. Remplacer le onBackPressed méthode et masquez le clavier en utilisant InputMethodManager.
9. Puis-je personnaliser la disposition du clavier ?
10. Oui, Android autorise des dispositions de clavier personnalisées via InputMethodService.
11. Quelle est la meilleure façon de cacher le clavier dans un fragment ?
12. Utiliser getActivity().getSystemService pour obtenir le InputMethodManager dans un fragment.
13. Comment puis-je masquer le clavier lors du basculement entre les fragments ?
14. Mettre en œuvre un FragmentTransaction avec un auditeur pour cacher le clavier pendant le changement.
15. Est-il possible d'animer le masquage du clavier ?
16. Oui, vous pouvez animer la vue contenant le EditText pour créer un effet de masquage lisse.

Résumer les principaux points à retenir

Une gestion efficace du clavier logiciel Android est cruciale pour créer des applications intuitives. En utilisant getSystemService pour récupérer InputMethodManager et hideSoftInputFromWindow pour masquer le clavier, les développeurs peuvent contrôler le moment où le clavier apparaît et disparaît. La mise en œuvre d'écouteurs tactiles et clics affine davantage ce contrôle, garantissant que le clavier se cache correctement lors de l'interaction avec d'autres éléments de l'interface utilisateur. Ces techniques améliorent l'expérience utilisateur en empêchant le clavier d'obstruer un contenu important ou des éléments de l'interface utilisateur.