我正在使用AlertDialog显示输入框。调用EditText时，对话框内部的AlertDialog.show()会自动聚焦，但不会自动显示软键盘。

如何显示对话框时如何自动显示软键盘？ （并且没有物理/硬件键盘）。类似于当我按下“搜索”按钮以调用全局搜索时，会自动显示软键盘。

评论

根据下面的Ted的评论，这应该自动发生。首先检查一下！
这个答案是最简单的并且可以正常工作：stackoverflow.com/a/8018630/89818
检查此链接对我有用
这些年来，我已经多次回到这个答案。它总是出现在对话框中，我遇到了这个麻烦，从来没有Fragment或Activity。
关闭/隐藏Android软键盘的可能重复项

#1 楼

您可以在EditText的AlertDialog上创建焦点侦听器，然后获取AlertDialog的Window。从那里您可以通过调用setSoftInputMode来显示软键盘。

final AlertDialog dialog = ...;

editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        }
    }
});


评论

我如何使用AlertDialog.Builder做到这一点？ ...最终AlertDialog.Builder alert =新的AlertDialog.Builder（Main.this）;

–斯蒂芬
2011-1-25在18:02


@Stephen可以通过使用最终的AlertDialog dialog = builder.create（）从构建器中获取对话框，然后在对话框上显示而不是在构建器上显示。

–tidbeck
2011年10月11日上午9:38
我在上面回想一下，我发现，如果您不能正确地关注焦点，请看一下您的XML！如果在其中看到标签 -请将其删除。似乎该标记将焦点移至EditText，然后您的侦听器将不会被触发，因为EditText已具有焦点。

–特德
11-10-20在13:09
如果设备具有硬件键盘，怎么办？似乎对于这些用户来说很烦。

–mxcl
2012年8月8日17:23
我真的不明白为什么这不是SDK中的默认行为。如果需要文本输入的视图显示闪烁的光标，为什么有人不想看到键盘来输入文本？我觉得UX太不对劲了

–克里斯蒂安·加西亚（ChristianGarcía）
16年4月30日在9:44

#2 楼

用于显示键盘的用途：

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);


用于隐藏键盘的用途：

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


评论

当您希望在布局中的“可见”和“消失”之间切换视图的可见性时，此功能特别好显示/隐藏。

– PacificSky
2012年7月5日在18:47
我建议改用SHOW_IMPLICIT标志，因为这意味着更改活动或应用程序将按预期自动隐藏键盘。

–卡西
13年4月10日在1:28
@drspaceboo使用SHOW_IMPLICIT对我来说根本不起作用，我必须使用SHOW_FORCED，不确定为什么...

–约安·赫库埃（Yoann Hercouet）
2014年4月26日14:27在
以上代码何时应运行？在将布局添加到其父级后不久，我尝试这样做。那没用。但是，如果我在布局出现了一段时间之后才这样做，那么它确实起作用了。因此，有没有一个回调函数来告诉我“如果您现在尝试显示键盘，它实际上会工作”？

–威廉·乔克施
2015年1月19日在21:26


toggleSoftInput（InputMethodManager.SHOW_FORCED，0）切换软键盘。如果要确保出现键盘，则可以改用imm.showSoftInput（view，InputMethodManager.SHOW_IMPLICIT），其中view是将获取输入的View。

– PJ_Finnegan
15年5月21日在12:38


#3 楼

您可以在创建对话框后立即请求软键盘（在SDK-r20上测试）

// create dialog
final AlertDialog dialog = ...; 

// request keyboard   
dialog.getWindow().setSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);


评论

对于任何想知道的人，当连接了硬件键盘时，此方法都不会打开软键盘。我刚刚使用USB On-The-Go电缆进行了测试。完善！

– 13rac1
16年1月27日在18:25
这对我没有任何帮助。

–JohnyTex
16 Mar 24 '16 at 11:02
我没有硬件键盘。也许配置（？）

–JohnyTex
16 Mar 24 '16 at 11:11

#4 楼

我遇到了同样的问题，并使用以下代码解决了它。我不确定在带有硬件键盘的手机上它将如何运行。

// TextEdit
final EditText textEdit = new EditText(this);

// Builder
AlertDialog.Builder alert = new AlertDialog.Builder(this);
alert.setTitle("Enter text");
alert.setView(textEdit);

alert.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        String text = textEdit.getText().toString();
        finish();
    }
});

alert.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        finish();
    }
});

// Dialog
AlertDialog dialog = alert.create();
dialog.setOnShowListener(new OnShowListener() {

    @Override
    public void onShow(DialogInterface dialog) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(textEdit, InputMethodManager.SHOW_IMPLICIT);
    }
});

dialog.show();


评论

它在Dialog类API级别8中。

–tidbeck
2011年10月21日14:19
必须在以后删除：/

–杰西克·科维辛（JacekKwiecień）
2012年1月12日20:40
@Xylian仍在文档Dialog.setOnShowListener（）中

–tidbeck
2012年1月13日，0：32

#5 楼

我发现了这个示例http://android-codes-examples.blogspot.com/2011/11/show-or-hide-soft-keyboard-on-opening.html。在alert.show()之前添加以下代码。

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);


#6 楼

<activity
    ...
    android:windowSoftInputMode="stateVisible" >
</activity>


或

getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);


评论

谢谢很多同伴，这太棒了，实际上我用它们都解决了我的问题，我遇到了这样的情况：如果用户处于添加模式，则需要在活动开始时显示键盘，而对于更新模式，则不需要键盘默认。因此，在活动清单中，我设置了stateHidden，当我检测到用户正在创建新项目时，我使用您提到的代码行显示了键盘。 :)再次感谢。

– PHP Avenger
13年11月16日在21:42
我收到“无法解析getWindow（）”消息。我试过把这个。和其他事情。我只想通过单击屏幕的某个部分来获得键盘而不使用edittext。

– Androidcoder
18年5月26日在19:07


@Androidcoder，它是Activity的一部分，因此添加类似（（Activity）context）.getWindow（）.....

– CoolMind
18-10-3在16:18

#7 楼

其他答案中的代码片段也可以工作，但是在代码中将它们放置在哪里并不总是很明显，尤其是如果您使用的是AlertDialog.Builder并遵循官方的对话框教程，因为它不使用final AlertDialog ...或alertDialog.show()。

alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);


优于

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);


因为如果焦点从EditText移开，则SOFT_INPUT_STATE_ALWAYS_VISIBLE将隐藏键盘，SHOW_FORCED将在其中即使用户返回主屏幕或显示最近的应用程序，键盘仍保持显示状态，直到明确将其关闭为止。

下面是使用自定义布局创建的AlertDialog的工作代码，该布局具有XML定义的EditText 。它还将键盘设置为具有“ go”键，并允许其触发肯定按钮。

alert_dialog.xml：

<RelativeLayout
android:id="@+id/dialogRelativeLayout"
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content" >

    <!-- android:imeOptions="actionGo" sets the keyboard to have a "go" key instead of a "new line" key. -->
    <!-- android:inputType="textUri" disables spell check in the EditText and changes the "go" key from a check mark to an arrow. -->
    <EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="4dp"
        android:layout_marginRight="4dp"
        android:layout_marginBottom="16dp"
        android:imeOptions="actionGo"
        android:inputType="textUri"/>

</RelativeLayout>


AlertDialog.java：

import android.app.Activity;
import android.app.Dialog;
import android.content.DialogInterface;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v4.app.DialogFragment;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatDialogFragment;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.WindowManager;
import android.widget.EditText;

public class CreateDialog extends AppCompatDialogFragment {
    // The public interface is used to send information back to the activity that called CreateDialog.
    public interface CreateDialogListener {
        void onCreateDialogCancel(DialogFragment dialog);    
        void onCreateDialogOK(DialogFragment dialog);
    }

    CreateDialogListener mListener;

    // Check to make sure that the activity that called CreateDialog implements both listeners.
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        try {
            mListener = (CreateDialogListener) activity;
        } catch (ClassCastException e) {
            throw new ClassCastException(activity.toString() + " must implement CreateDialogListener.");
        }
    }

    // onCreateDialog requires @NonNull.
    @Override
    @NonNull
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(getActivity());
        LayoutInflater customDialogInflater = getActivity().getLayoutInflater();

        // Setup dialogBuilder.
        alertDialogBuilder.setTitle(R.string.title);
        alertDialogBuilder.setView(customDialogInflater.inflate(R.layout.alert_dialog, null));
        alertDialogBuilder.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                mListener.onCreateDialogCancel(CreateDialog.this);
            }
        });
        alertDialogBuilder.setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                mListener.onCreateDialogOK(CreateDialog.this);
            }
        });

        // Assign the resulting built dialog to an AlertDialog.
        final AlertDialog alertDialog = alertDialogBuilder.create();

        // Show the keyboard when the dialog is displayed on the screen.
        alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

        // We need to show alertDialog before we can setOnKeyListener below.
        alertDialog.show();

        EditText editText = (EditText) alertDialog.findViewById(R.id.editText);

        // Allow the "enter" key on the keyboard to execute "OK".
        editText.setOnKeyListener(new View.OnKeyListener() {
            public boolean onKey(View v, int keyCode, KeyEvent event) {
                // If the event is a key-down event on the "enter" button, select the PositiveButton "OK".
                if ((event.getAction() == KeyEvent.ACTION_DOWN) && (keyCode == KeyEvent.KEYCODE_ENTER)) {
                    // Trigger the create listener.
                    mListener.onCreateDialogOK(CreateDialog.this);

                    // Manually dismiss alertDialog.
                    alertDialog.dismiss();

                    // Consume the event.
                    return true;
                } else {
                    // If any other key was pressed, do not consume the event.
                    return false;
                }
            }
        });

        // onCreateDialog requires the return of an AlertDialog.
        return alertDialog;
    }
}


#8 楼

好吧，这是一个很老的帖子，仍然有一些要添加的内容。这是2种简单的方法，可以帮助我控制键盘，并且它们非常完美：

显示键盘

public void showKeyboard() {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View v = getCurrentFocus();
    if (v != null)
        imm.showSoftInput(v, 0);
}


隐藏键盘

public void hideKeyboard() {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View v = getCurrentFocus();
    if (v != null)
        imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
}


评论

什么是getCurrentFocus（）？

– CoolMind
18-10-3在16:19
我知道，这是一种Activity的方法。

– CoolMind
18-10-5在9:17


#9 楼

让我为yuku的解决方案指出一些其他信息，因为我发现很难使其正常工作！如何从我的AlertDialog.Builder获取AlertDialog对象？好吧，这是我执行alert.show()的结果：

final AlertDialog.Builder alert = new AlertDialog.Builder(getActivity());
final EditText input = new EditText(getActivity());
alert.setView(input);

// do what you need, like setting positive and negative buttons...

final AlertDialog dialog = alert.show();

input.setOnFocusChangeListener(new OnFocusChangeListener() {
   @Override
   public void onFocusChange(View v, boolean hasFocus) {
      if(hasFocus) {
         dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
      }
   }
});


#10 楼

看一下这个讨论，该讨论处理手动隐藏和显示IME。但是，我的感觉是，如果专注的EditText不能启动IME，那是因为您正在调用AlertDialog.show()中的OnCreate()或在实际显示屏幕之前调用的其他方法。我相信，在这种情况下，将其移至OnPostResume()应该可以对其进行修复。

#11 楼

是的，您可以使用setOnFocusChangeListener它将为您提供帮助。

editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        }
    }
});


#12 楼

我知道这个问题已经过时了，因为我认为使用扩展功能是显示用于编辑文本的键盘的更漂亮的方法

这是我用于显示用于编辑文本的键盘的方法。

kotlin代码：
只需要调用edittext.showKeyboard() 

fun EditText.showKeyboard() {
  post {
    requestFocus()
    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
  }
}


java代码：

 public static void showKeyboard(EditText editText) {
    editText.post(new Runnable() {
      @Override
      public void run() {
        editText.requestFocus();
        InputMethodManager imm = (InputMethodManager) editText.getContext()
            .getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(editText, InputMethodManager.SHOW_IMPLICIT);
      }
    });
  }


#13 楼

如果有人得到：



无法从活动类型中静态引用非静态方法getSystemService（String）



尝试向getSystemService调用添加上下文。

So 

InputMethodManager imm = 
(InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);


#14 楼

最初的问题与对话框有关，而我的EditText位于常规视图上。无论如何，我怀疑这也适用于大多数人。所以这是对我有用的方法（上面建议的最高评分方法对我没有任何帮助）。这是一个执行此操作的自定义EditView（不必进行子类化，但是我发现它很方便，因为我想在视图变为可见时也能抓住焦点）。

实际上基本上是相同的作为潮汐的答案。我实际上根本没有注意到他的答案，因为它的票数为零。然后我只想评论他的帖子，但是那太久了，所以无论如何我都结束了这篇帖子。 tidbeck指出，他不确定带键盘的设备如何工作。我可以确认两种情况下的行为似乎完全相同。这样一来，在纵向模式下，软件键盘会弹出，而在横向模式下则不会。物理键盘是否滑出对我的手机没有影响。

因为我个人选择了以下行为，所以我选择使用该行为：InputMethodManager.SHOW_FORCED。这可以按我想要的方式工作。无论方向如何，键盘都可见，但是，至少在我的设备上，如果滑出了硬件键盘，它不会弹出。

import android.app.Service;
import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

public class BringOutTheSoftInputOnFocusEditTextView extends EditText {

    protected InputMethodManager inputMethodManager;

    public BringOutTheSoftInputOnFocusEditTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init();
    }

    public BringOutTheSoftInputOnFocusEditTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public BringOutTheSoftInputOnFocusEditTextView(Context context) {
        super(context);
        init();
    }

    private void init() {
        this.inputMethodManager = (InputMethodManager)getContext().getSystemService(Service.INPUT_METHOD_SERVICE);
        this.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View v, boolean hasFocus) {
                if (hasFocus) {
                    BringOutTheSoftInputOnFocusEditTextView.this.inputMethodManager.showSoftInput(BringOutTheSoftInputOnFocusEditTextView.this, InputMethodManager.SHOW_FORCED);
                }
            }
        });
    }

    @Override
    protected void onVisibilityChanged(View changedView, int visibility) {
        super.onVisibilityChanged(changedView, visibility);
        if (visibility == View.VISIBLE) {
            BringOutTheSoftInputOnFocusEditTextView.this.requestFocus();
        }
    }

}


#15 楼

问题似乎在于，由于最初输入文本的位置是隐藏的（或嵌套的或类似的东西），因此AlertDialog会自动设置标志WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM或WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE，以使事情不会触发显示软输入。

解决此问题的方法是添加以下内容：

(...)
// Create the dialog and show it
Dialog dialog = builder.create()
dialog.show();

// After show (this is important specially if you have a list, a pager or other view that uses a adapter), clear the flags and set the soft input mode
dialog.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);


#16 楼

尝试并使用：

editText.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY);


#17 楼

为了显示键盘，对我来说，我必须执行以下操作

Android TextField：以编程方式设置焦点+软输入

基本上，解决方法是以下操作

@Override
public void onResume() {
    super.onResume();
    //passwordInput.requestFocus(); <-- that doesn't work
    passwordInput.postDelayed(new ShowKeyboard(), 325); //250 sometimes doesn't run if returning from LockScreen
}


ShowKeyboard在哪里

private class ShowKeyboard implements Runnable {
    @Override
    public void run() {
        passwordInput.setFocusableInTouchMode(true);
        //passwordInput.requestFocusFromTouch(); //this gives touch event to launcher in background -_-
        passwordInput.requestFocus();
        getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        ((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(passwordInput, 0);
    }
}


输入成功后，我还要确保隐藏键盘

getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);
((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE))
                    .hideSoftInputFromWindow(getView().getWindowToken(), 0);


#18 楼

将这些方法放在Util类中并在任何地方使用。

Kotlin 

fun hideKeyboard(activity: Activity) {
    val view = activity.currentFocus
    val methodManager = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.hideSoftInputFromWindow(view!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

private fun showKeyboard(activity: Activity) {
    val view = activity.currentFocus
    val methodManager = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}


Java 

public static void hideKeyboard(Activity activity) {
    View view = activity.getCurrentFocus();
    InputMethodManager methodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert methodManager != null && view != null;
    methodManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}

private static void showKeyboard(Activity activity) {
    View view = activity.getCurrentFocus();
    InputMethodManager methodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert methodManager != null && view != null;
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
}


#19 楼

我创建了不错的kotlin-esqe扩展函数，以防有人感兴趣

fun Activity.hideKeyBoard() {
    val view = this.currentFocus
    val methodManager = this.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.hideSoftInputFromWindow(view!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

fun Activity.showKeyboard() {
    val view = this.currentFocus
    val methodManager = this.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}


#20 楼

这是适合您的好样本：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <ScrollView
        android:id="@+id/scrollID"
        android:layout_width="fill_parent"
        android:layout_height="0dip"
        android:layout_weight="1" >

        <LinearLayout
            android:id="@+id/test"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical" >
        </LinearLayout>
    </ScrollView>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:baselineAligned="true"
        android:orientation="horizontal"
        android:paddingBottom="5dp"
        android:paddingLeft="5dp"
        android:paddingRight="5dp"
        android:weightSum="1" >

        <EditText
            android:id="@+id/txtInpuConversation"
            android:layout_width="0dip"
            android:layout_height="wrap_content"
            android:layout_weight="0.5"
            android:hint="@string/edt_Conversation" >

            <requestFocus />
        </EditText>

        <Button
            android:id="@+id/btnSend"
            android:layout_width="0dip"
            android:layout_height="wrap_content"
            android:layout_weight="0.5"
            android:text="@string/btn_Conversation" />
    </LinearLayout>

</LinearLayout>


#21 楼

为什么要回答这个问题-因为上述解决方案将显示您的键盘，但是如果您单击除EditText之外的其他任何位置，它将不会消失。因此，当EditText失去焦点时，您需要做一些事情使键盘消失。

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




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

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



实现hideKeyboard（）方法

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



最后，设置编辑文本的onFocusChangeListener。

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




#22 楼

这有点棘手。我以这种方式完成了工作。

1.第一次调用时，要从窗口隐藏软输入。

2.显示对话框

3.然后只需调用以切换软输入即可隐藏软输入。 。

代码：

InputMethodManager inputManager = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); 
//hiding soft input
inputManager.hideSoftInputFromWindow(findViewById(android.R.id.content).getWind‌​owToken(), 0);
//show dialog
yourDialog.show();
//toggle soft input
inputManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,InputMethodManager.SHOW_IMPLICIT);


#23 楼

试试这个


SomeUtils.java 

public static void showKeyboard(Activity activity, boolean show) {
    InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);

    if(show)
        inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
    else
        inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY,0);
}



#24 楼

getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);


当我进入Activity时，我在onCreate（）中称其为自动显示键盘。

#25 楼

尝试了很多，但这对我有用（kotlin）：

        val dialog = builder.create()
        dialog.setOnShowListener {
            nameEditText.requestFocus()
            val s = ContextCompat.getSystemService(requireContext(), InputMethodManager::class.java)
            s?.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0)
        }

        dialog.setOnDismissListener {
            val s = ContextCompat.getSystemService(requireContext(), InputMethodManager::class.java)
            s?.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0)
        }

        dialog.show()


#26 楼

看https://stackoverflow.com/a/39144104/2914140我简化了一点：

// In onCreateView():
view.edit_text.run {
    requestFocus()
    post { showKeyboard(this) }
}

fun showKeyboard(view: View) {
    val imm = view.context.getSystemService(
        Context.INPUT_METHOD_SERVICE) as InputMethodManager?
    imm?.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}


比https://stackoverflow.com/a更好/ 11155404/2914140：

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);


，因为当您按下主屏幕按钮并移至主屏幕时，键盘将保持打开状态。

#27 楼

只需将此行添加到清单文件中必要的活动即可。
android:windowSoftInputMode="stateVisible"