android 输入法WINDOW_FOCUS_CHANGED|MSG_CREATE_SESSION|MSG_BIND_INPUT|MSG_START_INPUT|MSG_BIND_METHOD消息

最新推荐文章于 2024-06-29 21:44:09 发布
最新推荐文章于 2024-06-29 21:44:09 发布
阅读量2.7k 收藏
点赞数
分类专栏： Framework android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jianguo_liao19840726/article/details/25036241
版权



当我们从home界面进入到设置界面应用，这个时候设置应用下没有任何输入框，但是这个时候foucs进行了change，而输入法也将进行一次尝试性判断是否需要显示输入法

ViewRootImpl.java 的 case WINDOW_FOCUS_CHANGED: {处理

    InputMethodManager imm = InputMethodManager.peekInstance();
                Log.v("PateoInputMethod","ViewRootImpl class " + " ,WINDOW_FOCUS_CHANGED msg,");
                if (mView != null) {
                    if (hasWindowFocus && imm != null && mLastWasImTarget) {
                    	 Log.v("PateoInputMethod","ViewRootImpl class " + " ,WINDOW_FOCUS_CHANGED msg, imm.startGettingWindowFocus mView=" + mView);
                        imm.startGettingWindowFocus(mView);
                    }
                    mAttachInfo.mKeyDispatchState.reset();
                    mView.dispatchWindowFocusChanged(hasWindowFocus);
                }

                // Note: must be done after the focus change callbacks,
                // so all of the view state is set up correctly.
                if (hasWindowFocus) {
                    if (imm != null && mLastWasImTarget) {
                    	 Log.v("PateoInputMethod","ViewRootImpl class " + " ,WINDOW_FOCUS_CHANGED msg,imm.onWindowFocus");
                        imm.onWindowFocus(mView, mView.findFocus(),
                                mWindowAttributes.softInputMode,
                                !mHasHadWindowFocus, mWindowAttributes.flags);
                    }

输出日志： 

01-01 09:41:43.840 V/PateoInputMethod( 1757): ViewRootImpl class  ,WINDOW_FOCUS_CHANGED msg,
01-01 09:41:43.840 V/PateoInputMethod( 1757): ViewRootImpl class  ,WINDOW_FOCUS_CHANGED msg, imm.startGettingWindowFocus mView=com.android.internal.policy.impl.PhoneWindow$DecorView@418f5518
01-01 09:41:43.860 V/PateoInputMethod( 1757): ViewRootImpl class  ,WINDOW_FOCUS_CHANGED msg,imm.onWindowFocus

从上面来看，我们进入imm.onWindowFocus的方法进行分析 

    /**
     * Called by ViewAncestor when its window gets input focus.
     * @hide
     */
    public void onWindowFocus(View rootView, View focusedView, int softInputMode,
            boolean first, int windowFlags) {
        boolean forceNewFocus = false;
        synchronized (mH) {
            if (DEBUG) Log.v(TAG,"InputMethodManager class " +  "onWindowFocus: " + focusedView
                    + " softInputMode=" + softInputMode
                    + " first=" + first + " flags=#"
                    + Integer.toHexString(windowFlags));
            if (mHasBeenInactive) {
                if (DEBUG) Log.v(TAG,"InputMethodManager class " +  "Has been inactive!  Starting fresh");
                mHasBeenInactive = false;
                forceNewFocus = true;
            }
            focusInLocked(focusedView != null ? focusedView : rootView);
        }

        int controlFlags = 0;
        if (focusedView != null) {
            controlFlags |= CONTROL_WINDOW_VIEW_HAS_FOCUS;
            if (focusedView.onCheckIsTextEditor()) {
                controlFlags |= CONTROL_WINDOW_IS_TEXT_EDITOR;
            }
        }
        if (first) {
            controlFlags |= CONTROL_WINDOW_FIRST;
        }
        
        if (checkFocusNoStartInput(forceNewFocus)) {
            // We need to restart input on the current focus view.  This
            // should be done in conjunction with telling the system service
            // about the window gaining focus, to help make the transition
            // smooth.
        	Log.d(TAG, "InputMethodManager class onWindowFocus method");
            if (startInputInner(rootView.getWindowToken(),
                    controlFlags, softInputMode, windowFlags)) {
                return;
            }
        }
        
        // For some reason we didn't do a startInput + windowFocusGain, so
        // we'll just do a window focus gain and call it a day.
        synchronized (mH) {
            try {
                mService.windowGainedFocus(mClient, rootView.getWindowToken(),
                        controlFlags, softInputMode, windowFlags, null, null);
            } catch (RemoteException e) {
            }
        }
    }

相应的日志输入Log.d(TAG, "InputMethodManager class onWindowFocus method");  发现进入了startInputInner方法，在此方法中，根据相应的输出日志我们发现走入了如下代码行： 

                if (windowGainingFocus != null) {
                	if (DEBUG) Log.v(TAG,"InputMethodManager class " + " IInputMethodManager.windowGainedFocus");
                    res = mService.windowGainedFocus(mClient, windowGainingFocus,
                            controlFlags, softInputMode, windowFlags,
                            tba, servedContext);
                }
进入该InputMethodManagerService的windowGainedFocus方法 

switch (softInputMode&WindowManager.LayoutParams.SOFT_INPUT_MASK_STATE) {
                    case WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED:
                        if (!isTextEditor || !doAutoShow) {
                            if (WindowManager.LayoutParams.mayUseInputMethod(windowFlags)) {
                                // There is no focus view, and this window will
                                // be behind any soft input window, so hide the
                                // soft input window if it is shown.
                                if (DEBUG) Slog.v(TAG, "InputMethodManagerService class" +  "Unspecified window will hide input");
                                hideCurrentInputLocked(InputMethodManager.HIDE_NOT_ALWAYS, null);
                            }
                        }

输出日志：Unspecified window will hide input，在上面的switch代码行下面还有如下必覆盖代码： 

if (!didStart && attribute != null) {
                    res = startInputUncheckedLocked(cs, inputContext, attribute,
                            controlFlags);
                }

进入该startInputUncheckedLocked方法 

    InputBindResult startInputUncheckedLocked(ClientState cs,
            IInputContext inputContext, EditorInfo attribute, int controlFlags) {
        // If no method is currently selected, do nothing.
        if (mCurMethodId == null) {
            return mNoBinding;
        }

        if (mCurClient != cs) {
            // If the client is changing, we need to switch over to the new
            // one.
            unbindCurrentClientLocked();
            if (DEBUG) Slog.v(TAG, "InputMethodManagerService class" +  "switching to client: client = "
                    + cs.client.asBinder());

            // If the screen is on, inform the new client it is active
            if (mScreenOn) {
                try {
                    cs.client.setActive(mScreenOn);
                } catch (RemoteException e) {
                    Slog.w(TAG, "InputMethodManagerService class" +  "Got RemoteException sending setActive notification to pid "
                            + cs.pid + " uid " + cs.uid);
                }
            }
        }

        // Bump up the sequence for this client and attach it.
        mCurSeq++;
        if (mCurSeq <= 0) mCurSeq = 1;
        mCurClient = cs;
        mCurInputContext = inputContext;
        mCurAttribute = attribute;

        // Check if the input method is changing.
        if (mCurId != null && mCurId.equals(mCurMethodId)) {
            if (cs.curSession != null) {
                // Fast case: if we are already connected to the input method,
                // then just return it.
            	Slog.w(TAG, "InputMethodManagerService class" + "startInputUncheckedLocked method ,attachNewInputLocked");
                return attachNewInputLocked(
                        (controlFlags&InputMethodManager.CONTROL_START_INITIAL) != 0);
            }
            if (mHaveConnection) {
                if (mCurMethod != null) {
                    if (!cs.sessionRequested) {
                        cs.sessionRequested = true;
                        if (DEBUG) Slog.v(TAG, "InputMethodManagerService class" +  "Creating new session for client " + cs);
                        executeOrSendMessage(mCurMethod, mCaller.obtainMessageOO(
                                MSG_CREATE_SESSION, mCurMethod,
                                new MethodCallback(mCurMethod, this)));
                    }
                    // Return to client, and we will get back with it when
                    // we have had a session made for it.
                    return new InputBindResult(null, mCurId, mCurSeq);
                } else if (SystemClock.uptimeMillis()
                        < (mLastBindTime+TIME_TO_RECONNECT)) {
                    // In this case we have connected to the service, but
                    // don't yet have its interface.  If it hasn't been too
                    // long since we did the connection, we'll return to
                    // the client and wait to get the service interface so
                    // we can report back.  If it has been too long, we want
                    // to fall through so we can try a disconnect/reconnect
                    // to see if we can get back in touch with the service.
                    return new InputBindResult(null, mCurId, mCurSeq);
                } else {
                    EventLog.writeEvent(EventLogTags.IMF_FORCE_RECONNECT_IME,
                            mCurMethodId, SystemClock.uptimeMillis()-mLastBindTime, 0);
                }
            }
        }

        return startInputInnerLocked();
    }

我们先看上面方法中的如下一行代码 

unbindCurrentClientLocked();

进入该方法 

   void unbindCurrentClientLocked() {
        if (mCurClient != null) {
            if (DEBUG) Slog.v(TAG, "InputMethodManagerService class" +  "unbindCurrentInputLocked: client = "
                    + mCurClient.client.asBinder());
            if (mBoundToMethod) {
                mBoundToMethod = false;
                if (mCurMethod != null) {
                    executeOrSendMessage(mCurMethod, mCaller.obtainMessageO(
                            MSG_UNBIND_INPUT, mCurMethod));
                }
            }
            
            	           
	    	try {
	           mCurSeq = ((IInputMethodClient)mCurClient.client).getBindSequence();
	        } catch (RemoteException e) {
	
	        }
            
            executeOrSendMessage(mCurClient.client, mCaller.obtainMessageIO(
                    MSG_UNBIND_METHOD, mCurSeq, mCurClient.client));
            mCurClient.sessionRequested = false;

            // Call setActive(false) on the old client
            try {
                mCurClient.client.setActive(false);
            } catch (RemoteException e) {
                Slog.w(TAG, "InputMethodManagerService class" +  "Got RemoteException sending setActive(false) notification to pid "
                        + mCurClient.pid + " uid " + mCurClient.uid);
            }
            mCurClient = null;

            hideInputMethodMenuLocked();
        }
    }

因为mCurClient == null所以该放入内代码未覆盖执行，但是这里需要注意下，如果mCurClient ！= null 则会MSG_UNBIND_INPUT、MSG_UNBIND_METHOD即其它

这里我们回到startInputUncheckedLocked方法，紧接着我们走入了如下代码：

if (mHaveConnection) {
                if (mCurMethod != null) {
                    if (!cs.sessionRequested) {
                        cs.sessionRequested = true;
                        if (DEBUG) Slog.v(TAG, "InputMethodManagerService class" +  "Creating new session for client " + cs);
                        executeOrSendMessage(mCurMethod, mCaller.obtainMessageOO(
                                MSG_CREATE_SESSION, mCurMethod,
                                new MethodCallback(mCurMethod, this)));
                    }
                    // Return to client, and we will get back with it when
                    // we have had a session made for it.
                    return new InputBindResult(null, mCurId, mCurSeq);
                }

从这里来看我们开始MSG_CREATE_SESSION消息的处理 

            case MSG_CREATE_SESSION:
            	Slog.d(TAG,"InputMethodManagerService class MSG_CREATE_SESSION msg ");
                args = (HandlerCaller.SomeArgs)msg.obj;
                try {
                    ((IInputMethod)args.arg1).createSession(
                            (IInputMethodCallback)args.arg2);
                } catch (RemoteException e) {
                }
                return true;

此进入了当前类的回调sessionCreated 

    private static class MethodCallback extends IInputMethodCallback.Stub {
        private final IInputMethod mMethod;
        private final InputMethodManagerService mParentIMMS;

        MethodCallback(final IInputMethod method, final InputMethodManagerService imms) {
            mMethod = method;
            mParentIMMS = imms;
        }

        @Override
        public void finishedEvent(int seq, boolean handled) throws RemoteException {
        	Slog.i(TAG, "InputMethodManagerService class" + " ,MethodCallback finishedEvent method");
        }

        @Override
        public void sessionCreated(IInputMethodSession session) throws RemoteException {
        	Slog.i(TAG, "InputMethodManagerService class" + " ,MethodCallback sessionCreated method");
            mParentIMMS.onSessionCreated(mMethod, session);
        }
    }


    void onSessionCreated(IInputMethod method, IInputMethodSession session) {
        synchronized (mMethodMap) {
            if (mCurMethod != null && method != null
                    && mCurMethod.asBinder() == method.asBinder()) {
                if (mCurClient != null) {
                    mCurClient.curSession = new SessionState(mCurClient,
                            method, session);
                    mCurClient.sessionRequested = false;
                    Slog.w(TAG, "InputMethodManagerService class" + "onSessionCreated method ,attachNewInputLocked");
                    InputBindResult res = attachNewInputLocked(true);
                    if (res.method != null) {
                    	Slog.w(TAG, "InputMethodManagerService class" + "onSessionCreated method ,attachNewInputLocked MSG_BIND_METHOD");
                        executeOrSendMessage(mCurClient.client, mCaller.obtainMessageOO(
                                MSG_BIND_METHOD, mCurClient.client, res));
                    }
                }
            }
        }
    }

相应的输出日志：

onSessionCreated method ,attachNewInputLocked

attachNewInputLocked method coming...,mBoundToMethod=false ,initial=true

onSessionCreated method ,attachNewInputLocked MSG_BIND_METHOD

    InputBindResult attachNewInputLocked(boolean initial) {
    	if (DEBUG) Slog.v(TAG, "InputMethodManagerService class" +  "attachNewInputLocked method coming...,mBoundToMethod=" + mBoundToMethod + " ,initial=" + initial);
        if (!mBoundToMethod) {
            executeOrSendMessage(mCurMethod, mCaller.obtainMessageOO(
                    MSG_BIND_INPUT, mCurMethod, mCurClient.binding));
            mBoundToMethod = true;
        }
        final SessionState session = mCurClient.curSession;
        if (initial) {
            executeOrSendMessage(session.method, mCaller.obtainMessageOOO(
                    MSG_START_INPUT, session, mCurInputContext, mCurAttribute));
        } else {
            executeOrSendMessage(session.method, mCaller.obtainMessageOOO(
                    MSG_RESTART_INPUT, session, mCurInputContext, mCurAttribute));
        }
        if (mShowRequested) {
            if (DEBUG) Slog.v(TAG, "InputMethodManagerService class" +  "Attach new input asks to show input");
            showCurrentInputLocked(getAppShowFlags(), null);
        }
        if (DEBUG) Slog.v(TAG, "InputMethodManagerService class" +  "attachNewInputLocked method coming...");
        return new InputBindResult(session.session, mCurId, mCurSeq);
    }

从上面来看，执行了MSG_BIND_INPUT、MSG_START_INPUT、MSG_BIND_METHOD消息，上面即初始化的过程，而这个过程中虽然MSG_START_INPUT了，但是这个最终调用InputMethodService 

        public void startInput(InputConnection ic, EditorInfo attribute) {
            if (DEBUG) Log.v(TAG,"InputMethodService class" +  "startInput(): editor=" + attribute);
            doStartInput(ic, attribute, false);
        }

进入该方法 

    void doStartInput(InputConnection ic, EditorInfo attribute, boolean restarting) {
        if (!restarting) {
            doFinishInput();
        }
        mInputStarted = true;
        mStartedInputConnection = ic;
        mInputEditorInfo = attribute;
        initialize();
        if (DEBUG) Log.v(TAG,"InputMethodService class" +  "CALL: onStartInput , mWindowVisible=" + mWindowVisible);
        onStartInput(attribute, restarting);
        if (mWindowVisible) {
            if (mShowInputRequested) {
                if (DEBUG) Log.v(TAG,"InputMethodService class" +  "CALL: onStartInputView");
                mInputViewStarted = true;
                onStartInputView(mInputEditorInfo, restarting);
                startExtractingText(true);
            } else if (mCandidatesVisibility == View.VISIBLE) {
                if (DEBUG) Log.v(TAG,"InputMethodService class" +  "CALL: onStartCandidatesView");
                mCandidatesViewStarted = true;
                onStartCandidatesView(mInputEditorInfo, restarting);
            }
        }
    }

看输入日志InputMethodService classCALL: onStartInput , mWindowVisible=false，因为mWindowVisible=false所以未显示输入法界面


上面的初始化过程很重要，很多对象进行了初始化在此过程中，后续MSG_SHOW_SOFT_INPUT的时候会用到上面的变量，输入法的变量而且比较多，需要慢慢梳理









沈纵情
关注
专栏目录
TypeError:__init__() got an unexpected keyword argunent ‘executable_path‘解决方案
weixin_43178406的博客
06-30 7万+
本文主要介绍了TypeError:__init__() got an unexpected keyword argunent 'executable_path’解决方案，希望能对学习selenium的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案 2.1 方案一 2.2 方案二
Flask-SQLAlchemy连接多个数据库（__bind_key__）---ORM（5）
Alien-Hu
07-15 5225
文章目录0.知识背景1.数据库模型类里面添加参数：2.初始化app的时候，需要绑定数据库的信息 0.知识背景 如下主要说明的是，连接某一个地址的数据库里面的不同库的方式 Flask-SQLAlchemy在设置SQLALCHEMY_DATABASE_URI的参数的时候，设置的数据库是默认的数据库，但是偶尔需要连接其他数据库的时候，无法访问到里面的表格，如何操作呢？ 1.数据库模型类里面添加参...
android onWindowsFocusChanged()
u013750244的博客
08-20 2222
概述 从字面上来讲，onWindowsFocusChanged()方法是指当窗口焦点变化的时候；从意义来说，onWindowsFocusChanged()就是指当前的Activity的Windows(窗口)获取或者失去焦点时这个方法就会被调用，并且当回调这个方法时，Activity是完全可见的。 在Activity生命周期中，onStart(), onResume(), onCreate()都不是布局visible的时间点，真正的visible时间点是onWindowFocusChanged()函数被执行时
android 输入法如何启动流程_Android输入法显示流程
Android framework
07-18 1461
android 输入法流程
Android Focused Window的更新
最新发布
薛文旺
06-29 940
App主线程调ViewRootImpl.java的relayoutWindow()；然后调用到Wms的relayoutWindow()，窗口布局流程。焦点窗口的更新，通过WMS#updateFocusedWindowLocked()方法开始
java 窗口 焦点事件_Java捕获窗口焦点事件
weixin_33782296的博客
02-13 296
package com.han;import java.awt.event.WindowEvent;import java.awt.event.WindowFocusListener;import javax.swing.JFrame;/*** 捕获窗口焦点事件* @author HAN**/public class WindowEvent_1 extends JFrame {/****/priv...
窗体触发事件之焦点以及状态转换
qq_36594703的博客
05-26 910
import java.awt.Frame; import java.awt.event.WindowEvent; import java.awt.event.WindowFocusListener; import java.awt.event.WindowStateListener; import javax.swing.JFrame; class WindowStateListener_Ex
JAVA_API1.6文档（中文）
04-12
javax.xml.bind.helpers 仅由 JAXB 提供者用于： 提供某些 javax.xml.bind 接口的部分默认实现。 javax.xml.bind.util 有用的客户端实用工具类。 javax.xml.crypto 用于 XML 加密的通用类。 javax.xml.crypto.dom...
[万字] eMMC 调试工具 | eMMC/MMC 性能测试工具 MMC -utils | DD test | FIO test | IOZone test| Kernal mmc test 实战
热门推荐
串起点滴
08-05 9万+
linux 和 Android emmc 性能测试主要有 4 种工具: DD FIO IOZone Keneral mmc_test
30.Python面向对象（三）【类方法和静态方法、动态绑定属性和__slots__限制绑定、@property】
孤寒者的博客
08-02 3万+
30.Python面向对象（三）【类方法和静态方法、动态绑定属性和__slots__限制绑定、@property】
Activity.onWindowFocusChanged()调用流程
weixin_34199335的博客
11-06 814
之前梳理了Activity的启动时序图，想着Activity.onWindowFocusChanged()的调用流程又是怎样的？追了下源码，梳理出来分享下。 首先看ActivityThread.handleResumeActivity() public final class ActivityThread { final void handleResumeActivity(IBinder...
Android输入法框架系统(下)
区块链斜杠青年(爱踢门)
05-29 5875
程序焦点获取事件导致输入法显示          从上面可以知道程序获得焦点时，程序端会先间接的调用IMMS的startInput将焦点View绑定到输入法，然后会调用IMMS的windowGainFocus函数，这个函数就可能显示输入法, 是否显示输入法由焦点view的属性决定。过程流程图如下：   IMMS处理逻辑   输入法响应显示请求          从上面可以看出，输入法响
Android 输入法窗口焦点获取流程(2) ,输入法窗口和应用窗口绑定
u010573857的博客
07-15 4046
Android焦点流程
Android InputMethod 源码分析，显示输入法流程
jieqiong1的博客
05-06 1万+
1.简介本文基于 android N，借鉴 http://blog.csdn.net/huangyabin001/article/details/28434989 ，记录一下输入法显示的流程，相当于一篇读书笔记，方便记忆与学习大体流程如下： InputMethodManagerService（下文也称IMMS）负责管理系统的所有输入法，包括输入法service(InputMethodServic
Android 输入法框架 （2）- 输入法显示和隐藏
Justwen26的博客
03-06 2021
通常显示或者隐藏输入法有以下三个场景 当一个窗口焦点改变的时候，会根据Window属性控制输入法的显示 App主动调用imm::showSoftInput或者imm::hideSoftinputFromWindow 输入法自己调用ims:requestShowSelf或者ims:requestHideSelf Window焦点改变 当window获得焦点时会调用imm::onPostWin...
touchmode
lizh的博客
04-04 400
针对source不是非touchscreen设备进行判断 <!-- Whether to start in touch mode --> <bool name="config_defaultInTouchMode">true</bool> 默认开启touchmode ViewRootImpl.java private int processPointerEvent(QueuedInputEvent q) { final MotionEvent event
android windowmanager 获取焦点,Activity.onWindowFocusChanged()调用流程
weixin_39974932的博客
06-03 1736
之前梳理了Activity的启动时序图，想着Activity.onWindowFocusChanged()的调用流程又是怎样的？追了下源码，梳理出来分享下。首先看ActivityThread.handleResumeActivity()public final class ActivityThread {final void handleResumeActivity(IBinder token, ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值