Comment vérifier la visibilité de logiciel clavier Android?

NOUVELLE RÉPONSE ajouté 25 Jan 2012

Depuis la rédaction de la réponse ci-dessous, quelqu'un de doué-moi pour l'existence de ViewTreeObserver et les amis, les Api qui rôdent dans le SDK depuis la version 1.

Plutôt que d'exiger une Mise en page personnalisée de type, une solution beaucoup plus simple est de donner à votre activité, en vue de la racine connu ID, dire @+id/activityRoot, crochet un GlobalLayoutListener dans le ViewTreeObserver, et à partir de là calculer la taille de diff entre votre activité, en vue de la racine et de la taille de la fenêtre:

final View activityRootView = findViewById(R.id.activityRoot);
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
    @Override
    public void onGlobalLayout() {
        int heightDiff = activityRootView.getRootView().getHeight() - activityRootView.getHeight();
        if (heightDiff > dpToPx(this, 200)) { //if more than 200 dp, it's probably a keyboard...
            //... do something here
        }
     }
});

À l'aide d'un utilitaire tel que:

public static float dpToPx(Context context, float valueInDp) {
    DisplayMetrics metrics = context.getResources().getDisplayMetrics();
    return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, valueInDp, metrics);
}

Facile!

Remarque:
Votre application doit définir cette option dans Android Manifeste android:windowSoftInputMode="adjustResize" sinon solution ci-dessus ne fonctionnera pas.

RÉPONSE ORIGINALE À CETTE QUESTION

Oui c'est possible, mais il est beaucoup plus difficile qu'elle ne devrait l'être.

Si j'ai besoin de s'en soucier lorsque le clavier apparaît et disparaît (ce qui est assez souvent) alors ce que je fais est de personnaliser mon top-niveau classe de mise en page dans un qui remplace onMeasure(). La logique de base est que si la mise en page se trouve de remplissage de manière significative moins que la superficie totale de la fenêtre, puis un clavier souple est sans doute montrer.

import android.app.Activity;
import android.content.Context;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.widget.LinearLayout;

/*
 * LinearLayoutThatDetectsSoftKeyboard - a variant of LinearLayout that can detect when 
 * the soft keyboard is shown and hidden (something Android can't tell you, weirdly). 
 */

public class LinearLayoutThatDetectsSoftKeyboard extends LinearLayout {

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

    public interface Listener {
        public void onSoftKeyboardShown(boolean isShowing);
    }
    private Listener listener;
    public void setListener(Listener listener) {
        this.listener = listener;
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int height = MeasureSpec.getSize(heightMeasureSpec);
        Activity activity = (Activity)getContext();
        Rect rect = new Rect();
        activity.getWindow().getDecorView().getWindowVisibleDisplayFrame(rect);
        int statusBarHeight = rect.top;
        int screenHeight = activity.getWindowManager().getDefaultDisplay().getHeight();
        int diff = (screenHeight - statusBarHeight) - height;
        if (listener != null) {
            listener.onSoftKeyboardShown(diff>128); //assume all soft keyboards are at least 128 pixels high
        }
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);       
    }

    }

Puis dans votre classe d'Activité...

public class MyActivity extends Activity implements LinearLayoutThatDetectsSoftKeyboard.Listener {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ...
        LinearLayoutThatDetectsSoftKeyboard mainLayout = (LinearLayoutThatDetectsSoftKeyboard)findViewById(R.id.main);
        mainLayout.setListener(this);
        ...
    }


    @Override
    public void onSoftKeyboardShown(boolean isShowing) {
        //do whatever you need to do here
    }

    ...
}

Il a été à jamais dans les termes de l'ordinateur, mais cette question est encore incroyablement pertinent!

J'ai donc pris les réponses ci-dessus, et ont combiné et raffiné, un peu...

public interface OnKeyboardVisibilityListener {


    void onVisibilityChanged(boolean visible);
}

public final void setKeyboardListener(final OnKeyboardVisibilityListener listener) {
    final View activityRootView = ((ViewGroup) getActivity().findViewById(android.R.id.content)).getChildAt(0);

    activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {

        private boolean wasOpened;

        private final int DefaultKeyboardDP = 100;

        //From @nathanielwolf answer...  Lollipop includes button bar in the root. Add height of button bar (48dp) to maxDiff
        private final int EstimatedKeyboardDP = DefaultKeyboardDP + (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP ? 48 : 0);

        private final Rect r = new Rect();

        @Override
        public void onGlobalLayout() {
            //Convert the dp to pixels.
            int estimatedKeyboardHeight = (int) TypedValue
                    .applyDimension(TypedValue.COMPLEX_UNIT_DIP, EstimatedKeyboardDP, activityRootView.getResources().getDisplayMetrics());

            //Conclude whether the keyboard is shown or not.
            activityRootView.getWindowVisibleDisplayFrame(r);
            int heightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
            boolean isShown = heightDiff >= estimatedKeyboardHeight;

            if (isShown == wasOpened) {
                Log.d("Keyboard state", "Ignoring global layout change...");
                return;
            }

            wasOpened = isShown;
            listener.onVisibilityChanged(isShown);
        }
    });
}

Fonctionne pour moi 🙂

REMARQUE:
Si vous remarquez que le DefaultKeyboardDP ne convient pas à votre appareil un jeu avec la valeur et de poster un commentaire pour que tout le monde sache ce que devrait être la valeur... finalement, nous allons obtenir la valeur correcte pour s'adapter à tous les appareils!

Pour plus de détails, consultez la mise en œuvre sur Cyborg

Quelques améliorations pour éviter de détecter à tort la visibilité de clavier souple à haute densité d'appareils:

1. Seuil de différence de hauteur doit être définie comme 128 dp, pas 128 pixels.
   
   Reportez-vous à Google conception de la doc sur des Métriques et de la Grille, 48 dp est de la bonne taille pour toucher l'objet et 32 dp minimale pour les boutons. Générique soft clavier devrait inclure 4 rangées de touches, donc minimum de la hauteur du clavier doit être: 32 dp * 4 = 128 dp, cela signifie que le seuil de taille devrait transfert de pixels par multiplier dispositif de densité. Pour xxxhdpi périphériques (densité 4), le clavier hauteur de seuil doit être de 128 * 4 = 512 pixels.

2. Différence de hauteur entre la racine de la vue et de sa zone visible:
   
   vue de la racine de hauteur - barre d'état - hauteur de cadre visible height = vue de la racine de fond - image visible en bas, depuis la barre de statut la hauteur égale à la top de vue de la racine de l'image visible.

   private final String TAG = "TextEditor";
   private TextView mTextEditor;
   @Override
   protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   setContentView(R.layout.activity_editor);
   mTextEditor = (TextView) findViewById(R.id.text_editor);
   mTextEditor.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
   @Override
   public void onGlobalLayout() {
   isKeyboardShown(mTextEditor.getRootView());
   }
   });
   }
   private boolean isKeyboardShown(View rootView) {
   /* 128dp = 32dp * 4, minimum button height 32dp and generic 4 rows soft keyboard */
   final int SOFT_KEYBOARD_HEIGHT_DP_THRESHOLD = 128;
   Rect r = new Rect();
   rootView.getWindowVisibleDisplayFrame(r);
   DisplayMetrics dm = rootView.getResources().getDisplayMetrics();
   /* heightDiff = rootView height - status bar height (r.top) - visible frame height (r.bottom - r.top) */
   int heightDiff = rootView.getBottom() - r.bottom;
   /* Threshold size: dp to pixels, multiply with display density */
   boolean isKeyboardShown = heightDiff > SOFT_KEYBOARD_HEIGHT_DP_THRESHOLD * dm.density;
   Log.d(TAG, "isKeyboardShown ? " + isKeyboardShown + ", heightDiff:" + heightDiff + ", density:" + dm.density
   + "root view height:" + rootView.getHeight() + ", rect:" + r);
   return isKeyboardShown;
   }

La vérification de la hauteur des éléments n'est pas fiable parce que certains claviers WifiKeyboard ont une hauteur nulle.

Au lieu de cela, vous pouvez utiliser la fonction de rappel suite de showSoftInput() et hideSoftInput() pour vérifier l'état du clavier. Plus de détails et un exemple de code à

https://rogerkeays.com/how-to-check-if-the-software-keyboard-is-shown-in-android

Vous pouvez observer softkeyboard de se cacher en utilisant de l'activité decorView.

public final class SoftKeyboardUtil {
public static final String TAG = "SoftKeyboardUtil";
public static void observeSoftKeyBoard(Activity activity , final OnSoftKeyBoardHideListener listener){
final View decorView = activity.getWindow().getDecorView();
decorView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
Rect rect = new Rect();
decorView.getWindowVisibleDisplayFrame(rect);
int displayHight = rect.bottom - rect.top;
int hight = decorView.getHeight();
boolean hide = (double)displayHight / hight > 0.8 ;
if(Log.isLoggable(TAG, Log.DEBUG)){
Log.d(TAG ,"DecorView display hight = "+displayHight);
Log.d(TAG ,"DecorView hight = "+ hight);
Log.d(TAG, "softkeyboard visible = " + !hide);
}
listener.onSoftKeyBoardVisible(!hide);
}
});
}
public interface OnSoftKeyBoardHideListener{
void onSoftKeyBoardVisible(boolean visible);
}
}

J'ai trouvé que la combinaison de @Reuben_Scratton de la méthode avec @Yogesh la méthode semble fonctionner le mieux. En combinant leurs méthodes donnerait quelque chose comme ceci:

final View activityRootView = findViewById(R.id.activityRoot);
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
if (getResources().getConfiguration().keyboardHidden == Configuration.KEYBOARDHIDDEN_NO) { //Check if keyboard is not hidden
//... do something here
}
}
});

Il y a de caché méthode peut aider pour cela, InputMethodManager.getInputMethodWindowVisibleHeight. Mais je ne sais pas pourquoi il est caché.

import android.content.Context
import android.os.Handler
import android.view.inputmethod.InputMethodManager
class SoftKeyboardStateWatcher(private val ctx: Context) {
companion object {
private const val DELAY = 10L
}
private val handler = Handler()
private var isSoftKeyboardOpened: Boolean = false
private val height: Int
get() {
val imm = ctx.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
val method = imm.javaClass.getMethod("getInputMethodWindowVisibleHeight")
method.isAccessible = true
return method.invoke(imm) as Int
}
private val task: Runnable by lazy {
Runnable {
start()
if (!isSoftKeyboardOpened && height > 0) {
isSoftKeyboardOpened = true
notifyOnSoftKeyboardOpened(height)
} else if (isSoftKeyboardOpened && height == 0) {
isSoftKeyboardOpened = false
notifyOnSoftKeyboardClosed()
}
}
}
var listener: SoftKeyboardStateListener? = null
interface SoftKeyboardStateListener {
fun onSoftKeyboardOpened(keyboardHeightInPx: Int)
fun onSoftKeyboardClosed()
}
fun start() {
handler.postDelayed(task, DELAY)
}
fun stop() {
handler.postDelayed({
if (!isSoftKeyboardOpened) handler.removeCallbacks(task)
}, DELAY * 10)
}
private fun notifyOnSoftKeyboardOpened(keyboardHeightInPx: Int) {
listener?.onSoftKeyboardOpened(keyboardHeightInPx)
}
private fun notifyOnSoftKeyboardClosed() {
listener?.onSoftKeyboardClosed()
}
}

J'ai utilisé une légère variante de Reuban réponse, qui s'est avérée être plus utile dans certaines circonstances, en particulier grâce à la haute résolution des appareils.

final View activityRootView = findViewById(android.R.id.content);
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(
new OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
int heightView = activityRootView.getHeight();
int widthView = activityRootView.getWidth();
if (1.0 * widthView / heightView > 3) {
//Make changes for Keyboard not visible
} else {
//Make changes for keyboard visible
}
}
});

Ma réponse est fondamentalement la même que Kachi réponse, mais j'ai enveloppé dans une belle classe d'aide à nettoyer la façon dont il est utilisé tout au long de mon application.

import android.app.Activity;
import android.app.Fragment;
import android.graphics.Rect;
import android.view.View;
import android.view.ViewTreeObserver.OnGlobalLayoutListener;
/**
* Detects Keyboard Status changes and fires events only once for each change
*/
public class KeyboardStatusDetector {
KeyboardVisibilityListener visibilityListener;
boolean keyboardVisible = false;
public void registerFragment(Fragment f) {
registerView(f.getView());
}
public void registerActivity(Activity a) {
registerView(a.getWindow().getDecorView().findViewById(android.R.id.content));
}
public KeyboardStatusDetector registerView(final View v) {
v.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
Rect r = new Rect();
v.getWindowVisibleDisplayFrame(r);
int heightDiff = v.getRootView().getHeight() - (r.bottom - r.top);
if (heightDiff > 100) { //if more than 100 pixels, its probably a keyboard...
/** Check this variable to debounce layout events */
if(!keyboardVisible) {
keyboardVisible = true;
if(visibilityListener != null) visibilityListener.onVisibilityChanged(true);
}
} else {
if(keyboardVisible) {
keyboardVisible = false;
if(visibilityListener != null) visibilityListener.onVisibilityChanged(false);
}
}
}
});
return this;
}
public KeyboardStatusDetector setVisibilityListener(KeyboardVisibilityListener listener) {
visibilityListener = listener;
return this;
}
public static interface KeyboardVisibilityListener {
public void onVisibilityChanged(boolean keyboardVisible);
}
}

Vous pouvez l'utiliser pour détecter les changements-clavier le clavier n'importe où dans l'application comme ceci:

    new KeyboardStatusDetector()
.registerFragment(fragment)  //register to a fragment 
.registerActivity(activity)  //or register to an activity
.registerView(view)          //or register to a view
.setVisibilityListener(new KeyboardVisibilityListener() {
@Override
public void onVisibilityChanged(boolean keyboardVisible) {
if(keyboardVisible) {
//Do stuff for keyboard visible
}else {
//Do stuff for keyboard hidden
}
}
});

Remarque: utilisez uniquement l'un des "registre" des appels. Ils travaillent tous les mêmes et ne sont là que pour des raisons de commodité

J'ai juste rencontré un bug lors de l'utilisation de la plupart des solutions ci-dessus suggèrent que l'ajout d'un nombre fixe.

S4 est doté d'un haut dpi, ce qui a entraîné dans la barre de navigation de la hauteur 100px donc mon application de penser que le clavier est ouvert tout le temps.

Donc, avec tous les nouveaux high res téléphones être publié, je crois, à l'aide d'un codage en dur la valeur n'est pas une bonne idée pour le long terme.

Une meilleure approche que j'ai trouvé après quelques tests sur les différents écrans et les dispositifs a été d'utiliser le pourcentage.
Obtenez la différence entre decorView et ur du contenu de l'application et par la suite de vérifier quel est le pourcentage de cette différence.
De les stats que j'ai eu, plus de la barre de navigation(quelle que soit la taille, la résolution, etc..) va prendre entre 3% à 5% de l'écran. Si le clavier est ouvert, il était de 47% à 55% de l'écran.

En conclusion, ma solution a été de vérifier si l'écart est de plus de 10%, alors je suppose que son clavier ouvert.

Essayez ceci:

final View activityRootView = getWindow().getDecorView().getRootView();
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
Rect r = new Rect();
//r will be populated with the coordinates of your view that area still visible.
activityRootView.getWindowVisibleDisplayFrame(r);
int heightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
if (heightDiff < activityRootView.getRootView().getHeight() / 4 ) { //if more than 100 pixels, its probably a keyboard...
//... do something here ... \\
}
}
});

De ne pas faire le code. La meilleure façon est que vous devez redimensionner votre point de vue tout à Obtenir l'Accent sur EditText avec KeyBord Spectacle.
Vous pouvez le faire en ajoutant redimensionner propriété sur l'activité dans le Manifeste de fichier à l'aide du code ci-dessous.

android:windowSoftInputMode="adjustResize"

je pense que cette méthode va vous aider à trouver est keybord est visible ou non.

 public Boolean isSoftKeyBoardVisible(){
InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
if (imm.isAcceptingText()) {
Log.d(TAG,"Software Keyboard was shown");
return true;
} else {
Log.d(TAG,"Software Keyboard was not shown");
return false;
}
}

Une méthode qui n'a pas besoin d'un LayoutListener

Dans mon cas, je voudrais enregistrer l'état du clavier avant de remplacer mon Fragment. J'ai appeler la méthode hideSoftInputFromWindow de onSaveInstanceState, ce qui ferme le clavier et me renvoie si le clavier est visible ou non.

Cette méthode est simple, mais peut modifier l'état de votre clavier.

if (keyopen())
{
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY,0);            
}

La fonction ci-dessus est ce que j'utilise pour vérifier si un Clavier est visible. Si c'est le cas, je le ferme.

Ci-dessous montre les deux méthodes.

D'abord, de définir le réalisable hauteur de la Fenêtre en onCreate.

protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// add to onCreate method
Rect rectgle= new Rect();
Window window= getWindow();
window.getDecorView().getWindowVisibleDisplayFrame(rectgle);
sheight= rectgle.bottom;
//
} 

Ensuite, ajouter un booléen qui obtient la hauteur de la Fenêtre au niveau de cette instance. Si elle ne correspond pas à l'original (en supposant que vous ne modifiez pas le long du chemin...) ensuite, le clavier est ouvert.

public boolean keyopen()
{
Rect rectgle= new Rect();
Window window= getWindow();
window.getDecorView().getWindowVisibleDisplayFrame(rectgle);
int curheight= rectgle.bottom;
if (curheight!=sheight)
{
return true;
}
else
{
return false;
}
}

Frotz!

Pense a un moyen facile, comme ceci:

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.isActive();

Vous pouvez également voir si lui est active dans une vue spécifique:

imm.isActive(View v);

Voici une solution de contournement pour savoir si softkeyboard est visible.

1. Vérification pour l'exécution des services sur le système à l'aide de
   ActivityManager.getRunningServices(max_count_of_services);
2. De l'retourné ActivityManager.RunningServiceInfo cas, vérifier clientCount valeur pour clavier souple de service.
3. Ladite clientCount sera incrémenté à chaque fois, le clavier est affiché. Par exemple, si clientCount a été
   initialement 1, il serait 2 lorsque le clavier est affiché.
4. Sur le clavier de licenciement, clientCount est décrémenté. Dans ce cas, il se remet à 1.

Les claviers ont certains mots-clés dans leurs noms de classe:

Google AOSP = IME
Swype = IME
Swiftkey = KeyboardService
Fleksy = keyboard
Adaptxt = IME (KPTAdaptxtIME)
Smart = Keyboard (SmartKeyboard)

De ActivityManager.RunningServiceInfo, vérifier ces tendances dans les noms de classe. Aussi, ActivityManager.RunningServiceInfo de clientPackage=android, pour indiquer que le clavier est lié au système.

Les informations mentionnées ci-dessus pourraient être combinées de manière stricte à savoir si le clavier est visible.

Ce code fonctionne très agréable

utiliser cette classe pour la vue racine:

public class KeyboardConstraintLayout extends ConstraintLayout {
private KeyboardListener keyboardListener;
private EditText targetEditText;
private int minKeyboardHeight;
private boolean isShow;
public KeyboardConstraintLayout(Context context) {
super(context);
minKeyboardHeight = getResources().getDimensionPixelSize(R.dimen.keyboard_min_height);
}
public KeyboardConstraintLayout(Context context, AttributeSet attrs) {
super(context, attrs);
minKeyboardHeight = getResources().getDimensionPixelSize(R.dimen.keyboard_min_height);
}
public KeyboardConstraintLayout(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
minKeyboardHeight = getResources().getDimensionPixelSize(R.dimen.keyboard_min_height);
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
if (!isInEditMode()) {
Activity activity = (Activity) getContext();
@SuppressLint("DrawAllocation")
Rect rect = new Rect();
getWindowVisibleDisplayFrame(rect);
int statusBarHeight = rect.top;
int keyboardHeight = activity.getWindowManager().getDefaultDisplay().getHeight() - (rect.bottom - rect.top) - statusBarHeight;
if (keyboardListener != null && targetEditText != null && targetEditText.isFocused()) {
if (keyboardHeight > minKeyboardHeight) {
if (!isShow) {
isShow = true;
keyboardListener.onKeyboardVisibility(true);
}
}else {
if (isShow) {
isShow = false;
keyboardListener.onKeyboardVisibility(false);
}
}
}
}
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}
public boolean isShowKeyboard() {
return isShow;
}
public void setKeyboardListener(EditText targetEditText, KeyboardListener keyboardListener) {
this.targetEditText = targetEditText;
this.keyboardListener = keyboardListener;
}
public interface KeyboardListener {
void onKeyboardVisibility (boolean isVisible);
}

}

et choisir le clavier auditeur dans une activité ou un fragment:

    rootLayout.setKeyboardListener(targetEditText, new KeyboardConstraintLayout.KeyboardListener() {
@Override
public void onKeyboardVisibility(boolean isVisible) {
}
});

99% de solutions ici sont basés sur la probabilité de l'IME la TAILLE de la FENÊTRE et chaque solution est un poisson... vaut!

parce que:

1. SUPERPOSITIONS - de l'Utilisateur à partir des applications ou du Système d'apps
2. IME ont pas de TAILLE MINIMALE, il peut prendre 100% de la taille de la fenêtre et peut être si mince que l'imagination des développeurs de mise en œuvre 🙂
3. MODAL windows /MULTI windows
4. et beaucoup de beaucoup plus comme aucune connaissance de l'IPC (par exemple: les étrangers de la fenêtre ou de son contenu de détection)

donc deviner qu'il IME est toujours à tort - ne sait pas en être sûr !!!

@kevin-du est la meilleure solution wright maintenant que sa requête IMM pour IME en hauteur, mais comme il dit que la méthode est caché API afin de l'utiliser peut être dangereux dans la façon d'obtenir faux "faux négatifs" - par le mauvais dev d'utilisation.

Cette solution peut ré-ouvre le clavier, mais il fonctionne.

InputMethodManager inputManager = ( (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE) );
private boolean isKeyboardShowing() {
boolean isKeyboardShowing = inputManager.hideSoftInputFromWindow(irrelevantView.getWindowToken(), 0);
if (isKeyboardShowing) {
inputManager.showSoftInput(this.getCurrentFocus(), 0);
}
return isKeyboardShowing;
}