android监听键盘弹出

㈠ Android 键盘顶起最终完美解决方法

1.在布局底部放置一个透明的 view_Bottom，通隐没陆过监听键盘弹出修改 view_Bottom的高度实现，键盘弹出顶察码起，键盘消失收回 的效果

4.想要不再界面一出现就弹出键盘，完善用户体验，只要在根布局里加入灶顷，就能完美解决

Demo连接

㈡ android没办法监听软键盘的弹出和消失吗

如果要监听,目简型启前Android没有提供监听的callback的注租亮册接口,要完拦如美实现这个可能需要改framework。

㈢ android的键盘弹出和缩回应该怎么处理

监听布局的高度来判断软键盘的打开和关闭public class SoftKeyboardStateHelper implements ViewTreeObserver.OnGlobalLayoutListener {

public interface SoftKeyboardStateListener {
void onSoftKeyboardOpened(int keyboardHeightInPx);
void onSoftKeyboardClosed();
}

private final List<SoftKeyboardStateListener> listeners = new LinkedList<SoftKeyboardStateListener>();
private final View activityRootView;
private int lastSoftKeyboardHeightInPx;
private boolean isSoftKeyboardOpened;

public SoftKeyboardStateHelper(View activityRootView) {
this(activityRootView, false);
}

public SoftKeyboardStateHelper(View activityRootView, boolean isSoftKeyboardOpened) {
this.activityRootView = activityRootView;
this.isSoftKeyboardOpened = isSoftKeyboardOpened;
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(this);
}

@Override
public void onGlobalLayout() {
final Rect r = new Rect();
//r will be populated with the coordinates of your view that area still visible.
activityRootView.getWindowVisibleDisplayFrame(r);

final int heightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
if (!isSoftKeyboardOpened && heightDiff > 100) { // if more than 100 pixels, its probably a keyboard...
isSoftKeyboardOpened = true;
notifyOnSoftKeyboardOpened(heightDiff);
} else if (isSoftKeyboardOpened && heightDiff < 100) {
isSoftKeyboardOpened = false;
notifyOnSoftKeyboardClosed();
}
}

public void setIsSoftKeyboardOpened(boolean isSoftKeyboardOpened) {
this.isSoftKeyboardOpened = isSoftKeyboardOpened;
}

public boolean isSoftKeyboardOpened() {
return isSoftKeyboardOpened;
}

/**
* Default value is zero (0)
* @return last saved keyboard height in px
*/
public int getLastSoftKeyboardHeightInPx() {
return lastSoftKeyboardHeightInPx;
}

public void addSoftKeyboardStateListener(SoftKeyboardStateListener listener) {
listeners.add(listener);
}

public void (SoftKeyboardStateListener listener) {
listeners.remove(listener);
}

private void notifyOnSoftKeyboardOpened(int keyboardHeightInPx) {
this.lastSoftKeyboardHeightInPx = keyboardHeightInPx;

for (SoftKeyboardStateListener listener : listeners) {
if (listener != null) {
listener.onSoftKeyboardOpened(keyboardHeightInPx);
}
}
}

private void notifyOnSoftKeyboardClosed() {
for (SoftKeyboardStateListener listener : listeners) {
if (listener != null) {
listener.onSoftKeyboardClosed();
}
}
}
}

㈣ H5如何对android和ios手机软键盘的监听

    总结：

    1.在ios中软键盘弹起时，仅会引起body的scrollTop值改变，但是我们可以通过输入框的获取焦点情况来做判断，单也只能在ios中采用这个方案，因为在android中存在主动受气键盘后，但输入框并没有失去焦点，而ios中键盘受气后就会失去焦点；

2.在androis中软键盘弹起或收起时，会改变window的高度，因此监听window的onresize事件；

一、Android

//获取原窗口的高度

var originalHeight=document.documentElement.clientHeight ||document.body.clientHeight;

window.onresize=function(){

    //键盘弹起与隐藏都会引起窗口的高度发生变化

      var resizeHeight=document.documentElement.clientHeight || document.body.clientHeight;

        if(resizeHeight-0<originalHeight-0){

        //当软键盘弹起，在此处操作

        }else{

        //当软键盘收起，在此处操作

        }

}

二、ios

focusin和focusout支持冒泡，对应focus和blur, 使用focusin和focusout的原因是focusin和focusout可以冒泡，focus和blur不会冒泡，这样就可以使用事件代理，处理多个输入框存在的情况。

document.body.addEventListener('focusin', () => {

            //软键盘弹出的事件处理

            if(isIphone()）{

            }

        })

  document.body.addEventListener('focusout', () => {

      //软键盘收起的事件处理

        if(isIphone()）{

        }

  })

特此声明文章出处： https://blog.csdn.net/u012982629/article/details/81905894

㈤ Android软键盘弹出和收回监听

软键盘弹出和收回的三种方式

为什么 重写 Activity.onKeyDown() 方法为什么没有用？而用的是 onKeyPreIme，该博客写的很明白 http://blog.csdn.net/yxhuang2008/article/details/53822072 ，感谢该博客博主

软键盘收回监听

//键盘隐藏监听
customized_edit.setOnKeyBoardHideListener(new TextEditTextView.OnKeyBoardHideListener(){

});

软键盘弹出监听（通过高度计算，但是这种方式有问题，不推荐用）：

㈥ android 判断键盘弹出和消失的监听事件的方法

原理：自定义布局的onSizeChanged()方法，在其中增加一个监听接口，当软键盘显示或隐藏使得布局尺寸发生改变，就能捕获到这个事件。

具体方法如下：
首先，在清单文件Manifest.xml中的对应的Activity标签内设置
android:windowSoftInputMode=”adjustResize”
作用是当软键盘显示或隐藏时，该Activity主窗口总是会被调整大小以便留出软键盘的空间。唯有这样才能保证布局触发onSizeChanged()方法。

然后，自定义一个布局，具体是RelativeLayout、LinearLayout或是其它的，根据实际情况而定，自定义的目的是在其onSizeChanged()方法中增加一个监听接口。这里给出一个自定义RelativeLayout布局代码：

public class CustomRelativeLayout extends RelativeLayout {

private OnSizeChangedListener listener;

public CustomRelativeLayout(Context context) {
super(context);
}

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

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}

@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
super.onLayout(changed, l, t, r, b);
}

@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {

Log.d(TAG.CUSTOM_VIEW, “onSizeChanged”);
super.onSizeChanged(w, h, oldw, oldh);
if (listener != null) {
listener.onSizeChanged(w, h, oldw, oldh);
}
}

public void setOnSizeChangedListener(OnSizeChangedListener listener) {
this.listener = listener;
}

/** * Activity主窗口大小改变时的回调接口(本示例中，等价于软键盘显示隐藏时的回调接口) */
public interface OnSizeChangedListener {
public void onSizeChanged(int w, int h, int oldw, int oldh);
}
}

最后，在程序中使用此接口（xxx.setOnSizeChangedListener(…)）即可实现监听键盘隐藏或显示事件。

㈦ 如何在android中判断软键盘是否弹出或隐藏

Android中判断软键盘是否弹出或隐藏可以借悉棚助软键盘显示和隐藏时，对主窗口进行了重新布局这个特性来进行侦听。如果我们设置的模式为压缩模式，那么我们可以对布局的onSizeChanged函数进行跟踪，如果为平移模式，那么该函数可能不会被调用。
假设跟布局为线性布局耐橘，模式为压缩模式，我们写一个例子，当输入昌陆团法弹出时隐藏某个view，输入法隐藏时显示某个view。

public class ResizeLayout extends LinearLayout{
private OnResizeListener mListener;
public interface OnResizeListener {
void OnResize(int w, int h, int oldw, int oldh);
}
public void setOnResizeListener(OnResizeListener l) {
mListener = l;
}
public ResizeLayout(Context context, AttributeSet attrs) {
super(context, attrs);
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) { super.onSizeChanged(w, h, oldw, oldh);
if (mListener != null) {
mListener.OnResize(w, h, oldw, oldh);
}
}
}

㈧ android 如何让软键盘自动弹出

可以通过下面的代码来实现Android自动弹出软键盘：

edittext.requestFocus(); //edittext是一个EditText控件
Timer timer = new Timer(); //设置定时器
timer.schele(new TimerTask() {
@Override
public void run() { //弹出软键盘的代码
 InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
 imm.showSoftInput(edittext, InputMethodManager.RESULT_SHOWN);
 imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,InputMethodManager.HIDE_IMPLICIT_ONLY);
}
}, 300); //设置300毫秒的时长

说明：同样是在写Techo Lite时遇到的问题。希望程序可以自动弹出软键盘，可是尝试了各种办法都没有效果。问题的原因似乎是必须等待UI绘制完成后弹出软键盘的代码才会有效。于是就采用了上面的方法。需要注意的是，在此之前必须让edittext获取焦点，不然也是无效的。

㈨ 如何在Android中判断软键盘是否弹出或隐藏

不知道你是州氏侍说的哪一种？
(1)：虚拟键盘弹出后一般会占据当前activity的核旦大部分，所以肉册吵眼可以看到；
(2)：代码中判断：
//判断隐藏软键盘是否弹出
if(getWindow().getAttributes().softInputMode==WindowManager.LayoutParamsSOFT_INPUT_STATE_UNSPECIFIED)
{
//隐藏软键盘
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);

㈩ 如何监听软键盘的弹出和退出

Android是一个针对触摸屏专门设计的操作系统，当点击编辑框，系统自动为用户弹出软键盘，以便用户进行输入。
那么，弹出软键盘后必然会造成原有布局高度的减少，那么系统应该如何来处理布局的减少？我们能否在应用程序中进行自定义的控制？这些是本文要讨论的重点。

一、软键盘显示的原理
软件盘的本质是什么？软键盘其实是一个Dialog！
InputMethodService为我们的输入法创建了一个Dialog，并且将该Dialog的Window的某些参数（如Gravity）进行了设置，使之能够在底部或者全屏显示。当我们点击输入框时，系统对活动主窗口进行调整，从而为输入法腾出相应的空间，然后将该Dialog显示在底部，或者全屏显示。
二、活动主窗口调整
android定义了一个属性，名字为windowSoftInputMode, 用它可以让程序可以控制活动主窗口调整的方式。我们可以在AndroidManifet.xml中对Activity进行设置。如：android:windowSoftInputMode="stateUnchanged|adjustPan"
该属性可选的值有两部分，一部分为软键盘的状态控制，另一部分是活动主窗口的调整。前一部分本文不做讨论，请读者自行查阅android文档。
模式一，压缩模式
windowSoftInputMode的值如果设置为adjustResize，那么该Activity主窗口总是被调整大小以便留出软键盘的空间。
我们通过一段代码来测试一下，当我们设置了该属性后，弹出输入法时，系统做了什么。
重写Layout布局：

1. public class ResizeLayout extends LinearLayout{
2. private static int count = 0;
3.
4. public ResizeLayout(Context context, AttributeSet attrs) {
5. super(context, attrs);
6. }
7.
8. @Override
9. protected void onSizeChanged(int w, int h, int oldw, int oldh) {
10. super.onSizeChanged(w, h, oldw, oldh);
11.
12. Log.e("onSizeChanged " + count++, "=>onResize called! w="+w + ",h="+h+",oldw="+oldw+",oldh="+oldh);
13. }
14.
15. @Override
16. protected void onLayout(boolean changed, int l, int t, int r, int b) {
17. super.onLayout(changed, l, t, r, b);
18. Log.e("onLayout " + count++, "=>OnLayout called! l=" + l + ", t=" + t + ",r=" + r + ",b="+b);
19. }
20.
21. @Override
22. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
23. super.onMeasure(widthMeasureSpec, heightMeasureSpec);
24.
25. Log.e("onMeasure " + count++, "=>onMeasure called! widthMeasureSpec=" + widthMeasureSpec + ", heightMeasureSpec=" + heightMeasureSpec);
26. }

我们的布局设置为：

1. <com.winuxxan.inputMethodTest.ResizeLayout
2. xmlns:android="http://schemas.android.com/apk/res/android"
3. android:id="@+id/root_layout"
4. android:layout_width="fill_parent"
5. android:layout_height="fill_parent"
6. android:orientation="vertical"
7. >
8.
9. <EditText
10. android:layout_width="fill_parent"
11. android:layout_height="wrap_content"
12. />
13.
14. <LinearLayout
15. android:id="@+id/bottom_layout"
16. android:layout_width="fill_parent"
17. android:layout_height="fill_parent"
18. android:orientation="vertical"
19. android:gravity="bottom">s
20.
21. <TextView
22. android:layout_width="fill_parent"
23. android:layout_height="wrap_content"
24. android:text="@string/hello"
25. android:background="#77777777"
26. />
27. </LinearLayout>
28. </com.winuxxan.inputMethodTest.ResizeLayout>

AndroidManifest.xml的Activity设置属性：android:windowSoftInputMode = "adjustResize"
运行程序，点击文本框，查看调试信息：
E/onMeasure 6(7960): =>onMeasure called! widthMeasureSpec=1073742144, heightMeasureSpec = 1073742024
E/onMeasure 7(7960): =>onMeasure called! widthMeasureSpec=1073742144, heightMeasureSpec = 1073742025
E/onSizeChanged 8(7960): =>onSizeChanged called! w=320,h=201,oldw=320,oldh=377
E/onLayout 9(7960): =>OnLayout called! l=0, t=0,r=320,b=201
从调试结果我们可以看出，当我们点击文本框后，根布局调用了onMeasure，onSizeChanged和onLayout。
实际上，当设置为adjustResize后，软键盘弹出时，要对主窗口布局重新进行measure和layout，而在layout时，发现窗口的大小发生的变化，因此调用了onSizeChanged。
从下图的运行结果我们也可以看出，原本在下方的TextView被顶到了输入法的上方。

模式二，平移模式
windowSoftInputMode的值如果设置为adjustPan，那么该Activity主窗口并不调整屏幕的大小以便留出软键盘的空间。相反，当前窗口的内容将自动移动以便当前焦点从不被键盘覆盖和用户能总是看到输入内容的部分。这个通常是不期望比调整大小，因为用户可能关闭软键盘以便获得与被覆盖内容的交互操作。
上面的例子中，我们将AndroidManifest.xml的属性进行更改：android: windowSoftInputMode = "adjustPan"

重新运行，并点击文本框，查看调试信息：
E/onMeasure 6(8378): =>onMeasure called! widthMeasureSpec=1073742144, heightMeasureSpec=1073742200
E/onMeasure 7(8378): =>onMeasure called! widthMeasureSpec=1073742144, heightMeasureSpec=1073742201
E/onLayout 8(8378): =>OnLayout called! l=0, t=0,r=320,b=377
我们看到：系统也重新进行了measrue和layout，但是我们发现，layout过程中onSizeChanged并没有调用，这说明输入法弹出前后并没有改变原有布局的大小。
从下图的运行结果我们可以看到，下方的TextView并没有被顶到输入法上方。

事实上，当输入框不会被遮挡时，该模式没有对布局进行调整，然而当输入框将要被遮挡时，窗口就会进行平移。也就是说，该模式始终是保持输入框为可见。如下图，整个窗口，包括标题栏均被上移，以保证文本框可见。

模式三 自动模式
当属性windowSoftInputMode被设置为adjustUspecified时，它不被指定是否该Activity主窗口调整大小以便留出软键盘的空间，或是否窗口上的内容得到屏幕上当前的焦点是可见的。系统将自动选择这些模式中一种主要依赖于是否窗口的内容有任何布局视图能够滚动他们的内容。如果有这样的一个视图，这个窗口将调整大小，这样的假设可以使滚动窗口的内容在一个较小的区域中可见的。这个是主窗口默认的行为设置。
也就是说，系统自动决定是采用平移模式还是压缩模式，决定因素在于内容是否可以滚动。

三、侦听软键盘的显示隐藏
有时候，借助系统本身的机制来实现主窗口的调整并非我们想要的结果，我们可能希望在软键盘显示隐藏的时候，手动的对布局进行修改，以便使软键盘弹出时更加美观。这时就需要对软键盘的显示隐藏进行侦听。
直接对软键盘的显示隐藏侦听的方法本人没有找到，如果哪位找到的方法请务必告诉本人一声。还有本方法针对压缩模式，平移模式不一定有效。
我们可以借助软键盘显示和隐藏时，对主窗口进行了重新布局这个特性来进行侦听。如果我们设置的模式为压缩模式，那么我们可以对布局的onSizeChanged函数进行跟踪，如果为平移模式，那么该函数可能不会被调用。
我们可以重写根布局，因为根布局的高度一般情况下是不发生变化的。
假设跟布局为线性布局，模式为压缩模式，我们写一个例子，当输入法弹出时隐藏某个view，输入法隐藏时显示某个view。

1. public class ResizeLayout extends LinearLayout{
2. private OnResizeListener mListener;
3.
4. public interface OnResizeListener {
5. void OnResize(int w, int h, int oldw, int oldh);
6. }
7.
8. public void setOnResizeListener(OnResizeListener l) {
9. mListener = l;
10. }
11.
12. public ResizeLayout(Context context, AttributeSet attrs) {
13. super(context, attrs);
14. }
15.
16. @Override
17. protected void onSizeChanged(int w, int h, int oldw, int oldh) {
18. super.onSizeChanged(w, h, oldw, oldh);
19.
20. if (mListener != null) {
21. mListener.OnResize(w, h, oldw, oldh);
22. }
23. }
24. }

在我们的Activity中，通过如下方法调用：

1. public class InputMethodTestActivity extends Activity {
2. private static final int BIGGER = 1;
3. private static final int SMALLER = 2;
4. private static final int MSG_RESIZE = 1;
5.
6. private static final int HEIGHT_THREADHOLD = 30;
7.
8. class InputHandler extends Handler {
9. @Override
10. public void handleMessage(Message msg) {
11. switch (msg.what) {
12. case MSG_RESIZE: {
13. if (msg.arg1 == BIGGER) {
14. findViewById(R.id.bottom_layout).setVisibility(View.VISIBLE);
15. } else {
16. findViewById(R.id.bottom_layout).setVisibility(View.GONE);
17. }
18. }
19. break;
20.
21. default:
22. break;
23. }
24. super.handleMessage(msg);
25. }
26. }
27.
28. private InputHandler mHandler = new InputHandler();
29.
30. /** Called when the activity is first created. */
31. @Override
32. public void onCreate(Bundle savedInstanceState) {
33. super.onCreate(savedInstanceState);
34. setContentView(R.layout.main);
35.
36. ResizeLayout layout = (ResizeLayout) findViewById(R.id.root_layout);
37. layout.setOnResizeListener(new ResizeLayout.OnResizeListener() {
38.
39. public void OnResize(int w, int h, int oldw, int oldh) {
40. int change = BIGGER;
41. if (h < oldh) {
42. change = SMALLER;
43. }
44.
45. Message msg = new Message();
46. msg.what = 1;
47. msg.arg1 = change;
48. mHandler.sendMessage(msg);
49. }
50. });
51. }
52. }

这里特别需要注意的是，不能直接在OnResizeListener中对要改变的View进行更改，因为OnSizeChanged函数实际上是运行在 View的layout方法中，如果直接在onSizeChange中改变view的显示属性，那么很可能需要重新调用layout方法才能显示正确。然而我们的方法又是在layout中调用的，因此会出现错误。因此我们在例子中采用了Handler的方法。