一、自动弹出键盘或是自动不弹出

在进入界面时，有时会需要自动弹出键盘，实现方式如下：

    1. 在清单文件中设置android:windowSoftInputMode属性 ``` 在 AndroidManifest.xml文件中的activity节点下添加： android:windowSoftInputMode=”stateHidden|adjustPan”

stateVisibile:显示键盘 stateHidden：是隐藏软键盘的

adjustPan：是保证控件不会因为输入法的弹出而发生形变的。 adjustResize: 会因为弹出键盘调整布局

  2. - 2. 代码中调用 setSoftInputMode()方法进行设置

OnCreate方法里面加下面这句代码 ，很管用，而且再点EditBox也能让输入法正常弹出。。 getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

  1. <a name="7Qbeh"></a>
  2. ## 二、键盘遮挡布局处理
  3. <a name="MJCV3"></a>
  4. #### 2.1 对于非滚动布局
  6. - 如果设置了adjustResize，键盘会顶起整个界面
  8. 没有键盘时的界面：<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/1624725/1604849402465-13bc035c-5530-4916-a893-9693da935654.png#align=left&display=inline&height=493&margin=%5Bobject%20Object%5D&name=image.png&originHeight=986&originWidth=628&size=52663&status=done&style=none&width=314)<br />有了键盘后的界面：<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/1624725/1604849424905-97c166e2-ed53-49d3-8c65-13b1d9d8e32b.png#align=left&display=inline&height=510&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1020&originWidth=614&size=72580&status=done&style=none&width=307)<br />处理方法：<br />在没有滚动布局时，尽量设置不改动界面布局，在清单文件中设置adjustPan，保证布局完整性。
  9. <a name="z80OV"></a>
  10. ### 2.2 在滚动布局中时
  12. - 1. 无论设置了 adjustPan 或是 adjustResize,都可以做到顶起布局，键盘不会挡到输入的文字。但是效果却不一样，下面是 adjustPan的效果：
  14. ![image.png](https://cdn.nlark.com/yuque/0/2020/png/1624725/1605452047339-b291c87e-c3e5-480e-9c2b-ca5504fae52e.png#align=left&display=inline&height=521&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1042&originWidth=616&size=62985&status=done&style=none&width=308)<br />会将整个布局顶起。
  16. - 2. adjustResize 效果，不会顶起标题。
  18. ![image.png](https://cdn.nlark.com/yuque/0/2020/png/1624725/1605452683385-17a26bed-6e18-4b66-819c-8ccb30e01068.png#align=left&display=inline&height=523&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1046&originWidth=616&size=66100&status=done&style=none&width=308)
  19. <a name="Lcgng"></a>
  20. ## 三、封装工具的使用

showSoftInput : 显示软键盘 hideSoftInput : 隐藏软键盘 toggleSoftInput : 切换键盘显示与否状态 isSoftInputVisible : 判断软键盘是否可见 registerSoftInputChangedListener : 注册软键盘改变监听器 unregisterSoftInputChangedListener: 注销软键盘改变监听器 fixAndroidBug5497 : 修复安卓 5497 BUG fixSoftInputLeaks : 修复软键盘内存泄漏 clickBlankArea2HideSoftInput : 点击屏幕空白区域隐藏软键盘 setSoftInputAdjustNothing : 软键盘以覆盖当前界面的形式出现 setSoftInputAdjustResize : 软键盘以顶起当前界面的形式出现, 注意这种方式会使得当前布局的高度发生变化，触发当前布局onSizeChanged方法回调，这里前后高度差就是软键盘的高度了 setSoftInputAdjustPan : 软键盘以上推当前界面的形式出现, 注意这种方式不会改变布局的高度 onDisableBackKeyDown : 禁用物理返回键 dispatchTouchEvent : 点击屏幕空白区域隐藏软键盘

  1. KeyboardUtils:

package com.kiwilss.lutils.res

import android.R import android.app.Activity import android.app.Dialog import android.content.Context import android.graphics.Rect import android.os. import android.util.Log import android.view. import android.view.ViewTreeObserver.OnGlobalLayoutListener import android.view.inputmethod.InputMethodManager import android.widget.EditText import android.widget.FrameLayout import com.kiwilss.lutils.LUtilsConfig

/* @FileName: KeyboardUtils *@author : Lss kiwilss

  • @e-mail : kiwilss@163.com
  • @time : 2020/11/15

  • @desc : {DESCRIPTION} */ object KeyboardUtils { private var millis: Long = 0 private var sDecorViewDelta = 0 private const val TAG_ON_GLOBAL_LAYOUT_LISTENER = -8

    //显示软键盘相关 /**

    • Show the soft input. */ fun showSoftInput() { val imm = LUtilsConfig.getContext().getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager ?: return imm.toggleSoftInput(

      1.  InputMethodManager.SHOW_FORCED,
      2.  InputMethodManager.HIDE_IMPLICIT_ONLY

      ) }

      /**

    • Show the soft input. */ fun showSoftInput(activity: Activity) { if (!isSoftInputVisible(activity)) {

      1.  toggleSoftInput()

      } }

      /**

    • Show the soft input. *

    • @param view The view. */ fun showSoftInput(view: View) { showSoftInput(view, 0) }

      /**

    • Show the soft input. *
    • @param view The view.
    • @param flags Provides additional operating flags. Currently may be
    • 0 or have the [InputMethodManager.SHOW_IMPLICIT] bit set. */ fun showSoftInput(view: View, flags: Int) { val imm =
      1.  LUtilsConfig.getContext().getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager ?: return
      view.isFocusable = true view.isFocusableInTouchMode = true view.requestFocus() imm.showSoftInput(view, flags, object : ResultReceiver(Handler()) {
      1.  override fun onReceiveResult(resultCode: Int, resultData: Bundle) {
      2.      if (resultCode == InputMethodManager.RESULT_UNCHANGED_HIDDEN
      3.          || resultCode == InputMethodManager.RESULT_HIDDEN
      4.      ) {
      5.          toggleSoftInput()
      6.      }
      7.  }
      }) imm.toggleSoftInput(
      1.  InputMethodManager.SHOW_FORCED,
      2.  InputMethodManager.HIDE_IMPLICIT_ONLY
      ) }
  1. /**
  2.  * Toggle the soft input display or not.即使已经显示了键盘,调用以后会先隐藏键盘再显示
  3.  */
  4. fun toggleSoftInput() {
  5.     val imm =
  6.         LUtilsConfig.getContext()
  7.             .getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
  8.             ?: return
  9.     imm.toggleSoftInput(0, 0)
  10. }
  12. /**
  13.  * Hide the soft input.
  14.  *
  15.  * @param activity The activity.
  16.  */
  17. fun hideSoftInputByToggle(activity: Activity?) {
  18.     val nowMillis = SystemClock.elapsedRealtime()
  19.     val delta = nowMillis - millis
  20.     if (Math.abs(delta) > 500 && isSoftInputVisible(activity!!)) {
  21.         toggleSoftInput()
  22.     }
  23.     millis = nowMillis
  24. }
  27. /**
  28.  * Hide the soft input.
  29.  *
  30.  * @param activity The activity.
  31.  */
  32. fun hideSoftInput(activity: Activity) {
  33.     hideSoftInput(activity.window)
  34. }
  36. /**
  37.  * Hide the soft input.
  38.  *
  39.  * @param window The window.
  40.  */
  41. fun hideSoftInput(window: Window) {
  42.     var view = window.currentFocus
  43.     if (view == null) {
  44.         val decorView = window.decorView
  45.         val focusView =
  46.             decorView.findViewWithTag<View>("keyboardTagView")
  47.         if (focusView == null) {
  48.             view = EditText(window.context)
  49.             view.setTag("keyboardTagView")
  50.             (decorView as ViewGroup).addView(view, 0, 0)
  51.         } else {
  52.             view = focusView
  53.         }
  54.         view.requestFocus()
  55.     }
  56.     hideSoftInput(view)
  57. }
  59. /**
  60.  * Hide the soft input.
  61.  *
  62.  * @param view The view.
  63.  */
  64. fun hideSoftInput(view: View?) {
  65.     if (view == null) return
  66.     val imm =
  67.         LUtilsConfig.getContext().getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
  68.             ?: return
  69.     imm.hideSoftInputFromWindow(view.windowToken, 0)
  70. }
  73. /**
  74.  * Return whether soft input is visible.
  75.  *
  76.  * @param activity The activity.
  77.  * @return `true`: yes<br></br>`false`: no
  78.  */
  79. fun isSoftInputVisible(activity: Activity): Boolean {
  80.     return getDecorViewInvisibleHeight(activity.window) > 0
  81. }
  84. private fun getDecorViewInvisibleHeight(window: Window): Int {
  85.     val decorView = window.decorView
  86.     val outRect = Rect()
  87.     decorView.getWindowVisibleDisplayFrame(outRect)
  88.     val delta = Math.abs(decorView.bottom - outRect.bottom)
  89.     if (delta <= UtilsBridge.getNavBarHeight() + UtilsBridge.getStatusBarHeight()) {
  90.         sDecorViewDelta = delta
  91.         return 0
  92.     }
  93.     return delta - sDecorViewDelta
  94. }
  96. /**
  97.  * Register soft input changed listener.
  98.  *
  99.  * @param activity The activity.
  100.  * @param listener The soft input changed listener.
  101.  */
  102. fun registerSoftInputChangedListener(
  103.     activity: Activity,
  104.     listener: OnSoftInputChangedListener
  105. ) {
  106.     registerSoftInputChangedListener(activity.window, listener)
  107. }
  109. /**
  110.  * Register soft input changed listener.
  111.  *
  112.  * @param window   The window.
  113.  * @param listener The soft input changed listener.
  114.  */
  115. fun registerSoftInputChangedListener(
  116.     window: Window,
  117.     listener: OnSoftInputChangedListener
  118. ) {
  119.     val flags = window.attributes.flags
  120.     if (flags and WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS != 0) {
  121.         window.clearFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS)
  122.     }
  123.     val contentView = window.findViewById<FrameLayout>(R.id.content)
  124.     val decorViewInvisibleHeightPre =
  125.         intArrayOf(getDecorViewInvisibleHeight(window))
  126.     val onGlobalLayoutListener = OnGlobalLayoutListener {
  127.         val height = getDecorViewInvisibleHeight(window)
  128.         if (decorViewInvisibleHeightPre[0] != height) {
  129.             listener.onSoftInputChanged(height)
  130.             decorViewInvisibleHeightPre[0] = height
  131.         }
  132.     }
  133.     contentView.viewTreeObserver.addOnGlobalLayoutListener(onGlobalLayoutListener)
  134.     contentView.setTag(TAG_ON_GLOBAL_LAYOUT_LISTENER, onGlobalLayoutListener)
  135. }
  137. /**
  138.  * Unregister soft input changed listener.
  139.  *
  140.  * @param window The window.
  141.  */
  142. fun unregisterSoftInputChangedListener(window: Window) {
  143.     val contentView =
  144.         window.findViewById<View>(R.id.content) ?: return
  145.     val tag = contentView.getTag(TAG_ON_GLOBAL_LAYOUT_LISTENER)
  146.     if (tag is OnGlobalLayoutListener) {
  147.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
  148.             contentView.viewTreeObserver
  149.                 .removeOnGlobalLayoutListener(tag)
  150.         }
  151.     }
  152. }
  154. /**
  155.  * Fix the bug of 5497 in Android.
  156.  *
  157.  * Don't set adjustResize
  158.  *
  159.  * @param activity The activity.
  160.  */
  161. fun fixAndroidBug5497(activity: Activity) {
  162.     fixAndroidBug5497(activity.window)
  163. }
  165. /**
  166.  * Fix the bug of 5497 in Android.
  167.  *
  168.  * It will clean the adjustResize
  169.  *
  170.  * @param window The window.
  171.  */
  172. fun fixAndroidBug5497(window: Window) {
  173.     val softInputMode = window.attributes.softInputMode
  174.     window.setSoftInputMode(softInputMode and WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE.inv())
  175.     val contentView = window.findViewById<FrameLayout>(R.id.content)
  176.     val contentViewChild = contentView.getChildAt(0)
  177.     val paddingBottom = contentViewChild.paddingBottom
  178.     val contentViewInvisibleHeightPre5497 =
  179.         intArrayOf(getContentViewInvisibleHeight(window))
  180.     contentView.viewTreeObserver
  181.         .addOnGlobalLayoutListener {
  182.             val height = getContentViewInvisibleHeight(window)
  183.             if (contentViewInvisibleHeightPre5497[0] != height) {
  184.                 contentViewChild.setPadding(
  185.                     contentViewChild.paddingLeft,
  186.                     contentViewChild.paddingTop,
  187.                     contentViewChild.paddingRight,
  188.                     paddingBottom + getDecorViewInvisibleHeight(window)
  189.                 )
  190.                 contentViewInvisibleHeightPre5497[0] = height
  191.             }
  192.         }
  193. }
  195. private fun getContentViewInvisibleHeight(window: Window): Int {
  196.     val contentView =
  197.         window.findViewById<View>(R.id.content) ?: return 0
  198.     val outRect = Rect()
  199.     contentView.getWindowVisibleDisplayFrame(outRect)
  200.     Log.d(
  201.         "KeyboardUtils", "getContentViewInvisibleHeight: "
  202.                 + (contentView.bottom - outRect.bottom)
  203.     )
  204.     val delta = Math.abs(contentView.bottom - outRect.bottom)
  205.     return if (delta <= UtilsBridge.getStatusBarHeight() + UtilsBridge.getNavBarHeight()) {
  206.         0
  207.     } else delta
  208. }
  210. /**
  211.  * Fix the leaks of soft input.
  212.  *
  213.  * @param activity The activity.
  214.  */
  215. fun fixSoftInputLeaks(activity: Activity) {
  216.     fixSoftInputLeaks(activity.window)
  217. }
  219. /**
  220.  * Fix the leaks of soft input.
  221.  *
  222.  * @param window The window.
  223.  */
  224. fun fixSoftInputLeaks(window: Window) {
  225.     val imm =
  226.         LUtilsConfig.getContext()
  227.             .getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
  228.             ?: return
  229.     val leakViews =
  230.         arrayOf("mLastSrvView", "mCurRootView", "mServedView", "mNextServedView")
  231.     for (leakView in leakViews) {
  232.         try {
  233.             val leakViewField =
  234.                 InputMethodManager::class.java.getDeclaredField(
  235.                     leakView
  236.                 )
  237.             if (!leakViewField.isAccessible) {
  238.                 leakViewField.isAccessible = true
  239.             }
  240.             val obj = leakViewField[imm] as? View ?: continue
  241.             if (obj.rootView === window.decorView.rootView) {
  242.                 leakViewField[imm] = null
  243.             }
  244.         } catch (ignore: Throwable) { /**/
  245.         }
  246.     }
  247. }
  249. // interface
  250. ///////////////////////////////////////////////////////////////////////////
  251. interface OnSoftInputChangedListener {
  252.     fun onSoftInputChanged(height: Int)
  253. }
  255. /**
  256.  * 软键盘以覆盖当前界面的形式出现
  257.  *
  258.  * @param activity
  259.  */
  260. fun setSoftInputAdjustNothing(activity: Activity) {
  261.     activity.window.setSoftInputMode(
  262.         WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING
  263.                 or WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
  264.     )
  265. }
  267. /**
  268.  * 软键盘以顶起当前界面的形式出现, 注意这种方式会使得当前布局的高度发生变化，触发当前布局onSizeChanged方法回调，这里前后高度差就是软键盘的高度了
  269.  *
  270.  * @param activity
  271.  */
  272. fun setSoftInputAdjustResize(activity: Activity) {
  273.     activity.window.setSoftInputMode(
  274.         WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
  275.                 or WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
  276.     )
  277. }
  279. /**
  280.  * 软键盘以上推当前界面的形式出现, 注意这种方式不会改变布局的高度
  281.  *
  282.  * @param activity
  283.  */
  284. fun setSoftInputAdjustPan(activity: Activity) {
  285.     activity.window.setSoftInputMode(
  286.         WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN
  287.                 or WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
  288.     )
  289. }
  291. /**
  292.  * 禁用物理返回键
  293.  *
  294.  *
  295.  * 使用方法：
  296.  *
  297.  * 需重写 onKeyDown
  298.  *
  299.  * @param keyCode
  300.  * @return
  301.  * @Override public boolean onKeyDown(int keyCode, KeyEvent event) {
  302.  * return KeyboardUtils.onDisableBackKeyDown(keyCode) && super.onKeyDown(keyCode, event) ;
  303.  * }
  304.  */
  305. fun onDisableBackKeyDown(keyCode: Int): Boolean {
  306.     when (keyCode) {
  307.         KeyEvent.KEYCODE_BACK -> return false
  308.         KeyEvent.KEYCODE_HOME -> return false
  309.         else -> {
  310.         }
  311.     }
  312.     return true
  313. }
  316. /**
  317.  * 点击屏幕空白区域隐藏软键盘
  318.  *
  319.  * 根据 EditText 所在坐标和用户点击的坐标相对比，来判断是否隐藏键盘
  320.  *
  321.  * 需重写 dispatchTouchEvent
  322.  *
  323.  * @param ev
  324.  * @param activity 窗口
  325.  * @return
  326.  */
  327. fun dispatchTouchEvent(ev: MotionEvent?, activity: Activity) {
  328.     if (ev == null) return
  329.     if (ev.action == MotionEvent.ACTION_DOWN) {
  330.         val v = activity.currentFocus
  331.         if (isShouldHideKeyboard(v, ev)) {
  332.             hideSoftInput(v)
  333.         }
  334.     }
  335. }
  337. /**
  338.  * 点击屏幕空白区域隐藏软键盘
  339.  *
  340.  * 根据 EditText 所在坐标和用户点击的坐标相对比，来判断是否隐藏键盘
  341.  *
  342.  * 需重写 dispatchTouchEvent
  343.  *
  344.  * @param ev
  345.  * @param dialog 窗口
  346.  * @return
  347.  */
  348. fun dispatchTouchEvent(ev: MotionEvent?, dialog: Dialog) {
  349.     if (ev == null) return
  350.     if (ev.action == MotionEvent.ACTION_DOWN) {
  351.         val v = dialog.currentFocus
  352.         if (isShouldHideKeyboard(v, ev)) {
  353.             hideSoftInput(v)
  354.         }
  355.     }
  356. }
  358. /**
  359.  * 点击屏幕空白区域隐藏软键盘
  360.  *
  361.  * 根据 EditText 所在坐标和用户点击的坐标相对比，来判断是否隐藏键盘
  362.  *
  363.  * 需重写 dispatchTouchEvent
  364.  *
  365.  * @param ev
  366.  * @param focusView 聚焦的view
  367.  * @return
  368.  */
  369. fun dispatchTouchEvent(ev: MotionEvent?, focusView: View?) {
  370.     if (ev == null) return
  371.     if (ev.action == MotionEvent.ACTION_DOWN) {
  372.         if (isShouldHideKeyboard(focusView, ev)) {
  373.             hideSoftInput(focusView)
  374.         }
  375.     }
  376. }
  378. /**
  379.  * 点击屏幕空白区域隐藏软键盘
  380.  *
  381.  * 根据 EditText 所在坐标和用户点击的坐标相对比，来判断是否隐藏键盘
  382.  *
  383.  * 需重写 dispatchTouchEvent
  384.  *
  385.  * @param ev
  386.  * @param window 窗口
  387.  * @return
  388.  */
  389. fun dispatchTouchEvent(ev: MotionEvent?, window: Window) {
  390.     if (ev == null) return
  391.     if (ev.action == MotionEvent.ACTION_DOWN) {
  392.         val v = window.currentFocus
  393.         if (isShouldHideKeyboard(v, ev)) {
  394.             hideSoftInput(v)
  395.         }
  396.     }
  397. }
  399. /**
  400.  * 根据 EditText 所在坐标和用户点击的坐标相对比，来判断是否隐藏键盘
  401.  *
  402.  * @param v
  403.  * @param event
  404.  * @return
  405.  */
  406. private fun isShouldHideKeyboard(v: View?, event: MotionEvent): Boolean {
  407.     if (v != null && v is EditText) {
  408.         val l = intArrayOf(0, 0)
  409.         v.getLocationInWindow(l)
  410.         val left = l[0]
  411.         val top = l[1]
  412.         val bottom = top + v.getHeight()
  413.         val right = left + v.getWidth()
  414.         return !(event.x > left && event.x < right && event.y > top && event.y < bottom)
  415.     }
  416.     return false
  417. }

}

  1. UtilsBridge:

object UtilsBridge { val statusBarHeight: Int get() { val resources = getContext().resources val resourceId = resources.getIdentifier(“status_bar_height”, “dimen”, “android”) return resources.getDimensionPixelSize(resourceId) }

  1. val navBarHeight: Int
  2.     get() {
  3.         val res =
  4.             getContext().resources
  5.         val resourceId = res.getIdentifier("navigation_bar_height", "dimen", "android")
  6.         return if (resourceId != 0) {
  7.             res.getDimensionPixelSize(resourceId)
  8.         } else {
  9.             0
  10.         }
  11.     }

} ```