Android输入法框架系统(下)

时间：2022-04-18 04:38:33

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

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

Android输入法框架系统(下)

代码处理逻辑如下：

  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来处。处理逻辑如下：

Android输入法框架系统(下)

  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函数

Android输入法框架系统(下)

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

相关文章