用ChatGPT解决这个技术问题 Extra ChatGPT

Android：当焦点在 EditText 上时自动显示软键盘

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

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

这应该会按照下面的 Ted's comment 自动发生。先检查一下！
这个答案最简单而且效果很好：stackoverflow.com/a/8018630/89818
Check this link its working for me
多年来，我多次回到这个答案。我总是在对话框中遇到这个问题，而不是片段或活动。
Close/hide the Android Soft Keyboard 的可能重复项

R
Randy Sugianto 'Yuku'

您可以在 AlertDialog 上的 EditText 上创建焦点侦听器，然后获取 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 来做到这一点？ ...final AlertDialog.Builder alert = new AlertDialog.Builder(Main.this);
@Stephen，您可以使用 final AlertDialog dialog = builder.create() 从构建器获取对话框，然后在对话框而不是构建器上使用 show。
我撤回上面的评论我发现如果您无法正确关注焦点，请查看您的 XML！如果您在其中看到标签 - 将其删除。似乎该标签会将焦点赋予 EditText，然后您的侦听器将不会被触发，因为 EditText 已经具有焦点。
如果设备有硬件键盘，你怎么不这样做？似乎这对那些用户来说很烦人。
我真的不明白为什么这不是 SDK 中的默认行为。如果需要文本输入的视图显示闪烁的光标，为什么有人不想看到键盘输入文本？对我来说，UX 感觉很不对劲
h
horkavlna

用于显示键盘使用： 

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);
当您想要基于在可见和已消失之间切换布局中视图的可见性来显示/隐藏软键盘时，这特别有效。
我建议改用 SHOW_IMPLICIT 标志，因为这意味着更改活动或应用程序将按预期自动隐藏键盘。
@drspaceboo 使用 SHOW_IMPLICIT 对我来说根本不起作用，我必须使用 SHOW_FORCED，不知道为什么......
什么时候应该运行上面的代码？在将布局添加到其父级后不久，我尝试这样做。那没有用。但是，如果我在布局出现一段时间后才这样做，它确实有效。那么是否有一个回调会告诉我“如果您现在尝试显示键盘，它实际上会起作用”？
toggleSoftInput(InputMethodManager.SHOW_FORCED,0) 切换软键盘。如果要确保出现键盘，可以使用 imm.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT) 代替，其中 view 是获取输入的视图。
B
Bao Le

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

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

// request keyboard   
dialog.getWindow().setSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
对于任何想知道的人，此方法在连接硬件键盘时不会打开软键盘。我刚刚使用 USB On-The-Go 电缆进行了测试。完美的！
这对我没有任何作用。
我没有硬件键盘。也许配置（？）
P
Peter O.

我找到了这个例子 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);
t
tidbeck

我有同样的问题，并用下面的代码解决了。我不确定它在带有硬件键盘的手机上会如何表现。 

// 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 class API 级别 8 中。
必须在以后删除：/
@Xylian 它仍在文档中Dialog.setOnShowListener()
a
ahtartam 
<activity
    ...
    android:windowSoftInputMode="stateVisible" >
</activity>

或者 

getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
非常感谢队友，这太棒了，实际上我用它们来解决我的问题，我有一个情况，如果用户处于添加模式，那么需要在活动开始时显示键盘，而对于更新模式，不需要键盘默认。因此，在活动清单中，我设置了 stateHidden，当我检测到用户正在创建新项目时，我使用您提到的代码行显示了键盘。 :) 再次感谢。
我收到“无法解析 getWindow()”消息。我试过放“这个”。以及之前的其他事情。我想在不使用edittext的情况下获得键盘，只需单击屏幕的某个部分。
@Androidcoder，它是 Activity 的一部分，所以添加类似 ((Activity) context).getWindow().... 的内容。
S
Soren Stoutner

其他答案的代码片段有效，但将它们放在代码中的位置并不总是很明显，特别是如果您使用 AlertDialog.Builder 并遵循 official dialog tutorial，因为它不使用 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);

因为 SOFT_INPUT_STATE_ALWAYS_VISIBLE 将在焦点从 EditText 移开时隐藏键盘，其中 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>

警报对话框.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;
    }
}
a
alireza easazade

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

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

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);
      }
    });
  }
s
sberezin

嗯，这是一个很老的帖子，还有一些东西要补充。这些是 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() 是什么？
我明白了，这是 Activity 的一种方法。
r
resueman

让我为 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);
      }
   }
});
j
jqpubliq

看一下处理手动隐藏和显示 IME 的 this 讨论。但是，我的感觉是，如果焦点 EditText 没有启动 IME，那是因为您在 OnCreate() 中调用 AlertDialog.show() 或在实际呈现屏幕之前调用的其他方法。在这种情况下，我相信将它移到 OnPostResume() 应该可以解决它。

M
MKJParekh

是的，您可以使用 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);
        }
    }
});
R
Ryan Wittenburg

如果有人得到：

无法从 Activity 类型对非静态方法 getSystemService(String) 进行静态引用

尝试将上下文添加到 getSystemService 调用。

所以 

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

问题似乎在于，由于您输入文本的位置最初是隐藏的（或嵌套的或其他），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);
这应该有更多的赞成票。
D
Dulaj Madusanka

只需将此行添加到清单文件必要的活动。

android:windowSoftInputMode="stateVisible"

在我赞成这个答案并且改变我的投票为时已晚之后，我发现它在所有情况下都不适用于我。
T
Timo

最初的问题与对话框有关，而我的 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();
        }
    }

}
u
ungalcrys

尝试使用： 

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

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

Android TextField : set focus + soft input programmatically

基本上解决方案如下 

@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);
a
atline 
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

当我进入 Activity 时，我在 onCreate() 中调用它来自动显示键盘。

我的噩梦终于结束了！
K
Khemraj Sharma

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

科特林 

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

爪哇 

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);
}
i
i am E

我创建了不错的 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)
}
l
lorenzo

尝试了很多，但这对我有用（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()
R
Rondev

我的方法使用 Android 11+ 的新方法，并且还支持旧版本： 

fun Fragment.showKeyboard() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
        ViewCompat.getWindowInsetsController(requireView())?.show(WindowInsetsCompat.Type.ime())
    } else {
        val focusedView = view?.findFocus() ?: view?.apply { requestFocus() }
        val imm = (context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager)
        val isShowSucceeded = imm.showSoftInput(focusedView, InputMethodManager.SHOW_IMPLICIT)
        if(!isShowSucceeded) {
            imm.toggleSoftInputFromWindow(
                view?.windowToken, 0, InputMethodManager.HIDE_IMPLICIT_ONLY)
    }
}

}

谢谢！ ViewCompat.getWindowInsetsController(binding.root)?.show(WindowInsetsCompat.Type.ime()) 完美运行！
A
A.A

这对您来说是一个很好的样本： 

<?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>
D
Darpan

为什么这个答案 - 因为上述解决方案会显示您的键盘，但如果您点击 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); } } });

F
FRR

这有点棘手。我以这种方式做到了，它奏效了。

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);
G
GameBug

尝试这个

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);否则 inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY,0); }

C
CoolMind

查看 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);

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

B
Bokili Production

在 AlertDialog 内从 EditText 显示软键盘的问题可能在 AlertDialog.show() 中，因为在显示 AlertDialog 之后应用了 EditText。我不确定 API 的所有版本都是这种情况，但我认为该解决方案带有 API 级别 21，因为它带有 AlertDialog.create()，它应该在 AlertDialog.show() 之前调用。

这是我针对这种情况的最佳解决方案。首先，在某处创建： 

    private int showKeyboard(View view) {
        final InputMethodManager inputManager = (InputMethodManager) requireActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
        if (inputManager != null) {
            boolean isShown = inputManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT); // flag=InputMethodManager.SHOW_IMPLICIT ili =
            return (isShown) ? 1: -1;
        }
        return 0;
    }

然后，在您的 AlertDialog.Builder builder = new AlertDialog.Builder(requireContext()); 继续： 

    EditText editText = new EditText(requireContext());
    builder.setView(editText);
    // ... put positive-negative buttons, and etc ...
    AlertDialog dialog = builder.create(); // Create dialog from builder
    dialog.setCancelable(false); // If you need
    Handler handler = new Handler();
    dialog.setOnShowListener(new DialogInterface.OnShowListener() {
        @Override
        public void onShow(DialogInterface dialog) { // 1. When a dialog is displayed
            editText.requestFocus();
            Runnable runnable = new Runnable() { // create one runnable
                int counter = 0;
                public void run() {
                    int status = showKeyboard(editText); // 2. Call func.above for keyboard, but...
                    if(status == -1 && counter < 10){ handler.postDelayed(this, 100); counter ++; } // ...if it inst shown call again after 100ms
                }
            };
            runnable.run(); // Execute runnable first time here
        }
    });
    dialog.show();

不要忘记 import android.os.Handler; 等；-)

感谢Vote Up。

关注公众号,不定期副业成功案例分享
关注公众号

不定期副业成功案例分享

想领先一步获取最新的外包任务吗？

立即订阅

HuntsBot(狩猎机器人)，一站式外包任务、远程工作、产品创意分享与订阅平台，支持钉钉、飞书、企业微信、邮箱、Telegram机器人订阅。平台会以及时、稳定、可靠的技术把外包任务需求、远程工作机会、产品创意等推送给每一位订阅的用户。

简体中文 English

平台

支持

友情链接

联系我们

在使用过程中有任何问题或建议，可以通过以下方式联系我们：

微信公众号: 火星来客

Email: huntsbot@xinbeitime.com

Copyright© 2022-2023 www.huntsbot.com 浙ICP备2022000860号-4 All Rights Reserved.