Android输入法框架系统(下)

程序焦点获取事件导致输入法显示

从上面可以知道程序获得焦点时，程序端会先间接的调用IMMS的startInput将焦点View绑定到输入法，然后会调用IMMS的windowGainFocus函数，这个函数就可能显示输入法, 是否显示输入法由焦点view的属性决定。过程流程图如下：

代码处理逻辑如下：

1. //ViewRootImpl.java
2. case MSG_WINDOW_FOCUS_CHANGED: {
3. if (hasWindowFocus) {
4. if (imm != null && mLastWasImTarget && !isInLocalFocusMode()) {
5. imm.onWindowFocus(mView, mView.findFocus(),
6. mWindowAttributes.softInputMode,
7. !mHasHadWindowFocus, mWindowAttributes.flags);
8. }
9. }
10. }
11. //InputMethodManager
12. public void onWindowFocus(View rootView, View focusedView, int softInputMode,
13. boolean first, int windowFlags) {
14. boolean forceNewFocus = false;
15. synchronized (mH) {
16. //和上面view获取焦点事件的处理一样
17. focusInLocked(focusedView != null ? focusedView : rootView);
18. }
19. //确认当前focused view是否已经调用过startInputInner来绑定输入法
20. //因为在前面mView.dispatchWindowFocusChanged处理过程focused view已经完成
21. //了绑定，所以大部分情况下，该函数返回false，即不会再次调用startInputInner
22. if (checkFocusNoStartInput(forceNewFocus, true)) {
23. if (startInputInner(rootView.getWindowToken(),
24. controlFlags, softInputMode, windowFlags)) {
25. return;
26. }
27. }
28. synchronized (mH) {
29. try {
30. //调用IMMS windowGainedFocus函数
31. mService.windowGainedFocus(mClient, rootView.getWindowToken(),
32. controlFlags, softInputMode, windowFlags, null, null);
33. } catch (RemoteException e) {
34. }
35. }

输入法响应显示请求

从上面可以看出，输入法响应显示请求是通过IInputMethod，而这个是在输入法service完成启动通过onBind接口传递过去的，所以我们先来看下这个IInputMethod的实现是什么？

输入法service都是继承InputMethodService类

1. public class InputMethodService extends AbstractInputMethodService {
2. @Override
3. public AbstractInputMethodImpl onCreateInputMethodInterface() {
4. return new InputMethodImpl();
5. }
6. }
7. public abstract class AbstractInputMethodService extends Service
8. implements KeyEvent.Callback {
9. private InputMethod mInputMethod;
10. @Override
11. final public IBinder onBind(Intent intent) {
12. if (mInputMethod == null) {
13. mInputMethod = onCreateInputMethodInterface();
14. }
15. return new IInputMethodWrapper(this, mInputMethod);
16. }
17. }

从上可见IMMS保存的IInputMethod的实现是封装了InputMethodImpl的类IInputMethodWrapper，那肯定就是它负责处理消息MSG_SHOW_SOFT_INPUT，处理逻辑如下。

1. public IInputMethodWrapper(AbstractInputMethodService context,
2. InputMethod inputMethod) {
3. mTarget = new WeakReference<AbstractInputMethodService>(context);
4. mCaller = new HandlerCaller(context.getApplicationContext(), null,
5. this, true /*asyncHandler*/);
6. mInputMethod = new WeakReference<InputMethod>(inputMethod);
7. mTargetSdkVersion = context.getApplicationInfo().targetSdkVersion;
8. }
9. public InputMethod getInternalInputMethod() {
10. return mInputMethod.get();
11. }
12. @Override
13. public void executeMessage(Message msg) {
14. InputMethod inputMethod = mInputMethod.get();
15. switch (msg.what) {
16. case DO_SHOW_SOFT_INPUT:
17. //这个inputMethod是通过onCreateInputMethodInterface函数创建的
18. //InputMethodImpl对象
19. inputMethod.showSoftInput(msg.arg1, (ResultReceiver)msg.obj);
20. return;
21. }
22. }
23. public class InputMethodImpl extends AbstractInputMethodImpl {
24. public void showSoftInput(int flags, ResultReceiver resultReceiver) {
25. boolean wasVis = isInputViewShown();
26. mShowInputFlags = 0;
27. if (onShowInputRequested(flags, false)) {
28. try {
29. //这个是真正显示UI的函数
30. showWindow(true);
31. }
32. }
33. }
34. }
35. public class InputMethodService extends AbstractInputMethodService {
36. @Override public void onCreate() {
37. mTheme = Resources.selectSystemTheme(mTheme,
38. getApplicationInfo().targetSdkVersion,
39. android.R.style.Theme_InputMethod,
40. android.R.style.Theme_Holo_InputMethod,
41. android.R.style.Theme_DeviceDefault_InputMethod);
42. // SoftInputWindow就是大家一般用的Dialog的子类
43. mWindow = new SoftInputWindow(this, mTheme, mDispatcherState);
44. initViews();
45. mWindow.getWindow().setLayout(MATCH_PARENT, WRAP_CONTENT);
46. }
47. public void showWindow(boolean showInput) {
48. try {
49. mWindowWasVisible = mWindowVisible;
50. mInShowWindow = true;
51. showWindowInner(showInput);
52. } finally {
53. mWindowWasVisible = true;
54. mInShowWindow = false;
55. }
56. }
57. void showWindowInner(boolean showInput) {
58. initialize();
59. updateFullscreenMode();
60. //这个函数会创建输入法的键盘
61. updateInputViewShown();
62. if (!mWindowAdded || !mWindowCreated) {
63. mWindowAdded = true;
64. mWindowCreated = true;
65. initialize();
66. //创建输入法dialog里的词条选择View
67. View v = onCreateCandidatesView();
68. if (v != null) {
69. setCandidatesView(v);
70. }
71. }
72. if (mShowInputRequested) {
73. if (!mInputViewStarted) {
74. mInputViewStarted = true;
75. onStartInputView(mInputEditorInfo, false);
76. }
77. } else if (!mCandidatesViewStarted) {
78. mCandidatesViewStarted = true;
79. onStartCandidatesView(mInputEditorInfo, false);
80. }
81. if (!wasVisible) {
82. mImm.setImeWindowStatus(mToken, IME_ACTIVE, mBackDisposition);
83. onWindowShown();
84. //这个是Dialog的window,这里开始就显示UI了
85. mWindow.show();
86. }
87. }
88. public void updateInputViewShown() {
89. boolean isShown = mShowInputRequested && onEvaluateInputViewShown();
90. if (mIsInputViewShown != isShown && mWindowVisible) {
91. mIsInputViewShown = isShown;
92. mInputFrame.setVisibility(isShown ? View.VISIBLE : View.GONE);
93. if (mInputView == null) {
94. initialize();
95. //这个是核心view，创建显示键盘的根view
96. View v = onCreateInputView();
97. if (v != null) {
98. setInputView(v);
99. }
100. }
101. }
102. }
103. }

用户单击输入框View导致输入法显示

在上一篇InputChannel章节我们说到，事件传递到程序端，最后让ViewPostImeInputStage来处。处理逻辑如下：

1. final class ViewPostImeInputStage extends InputStage {
2. public ViewPostImeInputStage(InputStage next) {
3. super(next);
4. }
5. @Override
6. protected int onProcess(QueuedInputEvent q) {
7. if (q.mEvent instanceof KeyEvent) {
8. } else {
9. final int source = q.mEvent.getSource();
10. if ((source & InputDevice.SOURCE_CLASS_POINTER) != 0) {
11. //处理touch事件
12. return processPointerEvent(q);
13. }
14. }
15. }
16. private int processPointerEvent(QueuedInputEvent q) {
17. final MotionEvent event = (MotionEvent)q.mEvent;
18. if (mView.dispatchPointerEvent(event)) {
19. return FINISH_HANDLED;
20. }
21. return FORWARD;
22. }
23. }

从上可知最后会调用DecorView的dispatchPointerEvent，DecorView也是一个view,所以该函数其实就是View的dispatchPointerEvent函数。

1. //View.java
2. public final boolean dispatchPointerEvent(MotionEvent event) {
3. if (event.isTouchEvent()) {
4. return dispatchTouchEvent(event);
5. }
6. }
7. //DecorView又是一个ViewGroup，所以会调用ViewGroup的dispatchTouchEvent
8. //ViewGroup.java
9. public boolean dispatchTouchEvent(MotionEvent ev) {
10. if (mInputEventConsistencyVerifier != null) {
11. mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
12. }
13. boolean handled = false;
14. if (onFilterTouchEventForSecurity(ev)) {
15. final int action = ev.getAction();
16. final int actionMasked = action & MotionEvent.ACTION_MASK;
17. // Handle an initial down.
18. if (actionMasked == MotionEvent.ACTION_DOWN) {
19. // Throw away all previous state when starting a new touch gesture.
20. // The framework may have dropped the up or cancel event for the previous gesture
21. // due to an app switch, ANR, or some other state change.
22. cancelAndClearTouchTargets(ev);
23. resetTouchState();
24. }
25. // Check for interception.
26. final boolean intercepted;
27. if (actionMasked == MotionEvent.ACTION_DOWN
28. || mFirstTouchTarget != null) {
29. final boolean disallowIntercept = (mGroupFlags &
30. AG_DISALLOW_INTERCEPT) != 0;
31. if (!disallowIntercept) {
32. //先给该view一个处理事件的机会，如果Intercept，则事件不会往
33. //下发送
34. intercepted = onInterceptTouchEvent(ev);
35. ev.setAction(action); // restore action in case it was changed
36. } else {
37. intercepted = false;
38. }
39. } else {
40. // There are no touch targets and this action is not an initial down
41. // so this view group continues to intercept touches.
42. intercepted = true;
43. }
44. //按照冒泡法，将触摸事件传递给每个child处理
45. if (mFirstTouchTarget != null) {
46. // Dispatch to touch targets, excluding the new touch target if we already
47. // dispatched to it.  Cancel touch targets if necessary.
48. TouchTarget predecessor = null;
49. TouchTarget target = mFirstTouchTarget;
50. while (target != null) {
51. final TouchTarget next = target.next;
52. if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
53. handled = true;
54. } else {
55. final boolean cancelChild = resetCancelNextUpFlag(target.child)
56. || intercepted;
57. //真正处理函数
58. if (dispatchTransformedTouchEvent(ev, cancelChild,
59. target.child, target.pointerIdBits)) {
60. handled = true;
61. }
62. if (cancelChild) {
63. if (predecessor == null) {
64. mFirstTouchTarget = next;
65. } else {
66. predecessor.next = next;
67. }
68. target.recycle();
69. target = next;
70. continue;
71. }
72. }
73. predecessor = target;
74. target = next;
75. }
76. }
77. }
78. return handled;
79. }
80. private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
81. View child, int desiredPointerIdBits) {
82. // child == null意味着该parent已经调用完所有的child的dispatchTouchEvent
83. //所以从这里可以看出是child优先处理触摸事件的
84. if (child == null) {
85. handled = super.dispatchTouchEvent(transformedEvent);
86. } else {
87. handled = child.dispatchTouchEvent(transformedEvent);
88. }
89. return handled;
90. }
91. //这里的child如果仍就是一个ViewGroup，则和上面的逻辑一样。如果是一般的view，则
92. //直接调用view. dispatchTouchEvent
93. public boolean dispatchTouchEvent(MotionEvent event) {
94. if (onFilterTouchEventForSecurity(event)) {
95. //这个就是我们常使用view.setOnTouchListener调用保存下来的信息
96. ListenerInfo li = mListenerInfo;
97. if (li != null && li.mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED
98. && li.mOnTouchListener.onTouch(this, event)) {
99. return true;
100. }
101. //view的默认处理，即调用onTouchEvent函数
102. if (onTouchEvent(event)) {
103. return true;
104. }
105. }
106. return false;
107. }
108. //TextView.java
109. @Override
110. public boolean onTouchEvent(MotionEvent event) {
111. //非TextView只会执行View. onTouchEvent,该函数是另一种将view和输入法绑定的调用
112. //而TextView会调用imm.showSoftInput会显示输入法
113. final boolean superResult = super.onTouchEvent(event);
114. if ((mMovement != null || onCheckIsTextEditor()) && isEnabled()
115. && mText instanceof Spannable && mLayout != null) {
116. if (touchIsFinished && (isTextEditable() || textIsSelectable)) {
117. // Show the IME, except when selecting in read-only text.
118. final InputMethodManager imm = InputMethodManager.peekInstance();
119. viewClicked(imm);
120. //这个是真正显示输入法的调用
121. if (!textIsSelectable && mEditor.mShowSoftInputOnFocus) {
122. handled |= imm != null && imm.showSoftInput(this, 0);
123. }
124. handled = true;
125. }
126. if (handled) {
127. return true;
128. }
129. }
130. return superResult;
131. }
132. //View.java的onTouchEvent
133. public boolean onTouchEvent(MotionEvent event) {
134. final int viewFlags = mViewFlags;
135. if (((viewFlags & CLICKABLE) == CLICKABLE ||
136. (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
137. switch (event.getAction()) {
138. case MotionEvent.ACTION_UP:
139. boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
140. if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
141. // take focus if we don't have it already and we should in
142. // touch mode.
143. boolean focusTaken = false;
144. //让view获得焦点
145. if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
146. focusTaken = requestFocus();
147. }
148. }
149. break;
150. }
151. return true;
152. }
153. return false;
154. }
155. public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
156. return requestFocusNoSearch(direction, previouslyFocusedRect);
157. }
158. private boolean requestFocusNoSearch(int direction, Rect previouslyFocusedRect) {
159. // 该view必须是可以获取焦点的
160. if ((mViewFlags & FOCUSABLE_MASK) != FOCUSABLE ||
161. (mViewFlags & VISIBILITY_MASK) != VISIBLE) {
162. return false;
163. }
164. // 这个检查得到对象大家可能经常用过，就是这个属性
165. //android:descendantFocusability=”blocksDescendants”，这个属性可以解决listView
166. //等容器类View没法获取点击事件问题,它的实现就在此，当父亲设置了这个属性
167. //子view就没法获取焦点了
168. if (hasAncestorThatBlocksDescendantFocus()) {
169. return false;
170. }
171. //获取焦点处理逻辑
172. handleFocusGainInternal(direction, previouslyFocusedRect);
173. return true;
174. }
175. void handleFocusGainInternal(int direction, Rect previouslyFocusedRect) {
176. if ((mPrivateFlags & PFLAG_FOCUSED) == 0) {
177. mPrivateFlags |= PFLAG_FOCUSED;
178. View oldFocus = (mAttachInfo != null) ? getRootView().findFocus() : null;
179. //由于当前焦点view没法知道旧的焦点view,没法告知旧的焦点view失去焦点
180. //所以必须叫父亲去做这个事情
181. if (mP arent != null) {
182. mParent.requestChildFocus(this, this);
183. }
184. //这个函数很重要，编辑类view(比如TextEditor)和普通view的差别就在此
185. //和输入法相关的处理也在此
186. onFocusChanged(true, direction, previouslyFocusedRect);
187. refreshDrawableState();
188. }
189. }
190. //基类View的处理：
191. protected void onFocusChanged(boolean gainFocus, int direction, Rect previouslyFocusedRect) {
192. InputMethodManager imm = InputMethodManager.peekInstance();
193. if (!gainFocus) {
194. } else if (imm != null && mAttachInfo != null
195. && mAttachInfo.mHasWindowFocus) {
196. //通知IMMS该view获得了焦点，到此，这后面的逻辑就和上面的window获
197. //得焦点导致view和输入法绑定的逻辑一样了
198. imm.focusIn(this);
199. }
200. }

输入法传递输入文本信息给view

输入法如何获得输入文本信息通信接口

从上面的输入法绑定的分析中可以知道，输入法其startInput接口被调用的时候获得了文本信息通信接口，这个通信接口是IInputContext的封装InputConnection，获取点如下：

1. //InputMethodService.java
2. void doStartInput(InputConnection ic, EditorInfo attribute, boolean restarting) {
3. if (!restarting) {
4. doFinishInput();
5. }
6. mInputStarted = true;
7. //这个就是通信接口
8. mStartedInputConnection = ic;
9. }
10. public InputConnection getCurrentInputConnection() {
11. InputConnection ic = mStartedInputConnection;
12. if (ic != null) {
13. return ic;
14. }
15. return mInputConnection;
16. }

输入法如何传递文本信息给view

从上可见，输入法要传递文本信息时，肯定是先调用getCurrentInputConnection拿到接口，然后再传递信息，我们以pinyin输入法的实现来解释这个过程。

Pinyin输入法传递输入信息最后都会调用到sendKeyChar函数

1. public void sendKeyChar(char charCode) {
2. switch (charCode) {
3. case '\n': // Apps may be listening to an enter key to perform an action
4. if (!sendDefaultEditorAction(true)) {
5. sendDownUpKeyEvents(KeyEvent.KEYCODE_ENTER);
6. }
7. break;
8. default:
9. // Make sure that digits go through any text watcher on the client side.
10. if (charCode >= '0' && charCode <= '9') {
11. sendDownUpKeyEvents(charCode - '0' + KeyEvent.KEYCODE_0);
12. } else {
13. InputConnection ic = getCurrentInputConnection();
14. if (ic != null) {
15. //这个是真正传递信息到view的跨进程接口
16. ic.commitText(String.valueOf((char) charCode), 1);
17. }
18. }
19. break;
20. }
21. }

View接收输入文本信息

从上面可知，输入法端最后会通过InputConnection逻辑来传递文本信息，那程序view端的InputConnection是如何创建的呢？

1. //InputMethodManager.java
2. boolean startInputInner(IBinder windowGainingFocus, int controlFlags, int softInputMode,
3. EditorInfo tba = new EditorInfo();
4. tba.packageName = view.getContext().getPackageName();
5. tba.fieldId = view.getId();
6. //由具体的view创建
7. InputConnection ic = view.onCreateInputConnection(tba);
8. return true;
9. }
10. //我们先看下textView会创建怎样的InputConnection？
11. //TextView.java
12. @Override
13. public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
14. {
15. outAttrs.hintText = mHint;
16. if (mText instanceof Editable) {
17. //露面了，是 EditableInputConnection, textView作为参数传入
18. InputConnection ic = new EditableInputConnection(this);
19. return ic;
20. }
21. }
22. return null;
23. }

接下来肯定是EditableInputConnection 接收文本消息了

1. public class EditableInputConnection extends BaseInputConnection {
2. //该函数很重要，super.commitText会将字符添加到Editable里
3. @Override
4. public Editable getEditable() {
5. TextView tv = mTextView;
6. if (tv != null) {
7. return tv.getEditableText();
8. }
9. return null;
10. }
11. @Override
12. public boolean commitText(CharSequence text, int newCursorPosition) {
13. mTextView.resetErrorChangedFlag();
14. //调用父类的方法
15. boolean success = super.commitText(text, newCursorPosition);
16. mTextView.hideErrorIfUnchanged();
17. return success;
18. }
19. }
20. public class BaseInputConnection implements InputConnection {
21. public boolean commitText(CharSequence text, int newCursorPosition) {
22. replaceText(text, newCursorPosition, false);
23. sendCurrentText();
24. return true;
25. }
26. private void replaceText(CharSequence text, int newCursorPosition,
27. boolean composing) {
28. //获取eidtor
29. final Editable content = getEditable();
30. if (content == null) {
31. return;
32. }
33. beginBatchEdit();
34. ………………..
35. //修改editor
36. content.replace(a, b, text);
37. endBatchEdit();
38. }
39. private void sendCurrentText() {
40. Editable content = getEditable();
41. if (content != null) {
42. final int N = content.length();
43. // 将输入文本模拟为为一个key事件，这样view就会更新内容了
44. KeyEvent event = new KeyEvent(SystemClock.uptimeMillis(),
45. content.toString(), KeyCharacterMap.VIRTUAL_KEYBOARD, 0);
46. sendKeyEvent(event);
47. content.clear();
48. }
49. }
50. public boolean sendKeyEvent(KeyEvent event) {
51. //同ViewRootImpl有按键事件，到此为止就像是外接键盘的按键事件似的
52. synchronized (mIMM.mH) {
53. ViewRootImpl viewRootImpl = mTargetView != null ? mTargetView.getViewRootImpl() : null;
54. if (viewRootImpl == null) {
55. if (mIMM.mServedView != null) {
56. viewRootImpl = mIMM.mServedView.getViewRootImpl();
57. }
58. }
59. if (viewRootImpl != null) {
60. //发送信息
61. viewRootImpl.dispatchKeyFromIme(event);
62. }
63. }