单击外部EditText后如何在android上隐藏软键盘？

好的，每个人都知道隐藏键盘需要实现：

InputMethodManager imm = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);

但是最重​​要的是，当用户触摸或选择其他非键盘位置时，如何隐藏键盘。 EditText或softKeyboard的？

我尝试使用 onTouchEvent()在父级上Activity但仅当用户触摸任何其他视图且没有滚动视图时，该方法才有效。

我尝试实现触摸，单击，焦点侦听器，但没有成功。

我什至尝试实现自己的滚动视图来拦截触摸事件，但是我只能获取事件的坐标，而不能单击视图。

有标准的方法吗？在iPhone中，这真的很容易。

以下代码段只是隐藏了键盘：

public static void hideSoftKeyboard(Activity activity) {
    InputMethodManager inputMethodManager = 
        (InputMethodManager) activity.getSystemService(
            Activity.INPUT_METHOD_SERVICE);
    inputMethodManager.hideSoftInputFromWindow(
        activity.getCurrentFocus().getWindowToken(), 0);
}

您可以将其放在实用程序类中，或者如果要在活动中定义它，请避免使用activity参数或调用 hideSoftKeyboard(this)。

最棘手的部分是何时调用它。您可以编写一个遍历View活动中每个步骤的方法，并检查该方法instanceof EditText是否setOnTouchListener为该组件未注册的方法，并且一切都准备就绪。如果您想知道如何做到这一点，那实际上很简单。这是您的工作，您编写了如下的递归方法，实际上您可以使用此方法执行任何操作，例如设置自定义字体等。

public void setupUI(View view) {

    // Set up touch listener for non-text box views to hide keyboard.
    if (!(view instanceof EditText)) {
        view.setOnTouchListener(new OnTouchListener() {
            public boolean onTouch(View v, MotionEvent event) {
                hideSoftKeyboard(MyActivity.this);
                return false;
            }
        });
    }

    //If a layout container, iterate over children and seed recursion.
    if (view instanceof ViewGroup) {
        for (int i = 0; i < ((ViewGroup) view).getChildCount(); i++) {
            View innerView = ((ViewGroup) view).getChildAt(i);
            setupUI(innerView);
        }
    }
}

就是这样，只需setContentView在您进行活动后调用此方法即可。如果您想知道要传递什么参数，它是id父容器的参数。将分配id给您的父容器，例如

<RelativeLayoutPanel android:id="@+id/parent"> ... </RelativeLayout>

并打电话 setupUI(findViewById(R.id.parent))，仅此而已。

如果您想有效地使用它，则可以创建一个扩展Activity并将其放入其中，并使应用程序中的所有其他活动扩展该活动并setupUI()在onCreate()方法中。

希望能帮助到你。

如果您使用多个活动，请为父级布局定义通用ID，例如 <RelativeLayout android:id="@+id/main_parent"> ... </RelativeLayout>

然后从中扩展一个类Activity并setupUI(findViewById(R.id.main_parent))在其中定义OnResume()并扩展该类，而不是``活动in your program

这是上述功能的Kotlin版本：

@file:JvmName("KeyboardUtils")

fun Activity.hideSoftKeyboard() {
    currentFocus?.let {
        val inputMethodManager = ContextCompat.getSystemService(this, InputMethodManager::class.java)!!
        inputMethodManager.hideSoftInputFromWindow(it.windowToken, 0)
    }
}

您可以通过执行以下步骤来实现：

1. 通过添加以下属性，使父视图（您的活动的内容视图）可单击和可聚焦

       android:clickable="true" 
       android:focusableInTouchMode="true" 

2. 实现hideKeyboard（）方法

       public void hideKeyboard(View view) {
           InputMethodManager inputMethodManager =(InputMethodManager)getSystemService(Activity.INPUT_METHOD_SERVICE);
           inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
       }

3. 最后，设置您的edittext的onFocusChangeListener。

       edittext.setOnFocusChangeListener(new View.OnFocusChangeListener() {
           @Override
           public void onFocusChange(View v, boolean hasFocus) {
               if (!hasFocus) {
                   hideKeyboard(v);
               }
           }
       });

正如下面的注释之一所指出的，如果父视图是ScrollView，则此方法可能不起作用。对于这种情况，可以将clickable和focusableInTouchMode添加到直接在ScrollView下的视图上。

只需覆盖Activity中的以下代码

 @Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    if (getCurrentFocus() != null) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
    }
    return super.dispatchTouchEvent(ev);
}

我发现接受的答案有点复杂。

这是我的解决方案。OnTouchListener在主布局中添加一个，即：

findViewById(R.id.mainLayout).setOnTouchListener(this)

并将以下代码放入onTouch方法中。

InputMethodManager imm = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);

这样，您不必遍历所有视图。

我还有另一种隐藏键盘的方法：

InputMethodManager imm = (InputMethodManager) getSystemService(
    Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);

路过这里HIDE_IMPLICIT_ONLY时的位置showFlag，并0在该位置hiddenFlag。它将强行关闭软键盘。

好吧，我设法某种程度上解决了这个问题，我在我的活动中覆盖了dispatchTouchEvent，在那里我正在使用以下代码来隐藏键盘。

 /**
 * Called to process touch screen events. 
 */
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {

    switch (ev.getAction()){
        case MotionEvent.ACTION_DOWN:
            touchDownTime = SystemClock.elapsedRealtime();
            break;

        case MotionEvent.ACTION_UP:
            //to avoid drag events
            if (SystemClock.elapsedRealtime() - touchDownTime <= 150){  

                EditText[] textFields = this.getFields();
                if(textFields != null && textFields.length > 0){

                    boolean clickIsOutsideEditTexts = true;

                    for(EditText field : textFields){
                        if(isPointInsideView(ev.getRawX(), ev.getRawY(), field)){
                            clickIsOutsideEditTexts = false;
                            break;
                        }
                    }

                    if(clickIsOutsideEditTexts){
                        this.hideSoftKeyboard();
                    }               
                } else {
                    this.hideSoftKeyboard();
                }
            }
            break;
    }

    return super.dispatchTouchEvent(ev);
}

编辑： getFields（）方法只是一种在视图中返回带有文本字段的数组的方法。为了避免在每次触摸时都创建此数组，我创建了一个名为sFields的静态数组，该数组在getFields（）方法中返回。该数组在onStart（）方法上初始化，例如：

sFields = new EditText[] {mUserField, mPasswordField};

这不是完美的，拖动事件的时间仅基于启发式方法，因此有时在执行较长的操作时它不会隐藏。否则，当单击其他EditText时，键盘将隐藏并显示。

不过，欢迎使用更清洁，更短的解决方案

使用OnFocusChangeListener。

例如：

editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (!hasFocus) {
            hideKeyboard();
        }
    }
});

更新：您还可以onTouchEvent()在活动中覆盖并检查触摸的坐标。如果坐标在EditText之外，则隐藏键盘。

我在Activity中实现了dispatchTouchEvent来做到这一点：

private EditText mEditText;
private Rect mRect = new Rect();
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    final int action = MotionEventCompat.getActionMasked(ev);

    int[] location = new int[2];
    mEditText.getLocationOnScreen(location);
    mRect.left = location[0];
    mRect.top = location[1];
    mRect.right = location[0] + mEditText.getWidth();
    mRect.bottom = location[1] + mEditText.getHeight();

    int x = (int) ev.getX();
    int y = (int) ev.getY();

    if (action == MotionEvent.ACTION_DOWN && !mRect.contains(x, y)) {
        InputMethodManager input = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        input.hideSoftInputFromWindow(mEditText.getWindowToken(), 0);
    }
    return super.dispatchTouchEvent(ev);
}

我测试了一下，效果完美！

使用TextInputEditText的另一种Kotlin 和材料设计方法（该方法也与EditTextView兼容）...

1.通过添加以下属性，使父视图（您的活动/片段的内容视图）可点击并具有焦点

android:focusable="true"
android:focusableInTouchMode="true"
android:clickable="true"

2.为所有视图创建扩展名（例如，在ViewExtension.kt文件内部）：

fun View.hideKeyboard(){
    val inputMethodManager = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
    inputMethodManager.hideSoftInputFromWindow(this.windowToken, 0)
}

3.创建一个继承自TextInputEditText的BaseTextInputEditText。实现onFocusChanged方法以在视图未聚焦时隐藏键盘：

class BaseTextInputEditText(context: Context?, attrs: AttributeSet?) : TextInputEditText(context, attrs){
    override fun onFocusChanged(focused: Boolean, direction: Int, previouslyFocusedRect: Rect?) {
        super.onFocusChanged(focused, direction, previouslyFocusedRect)
        if (!focused) this.hideKeyboard()
    }
}

4，只需在XML中调用全新的自定义视图：

<android.support.design.widget.TextInputLayout
        android:id="@+id/textInputLayout"
        ...>

        <com.your_package.BaseTextInputEditText
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            ... />

    </android.support.design.widget.TextInputLayout> 

就这样。无需修改您的控制器（片段或活动）即可处理这种重复情况。

覆盖任何Activity中的公共布尔型dispatchTouchEvent（MotionEvent event）（或扩展Activity的类）

@Override
public boolean dispatchTouchEvent(MotionEvent event) {
    View view = getCurrentFocus();
    boolean ret = super.dispatchTouchEvent(event);

    if (view instanceof EditText) {
        View w = getCurrentFocus();
        int scrcoords[] = new int[2];
        w.getLocationOnScreen(scrcoords);
        float x = event.getRawX() + w.getLeft() - scrcoords[0];
        float y = event.getRawY() + w.getTop() - scrcoords[1];

        if (event.getAction() == MotionEvent.ACTION_UP 
 && (x < w.getLeft() || x >= w.getRight() 
 || y < w.getTop() || y > w.getBottom()) ) { 
            InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(getWindow().getCurrentFocus().getWindowToken(), 0);
        }
    }
 return ret;
}

这就是您需要做的

我修改了Andre Luis IM的解决方案，从而实现了这一目标：

我创建了一个实用程序方法来隐藏软键盘，就像Andre Luiz IM一样：

public static void hideSoftKeyboard(Activity activity) {
    InputMethodManager inputMethodManager = (InputMethodManager)  activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}

但是，我没有为每个视图都注册一个会降低性能的OnTouchListener，而是为根视图注册了OnTouchListener。由于事件会一直持续到消费为止（EditText是默认情况下使用它的视图之一），因此，如果事件到达根视图，是因为未消费，所以我关闭了软键盘。

findViewById(android.R.id.content).setOnTouchListener(new OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        Utils.hideSoftKeyboard(activity);
        return false;
    }
});

我知道这个线程已经很老了，正确的答案似乎是正确的，并且有很多可行的解决方案，但是我认为下面提到的方法可能会在效率和优雅方面带来额外的好处。

我的所有活动都需要这种行为，因此我创建了一个从类Activity继承的CustomActivity类，并“钩住了” dispatchTouchEvent函数。主要要满足两个条件：

1. 如果焦点保持不变，并且有人在当前输入字段之外点击，则关闭IME
2. 如果焦点已更改并且下一个焦点元素不是任何类型的输入字段的实例，则关闭IME

这是我的结果：

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    if(ev.getAction() == MotionEvent.ACTION_UP) {
        final View view = getCurrentFocus();

        if(view != null) {
            final boolean consumed = super.dispatchTouchEvent(ev);

            final View viewTmp = getCurrentFocus();
            final View viewNew = viewTmp != null ? viewTmp : view;

            if(viewNew.equals(view)) {
                final Rect rect = new Rect();
                final int[] coordinates = new int[2];

                view.getLocationOnScreen(coordinates);

                rect.set(coordinates[0], coordinates[1], coordinates[0] + view.getWidth(), coordinates[1] + view.getHeight());

                final int x = (int) ev.getX();
                final int y = (int) ev.getY();

                if(rect.contains(x, y)) {
                    return consumed;
                }
            }
            else if(viewNew instanceof EditText || viewNew instanceof CustomEditText) {
                return consumed;
            }

            final InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);

            inputMethodManager.hideSoftInputFromWindow(viewNew.getWindowToken(), 0);

            viewNew.clearFocus();

            return consumed;
        }
    }       

    return super.dispatchTouchEvent(ev);
}

旁注：另外，我将这些属性分配给根视图，从而可以清除对每个输入字段的关注，并防止输入字段专注于活动启动（使内容视图成为“焦点捕获器”）：

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    final View view = findViewById(R.id.content);

    view.setFocusable(true);
    view.setFocusableInTouchMode(true);
}

我喜欢dispatchTouchEventhtafoya 进行呼叫的方法，但是：

• 我不了解计时器部分（不知道为什么要测量停机时间？）
• 我不喜欢在每次视图更改时都注册/注销所有EditText（在复杂的层次结构中可能有很多viewchange和edittext）

因此，我使此解决方案更简单：

@Override
public boolean dispatchTouchEvent(final MotionEvent ev) {
    // all touch events close the keyboard before they are processed except EditText instances.
    // if focus is an EditText we need to check, if the touchevent was inside the focus editTexts
    final View currentFocus = getCurrentFocus();
    if (!(currentFocus instanceof EditText) || !isTouchInsideView(ev, currentFocus)) {
        ((InputMethodManager) getApplicationContext().getSystemService(Context.INPUT_METHOD_SERVICE))
            .hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
    return super.dispatchTouchEvent(ev);
}

/**
 * determine if the given motionevent is inside the given view.
 * 
 * @param ev
 *            the given view
 * @param currentFocus
 *            the motion event.
 * @return if the given motionevent is inside the given view
 */
private boolean isTouchInsideView(final MotionEvent ev, final View currentFocus) {
    final int[] loc = new int[2];
    currentFocus.getLocationOnScreen(loc);
    return ev.getRawX() > loc[0] && ev.getRawY() > loc[1] && ev.getRawX() < (loc[0] + currentFocus.getWidth())
        && ev.getRawY() < (loc[1] + currentFocus.getHeight());
}

有一个缺点：

从一个切换EditText到另一个EditText会使键盘隐藏并重新显示-在我的情况下，希望这样做，因为它表明您在两个输入组件之间进行了切换。

恳求：我知道我没有影响力，但是请认真对待我的回答。

问题：单击远离键盘或使用最少的代码编辑文本时，关闭软键盘。

解决方案：外部库称为Butterknife。

一线解决方案：

@OnClick(R.id.activity_signup_layout) public void closeKeyboard() { ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0); }

更易读的解决方案：

@OnClick(R.id.activity_signup_layout) 
public void closeKeyboard() {
        InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}

说明：将 OnClick Listener绑定到活动的XML Layout父ID，以便对布局（而不是在编辑文本或键盘上）的任何单击都将运行该代码段，从而隐藏键盘。

示例： 如果您的布局文件是R.layout.my_layout，而您的布局ID是R.id.my_layout_id，则Butterknife绑定调用应类似于：

(@OnClick(R.id.my_layout_id) 
public void yourMethod {
    InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}

Butterknife文档链接： http ://jakewharton.github.io/butterknife/

插件： Butterknife将彻底改变您的android开发。考虑一下。

注意：无需使用外部库Butterknife即可获得相同的结果。只需如上所述将OnClickListener设置为父布局即可。

在Kotlin中，我们可以执行以下操作。无需迭代所有视图。它也适用于片段。

override fun dispatchTouchEvent(ev: MotionEvent?): Boolean {
    currentFocus?.let {
        val imm: InputMethodManager = getSystemService(
            Context.INPUT_METHOD_SERVICE
        ) as (InputMethodManager)
        imm.hideSoftInputFromWindow(it.windowToken, 0)
    }
    return super.dispatchTouchEvent(ev)
}

这是fje回答的另一种变体，解决了sosite提出的问题。

这里的想法是要处理活动中的向下和向上操作 dispatchTouchEvent方法中。在向下操作中，我们记下当前聚焦的视图（如果有）以及触摸是否在其中，将这两部分信息保存下来以备后用。

在up操作中，我们首先调度，以使另一个视图有可能成为焦点。如果之后，当前聚焦的视图是原始聚焦的视图，而向下触摸位于该视图内部，则使键盘保持打开状态。

如果当前聚焦的视图与原始聚焦的视图不同，并且是EditText，则我们也将键盘保持打开状态。

否则，我们将其关闭。

综上所述，其工作原理如下：

• 触摸当前聚焦的内部时EditText，键盘保持打开状态
• 当从一个专注的EditText转移到另一个EditText，键盘保持打开状态（不关闭/重新打开）
• 当触摸当前焦点以外的EditText其他地方时EditText，键盘关闭
• 长按以调出EditText上下文操作栏（带有“剪切/复制/粘贴”按钮）时，键盘会保持打开状态，即使UP操作是在焦点区域之外进行的EditText（向下移动以为CAB 留出空间） 。但是请注意，当您点击CAB中的按钮时，它将关闭键盘。这可能是合乎要求的，也可能是不合要求的。如果您想从一个字段剪切/复制并粘贴到另一个字段，那就可以了。如果要粘贴回相同的内容EditText，则不会。

• 当焦点EditText位于屏幕底部并且您长时间单击某些文本以将其选中时，将EditText保持焦点，因此键盘将按您想要的方式打开，因为我们在向下操作中执行了“触摸位于视图范围内”的检查，而不是up操作。

  private View focusedViewOnActionDown;
  private boolean touchWasInsideFocusedView;
  
  
  @Override
  public boolean dispatchTouchEvent(MotionEvent ev) {
      switch (ev.getAction()) {
          case MotionEvent.ACTION_DOWN:
              focusedViewOnActionDown = getCurrentFocus();
              if (focusedViewOnActionDown != null) {
                  final Rect rect = new Rect();
                  final int[] coordinates = new int[2];
  
                  focusedViewOnActionDown.getLocationOnScreen(coordinates);
  
                  rect.set(coordinates[0], coordinates[1],
                          coordinates[0] + focusedViewOnActionDown.getWidth(),
                          coordinates[1] + focusedViewOnActionDown.getHeight());
  
                  final int x = (int) ev.getX();
                  final int y = (int) ev.getY();
  
                  touchWasInsideFocusedView = rect.contains(x, y);
              }
              break;
  
          case MotionEvent.ACTION_UP:
  
              if (focusedViewOnActionDown != null) {
                  // dispatch to allow new view to (potentially) take focus
                  final boolean consumed = super.dispatchTouchEvent(ev);
  
                  final View currentFocus = getCurrentFocus();
  
                  // if the focus is still on the original view and the touch was inside that view,
                  // leave the keyboard open.  Otherwise, if the focus is now on another view and that view
                  // is an EditText, also leave the keyboard open.
                  if (currentFocus.equals(focusedViewOnActionDown)) {
                      if (touchWasInsideFocusedView) {
                          return consumed;
                      }
                  } else if (currentFocus instanceof EditText) {
                      return consumed;
                  }
  
                  // the touch was outside the originally focused view and not inside another EditText,
                  // so close the keyboard
                  InputMethodManager inputMethodManager =
                          (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                  inputMethodManager.hideSoftInputFromWindow(
                      focusedViewOnActionDown.getWindowToken(), 0);
                  focusedViewOnActionDown.clearFocus();
  
                  return consumed;
              }
              break;
      }
  
      return super.dispatchTouchEvent(ev);
  }

它太简单了，只需通过以下代码使您的近期布局可点击即可成为焦点：

android:id="@+id/loginParentLayout"
android:clickable="true"
android:focusableInTouchMode="true"

然后为该布局编写一个方法和一个OnClickListner，以便在触摸最上层布局时在任何位置调用该方法，您将在其中编写代码以关闭键盘。以下是两者的代码；//您必须在OnCreate（）中编写此代码

 yourLayout.setOnClickListener(new View.OnClickListener(){
                @Override
                public void onClick(View view) {
                    hideKeyboard(view);
                }
            });

从列表器调用的方法：-

 public void hideKeyboard(View view) {
     InputMethodManager imm =(InputMethodManager)getSystemService(Activity.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
    }

对于这个简单的要求，我发现接受的答案有点复杂。这是对我无故障的工作。

findViewById(R.id.mainLayout).setOnTouchListener(new View.OnTouchListener() {
        @Override
        public boolean onTouch(View view, MotionEvent motionEvent) {
            InputMethodManager imm = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
            return false;
        }
    });

有一个更简单的方法，基于iPhone同样的问题。只需在包含编辑文本的touch事件上覆盖背景的布局即可。只需在活动的OnCreate中使用以下代码（login_fondo是根布局）：

    final LinearLayout llLogin = (LinearLayout)findViewById(R.id.login_fondo);
    llLogin.setOnTouchListener(
            new OnTouchListener()
            {
                @Override
                public boolean onTouch(View view, MotionEvent ev) {
                    InputMethodManager imm = (InputMethodManager) mActivity.getSystemService(
                            android.content.Context.INPUT_METHOD_SERVICE);
                    imm.hideSoftInputFromWindow(mActivity.getCurrentFocus().getWindowToken(), 0);
                    return false;
                }
            });

显示/隐藏软键盘的方法

InputMethodManager inputMethodManager = (InputMethodManager) currentActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
    if (isShow) {
        if (currentActivity.getCurrentFocus() == null) {
            inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
        } else {
            inputMethodManager.showSoftInput(currentActivity.getCurrentFocus(), InputMethodManager.SHOW_FORCED);    
        }

    } else {
        if (currentActivity.getCurrentFocus() == null) {
            inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_NOT_ALWAYS, 0);
        } else {
            inputMethodManager.hideSoftInputFromInputMethod(currentActivity.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);    
        }

    }

我希望他们有用

这对我来说是最简单的解决方案（由我自己制定）。

这是隐藏键盘的方法。

public void hideKeyboard(View view){
        if(!(view instanceof EditText)){
            InputMethodManager inputMethodManager=(InputMethodManager)getSystemService(INPUT_METHOD_SERVICE);
            inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(),0);
        }
    }

现在，hideKeyboard可以从XML文件的“设计”视图或在XML文件的“文本”视图中编写以下代码，将活动的父布局的onclick属性设置为上述方法。

android:onClick="hideKeyboard"

我已经完善了该方法，将以下代码放在某个UI实用程序类中（最好是不一定要放置），以便可以从所有Activity或Fragment类中访问它，以实现其目的。

public static void serachAndHideSoftKeybordFromView(View view, final Activity act) {
    if(!(view instanceof EditText)) {
        view.setOnTouchListener(new View.OnTouchListener() {
            public boolean onTouch(View v, MotionEvent event) {
                hideSoftKeyboard(act);
                return false;
            }
        });
    }
    if (view instanceof ViewGroup) {
        for (int i = 0; i < ((ViewGroup) view).getChildCount(); i++) {
            View nextViewInHierarchy = ((ViewGroup) view).getChildAt(i);
            serachAndHideSoftKeybordFromView(nextViewInHierarchy, act);
        }
    }
}
public static void hideSoftKeyboard (Activity activity) {
    InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}

然后说，例如，您需要从活动中调用它，方法如下：

UIutils.serachAndHideSoftKeybordFromView(findViewById(android.R.id.content), YourActivityName.this);

注意

findViewById（android.R.id.content）

这为我们提供了当前组的根视图（您不必在根视图上设置ID）。

干杯:)

尝试将stateHidden设置为活动 windowSoftInputMode值

http://developer.android.com/reference/android/R.attr.html#windowSoftInputMode

例如对于您的活动：

this.getWindow().setSoftInputMode(
    WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);

活动

 @Override
 public boolean dispatchTouchEvent(MotionEvent ev) {
     ScreenUtils.hideKeyboard(this, findViewById(android.R.id.content).getWindowToken());
     return super.dispatchTouchEvent(ev);
 }

ScreenUtils

 public static void hideKeyboard(Context context, IBinder windowToken) {
     InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
     imm.hideSoftInputFromWindow(windowToken, InputMethodManager.HIDE_NOT_ALWAYS);
 }

只需在@Overide类中添加此代码

public boolean dispatchTouchEvent(MotionEvent ev) {
    View view = getCurrentFocus();
    if (view != null && (ev.getAction() == MotionEvent.ACTION_UP || ev.getAction() == MotionEvent.ACTION_MOVE) && view instanceof EditText && !view.getClass().getName().startsWith("android.webkit.")) {
        int scrcoords[] = new int[2];
        view.getLocationOnScreen(scrcoords);
        float x = ev.getRawX() + view.getLeft() - scrcoords[0];
        float y = ev.getRawY() + view.getTop() - scrcoords[1];
        if (x < view.getLeft() || x > view.getRight() || y < view.getTop() || y > view.getBottom())
            ((InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow((this.getWindow().getDecorView().getApplicationWindowToken()), 0);
    }
    return super.dispatchTouchEvent(ev);
}

而不是遍历所有视图或覆盖dispatchTouchEvent。

为什么不仅仅覆盖Activity的onUserInteraction（），这可以确保每当用户在EditText之外点击时，键盘都会关闭。

即使EditText位于scrollView内也可以使用。

@Override
public void onUserInteraction() {
    if (getCurrentFocus() != null) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
    }
}

我在Fernando Camarago的解决方案上做了一些细微的改动。在我的onCreate方法中，我将单个onTouchListener附加到根视图，但是将视图而不是活动作为参数发送。

        findViewById(android.R.id.content).setOnTouchListener(new OnTouchListener() {           
        public boolean onTouch(View v, MotionEvent event) {
            Utils.hideSoftKeyboard(v);
            return false;
        }
    });

在单独的Utils类中是...

    public static void hideSoftKeyboard(View v) {
    InputMethodManager imm = (InputMethodManager) v.getContext().getSystemService(Context.INPUT_METHOD_SERVICE); 
    imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
}

这可能很旧，但是我通过强制自定义课程来使它起作用

public class DismissKeyboardListener implements OnClickListener {

    Activity mAct;

    public DismissKeyboardListener(Activity act) {
        this.mAct = act;
    }

    @Override
    public void onClick(View v) {
        if ( v instanceof ViewGroup ) {
            hideSoftKeyboard( this.mAct );
        }
    }       
}

public void hideSoftKeyboard(Activity activity) {
        InputMethodManager imm = (InputMethodManager)
        getSystemService(Activity.INPUT_METHOD_SERVICE);
        imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
}

此处的最佳实践是创建一个Helper类，并且每个容器“相对/线性布局”都应实现此功能。

****请注意，只有主容器才能实现此类（用于优化）****

并像这样实现它：

Parent.setOnClickListener( new DismissKeyboardListener(this) ); 

用于活动的关键字。因此，如果您使用的是片段，则使用类似getActivity（）;的方法。

---如果有帮助，请竖起大拇指...--为拉尔夫加油---

这是fje答案的稍作修改的版本，大多数情况下效果很好。

此版本使用ACTION_DOWN，因此执行滚动操作也会关闭键盘。除非您单击另一个EditText，否则它也不会传播事件。这意味着单击EditText之外的任何位置，甚至单击另一个可单击的位置，都只会关闭键盘。

@Override
public boolean dispatchTouchEvent(MotionEvent ev)
{
    if(ev.getAction() == MotionEvent.ACTION_DOWN)
    {
        final View view = getCurrentFocus();

        if(view != null)
        {
            final View viewTmp = getCurrentFocus();
            final View viewNew = viewTmp != null ? viewTmp : view;

            if(viewNew.equals(view))
            {
                final Rect rect = new Rect();
                final int[] coordinates = new int[2];

                view.getLocationOnScreen(coordinates);

                rect.set(coordinates[0], coordinates[1], coordinates[0] + view.getWidth(), coordinates[1] + view.getHeight());

                final int x = (int) ev.getX();
                final int y = (int) ev.getY();

                if(rect.contains(x, y))
                {
                    super.dispatchTouchEvent(ev);
                    return true;
                }
            }
            else if(viewNew instanceof EditText || viewNew instanceof CustomEditText)
            {
                super.dispatchTouchEvent(ev);
                return true;
            }

            final InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);

            inputMethodManager.hideSoftInputFromWindow(viewNew.getWindowToken(), 0);

            viewNew.clearFocus();

            return true;
        }
    }
    return super.dispatchTouchEvent(ev);
}

我这样做：

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
   View view = getCurrentFocus();
   if (view != null && (ev.getAction() == MotionEvent.ACTION_UP || ev.getAction() == MotionEvent.ACTION_MOVE) && view instanceof EditText && !view.getClass().getName().startsWith("android.webkit.")) {
            int scrcoords[] = new int[2];
            view.getLocationOnScreen(scrcoords);
            float x = ev.getRawX() + view.getLeft() - scrcoords[0];
            float y = ev.getRawY() + view.getTop() - scrcoords[1];
            if (x < view.getLeft() || x > view.getRight() || y < view.getTop() || y > view.getBottom())
                hideKeyboard(this);
        }
    return super.dispatchTouchEvent(ev);
}

隐藏键盘代码：

public static void hideKeyboard(Activity act) {
    if(act!=null)
      ((InputMethodManager)act.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow((act.getWindow().getDecorView().getApplicationWindowToken()), 0);
  }

完成了