Android 键盘和activity生命周期管理

package com.ebensz.enote.draft.input;


import android.app.Activity;
import android.app.Application;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.KeyEvent;
import android.view.inputmethod.BaseInputConnection;
import android.view.inputmethod.InputConnection;
import android.view.inputmethod.InputMethodManager;
import com.ebensz.enote.draft.ENoteWriterActivity;
import com.ebensz.enote.draft.enote.EnoteEditor;
import com.ebensz.enote.draft.util.Log;
import com.ebensz.pennable.enote.content.Word;


import java.util.ArrayList;
import java.util.List;


/**
 * User: YJ.Huang
 * Date: 13-8-8
 * Time: 下午5:40
 * 调用系统软键盘管理类
 */
public class SoftKeyboardManager implements Application.ActivityLifecycleCallbacks {


    private static  SoftKeyboardManager mManager;




    private static InputConnection mInputConnection;


    private static EnoteInputEditor mEnoteInputEditor;


    /**
     *当前键盘的状态
     * true-显示  false-隐藏
     */
    public  boolean gKeyboardCurrentStatus;


    public   boolean mNeedCallback ;


    /**
     * 键盘有没有隐藏
     * true-键盘有临时隐藏，反之 没有临时隐藏
     */
    public static boolean gKeyboardHasHide =false;


    private static final int KEYBOARD_HIDE = 0X01;
    private static final int KEYBOARD_SHOW = 0X02;


    private SoftKeyboardManager(){
    }


    public static synchronized SoftKeyboardManager getInstance(){
        if(mManager == null){
              mManager = new SoftKeyboardManager();
        }
        return mManager;
    }


    private   Handler mHandler = new Handler(){


        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case KEYBOARD_HIDE:
                    hideKeywordTemp(true);
                    break;
                case KEYBOARD_SHOW:
                    hideKeywordTemp(false);
                    break;
                default:
                    break;


            }
            super.handleMessage(msg);    //To change body of overridden methods use File | Settings | File Templates.
        }
    };


    public   InputConnection getInputConnection(EnoteInputEditor enoteInputEditor){
        mEnoteInputEditor = enoteInputEditor;
        ((Application)mEnoteInputEditor.getContext().getApplicationContext()).registerActivityLifecycleCallbacks(this);
        mInputConnection = new BaseInputConnection(mEnoteInputEditor, false){
         EnoteEditor enoteEditor = mEnoteInputEditor.getEnoteEditor();


            @Override
            public boolean commitText(CharSequence text, int newCursorPosition) {
                Word word = new Word();
                word.penText = text.toString();
                List<Word> words = new ArrayList<Word>();


                words.add(word);
                enoteEditor.insertWords(words, true);


                return super.commitText(text, newCursorPosition);
            }


            @Override
            public boolean sendKeyEvent(KeyEvent event) {
                int action = event.getAction();
                if(action == KeyEvent.ACTION_UP){


                    switch (event.getKeyCode()){
                        case KeyEvent.KEYCODE_DEL: //删除
                            if(enoteEditor.isSelecting()){
                                enoteEditor.doDeleteSelectAction();
                            }else{
                                enoteEditor.doBackKeyAction(1);
                            }
                            break;
                        case KeyEvent.KEYCODE_ENTER://回车
                            enoteEditor.doEnterKeyAction();
                            break;
                        default:
                            break;
                    }
                }


                return true;
            }


            @Override
            public boolean finishComposingText() {
               if(mEnoteInputEditor.isWindow2KeyboardModelFlag()){
                   /**框输入模式切换到键盘模式后，如果按back键键盘退出，则切换到自由输入模式**/
                    mEnoteInputEditor.setWindow2KeyboardModelFlag(false);
                    mEnoteInputEditor.setInputMethod(EnoteInputEditor.ENOTE_INPUT_METHOD_WINDOW_MODE);
                   mEnoteInputEditor.setFocusable(false);
                   gKeyboardCurrentStatus = false;
               }else{
              mEnoteInputEditor.setInputMethod(EnoteInputEditor.ENOTE_INPUT_METHOD_FREE_MODE);//进入自由模式.
               }
               return true;
            }
        } ;
        return mInputConnection;
    }


    /**
     * 调用软键盘
     * @param show
     *          true-调出键盘  false-隐藏键盘
     * @param  enoteInputEditor
     *          调用软键盘的enoteInputEditor
     */
    public  void showKeyboardInput(boolean show, EnoteInputEditor enoteInputEditor){
        InputMethodManager inm = (InputMethodManager) enoteInputEditor.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);


        if(show){
            enoteInputEditor.setFocusableInTouchMode(true);
            enoteInputEditor.setFocusable(true);
            enoteInputEditor.requestFocus();


            enoteInputEditor.scrollCursorToUpArea();//光标在屏幕的上半部分


            gKeyboardCurrentStatus = true;
            if(!inm.showSoftInput(enoteInputEditor, 0)){
            inm.toggleSoftInputFromWindow(enoteInputEditor.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS, 0);
            }
        } else{
        gKeyboardCurrentStatus = false;
            inm.hideSoftInputFromWindow(enoteInputEditor.getWindowToken(), 0);
            enoteInputEditor.setFocusable(false);
            
        }
    }
    
    /**
     * hideStatus
     *         true-隐藏键盘，  false-显示键盘
     *
     */
    private  void hideKeywordTemp(boolean hideStatus){


       if(mEnoteInputEditor != null){
           if(hideStatus){
               /**键盘由临时显示-> 临时隐藏**/
               if(gKeyboardCurrentStatus && !gKeyboardHasHide){
                   showKeyboardInput(false, mEnoteInputEditor);
                   gKeyboardHasHide = true;
               }
           }else{
               /**键盘由临时隐藏-> 临时显示**/
               if(gKeyboardHasHide){
                   showKeyboardInput(true, mEnoteInputEditor);
                   gKeyboardHasHide  = false;
               }
           }
       }
    }


    /**
     *
     * @param hideKeyboard
     *              true-隐藏键盘 ，false-显示隐藏的键盘     */
    public  void switchHideKeyboardInput(boolean hideKeyboard){
        if(hideKeyboard){
            setNeedCallback(true);
           mHandler.sendEmptyMessage(KEYBOARD_HIDE);
        }else {
            setNeedCallback(false);
            mHandler.sendEmptyMessage(KEYBOARD_SHOW);
        }
    }




    @Override
    public void onActivityCreated(Activity activity, Bundle bundle) {
        //To change body of implemented methods use File | Settings | File Templates.
    }


    @Override
    public void onActivityStarted(Activity activity) {
        //To change body of implemented methods use File | Settings | File Templates.
    }


    @Override
    public void onActivityResumed(Activity activity) {
        Log.i("ENoteWriterActivity", "ENoteWriterActivity is back");
//         if(mNeedCallback){
//              switchHideKeyboardInput(false);
//         }
    }


    @Override
    public void onActivityPaused(Activity activity) {
        //To change body of implemented methods use File | Settings | File Templates.
    }


    @Override
    public void onActivityStopped(Activity activity) {
        //To change body of implemented methods use File | Settings | File Templates.
    }


    @Override
    public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {
        //To change body of implemented methods use File | Settings | File Templates.
    }


    @Override
    public void onActivityDestroyed(Activity activity) {
        //To change body of implemented methods use File | Settings | File Templates.
    }


    public  boolean isNeedCallback() {
        return mNeedCallback;
    }


    public  void setNeedCallback(boolean needCallback) {
        mNeedCallback = needCallback;
    }
}