Android4.3 屏蔽HOME按键返回桌面详解(源码环境下)

点击打开链接

首先声明我是做系统开发的(高通平台)，所以下面介绍的方法并不适合应用开发者。

    最经有个需求要屏蔽HOME按键返回桌面并且实现自己的功能，发现以前的方式报错用不了，上网搜索了一下，发现都是抄来抄去基本是无用的。网上的方法不外乎这几种：

  第一， 大家最常用的重写onAttachedToWindow()方法，然后在HOME点击事件KeyEvent.KEYCODE_HOME中做自己想做的事情，但是这个方法google处于安全考虑在android2.3.3之后就不支持了。

  第二， 抓取系统log日志，判断有没有打印“Android.intent.category.HOME”信息来获得是否按下了HOME按键， 这样做就算代码知道是按下HOME键，那怎么阻止返回桌面呢？ 这只能是截获HOME按键，并不能屏蔽它返回桌面的功能。

 第三， 修改framework源码，在PhoneWindowManager中处理HOME按键的地方发送一个消息，然后在上层应用中捕获这个消息，这和上面是一样的，只能截获HOME按键，并不能阻止返回桌面的动作。

 第四， 在setContentView之前getWindow().setFlags(FLAG_HOMEKEY_DISPATCHED, FLAG_HOMEKEY_DISPATCHED); 这个FLAG_HOMEKEY_DISPATCHED其实是个标志位，是个常量，值为0x80000000， 这个方法确实可以，但仅限于MTK(联发科)平台的系统，因为MTK自己实现了一套机制来规避HOME按键，而其它的平台，如高通、博通、展迅的代码中是没有加这个属性的，所以也不行。

 还有极少数思路很极端的方式，看上去都觉得很繁琐，根本没耐心细看。

 现在介绍我的思路，首先还是复写onAttachedToWindow()方法，具体代码是在activity中加入这一段：

@Override
public void onAttachedToWindow() {
        this.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD);
        super.onAttachedToWindow();

    }

   结果当然是一进入这个activity就报错，logcat查看错误信息，报的错误是"Window type can not be changed after the window is added."，发现是WindowManagerService.java中报的错，源码位置frameworks/base/services/java/com/android/server/wm/WindowManagerService.java，具体代码段是relayoutWindow方法中判断窗口类型的时候报错：

  if (attrs != null) {
                if (win.mAttrs.type != attrs.type) {
                    throw new IllegalArgumentException(
                            "Window type can not be changed after the window is added.");
                }
                flagChanges = win.mAttrs.flags ^= attrs.flags;
                attrChanges = win.mAttrs.copyFrom(attrs);
                if ((attrChanges & (WindowManager.LayoutParams.LAYOUT_CHANGED
                        | WindowManager.LayoutParams.SYSTEM_UI_VISIBILITY_CHANGED)) != 0) {
                    win.mLayoutNeeded = true;
                }
     }

  刚才说了，google可能是出于安全原因不能让你把窗口类型设为WindowManager.LayoutParams.TYPE_KEYGUARD了， 设置了就报错，要屏蔽这个错误只需要把if (win.mAttrs.type != attrs.type) {
                    throw new IllegalArgumentException(
                            "Window type can not be changed after the window is added.");
                }

注释掉就行了，再次运行就不会报错了，但是按HOME键还是返回桌面。继续看分发HOME按键事件的代码，源码位置frameworks/base/policy/src/com/android/internal/policy/impl/PhoneWindowManager.java中的if (keyCode == KeyEvent.KEYCODE_HOME) {...}中，这里就是处理上层用户按下HOME键的代码，在里面会看到// If a system window has focus, then it doesn't make sense
            // right now to interact with applications.
            WindowManager.LayoutParams attrs = win != null ? win.getAttrs() : null;
            if (attrs != null) {
                final int type = attrs.type;
                if (type == WindowManager.LayoutParams.TYPE_KEYGUARD
                        || type == WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG) {
                    // the "app" is keyguard, so give it the key
                    return 0;
                }
                final int typeCount = WINDOW_TYPES_WHERE_HOME_DOESNT_WORK.length;
                for (int i=0; i<typeCount; i++) {
                    if (type == WINDOW_TYPES_WHERE_HOME_DOESNT_WORK[i]) {
                        // don't do anything, but also don't pass it to the app
                        return -1;
                    }
                }
            }

这一段代码，意思就是如果设置了窗口类型为 WindowManager.LayoutParams.TYPE_KEYGUARD(值为2004) 或者WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG，那就return 0，交给用户自己处理，不返回桌面，否则返回－1，返回桌面。通过打log发现代码确实是return 0，但还是返回桌面，后来才发现还有方法在返回桌面：/**
     * A home key -> launch home action was detected.  Take the appropriate action
     * given the situation with the keyguard.
     */
    void launchHomeFromHotKey() {
        if (mKeyguardMediator != null && mKeyguardMediator.isShowingAndNotHidden()) {
            // don't launch home if keyguard showing
        } else if (!mHideLockScreen && mKeyguardMediator.isInputRestricted()) {
            // when in keyguard restricted mode, must first verify unlock
            // before launching home
            mKeyguardMediator.verifyUnlock(new OnKeyguardExitResult() {
                public void onKeyguardExitResult(boolean success) {
                    if (success) {
                        try {
                            ActivityManagerNative.getDefault().stopAppSwitches();
                        } catch (RemoteException e) {
                        }
                        sendCloseSystemWindows(SYSTEM_DIALOG_REASON_HOME_KEY);
                        startDockOrHome();
                    }
                }
            });
        } else {
            // no keyguard stuff to worry about, just launch home!
            try {
                ActivityManagerNative.getDefault().stopAppSwitches();
            } catch (RemoteException e) {
            }
            sendCloseSystemWindows(SYSTEM_DIALOG_REASON_HOME_KEY);
            startDockOrHome();
        }
    }

不知道高通怎么改的，就算return 0也会执行这个方法，也会返回桌面，因为这个方法在判断窗口类型前面调用，现在要做的就简单了，只需要加个判断，就可以屏蔽返回HOME了：

boolean isGoHome = true;
                WindowManager.LayoutParams attrs = win != null ? win.getAttrs() : null;
                if (attrs != null) {
                    final int type = attrs.type;
                    if (type == WindowManager.LayoutParams.TYPE_KEYGUARD) {
                        isGoHome = false;
                    }
                }
                // Go home!
                if (isGoHome) {
                    launchHomeFromHotKey();
                }

整个HOME按键的代码段：

// First we always handle the home key here, so applications
        // can never break it, although if keyguard is on, we do let
        // it handle it, because that gives us the correct 5 second
        // timeout.
        if (keyCode == KeyEvent.KEYCODE_HOME) {

            // If we have released the home key, and didn't do anything else
            // while it was pressed, then it is time to go home!
            if (!down) {
                cancelPreloadRecentApps();
                mHomePressed = false;
                if (mHomeConsumed) {
                    mHomeConsumed = false;
                    return -1;
                }

                if (canceled) {
                    Log.i(TAG, "Ignoring HOME; event canceled.");
                    return -1;
                }

                // If an incoming call is ringing, HOME is totally disabled.
                // (The user is already on the InCallScreen at this point,
                // and his ONLY options are to answer or reject the call.)
                try {
                    ITelephony telephonyService = getTelephonyService();
                    if (telephonyService != null && telephonyService.isRinging()) {
                        Log.i(TAG, "Ignoring HOME; there's a ringing incoming call.");
                        return -1;
                    }
                } catch (RemoteException ex) {
                    Log.w(TAG, "RemoteException from getPhoneInterface()", ex);
                }

                // Delay handling home if a double-tap is possible.
                if (mDoubleTapOnHomeBehavior != DOUBLE_TAP_HOME_NOTHING) {
                    mHandler.removeCallbacks(mHomeDoubleTapTimeoutRunnable); // just in case
                    mHomeDoubleTapPending = true;
                    mHandler.postDelayed(mHomeDoubleTapTimeoutRunnable,
                            ViewConfiguration.getDoubleTapTimeout());
                    return -1;
                }

                boolean isGoHome = true;
                WindowManager.LayoutParams attrs = win != null ? win.getAttrs() : null;
                if (attrs != null) {
                    final int type = attrs.type;
                    if (type == WindowManager.LayoutParams.TYPE_KEYGUARD) {
                        isGoHome = false;
                    }
                }
                // Go home!
                if (isGoHome) {
                    launchHomeFromHotKey();
                }
                return -1;
            }

            // If a system window has focus, then it doesn't make sense
            // right now to interact with applications.
            WindowManager.LayoutParams attrs = win != null ? win.getAttrs() : null;
            if (attrs != null) {
                final int type = attrs.type;
                if (type == WindowManager.LayoutParams.TYPE_KEYGUARD
                        || type == WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG) {
                    // the "app" is keyguard, so give it the key
                    return 0;
                }
                final int typeCount = WINDOW_TYPES_WHERE_HOME_DOESNT_WORK.length;
                for (int i=0; i<typeCount; i++) {
                    if (type == WINDOW_TYPES_WHERE_HOME_DOESNT_WORK[i]) {
                        // don't do anything, but also don't pass it to the app
                        return -1;
                    }
                }
            }

            // Remember that home is pressed and handle special actions.
            if (repeatCount == 0) {
                mHomePressed = true;
                if (mHomeDoubleTapPending) {
                    mHomeDoubleTapPending = false;
                    mHandler.removeCallbacks(mHomeDoubleTapTimeoutRunnable);
                    handleDoubleTapOnHome();
                } else if (mLongPressOnHomeBehavior == LONG_PRESS_HOME_RECENT_SYSTEM_UI
                        || mDoubleTapOnHomeBehavior == DOUBLE_TAP_HOME_RECENT_SYSTEM_UI) {
                    preloadRecentApps();
                }
            } else if ((event.getFlags() & KeyEvent.FLAG_LONG_PRESS) != 0) {
                if (!keyguardOn) {
                    handleLongPressOnHome();
                }
            }
            return -1;
        }

至此就可以屏蔽HOME按键了，在需在上层应用中复写onAttachedToWindow()方法即可，然后

@Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        switch (keyCode) {
            case KeyEvent.KEYCODE_HOME:
// 想实现的功能

                break;
        }
        return true;
    }

至此分析完毕，如果要屏蔽HOME键返回桌面不修改源码是不行的，至少上面介绍的那些方法是不行的(MTK除外)，所以有这个需求的童鞋找方法的时候就不要浪费时间去看那些抄来抄去的帖子了。