android输入法01：SoftKeyboard源码解析03

4、SoftKeyboard

 /**
  * Example of writing an input method for a soft keyboard.  This code is
  * focused on simplicity over completeness, so it should in no way be considered
  * to be a complete soft keyboard implementation.  Its purpose is to provide
  * a basic example for how you would get started writing an input method, to
  * be fleshed out as appropriate.
  */
 public class SoftKeyboard extends InputMethodService
         implements KeyboardView.OnKeyboardActionListener {
     static final boolean DEBUG = false;

     /**
      * This boolean indicates the optional example code for performing
      * processing of hard keys in addition to regular text generation
      * from on-screen interaction.  It would be used for input methods that
      * perform language translations (such as converting text entered on
      * a QWERTY keyboard to Chinese), but may not be used for input methods
      * that are primarily intended to be used for on-screen text entry.
      */
   //是否在用硬键盘，这里默认的是总可以使用,费柴变量
     static final boolean PROCESS_HARD_KEYS = true;

   //键盘view对象,但不是自己定义的类latinkeyboardview....
     private KeyboardView mInputView;
     //候选栏对象
     private CandidateView mCandidateView;
   //候选串之串
     private CompletionInfo[] mCompletions;

     private StringBuilder mComposing = new StringBuilder();
     //这东西是决定能不能有候选条
     private boolean mPredictionOn;
   //决定auto是否需要显示在候选栏
     private boolean mCompletionOn;

     private int mLastDisplayWidth;
     private boolean mCapsLock;
     private long mLastShiftTime;
     //matakey的按下状态，猜测是每种组合对应一个此值？
     private long mMetaState;

     private LatinKeyboard mSymbolsKeyboard;
     private LatinKeyboard mSymbolsShiftedKeyboard;
     private LatinKeyboard mQwertyKeyboard;

   //当前键盘
     private LatinKeyboard mCurKeyboard;

     //默认的使得输入中断的字符
     private String mWordSeparators;

     /**
      * Main initialization of the input method component.  Be sure to call
      * to super class.
      */
     @Override public void onCreate() {
         super.onCreate();
       //对resource这个东西有了一些了解：getResources是contextWrapper类的函数，contextWrapper而是inputmethodservice
       //的间接基类
         mWordSeparators = getResources().getString(R.string.word_separators);
         Log.i("mytest", "SoftKeyboard_onCreate");
     }

     /**
      * This is the point where you can do all of your UI initialization.  It
      * is called after creation and any configuration change.
      */
     @Override public void onInitializeInterface() {
         Log.i("mytest", "SoftKeyboard_onInitializeInterface");
         //这只加载键盘，类似于findViewById，离真正生成界面还早
         if (mQwertyKeyboard != null) {
             // Configuration changes can happen after the keyboard gets recreated,
             // so we need to be able to re-build the keyboards if the available
             // space has changed.
             //可用的，最大屏幕宽度，好像也没什么用
             int displayWidth = getMaxWidth();
             if (displayWidth == mLastDisplayWidth) return;
           //难道就是为了记录最大宽度于mLastDisplayWidth？
             mLastDisplayWidth = displayWidth;
         }
         mQwertyKeyboard = new LatinKeyboard(this, R.xml.qwerty);
         mSymbolsKeyboard = new LatinKeyboard(this, R.xml.symbols);
         mSymbolsShiftedKeyboard = new LatinKeyboard(this, R.xml.symbols_shift);
     }

     /**
      * Called by the framework when your view for creating input needs to
      * be generated.  This will be called the first time your input method
      * is displayed, and every time it needs to be re-created such as due to
      * a configuration change.
      */
     @Override public View onCreateInputView() {
         Log.i("mytest", "SoftKeyboard_onCreateInputView");
         mInputView = (KeyboardView) getLayoutInflater().inflate(
                 R.layout.input, null);
       //上边的函数findViewById对于keyboardView是不能用的
       //只对TextView等可以用
         mInputView.setOnKeyboardActionListener(this);
         mInputView.setKeyboard(mQwertyKeyboard);
         //通过这个return,自己定义的keyboardview类对象就与这个类绑定了
         return mInputView;
     }

     /**
      * Called by the framework when your view for showing candidates needs to
      * be generated, like {@link #onCreateInputView}.
      */
     @Override public View onCreateCandidatesView() {
         Log.i("mytest", "SoftKeyboard_onCreateCandidatesView");
         mCandidateView = new CandidateView(this);
         //为什么参数是this??因为activity,inputmethodservice,这都是context的派生类
         mCandidateView.setService(this);//在CandidateView类里面对这个类的描述中，参数就是个
         return mCandidateView; //这一步很重要，后面的setCandidatesViewShown(false);就是个返回的结果造成的？
     }

     /**
      * This is the main point where we do our initialization of the input method
      * to begin operating on an application.  At this point we have been
      * bound to the client, and are now receiving all of the detailed information
      * about the target of our edits.
      */
     @Override public void onStartInput(EditorInfo attribute, boolean restarting) {
         super.onStartInput(attribute, restarting);
         Log.i("mytest", "SoftKeyboard_onStartInput");
         // Reset our state.  We want to do this even if restarting, because
         // the underlying state of the text editor could have changed in any way.
       //一个StringBuilder,前面定义的
         mComposing.setLength(0);
         updateCandidates();//可知此处的candidateview注定还不显示

         if (!restarting) {
             // Clear shift states.
             mMetaState = 0;
         }

         mPredictionOn = false; //猜测：是否需要显示候选词条,证实确实如此
         mCompletionOn = false; //允许auto的内容显示在后选栏中
         mCompletions = null;

         // We are now going to initialize our state based on the type of
         // text being edited.
       //一个靠谱的猜测：inputtype的给定值里面有那么几个掩码，但是从参数传来的具体inputtype值里面包含了所有的信息，不同的掩码能够得出不同的信息
       //例如TYPE_MASK_CLASS就能得出下面四种，这四种属于同一类期望信息，这个信息叫做CLASS,下面一个掩码TYPE_MASK_VARIATION按位与出来的是一类
       //叫做VARIATION的信息
         switch (attribute.inputType&EditorInfo.TYPE_MASK_CLASS) {
             case EditorInfo.TYPE_CLASS_NUMBER:
             case EditorInfo.TYPE_CLASS_DATETIME:
                 // Numbers and dates default to the symbols keyboard, with
                 // no extra features.
                 mCurKeyboard = mSymbolsKeyboard;
                 break;

             case EditorInfo.TYPE_CLASS_PHONE:
                 // Phones will also default to the symbols keyboard, though
                 // often you will want to have a dedicated phone keyboard.
                 mCurKeyboard = mSymbolsKeyboard;
                 break;

             case EditorInfo.TYPE_CLASS_TEXT:
                 // This is general text editing.  We will default to the
                 // normal alphabetic keyboard, and assume that we should
                 // be doing predictive text (showing candidates as the
                 // user types).
                 mCurKeyboard = mQwertyKeyboard;
                 mPredictionOn = true;

                 // We now look for a few special variations of text that will
                 // modify our behavior.
                 int variation = attribute.inputType &  EditorInfo.TYPE_MASK_VARIATION;
                 if (variation == EditorInfo.TYPE_TEXT_VARIATION_PASSWORD ||
                         variation == EditorInfo.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD) {
                     // Do not display predictions / what the user is typing
                     // when they are entering a password.
                     mPredictionOn = false; //密码框的输入是不需要候选词条的
                 }

                 if (variation == EditorInfo.TYPE_TEXT_VARIATION_EMAIL_ADDRESS
                         || variation == EditorInfo.TYPE_TEXT_VARIATION_URI
                         || variation == EditorInfo.TYPE_TEXT_VARIATION_FILTER) {
                     // Our predictions are not useful for e-mail addresses
                     // or URIs.
                     mPredictionOn = false;   //如果是网站或者是邮箱地址，不用候选词条
                 }

                 if ((attribute.inputType&EditorInfo.TYPE_TEXT_FLAG_AUTO_COMPLETE) != 0) {
                      //开始界面的那个输入框，就是自动生成的
                     // If this is an auto-complete text view, then our predictions
                     // will not be shown and instead we will allow the editor
                     // to supply their own.  We only show the editor's
                     // candidates when in fullscreen mode, otherwise relying
                     // own it displaying its own UI.
                     mPredictionOn = false;
                   //经过测试，当输入法处在全屏模式的时候，原本auto的候选词会显示在输入法的候选栏中
                   //这是mCompletiOn的作用，这个值初始化设为false.
                   //如果把这里的两个值都设置为true则可以发现再输入任意auto的时候都会在候选栏中显示auto的词语
                   //所以，变量mCompletionOn的后续作用需要监视

                   //这两行做后续测试： 真值：false,isFullscreenMode()
                     mCompletionOn = isFullscreenMode();
                 }

                 // We also want to look at the current state of the editor
                 // to decide whether our alphabetic keyboard should start out
                 // shifted.
                 updateShiftKeyState(attribute);
                 break;

             default:
                 // For all unknown input types, default to the alphabetic
                 // keyboard with no special features.
                 mCurKeyboard = mQwertyKeyboard;
                 updateShiftKeyState(attribute);//决定是否需要初始大写状态
         }

         // Update the label on the enter key, depending on what the application
         // says it will do.
         mCurKeyboard.setImeOptions(getResources(), attribute.imeOptions);//根据输入目标设置回车键
     }

     /**
      * This is called when the user is done editing a field.  We can use
      * this to reset our state.
      */
     @Override public void onFinishInput() {
         super.onFinishInput();
         Log.i("mytest", "SoftKeyboard_onFinishInput");
         //经测试，终于发现，start与finish,在输入框切换的时候，平时这俩结束函数并不调用，或许输入框只是隐藏。

       //测试语句      mInputView=null;
         // Clear current composing text and candidates.
         mComposing.setLength(0);
         updateCandidates();

         // We only hide the candidates window when finishing input on
         // a particular editor, to avoid popping the underlying application
         // up and down if the user is entering text into the bottom of
         // its window.
         setCandidatesViewShown(false);//默认的就是不可见的

         mCurKeyboard = mQwertyKeyboard;
         if (mInputView != null) {
             mInputView.closing(); //据分析，关闭输入界面和收起输入界面还不是一回事？
         }
     }

     @Override public void onStartInputView(EditorInfo attribute, boolean restarting) {
         super.onStartInputView(attribute, restarting);
       //如果没有这个函数的作用，在切换输入目标的时候不会发生键盘的变化
       //而且经过测试，这个函数执行的时间是开始输入的时候
         // Apply the selected keyboard to the input view.
         Log.i("mytest", "SoftKeyboard_onStartInputView");
         mInputView.setKeyboard(mCurKeyboard);
         //这个是转换键盘的关键
       //mInputView是自己定义的一个键盘
         mInputView.closing(); //这个语句能让整个需要输入的目标关闭？到底是干什么用的？？疑问？
     }

     /**
      * Deal with the editor reporting movement of its cursor.
      */
     @Override public void onUpdateSelection(int oldSelStart, int oldSelEnd,
             int newSelStart, int newSelEnd,
             int candidatesStart, int candidatesEnd) {
         //光标！
         super.onUpdateSelection(oldSelStart, oldSelEnd, newSelStart, newSelEnd,
                 candidatesStart, candidatesEnd);
         Log.i("mytest", "SoftKeyboard_onUpdateSelection");
         // If the current selection in the text view changes, we should
         // clear whatever candidate text we have.
       //当输入框向输入法报告用户移动了光标时调用。，当用户移动输入框中的光标的时候，它就默认的表示本次输入完成了，
       //然后将候选词以及正在输入的文本复位，并且向编辑器报告输入法已经完成了一个输入。
       //四个整形都是坐标？
         if (mComposing.length() > 0 && (newSelStart != candidatesEnd
                 || newSelEnd != candidatesEnd)) {
             mComposing.setLength(0);//这才是候选栏置空的精义所在
             updateCandidates();//候选栏置空
             InputConnection ic = getCurrentInputConnection(); //这个语句和下面if里面那个，决定了结束输入的全过程
             if (ic != null) {
                 ic.finishComposingText();//这个语句的作用是，让输入目标内的下划线去掉，完成一次编辑
             }
         }
     }

     /**
      * This tells us about completions that the editor has determined based
      * on the current text in it.  We want to use this in fullscreen mode
      * to show the completions ourself, since the editor can not be seen
      * in that situation.
      */
     @Override public void onDisplayCompletions(CompletionInfo[] completions) {
         //当需要在候选栏里面显示auto的内容
         //此函数作用，猜测：当全屏幕模式的时候，mCompletionOn置true,可以通过候选栏来显示auto
         Log.i("mytest", "SoftKeyboard_onDisplayCompletions");
         if (mCompletionOn) { //必须这个变量允许
             mCompletions = completions; //赋值给本来里面专门记录候选值的变量
             if (completions == null) {
                 setSuggestions(null, false, false); //如果没有候选词，就这样处置
                 return;
             }

             List<String> stringList = new ArrayList<String>();
             for (int i=0; i<(completions != null ? completions.length : 0); i++) {
                 CompletionInfo ci = completions[i];
                 if (ci != null) stringList.add(ci.getText().toString());
             }
             setSuggestions(stringList, true, true);
         }
     }

     /**
      * This translates incoming hard key events in to edit operations on an
      * InputConnection.  It is only needed when using the
      * PROCESS_HARD_KEYS option.
      */
     private boolean translateKeyDown(int keyCode, KeyEvent event) {
         //这个函数在OnKeyDown中用到了
         //这个是当组合键时候用，shift+A或者别的Alt+A之类
         Log.i("mytest", "SoftKeyboard_translateKeyDown");
         mMetaState = MetaKeyKeyListener.handleKeyDown(mMetaState,
                 keyCode, event);
       //处理matakey的按下，猜测：每一个long型的mMetaState值都代表着一个meta键组合值。8成是对的
         int c = event.getUnicodeChar(MetaKeyKeyListener.getMetaState(mMetaState)); //如果没这套组合键，就返回0
         //这又是在干什么？猜测：每一个mMetaState值，对应着一个unicode值，这一步就是为了得到它，此猜测正确
       //重置这个元状态。当取得了C值之后，完全可以重置元状态了，后面的语句不会出现任何问题。
         //上面这三行有点疑问
         mMetaState = MetaKeyKeyListener.adjustMetaAfterKeypress(mMetaState);

       //后边这函数是inputmethodservice自己的，获得当前的链接
         InputConnection ic = getCurrentInputConnection();
         if (c == 0 || ic == null) {
             return false;
         }

       //一个dead=true意味着是一个有定义的组合键
         boolean dead = false;

       //看看c所昭示的这个键能不能被允许组合键
         if ((c & KeyCharacterMap.COMBINING_ACCENT) != 0) {
              //定义下来看能否使用这个组合键
             dead = true;
           //这样就得到了真正的码值
             c = c & KeyCharacterMap.COMBINING_ACCENT_MASK;
         }

       //这是处理“编辑中最后字符越变”的情况
         if (mComposing.length() > 0) {
             char accent = mComposing.charAt(mComposing.length() -1 );//返回正在编辑的字串的最后一个字符
             //这种情况下最后是返回了新的阿斯课码。composed最终还是要还给c.作为onKey的参数。
             int composed = KeyEvent.getDeadChar(accent, c);

             if (composed != 0) {
                 c = composed;
                 mComposing.setLength(mComposing.length()-1); // 要把最后一个字符去掉，才能够在下一步中越变成为新的字符
             }
         }

         onKey(c, null); //强制输入C,这样就实现了组合键的功效

         return true;
     }

     /**
      * Use this to monitor key events being delivered to the application.
      * We get first crack at them, and can either resume them or let them
      * continue to the app.
      */
     @Override public boolean onKeyDown(int keyCode, KeyEvent event) {
         Log.i("mytest", "SoftKeyboard_onKeyDown");
         //这是重载了基类的,经测试确定，只有在硬件盘被敲击时候才调用，除了那个键本身的功效，还有这里定义的这些
         //是对输入法的影响
         switch (keyCode) {
             case KeyEvent.KEYCODE_BACK: //这就是那个破箭头，扭曲的
                 // The InputMethodService already takes care of the back
                 // key for us, to dismiss the input method if it is shown.
                 // However, our keyboard could be showing a pop-up window
                 // that back should dismiss, so we first allow it to do that.
                 //mInputView类是自己定义的keyBoardView类
                 if (event.getRepeatCount() == 0 && mInputView != null) {
                     if (mInputView.handleBack()) {//通过弯钩键来关闭键盘的元凶在这里
                         //这函数干吗呢？猜测：如果成功地荡掉了键盘，就返回真
                         return true;
                     }
                 }
                 break;

             case KeyEvent.KEYCODE_DEL:
                 // Special handling of the delete key: if we currently are
                 // composing text for the user, we want to modify that instead
                 // of let the application to the delete itself.
                 if (mComposing.length() > 0) {
                     onKey(Keyboard.KEYCODE_DELETE, null); //所以，onkey定义中的事情才是软键盘的事件
                     return true;
                 }
                 break;

             case KeyEvent.KEYCODE_ENTER:
                 // Let the underlying text editor always handle these.
                 return false;

             default:
                 // For all other keys, if we want to do transformations on
                 // text being entered with a hard keyboard, we need to process
                 // it and do the appropriate action.
                 if (PROCESS_HARD_KEYS) {  //这个是个废柴变量，因为在前面赋值了，永远是true
                     if (keyCode == KeyEvent.KEYCODE_SPACE
                             && (event.getMetaState()&KeyEvent.META_ALT_ON) != 0) {
                         //为什么有这个按位与？因为这个META_ALT_ON就是用来按位与来判断是否按下alt
                         //条件：alt+空格
                         // A silly example: in our input method, Alt+Space
                         // is a shortcut for 'android' in lower case.
                         InputConnection ic = getCurrentInputConnection();
                         if (ic != null) {
                             // First, tell the editor that it is no longer in the
                             // shift state, since we are consuming this.
                             ic.clearMetaKeyStates(KeyEvent.META_ALT_ON);// 清除组合键状态，如果不清除，出来的字符就不是Android
                           //由此可知，这些函数才是控制显示字符的，但貌似没那么简单
                             keyDownUp(KeyEvent.KEYCODE_A);
                             keyDownUp(KeyEvent.KEYCODE_N);
                             keyDownUp(KeyEvent.KEYCODE_D);
                             keyDownUp(KeyEvent.KEYCODE_R);
                             keyDownUp(KeyEvent.KEYCODE_O);
                             keyDownUp(KeyEvent.KEYCODE_I);
                             keyDownUp(KeyEvent.KEYCODE_D);
                             // And we consume this event.
                             return true;
                         }
                     }
                     if (mPredictionOn && translateKeyDown(keyCode, event)) {
                         return true;
                     }
                 }
         }

         return super.onKeyDown(keyCode, event);
     }

     /**
      * Use this to monitor key events being delivered to the application.
      * We get first crack at them, and can either resume them or let them
      * continue to the app.
      */
     @Override public boolean onKeyUp(int keyCode, KeyEvent event) {
         // If we want to do transformations on text being entered with a hard
         // keyboard, we need to process the up events to update the meta key
         // state we are tracking.
         Log.i("mytest", "SoftKeyboard_onKeyUp");
         if (PROCESS_HARD_KEYS) {
              //哈哈，判断是不在使用硬件输入
             //要懂得，mete keys意味着shift和alt这类的键
             if (mPredictionOn) {
                 //处理matakey的释放
                 mMetaState = MetaKeyKeyListener.handleKeyUp(mMetaState,
                         keyCode, event);
             }
         }
       //只有在一个键被放起时候执行,但经过测试，他不是执行输入的，仅仅是再输入之前做些事务，
         return super.onKeyUp(keyCode, event);
     }

     /**
      * Helper function to commit any text being composed in to the editor.
      */
     private void commitTyped(InputConnection inputConnection) {
         Log.i("mytest", "SoftKeyboard_commitTyped");
         if (mComposing.length() > 0) {
             inputConnection.commitText(mComposing, mComposing.length()); //后边的参数决定了光标的应有位置
             mComposing.setLength(0);
             updateCandidates();//这两行联手，一般能造成候选栏置空与候选词条串置空的效果
         }
     }

     /**
      * Helper to update the shift state of our keyboard based on the initial
      * editor state.
      */
     private void updateShiftKeyState(EditorInfo attr) {
          //但是，这个函数每次输入一个字母都要执行
         //用于在开始输入前切换大写
         //它首先是判断是否输入视图存在，并且输入框要求有输入法，然后根据输入框的输入类型来获得是否需要大小写，最后定义在输入视图上。
         //经测试，每当键盘刚出来的时候会有，每输入一个字符都会有这个函数的作用
         Log.i("mytest", "SoftKeyboard_updateShiftKeyState");
         //getKeyboard又是个可得私有变量的公有函数
         //条件的含义是：当有字母键盘存在的时候
         if (attr != null
                 && mInputView != null && mQwertyKeyboard == mInputView.getKeyboard()) {
             int caps = 0;
             EditorInfo ei = getCurrentInputEditorInfo(); //获得当前输入框的信息？本.java中，大多数的attr参数于这个东西等同
           //这个破inputtype类型是全0，一般不会有这种破类型
             if (ei != null && ei.inputType != EditorInfo.TYPE_NULL) {
                 caps = getCurrentInputConnection().getCursorCapsMode(attr.inputType);//返回的东西不是光标位置，得到的是
               //是否需要大写的判断，但是返回值是怎么弄的？？
             }
             mInputView.setShifted(mCapsLock || caps != 0);
         }
     }

     /**
      * Helper to determine if a given character code is alphabetic.
      */
     private boolean isAlphabet(int code) {
         //看看是不是字母
         Log.i("mytest", "SoftKeyboard_isAlphabet");
         if (Character.isLetter(code)) {
             return true;
         } else {
             return false;
         }
     }

     /**
      * Helper to send a key down / key up pair to the current editor.
      */
     private void keyDownUp(int keyEventCode) {
         Log.i("mytest", "SoftKeyboard_keyDownUp");
         getCurrentInputConnection().sendKeyEvent(
                 new KeyEvent(KeyEvent.ACTION_DOWN, keyEventCode)); //参见文档中KeyEvent
         getCurrentInputConnection().sendKeyEvent(
                 new KeyEvent(KeyEvent.ACTION_UP, keyEventCode));
         //明白了，这个函数是用来特殊输出的，就好像前面定义的“android”输出，但如果简单地从键盘输入字符，是不会经过这一步的
       //一点都没错，强制输出，特殊输出，就这里
       //  keyDownUp(KeyEvent.KEYCODE_N);
       //  keyDownUp(KeyEvent.KEYCODE_B);
     }

     /**
      * Helper to send a character to the editor as raw key events.
      */
     private void sendKey(int keyCode) {
          //传入的参数是阿斯课码
         //处理中断符的时候使用到了
         Log.i("mytest", "SoftKeyboard_sendKey");
         switch (keyCode) {
             case '\n':
                 keyDownUp(KeyEvent.KEYCODE_ENTER);
                 break;
             default:
                 if (keyCode >= '0' && keyCode <= '9') {
                     keyDownUp(keyCode - '0' + KeyEvent.KEYCODE_0);
                 } else {
                     getCurrentInputConnection().commitText(String.valueOf((char) keyCode), 1);
                 }
                 break;
         }
     }

     // Implementation of KeyboardViewListener
  // Implementation of KeyboardViewListener
   //你难道没看见这个类定义时候的接口吗？那个接口定义的监听函数就是为了监听这种On事件的，这就是软键盘按压事件
     public void onKey(int primaryCode, int[] keyCodes) {
         Log.i("mytest", "SoftKeyboard_onKey");
          //后面定义的函数
         //当输入被中断符号中断
         if (isWordSeparator(primaryCode)) {
             // Handle separator
             if (mComposing.length() > 0) {
                 commitTyped(getCurrentInputConnection());
             }
             sendKey(primaryCode); //提交完了输出之后，还必须要把这个特殊字符写上
             updateShiftKeyState(getCurrentInputEditorInfo());//看看是否到了特殊的位置，需要改变大小写状态
         } else if (primaryCode == Keyboard.KEYCODE_DELETE) {
             handleBackspace();
         } else if (primaryCode == Keyboard.KEYCODE_SHIFT) {
             handleShift();
         } else if (primaryCode == Keyboard.KEYCODE_CANCEL) { //左下角那个键，关闭
             handleClose();
             return;
         } else if (primaryCode == LatinKeyboardView.KEYCODE_OPTIONS) {
             //这个键，是这样的，前面的LatinKeyboardView这个类里面定义了KEYCODE_OPTIONS
             //用来描述长按左下角关闭键的代替。经测试，千真万确
             // Show a menu or somethin'
         } else if (primaryCode == Keyboard.KEYCODE_MODE_CHANGE
                 && mInputView != null) { //就是显示着“abc”或者"123"的那个键
             Keyboard current = mInputView.getKeyboard();
             if (current == mSymbolsKeyboard || current == mSymbolsShiftedKeyboard) {
                 current = mQwertyKeyboard;
             }