如何检查Android中软件键盘的可见性？

Question

我需要做一个非常简单的事情 - 找出是否显示了软件键盘.这在Android中可行吗？

Answer 1

NEW ANSWER 于2012年1月25日补充说

自从写下面的答案后,有人告诉我ViewTreeObserver和朋友的存在,这些 API自版本1以来一直潜伏在SDK中.

而不是需要自定义布局类型,更简单的解决方案是为活动的根视图提供一个已知的ID,比如@+id/activityRoot将GlobalLayoutListener挂钩到ViewTreeObserver,然后从中计算活动的视图根和窗口大小之间的大小差异:

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

使用如下的实用程序:

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

简单!

注意: 您的应用程序必须在Android Manifest中设置此标志,android:windowSoftInputMode="adjustResize"否则上述解决方案将无效.

原始答案

是的,这是可能的,但它比它应该的要困难得多.

如果我需要关心键盘何时出现并消失(这是很常见的话),那么我所做的就是将我的顶级布局类自定义为覆盖的类onMeasure().基本逻辑是,如果布局发现自己填充的内容明显少于窗口的总面积,则可能会显示软键盘.

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

    }

然后在你的Activity类中......

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
    }

    ...
}

Answer 2

所以希望这可以帮助某人.

Reuben Scratton给出的新答案非常棒且效率很高,但它确实只有在将windowSoftInputMode设置为adjustResize时才有效.如果将其设置为adjustPan,则仍无法使用其代码片段检测键盘是否可见.为了解决这个问题,我对上面的代码做了一些微小的修改.

final View activityRootView = findViewById(R.id.activityRoot);
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new 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 > 100) { // if more than 100 pixels, its probably a keyboard...
        ... do something here
    }
 }
}); 

Answer 3

它一直是计算机方面的问题,但这个问题仍然令人难以置信!

所以我已经采取了上述答案,并将它们结合起来并进行了一些改进......

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

适合我:)

注意: 如果您发现DefaultKeyboardDP不适合您的设备,请使用该值并发布评论以便每个人知道该值应该是什么...最终我们将获得适合所有设备的正确值!

有关更多详细信息,请查看Cyborg上的实施

Answer 4

对于迟到的答案很抱歉,但是我创建了一个小助手类来处理打开/关闭事件,通知听众和其他有用的东西,可能有人会发现它有用:

import android.graphics.Rect;
import android.view.View;
import android.view.ViewTreeObserver;

import java.util.LinkedList;
import java.util.List;

public class SoftKeyboardStateWatcher implements ViewTreeObserver.OnGlobalLayoutListener {

    public interface SoftKeyboardStateListener {
        void onSoftKeyboardOpened(int keyboardHeightInPx);
        void onSoftKeyboardClosed();
    }

    private final List<SoftKeyboardStateListener> listeners = new LinkedList<SoftKeyboardStateListener>();
    private final View activityRootView;
    private int        lastSoftKeyboardHeightInPx;
    private boolean    isSoftKeyboardOpened;

    public SoftKeyboardStateWatcher(View activityRootView) {
        this(activityRootView, false);
    }

    public SoftKeyboardStateWatcher(View activityRootView, boolean isSoftKeyboardOpened) {
        this.activityRootView     = activityRootView;
        this.isSoftKeyboardOpened = isSoftKeyboardOpened;
        activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(this);
    }

    @Override
    public void onGlobalLayout() {
        final Rect r = new Rect();
        //r will be populated with the coordinates of your view that area still visible.
        activityRootView.getWindowVisibleDisplayFrame(r);

        final int heightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
        if (!isSoftKeyboardOpened && heightDiff > 100) { // if more than 100 pixels, its probably a keyboard...
            isSoftKeyboardOpened = true;
            notifyOnSoftKeyboardOpened(heightDiff);
        } else if (isSoftKeyboardOpened && heightDiff < 100) {
            isSoftKeyboardOpened = false;
            notifyOnSoftKeyboardClosed();
        }
    }

    public void setIsSoftKeyboardOpened(boolean isSoftKeyboardOpened) {
        this.isSoftKeyboardOpened = isSoftKeyboardOpened;
    }

    public boolean isSoftKeyboardOpened() {
        return isSoftKeyboardOpened;
    }

    /**
     * Default value is zero {@code 0}.
     *
     * @return last saved keyboard height in px
     */
    public int getLastSoftKeyboardHeightInPx() {
        return lastSoftKeyboardHeightInPx;
    }

    public void addSoftKeyboardStateListener(SoftKeyboardStateListener listener) {
        listeners.add(listener);
    }

    public void removeSoftKeyboardStateListener(SoftKeyboardStateListener listener) {
        listeners.remove(listener);
    }

    private void notifyOnSoftKeyboardOpened(int keyboardHeightInPx) {
        this.lastSoftKeyboardHeightInPx = keyboardHeightInPx;

        for (SoftKeyboardStateListener listener : listeners) {
            if (listener != null) {
                listener.onSoftKeyboardOpened(keyboardHeightInPx);
            }
        }
    }

    private void notifyOnSoftKeyboardClosed() {
        for (SoftKeyboardStateListener listener : listeners) {
            if (listener != null) {
                listener.onSoftKeyboardClosed();
            }
        }
    }
}

用法示例:

final SoftKeyboardStateWatcher softKeyboardStateWatcher 
    = new SoftKeyboardStateWatcher(findViewById(R.id.activity_main_layout);

// Add listener
softKeyboardStateWatcher.addSoftKeyboardStateListener(...);
// then just handle callbacks

Answer 5

一些改进,以避免错误地检测高密度设备上软键盘的可见性:

1. 高度差的阈值应定义为128 dp,而不是128像素.
   请参阅有关指标和网格的Google设计文档,48 dp是触摸对象的舒适尺寸,按钮最小32 dp.通用软键盘应包括4行按键,因此最小键盘高度应为: 32 dp*4 = 128 dp,这意味着阈值大小应通过乘以设备密度传输到像素.对于xxxhdpi设备(密度4),软键盘高度阈值应为128*4 = 512像素.

2. 根视图与其可见区域之间的高度差:
   根视图高度 - 状态栏高度 - 可见框架高度=根视图底部 - 可见框架底部,因为状态栏高度等于根视图可见框架的顶部.

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

Answer 6

哇，我们有好消息 Android Geeks。是时候告别旧方式了。首先我会添加官方发布说明来阅读和了解更多关于这些方法/类的信息，然后我们将看到这些惊人的方法/类

重要提示：在发布这些类/方法之前，不要将这些添加到您的发布应用程序中

如何检查键盘可见性

val insets = ViewCompat.getRootWindowInsets(view)
val isKeyboardVisible = insets.isVisible(Type.ime())

很少有其他实用程序

如何获得键盘的高度

val insets = ViewCompat.getRootWindowInsets(view)
val keyboardHeight = insets.getInsets(Type.ime()).bottom

如何显示/隐藏键盘

val controller = view.windowInsetsController

// Show the keyboard
controller.show(Type.ime())

// Hide the keyboard
controller.hide(Type.ime())

注意：在 API-30 中添加了WindowInsetsController，因此请等待向后兼容类不可用。

如何监听键盘隐藏/显示事件

ViewCompat.setOnApplyWindowInsetsListener(view) { v, insets ->
    val isKeyboardVisible = insets.isVisible(Type.ime())
    if (isKeyboardVisible) {
        // Do it when keyboard is being shown
    } else {
        // Do it when keyboard is hidden
    }

    // Return the insets to keep going down this event to the view hierarchy
    insets
}

Answer 7

我花了一点时间来弄明白这一点...我运行了一些CastExceptions,但想通了你可以在layout.xml中用类的名称替换LinearLayout.

像这样:

<?xml version="1.0" encoding="UTF-8"?>
<LinearLayout android:layout_width="fill_parent" android:layout_height="fill_parent"
    xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/llMaster">

<com.ourshoppingnote.RelativeLayoutThatDetectsSoftKeyboard android:background="@drawable/metal_background"
    android:layout_width="fill_parent" android:layout_height="fill_parent"
    android:id="@+id/rlMaster" >
    <LinearLayout android:layout_width="fill_parent"
        android:layout_height="1dip" android:background="@drawable/line"></LinearLayout>

          ....

</com.ourshoppingnote.RelativeLayoutThatDetectsSoftKeyboard>    


</LinearLayout>

这样你就不会遇到任何演员问题.

...如果您不想在每个页面上执行此操作,我建议您使用"Android中的MasterPage".请点击此处链接:http: //jnastase.alner.net/archive/2011/01/08/ldquomaster-pagesrdquo-in-android.aspx

Answer 8

检查元素的高度是不可靠的,因为像WifiKeyboard这样的键盘高度为零.

相反,您可以使用showSoftInput()和hideSoftInput()的回调结果来检查键盘的状态.完整的详细信息和示例代码

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

Answer 9

我们的想法是,如果您需要隐藏键盘并同时检查软输入状态,请使用以下解决方案:

public boolean hideSoftInput() {
    InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
    return imm.hideSoftInputFromWindow(mViewPager.getWindowToken(), 0);
}

如果在隐藏之前显示键盘,则此方法返回true.