blocks|key|1031850|text|没有直接的方法-看看http://groups.google.com/group/android-platform/browse_thread/thread/1728f26f2334c060/5e4910f0d9eb898a，安卓团队的戴安·哈克伯恩回复说。但是，您可以通过检查#onMeasure中的窗口大小是否更改来间接检测它。参见How+to+check+visibility+of+software+keyboard+in+Android?。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1031851|entityMap|0|LINK|mutability|MUTABLE|url|http://groups.google.com/group/android-platform/browse_thread/thread/1728f26f2334c060/5e4910f0d9eb898a|1|https://stackoverflow.com/questions/2150078/android-is-software-keyboard-shown^0|A|2U|0|4O|1K|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

There is no direct way - see <a href="http://groups.google.com/group/android-platform/browse_thread/thread/1728f26f2334c060/5e4910f0d9eb898a" rel="noreferrer">http://groups.google.com/group/android-platform/browse_thread/thread/1728f26f2334c060/5e4910f0d9eb898a</a> where Dianne Hackborn from the Android team has replied. However, you can detect it indirectly by checking if the window size changed in #onMeasure. See <a href="https://stackoverflow.com/questions/2150078/android-is-software-keyboard-shown">How to check visibility of software keyboard in Android?</a>.

blocks|key|817028|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|817029|InputMethodManager+imm+=+(InputMethodManager)+getActivity()
++++++++++++.getSystemService(Context.INPUT_METHOD_SERVICE);

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

try this:

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

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

blocks|key|1032513|text|我创建了一个可用于此目的的简单类：https://github.com/ravindu1024/android-keyboardlistener。只需将其复制到您的项目中，并按如下方式使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1032514|KeyboardUtils.addKeyboardToggleListener(this,+new+KeyboardUtils.SoftKeyboardToggleListener()
{
++++@Override
++++public+void+onToggleSoftKeyboard(boolean+isVisible)
++++{
++++++++Log.d("keyboard",+"keyboard+visible:+"%2BisVisible);
++++}
});|code-block|syntax|javascript|1032515|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/ravindu1024/android-keyboardlistener/blob/master/keyboard-listener/src/main/java/com/rw/keyboardlistener/KeyboardUtils.java^0|H|1J|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

I created a simple class that can be used for this: <a href="https://github.com/ravindu1024/android-keyboardlistener/blob/master/keyboard-listener/src/main/java/com/rw/keyboardlistener/KeyboardUtils.java" rel="noreferrer">https://github.com/ravindu1024/android-keyboardlistener</a>. Just copy it in to your project and use as follows:

<pre><code>KeyboardUtils.addKeyboardToggleListener(this, new KeyboardUtils.SoftKeyboardToggleListener()
{
 @Override
 public void onToggleSoftKeyboard(boolean isVisible)
 {
 Log.d("keyboard", "keyboard visible: "+isVisible);
 }
});
</code></pre>

blocks|key|1032439|text|非常简单|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1032440|1.把id放在你的根视图上|1032441|rootView只是一个指向根视图的视图，在本例中是一个relative+layout|offset|length|style|CODE|1032442|<RelativeLayout+xmlns:android="http://schemas.android.com/apk/res/android"
++++++++++++++++android:layout_width="match_parent"
++++++++++++++++android:layout_height="match_parent"
++++++++++++++++android:id="@%2Bid/addresses_confirm_root_view"
++++++++++++++++android:background="@color/WHITE_CLR">|code-block|syntax|javascript|1032443|2.在活动中初始化根视图：|1032444|RelativeLayout+rootView+=+(RelativeLayout)+findViewById(R.id.addresses_confirm_root_view);|1032445|3.使用getViewTreeObserver()检测键盘是否打开或关闭|1032446|++++rootView.getViewTreeObserver().addOnGlobalLayoutListener(new+ViewTreeObserver.OnGlobalLayoutListener()+{
++++++++++++@Override
++++++++++++public+void+onGlobalLayout()+{
++++++++++++++++int+heightDiff+=+rootView.getRootView().getHeight()+-+rootView.getHeight();
++++++++++++++++
++++++++++++++++if+(heightDiff+>+100)+{+//+Value+should+be+less+than+keyboard's+height+
++++++++++++++++++++Log.e("MyActivity",+"keyboard+opened");
++++++++++++++++}+else+{+
++++++++++++++++++++Log.e("MyActivity",+"keyboard+closed");
++++++++++++++++}
++++++++++++}
++++++++});|1032447|entityMap^0|0|0|0|8|S|F|0|0|0|0|2I|0|4|L|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@$F|11|G|12|H|I]|$F|13|G|14|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|15|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|17|8|@$F|18|G|19|H|I]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1A|8|@$F|1B|G|1C|H|I]]|9|@]|A|$]]|$1|U|3|V|5|L|7|1D|8|@]|9|@]|A|$M|N]]|$1|W|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|X|$]]

<h1>Very Easy</h1>
<h3>1. Put id on your root view</h3>
<code>rootView</code> is just a view pointing to my root view in this case a <code>relative layout</code>:
<pre><code>&lt;RelativeLayout xmlns:android=&quot;http://schemas.android.com/apk/res/android&quot;
 android:layout_width=&quot;match_parent&quot;
 android:layout_height=&quot;match_parent&quot;
 android:id=&quot;@+id/addresses_confirm_root_view&quot;
 android:background=&quot;@color/WHITE_CLR&quot;&gt;
</code></pre>
<h3>2. Initialize your root view in your Activity:</h3>
<code>RelativeLayout rootView = (RelativeLayout) findViewById(R.id.addresses_confirm_root_view);</code>
<h3>3. Detect if keyboard is opened or closed by using <code>getViewTreeObserver()</code></h3>
<pre><code> rootView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
 @Override
 public void onGlobalLayout() {
 int heightDiff = rootView.getRootView().getHeight() - rootView.getHeight();
 
 if (heightDiff &gt; 100) { // Value should be less than keyboard's height 
 Log.e(&quot;MyActivity&quot;, &quot;keyboard opened&quot;);
 } else { 
 Log.e(&quot;MyActivity&quot;, &quot;keyboard closed&quot;);
 }
 }
 });
</code></pre>

blocks|key|817815|text|因此，在尝试了很长时间的AccessibilityServices、窗口嵌入、屏幕高度检测等之后，我想我找到了一种方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|817816|免责声明:它在Android中使用了隐藏的方法，这意味着它可能不一致。然而，在我的测试中，它似乎起作用了。|817817|这个方法是InputMethodManager#getInputMethodWindowVisibleHeight()，它从Lollipop+(5.0)开始就存在了。|offset|length|817818|调用该函数返回当前键盘的高度(以像素为单位)。理论上，键盘不应该是0像素高的，所以我做了一个简单的高度检查(在Kotlin中)：|817819|val+imm+by+lazy+{+context.getSystemService(Context.INPUT_METHOD_SERVICE)+as+InputMethodManager+}
if+(imm.inputMethodWindowVisibleHeight+>+0)+{
++++//keyboard+is+shown
else+{
++++//keyboard+is+hidden
}|code-block|syntax|javascript|817820|当我调用隐藏方法时，我使用Android+Hidden+API来避免反射(我为我开发的应用程序做了很多这样的事情，这些应用程序大多是hacky/tuner应用程序)，但是使用反射也应该是可能的：|817821|val+imm+by+lazy+{+context.getSystemService(Context.INPUT_METHOD_SERVICE)+as+InputMethodManager+}
val+windowHeightMethod+=+InputMethodManager::class.java.getMethod("getInputMethodWindowVisibleHeight")
val+height+=+windowHeightMethod.invoke(imm)+as+Int
//use+the+height+val+in+your+logic|817822|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/aosp-mirror/platform_frameworks_base/blob/lollipop-release/core/java/android/view/inputmethod/InputMethodManager.java|1|https://github.com/anggrayudi/android-hidden-api^0|0|0|5|1I|0|0|0|0|D|I|1|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@$F|15|G|16|1|17]]|A|$]]|$1|H|3|I|5|6|7|18|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|19|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1A|8|@]|9|@$F|1B|G|1C|1|1D]]|A|$]]|$1|Q|3|R|5|L|7|1E|8|@]|9|@]|A|$M|N]]|$1|S|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]|10|$5|V|W|X|A|$Y|11]]]]

So after a long time of playing around with AccessibilityServices, window insets, screen height detection, etc, I think I found a way to do this.

Disclaimer: it uses a hidden method in Android, meaning it might not be consistent. However, in my testing, it seems to work.

The method is <a href="https://github.com/aosp-mirror/platform_frameworks_base/blob/lollipop-release/core/java/android/view/inputmethod/InputMethodManager.java" rel="noreferrer">InputMethodManager#getInputMethodWindowVisibleHeight()</a>, and it's existed since Lollipop (5.0).

Calling that returns the height, in pixels, of the current keyboard. In theory, a keyboard shouldn't be 0 pixels tall, so I did a simple height check (in Kotlin):

<pre><code>val imm by lazy { context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager }
if (imm.inputMethodWindowVisibleHeight &gt; 0) {
 //keyboard is shown
else {
 //keyboard is hidden
}
</code></pre>

I use <a href="https://github.com/anggrayudi/android-hidden-api" rel="noreferrer">Android Hidden API</a> to avoid reflection when I call hidden methods (I do that a lot for the apps I develop, which are mostly hacky/tuner apps), but this should be possible with reflection as well:

<pre><code>val imm by lazy { context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager }
val windowHeightMethod = InputMethodManager::class.java.getMethod("getInputMethodWindowVisibleHeight")
val height = windowHeightMethod.invoke(imm) as Int
//use the height val in your logic
</code></pre>

blocks|key|1032292|text|我使用这个作为基础：https://rogerkeays.com/how-to-check-if-the-software-keyboard-is-shown-in-android|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1032293|/**
*+To+capture+the+result+of+IMM+hide/show+soft+keyboard
*/
public+class+IMMResult+extends+ResultReceiver+{
+++++public+int+result+=+-1;
+++++public+IMMResult()+{
+++++++++super(null);
}

@Override+
public+void+onReceiveResult(int+r,+Bundle+data)+{
++++result+=+r;
}

//+poll+result+value+for+up+to+500+milliseconds
public+int+getResult()+{
++++try+{
++++++++int+sleep+=+0;
++++++++while+(result+==+-1+&&+sleep+<+500)+{
++++++++++++Thread.sleep(100);
++++++++++++sleep+%2B=+100;
++++++++}
++++}+catch+(InterruptedException+e)+{
++++++++Log.e("IMMResult",+e.getMessage());
++++}
++++return+result;
}
}|code-block|syntax|javascript|1032294|然后写了这个方法：|1032295|public+boolean+isSoftKeyboardShown(InputMethodManager+imm,+View+v)+{
++++
++++IMMResult+result+=+new+IMMResult();
++++int+res;
++++
++++imm.showSoftInput(v,+0,+result);

++++//+if+keyboard+doesn't+change,+handle+the+keypress
++++res+=+result.getResult();
++++if+(res+==+InputMethodManager.RESULT_UNCHANGED_SHOWN+%7C%7C
++++++++++++res+==+InputMethodManager.RESULT_UNCHANGED_HIDDEN)+{

++++++++return+true;
++++}
++++else
++++++++return+false;

}|1032296|然后，您可以使用此命令测试可能已打开软键盘的所有字段(EditText、AutoCompleteTextView等)：|1032297|++++InputMethodManager+imm+=+(InputMethodManager)+getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
++++if(isSoftKeyboardShown(imm,+editText1)+%7C+isSoftKeyboardShown(imm,+autocompletetextview1))
++++++++//close+the+softkeyboard
++++++++imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,+0);|1032298|另外，这不是一个理想的解决方案，但它可以完成这项工作。|1032299|entityMap|0|LINK|mutability|MUTABLE|url|https://rogerkeays.com/how-to-check-if-the-software-keyboard-is-shown-in-android^0|A|28|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|18|8|@]|9|@]|C|$G|H]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

I used this as a basis: <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>
<pre><code>/**
* To capture the result of IMM hide/show soft keyboard
*/
public class IMMResult extends ResultReceiver {
 public int result = -1;
 public IMMResult() {
 super(null);
}

@Override 
public void onReceiveResult(int r, Bundle data) {
 result = r;
}

// poll result value for up to 500 milliseconds
public int getResult() {
 try {
 int sleep = 0;
 while (result == -1 &amp;&amp; sleep &lt; 500) {
 Thread.sleep(100);
 sleep += 100;
 }
 } catch (InterruptedException e) {
 Log.e(&quot;IMMResult&quot;, e.getMessage());
 }
 return result;
}
}
</code></pre>
Then wrote this method:
<pre><code>public boolean isSoftKeyboardShown(InputMethodManager imm, View v) {
 
 IMMResult result = new IMMResult();
 int res;
 
 imm.showSoftInput(v, 0, result);

 // if keyboard doesn't change, handle the keypress
 res = result.getResult();
 if (res == InputMethodManager.RESULT_UNCHANGED_SHOWN ||
 res == InputMethodManager.RESULT_UNCHANGED_HIDDEN) {

 return true;
 }
 else
 return false;

}
</code></pre>
You may then use this to test all fields (EditText, AutoCompleteTextView, etc) that may have opened a softkeyboard:
<pre><code> InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
 if(isSoftKeyboardShown(imm, editText1) | isSoftKeyboardShown(imm, autocompletetextview1))
 //close the softkeyboard
 imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
</code></pre>
Addmittely not an ideal solution, but it gets the job done.

blocks|key|1031934|text|可以使用showSoftInput()和hideSoftInput()的回调结果来检查键盘的状态。详细信息和示例代码，请访问|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1031935|https://rogerkeays.com/how-to-check-if-the-software-keyboard-is-shown-in-android|offset|length|1031936|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|28|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

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>

blocks|key|1032021|text|你可以参考这个答案--+https://stackoverflow.com/a/24105062/3629912|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1032022|它每次都对我起作用。|1032023|adb+shell+dumpsys+window+InputMethod+%7C+grep+"mHasSurface"|code-block|syntax|javascript|1032024|如果软件键盘可见，它将返回true。|1032025|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/24105062/3629912^0|C|18|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

You can refer to this answer - <a href="https://stackoverflow.com/a/24105062/3629912">https://stackoverflow.com/a/24105062/3629912</a>

It worked for me everytime.

<pre><code>adb shell dumpsys window InputMethod | grep "mHasSurface"
</code></pre>

It will return true, if software keyboard is visible.

blocks|key|817850|text|如果您需要检查键盘状态，这应该会起作用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|817851|fun+Activity.isKeyboardOpened():+Boolean+{
++++val+r+=+Rect()

++++val+activityRoot+=+getActivityRoot()
++++val+visibleThreshold+=+dip(UiUtils.KEYBOARD_VISIBLE_THRESHOLD_DP)

++++activityRoot.getWindowVisibleDisplayFrame(r)

++++val+heightDiff+=+activityRoot.rootView.height+-+r.height()

++++return+heightDiff+>+visibleThreshold;
}

fun+Activity.getActivityRoot():+View+{
++++return+(findViewById<ViewGroup>(android.R.id.content)).getChildAt(0);
}|code-block|syntax|javascript|817852|其中UiUtils.KEYBOARD_VISIBLE_THRESHOLD_DP+=+100，dip()是一个用于转换dpToPx的anko函数：|offset|length|style|CODE|817853|fun+dip(value:+Int):+Int+{
++++return+(value+*+Resources.getSystem().displayMetrics.density).toInt()
}|817854|entityMap^0|0|0|2|11|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This should work if you need to check keyboard status:

<pre><code>fun Activity.isKeyboardOpened(): Boolean {
 val r = Rect()

 val activityRoot = getActivityRoot()
 val visibleThreshold = dip(UiUtils.KEYBOARD_VISIBLE_THRESHOLD_DP)

 activityRoot.getWindowVisibleDisplayFrame(r)

 val heightDiff = activityRoot.rootView.height - r.height()

 return heightDiff &gt; visibleThreshold;
}

fun Activity.getActivityRoot(): View {
 return (findViewById&lt;ViewGroup&gt;(android.R.id.content)).getChildAt(0);
}
</code></pre>

Where <code>UiUtils.KEYBOARD_VISIBLE_THRESHOLD_DP</code> = 100 and dip() is an anko func that convert dpToPx:

<pre><code>fun dip(value: Int): Int {
 return (value * Resources.getSystem().displayMetrics.density).toInt()
}
</code></pre>

blocks|key|1033147|text|现在终于有了一种直接从基于Kotlin的Android+R开始的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1033148|+val+imeInsets+=+requireView().rootWindowInsets.isVisible(WindowsInsetsCompat.Type.ime())+
++++if+(imeInsets)+{+
+++++//Ime+is+visible
+++++//Lets+move+our+view+by+the+height+of+the+IME
+++++view.translationX+=+imeInsets.bottom+}|code-block|syntax|javascript|1033149|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There's finally a direct way starting from Android R based on Kotlin now.
<pre><code> val imeInsets = requireView().rootWindowInsets.isVisible(WindowsInsetsCompat.Type.ime()) 
 if (imeInsets) { 
 //Ime is visible
 //Lets move our view by the height of the IME
 view.translationX = imeInsets.bottom }
</code></pre>

blocks|key|817127|text|为此，我设置了一个GlobalLayoutListener，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|817128|final+View+activityRootView+=+findViewById(R.id.activityRoot);
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|817129|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I did this by setting a GlobalLayoutListener, as follows:

<pre><code>final View activityRootView = findViewById(R.id.activityRoot);
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>

blocks|key|1032150|text|试试这段代码，它真的很有效，如果显示了KeyboardShown，则此函数返回真值...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1032151|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+?+"+%2B+isKeyboardShown+%2B+",+heightDiff:"+%2B+heightDiff+%2B+",+density:"+%2B+dm.density
++++++++++++%2B+"root+view+height:"+%2B+rootView.getHeight()+%2B+",+rect:"+%2B+r);

++++return+isKeyboardShown;
}|code-block|syntax|javascript|1032152|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try this code it's really working if KeyboardShown is Shown then this function return true value....

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

blocks|key|818354|text|基于@bohdan-oliynyk的答案的更紧凑的Kotlin版本|type|unstyled|depth|inlineStyleRanges|entityRanges|data|818355|private+const+val+KEYBOARD_VISIBLE_THRESHOLD_DP+=+100

fun+Activity.isKeyboardOpen():+Boolean+{
++++fun+convertDpToPx(value:+Int):+Int+=
++++++++(value+*+Resources.getSystem().displayMetrics.density).toInt()

++++val+rootView+=+findViewById<View>(android.R.id.content)
++++val+visibleThreshold+=+Rect()
++++rootView.getWindowVisibleDisplayFrame(visibleThreshold)
++++val+heightDiff+=+rootView.height+-+visibleThreshold.height()

++++val+accessibleValue+=+convertDpToPx(KEYBOARD_VISIBLE_THRESHOLD_DP)

++++return+heightDiff+>+accessibleValue
}

fun+Activity.isKeyboardClosed():+Boolean+{
++++return+isKeyboardOpen().not()
}|code-block|syntax|javascript|818356|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A little bit more compacted Kotlin version based on the answer of @bohdan-oliynyk
<pre><code>private const val KEYBOARD_VISIBLE_THRESHOLD_DP = 100

fun Activity.isKeyboardOpen(): Boolean {
 fun convertDpToPx(value: Int): Int =
 (value * Resources.getSystem().displayMetrics.density).toInt()

 val rootView = findViewById&lt;View&gt;(android.R.id.content)
 val visibleThreshold = Rect()
 rootView.getWindowVisibleDisplayFrame(visibleThreshold)
 val heightDiff = rootView.height - visibleThreshold.height()

 val accessibleValue = convertDpToPx(KEYBOARD_VISIBLE_THRESHOLD_DP)

 return heightDiff &gt; accessibleValue
}

fun Activity.isKeyboardClosed(): Boolean {
 return isKeyboardOpen().not()
}
</code></pre>

blocks|key|817451|text|在Android中，您可以通过ADB+shell进行检测。我编写并使用了这个方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|817452|{
++++++++JSch+jsch+=+new+JSch();
++++++++try+{
++++++++++++Session+session+=+jsch.getSession("<userName>",+"<IP>",+22);
++++++++++++session.setPassword("<Password>");
++++++++++++Properties+config+=+new+Properties();
++++++++++++config.put("StrictHostKeyChecking",+"no");
++++++++++++session.setConfig(config);
++++++++++++session.connect();

++++++++++++ChannelExec+channel+=+(ChannelExec)session.openChannel("exec");
++++++++++++BufferedReader+in+=+new+BufferedReader(new++++
++++++++++++InputStreamReader(channel.getInputStream()));
++++++++++++channel.setCommand("C:/Android/android-sdk/platform-tools/adb+shell+dumpsys+window+
++++++++++++InputMethod+%7C+findstr+\"mHasSurface\"");
++++++++++++channel.connect();

++++++++++++String+msg+=+null;
++++++++++++String+msg2+=+"+mHasSurface=true";

++++++++++++while+((msg+=+in.readLine())+!=+null)+{
++++++++++++++++Boolean+isContain+=+msg.contains(msg2);
++++++++++++++++log.info(isContain);
++++++++++++++++if+(isContain){
++++++++++++++++++++log.info("Hiding+keyboard...");
++++++++++++++++++++driver.hideKeyboard();
++++++++++++++++}
++++++++++++++++else+{
++++++++++++++++++++log.info("No+need+to+hide+keyboard.");
++++++++++++++++}
++++++++++++}

++++++++++++channel.disconnect();
++++++++++++session.disconnect();

++++++++}+catch+(JSchException+%7C+IOException+%7C+InterruptedException+e)+{
++++++++++++e.printStackTrace();
++++++++}
++++}
}|code-block|syntax|javascript|817453|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In Android you can detect through ADB shell. I wrote and use this method:

<pre><code>{
 JSch jsch = new JSch();
 try {
 Session session = jsch.getSession("&lt;userName&gt;", "&lt;IP&gt;", 22);
 session.setPassword("&lt;Password&gt;");
 Properties config = new Properties();
 config.put("StrictHostKeyChecking", "no");
 session.setConfig(config);
 session.connect();

 ChannelExec channel = (ChannelExec)session.openChannel("exec");
 BufferedReader in = new BufferedReader(new 
 InputStreamReader(channel.getInputStream()));
 channel.setCommand("C:/Android/android-sdk/platform-tools/adb shell dumpsys window 
 InputMethod | findstr \"mHasSurface\"");
 channel.connect();

 String msg = null;
 String msg2 = " mHasSurface=true";

 while ((msg = in.readLine()) != null) {
 Boolean isContain = msg.contains(msg2);
 log.info(isContain);
 if (isContain){
 log.info("Hiding keyboard...");
 driver.hideKeyboard();
 }
 else {
 log.info("No need to hide keyboard.");
 }
 }

 channel.disconnect();
 session.disconnect();

 } catch (JSchException | IOException | InterruptedException e) {
 e.printStackTrace();
 }
 }
}
</code></pre>

blocks|key|817546|text|final+View+activityRootView+=+findViewById(R.id.rootlayout);
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new+ViewTreeObserver.OnGlobalLayoutListener()+{
++++++++@Override
++++++++public+void+onGlobalLayout()+{

++++++++++++Rect+r+=+new+Rect();
++++++++++++activityRootView.getWindowVisibleDisplayFrame(r);

++++++++++++int+screenHeight+=+activityRootView.getRootView().getHeight();
++++++++++++Log.e("screenHeight",+String.valueOf(screenHeight));
++++++++++++int+heightDiff+=+screenHeight+-+(r.bottom+-+r.top);
++++++++++++Log.e("heightDiff",+String.valueOf(heightDiff));
++++++++++++boolean+visible+=+heightDiff+>+screenHeight+/+3;
++++++++++++Log.e("visible",+String.valueOf(visible));
++++++++++++if+(visible)+{
++++++++++++++++Toast.makeText(LabRegister.this,+"I+am+here+1",+Toast.LENGTH_SHORT).show();
++++++++++++}+else+{
++++++++++++++++Toast.makeText(LabRegister.this,+"I+am+here+2",+Toast.LENGTH_SHORT).show();
++++++++++++}
++++++++}
});|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|817547|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>final View activityRootView = findViewById(R.id.rootlayout);
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
 @Override
 public void onGlobalLayout() {

 Rect r = new Rect();
 activityRootView.getWindowVisibleDisplayFrame(r);

 int screenHeight = activityRootView.getRootView().getHeight();
 Log.e("screenHeight", String.valueOf(screenHeight));
 int heightDiff = screenHeight - (r.bottom - r.top);
 Log.e("heightDiff", String.valueOf(heightDiff));
 boolean visible = heightDiff &gt; screenHeight / 3;
 Log.e("visible", String.valueOf(visible));
 if (visible) {
 Toast.makeText(LabRegister.this, "I am here 1", Toast.LENGTH_SHORT).show();
 } else {
 Toast.makeText(LabRegister.this, "I am here 2", Toast.LENGTH_SHORT).show();
 }
 }
});
</code></pre>

blocks|key|817746|text|@iWantScala的答案很棒，但不适合我|type|unstyled|depth|inlineStyleRanges|entityRanges|data|817747|rootView.getRootView().getHeight()始终具有相同的值|offset|length|style|CODE|817748|一种方法是定义两个var|817749|private+int+maxRootViewHeight+=+0;
private+int+currentRootViewHeight+=+0;|code-block|syntax|javascript|817750|添加全局监听器|817751|rootView.getViewTreeObserver()
++++.addOnGlobalLayoutListener(new+ViewTreeObserver.OnGlobalLayoutListener()+{
++++++++@Override
++++++++public+void+onGlobalLayout()+{
++++++++++++currentRootViewHeight+=+rootView.getHeight();
++++++++++++if+(currentRootViewHeight+>+maxRootViewHeight)+{
++++++++++++++++maxRootViewHeight+=+currentRootViewHeight;
++++++++++++}
++++++++}
++++});|817752|然后勾选|817753|if+(currentRootViewHeight+>=+maxRootViewHeight)+{
++++//+Keyboard+is+hidden
}+else+{
++++//+Keyboard+is+shown
}|817754|工作正常|817755|entityMap^0|0|0|Y|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@$D|12|E|13|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|14|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|15|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|17|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|L|7|19|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

Answer of @iWantScala is great but not working for me 
<code>rootView.getRootView().getHeight()</code> always has the same value

one way is to define two vars

<pre><code>private int maxRootViewHeight = 0;
private int currentRootViewHeight = 0;
</code></pre>

add global listener

<pre><code>rootView.getViewTreeObserver()
 .addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
 @Override
 public void onGlobalLayout() {
 currentRootViewHeight = rootView.getHeight();
 if (currentRootViewHeight &gt; maxRootViewHeight) {
 maxRootViewHeight = currentRootViewHeight;
 }
 }
 });
</code></pre>

then check

<pre><code>if (currentRootViewHeight &gt;= maxRootViewHeight) {
 // Keyboard is hidden
} else {
 // Keyboard is shown
}
</code></pre>

works fine

blocks|key|816942|text|我也遇到过类似的问题。我需要对屏幕上的Enter按钮做出反应(它隐藏了键盘)。在这种情况下，您可以订阅键盘打开时所使用的文本视图的OnEditorAction+-如果您有多个可编辑框，则订阅所有框。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|816943|在您的活动中，您可以完全控制键盘，因此，如果您收听所有的打开和关闭事件，则无论键盘是否打开，您都不会遇到任何问题。|816944|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I had a similar problem. I needed to react to the Enter button on screen (which hid the keyboard). In this case you can subscribe to the OnEditorAction of the text view the keyboard was opend with - if you have multiple editable boxes, then subscribe to all of them.

In your Activity you have full control of the keyboard, so at no point will you face the problem whether the keyboard is opened or not, if you listen to all opening and closing events.

blocks|key|1032088|text|有一个直接的方法来找出这一点。而且，它不需要更改布局。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1032089|所以它也可以在全屏模式下工作。|1032090|但是，不幸的是，它并不能在所有设备上工作。所以你必须用你的设备来测试它。|1032091|诀窍是您尝试隐藏或显示软键盘，并捕获该尝试的结果。|1032092|如果它工作正常，则键盘不会真正显示或隐藏。我们只要求州政府。|1032093|要保持最新，您只需使用Handler重复此操作，例如每200毫秒一次。|1032094|下面的实现只做了一次检查。|1032095|如果执行多项检查，则应启用所有(_keyboardVisible)测试。|1032096|public+interface+OnKeyboardShowHide
{
++++void++++onShowKeyboard(+Object+param+);
++++void++++onHideKeyboard(+Object+param+);
}

private+static+Handler++++++_keyboardHandler++++=+new+Handler();
private+boolean+++++++++++++_keyboardVisible++++=+false;
private+OnKeyboardShowHide++_keyboardCallback;
private+Object++++++++++++++_keyboardCallbackParam;

public+void+start(+OnKeyboardShowHide+callback,+Object+callbackParam+)
{
++++_keyboardCallback++++++=+callback;
++++_keyboardCallbackParam+=+callbackParam;
++++//
++++View+view+=+getCurrentFocus();
++++if+(view+!=+null)
++++{
++++++++InputMethodManager+imm+=+(InputMethodManager)+getSystemService(+Activity.INPUT_METHOD_SERVICE+);
++++++++imm.hideSoftInputFromWindow(+view.getWindowToken(),+InputMethodManager.HIDE_IMPLICIT_ONLY,+_keyboardResultReceiver+);
++++++++imm.showSoftInput(+view,+InputMethodManager.SHOW_IMPLICIT,+_keyboardResultReceiver+);
++++}
++++else+//+if+(_keyboardVisible)
++++{
++++++++_keyboardVisible+=+false;
++++++++_keyboardCallback.onHideKeyboard(+_keyboardCallbackParam+);
++++}
}

private+ResultReceiver++++++_keyboardResultReceiver+=+new+ResultReceiver(+_keyboardHandler+)
{
++++@Override
++++protected+void+onReceiveResult(+int+resultCode,+Bundle+resultData+)
++++{
++++++++switch+(resultCode)
++++++++{
++++++++++++case+InputMethodManager.RESULT_SHOWN+:
++++++++++++case+InputMethodManager.RESULT_UNCHANGED_SHOWN+:
++++++++++++++++//+if+(!_keyboardVisible)
++++++++++++++++{
++++++++++++++++++++_keyboardVisible+=+true;
++++++++++++++++++++_keyboardCallback.onShowKeyboard(+_keyboardCallbackParam+);
++++++++++++++++}
++++++++++++++++break;
++++++++++++case+InputMethodManager.RESULT_HIDDEN+:
++++++++++++case+InputMethodManager.RESULT_UNCHANGED_HIDDEN+:
++++++++++++++++//+if+(_keyboardVisible)
++++++++++++++++{
++++++++++++++++++++_keyboardVisible+=+false;
++++++++++++++++++++_keyboardCallback.onHideKeyboard(+_keyboardCallbackParam+);
++++++++++++++++}
++++++++++++++++break;
++++++++}
++++}
};|code-block|syntax|javascript|1032097|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|11|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|12|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|13|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|14|8|@]|9|@]|A|$S|T]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

There is a direct method to find this out. And, it does not require the layout changes. 
So it works in immersive fullscreen mode, too. 
But, unfortunately, it does not work on all devices. So you have to test it with your device(s). 
 
The trick is that you try to hide or show the soft keyboard and capture the result of that try. 
If it works correct then the keyboard is not really shown or hidden. We just ask for the state. 
 
To stay up-to-date, you simply repeat this operation, e.g. every 200 milliseconds, using a Handler. 
 
The implementation below does just a single check. 
If you do multiple checks, then you should enable all the (_keyboardVisible) tests.

<pre><code>public interface OnKeyboardShowHide
{
 void onShowKeyboard( Object param );
 void onHideKeyboard( Object param );
}

private static Handler _keyboardHandler = new Handler();
private boolean _keyboardVisible = false;
private OnKeyboardShowHide _keyboardCallback;
private Object _keyboardCallbackParam;

public void start( OnKeyboardShowHide callback, Object callbackParam )
{
 _keyboardCallback = callback;
 _keyboardCallbackParam = callbackParam;
 //
 View view = getCurrentFocus();
 if (view != null)
 {
 InputMethodManager imm = (InputMethodManager) getSystemService( Activity.INPUT_METHOD_SERVICE );
 imm.hideSoftInputFromWindow( view.getWindowToken(), InputMethodManager.HIDE_IMPLICIT_ONLY, _keyboardResultReceiver );
 imm.showSoftInput( view, InputMethodManager.SHOW_IMPLICIT, _keyboardResultReceiver );
 }
 else // if (_keyboardVisible)
 {
 _keyboardVisible = false;
 _keyboardCallback.onHideKeyboard( _keyboardCallbackParam );
 }
}

private ResultReceiver _keyboardResultReceiver = new ResultReceiver( _keyboardHandler )
{
 @Override
 protected void onReceiveResult( int resultCode, Bundle resultData )
 {
 switch (resultCode)
 {
 case InputMethodManager.RESULT_SHOWN :
 case InputMethodManager.RESULT_UNCHANGED_SHOWN :
 // if (!_keyboardVisible)
 {
 _keyboardVisible = true;
 _keyboardCallback.onShowKeyboard( _keyboardCallbackParam );
 }
 break;
 case InputMethodManager.RESULT_HIDDEN :
 case InputMethodManager.RESULT_UNCHANGED_HIDDEN :
 // if (_keyboardVisible)
 {
 _keyboardVisible = false;
 _keyboardCallback.onHideKeyboard( _keyboardCallbackParam );
 }
 break;
 }
 }
};
</code></pre>

blocks|key|1032754|text|我将答案转换为kotlin，希望这对kotlin用户有所帮助。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1032755|private+fun+checkKeyboardVisibility()+{
++++var+isKeyboardShowing+=+false

++++binding.coordinator.viewTreeObserver.addOnGlobalLayoutListener+{
++++++++val+r+=+Rect()
++++++++binding.coordinator.getWindowVisibleDisplayFrame(r)
++++++++val+screenHeight+=+binding.coordinator.rootView.height

++++++++//+r.bottom+is+the+position+above+soft+keypad+or+device+button.
++++++++//+if+keypad+is+shown,+the+r.bottom+is+smaller+than+that+before.
++++++++val+keypadHeight+=+screenHeight+-+r.bottom


++++++++if+(keypadHeight+>+screenHeight+*+0.15)+{+//+0.15+ratio+is+perhaps+enough+to+determine+keypad+height.
++++++++++++//+keyboard+is+opened
++++++++++++if+(!isKeyboardShowing)+{
++++++++++++++++isKeyboardShowing+=+true

++++++++++++}
++++++++}+else+{
++++++++++++//+keyboard+is+closed
++++++++++++if+(isKeyboardShowing)+{
++++++++++++++++isKeyboardShowing+=+false

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

I converted the answer to the kotlin, hope this helps for kotlin users. 

<pre><code>private fun checkKeyboardVisibility() {
 var isKeyboardShowing = false

 binding.coordinator.viewTreeObserver.addOnGlobalLayoutListener {
 val r = Rect()
 binding.coordinator.getWindowVisibleDisplayFrame(r)
 val screenHeight = binding.coordinator.rootView.height

 // r.bottom is the position above soft keypad or device button.
 // if keypad is shown, the r.bottom is smaller than that before.
 val keypadHeight = screenHeight - r.bottom


 if (keypadHeight &gt; screenHeight * 0.15) { // 0.15 ratio is perhaps enough to determine keypad height.
 // keyboard is opened
 if (!isKeyboardShowing) {
 isKeyboardShowing = true

 }
 } else {
 // keyboard is closed
 if (isKeyboardShowing) {
 isKeyboardShowing = false

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

blocks|key|1033216|text|如果你在你的应用中支持AndroidR的apis，那么你可以使用下面的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1033217|In+kotlin+:
++++var+imeInsets+=+view.rootWindowInsets.getInsets(Type.ime())+
++++if+(imeInsets.isVisible)+{+
++++++++view.translationX+=+imeInsets.bottom+
++++}|code-block|syntax|javascript|1033218|注意:这只适用于AndroidR，下面的安卓版本需要遵循一些其他的答案，否则我会为此更新它。|1033219|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you support apis for AndroidR in your app then you can use the below method. 

<pre><code>In kotlin :
 var imeInsets = view.rootWindowInsets.getInsets(Type.ime()) 
 if (imeInsets.isVisible) { 
 view.translationX = imeInsets.bottom 
 }
</code></pre>

Note: This is only available for the AndroidR and below android version needs to follow some of other answer or i will update it for that.

blocks|key|818264|text|它与活动和生命周期事件的adjustNothing标志一起工作。还有Kotlin：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|818265|/**
+*+This+class+uses+a+PopupWindow+to+calculate+the+window+height+when+the+floating+keyboard+is+opened+and+closed
+*
+*+@param+activity+The+parent+activity
+*++The+root+activity+that+uses+this+KeyboardManager
+*/
class+KeyboardManager(private+val+activity:+AppCompatActivity)+:+PopupWindow(activity),+LifecycleObserver+{

++++private+var+observerList+=+mutableListOf<((keyboardTop:+Int)+->+Unit)>()

++++/**+The+last+value+of+keyboardTop+*/
++++private+var+keyboardTop:+Int+=+0

++++/**+The+view+that+is+used+to+calculate+the+keyboard+top++*/
++++private+val+popupView:+View?

++++/**+The+parent+view++*/
++++private+var+parentView:+View

++++var+isKeyboardShown+=+false
++++++++private+set

++++/**
+++++*+Create+transparent+view+which+will+be+stretched+over+to+the+full+screen
+++++*/
++++private+fun+createFullScreenView():+View+{
++++++++val+view+=+LinearLayout(activity)
++++++++view.layoutParams+=+LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
++++++++++++++++ViewGroup.LayoutParams.MATCH_PARENT)
++++++++view.background+=+ColorDrawable(Color.TRANSPARENT)
++++++++return+view
++++}

++++init+{
++++++++this.popupView+=+createFullScreenView()
++++++++contentView+=+popupView

++++++++softInputMode+=+LayoutParams.SOFT_INPUT_ADJUST_RESIZE+or+LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE
++++++++inputMethodMode+=+INPUT_METHOD_NEEDED

++++++++parentView+=+activity.findViewById(android.R.id.content)

++++++++width+=+0
++++++++height+=+LayoutParams.MATCH_PARENT

++++++++popupView.viewTreeObserver.addOnGlobalLayoutListener+{
++++++++++++val+rect+=+Rect()
++++++++++++popupView.getWindowVisibleDisplayFrame(rect)

++++++++++++val+keyboardTop+=+rect.bottom
++++++++++++if+(this.keyboardTop+!=+keyboardTop)+{
++++++++++++++++isKeyboardShown+=+keyboardTop+<+this.keyboardTop
++++++++++++++++this.keyboardTop+=+keyboardTop
++++++++++++++++observerList.forEach+{+it(keyboardTop)+}
++++++++++++}
++++++++}
++++++++activity.lifecycle.addObserver(this)
++++}

++++/**
+++++*+This+must+be+called+after+the+onResume+of+the+Activity+or+inside+view.post+{+}+.
+++++*+PopupWindows+are+not+allowed+to+be+registered+before+the+onResume+has+finished
+++++*+of+the+Activity
+++++*/
++++@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
++++fun+start()+{
++++++++parentView.post+{
++++++++++++if+(!isShowing+&&+parentView.windowToken+!=+null)+{
++++++++++++++++setBackgroundDrawable(ColorDrawable(0))
++++++++++++++++showAtLocation(parentView,+Gravity.NO_GRAVITY,+0,+0)
++++++++++++}
++++++++}
++++}

++++/**
+++++*+This+manager+will+not+be+used+anymore
+++++*/
++++@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
++++fun+close()+{
++++++++activity.lifecycle.removeObserver(this)
++++++++observerList.clear()
++++++++dismiss()
++++}

++++/**
+++++*+Set+the+keyboard+top+observer.+The+observer+will+be+notified+when+the+keyboard+top+has+changed.
+++++*+For+example+when+the+keyboard+is+opened+or+closed
+++++*
+++++*+@param+observer+The+observer+to+be+added+to+this+provider
+++++*/
++++fun+registerKeyboardTopObserver(observer:+(keyboardTop:+Int)+->+Unit)+{
++++++++observerList.add(observer)
++++}
}|code-block|syntax|javascript|818266|将视图始终保持在键盘上方的有用方法|818267|fun+KeyboardManager.updateBottomMarginIfKeyboardShown(
++++++++view:+View,
++++++++activity:+AppCompatActivity,
++++++++//+marginBottom+of+view+when+keyboard+is+hide
++++++++marginBottomHideKeyboard:+Int,
++++++++//+marginBottom+of+view+when+keybouard+is+shown
++++++++marginBottomShowKeyboard:+Int
)+{
++++registerKeyboardTopObserver+{+bottomKeyboard+->
++++++++val+bottomView+=+ViewUtils.getFullViewBounds(view).bottom
++++++++val+maxHeight+=+ScreenUtils.getFullScreenSize(activity.windowManager).y
++++++++//+Check+that+view+is+within+the+window+size
++++++++if+(bottomView+<+maxHeight)+{
++++++++++++if+(bottomKeyboard+<+bottomView)+{
++++++++++++++++ViewUtils.updateMargin(view,+bottomMargin+=+bottomView+-+bottomKeyboard+%2B
++++++++++++++++++++++++view.marginBottom+%2B+marginBottomShowKeyboard)
++++++++++++}+else+ViewUtils.updateMargin(view,+bottomMargin+=+marginBottomHideKeyboard)
++++++++}
++++}
}|818268|Where+getFullViewBounds|818269|fun+getLocationOnScreen(view:+View):+Point+{
++++val+location+=+IntArray(2)
++++view.getLocationOnScreen(location)
++++return+Point(location[0],+location[1])
}

fun+getFullViewBounds(view:+View):+Rect+{
+++++val+location+=+getLocationOnScreen(view)
+++++return+Rect(location.x,+location.y,+location.x+%2B+view.width,
++++++++++++location.y+%2B+view.height)
+}|818270|Where+getFullScreenSize|818271|fun+getFullScreenSize(wm:+WindowManager?+=+null)+=
++++++++++++getScreenSize(wm)+{+getRealSize(it)+}

private+fun+getScreenSize(wm:+WindowManager?+=+null,+block:+Display.(Point)+->+Unit):+Point+{
++++val+windowManager+=+wm+?:+App.INSTANCE.getSystemService(Context.WINDOW_SERVICE)
++++++++++++as+WindowManager
++++val+point+=+Point()
++++windowManager.defaultDisplay.block(point)
++++return+point
}|818272|Where+updateMargin|818273|fun+updateMargin(
++++++++view:+View,
++++++++leftMargin:+Int?+=+null,
++++++++topMargin:+Int?+=+null,
++++++++rightMargin:+Int?+=+null,
++++++++bottomMargin:+Int?+=+null
)+{
++++val+layoutParams+=+view.layoutParams+as+ViewGroup.MarginLayoutParams
++++if+(leftMargin+!=+null)+layoutParams.leftMargin+=+leftMargin
++++if+(topMargin+!=+null)+layoutParams.topMargin+=+topMargin
++++if+(rightMargin+!=+null)+layoutParams.rightMargin+=+rightMargin
++++if+(bottomMargin+!=+null)+layoutParams.bottomMargin+=+bottomMargin
++++view.layoutParams+=+layoutParams
}|818274|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

It works with adjustNothing flag of activity and lifecycle events are used. Also with Kotlin: 

<pre><code>/**
 * This class uses a PopupWindow to calculate the window height when the floating keyboard is opened and closed
 *
 * @param activity The parent activity
 * The root activity that uses this KeyboardManager
 */
class KeyboardManager(private val activity: AppCompatActivity) : PopupWindow(activity), LifecycleObserver {

 private var observerList = mutableListOf&lt;((keyboardTop: Int) -&gt; Unit)&gt;()

 /** The last value of keyboardTop */
 private var keyboardTop: Int = 0

 /** The view that is used to calculate the keyboard top */
 private val popupView: View?

 /** The parent view */
 private var parentView: View

 var isKeyboardShown = false
 private set

 /**
 * Create transparent view which will be stretched over to the full screen
 */
 private fun createFullScreenView(): View {
 val view = LinearLayout(activity)
 view.layoutParams = LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
 ViewGroup.LayoutParams.MATCH_PARENT)
 view.background = ColorDrawable(Color.TRANSPARENT)
 return view
 }

 init {
 this.popupView = createFullScreenView()
 contentView = popupView

 softInputMode = LayoutParams.SOFT_INPUT_ADJUST_RESIZE or LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE
 inputMethodMode = INPUT_METHOD_NEEDED

 parentView = activity.findViewById(android.R.id.content)

 width = 0
 height = LayoutParams.MATCH_PARENT

 popupView.viewTreeObserver.addOnGlobalLayoutListener {
 val rect = Rect()
 popupView.getWindowVisibleDisplayFrame(rect)

 val keyboardTop = rect.bottom
 if (this.keyboardTop != keyboardTop) {
 isKeyboardShown = keyboardTop &lt; this.keyboardTop
 this.keyboardTop = keyboardTop
 observerList.forEach { it(keyboardTop) }
 }
 }
 activity.lifecycle.addObserver(this)
 }

 /**
 * This must be called after the onResume of the Activity or inside view.post { } .
 * PopupWindows are not allowed to be registered before the onResume has finished
 * of the Activity
 */
 @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
 fun start() {
 parentView.post {
 if (!isShowing &amp;&amp; parentView.windowToken != null) {
 setBackgroundDrawable(ColorDrawable(0))
 showAtLocation(parentView, Gravity.NO_GRAVITY, 0, 0)
 }
 }
 }

 /**
 * This manager will not be used anymore
 */
 @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
 fun close() {
 activity.lifecycle.removeObserver(this)
 observerList.clear()
 dismiss()
 }

 /**
 * Set the keyboard top observer. The observer will be notified when the keyboard top has changed.
 * For example when the keyboard is opened or closed
 *
 * @param observer The observer to be added to this provider
 */
 fun registerKeyboardTopObserver(observer: (keyboardTop: Int) -&gt; Unit) {
 observerList.add(observer)
 }
}
</code></pre>

Useful method to keep view always above the keyboard

<pre><code>fun KeyboardManager.updateBottomMarginIfKeyboardShown(
 view: View,
 activity: AppCompatActivity,
 // marginBottom of view when keyboard is hide
 marginBottomHideKeyboard: Int,
 // marginBottom of view when keybouard is shown
 marginBottomShowKeyboard: Int
) {
 registerKeyboardTopObserver { bottomKeyboard -&gt;
 val bottomView = ViewUtils.getFullViewBounds(view).bottom
 val maxHeight = ScreenUtils.getFullScreenSize(activity.windowManager).y
 // Check that view is within the window size
 if (bottomView &lt; maxHeight) {
 if (bottomKeyboard &lt; bottomView) {
 ViewUtils.updateMargin(view, bottomMargin = bottomView - bottomKeyboard +
 view.marginBottom + marginBottomShowKeyboard)
 } else ViewUtils.updateMargin(view, bottomMargin = marginBottomHideKeyboard)
 }
 }
}
</code></pre>

Where getFullViewBounds

<pre><code>fun getLocationOnScreen(view: View): Point {
 val location = IntArray(2)
 view.getLocationOnScreen(location)
 return Point(location[0], location[1])
}

fun getFullViewBounds(view: View): Rect {
 val location = getLocationOnScreen(view)
 return Rect(location.x, location.y, location.x + view.width,
 location.y + view.height)
 }
</code></pre>

Where getFullScreenSize

<pre><code>fun getFullScreenSize(wm: WindowManager? = null) =
 getScreenSize(wm) { getRealSize(it) }

private fun getScreenSize(wm: WindowManager? = null, block: Display.(Point) -&gt; Unit): Point {
 val windowManager = wm ?: App.INSTANCE.getSystemService(Context.WINDOW_SERVICE)
 as WindowManager
 val point = Point()
 windowManager.defaultDisplay.block(point)
 return point
}
</code></pre>

Where updateMargin

<pre><code>fun updateMargin(
 view: View,
 leftMargin: Int? = null,
 topMargin: Int? = null,
 rightMargin: Int? = null,
 bottomMargin: Int? = null
) {
 val layoutParams = view.layoutParams as ViewGroup.MarginLayoutParams
 if (leftMargin != null) layoutParams.leftMargin = leftMargin
 if (topMargin != null) layoutParams.topMargin = topMargin
 if (rightMargin != null) layoutParams.rightMargin = rightMargin
 if (bottomMargin != null) layoutParams.bottomMargin = bottomMargin
 view.layoutParams = layoutParams
}
</code></pre>

blocks|key|1033477|text|感谢所有的答案，我根据自己的情况想出了答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1033478|/**
+*+Add+global+layout+listener+to+observe+system+keyboard+visibility
+*/
private+void+initObserverForSystemKeyboardVisibility()+{
++++getRootView().getViewTreeObserver().addOnGlobalLayoutListener(new+ViewTreeObserver.OnGlobalLayoutListener()+{
++++++++@Override
++++++++public+void+onGlobalLayout()+{
++++++++++++//Add+your+own+code+here
++++++++++++Log.d("TEST_CODE",+"isSystemKeyboardVisible:"+%2B+isSystemKeyboardVisible())
++++++++}
++++});
}


/**
+*+Check+system+keyboard+visibility
+*+@return+true+if+visible
+*/
public+boolean+isSystemKeyboardVisible()+{
++++try+{
++++++++final+InputMethodManager+manager+=+(InputMethodManager)+getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
++++++++final+Method+windowHeightMethod+=+InputMethodManager.class.getMethod("getInputMethodWindowVisibleHeight");
++++++++final+int+height+=+(int)+windowHeightMethod.invoke(manager);
++++++++return+height+>+0;
++++}+catch+(Exception+e)+{
++++++++return+false;
++++}
}|code-block|syntax|javascript|1033479|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Thanks all answers, I figure it out for my own circumstances
<pre><code>/**
 * Add global layout listener to observe system keyboard visibility
 */
private void initObserverForSystemKeyboardVisibility() {
 getRootView().getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
 @Override
 public void onGlobalLayout() {
 //Add your own code here
 Log.d(&quot;TEST_CODE&quot;, &quot;isSystemKeyboardVisible:&quot; + isSystemKeyboardVisible())
 }
 });
}


/**
 * Check system keyboard visibility
 * @return true if visible
 */
public boolean isSystemKeyboardVisible() {
 try {
 final InputMethodManager manager = (InputMethodManager) getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
 final Method windowHeightMethod = InputMethodManager.class.getMethod(&quot;getInputMethodWindowVisibleHeight&quot;);
 final int height = (int) windowHeightMethod.invoke(manager);
 return height &gt; 0;
 } catch (Exception e) {
 return false;
 }
}
</code></pre>

blocks|key|818449|text|private+fun+isKeyboardVisible(rootView:+View)+=
++++ViewCompat.getRootWindowInsets(rootView)!!.isVisible(WindowInsetsCompat.Type.ime())|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|818450|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>private fun isKeyboardVisible(rootView: View) =
 ViewCompat.getRootWindowInsets(rootView)!!.isVisible(WindowInsetsCompat.Type.ime())
</code></pre>

blocks|key|817337|text|我这样做如下，但只有当你的目标是关闭/打开键盘时，它才是相关的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|817338|关闭示例：(检查键盘是否已经关闭，如果没有-关闭)|817339|imm.showSoftInput(etSearch,+InputMethodManager.HIDE_IMPLICIT_ONLY,+new+ResultReceiver(null)+{
++++++++++++++++++++@Override
++++++++++++++++++++protected+void+onReceiveResult(int+resultCode,+Bundle+resultData)+{
++++++++++++++++++++++++super.onReceiveResult(resultCode,+resultData);
++++++++++++++++++++++++if+(resultCode+!=+InputMethodManager.RESULT_UNCHANGED_HIDDEN)
++++++++++++++++++++++++++++imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,+0);
++++++++++++++++++++}
++++++++++++++++});|code-block|syntax|javascript|817340|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I did this as follows, but its relevet only if your goal is to close / open the keyboad.

close example: (checking if keyboard already closed, if not - closing)

<pre><code>imm.showSoftInput(etSearch, InputMethodManager.HIDE_IMPLICIT_ONLY, new ResultReceiver(null) {
 @Override
 protected void onReceiveResult(int resultCode, Bundle resultData) {
 super.onReceiveResult(resultCode, resultData);
 if (resultCode != InputMethodManager.RESULT_UNCHANGED_HIDDEN)
 imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
 }
 });
</code></pre>

blocks|key|817570|text|A可能正在使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|817571|@Override
public+void+onConfigurationChanged(Configuration+newConfig)+{
++++super.onConfigurationChanged(newConfig);

++++Log.d(
++++getClass().getSimpleName(),+
++++String.format("conf:+%25s",+newConfig));

++++if+(newConfig.hardKeyboardHidden+!=+hardKeyboardHidden)+{
++++++++onHardwareKeyboardChange(newConfig.hardKeyboardHidden);

++++++++hardKeyboardHidden+=+newConfig.hardKeyboardHidden;
++++}

++++if+(newConfig.keyboardHidden+!=+keyboardHidden)+{
++++++++onKeyboardChange(newConfig.keyboardHidden);

++++++++keyboardHidden+=+newConfig.hardKeyboardHidden;
++++}

}

public+static+final+int+KEYBOARDHIDDEN_UNDEFINED+=+0;
public+static+final+int+KEYBOARDHIDDEN_NO+=+1;
public+static+final+int+KEYBOARDHIDDEN_YES+=+2;
public+static+final+int+KEYBOARDHIDDEN_SOFT+=+3;

//todo
private+void+onKeyboardChange(int+keyboardHidden)+{

}

//todo
private+void+onHardwareKeyboardChange(int+hardKeyboardHidden)+{

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

a may be using : 

<pre><code>@Override
public void onConfigurationChanged(Configuration newConfig) {
 super.onConfigurationChanged(newConfig);

 Log.d(
 getClass().getSimpleName(), 
 String.format("conf: %s", newConfig));

 if (newConfig.hardKeyboardHidden != hardKeyboardHidden) {
 onHardwareKeyboardChange(newConfig.hardKeyboardHidden);

 hardKeyboardHidden = newConfig.hardKeyboardHidden;
 }

 if (newConfig.keyboardHidden != keyboardHidden) {
 onKeyboardChange(newConfig.keyboardHidden);

 keyboardHidden = newConfig.hardKeyboardHidden;
 }

}

public static final int KEYBOARDHIDDEN_UNDEFINED = 0;
public static final int KEYBOARDHIDDEN_NO = 1;
public static final int KEYBOARDHIDDEN_YES = 2;
public static final int KEYBOARDHIDDEN_SOFT = 3;

//todo
private void onKeyboardChange(int keyboardHidden) {

}

//todo
private void onHardwareKeyboardChange(int hardKeyboardHidden) {

}
</code></pre>

blocks|key|817984|text|我写了sample。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|817985|此存储库可以帮助检测键盘状态，而无需假设“键盘应大于屏幕的X部分”|817986|​|817987|📷|atomic|817988|817989|817990|817991|817992|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/vovaksenov99/AndroidInsetUsageSample|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/f8b74057bd0c104802ae986015fe5f35.png|imageAlt|2|https://ask.qcloudimg.com/http-save/yehe-900000/a2411f53132e3f95dc237d54b9584d51.png^0|3|6|0|0|0|0|0|1|1|0|0|0|0|1|2|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|19|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]]|C|$]]|$1|K|3|G|5|6|7|1E|8|@]|9|@]|C|$]]|$1|L|3|G|5|6|7|1F|8|@]|9|@]|C|$]]|$1|M|3|I|5|J|7|1G|8|@]|9|@$A|1H|B|1I|1|1J]]|C|$]]|$1|N|3|G|5|6|7|1K|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|1L|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|X|S|Y|C|$Z|10|11|-4]]|12|$5|X|S|Y|C|$Z|13|11|-4]]]]

I wrote <a href="https://github.com/vovaksenov99/AndroidInsetUsageSample" rel="nofollow noreferrer">sample</a>. 

This repository can help to detect keyboard status without assumption that "keyboard should be more than X part of screen"

<a href="https://i.stack.imgur.com/XwfCy.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/XwfCy.png" alt=""></a>

<a href="https://i.stack.imgur.com/7YGoV.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/7YGoV.png" alt=""></a>

blocks|key|818430|text|试试这个，对我来说很好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|818431|InputMethodManager+imm+=+(InputMethodManager)+getSystemService(Context.INPUT_METHOD_SERVICE);
++++if+(imm.isActive())
++++++++//Keyboard+is+active|code-block|syntax|javascript|818432|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try with this, working fine for me
<pre><code>InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
 if (imm.isActive())
 //Keyboard is active
</code></pre>

Is there a way in Android to detect if the software (a.k.a. "soft") keyboard is visible on screen?

How do I detect if software keyboard is visible on Android Device or not?

Android

Kotlin

在Android中是否有一种方法可以检测软件(也称为“软”)键盘在屏幕上可见？

问如何检测软件键盘在Android设备上是否可见？
EN

回答 27

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何检测软件键盘在Android设备上是否可见？EN

回答 27

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何检测软件键盘在Android设备上是否可见？
EN