entityMap|blocks|key|4tsgo|text|新答案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3vd9k|flenb|增加了2012年1月25日|cd9ut|由于写了下面的答案，有人提示我存在|6mg2j|ViewTreeObserver|5qoa6|和朋友，从版本1开始就潜伏在SDK中的API。|4a4s1|与需要自定义布局类型相比，一种更简单的解决方案是为活动的根视图提供一个已知ID|3u7s7|，将一个GlobalLayoutListener挂接到ViewTreeObserver中，然后从那里计算活动的视图根和窗口大小之间的大小差：|coilm|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
++++++++}
+++++}
});|code-block|syntax|javascript|dkonl|使用以下实用程序：|f0sot|public+static+float+dpToPx(Context+context,+float+valueInDp)+{
++++DisplayMetrics+metrics+=+context.getResources().getDisplayMetrics();
++++return+TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,+valueInDp,+metrics);
}|7qsrt|简单！|9p7ir|注意：|bjdi7|您的应用程序必须在Android+Manifest中设置此标志|92q5o|否则上述解决方案将不起作用。|9iqt6|原始答案|4h8a1|是的，这是可能的，但它比应该的要难得多。|18uee|如果我需要关心键盘何时出现和消失(这是很常见的)，那么我要做的就是将我的顶级布局类自定义为一个覆盖|at613|..。基本的逻辑是，如果布局发现自己填充的区域比窗口的总面积小得多，那么可能会显示软键盘。|643l|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);+++++++
++++}

++++}|149lk|然后在你的活动课上..。|2r8fn|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
++++}

++++...
}^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|1K|9|@]|A|@]|B|$]]|$2|C|4|-4|6|7|8|1L|9|@]|A|@]|B|$]]|$2|D|4|E|6|7|8|1M|9|@]|A|@]|B|$]]|$2|F|4|G|6|7|8|1N|9|@]|A|@]|B|$]]|$2|H|4|I|6|7|8|1O|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|1P|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|1Q|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|1R|9|@]|A|@]|B|$]]|$2|P|4|Q|6|R|8|1S|9|@]|A|@]|B|$S|T]]|$2|U|4|V|6|7|8|1T|9|@]|A|@]|B|$]]|$2|W|4|X|6|R|8|1U|9|@]|A|@]|B|$S|T]]|$2|Y|4|Z|6|7|8|1V|9|@]|A|@]|B|$]]|$2|10|4|11|6|7|8|1W|9|@]|A|@]|B|$]]|$2|12|4|13|6|7|8|1X|9|@]|A|@]|B|$]]|$2|14|4|15|6|7|8|1Y|9|@]|A|@]|B|$]]|$2|16|4|17|6|7|8|1Z|9|@]|A|@]|B|$]]|$2|18|4|19|6|7|8|20|9|@]|A|@]|B|$]]|$2|1A|4|1B|6|7|8|21|9|@]|A|@]|B|$]]|$2|1C|4|1D|6|7|8|22|9|@]|A|@]|B|$]]|$2|1E|4|1F|6|R|8|23|9|@]|A|@]|B|$S|T]]|$2|1G|4|1H|6|7|8|24|9|@]|A|@]|B|$]]|$2|1I|4|1J|6|R|8|25|9|@]|A|@]|B|$S|T]]]]

NEW ANSWER added Jan 25th 2012

Since writing the below answer, someone clued me in to the existence of <a href="http://developer.android.com/reference/android/view/ViewTreeObserver.html" rel="noreferrer">ViewTreeObserver</a> and friends, APIs which have been lurking in the SDK since version 1.

Rather than requiring a custom Layout type, a much simpler solution is to give your activity's root view a known ID, say <code>@+id/activityRoot</code>, hook a GlobalLayoutListener into the ViewTreeObserver, and from there calculate the size diff between your activity's view root and the window size:

<pre><code>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 &gt; dpToPx(this, 200)) { // if more than 200 dp, it's probably a keyboard...
 // ... do something here
 }
 }
});
</code></pre>

Using a utility such as: 

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

Easy!

Note:
Your application must set this flag in Android Manifest <code>android:windowSoftInputMode="adjustResize"</code> otherwise above solution will not work.

ORIGINAL ANSWER

Yes it's possible, but it's far harder than it ought to be.

If I need to care about when the keyboard appears and disappears (which is quite often) then what I do is customize my top-level layout class into one which overrides <code>onMeasure()</code>. The basic logic is that if the layout finds itself filling significantly less than the total area of the window, then a soft keyboard is probably showing. 

<pre><code>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&gt;128); // assume all soft keyboards are at least 128 pixels high
 }
 super.onMeasure(widthMeasureSpec, heightMeasureSpec); 
 }

 }
</code></pre>

Then in your Activity class...

<pre><code>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
 }

 ...
}
</code></pre>

entityMap|blocks|key|6rhma|text|我花了一点时间来弄清楚这件事..。我运行了一些CastExceptions，但发现您可以将layout.xml中的LinearLayout替换为类的名称。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|aft1j|如下所示：|71hm6|....|code-block|syntax|javascript|3g4ma|这样就不会遇到任何cast问题。|41c5o|..。如果你不想在每个页面上都这样做，我建议你使用"MasterPage+in+Android“。请参阅此处的链接：|5ipk|http://jnastase.alner.net/archive/2011/01/08/ldquomaster-pagesrdquo-in-android.aspx^0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|P|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|Q|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|R|9|@]|A|@]|B|$H|I]]|$2|J|4|K|6|7|8|S|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|T|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|U|9|@]|A|@]|B|$]]]]

I used a little time to figure this out... I ran it some CastExceptions, but figured out that you can replace you LinearLayout in the layout.xml with the name of the class.

Like this:

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

&lt;com.ourshoppingnote.RelativeLayoutThatDetectsSoftKeyboard android:background="@drawable/metal_background"
 android:layout_width="fill_parent" android:layout_height="fill_parent"
 android:id="@+id/rlMaster" &gt;
 &lt;LinearLayout android:layout_width="fill_parent"
 android:layout_height="1dip" android:background="@drawable/line"&gt;&lt;/LinearLayout&gt;

 ....

&lt;/com.ourshoppingnote.RelativeLayoutThatDetectsSoftKeyboard&gt; 


&lt;/LinearLayout&gt;
</code></pre>

That way you do not run into any cast issues.

... and if you don't want to do this on every page, I recommend that you use "MasterPage in Android". See the link here:
<a href="http://jnastase.alner.net/archive/2011/01/08/ldquomaster-pagesrdquo-in-android.aspx" rel="noreferrer">http://jnastase.alner.net/archive/2011/01/08/ldquomaster-pagesrdquo-in-android.aspx</a>

entityMap|blocks|key|fsvai|text|我发现@Reuben的组合|type|unstyled|depth|inlineStyleRanges|entityRanges|data|d1thl|_|ejajk|Scratton的方法和@Yogesh的方法似乎效果最好。结合他们的方法会产生类似这样的结果：|dfv35|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
++++}
++}
});|code-block|syntax|javascript^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|M|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|N|9|@]|A|@]|B|$]]|$2|G|4|H|6|I|8|O|9|@]|A|@]|B|$J|K]]]]

I found that a combination of @Reuben_Scratton's method along with @Yogesh's method seems to work best. Combining their methods would yield something like this:

<pre><code>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
 }
 }
});
</code></pre>

entityMap|blocks|key|cverk|text|所以希望这能帮助到一些人。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|j63h|鲁本·斯克拉顿给出的新答案很棒，而且非常有效，但只有当你将windowSoftInputMode设置为adjustResize时，它才能真正起作用。如果将其设置为adjustPan，仍然无法使用他的代码片段检测键盘是否可见。为了解决这个问题，我对上面的代码做了这个小小的修改。|8gkbv|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%25+of+the+screen,+its+probably+a+keyboard...
++++++++...+do+something+here
++++}
+}
});|code-block|syntax|javascript^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|K|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|L|9|@]|A|@]|B|$H|I]]]]

So hopefully this helps someone out.
The new answer that Reuben Scratton gave is great and really efficient, but it really only works if you set your windowSoftInputMode to adjustResize. If you set it to adjustPan, it's still not possible to detect whether or not the keyboard is visible using his code snippet. To work around this, I made this tiny modification to the code above.
<pre><code>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 &gt; 0.25*activityRootView.getRootView().getHeight()) { // if more than 25% of the screen, its probably a keyboard...
 ... do something here
 }
 }
}); 
</code></pre>

entityMap|blocks|key|6nd9s|text|检查元素的高度是不可靠的，因为像WifiKeyboard这样的一些键盘的高度为零。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4a7rp|相反，您可以使用showSoftInput()和hideSoftInput()的回调结果来检查键盘的状态。完整的详细信息和示例代码，请访问|dqulo|https://rogerkeays.com/how-to-check-if-the-software-keyboard-is-shown-in-android^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|G|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|H|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|I|9|@]|A|@]|B|$]]]]

Checking the height of elements is not reliable because some keyboards like WifiKeyboard have zero height.

Instead, you can use the callback result of showSoftInput() and hideSoftInput() to check for the status of the keyboard. Full details and example code at

<a href="https://rogerkeays.com/how-to-check-if-the-software-keyboard-is-shown-in-android" rel="nofollow noreferrer">https://rogerkeays.com/how-to-check-if-the-software-keyboard-is-shown-in-android</a>

entityMap|blocks|key|3cpsk|text|我没有假设编码的不同，而是这样做的，因为我的应用程序中有菜单选项。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|bi9hm|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
++++++++}
+++++}
});|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Instead of assuming the difference coding I did something like this, as I dint had menu options in my application.

<pre><code>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 &lt;= contentViewTop){
 //Soft KeyBoard Hidden
 }else{
 //Soft KeyBoard Shown
 }
 }
});
</code></pre>

entityMap|blocks|key|cfho4|text|对于计算机来说，这已经是一个永恒的问题了，但这个问题仍然是令人难以置信的相关！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|f1pva|因此，我采用了上面的答案，并对它们进行了一些组合和提炼……|32san|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+%2B+(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);
++++++++}
++++});
}|code-block|syntax|javascript|dmum7|适用于我:)|deupu|注意：|5js78|如果您注意到|32pns|DefaultKeyboardDP|bep0d|不适合你的设备，玩价值，并发表评论，让每个人都知道应该是什么价值……最终，我们将获得适合所有设备的正确值！|297lc|有关更多详细信息，请查看|acmk4|半机械人^0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|X|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|Y|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|Z|9|@]|A|@]|B|$H|I]]|$2|J|4|K|6|7|8|10|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|11|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|12|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|13|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|14|9|@]|A|@]|B|$]]|$2|T|4|U|6|7|8|15|9|@]|A|@]|B|$]]|$2|V|4|W|6|7|8|16|9|@]|A|@]|B|$]]]]

It has been forever in terms of computer but this question is still unbelievably relevant!

So I've taken the above answers and have combined and refined them a bit...

<pre><code>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 &gt;= 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 &gt;= estimatedKeyboardHeight;

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

 wasOpened = isShown;
 listener.onVisibilityChanged(isShown);
 }
 });
}
</code></pre>

Works for me :)

NOTE: 
If you notice that the DefaultKeyboardDP does not fit your device play with the value and post a comment for everyone to know what should be the value... eventually we will get the correct value to fit all devices!

For more details, check out the implementation on <a href="https://github.com/nu-art/cyborg-core/blob/master/src/main/java/com/nu/art/cyborg/core/KeyboardChangeListener.java" rel="noreferrer">Cyborg</a>

entityMap|blocks|key|6u0q9|text|很抱歉回答得太晚了，但我已经创建了一个小助手类来处理打开/关闭事件，通知侦听器和其他有用的事情，可能有人会发现它很有帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|a5num|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+listeners+=+new+LinkedList();
++++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();
++++++++++++}
++++++++}
++++}
}|code-block|syntax|javascript|9lp0n|使用示例：|f1io7|final+SoftKeyboardStateWatcher+softKeyboardStateWatcher+
++++=+new+SoftKeyboardStateWatcher(findViewById(R.id.activity_main_layout);

//+Add+listener
softKeyboardStateWatcher.addSoftKeyboardStateListener(...);
//+then+just+handle+callbacks^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|M|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|N|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|O|9|@]|A|@]|B|$F|G]]]]

Sorry for the late answer, but I had created a little helper class to handle open/close events with notifying listeners and other useful things, may be someone would find it helpful:

<pre><code>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&lt;SoftKeyboardStateListener&gt; listeners = new LinkedList&lt;SoftKeyboardStateListener&gt;();
 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 &amp;&amp; heightDiff &gt; 100) { // if more than 100 pixels, its probably a keyboard...
 isSoftKeyboardOpened = true;
 notifyOnSoftKeyboardOpened(heightDiff);
 } else if (isSoftKeyboardOpened &amp;&amp; heightDiff &lt; 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();
 }
 }
 }
}
</code></pre>

Usage example:

<pre><code>final SoftKeyboardStateWatcher softKeyboardStateWatcher 
 = new SoftKeyboardStateWatcher(findViewById(R.id.activity_main_layout);

// Add listener
softKeyboardStateWatcher.addSoftKeyboardStateListener(...);
// then just handle callbacks
</code></pre>

entityMap|blocks|key|cbcfg|text|这个想法是，如果你需要隐藏你的键盘，同时检查软输入状态，使用以下解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|cq5he|public+boolean+hideSoftInput()+{
++++InputMethodManager+imm+=+(InputMethodManager)+getSystemService(Activity.INPUT_METHOD_SERVICE);
++++return+imm.hideSoftInputFromWindow(mViewPager.getWindowToken(),+0);
}|code-block|syntax|javascript|dcg1l|如果键盘在隐藏前显示，则此方法返回true。^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|K|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|L|9|@]|A|@]|B|$]]]]

The idea is, if you need to hide your keyboard and check soft input state at the same time, use the following solution:

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

This method returns true if keyboard was shown before hiding.

entityMap|blocks|key|bo0d|text|你可以通过使用activity的decorView来观察软键盘的隐藏。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2md65|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+=+"%2BdisplayHight);
++++++++++++++++++++Log.d(TAG+,"DecorView+hight+=+"%2B+hight);
++++++++++++++++++++Log.d(TAG,+"softkeyboard+visible+=+"+%2B+!hide);
++++++++++++++++}

++++++++++++++++listener.onSoftKeyBoardVisible(!hide);

++++++++++++}
++++++++});
++++}



++++public+interface+OnSoftKeyBoardHideListener{
++++++++void+onSoftKeyBoardVisible(boolean+visible);
++++}
}|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

You can observe softkeyboard's hide by using activity's decorView.

<pre><code>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 &gt; 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);
 }
}
</code></pre>

entityMap|blocks|key|70ahl|text|我使用了鲁班答案的一个轻微变体，事实证明在某些情况下更有帮助，特别是在高分辨率设备上。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|ee326|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
++++++++++++++++}
++++++++++++}
++++++++});|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

I used a slight variant of Reuban's answer, which proved to be more helpful in certain circumstances, especially with high resolution devices. 

<pre><code>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 &gt; 3) {
 //Make changes for Keyboard not visible
 } else {
 //Make changes for keyboard visible
 }
 }
 });
</code></pre>

entityMap|blocks|key|52t1j|text|这是我的解决方案，它是有效的。不要寻找像素大小，只需检查内容视图的高度是否发生了变化：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|kk9l|//+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();
}|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Here's my solution, and it works. Instead of looking for pixel size just check that the height of the content view has changed or not:

<pre><code>// 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 &lt; 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();
}
</code></pre>

entityMap|blocks|key|8an2n|text|避免错误检测高密度设备上软键盘可见性的一些改进：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|dvcu5|高差阈值应定义为|48ips|128+dp|4q1e2|，not|7b9oh|128像素|8v7cj|..。|217an|请参阅|abeit|关于度量和网格的Google设计文档|72d50|etpnc|48个dp|b0n|对于触摸对象来说是舒适大小，|bum7e|32个dp|4jdkc|是按钮的最低要求。通用软键盘应包括4行按键，因此最小键盘高度应为：|7s6oj|9be0h|*|ernep|4=+128+dp|72c1l|，这意味着阈值大小应该通过乘以器件密度来转换为像素。对于xxxhdpi设备(密度为4)，软键盘高度阈值应为128|2onh0|1pt19|4=+512像素。|3l2b1|根视图与其可见区域的高度差：|906dk|根视图高度-状态栏高度-可见框架高度=根视图底部-可见框架底部，因为状态栏高度等于根视图可见框架的顶部。|4udgl|private+final+String+TAG+=+"TextEditor"；private+TextView+mTextEditor；@Override+protected+void+onCreate(Bundle+savedInstanceState)+{+super.onCreate(savedInstanceState)；setContentView(R.layout.activity|c2vub|_|d1vi4|编辑器)；mTextEditor+=+(TextView)+findViewById(R.id.text|9mk0f|9hbkk|编辑器)；mTextEditor.getViewTreeObserver().addOnGlobalLayoutListener(new+ViewTreeObserver.OnGlobalLayoutListener()+{+@Override+public+void+onGlobalLayout()+{+isKeyboardShown(mTextEditor.getRootView())；}+})；}私有布尔isKeyboardShown(查看rootView)+{/|2s225|b630t|128dp+=+32dp|vomq|f7q46|4，最小按钮高度32dp，通用4排软键盘|bd2oo|june|/+final+int+SOFT|6rnqt|15f2q|键盘|9dii1|5ttrj|高度|7shec|60ofb|DP|9ojql|ft2ao|阈值=+128；Rect+r=+new+Rect()；rootView.getWindowVisibleDisplayFrame(r)；DisplayMetrics+dm+=+rootView.getResources().getDisplayMetrics()；/|fda3o|3oh69|heightDiff+=+rootView高度-状态栏高度(r.top)+-可见框架高度(r.bottom+-+r.top)|67rsi|ak4rq|/+int+heightDiff+=+rootView.getBottom()+-+r.bottom；/|7bjli|bb9he|阈值大小:+dp到像素，乘以显示密度|1acrt|ftsf0|/+boolean+isKeyboardShown+=+heightDiff+>+SOFT|1lo4f|1ek7e|c58iq|45c63|a5qn7|25hfc|224op|fivuo|阈值|cnlre|28slc|dm.density；Log.d(TAG，"isKeyboardShown？“%2B+isKeyboardShown+%2B+"，heightDiff:”%2B+heightDiff+%2B+"，密度：“%2B+dm.density+%2B”根视图高度：“%2B+rootView.getHeight()+%2B+"，rect:”%2B+r)；return+isKeyboardShown；}^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|2V|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|2W|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|2X|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|2Y|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|2Z|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|30|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|31|9|@]|A|@]|B|$]]|$2|O|4|P|6|7|8|32|9|@]|A|@]|B|$]]|$2|Q|4|-4|6|7|8|33|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|34|9|@]|A|@]|B|$]]|$2|T|4|U|6|7|8|35|9|@]|A|@]|B|$]]|$2|V|4|W|6|7|8|36|9|@]|A|@]|B|$]]|$2|X|4|Y|6|7|8|37|9|@]|A|@]|B|$]]|$2|Z|4|W|6|7|8|38|9|@]|A|@]|B|$]]|$2|10|4|11|6|7|8|39|9|@]|A|@]|B|$]]|$2|12|4|13|6|7|8|3A|9|@]|A|@]|B|$]]|$2|14|4|15|6|7|8|3B|9|@]|A|@]|B|$]]|$2|16|4|11|6|7|8|3C|9|@]|A|@]|B|$]]|$2|17|4|18|6|7|8|3D|9|@]|A|@]|B|$]]|$2|19|4|1A|6|7|8|3E|9|@]|A|@]|B|$]]|$2|1B|4|1C|6|7|8|3F|9|@]|A|@]|B|$]]|$2|1D|4|1E|6|7|8|3G|9|@]|A|@]|B|$]]|$2|1F|4|1G|6|7|8|3H|9|@]|A|@]|B|$]]|$2|1H|4|1I|6|7|8|3I|9|@]|A|@]|B|$]]|$2|1J|4|1G|6|7|8|3J|9|@]|A|@]|B|$]]|$2|1K|4|1L|6|7|8|3K|9|@]|A|@]|B|$]]|$2|1M|4|11|6|7|8|3L|9|@]|A|@]|B|$]]|$2|1N|4|1O|6|7|8|3M|9|@]|A|@]|B|$]]|$2|1P|4|11|6|7|8|3N|9|@]|A|@]|B|$]]|$2|1Q|4|1R|6|7|8|3O|9|@]|A|@]|B|$]]|$2|1S|4|11|6|7|8|3P|9|@]|A|@]|B|$]]|$2|1T|4|1U|6|7|8|3Q|9|@]|A|@]|B|$]]|$2|1V|4|1G|6|7|8|3R|9|@]|A|@]|B|$]]|$2|1W|4|1X|6|7|8|3S|9|@]|A|@]|B|$]]|$2|1Y|4|1G|6|7|8|3T|9|@]|A|@]|B|$]]|$2|1Z|4|20|6|7|8|3U|9|@]|A|@]|B|$]]|$2|21|4|1G|6|7|8|3V|9|@]|A|@]|B|$]]|$2|22|4|23|6|7|8|3W|9|@]|A|@]|B|$]]|$2|24|4|1G|6|7|8|3X|9|@]|A|@]|B|$]]|$2|25|4|26|6|7|8|3Y|9|@]|A|@]|B|$]]|$2|27|4|11|6|7|8|3Z|9|@]|A|@]|B|$]]|$2|28|4|29|6|7|8|40|9|@]|A|@]|B|$]]|$2|2A|4|11|6|7|8|41|9|@]|A|@]|B|$]]|$2|2B|4|2C|6|7|8|42|9|@]|A|@]|B|$]]|$2|2D|4|11|6|7|8|43|9|@]|A|@]|B|$]]|$2|2E|4|2F|6|7|8|44|9|@]|A|@]|B|$]]|$2|2G|4|11|6|7|8|45|9|@]|A|@]|B|$]]|$2|2H|4|2I|6|7|8|46|9|@]|A|@]|B|$]]|$2|2J|4|1G|6|7|8|47|9|@]|A|@]|B|$]]|$2|2K|4|1X|6|7|8|48|9|@]|A|@]|B|$]]|$2|2L|4|1G|6|7|8|49|9|@]|A|@]|B|$]]|$2|2M|4|20|6|7|8|4A|9|@]|A|@]|B|$]]|$2|2N|4|1G|6|7|8|4B|9|@]|A|@]|B|$]]|$2|2O|4|23|6|7|8|4C|9|@]|A|@]|B|$]]|$2|2P|4|1G|6|7|8|4D|9|@]|A|@]|B|$]]|$2|2Q|4|2R|6|7|8|4E|9|@]|A|@]|B|$]]|$2|2S|4|11|6|7|8|4F|9|@]|A|@]|B|$]]|$2|2T|4|2U|6|7|8|4G|9|@]|A|@]|B|$]]]]

Some improvements to avoid wrongly detect the visibility of soft keyboard on high density devices: 

<ol>
<li>Threshold of height difference should be defined as 128 dp, not 128 pixels. 
Refer to <a href="http://developer.android.com/design/style/metrics-grids.html">Google design doc about Metrics and Grid</a>, 48 dp is comfortable size for touch object and 32 dp is minimum for buttons. Generic soft keyboard should include 4 rows of key buttons, so minimum keyboard height should be: 32 dp * 4 = 128 dp, that means threshold size should transfer to pixels by multiply device density. For xxxhdpi devices (density 4), the soft keyboard height threshold should be 128 * 4 = 512 pixels.</li>
<li>Height difference between root view and its visible area: 
root view height - status bar height - visible frame height = root view bottom - visible frame bottom, since status bar height equal to the top of root view visible frame. 

<pre><code>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 &gt; 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;
}
</code></pre></li>
</ol>

entityMap|blocks|key|8cfn1|text|不要做任何硬编码。最好的方法是你必须调整你的视图大小，同时获得焦点在EditText与KeyBord显示。您可以使用以下代码将activity的resize属性添加到Manifest文件中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

Don't make any hard code. Best way is you have to resize your views while on Get Focus on EditText with KeyBord Show.
You can do this adding resize property on activity into Manifest file using below code.

<code>android:windowSoftInputMode="adjustResize"</code>

entityMap|blocks|key|8u5qs|text|我的答案基本上与Kachi的答案相同，但我将其封装在一个很好的helper类中，以理顺它在整个应用程序中的使用方式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|9s9od|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);
++++}
}|code-block|syntax|javascript|90v0f|您可以使用它来检测整个应用程序中任何位置的键盘更改，如下所示：|3pcjd|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
++++++++++++++++++++}
++++++++++++++++}
++++++++++++});|a5ho|注意:只能使用其中一个"register“调用。它们的工作方式都是一样的，只是为了方便起见。^0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|N|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|O|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|P|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|Q|9|@]|A|@]|B|$F|G]]|$2|L|4|M|6|7|8|R|9|@]|A|@]|B|$]]]]

My answer is basically the same as Kachi's answer, but I wrapped it into a nice helper class to clean up the way it's used throughout my app.

<pre><code>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 &gt; 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);
 }
}
</code></pre>

You can use this to detect keyboard changes anywhere throughout the app like this:

<pre><code> 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
 }
 }
 });
</code></pre>

Note: only use one of the "register" calls. They all work the same and are only there for convenience

entityMap|blocks|key|4mkg1|text|这些解决方案都不适用于棒棒糖。在棒棒糖|type|unstyled|depth|inlineStyleRanges|entityRanges|data|o4ih|包括按钮栏的高度，而测量视图则不包括。我已经采用了上面最好/最简单的解决方案来处理棒棒糖。|6thu4|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+%2B=+buttonBarHeight;
++++}
++++if+(heightDiff+>+maxDiff)+{+//+if+more+than+100+pixels,+its+probably+a+keyboard...
++++++...do+something+here
++++}
++}
});|code-block|syntax|javascript^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|K|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|L|9|@]|A|@]|B|$H|I]]]]

None of these solutions will work for Lollipop as is. In Lollipop <code>activityRootView.getRootView().getHeight()</code> includes the height of the button bar, while measuring the view does not. I've adapted the best/simplest solution above to work with Lollipop. 

<pre><code> 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 &gt;= Build.VERSION_CODES.LOLLIPOP) {
 float buttonBarHeight =
 TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 48, res.getDisplayMetrics());
 maxDiff += buttonBarHeight;
 }
 if (heightDiff &gt; maxDiff) { // if more than 100 pixels, its probably a keyboard...
 ...do something here
 }
 }
});
</code></pre>

entityMap|blocks|key|8pfe3|text|有一个直接的方法来找出这一点。而且，它不需要任何布局更改。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3hbjo|因此，它也可以在沉浸式全屏模式下工作。|f628o|诀窍是您尝试隐藏或显示软键盘，并捕获该尝试的结果。|91lvu|不要惊慌，这不会真正显示或隐藏键盘。我们只要求州政府。|4mec2|要保持最新状态，您可以使用Handler简单地重复该操作，例如每200毫秒重复一次。|4fv7g|你可以在这里找到一个实现：|469ru|https://stackoverflow.com/a/27567074/2525452^0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|O|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|P|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|Q|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|R|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|S|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|T|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|U|9|@]|A|@]|B|$]]]]

There is a direct method to find this out. And, it does not require any Layout changes. 
So, it works in immersive fullscreen mode, too. 
The trick is that you try to hide or show the soft keyboard and capture the result of that try. 
No panic, this does not really show or hide the keyboard. We just ask for the state. 
To stay up-to-date, you can simply repeat the operation, e.g. every 200 milliseconds, using a Handler. 
You find an implementation here: <a href="https://stackoverflow.com/a/27567074/2525452">https://stackoverflow.com/a/27567074/2525452</a>

entityMap|blocks|key|6clpb|text|我认为这个方法将帮助你找出keybord是否可见。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|arc6f|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;
++++}

}|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

i think this method will help you to find out is keybord is visible or not.

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

}
</code></pre>

entityMap|blocks|key|36k1|text|鲁本·斯克拉顿的新答案(计算HeightDiff|type|unstyled|depth|inlineStyleRanges|entityRanges|data|dp5q3|如果您设置了半透明状态栏模式，)将不会在活动中工作。|1u1aq|如果使用半透明状态栏，|6ekog|永远不会改变天气软键盘是可见的。它将始终返回活动和状态栏的高度。|bnlnm|例如，Nexus+4、Android+5.0.1、set|ajckg|到true，它将永远返回1184，甚至ime都已打开。如果设置|hufq|如果设置为false，它将正确返回Height，如果ime不可见，则返回1134(不包括状态栏)。关闭ime，它可能会返回5xx+(取决于ime的高度)|ff5lk|我不知道这是不是一个bug，我尝试了4.4.4和5.0.1，结果是一样的。|8cqha|因此，到目前为止，第二个最被认可的答案是，Kachi的解决方案将是最安全的方式来计算ime的高度。这是一份副本：|193oi|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
++++}
+}
});|code-block|syntax|javascript^0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|X|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|Y|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|Z|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|10|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|11|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|12|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|13|9|@]|A|@]|B|$]]|$2|O|4|P|6|7|8|14|9|@]|A|@]|B|$]]|$2|Q|4|R|6|7|8|15|9|@]|A|@]|B|$]]|$2|S|4|T|6|U|8|16|9|@]|A|@]|B|$V|W]]]]

Reuben Scratton's new answer (calculate the HeightDiff <code>int heightDiff = activityRootView.getRootView().getHeight() - activityRootView.getHeight();</code> ) will not work in activity if you set the translucent status bar mode.

if you use translucent status bar , <code>activityRootView.getHeight()</code> will never change weather the soft keyboard is visible. it will always return the height of activity and status bar.

For example, Nexus 4, Android 5.0.1, set <code>android:windowTranslucentStatus</code> to true, it will return 1184 forever, even the ime have opend. If you set <code>android:windowTranslucentStatus</code> to false, it will return Height correctly, if ime invisible,it return 1134(not include the status bar)。close the ime, it will return 5xx maybe (depends on ime's height)

I don't know weather this is a bug, I've try on 4.4.4 and 5.0.1, the result is same.

So, up to now, the second most agreed answer, Kachi's solution will be the most safe way to calcute the height of ime. Here's a copy:

<pre><code>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 &gt; 100) { // if more than 100 pixels, its probably a keyboard...
 ... do something here
 }
 }
}); 
</code></pre>

entityMap|blocks|key|702c5|text|你可以试试这个，对我来说效果很好：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|93gom|InputMethodManager+imm+=+(InputMethodManager)+getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);

if+(imm.isAcceptingText())+{
++++//Software+Keyboard+was+shown..
}+else+{
++++//Software+Keyboard+was+not+shown..
}|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

you can try this, work great for me:

<pre><code>InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);

if (imm.isAcceptingText()) {
 //Software Keyboard was shown..
} else {
 //Software Keyboard was not shown..
}
</code></pre>

entityMap|blocks|key|15sfd|text|一种方法，该方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|9u9pb|不需要LayoutListener|ch3pe|在我的例子中，我希望在替换我的片段之前保存键盘的状态。我调用该方法|et3ni|hideSoftInputFromWindow|29qdd|来自|a6dit|，它关闭键盘并返回键盘是否可见。|ee01v|这种方法很简单，但可能会改变键盘的状态。^0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|O|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|P|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|Q|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|R|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|S|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|T|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|U|9|@]|A|@]|B|$]]]]

A method that doesn't need a LayoutListener

In my case, I would like to save the state of the keyboard before replacing my Fragment. I call the method <a href="http://developer.android.com/reference/android/view/inputmethod/InputMethodManager.html#hideSoftInputFromWindow%28android.os.IBinder,%20int%29" rel="nofollow">hideSoftInputFromWindow</a> from <code>onSaveInstanceState</code>, which closes the keyboard and returns me whether the keyboard was visible or not. 

This method is straightforward but may change the state of your keyboard.

entityMap|blocks|key|chadr|text|我刚刚在使用上面的大多数建议添加固定数字的解决方案时遇到了一个bug。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5srni|S4的dpi很高，导致导航栏的高度为100px，因此我的应用程序认为键盘一直是打开的。|r9q|因此，随着所有新的高分辨率手机的发布，我认为从长远来看，使用硬编码的值不是一个好主意。|1g4lf|在对各种屏幕和设备进行测试后，我发现一个更好的方法是使用percentage。获取decorView和您的应用程序内容之间的差异，然后检查差异的百分比。从我得到的统计数据来看，大多数导航栏(无论大小，分辨率等)将占用3%25到5%25的屏幕。就好像键盘是打开的一样，它占据了47%25到55%25的屏幕。|d5cer|作为结论，我的解决方案是检查差异是否超过10%25，然后我假设这是一个键盘打开。^0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|K|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|L|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|M|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|N|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|O|9|@]|A|@]|B|$]]]]

I have just encountered a bug while using most of the solutions above that suggest adding a fixed number.

S4 is has a high dpi which resulted in the navigation bar's height being 100px thus my app thinking that the keyboard is open all the time.

So with all the new high res phones being released i believe using a hard coded value is not a good idea for long term.

A better approach that i found after some testing on various screens and devices was to use percentage.
Get the difference between decorView and ur app content and afterwards check what is the percentage of that difference. 
From the stats that i got, most nav bar(regardless of the size, resolution etc..) will take between 3% to 5% of the screen. Where as if the keyboard is open it was taking between 47% to 55% of the screen.

As a conclusion my solution was to check if the diff is more than 10% then i assume its a keyboard open.

entityMap|blocks|key|enr41|text|对于计算机来说，这个问题已经永远存在了，但这个问题仍然是令人难以置信的相关！因此，我采用了上面的答案，并对它们进行了一些组合和提炼……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1e53e|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);
++++++++}
++++});
}|code-block|syntax|javascript|8f736|这对我很有效。^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|K|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|L|9|@]|A|@]|B|$]]]]

It has been forever in terms of the computer but this question is still unbelievably relevant!
So I've taken the above answers and have combined and refined them a bit...

<pre><code>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 &gt; 100;
 if (isOpen == wasOpened) {
 logDebug("Ignoring global layout change...");
 return;
 }

 wasOpened = isOpen;
 listener.onVisibilityChanged(isOpen);
 }
 });
}
</code></pre>

It works for me.

entityMap|blocks|key|f4nvq|text|在viewpager中更改片断的方向时，我很难保持键盘状态。我不知道为什么，但它似乎就是不可靠，行为与标准活动不同。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|269r|要在这种情况下保持键盘状态，首先应该添加|9509k|致您的|2sg0r|..。但是，您可能会注意到，这并不能真正解决整个问题--如果键盘在方向改变之前是打开的，它就不会为我打开。在所有其他情况下，行为似乎都是正确的。|9gdp7|然后，我们需要实现这里提到的解决方案之一。我发现的最干净的回调是George+Maisuradze的--使用来自hideSoftInputFromWindow的布尔回调：|2h2qu|InputMethodManager+imm+=+(InputMethodManager)+getSystemService(Activity.INPUT_METHOD_SERVICE);
return+imm.hideSoftInputFromWindow(mViewPager.getWindowToken(),+0);|code-block|syntax|javascript|bg8es|我将这个值存储在片段的|fe0pj|方法并检索到它。|3oplh|..。然后，我强行将键盘显示在|e55m8|如果它的值为|3pp1e|(如果在片断销毁之前，键盘在实际隐藏之前是可见的，则返回true+)。^0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|Z|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|10|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|11|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|12|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|13|9|@]|A|@]|B|$]]|$2|K|4|L|6|M|8|14|9|@]|A|@]|B|$N|O]]|$2|P|4|Q|6|7|8|15|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|16|9|@]|A|@]|B|$]]|$2|T|4|U|6|7|8|17|9|@]|A|@]|B|$]]|$2|V|4|W|6|7|8|18|9|@]|A|@]|B|$]]|$2|X|4|Y|6|7|8|19|9|@]|A|@]|B|$]]]]

I was having difficulty maintaining keyboard state when changing orientation of fragments within a viewpager. I'm not sure why, but it just seems to be wonky and acts differently from a standard Activity.

To maintain keyboard state in this case, first you should add <code>android:windowSoftInputMode = "stateUnchanged"</code> to your <code>AndroidManifest.xml</code>. You may notice, though, that this doesn't actually solve the entire problem -- the keyboard didn't open for me if it was previously opened before orientation change. In all other cases, the behavior seemed to be correct.

Then, we need to implement one of the solutions mentioned here.
The cleanest one I found was George Maisuradze's--use the boolean callback from hideSoftInputFromWindow:

<pre><code>InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
return imm.hideSoftInputFromWindow(mViewPager.getWindowToken(), 0);
</code></pre>

I stored this value in my Fragment's <code>onSaveInstanceState</code> method and retrieved it <code>onCreate</code>. Then, I forcibly showed the keyboard in <code>onCreateView</code> if it had a value of <code>true</code> (it returns true if the keyboard is visible before actually hiding it prior to the Fragment destruction).

entityMap|blocks|key|d35hi|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|eiu23|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+...+\\
++++++++}
++++}
});|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Try this:

<pre><code>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 &lt; activityRootView.getRootView().getHeight() / 4 ) { // if more than 100 pixels, its probably a keyboard...
 // ... do something here ... \\
 }
 }
});
</code></pre>

entityMap|blocks|key|4qnno|text|也有使用系统插入的解决方案，但它只适用于|type|unstyled|depth|inlineStyleRanges|entityRanges|data|48vju|(|iqth|)。说你有|29hif|，它是的子级|4ghsm|当键盘显示时，你需要隐藏它：|bpfto|>+LinearLayout
++>+ContentView
++>+BottomNavigationView|code-block|syntax|javascript|8s5op|你所需要做的就是扩展|dl903|以这样的方式：|10hde|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%2B%2B)+{
++++++++++++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;
++++}
}|a4u3i|这个想法是，当键盘被显示时，系统插入的改变是相当大的|5mcd5|价值。^0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|Z|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|10|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|11|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|12|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|13|9|@]|A|@]|B|$]]|$2|K|4|L|6|M|8|14|9|@]|A|@]|B|$N|O]]|$2|P|4|Q|6|7|8|15|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|16|9|@]|A|@]|B|$]]|$2|T|4|U|6|M|8|17|9|@]|A|@]|B|$N|O]]|$2|V|4|W|6|7|8|18|9|@]|A|@]|B|$]]|$2|X|4|Y|6|7|8|19|9|@]|A|@]|B|$]]]]

There is also solution with system insets, but it works only with <code>API &gt;= 21</code> (<code>Android L</code>). Say you have <code>BottomNavigationView</code>, which is child of <code>LinearLayout</code> and you need to hide it when keyboard is shown:

<pre><code>&gt; LinearLayout
 &gt; ContentView
 &gt; BottomNavigationView
</code></pre>

All you need to do is to extend <code>LinearLayout</code> in such way:

<pre><code>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 &lt; childCount; index++) {
 View view = getChildAt(index);
 if (view instanceof BottomNavigationView) {
 int bottom = insets.getSystemWindowInsetBottom();
 if (bottom &gt;= ViewUtils.dpToPx(200)) {
 // keyboard is shown
 view.setVisibility(GONE);
 } else {
 // keyboard is hidden
 view.setVisibility(VISIBLE);
 }
 }
 }
 return insets;
 }
}
</code></pre>

The idea is that when keyboard is shown, system insets are changed with pretty big <code>.bottom</code> value.

entityMap|blocks|key|2h1tp|text|有一个隐藏的方法可以帮助解决这个问题，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|ass7d|..。但我不知道为什么它会被藏起来。|270qj|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()
++}
}|code-block|syntax|javascript^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|K|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|L|9|@]|A|@]|B|$H|I]]]]

There's a hidden method can help for this, <code>InputMethodManager.getInputMethodWindowVisibleHeight</code>. But I don't know why it's hidden.

<pre><code>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 &amp;&amp; height &gt; 0) {
 isSoftKeyboardOpened = true
 notifyOnSoftKeyboardOpened(height)
 } else if (isSoftKeyboardOpened &amp;&amp; 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()
 }
}
</code></pre>

entityMap|blocks|key|e675l|text|99%25的解决方案都是基于IME窗口大小的概率，每个这样的解决方案都是一个简单的解决方案。值得！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|bcbjs|因为：|sup9|覆盖-来自用户应用程序或系统应用程序|bkic3|IME没有最小大小，它可以占用窗口大小的100%25，并且可以像开发人员实现的想象力一样薄:)|e2glb|模式窗口/多窗口|elq2p|更多的人不喜欢没有IPC知识(例如:外部窗口或其内容检测)|buvvh|因此，猜测是IME总是错误的-不要猜测，一定要确定！|5uh8s|@kevin-du是最好的解决方案wright+now，因为它的IMM查询IME高度-但正如它所说的方法是隐藏的API，所以使用它的方式可能会得到错误的“假阴性结果”-通过错误的开发使用。^0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|Q|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|R|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|S|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|T|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|U|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|V|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|W|9|@]|A|@]|B|$]]|$2|O|4|P|6|7|8|X|9|@]|A|@]|B|$]]]]

<h1>99% of solutions here are based on probability of IME WINDOW SIZE and each such solution is a sh... worth!</h1>
because:
<ol>
<li>OVERLAYS - from User apps or System apps</li>
<li>IME have no MINIMUM SIZE it can take 100% of window size and can be so thin as imagination of developer implementation :)</li>
<li>MODAL windows / MULTI windows</li>
<li>and many many more like no knowledge of IPC (eg: foreign window or its content detection)</li>
</ol>
so guessing it's IME is always wrong - don't guess be sure !!!
@kevin-du is best solution wright now as its query IMM for IME height - but as it said the method is hidden API so using it could be dangerous in the way of getting wrong &quot;false negative results&quot; - by wrong dev usage.

entityMap|blocks|key|3p6hu|text|根据医生的说法..|type|unstyled|depth|inlineStyleRanges|entityRanges|data|49ug2|https://developer.android.com/reference/androidx/core/view/WindowInsetsCompat|81ind|查看发行说明..|2bpfu|https://developer.android.com/jetpack/androidx/releases/core#1.5.0-alpha02|ev3iq|要获得当前的键盘可见性，可以使用|cv1d7|，然后调用|4qi6|函数，传入IME类型。|f1eee|val+windowinsetscompat+=+ViewCompat.getRootWindowInsets(view)
val+imeVisible+=+windowinsetscompat.isVisible(Type.ime())|code-block|syntax|javascript|3au8t|还有一个监听程序，用于监听更改|e4ns6|ViewCompat.setOnApplyWindowInsetsListener(view)+{+v,+insets+->
++++val+imeVisible+=+insets.isVisible(Type.ime())
}^0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|X|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|Y|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|Z|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|10|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|11|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|12|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|13|9|@]|A|@]|B|$]]|$2|O|4|P|6|Q|8|14|9|@]|A|@]|B|$R|S]]|$2|T|4|U|6|7|8|15|9|@]|A|@]|B|$]]|$2|V|4|W|6|Q|8|16|9|@]|A|@]|B|$R|S]]]]

according to the doc..
<a href="https://developer.android.com/reference/androidx/core/view/WindowInsetsCompat" rel="nofollow noreferrer">https://developer.android.com/reference/androidx/core/view/WindowInsetsCompat</a>
check release note..
<a href="https://developer.android.com/jetpack/androidx/releases/core#1.5.0-alpha02" rel="nofollow noreferrer">https://developer.android.com/jetpack/androidx/releases/core#1.5.0-alpha02</a>
To get the current keyboard visibility, you can use <code>getRootWindowInsets</code>, and then call the <code>isVisible()</code> function, passing in the IME type.
<pre><code>val windowinsetscompat = ViewCompat.getRootWindowInsets(view)
val imeVisible = windowinsetscompat.isVisible(Type.ime())
</code></pre>
there is also listener for changes <code>OnApplyWindowInsetsListener</code>
<pre><code>ViewCompat.setOnApplyWindowInsetsListener(view) { v, insets -&gt;
 val imeVisible = insets.isVisible(Type.ime())
}
</code></pre>

I need to do a very simple thing - find out if the software keyboard is shown. Is this possible in Android?

How to check visibility of software keyboard in Android?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

 我需要做一件非常简单的事情--查看是否显示了软件键盘。这在Android中是可能的吗？

问如何在Android中查看软件键盘的可见性？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Android中查看软件键盘的可见性？EN