Java Examples for android.view.KeyEvent

private static final short aKeyEventType2NewtEventType(final int androidKeyAction) {
    switch(androidKeyAction) {
        case android.view.KeyEvent.ACTION_DOWN:
        case android.view.KeyEvent.ACTION_MULTIPLE:
            return com.jogamp.newt.event.KeyEvent.EVENT_KEY_PRESSED;
        case android.view.KeyEvent.ACTION_UP:
            return com.jogamp.newt.event.KeyEvent.EVENT_KEY_RELEASED;
    }
    return (short) 0;
}

public boolean onKey(View v, int keyCode, android.view.KeyEvent event) {
    if (event.getAction() == android.view.KeyEvent.ACTION_MULTIPLE)
        return false;
    synchronized (this) {
        KeyEvent keyEvent = keyEventPool.newObject();
        keyEvent.keyCode = keyCode;
        keyEvent.keyChar = (char) event.getUnicodeChar();
        if (event.getAction() == android.view.KeyEvent.ACTION_DOWN) {
            keyEvent.type = KeyEvent.KEY_DOWN;
            if (keyCode > 0 && keyCode < 127)
                pressedKeys[keyCode] = true;
        }
        if (event.getAction() == android.view.KeyEvent.ACTION_UP) {
            keyEvent.type = KeyEvent.KEY_UP;
            if (keyCode > 0 && keyCode < 127)
                pressedKeys[keyCode] = false;
        }
        keyEventsBuffer.add(keyEvent);
    }
    return false;
}

@Override
public boolean onKeyUp(int keyCode, KeyEvent event, OperationHolder holder) {
    switch(keyCode) {
        case NOOK_PAGE_UP_KEY_LEFT:
        case NOOK_PAGE_UP_KEY_RIGHT:
            holder.value = PREV;
            return true;
        case NOOK_PAGE_DOWN_KEY_LEFT:
        case NOOK_PAGE_DOWN_KEY_RIGHT:
            holder.value = NEXT;
            return true;
    }
    return super.onKeyUp(keyCode, event, holder);
}

/**
	 * @see android.view.View.OnKeyListener#onKey(android.view.View, int, android.view.KeyEvent)
	 */
@Override
public boolean onKey(final View v, int keyCode, KeyEvent event) {
    if (matchKeyCode(keyCode) && (event.getAction() == KeyEvent.ACTION_UP)) {
        Runnable runnable = new Runnable() {

            @Override
            public void run() {
                AppUtils.hideSoftInput(v);
                onRun(v);
            }
        };
        if (async) {
            ExecutorUtils.execute(runnable);
        } else {
            runnable.run();
        }
        return true;
    }
    return false;
}

@Override
public void onResume() {
    super.onResume();
    getDialog().setOnKeyListener(new DialogInterface.OnKeyListener() {

        @Override
        public boolean onKey(android.content.DialogInterface dialog, int keyCode, android.view.KeyEvent event) {
            if ((keyCode == android.view.KeyEvent.KEYCODE_BACK)) {
                closeSuperActivity();
            }
            return false;
        }
    });
}

@Override
public void onResume() {
    super.onResume();
    getDialog().setOnKeyListener(new DialogInterface.OnKeyListener() {

        @Override
        public boolean onKey(android.content.DialogInterface dialog, int keyCode, android.view.KeyEvent event) {
            if ((keyCode == android.view.KeyEvent.KEYCODE_BACK)) {
                closeSuperActivity();
            }
            return false;
        }
    });
}

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
    if (ActionBarPolicy.get(this).showsOverflowMenuButton() && Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
        if (event.getAction() == KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_MENU) {
            openOptionsMenu();
            return true;
        }
    }
    return super.onKeyUp(keyCode, event);
}

/*
     * Scroll the ListView by VOLUME DOWN/UP
     * return true if listview was scrolled
     * otherwise return false
     */
public static boolean ScrollListViewByKey(ListView lv, int keyCode) {
    if (lv != null) {
        int offset = (int) (lv.getHeight() * 0.95);
        if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
            lv.smoothScrollBy(offset, 500);
            return true;
        } else if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
            lv.smoothScrollBy(-1 * offset, 500);
            return true;
        }
    }
    return false;
}

@Override
public void onReceive(Context context, Intent intent) {
    KeyEvent event = (KeyEvent) intent.getExtras().get(Intent.EXTRA_KEY_EVENT);
    if (event.getAction() == KeyEvent.ACTION_DOWN) {
        int keycode = event.getKeyCode();
        context.startService(App.current().intents.playerHandleRemoteControlClient(keycode));
        Log.d(TAG, "Recived keycode: " + keycode);
    }
}

@Override
public void onReceive(Context context, Intent intent) {
    if (Intent.ACTION_MEDIA_BUTTON.equals(intent.getAction())) {
        KeyEvent keyEvent = (KeyEvent) intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
        // respond to one 
        if (keyEvent.getAction() == KeyEvent.ACTION_UP) {
            switch(keyEvent.getKeyCode()) {
                case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
                    context.startService(new Intent(PowerHourService.ACTION_PLAY_PAUSE));
                    break;
                case KeyEvent.KEYCODE_MEDIA_NEXT:
                    context.startService(new Intent(PowerHourService.ACTION_SKIP));
            }
        }
    }
}

/**
   * Bind given runnable to be invoked when the
   *
   * @param editText
   * @param runnable
   * @return edit text
   */
public static EditText onDone(final EditText editText, final BooleanRunnable runnable) {
    if ((editText.getInputType() & TYPE_TEXT_FLAG_MULTI_LINE) == 0)
        editText.setOnKeyListener(new OnKeyListener() {

            public boolean onKey(View v, int keyCode, KeyEvent event) {
                if (keyCode != KEYCODE_ENTER)
                    return false;
                if (event == null)
                    return false;
                if (event.getAction() != ACTION_DOWN)
                    return false;
                return runnable.run();
            }
        });
    editText.setOnEditorActionListener(new OnEditorActionListener() {

        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if (actionId == IME_ACTION_DONE)
                return runnable.run();
            else
                return false;
        }
    });
    return editText;
}

/**
   * Bind given runnable to be invoked when the
   *
   * @param editText
   * @param runnable
   * @return edit text
   */
public static EditText onDone(final EditText editText, final BooleanRunnable runnable) {
    if ((editText.getInputType() & TYPE_TEXT_FLAG_MULTI_LINE) == 0)
        editText.setOnKeyListener(new OnKeyListener() {

            public boolean onKey(View v, int keyCode, KeyEvent event) {
                if (keyCode != KEYCODE_ENTER)
                    return false;
                if (event == null)
                    return false;
                if (event.getAction() != ACTION_DOWN)
                    return false;
                return runnable.run();
            }
        });
    editText.setOnEditorActionListener(new OnEditorActionListener() {

        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if (actionId == IME_ACTION_DONE)
                return runnable.run();
            else
                return false;
        }
    });
    return editText;
}

/**
   * Bind given runnable to be invoked when the
   *
   * @param editText
   * @param runnable
   * @return edit text
   */
public static EditText onDone(final EditText editText, final BooleanRunnable runnable) {
    if ((editText.getInputType() & TYPE_TEXT_FLAG_MULTI_LINE) == 0)
        editText.setOnKeyListener(new OnKeyListener() {

            public boolean onKey(View v, int keyCode, KeyEvent event) {
                if (keyCode != KEYCODE_ENTER)
                    return false;
                if (event == null)
                    return false;
                if (event.getAction() != ACTION_DOWN)
                    return false;
                return runnable.run();
            }
        });
    editText.setOnEditorActionListener(new OnEditorActionListener() {

        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if (actionId == IME_ACTION_DONE)
                return runnable.run();
            else
                return false;
        }
    });
    return editText;
}

/**
   * Bind given runnable to be invoked when the
   *
   * @param editText
   * @param runnable
   * @return edit text
   */
public static EditText onDone(final EditText editText, final BooleanRunnable runnable) {
    if ((editText.getInputType() & TYPE_TEXT_FLAG_MULTI_LINE) == 0)
        editText.setOnKeyListener(new OnKeyListener() {

            public boolean onKey(View v, int keyCode, KeyEvent event) {
                if (keyCode != KEYCODE_ENTER)
                    return false;
                if (event == null)
                    return false;
                if (event.getAction() != ACTION_DOWN)
                    return false;
                return runnable.run();
            }
        });
    editText.setOnEditorActionListener(new OnEditorActionListener() {

        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if (actionId == IME_ACTION_DONE)
                return runnable.run();
            else
                return false;
        }
    });
    return editText;
}

@Override
protected void showDialog(android.os.Bundle state) {
    super.showDialog(state);
    getEditText().setOnKeyListener(new View.OnKeyListener() {

        @Override
        public boolean onKey(View view, int i, KeyEvent keyEvent) {
            getEditText().setText(Integer.toString(keyEvent.getKeyCode()));
            return false;
        }
    });
}

@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
    if (event.getAction() == KeyEvent.ACTION_UP) {
        switch(keyCode) {
            case KeyEvent.KEYCODE_DPAD_LEFT:
            case KeyEvent.KEYCODE_DPAD_RIGHT:
                {
                    canIGo = true;
                    return true;
                }
        }
        return false;
    }
    if (event.getAction() == KeyEvent.ACTION_DOWN) {
        switch(keyCode) {
            // go down
            case KeyEvent.KEYCODE_DPAD_DOWN:
                {
                    if (last && EPGScrollView.isScrolledToBottom) {
                        if (epgHandlingClass.getDayInWeekToLoadData() < 7) {
                            epgHandlingClass.createAskDialogAndShow(true);
                        }
                        return true;
                    } else {
                        return false;
                    }
                }
            // go up
            case KeyEvent.KEYCODE_DPAD_UP:
                {
                    if (first && EPGScrollView.isScrolledToTop) {
                        if (epgHandlingClass.getDayInWeekToLoadData() > 1) {
                            epgHandlingClass.createAskDialogAndShow(false);
                        }
                        return true;
                    } else {
                        return false;
                    }
                }
            default:
                break;
        }
    }
    return false;
}

public void testFocusOut() throws Throwable {
    runTestOnUiThread(new Runnable() {

        @Override
        public void run() {
            activity.findViewById(R.id.textfield_name).requestFocus();
        }
    });
    getInstrumentation().waitForIdleSync();
    // Focus out
    sendKeys(KeyEvent.KEYCODE_TAB);
    getInstrumentation().waitForIdleSync();
}

@Override
public void onReceive(Context context, Intent intent) {
    String action = intent.getAction();
    if (action.equals(Intent.ACTION_MEDIA_BUTTON)) {
        KeyEvent event = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
        if (event == null || event.getAction() != KeyEvent.ACTION_UP)
            return;
        abortBroadcast();
        switch(event.getKeyCode()) {
            case KeyEvent.KEYCODE_HEADSETHOOK:
            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
                SendAction.SendControlMsg(ServiceControl.PAUSE_CONTINE);
                break;
            case KeyEvent.KEYCODE_MEDIA_NEXT:
                SendAction.SendControlMsg(ServiceControl.NEXT);
                break;
            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
                SendAction.SendControlMsg(ServiceControl.PRE);
                break;
        }
    }
}

@Override
public void onReceive(Context context, Intent intent) {
    String intentAction = intent.getAction();
    if (!Intent.ACTION_MEDIA_BUTTON.equals(intentAction)) {
        return;
    }
    KeyEvent event = (KeyEvent) intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
    if (event == null) {
        return;
    }
    int action = event.getAction();
    if (action == KeyEvent.ACTION_DOWN) {
        // do something
        Toast.makeText(context, "BUTTON PRESSED!", Toast.LENGTH_SHORT).show();
        //ma.voiceSearch();
        Intent i = new Intent(context, MainActivity.class);
        i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        context.startActivity(i);
    //((Class MainActivity) context).voiceSearch();
    //MainActivity.voiceSearch();
    }
    abortBroadcast();
}

@Override
public void onReceive(Context context, Intent intent) {
    // Otherwise, it seems to replay the last Intent after connecting via Bluetooth,
    if (isInitialStickyBroadcast())
        return;
    if (intent.getAction().equals(Intent.ACTION_MEDIA_BUTTON)) {
        KeyEvent keyEvent = (KeyEvent) intent.getExtras().get(Intent.EXTRA_KEY_EVENT);
        if (keyEvent.getAction() != KeyEvent.ACTION_DOWN)
            return;
    }
    intent.setClass(context, ContentService.class);
    context.startService(intent);
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.player_new);
    setTitle("New player");
    mNameText = (EditText) findViewById(R.id.new_player_name);
    mNameText.setOnKeyListener(new View.OnKeyListener() {

        public boolean onKey(View view, int keyCode, KeyEvent event) {
            if (keyCode != KeyEvent.KEYCODE_ENTER)
                return false;
            Intent mIntent = new Intent();
            mIntent.putExtra("name", mNameText.getText().toString());
            setResult(RESULT_OK, mIntent);
            finish();
            return true;
        }
    });
}

@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
    CharSequence text = ((TextView) v).getText();
    if (text == null)
        return false;
    Integer usedChars = text.length();
    Integer remainingChars = maxChars - usedChars;
    view.setText(remainingChars.toString());
    button.setEnabled(usedChars > 0);
    return remainingChars <= 0;
}

@Override
public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
    return new BaseInputConnection(this, false) {

        @Override
        public boolean sendKeyEvent(KeyEvent event) {
            return super.sendKeyEvent(event);
        }

        @Override
        public boolean performEditorAction(int actionCode) {
            sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_ENTER));
            return super.performEditorAction(actionCode);
        }
    };
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    final ProgressDialog dialog = new ProgressDialog(getActivity());
    dialog.setMessage("Se încarcă");
    dialog.setIndeterminate(true);
    dialog.setCancelable(false);
    // Disable the back button
    OnKeyListener keyListener = new OnKeyListener() {

        @Override
        public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
            return keyCode == KeyEvent.KEYCODE_BACK;
        }
    };
    dialog.setOnKeyListener(keyListener);
    return dialog;
}

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
        Intent intent = new Intent(Animation_TargetActivity.this, Animation_BeginActivity.class);
        setResult(RESULT_OK, intent);
        finish();
        overridePendingTransition(R.anim.slide_up_in, R.anim.slide_down_out);
        return false;
    }
    return false;
}

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK && canGoBack()) {
        Log.d("PostcardWebView", "Should go back");
        loadUrl("javascript:window.history.back();");
        return true;
    }
    Log.d("PostcardWebView", "Can't go back any further");
    return super.onKeyDown(keyCode, event);
}

//�写 onKeyDown方法
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_DOWN) {
        //两秒之内按返回键就会退出
        if ((System.currentTimeMillis() - exitTime) > 2000) {
            Toast.makeText(getApplicationContext(), "�按一次退出程�", Toast.LENGTH_SHORT).show();
            exitTime = System.currentTimeMillis();
        } else {
            finish();
            System.exit(0);
        }
        return true;
    }
    return super.onKeyDown(keyCode, event);
}

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (event.getAction() == KeyEvent.ACTION_DOWN && event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
        showAlertDialog(R.string.msg, R.string.logout, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int which) {
                AndroidUtil.exitApp(HomeActivity.this);
            }
        }, null, null);
        return true;
    }
    return super.onKeyDown(keyCode, event);
}

@Test
public void dispatchKeyEvent_shouldSetText() throws Exception {
    EditText editText = new EditText(RuntimeEnvironment.application);
    editText.requestFocus();
    for (KeyEvent evt : keyMap.getEvents("string".toCharArray())) {
        editText.dispatchKeyEvent(evt);
    }
    Thread.sleep(500);
    ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
    assertThat(editText.getText().toString()).isEqualTo("string");
}

public static KeyToFaceMappings newInstance() {
    Map<Integer, FaceExpression> expressions = new HashMap<>();
    expressions.put(KeyEvent.KEYCODE_1, FaceExpression.SAD);
    expressions.put(KeyEvent.KEYCODE_2, FaceExpression.NEUTRAL);
    expressions.put(KeyEvent.KEYCODE_3, FaceExpression.HAPPY);
    expressions.put(KeyEvent.KEYCODE_4, FaceExpression.JOYFUL);
    return new KeyToFaceMappings(expressions);
}

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
            return true;
        }
    }
    return super.onKeyUp(keyCode, event);
}

@Override
public void onReceive(Context context, Intent intent) {
    if (Intent.ACTION_MEDIA_BUTTON.equals(intent.getAction())) {
        KeyEvent event = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
        Intent sendIntent = new Intent(context, LocalMusicService.class);
        sendIntent.setAction(com.atomjack.shared.Intent.ACTION_MEDIA_BUTTON);
        sendIntent.putExtra(com.atomjack.shared.Intent.KEY_EVENT, event);
        context.startService(sendIntent);
        if (isOrderedBroadcast())
            abortBroadcast();
    }
}

/*
	 * (non-Javadoc)
	 * 
	 * @see android.app.Activity#onKeyUp(int, android.view.KeyEvent)
	 */
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        // Pass our results back to any caller
        Intent result = new Intent();
        result.putExtra("checked", lv.getChecked());
        setResult(RESULT_OK, result);
        finish();
        return true;
    }
    return super.onKeyUp(keyCode, event);
}

@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
    if (event.getAction() == android.view.KeyEvent.ACTION_DOWN) {
        if (keyCode == android.view.KeyEvent.KEYCODE_BACK) {
            if (mWeb.canGoBack()) {
                mWeb.goBack();
            } else {
                if (!mComeFromAccoutActivity) {
                    Intent intent = new Intent(WebViewActivity.this, UnLoginActivity.class);
                    startActivity(intent);
                    finish();
                } else {
                    finish();
                }
            }
            return true;
        }
    }
    return false;
}

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        new ActSwitchAnimTool(this).setAnimType(ActSwitchAnimTool.MODE_SPREAD).target(mDemoFloatingBtn).setmColorStart(Color.parseColor("#FF5777")).setmColorEnd(Color.parseColor("#FF5777")).setCustomEndCallBack(new ActSwitchAnimTool.SwitchAnimCallback() {

            @Override
            public void onAnimationStart() {
            }

            @Override
            public void onAnimationEnd() {
                finish();
            }

            @Override
            public void onAnimationUpdate(int progress) {
            }
        }).build();
        return true;
    }
    return super.onKeyUp(keyCode, event);
}

public static boolean hasNavBar(Context context) {
    boolean hasBackKey = KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_BACK);
    boolean hasHomeKey = KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_HOME);
    if (hasBackKey && hasHomeKey) {
        if (Build.MANUFACTURER.toLowerCase().contains("samsung") && !Build.MODEL.toLowerCase().contains("nexus")) {
            return false;
        }
        Resources resources = context.getResources();
        int id = resources.getIdentifier("config_showNavigationBar", "bool", "android");
        if (id > 0) {
            return resources.getBoolean(id);
        } else {
            return false;
        }
    } else {
        return true;
    }
}

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        if (isSlidingMenuOpen()) {
            getSlidingMenu().toggle();
            return true;
        }
        DialogInterface.OnClickListener listener = new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface arg0, int arg1) {
                if (arg1 == DialogInterface.BUTTON_POSITIVE) {
                    QuickToolHelper.appExit();
                }
            }
        };
        QuickToolHelper.showDialog(this, "exit app?", listener, false);
        return true;
    }
    return super.onKeyDown(keyCode, event);
}

@Override
protected void onAttach() {
    super.onAttach();
    callback = new ActivityEventAdapter() {

        @Override
        public boolean onKeyDown(int keyCode, KeyEvent event) {
            ScrapLog.i("callback onKeyDown", "");
            return super.onKeyDown(keyCode, event);
        }

        @Override
        public boolean onBackPressed() {
            ScrapLog.i("callback onBackPressed", "");
            //if return true. the all BaseScrapView can't receive back event.
            return super.onBackPressed();
        }

        @Override
        public boolean onTouchEvent(MotionEvent event) {
            ScrapLog.i("callback onTouchEvent", "");
            return super.onTouchEvent(event);
        }
    };
    ScrapHelper.registerActivityEventCallback(callback);
}

@Override
public boolean onEditorAction(TextView v, int actionCode, KeyEvent event) {
    messageView.setText("typed: " + delegateEditText.getText());
    messageView.setVisibility(View.VISIBLE);
    InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(delegateEditText.getWindowToken(), 0);
    return true;
}

@Override
public void onClick(View v) {
    switch(v.getId()) {
        case R.id.dotButton:
            pressKey(KeyEvent.KEYCODE_PERIOD);
            return;
        case R.id.dashButton:
            pressKey(KeyEvent.KEYCODE_MINUS);
            return;
        case R.id.backspaceButton:
            pressKey(KeyEvent.KEYCODE_DEL);
            return;
    }
}

public State onKeyTracker(int keyCode, KeyEvent event, Stage stage, int duration) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        if (stage == KeyTracker.Stage.LONG_REPEAT) {
            // here we have the long pressed back button
            onLongPressBack(keyCode, event, stage, duration);
            lastStage = stage;
            return KeyTracker.State.KEEP_TRACKING;
        } else if (stage == KeyTracker.Stage.UP) {
            if (lastStage == Stage.LONG_REPEAT) {
                lastStage = Stage.SHORT_REPEAT;
                return KeyTracker.State.DONE_TRACKING;
            }
            onShortPressBack(keyCode, event, stage, duration);
            return KeyTracker.State.NOT_TRACKING;
        }
        return KeyTracker.State.KEEP_TRACKING;
    }
    return KeyTracker.State.NOT_TRACKING;
}

/**
	 * °´Ï¼üÅÌÉÏ·µ»Ø°´Å¥
	 */
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (//ËÑË÷
    keyCode == KeyEvent.KEYCODE_SEARCH) {
        Intent intent = new Intent(BaseActivity.this, SearchActivity.class);
        intent.putExtra("isShowQuitHints", false);
        startActivity(intent);
        return true;
    } else {
        return super.onKeyDown(keyCode, event);
    }
}

/**
	 * °´Ï¼üÅÌÉÏ·µ»Ø°´Å¥
	 */
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (// ËÑË÷
    keyCode == KeyEvent.KEYCODE_SEARCH) {
        Intent intent = new Intent(SuperView.this, SearchActivity.class);
        intent.putExtra("isShowQuitHints", false);
        startActivity(intent);
        return true;
    } else {
        return super.onKeyDown(keyCode, event);
    }
}

public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        //Í˳öÓ¦ÓóÌÐòʱ±£´æÊý¾Ý
        /* ·¢ËÍÓʼþµÄµØÖ· */
        Uri uri = Uri.parse("mailto:ggd543@gmail.com");
        /* ´´½¨Intent */
        Intent it = new Intent(Intent.ACTION_SENDTO, uri);
        /* ÉèÖÃÓʼþµÄÖ÷Ìâ */
        it.putExtra(android.content.Intent.EXTRA_SUBJECT, "Êý¾Ý±¸·Ý");
        /* ÉèÖÃÓʼþµÄÄÚÈÝ */
        it.putExtra(android.content.Intent.EXTRA_TEXT, "±¾´Î¼ÆÊý£º" + miCount);
        /* ¿ªÆô */
        startActivity(it);
        this.finish();
        return true;
    }
    return super.onKeyDown(keyCode, event);
}

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    if (event.getAction() == KeyEvent.ACTION_DOWN && event.getKeyCode() == KeyEvent.KEYCODE_DPAD_UP) {
        Utils.playKeySound(this.getCurrentView(), Utils.SOUND_KEYSTONE_KEY);
        try {
            Class osSystem = Class.forName("com.xiaomi.mitv.api.system.ExpandStatusBarController");
            Method showStatusBar = osSystem.getMethod("show", new Class[] { Context.class });
            showStatusBar.invoke(osSystem, new Object[] { this.getContext() });
        } catch (Exception e) {
        }
        return true;
    }
    return super.dispatchKeyEvent(event);
}

@Override
public boolean onEditorAction(TextView arg0, int arg1, KeyEvent arg2) {
    String txt = arg0.getText().toString().trim();
    if (!txt.equals(""))
        top.handle(new Event(Event.EType.SAY).setString(txt));
    setText("");
    InputMethodManager imm = (InputMethodManager) top.getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(getWindowToken(), 0);
    return true;
}

@Override
public boolean onEditorAction(TextView arg0, int arg1, KeyEvent arg2) {
    String txt = arg0.getText().toString().trim();
    if (!txt.equals(""))
        top.handle(new Event(Event.EType.SAY).setString(txt));
    setText("");
    InputMethodManager imm = (InputMethodManager) top.getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(getWindowToken(), 0);
    return true;
}

@Override
public void onReceive(Context context, Intent intent) {
    Log.d(TAG, "Received intent");
    KeyEvent event = (KeyEvent) intent.getExtras().get(Intent.EXTRA_KEY_EVENT);
    if (event != null && event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
        ClientConfig.initialize(context);
        Intent serviceIntent = new Intent(context, PlaybackService.class);
        serviceIntent.putExtra(EXTRA_KEYCODE, event.getKeyCode());
        serviceIntent.putExtra(EXTRA_SOURCE, event.getSource());
        context.startService(serviceIntent);
    }
}

@Override
public void onReceive(Context context, Intent intent) {
    if (AppConfig.DEBUG)
        Log.d(TAG, "Received intent");
    KeyEvent event = (KeyEvent) intent.getExtras().get(Intent.EXTRA_KEY_EVENT);
    if (event.getAction() == KeyEvent.ACTION_DOWN) {
        Intent serviceIntent = new Intent(context, PlaybackService.class);
        int keycode = event.getKeyCode();
        serviceIntent.putExtra(EXTRA_KEYCODE, keycode);
        context.startService(serviceIntent);
    }
}

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View root = inflater.inflate(R.layout.fragment_welcome, container, false);
    ((EditText) root.findViewById(R.id.aliasEntry)).setOnEditorActionListener(new TextView.OnEditorActionListener() {

        @Override
        public boolean onEditorAction(TextView textView, int i, KeyEvent keyEvent) {
            mCallback.onNameChosen(textView.getText().toString());
            return false;
        }
    });
    return root;
}

public static void setActionListener(final EditText editText, final Runnable runnable) {
    editText.setOnEditorActionListener(new TextView.OnEditorActionListener() {

        @Override
        public boolean onEditorAction(final TextView v, final int actionId, final KeyEvent event) {
            if (actionId == EditorInfo.IME_ACTION_GO) {
                runnable.run();
                return true;
            }
            return false;
        }
    });
    editText.setOnKeyListener(new View.OnKeyListener() {

        @Override
        public boolean onKey(final View v, final int keyCode, final KeyEvent event) {
            // If the event is a key-down event on the "enter" button
            if (event.getAction() == KeyEvent.ACTION_DOWN && keyCode == KeyEvent.KEYCODE_ENTER) {
                runnable.run();
                return true;
            }
            return false;
        }
    });
}

public boolean didDoubleTapR(int keyCode, View view) {
    if (keyCode == KeyEvent.KEYCODE_R && !(view instanceof EditText)) {
        if (mDoRefresh) {
            mDoRefresh = false;
            return true;
        } else {
            mDoRefresh = true;
            new Handler().postDelayed(new Runnable() {

                @Override
                public void run() {
                    mDoRefresh = false;
                }
            }, DOUBLE_TAP_DELAY);
        }
    }
    return false;
}

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    FragmentManager fragmentManager = getSupportFragmentManager();
    ModuleViewFragment fragment = (ModuleViewFragment) fragmentManager.findFragmentById(R.id.module_view_fragment);
    boolean result = fragment.onKeyDown(keyCode, event);
    if (result) {
        return result;
    } else {
        return super.onKeyDown(keyCode, event);
    }
}

@Override
public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        if (OnKeyType.DISMISS_KILL_ACTIVITY == onKeyType) {
            dialog.dismiss();
            activity.finish();
        } else if (OnKeyType.DISMISS_NOT_KILL_ACTIVITY == onKeyType) {
            dialog.dismiss();
        } else if (OnKeyType.NOT_DISMISS_NOT_KILL_ACTIVITY == onKeyType) {
        }
    }
    return true;
}

@Override
public boolean onEditorAction(TextView v, int actionCode, KeyEvent event) {
    messageView.setText("typed: " + delegateEditText.getText());
    messageView.setVisibility(View.VISIBLE);
    InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(delegateEditText.getWindowToken(), 0);
    return true;
}

@Override
public void onReceive(Context context, Intent intent) {
    if (AppConfig.DEBUG)
        Log.d(TAG, "Received intent");
    KeyEvent event = (KeyEvent) intent.getExtras().get(Intent.EXTRA_KEY_EVENT);
    if (event.getAction() == KeyEvent.ACTION_DOWN) {
        Intent serviceIntent = new Intent(context, PlaybackService.class);
        int keycode = event.getKeyCode();
        serviceIntent.putExtra(EXTRA_KEYCODE, keycode);
        context.startService(serviceIntent);
    }
}

@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
    if ((event.getAction() == KeyEvent.ACTION_DOWN)) {
        if (keyCode == KeyEvent.KEYCODE_ENTER) {
            if (adapter.add(((AutoCompleteTextView) v).getText().toString())) {
                Toast.makeText(context, context.getString(R.string.notification_keyword_added), Toast.LENGTH_LONG).show();
            } else {
                Toast.makeText(context, context.getString(R.string.notification_keyword_exist), Toast.LENGTH_LONG).show();
            }
            ((AutoCompleteTextView) v).setText("");
            adapter.notifyDataSetChanged();
        }
    }
    return false;
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    if (mDialog != null)
        return mDialog;
    mDialog = new ProgressDialog(getActivity());
    mDialog.setMessage(getString(R.string.text_loading));
    mDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
    mDialog.setCancelable(false);
    // 戻るボタンを無効化�る
    DialogInterface.OnKeyListener keyListener = new DialogInterface.OnKeyListener() {

        @Override
        public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
            if (keyCode == KeyEvent.KEYCODE_BACK) {
                return true;
            }
            return false;
        }
    };
    mDialog.setOnKeyListener(keyListener);
    return mDialog;
}

/**
	 * Activity onKeyDown事件
	 * */
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode != KeyEvent.KEYCODE_BACK) {
        return false;
    }
    if (isOnKeyBacking) {
        mHandler.removeCallbacks(onBackTimeRunnable);
        if (mBackToast != null) {
            mBackToast.cancel();
        }
        mActivity.finish();
        return true;
    } else {
        isOnKeyBacking = true;
        if (mBackToast == null) {
            mBackToast = Toast.makeText(mActivity, R.string.back_exit_tips, 2000);
        }
        mBackToast.show();
        mHandler.postDelayed(onBackTimeRunnable, 2000);
        return true;
    }
}

/**
     * Activity onKeyDown事件
     * @param keyCode
     * @param event
     * @return
     */
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode != KeyEvent.KEYCODE_BACK) {
        return false;
    }
    if (isOnkeyBacking) {
        mHandler.removeCallbacks(onBackTimeRunnable);
        if (mBackToast != null) {
            mBackToast.cancel();
        }
        // 退出程�
        AppManager.getAppManager().AppExit(mActivity);
        return true;
    } else {
        isOnkeyBacking = true;
        if (mBackToast == null) {
            mBackToast = Toast.makeText(mActivity, R.string.back_exit_tips, Toast.LENGTH_LONG);
        }
        mBackToast.show();
        mHandler.postDelayed(onBackTimeRunnable, 2000);
        return true;
    }
}

@Override
public boolean onEditorAction(TextView v, int actionCode, KeyEvent event) {
    messageView.setText("typed: " + delegateEditText.getText());
    messageView.setVisibility(View.VISIBLE);
    InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(delegateEditText.getWindowToken(), 0);
    return true;
}

protected void sendMediaKeyEvent(int code) {
    Context context = mView.getContext();
    long eventtime = SystemClock.uptimeMillis();
    Intent downIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
    KeyEvent downEvent = new KeyEvent(eventtime, eventtime, KeyEvent.ACTION_DOWN, code, 0);
    downIntent.putExtra(Intent.EXTRA_KEY_EVENT, downEvent);
    context.sendOrderedBroadcast(downIntent, null);
    Intent upIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
    KeyEvent upEvent = new KeyEvent(eventtime, eventtime, KeyEvent.ACTION_UP, code, 0);
    upIntent.putExtra(Intent.EXTRA_KEY_EVENT, upEvent);
    context.sendOrderedBroadcast(upIntent, null);
}

/**
     * Overridden to use {@link #onBackPressed()} instead of webview back
     * if there is only one element left in history.
     *
     * @param keyCode
     * @param event
     * @return
     */
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    boolean canGoBack = webview.canGoBackOrForward(-2);
    boolean isBack = keyCode == KeyEvent.KEYCODE_BACK;
    if (isBack && canGoBack) {
        webview.goBack();
        return true;
    } else if (isBack) {
        onBackPressed();
        return true;
    }
    return super.onKeyDown(keyCode, event);
}

/**
     * Activity onKeyDown事件
     */
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        if (isOnKeyBacking) {
            mHandler.removeCallbacks(onBackTimeRunnable);
            if (mBackToast != null) {
                mBackToast.cancel();
            }
            return true;
        } else {
            isOnKeyBacking = true;
            if (mBackToast == null) {
                mBackToast = Toast.makeText(mActivity, R.string.toast_hint_double_click_exit, Toast.LENGTH_LONG);
            }
            mBackToast.show();
            mHandler.postDelayed(onBackTimeRunnable, 2000);
            return false;
        }
    }
    return false;
}

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    // 在两秒钟内连续按两次返回，则退出
    if (keyCode == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_DOWN) {
        if ((System.currentTimeMillis() - exitTime) > 2000) {
            CommonUtil.shortToast(getApplicationContext(), "�按一次退出系统");
            exitTime = System.currentTimeMillis();
        } else {
            // 退出应用
            LoveApplication.getInstance().exit();
        }
        return true;
    }
    return super.onKeyDown(keyCode, event);
}

@Override
public void onReceive(Context context, Intent intent) {
    if (intent.getAction().equals(Intent.ACTION_MEDIA_BUTTON)) {
        KeyEvent keyEvent = (KeyEvent) intent.getExtras().get(Intent.EXTRA_KEY_EVENT);
        if (keyEvent.getAction() != KeyEvent.ACTION_DOWN)
            return;
        switch(keyEvent.getKeyCode()) {
            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
                Log.d(TAG, "Play/Pause was clicked");
                break;
            case KeyEvent.KEYCODE_MEDIA_NEXT:
                Log.d(TAG, "Next was clicked");
                break;
            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
                Log.d(TAG, "Previous was clicked");
                break;
            default:
                Log.d(TAG, keyEvent.getKeyCode() + " was clicked");
        }
    }
}

@Override
public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
    if (EditorInfo.IME_ACTION_DONE == actionId) {
        // Return input text to activity
        GuestnameDialogListener activity = (GuestnameDialogListener) getActivity();
        activity.onFinishEditDialog(mEditText.getText().toString());
        this.dismiss();
        return true;
    }
    return false;
}

public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode != KeyEvent.KEYCODE_BACK) {
        return false;
    }
    if (firstKeyDown) {
        if (exitToast == null) {
            exitToast = Toast.makeText(context, context.getString(R.string.double_back_exit_hint), Toast.LENGTH_SHORT);
        }
        exitToast.show();
        handler.postDelayed(onBackTimeRunnable, 2000);
        firstKeyDown = false;
    } else {
        handler.removeCallbacks(onBackTimeRunnable);
        if (exitToast != null) {
            exitToast.cancel();
        }
        context.finish();
    }
    return true;
}

/**
	 * Activity onKeyDown事件
	 * */
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode != KeyEvent.KEYCODE_BACK) {
        return false;
    }
    if (isOnKeyBacking) {
        mHandler.removeCallbacks(onBackTimeRunnable);
        if (mBackToast != null) {
            mBackToast.cancel();
        }
        // 退出
        AppManager.getAppManager().AppExit(mActivity);
        return true;
    } else {
        isOnKeyBacking = true;
        if (mBackToast == null) {
            mBackToast = Toast.makeText(mActivity, R.string.back_exit_tips, 2000);
        }
        mBackToast.show();
        mHandler.postDelayed(onBackTimeRunnable, 2000);
        return true;
    }
}

@Override
public void onReceive(Context context, Intent intent) {
    if (intent.getAction().equals(Intent.ACTION_MEDIA_BUTTON)) {
        KeyEvent keyEvent = (KeyEvent) intent.getExtras().get(Intent.EXTRA_KEY_EVENT);
        if (keyEvent.getAction() != KeyEvent.ACTION_DOWN)
            return;
        switch(keyEvent.getKeyCode()) {
            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
                Log.d(TAG, "Play/Pause was clicked");
                break;
            case KeyEvent.KEYCODE_MEDIA_NEXT:
                Log.d(TAG, "Next was clicked");
                break;
            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
                Log.d(TAG, "Previous was clicked");
                break;
            default:
                Log.d(TAG, keyEvent.getKeyCode() + " was clicked");
        }
    }
}

public boolean onKeyDown(int keyCode, KeyEvent event) {
    if ((keyCode == KeyEvent.KEYCODE_BACK)) {
        FragmentManager fragManager = getSupportFragmentManager();
        FragmentTransaction backTransaction = fragManager.beginTransaction();
        Fragment frag = fragManager.findFragmentById(getLayoutFragmentContainerId());
        if (frag != null) {
            backTransaction.detach(frag);
            backTransaction.commit();
        }
    }
    return super.onKeyDown(keyCode, event);
}

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    boolean isLGE = false;
    if (keyCode == KeyEvent.KEYCODE_MENU) {
        if ("LGE".equalsIgnoreCase(Build.BRAND))
            isLGE = true;
        if (Build.VERSION.SDK_INT <= 16 && "LGE".compareTo(Build.MANUFACTURER) == 0)
            isLGE = true;
    }
    if (isLGE)
        return true;
    return super.onKeyDown(keyCode, event);
}

@Override
public void onReceive(Context context, Intent intent) {
    KeyEvent event = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
    if (event == null || event.getAction() != KeyEvent.ACTION_UP) {
        return;
    }
    switch(event.getKeyCode()) {
        case KeyEvent.KEYCODE_MEDIA_PLAY:
        case KeyEvent.KEYCODE_MEDIA_PAUSE:
        case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
        case KeyEvent.KEYCODE_HEADSETHOOK:
            PlayService.startCommand(context, Actions.ACTION_MEDIA_PLAY_PAUSE);
            break;
        case KeyEvent.KEYCODE_MEDIA_NEXT:
            PlayService.startCommand(context, Actions.ACTION_MEDIA_NEXT);
            break;
        case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
            PlayService.startCommand(context, Actions.ACTION_MEDIA_PREVIOUS);
            break;
    }
}

public static void disableCancelableDialog(MaterialDialog materialDialog) {
    // Disable the back button
    DialogInterface.OnKeyListener keyListener = new DialogInterface.OnKeyListener() {

        @Override
        public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
            return keyCode == KeyEvent.KEYCODE_BACK;
        }
    };
    materialDialog.setOnKeyListener(keyListener);
    materialDialog.setCanceledOnTouchOutside(false);
}

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    if (event.getAction() == KeyEvent.ACTION_DOWN) {
        if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
            if (!permitClose) {
                return true;
            }
        } else if (event.getKeyCode() != KeyEvent.KEYCODE_HOME) {
            return true;
        }
    }
    return super.dispatchKeyEvent(event);
}

boolean onKeyUp(View currentFocus, int keyCode) {
    ReactInstanceManager reactInstanceManager = getReactInstanceManager();
    if (reactInstanceManager != null && reactInstanceManager.getDevSupportManager().getDevSupportEnabled()) {
        if (keyCode == KeyEvent.KEYCODE_MENU) {
            reactInstanceManager.showDevOptionsDialog();
            return true;
        }
        if (keyCode == KeyEvent.KEYCODE_R && !(currentFocus instanceof EditText)) {
            // Enable double-tap-R-to-reload
            if (shouldRefreshOnRR) {
                reload();
                return true;
            } else {
                shouldRefreshOnRR = true;
                NavigationApplication.instance.runOnMainThread(new Runnable() {

                    @Override
                    public void run() {
                        shouldRefreshOnRR = false;
                    }
                }, 500);
            }
        }
    }
    return false;
}

public boolean didDoubleTapR(int keyCode, View view) {
    if (keyCode == KeyEvent.KEYCODE_R && !(view instanceof EditText)) {
        if (mDoRefresh) {
            mDoRefresh = false;
            return true;
        } else {
            mDoRefresh = true;
            new Handler().postDelayed(new Runnable() {

                @Override
                public void run() {
                    mDoRefresh = false;
                }
            }, DOUBLE_TAP_DELAY);
        }
    }
    return false;
}

public boolean didDoubleTapR(int keyCode, View view) {
    if (keyCode == KeyEvent.KEYCODE_R && !(view instanceof EditText)) {
        if (mDoRefresh) {
            mDoRefresh = false;
            return true;
        } else {
            mDoRefresh = true;
            new Handler().postDelayed(new Runnable() {

                @Override
                public void run() {
                    mDoRefresh = false;
                }
            }, DOUBLE_TAP_DELAY);
        }
    }
    return false;
}

public State onKeyTracker(int keyCode, KeyEvent event, Stage stage, int duration) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        if (stage == KeyTracker.Stage.LONG_REPEAT) {
            // here we have the long pressed back button
            onLongPressBack(keyCode, event, stage, duration);
            lastStage = stage;
            return KeyTracker.State.KEEP_TRACKING;
        } else if (stage == KeyTracker.Stage.UP) {
            if (lastStage == Stage.LONG_REPEAT) {
                lastStage = Stage.SHORT_REPEAT;
                return KeyTracker.State.DONE_TRACKING;
            }
            onShortPressBack(keyCode, event, stage, duration);
            return KeyTracker.State.NOT_TRACKING;
        }
        return KeyTracker.State.KEEP_TRACKING;
    }
    return KeyTracker.State.NOT_TRACKING;
}

@Test
@UiThreadTest
public void keyboardDismisses() {
    RecordingObserver<Object> o = new RecordingObserver<>();
    RxSearchEditText.keyboardDismisses(view).subscribe(o);
    o.assertNoMoreEvents();
    KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK);
    view.onKeyPreIme(KeyEvent.KEYCODE_BACK, event);
    assertNotNull(o.takeNext());
    o.dispose();
    view.onKeyPreIme(KeyEvent.KEYCODE_BACK, event);
    o.assertNoMoreEvents();
}

@Override
public boolean onKeyPreIme(int keyCode, KeyEvent event) {
    if (mSearchView.getShouldHideOnKeyboardClose()) {
        if (keyCode == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_UP) {
            if (mSearchView != null && mSearchView.isSearchOpen()) {
                mSearchView.close(true);
                return true;
            }
        }
    }
    return super.onKeyPreIme(keyCode, event);
}

@Override
public void onReceive(Context context, Intent intent) {
    if (intent.getAction().equals(Intent.ACTION_MEDIA_BUTTON)) {
        KeyEvent keyEvent = (KeyEvent) intent.getExtras().get(Intent.EXTRA_KEY_EVENT);
        if (keyEvent.getAction() != KeyEvent.ACTION_DOWN)
            return;
        switch(keyEvent.getKeyCode()) {
            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
                Log.d(TAG, "Play/Pause was clicked");
                break;
            case KeyEvent.KEYCODE_MEDIA_NEXT:
                Log.d(TAG, "Next was clicked");
                break;
            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
                Log.d(TAG, "Previous was clicked");
                break;
            default:
                Log.d(TAG, keyEvent.getKeyCode() + " was clicked");
        }
    }
}

public static boolean hasNavBar(Context context) {
    boolean hasBackKey = KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_BACK);
    boolean hasHomeKey = KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_HOME);
    if (hasBackKey && hasHomeKey) {
        if (Build.MANUFACTURER.toLowerCase().contains("samsung") && !Build.MODEL.toLowerCase().contains("nexus")) {
            return false;
        }
        Resources resources = context.getResources();
        int id = resources.getIdentifier("config_showNavigationBar", "bool", "android");
        if (id > 0) {
            return resources.getBoolean(id);
        } else {
            return false;
        }
    } else {
        return true;
    }
}

public static void setFullScreen(final View decorView) {
    int options = decorView.getSystemUiVisibility();
    boolean hasBackKey = KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_BACK);
    boolean hasHomeKey = KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_HOME);
    if (hasBackKey && hasHomeKey) {
        return;
    }
    // Navigation bar hiding:  Backwards compatible to ICS.
    if (Build.VERSION.SDK_INT >= 14) {
        options |= View.SYSTEM_UI_FLAG_LAYOUT_STABLE;
        options |= View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION;
        options |= View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
    }
    // Status bar hiding: Backwards compatible to Jellybean
    if (Build.VERSION.SDK_INT >= 16) {
        options |= View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN;
        options |= View.SYSTEM_UI_FLAG_FULLSCREEN;
    }
    if (Build.VERSION.SDK_INT >= 18) {
        options |= View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
    }
    decorView.setSystemUiVisibility(options);
}

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        if (getFragmentManager().getBackStackEntryCount() == 0) {
            this.finish();
            return false;
        } else {
            getFragmentManager().popBackStack();
            return false;
        }
    }
    return super.onKeyDown(keyCode, event);
}

@Override
public void onReceive(Context context, Intent intent) {
    KeyEvent event = (KeyEvent) intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
    if (event == null) {
        return;
    }
    Intent i = new Intent(Intent.ACTION_MAIN);
    i.setClass(context, Camera.class);
    i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    context.startActivity(i);
}

@Override
public void onReceive(Context context, Intent intent) {
    if (intent.getAction().equals(Intent.ACTION_MEDIA_BUTTON)) {
        KeyEvent keyEvent = (KeyEvent) intent.getExtras().get(Intent.EXTRA_KEY_EVENT);
        if (keyEvent.getAction() != KeyEvent.ACTION_DOWN)
            return;
        switch(keyEvent.getKeyCode()) {
            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
                Log.d(TAG, "Play/Pause was clicked");
                break;
            case KeyEvent.KEYCODE_MEDIA_NEXT:
                Log.d(TAG, "Next was clicked");
                break;
            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
                Log.d(TAG, "Previous was clicked");
                break;
            default:
                Log.d(TAG, keyEvent.getKeyCode() + " was clicked");
        }
    }
}

public State onKeyTracker(int keyCode, KeyEvent event, Stage stage, int duration) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        if (stage == KeyTracker.Stage.LONG_REPEAT) {
            // here we have the long pressed back button
            onLongPressBack(keyCode, event, stage, duration);
            lastStage = stage;
            return KeyTracker.State.KEEP_TRACKING;
        } else if (stage == KeyTracker.Stage.UP) {
            if (lastStage == Stage.LONG_REPEAT) {
                lastStage = Stage.SHORT_REPEAT;
                return KeyTracker.State.DONE_TRACKING;
            }
            onShortPressBack(keyCode, event, stage, duration);
            return KeyTracker.State.NOT_TRACKING;
        }
        return KeyTracker.State.KEEP_TRACKING;
    }
    return KeyTracker.State.NOT_TRACKING;
}

@Override
protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
    KeyEvent event = (KeyEvent) param.args[0];
    Context mContext = (Context) getObjectField(param.thisObject, "mContext");
    int keyCode = event.getKeyCode();
    boolean power = Build.VERSION.SDK_INT < 23 && keyCode == KEYCODE_POWER;
    boolean interactive = ((int) param.args[1] & 0x20000000) != 0;
    logD(TAG, "Interactive: " + interactive);
    logD(TAG, "power: " + power);
    logD(TAG, "keyCode: " + keyCode);
    if (!interactive && (keyCode == KEYCODE_HOME || keyCode == KEYCODE_WAKEUP || power)) {
        sendAction(mContext, param, prefs);
        param.setResult(-1);
    }
}

@Override
public void onReceive(Context context, Intent intent) {
    if (Intent.ACTION_MEDIA_BUTTON.equals(intent.getAction())) {
        KeyEvent key = (KeyEvent) intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
        if (key.getAction() == KeyEvent.ACTION_DOWN) {
            TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
            if (tm.getCallState() == TelephonyManager.CALL_STATE_IDLE) {
                Log.i(TAG, "OnReceive, getKeyCode = " + key.getKeyCode());
                switch(key.getKeyCode()) {
                    case KeyEvent.KEYCODE_HEADSETHOOK:
                        context.startService(new Intent(MusicService.ACTION_PLAY));
                        break;
                    case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
                        context.startService(new Intent(MusicService.ACTION_PREVIOUS));
                        break;
                    case KeyEvent.KEYCODE_MEDIA_NEXT:
                        context.startService(new Intent(MusicService.ACTION_NEXT));
                        break;
                }
            }
        }
    }
}

@Override
public void onResume() {
    super.onResume();
    getView().setFocusableInTouchMode(true);
    getView().requestFocus();
    getView().setOnKeyListener(new View.OnKeyListener() {

        @Override
        public boolean onKey(View v, int keyCode, KeyEvent event) {
            if (event.getAction() == KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_BACK) {
                fgListener.switchFragment(new HomePageFg(), false);
                return true;
            }
            return false;
        }
    });
}

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (event.getAction() == KeyEvent.ACTION_DOWN) {
        switch(keyCode) {
            case KeyEvent.KEYCODE_BACK:
                if (wv.canGoBack()) {
                    wv.goBack();
                } else {
                    finish();
                }
                return true;
        }
    }
    return super.onKeyDown(keyCode, event);
}

/**
	 * Activity onKeyDownʼþ
	 * */
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode != KeyEvent.KEYCODE_BACK) {
        return false;
    }
    if (isOnKeyBacking) {
        mHandler.removeCallbacks(onBackTimeRunnable);
        if (mBackToast != null) {
            mBackToast.cancel();
        }
        mActivity.finish();
        return true;
    } else {
        isOnKeyBacking = true;
        if (mBackToast == null) {
        }
        mHandler.postDelayed(onBackTimeRunnable, 2000);
        return true;
    }
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.search_tab);
    searchTitle = (EditText) findViewById(R.id.search_query_words);
    searchButton = (ImageButton) findViewById(R.id.search_button);
    searchTitle.setOnKeyListener(new OnKeyListener() {

        @Override
        public boolean onKey(View v, int keyCode, KeyEvent event) {
            if (keyCode == KeyEvent.KEYCODE_ENTER && event.getAction() == KeyEvent.ACTION_UP) {
                search();
                return true;
            }
            return false;
        }
    });
    searchButton.setOnClickListener(new OnClickListener() {

        @Override
        public void onClick(View v) {
            search();
        }
    });
}

/*
	 * ���返回键�应(non-Javadoc)
	 * 
	 * @see android.app.Activity#onKeyDown(int, android.view.KeyEvent)
	 */
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        Timer tExit = null;
        if (isExit == false) {
            // 准备退出
            isExit = true;
            Toast.makeText(this, "功能暂�开通，�按一次返回上一页", Toast.LENGTH_SHORT).show();
            tExit = new Timer();
            tExit.schedule(new TimerTask() {

                @Override
                public void run() {
                    // �消退出
                    isExit = false;
                }
            }, // 如果2秒钟内没有按下返回键，则�动定时器�消掉刚�执行的任务
            2000);
        } else {
            this.finish();
            overridePendingTransition(R.anim.push_down_in, // 上往下推出效果
            R.anim.push_down_out);
        }
    }
    return false;
}

/*
     * (non-Javadoc)
     * 
     * @see android.widget.TextView#onKeyPreIme(int, android.view.KeyEvent)
     */
@Override
public boolean onKeyPreIme(int keyCode, KeyEvent event) {
    // doing this somehow interferes with key presses."
    if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
        if (mListener != null) {
            if (mListener.onBackButtonPressed()) {
                return true;
            }
        }
    }
    return super.dispatchKeyEvent(event);
}

/**
     * Report that a media button has been pressed.  This is like
     * {@link android.view.KeyEvent.Callback#onKeyDown(int, android.view.KeyEvent)} but
     * will only deliver media keys.  The default implementation handles these keys:
     * <ul>
     *     <li>KEYCODE_MEDIA_PLAY: call {@link #onStart}</li>
     *     <li>KEYCODE_MEDIA_PAUSE: call {@link #onPause}</li>
     *     <li>KEYCODE_MEDIA_STOP: call {@link #onStop}</li>
     *     <li>KEYCODE_MEDIA_PLAY_PAUSE and KEYCODE_HEADSETHOOK: call {@link #onPause}
     *          if {@link #onIsPlaying()} returns true, otherwise call {@link #onStart}</li>
     * </ul>
     * @param keyCode The code of the media key.
     * @param event The full key event.
     * @return Indicate whether the key has been consumed.  The default
     * implementation always returns true.  This only matters for keys
     * being dispatched here from
     * {@link TransportMediator#dispatchKeyEvent(android.view.KeyEvent)
     * TransportController.dispatchKeyEvent}, and determines whether the key
     * continues on to its default key handling (which for media keys means
     * being delivered to the current media remote control, which should
     * be us).
     */
public boolean onMediaButtonDown(int keyCode, KeyEvent event) {
    switch(keyCode) {
        case TransportMediator.KEYCODE_MEDIA_PLAY:
            onStart();
            return true;
        case TransportMediator.KEYCODE_MEDIA_PAUSE:
            onPause();
            return true;
        case KeyEvent.KEYCODE_MEDIA_STOP:
            onStop();
            return true;
        case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
        case KeyEvent.KEYCODE_HEADSETHOOK:
            if (onIsPlaying()) {
                onPause();
            } else {
                onStart();
            }
    }
    return true;
}

/**
     * Report that a media button has been pressed.  This is like
     * {@link android.view.KeyEvent.Callback#onKeyDown(int, android.view.KeyEvent)} but
     * will only deliver media keys.  The default implementation handles these keys:
     * <ul>
     *     <li>KEYCODE_MEDIA_PLAY: call {@link #onStart}</li>
     *     <li>KEYCODE_MEDIA_PAUSE: call {@link #onPause}</li>
     *     <li>KEYCODE_MEDIA_STOP: call {@link #onStop}</li>
     *     <li>KEYCODE_MEDIA_PLAY_PAUSE and KEYCODE_HEADSETHOOK: call {@link #onPause}
     *          if {@link #onIsPlaying()} returns true, otherwise call {@link #onStart}</li>
     * </ul>
     * @param keyCode The code of the media key.
     * @param event The full key event.
     * @return Indicate whether the key has been consumed.  The default
     * implementation always returns true.  This only matters for keys
     * being dispatched here from
     * {@link TransportMediator#dispatchKeyEvent(android.view.KeyEvent)
     * TransportController.dispatchKeyEvent}, and determines whether the key
     * continues on to its default key handling (which for media keys means
     * being delivered to the current media remote control, which should
     * be us).
     */
public boolean onMediaButtonDown(int keyCode, KeyEvent event) {
    switch(keyCode) {
        case TransportMediator.KEYCODE_MEDIA_PLAY:
            onStart();
            return true;
        case TransportMediator.KEYCODE_MEDIA_PAUSE:
            onPause();
            return true;
        case KeyEvent.KEYCODE_MEDIA_STOP:
            onStop();
            return true;
        case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
        case KeyEvent.KEYCODE_HEADSETHOOK:
            if (onIsPlaying()) {
                onPause();
            } else {
                onStart();
            }
    }
    return true;
}

/**
     * Report that a media button has been pressed.  This is like
     * {@link android.view.KeyEvent.Callback#onKeyDown(int, android.view.KeyEvent)} but
     * will only deliver media keys.  The default implementation handles these keys:
     * <ul>
     *     <li>KEYCODE_MEDIA_PLAY: call {@link #onStart}</li>
     *     <li>KEYCODE_MEDIA_PAUSE: call {@link #onPause}</li>
     *     <li>KEYCODE_MEDIA_STOP: call {@link #onStop}</li>
     *     <li>KEYCODE_MEDIA_PLAY_PAUSE and KEYCODE_HEADSETHOOK: call {@link #onPause}
     *          if {@link #onIsPlaying()} returns true, otherwise call {@link #onStart}</li>
     * </ul>
     * @param keyCode The code of the media key.
     * @param event The full key event.
     * @return Indicate whether the key has been consumed.  The default
     * implementation always returns true.  This only matters for keys
     * being dispatched here from
     * {@link TransportMediator#dispatchKeyEvent(android.view.KeyEvent)
     * TransportController.dispatchKeyEvent}, and determines whether the key
     * continues on to its default key handling (which for media keys means
     * being delivered to the current media remote control, which should
     * be us).
     */
public boolean onMediaButtonDown(int keyCode, KeyEvent event) {
    switch(keyCode) {
        case TransportMediator.KEYCODE_MEDIA_PLAY:
            onStart();
            return true;
        case TransportMediator.KEYCODE_MEDIA_PAUSE:
            onPause();
            return true;
        case KeyEvent.KEYCODE_MEDIA_STOP:
            onStop();
            return true;
        case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
        case KeyEvent.KEYCODE_HEADSETHOOK:
            if (onIsPlaying()) {
                onPause();
            } else {
                onStart();
            }
    }
    return true;
}

/**
     * Report that a media button has been pressed.  This is like
     * {@link android.view.KeyEvent.Callback#onKeyDown(int, android.view.KeyEvent)} but
     * will only deliver media keys.  The default implementation handles these keys:
     * <ul>
     *     <li>KEYCODE_MEDIA_PLAY: call {@link #onStart}</li>
     *     <li>KEYCODE_MEDIA_PAUSE: call {@link #onPause}</li>
     *     <li>KEYCODE_MEDIA_STOP: call {@link #onStop}</li>
     *     <li>KEYCODE_MEDIA_PLAY_PAUSE and KEYCODE_HEADSETHOOK: call {@link #onPause}
     *          if {@link #onIsPlaying()} returns true, otherwise call {@link #onStart}</li>
     * </ul>
     * @param keyCode The code of the media key.
     * @param event The full key event.
     * @return Indicate whether the key has been consumed.  The default
     * implementation always returns true.  This only matters for keys
     * being dispatched here from
     * {@link TransportMediator#dispatchKeyEvent(android.view.KeyEvent)
     * TransportController.dispatchKeyEvent}, and determines whether the key
     * continues on to its default key handling (which for media keys means
     * being delivered to the current media remote control, which should
     * be us).
     */
public boolean onMediaButtonDown(int keyCode, KeyEvent event) {
    switch(keyCode) {
        case TransportMediator.KEYCODE_MEDIA_PLAY:
            onStart();
            return true;
        case TransportMediator.KEYCODE_MEDIA_PAUSE:
            onPause();
            return true;
        case KeyEvent.KEYCODE_MEDIA_STOP:
            onStop();
            return true;
        case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
        case KeyEvent.KEYCODE_HEADSETHOOK:
            if (onIsPlaying()) {
                onPause();
            } else {
                onStart();
            }
    }
    return true;
}

/**
     * Report that a media button has been pressed.  This is like
     * {@link android.view.KeyEvent.Callback#onKeyDown(int, android.view.KeyEvent)} but
     * will only deliver media keys.  The default implementation handles these keys:
     * <ul>
     *     <li>KEYCODE_MEDIA_PLAY: call {@link #onStart}</li>
     *     <li>KEYCODE_MEDIA_PAUSE: call {@link #onPause}</li>
     *     <li>KEYCODE_MEDIA_STOP: call {@link #onStop}</li>
     *     <li>KEYCODE_MEDIA_PLAY_PAUSE and KEYCODE_HEADSETHOOK: call {@link #onPause}
     *          if {@link #onIsPlaying()} returns true, otherwise call {@link #onStart}</li>
     * </ul>
     * @param keyCode The code of the media key.
     * @param event The full key event.
     * @return Indicate whether the key has been consumed.  The default
     * implementation always returns true.  This only matters for keys
     * being dispatched here from
     * {@link TransportMediator#dispatchKeyEvent(android.view.KeyEvent)
     * TransportController.dispatchKeyEvent}, and determines whether the key
     * continues on to its default key handling (which for media keys means
     * being delivered to the current media remote control, which should
     * be us).
     */
public boolean onMediaButtonDown(int keyCode, KeyEvent event) {
    switch(keyCode) {
        case TransportMediator.KEYCODE_MEDIA_PLAY:
            onStart();
            return true;
        case TransportMediator.KEYCODE_MEDIA_PAUSE:
            onPause();
            return true;
        case KeyEvent.KEYCODE_MEDIA_STOP:
            onStop();
            return true;
        case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
        case KeyEvent.KEYCODE_HEADSETHOOK:
            if (onIsPlaying()) {
                onPause();
            } else {
                onStart();
            }
    }
    return true;
}