我需要做一件非常简单的事情 - 找出是否显示了软件键盘。这在Android中可能吗？
问问题
295260 次
45 回答
691
新答案 添加于 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);
}
}
然后在您的活动课程中...
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
}
...
}
于 2011-01-19T15:42:11.990 回答
310
所以希望这可以帮助某人。
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.height();
if (heightDiff > 0.25*activityRootView.getRootView().getHeight()) { // if more than 25% of the screen, its probably a keyboard...
... do something here
}
}
});
于 2012-02-02T06:45:31.817 回答
57
就计算机而言，它一直存在，但这个问题仍然具有令人难以置信的相关性！
所以我已经接受了上述答案，并对它们进行了一些组合和改进......
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上的实现
于 2013-09-24T21:58:44.187 回答
51
很抱歉回答迟了，但我创建了一个小助手类来处理打开/关闭事件并通知听众和其他有用的东西，可能有人会觉得它有帮助：
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
于 2013-10-14T05:53:19.090 回答
35
一些改进以避免错误地检测高密度设备上软键盘的可见性：
高度差的阈值应定义为128 dp，而不是128 像素。
请参阅有关 Metrics and Grid 的 Google 设计文档，触摸对象的舒适尺寸为48 dp，按钮的最小尺寸为32 dp 。通用软键盘应包括 4 行按键，因此最小键盘高度应为： 32 dp * 4 = 128 dp，这意味着阈值大小应通过乘以设备密度转换为像素。对于 xxxhdpi 设备（密度 4），软键盘高度阈值应为 128 * 4 = 512 像素。根视图与其可见区域的高度差：
根视图高度 - 状态栏高度 - 可见框架高度 = 根视图底部 - 可见框架底部，因为状态栏高度等于根视图可见框架的顶部。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; }
于 2014-10-02T00:00:01.387 回答
26
哇，我们有好消息 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
}
于 2020-08-26T10:38:44.947 回答
7
这个想法是，如果您需要隐藏键盘并同时检查软输入状态，请使用以下解决方案：
public boolean hideSoftInput() {
InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
return imm.hideSoftInputFromWindow(mViewPager.getWindowToken(), 0);
}
如果键盘在隐藏之前显示，则此方法返回 true。
于 2013-12-06T13:01:22.187 回答
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
于 2011-07-09T07:39:14.743 回答
6
检查元素的高度是不可靠的，因为像 WifiKeyboard 这样的键盘的高度为零。
相反，您可以使用 showSoftInput() 和 hideSoftInput() 的回调结果来检查键盘的状态。完整的细节和示例代码在
https://rogerkeays.com/how-to-check-if-the-software-keyboard-is-shown-in-android
于 2012-02-20T23:50:07.663 回答
4
我没有假设差异编码，而是做了这样的事情，因为我的应用程序中有菜单选项。
final View root= findViewById(R.id.myrootview);
root.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
int heightDiff = root.getRootView().getHeight() - root.getHeight();
Rect rectgle= new Rect();
Window window= getWindow();
window.getDecorView().getWindowVisibleDisplayFrame(rectgle);
int contentViewTop=
window.findViewById(Window.ID_ANDROID_CONTENT).getTop();
if(heightDiff <= contentViewTop){
//Soft KeyBoard Hidden
}else{
//Soft KeyBoard Shown
}
}
});
于 2012-09-29T09:32:11.423 回答
4
您可以使用活动的 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);
}
}
于 2014-01-23T05:34:17.893 回答
4
有一个隐藏的方法可以帮助解决这个问题，InputMethodManager.getInputMethodWindowVisibleHeight. 但是不知道为什么要隐藏。
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()
}
}
于 2018-05-22T04:30:43.097 回答
4
也有带有系统插图的解决方案，但它仅适用于API >= 21( Android L)。假设您有BottomNavigationView，它是的子项LinearLayout，您需要在显示键盘时隐藏它：
> LinearLayout
> ContentView
> BottomNavigationView
您需要做的就是以LinearLayout这种方式扩展：
public class KeyboardAwareLinearLayout extends LinearLayout {
public KeyboardAwareLinearLayout(Context context) {
super(context);
}
public KeyboardAwareLinearLayout(Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
}
public KeyboardAwareLinearLayout(Context context,
@Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
public KeyboardAwareLinearLayout(Context context, AttributeSet attrs,
int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
}
@Override
public WindowInsets onApplyWindowInsets(WindowInsets insets) {
int childCount = getChildCount();
for (int index = 0; index < childCount; index++) {
View view = getChildAt(index);
if (view instanceof BottomNavigationView) {
int bottom = insets.getSystemWindowInsetBottom();
if (bottom >= ViewUtils.dpToPx(200)) {
// keyboard is shown
view.setVisibility(GONE);
} else {
// keyboard is hidden
view.setVisibility(VISIBLE);
}
}
}
return insets;
}
}
这个想法是，当显示键盘时，系统插图会以相当大的.bottom价值发生变化。
于 2018-02-15T15:38:53.647 回答
3
我发现@Reuben_Scratton 的方法与@Yogesh 的方法相结合似乎效果最好。结合他们的方法会产生这样的结果：
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
}
}
});
于 2012-01-31T21:44:16.580 回答
3
我使用了鲁班答案的一个轻微变体，事实证明这在某些情况下更有帮助，尤其是在高分辨率设备上。
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
}
}
});
于 2014-02-21T22:07:22.497 回答
3
这些解决方案都不适用于 Lollipop。在 LollipopactivityRootView.getRootView().getHeight()中包括按钮栏的高度，而测量视图则不包括。我已经调整了上面最好/最简单的解决方案来使用 Lollipop。
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);
Resources res = getResources();
// The status bar is 25dp, use 50dp for assurance
float maxDiff =
TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 50, res.getDisplayMetrics());
//Lollipop includes button bar in the root. Add height of button bar (48dp) to maxDiff
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
float buttonBarHeight =
TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 48, res.getDisplayMetrics());
maxDiff += buttonBarHeight;
}
if (heightDiff > maxDiff) { // if more than 100 pixels, its probably a keyboard...
...do something here
}
}
});
于 2014-11-18T23:01:27.850 回答
3
在使用上面建议添加固定数字的大多数解决方案时，我刚刚遇到了一个错误。
S4 的 dpi 很高，导致导航栏的高度为 100 像素，因此我的应用程序认为键盘一直处于打开状态。
因此，随着所有新的高分辨率手机的发布，我相信长期使用硬编码值并不是一个好主意。
在对各种屏幕和设备进行一些测试后，我发现一个更好的方法是使用百分比。获取 decorView 和您的应用内容之间的差异，然后检查该差异的百分比。从我得到的统计数据来看，大多数导航栏（无论大小、分辨率等）都将占据屏幕的 3% 到 5%。就好像键盘打开一样，它占据了屏幕的 47% 到 55%。
作为结论，我的解决方案是检查差异是否超过 10%，然后我假设它的键盘打开。
于 2015-06-04T02:40:04.417 回答
3
尝试这个：
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 ... \\
}
}
});
于 2017-10-24T15:33:51.417 回答
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 Rect r = new Rect();
@Override
public void onGlobalLayout() {
activityRootView.getWindowVisibleDisplayFrame(r);
int heightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
boolean isOpen = heightDiff > 100;
if (isOpen == wasOpened) {
logDebug("Ignoring global layout change...");
return;
}
wasOpened = isOpen;
listener.onVisibilityChanged(isOpen);
}
});
}
这个对我有用。
于 2016-12-16T08:24:31.220 回答
2
不要编写任何硬代码。最好的方法是在 Get Focus on EditText with KeyBord Show 上调整视图大小。您可以使用以下代码将活动的调整大小属性添加到清单文件中。
android:windowSoftInputMode="adjustResize"
于 2014-10-14T22:57:44.233 回答
2
你可以试试这个，对我很有用：
InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
if (imm.isAcceptingText()) {
//Software Keyboard was shown..
} else {
//Software Keyboard was not shown..
}
于 2015-04-16T00:12:53.663 回答
2
我的回答与 Kachi 的回答基本相同，但我将它包装到一个很好的帮助类中，以清理它在整个应用程序中的使用方式。
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);
}
}
您可以使用它来检测整个应用程序中任何地方的键盘更改，如下所示：
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
}
}
});
注意：只使用“注册”调用之一。它们都工作相同，只是为了方便
于 2014-10-17T15:48:02.857 回答
2
我认为这种方法将帮助您找出键盘是否可见。
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;
}
}
于 2015-01-27T10:38:25.650 回答
2
根据文档.. https://developer.android.com/reference/androidx/core/view/WindowInsetsCompat
检查发行说明.. https://developer.android.com/jetpack/androidx/releases/core#1.5.0-alpha02
要获取当前键盘可见性，您可以使用getRootWindowInsets，然后调用该isVisible()函数，传入 IME 类型。
val windowinsetscompat = ViewCompat.getRootWindowInsets(view)
val imeVisible = windowinsetscompat.isVisible(Type.ime())
还有变化的监听器OnApplyWindowInsetsListener
ViewCompat.setOnApplyWindowInsetsListener(view) { v, insets ->
val imeVisible = insets.isVisible(Type.ime())
}
于 2020-09-04T06:14:09.913 回答
2
在查看器中更改片段的方向时，我很难保持键盘状态。我不知道为什么，但它似乎很不稳定，并且与标准 Activity 的行为不同。
要在这种情况下保持键盘状态，首先您应该添加android:windowSoftInputMode = "stateUnchanged"到您的AndroidManifest.xml. 不过，您可能会注意到，这实际上并不能解决整个问题——如果之前在方向更改之前打开过键盘，则不会为我打开键盘。在所有其他情况下，行为似乎都是正确的。
然后，我们需要实现这里提到的解决方案之一。我找到的最干净的是 George Maisuradze 的——使用 hideSoftInputFromWindow 中的布尔回调：
InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
return imm.hideSoftInputFromWindow(mViewPager.getWindowToken(), 0);
我将此值存储在 Fragment 的onSaveInstanceState方法中并检索它onCreate。然后，如果键盘onCreateView的值为true（如果在 Fragment 销毁之前实际隐藏键盘之前键盘是可见的，则返回 true）。
于 2017-08-21T00:13:50.467 回答
1
这是我的解决方案，它有效。无需查找像素大小，只需检查内容视图的高度是否已更改：
// Scroll to the latest comment whenever the keyboard is shown
commentsContent.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
private int oldHeight;
@Override
public void onGlobalLayout() {
int newHeight = commentsContent.getMeasuredHeight();
if (newHeight < oldHeight) {
// Check for the keyboard showing in case the height difference
// is a result of orientation change
if (isSoftKeyboardShowing(CommentsActivity.this)) {
// Keyboard is showing so scroll to the latest comment
scrollToLatestComment();
}
}
oldHeight = newHeight;
}
});
public static boolean isSoftKeyboardShowing(Activity activity) {
InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
return inputMethodManager.isActive();
}
于 2014-07-03T16:04:46.863 回答
1
有一种直接的方法可以找到它。而且，它不需要任何布局更改。
因此，它也可以在沉浸式全屏模式下工作。
诀窍是您尝试隐藏或显示软键盘并捕获该尝试的结果。
不用惊慌，这并没有真正显示或隐藏键盘。我们只要求状态。
为了保持最新，您可以简单地重复操作，例如每 200 毫秒，使用处理程序。
你可以在这里找到一个实现：https ://stackoverflow.com/a/27567074/2525452
于 2014-12-19T15:32:10.243 回答
1
这里 99% 的解决方案都是基于 IME WINDOW SIZE 的概率，每个这样的解决方案都非常值得！
因为：
- 叠加 - 来自用户应用程序或系统应用程序
- IME 没有 MINIMUM SIZE 它可以占用 100% 的窗口大小，并且可以像开发人员实现的想象一样薄:)
- MODAL 窗口/MULTI 窗口
- 还有更多，比如不了解 IPC（例如：外部窗口或其内容检测）
所以猜测它的 IME 总是错误的 - 不要猜测确定！
@kevin-du 现在是最好的解决方案，因为它查询 IMM 的 IME 高度 - 但正如它所说的方法是隐藏的 API，所以使用它可能会因为错误的开发使用而导致错误的“假阴性结果”。
于 2019-10-05T13:46:04.470 回答
1
在了解了不同分辨率的一些问题后，我决定使用相对大小。我注意到可见状态和隐藏状态之间的差异约为 30%。所以我决定用 0.3 替换 128 PX。
我添加了这个类监听器来通知任何变化。
这是我的版本
import android.app.*;
import android.graphics.*;
import android.view.*;
public class SoftKeyboardState {
public static final int HIDDEN = 0, VISIBLE = 1;
private OnKeyboardStateChangedListener listener;
private View decorView;
public SoftKeyboardState(Activity activity) {
this.decorView = activity.findViewById(android.R.id.content);
initKeyboardListener();
}
private void initKeyboardListener() {
decorView.getViewTreeObserver().addOnGlobalLayoutListener(
new ViewTreeObserver.OnGlobalLayoutListener(){
private final Rect windowVisibleDisplayFrame = new Rect();
private int lastVisibleDecorViewHeight;
@Override
public void onGlobalLayout() {
decorView.getWindowVisibleDisplayFrame(windowVisibleDisplayFrame);
final int visibleDecorViewHeight = windowVisibleDisplayFrame.height();
if (lastVisibleDecorViewHeight != 0) {
if ((lastVisibleDecorViewHeight > visibleDecorViewHeight) && (lastVisibleDecorViewHeight / visibleDecorViewHeight >= 0.3f)) {
// visible
if (listener != null)listener.onKeyboardStateChanged(VISIBLE);
} else if ((lastVisibleDecorViewHeight < visibleDecorViewHeight) && (visibleDecorViewHeight / lastVisibleDecorViewHeight >= 0.3f)) {
// hidden
if (listener != null)listener.onKeyboardStateChanged(HIDDEN);
}
}
lastVisibleDecorViewHeight = visibleDecorViewHeight;
}
});
}
public void setOnKeyboardStateChangedListener(OnKeyboardStateChangedListener listener) {
this.listener = listener;
}
public interface OnKeyboardStateChangedListener {
public void onKeyboardStateChanged(int state);
}
}
于 2017-11-13T08:02:25.090 回答
0
如果您设置半透明状态栏模式， Reuben Scratton 的新答案（计算 HeightDiff int heightDiff = activityRootView.getRootView().getHeight() - activityRootView.getHeight();）在活动中将不起作用。
如果您使用半透明状态栏，activityRootView.getHeight()将永远不会改变软键盘可见的天气。它将始终返回活动和状态栏的高度。
比如Nexus 4，Android 5.0.1，设置android:windowTranslucentStatus为true，会永远返回1184，连ime都打开了。如果设置android:windowTranslucentStatus为false，它将正确返回高度，如果ime不可见，则返回1134（不包括状态栏）。关闭ime，它可能会返回5xx（取决于ime的高度）
我不知道这是一个错误，我尝试了 4.4.4 和 5.0.1，结果是一样的。
因此，到目前为止，第二个最一致的答案，Kachi 的解决方案将是计算 ime 高度的最安全的方法。这是一个副本：
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
}
}
});
于 2015-03-24T12:45:49.407 回答
0
不需要 LayoutListener的方法
就我而言，我想在更换 Fragment 之前保存键盘的状态。我从调用 hideSoftInputFromWindowonSaveInstanceState方法，它关闭键盘并返回我是否可见键盘。
此方法很简单，但可能会更改键盘的状态。
于 2015-05-26T08:24:37.193 回答
0
此解决方案可能会重新打开键盘，但它可以工作。
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;
}
于 2015-06-23T14:49:40.223 回答
0
if (keyopen())
{
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY,0);
}
上面的函数是我用来检查键盘是否可见的。如果是，那么我关闭它。
下面显示了所需的两种方法。
首先，在 onCreate 中定义可行的 Window 高度。
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;
//
}
然后，添加一个布尔方法来获取该实例的 Window 高度。如果它与原始的不匹配（假设您没有在此过程中更改它......）那么，键盘是打开的。
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;
}
}
弗罗茨！
于 2015-08-11T18:58:22.007 回答
0
也许这会帮助你：
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
于 2019-03-07T10:28:12.190 回答
0
参考@TacB0sS 的这个答案，我在 Kotlin 中开发了一个类。希望这会有所帮助。让我知道它是否需要一些改进。
class KeyboardVisibilityObserver(val layRootContainer: View?, val keyboardVisibilityListener: KeyboardVisibilityListener?) {
var isKeyboardOpen = false
private set
private var keyBoardObserver = object : ViewTreeObserver.OnGlobalLayoutListener {
private val DefaultKeyboardDP = 100
// Lollipop includes button bar in the root. Add height of button bar (48dp) to maxDiff
private val EstimatedKeyboardDP = DefaultKeyboardDP + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) 48 else 0
private val r = Rect()
override fun onGlobalLayout() {
if (layRootContainer != null) {
// Convert the dp to pixels.
val estimatedKeyboardHeight = TypedValue
.applyDimension(TypedValue.COMPLEX_UNIT_DIP, EstimatedKeyboardDP.toFloat(), layRootContainer.resources.displayMetrics).toInt()
// Conclude whether the keyboard is shown or not.
layRootContainer.getWindowVisibleDisplayFrame(r)
val heightDiff = layRootContainer.rootView.height - (r.bottom - r.top)
val isShown = heightDiff >= estimatedKeyboardHeight
if (isShown == isKeyboardOpen) {
// Log.d("Keyboard state", "Ignoring global layout change...");
return
}
isKeyboardOpen = isShown
keyboardVisibilityListener?.onKeyboardVisibilityChanged(isKeyboardOpen)
}
}
}
init {
layRootContainer?.viewTreeObserver?.addOnGlobalLayoutListener(keyBoardObserver)
}
// call this in onDestroy
fun removeObserver(){
layRootContainer?.viewTreeObserver?.removeOnGlobalLayoutListener(keyBoardObserver)
}
interface KeyboardVisibilityListener {
fun onKeyboardVisibilityChanged(isKeyboardOpen: Boolean)
}
}
于 2019-11-12T20:58:18.727 回答
0
我知道这是一篇旧帖子，但我认为这是我所知道的最简单的方法，我的测试设备是 Nexus 5。我没有在其他设备上尝试过。如果其他人发现我的代码不好，希望其他人分享他们的方法:)
public static boolean isKeyboardShown(Context context, View view) {
if (context == null || view == null) {
return false;
}
InputMethodManager imm = (InputMethodManager) context
.getSystemService(Context.INPUT_METHOD_SERVICE);
return imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
imm.hideSoftInputFromWindow 返回布尔值。
谢谢，
于 2015-07-20T08:17:42.943 回答
0
除了正确答案之外，当在片段中使用 webview 时，我还必须在 onCreateView 的末尾添加它。
getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
可能是因为我在片段内运行 Webview，或者可能是 API 30 上的新行为，我的问题是即使显示键盘，片段的高度也从未改变。
所以对于 Fragment 整个代码应该是
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
View view = super.onCreateView(inflater, container, savedInstanceState);
//mWebView.postUrl("https://www.google.com/");
final View activityRootView = view;
layoutListener = 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);
// This variable was created only for Debug purposes and
// to see the height change when clicking on a field inside mWebView
int screenHeight = activityRootView.getRootView().getHeight();
Log.d("onGlobalLayout", "rect: " + r.toString());
Log.d("onGlobalLayout", "screenHeight: " + screenHeight);
//The difference on the heights from bottom to top and on the root height
int heightDiff = screenHeight - (r.bottom - r.top);
Log.d("onGlobalLayout", "heightDiff: " + heightDiff);
//I suggest to put 250 on resources to have better order
float dpx = dpToPx(getActivity(), 250);
if (previousHeightDiff != heightDiff) {
if (heightDiff > dpx) {
isSoftKeyboardPresent = true;
} else {
isSoftKeyboardPresent = false;
}
previousHeightDiff = heightDiff;
}
}
};
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(layoutListener);
getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
return view;
}
private static float dpToPx(Context context, float valueInDp) {
DisplayMetrics metrics = context.getResources().getDisplayMetrics();
return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, valueInDp, metrics);
}
于 2021-02-10T22:19:19.800 回答
0
这段代码很好用
将此类用于根视图：
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);
}
}
并在活动或片段中设置键盘监听器：
rootLayout.setKeyboardListener(targetEditText, new KeyboardConstraintLayout.KeyboardListener() {
@Override
public void onKeyboardVisibility(boolean isVisible) {
}
});
于 2018-05-22T16:14:02.517 回答
0
View#setOnApplyWindowInsetsListener 可用于获取窗口插入回调
public void setOnApplyWindowInsetsListener(OnApplyWindowInsetsListener listener) {
getListenerInfo().mOnApplyWindowInsetsListener = listener;
}
//OnApplyWindowInsetsListener
public WindowInsets onApplyWindowInsets(View v, WindowInsets insets);
并且boolean keyboardVisible = insets.isVisible(WindowInsets.Type.ime())可以给出可见性状态。
于 2021-06-15T05:17:21.877 回答
0
这是了解软键盘是否可见的解决方法。
- 使用 ActivityManager.getRunningServices(max_count_of_services) 检查系统上正在运行的服务；
- 从返回的 ActivityManager.RunningServiceInfo 实例中，检查软键盘服务的clientCount值。
- 上述clientCount每次都会递增，显示软键盘。例如，如果 clientCount 最初为 1，则在显示键盘时它将为 2。
- 在键盘关闭时，clientCount 会递减。在这种情况下，它重置为 1。
一些流行的键盘在其类名中有某些关键字：
Google AOSP = IME
Swype = IME
Swiftkey = KeyboardService
Fleksy = keyboard
Adaptxt = IME (KPTAdaptxtIME)
Smart = Keyboard (SmartKeyboard)
从 ActivityManager.RunningServiceInfo，检查 ClassNames 中的上述模式。还有，ActivityManager.RunningServiceInfo的clientPackage =android，表示键盘是绑定系统的。
可以将上述信息结合起来，以一种严格的方式来确定软键盘是否可见。
于 2016-06-01T12:52:43.440 回答
0
您可以使用InputMethodManager.isActive方法，true如果键盘可见则返回：
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.isActive();
您还可以查看键盘是否在特定视图中处于活动状态：
imm.isActive(View v);
于 2016-01-15T18:00:43.853 回答
0
Reuben Scratton 和 Kachi 提供的解决方案似乎依赖于设备的像素密度，如果您拥有高密度设备，即使键盘向下，高度差也可能大于 100。解决这个问题的方法是查看初始高度差（键盘向下），然后与当前差值进行比较。
boolean isOpened = false;
int firstHeightDiff = -1;
public void setListenerToRootView(){
final View activityRootView = getActivity().getWindow().getDecorView().findViewById(android.R.id.content);
Rect r = new Rect();
activityRootView.getWindowVisibleDisplayFrame(r);
firstHeightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
if (isAdded()) {
Rect r = new Rect();
activityRootView.getWindowVisibleDisplayFrame(r);
int heightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
isOpened = heightDiff>firstHeightDiff+100;
if (isAdded())
if(isOpened) {
//TODO stuff for when it is up
} else {
//TODO stuf for when it is down
}
}
}
});
}
于 2016-03-11T19:07:41.400 回答
0
这可能不适合生产，因为它会打开键盘。请注意，类似函数返回的布尔值未在 API 中指定，因此不可靠。请参阅此处的文档...
public boolean showSoftInput (View view,
int flags,
ResultReceiver resultReceiver)
请注意，此方法采用 ResultReceiver。它可以得到结果：RESULT_UNCHANGED_SHOWN、RESULT_UNCHANGED_HIDDEN、RESULT_SHOWN 或 RESULT_HIDDEN。如果您得到 RESULT_UNCHANGED_SHOWN，则键盘是可见的。如果您需要它在关闭时保持关闭，您将需要关闭它。
于 2021-02-28T04:21:05.550 回答
0
我知道您可以多么准确地确定键盘是否隐藏。
public int getStatusBarHeight() {
int result = 0;
int resourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resourceId > 0) {
result = getResources().getDimensionPixelSize(resourceId);
}
return result;
}
public int getNavigationBarHeight() {
int result = 0;
int resourceId = getResources().getIdentifier("navigation_bar_height", "dimen", "android");
if (resourceId > 0) {
result = getResources().getDimensionPixelSize(resourceId);
}
return result;
}
public boolean isKeyboardHidden() {
int delta = mRootView.getRootView().getHeight() - mRootView.getHeight() - getNavigationBarHeight() - getStatusBarHeight()
- getSupportActionBar().getHeight();
return delta <= 0;
}
这适用于平板电脑。当导航栏水平显示时。
于 2015-09-30T06:15:46.637 回答
-3
InputMethodManager 有关于软键盘的信息。您可以通过以下方式从活动中获取它：
((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE))
你可以玩弄它，看看它能告诉你什么。您可以使用它来显示或隐藏软输入...
于 2010-01-27T23:49:46.303 回答