Android 12系统源码_输入事件（一）HOME按键事件响应流程

已于 2025-05-21 19:44:20 修改
阅读量3k 收藏 13
点赞数 1
分类专栏： Framework12源码 文章标签： android frameworks
于 2023-08-19 14:36:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abc6368765/article/details/132164705
版权

前言

本文我们主要分析一下android系统对HOME按键的响应过程，HOME按键事件是属于系统级别的按键事件监听，而在Android系统中，系统级别的按键处理逻辑都在PhoneWindowManager这个类中。

一、interceptKeyBeforeDispatching方法分发按键事件

1、PhoneWindowManager的dispatchUnhandledKey方法会先收到按键事件。

frameworks/base/services/core/java/com/android/server/policy/PhoneWindowManager.java

public class PhoneWindowManager implements WindowManagerPolicy {
    @Override
    public KeyEvent dispatchUnhandledKey(IBinder focusedToken, KeyEvent event, int policyFlags) {
        KeyEvent fallbackEvent = null;
        if ((event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
            final KeyCharacterMap kcm = event.getKeyCharacterMap();
            final int keyCode = event.getKeyCode();
            final int metaState = event.getMetaState();
            final boolean initialDown = event.getAction() == KeyEvent.ACTION_DOWN
                    && event.getRepeatCount() == 0;

            // Check for fallback actions specified by the key character map.
            final FallbackAction fallbackAction;
            if (initialDown) {
                fallbackAction = kcm.getFallbackAction(keyCode, metaState);
            } else {
                fallbackAction = mFallbackActions.get(keyCode);
            }

            if (fallbackAction != null) {
                if (DEBUG_INPUT) {
                    Slog.d(TAG, "Fallback: keyCode=" + fallbackAction.keyCode
                            + " metaState=" + Integer.toHexString(fallbackAction.metaState));
                }

                final int flags = event.getFlags() | KeyEvent.FLAG_FALLBACK;
                fallbackEvent = KeyEvent.obtain(
                        event.getDownTime(), event.getEventTime(),
                        event.getAction(), fallbackAction.keyCode,
                        event.getRepeatCount(), fallbackAction.metaState,
                        event.getDeviceId(), event.getScanCode(),
                        flags, event.getSource(), event.getDisplayId(), null);
				//在这里进一步触发interceptFallback方法
                if (!interceptFallback(focusedToken, fallbackEvent, policyFlags)) {
                    fallbackEvent.recycle();
                    fallbackEvent = null;
                }

                if (initialDown) {
                    mFallbackActions.put(keyCode, fallbackAction);
                } else if (event.getAction() == KeyEvent.ACTION_UP) {
                    mFallbackActions.remove(keyCode);
                    fallbackAction.recycle();
                }
            }
        }
        return fallbackEvent;
    }
   
    private boolean interceptFallback(IBinder focusedToken, KeyEvent fallbackEvent,
            int policyFlags) {
        int actions = interceptKeyBeforeQueueing(fallbackEvent, policyFlags);
        if ((actions & ACTION_PASS_TO_USER) != 0) {
            //进一步调用interceptKeyBeforeDispatching
            long delayMillis = interceptKeyBeforeDispatching(
                    focusedToken, fallbackEvent, policyFlags);
            if (delayMillis == 0) {
                return true;
            }
        }
        return false;
    }
}

PhoneWindowManager的dispatchUnhandledKey方法会继续触发另一个关键方法interceptFallback，而interceptFallback方法又会进一步调用interceptKeyBeforeDispatching方法。

2、PhoneWindowManager的interceptKeyBeforeDispatching方法如下所示。

public class PhoneWindowManager implements WindowManagerPolicy {

    private final SparseArray<DisplayHomeButtonHandler> mDisplayHomeButtonHandlers = new SparseArray<>();
    @Override
    public long interceptKeyBeforeDispatching(IBinder focusedToken, KeyEvent event,
            int policyFlags) {
        final boolean keyguardOn = keyguardOn();
        final int keyCode = event.getKeyCode();//按键编码
        final int repeatCount = event.getRepeatCount();
        final int metaState = event.getMetaState();
        final int flags = event.getFlags();
        final boolean down = event.getAction() == KeyEvent.ACTION_DOWN;
        final boolean canceled = event.isCanceled();
        final int displayId = event.getDisplayId();//屏幕设备id
        final long key_consumed = -1;
   		...代码省略...
        switch(keyCode) {
            case KeyEvent.KEYCODE_HOME://系统主要是在这里对HOME按键事件进行响应的
                //从缓存集合中获取Handler
                DisplayHomeButtonHandler handler = mDisplayHomeButtonHandlers.get(displayId);
                if (handler == null) {
                    //如果没有缓存，则创建Handler并添加到缓存集合中
                    handler = new DisplayHomeButtonHandler(displayId);
                    mDisplayHomeButtonHandlers.put(displayId, handler);
                }
                return handler.handleHomeButton(focusedToken, event);
            case KeyEvent.KEYCODE_MENU://菜单按键事件
                ...代码省略...
                break;
            case KeyEvent.KEYCODE_APP_SWITCH://应用切换按键事件
                ...代码省略...
                return key_consumed;
            ...代码省略...
        }
        if (isValidGlobalKey(keyCode)
                && mGlobalKeyManager.handleGlobalKey(mContext, keyCode, event)) {
            return key_consumed;
        }
        if ((metaState & KeyEvent.META_META_ON) != 0) {
            return key_consumed;
        }
        return 0;
    }

interceptKeyBeforeDispatching方法会通过switch的各个case分支，分别来响应各种按键事件，我们这里主要关注HOME按键事件的响应过程，系统首先从mDisplayHomeButtonHandlers集合中获取DisplayHomeButtonHandler类型的缓存对象，如果不存在缓存对象则创建DisplayHomeButtonHandler对象并添加到集合中，反正最终会调用DisplayHomeButtonHandler的handleHomeButton方法。

3、DisplayHomeButtonHandler是PhoneWindowManager的内部类，handleHomeButton方法如下所示。

public class PhoneWindowManager implements WindowManagerPolicy {

    private class DisplayHomeButtonHandler {
        private final int mDisplayId;
        private boolean mHomeDoubleTapPending;
        private boolean mHomePressed;
        private boolean mHomeConsumed;

        private final Runnable mHomeDoubleTapTimeoutRunnable = new Runnable() {
            @Override
            public void run() {
                if (mHomeDoubleTapPending) {
                    mHomeDoubleTapPending = false;
                    handleShortPressOnHome(mDisplayId);
                }
            }
        };

        DisplayHomeButtonHandler(int displayId) {
            mDisplayId = displayId;
        }

        int handleHomeButton(IBinder focusedToken, KeyEvent event) {
            final boolean keyguardOn = keyguardOn();
            final int repeatCount = event.getRepeatCount();
            final boolean down = event.getAction() == KeyEvent.ACTION_DOWN;//是否是按下事件
            final boolean canceled = event.isCanceled();

            //一个按键事件大多都有两种Action，按下(ACTION_DOWN)和抬起(ACTION_UP)
            //!down意味着只有用户触发按键抬起的时候这里才会做响应回到首页
            if (!down) {
                if (mDisplayId == DEFAULT_DISPLAY) {
                    cancelPreloadRecentApps();
                }

                mHomePressed = false;
                if (mHomeConsumed) {
                    mHomeConsumed = false;
                    return -1;
                }

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

                if (mDoubleTapOnHomeBehavior != DOUBLE_TAP_HOME_NOTHING) {
                    mHandler.removeCallbacks(mHomeDoubleTapTimeoutRunnable); // just in case
                    mHomeDoubleTapPending = true;
                    mHandler.postDelayed(mHomeDoubleTapTimeoutRunnable,
                            ViewConfiguration.getDoubleTapTimeout());
                    return -1;
                }

                //为了避免阻塞输入管道，这里通过Handler的post方法切换到了主线程
                mHandler.post(() -> handleShortPressOnHome(mDisplayId));
                return -1;
            }
        	...代码省略...
            return -1;
        }
    }
    
    private void handleShortPressOnHome(int displayId) {
        // Turn on the connected TV and switch HDMI input if we're a HDMI playback device.
        final HdmiControl hdmiControl = getHdmiControl();
        if (hdmiControl != null) {
            hdmiControl.turnOnTv();
        }

        // If there's a dream running then use home to escape the dream
        // but don't actually go home.
        if (mDreamManagerInternal != null && mDreamManagerInternal.isDreaming()) {
            mDreamManagerInternal.stopDream(false /*immediate*/);
            return;
        }
        // Go home!
        launchHomeFromHotKey(displayId);
    }
}

handleHomeButton方法首先获取按键的Action类型是否为按下，并且进行了条件判断，只有当按键抬起的时候才会触发返回首页的相关操作，为了避免阻塞输入管道，这里通过Handler的post方法将当前线程切换到了主线程，并进一步调用handleShortPressOnHome方法，该方法又进一步调用launchHomeFromHotKey方法。

4、PhoneWindowManager的launchHomeFromHotKey方法如下所示。

public class PhoneWindowManager implements WindowManagerPolicy {

    void launchHomeFromHotKey(int displayId) {
        launchHomeFromHotKey(displayId, true /* awakenFromDreams */, true /*respectKeyguard*/);
    }

    /**
     * A home key -> launch home action was detected.  Take the appropriate action
     * given the situation with the keyguard.
     */
    void launchHomeFromHotKey(int displayId, final boolean awakenFromDreams,
            final boolean respectKeyguard) {
        if (respectKeyguard) {
            if (isKeyguardShowingAndNotOccluded()) {
                return;
            }

            if (!isKeyguardOccluded() && mKeyguardDelegate.isInputRestricted()) {
                //当处于锁屏模式的时候，首先应该解锁然后才能打开首页
                mKeyguardDelegate.verifyUnlock(new OnKeyguardExitResult() {
                    @Override
                    public void onKeyguardExitResult(boolean success) {
                        if (success) {
                            startDockOrHome(displayId, true /*fromHomeKey*/, awakenFromDreams);
                        }
                    }
                });
                return;
            }
        }

        //判断最近任务是否可见
        if (mRecentsVisible) {
            try {
                //如果最近任务视图可见，则会先停止应用切换功能
                ActivityManager.getService().stopAppSwitches();
            } catch (RemoteException e) {}

            if (awakenFromDreams) {
                awakenDreams();
            }
            //隐藏最近任务
            hideRecentApps(false, true);
        } else {
            //否则，打开首页
            startDockOrHome(displayId, true /*fromHomeKey*/, awakenFromDreams);
        }
    }
 }

launchHomeFromHotKey方法先是判断当前是否处于锁屏状态，如果处于锁屏状体则必须先解锁然后才能打开首页。然后会判断最近任务是否可见：

  • 如果可见则会调用AMS的stopAppSwitches方法停止应用切换功能，该方法的目的主要是为了暂停后台打开Activity的操作，避免打扰用户的操作.比如这时候我们在后台打开一个新的App，那么由于要回到home页面，所以需要先延时打开。在停止应用切换功能之后还会调用hideRecentApps隐藏最近任务。
  • 如果最近任务不可见，则会直接调用startDockOrHome方法打开首页。

二、暂停应用切换Activity的功能。

1、PhoneWindowManager的startDockOrHome方法如下所示。

public class PhoneWindowManager implements WindowManagerPolicy {

    static public final String SYSTEM_DIALOG_REASON_HOME_KEY = "homekey";

    void startDockOrHome(int displayId, boolean fromHomeKey, boolean awakenFromDreams,
            String startReason) {
        try {
        	//先停止应用切换功能
            ActivityManager.getService().stopAppSwitches();
        } catch (RemoteException e) {}
		...代码暂时省略...
    }
}

startDockOrHome方法首先会调用ActivityManager.getService().stopAppSwitches()方法暂停掉应用切换Activity的功能。

2、ActivityManagerService的stopAppSwitches方法如下所示。

frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {
   public ActivityTaskManagerService mActivityTaskManager;
    @Override
    public void stopAppSwitches() {
        mActivityTaskManager.stopAppSwitches();
    }
}

ActivityManagerService的stopAppSwitches方法什么都没做，只是进一步调用ActivityTaskManagerService的stopAppSwitches方法。

3、继续来看下和ActivityTaskManagerService的stopAppSwitches方法相关的代码。

frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java

public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
    /**是否允许一个正常的应用切换Acivity**/
    private volatile int mAppSwitchesState = APP_SWITCH_ALLOW;
    //重新允许后台应用进行应用切换的时间间隔
    private static final long RESUME_FG_APP_SWITCH_MS = 500;
    /** 不允许应用切换Activity */
    static final int APP_SWITCH_DISALLOW = 0;
    /**只允许前台应用进行Activity切换 */
    static final int APP_SWITCH_FG_ONLY = 1;
    /** 允许应用切换Activity */
    static final int APP_SWITCH_ALLOW = 2;
    
    @IntDef({
            APP_SWITCH_DISALLOW,
            APP_SWITCH_FG_ONLY,
            APP_SWITCH_ALLOW,
    })
    @Retention(RetentionPolicy.SOURCE)
    @interface AppSwitchState {}
    //最后一次设置禁止应用切换Activity的时间
    private volatile long mLastStopAppSwitchesTime;

    /**
     * 是否允许应用切换Activity
     */
    @AppSwitchState int getBalAppSwitchesState() {
        return mAppSwitchesState;
    }

    //禁止应用切换Activity的功能
    @Override
    public void stopAppSwitches() {
        mAmInternal.enforceCallingPermission(STOP_APP_SWITCHES, "stopAppSwitches");
        synchronized (mGlobalLock) {
            mAppSwitchesState = APP_SWITCH_DISALLOW;//不允许应用切换Activity
            mLastStopAppSwitchesTime = SystemClock.uptimeMillis();//纪录当前时间
            mH.removeMessages(H.RESUME_FG_APP_SWITCH_MSG);//清除原来的消息
            //发送消息，延时500毫秒执行，恢复前台应用切换Activity的功能
            mH.sendEmptyMessageDelayed(H.RESUME_FG_APP_SWITCH_MSG, RESUME_FG_APP_SWITCH_MS);
        }
    }
    
    ///恢复应用切换Activity的功能
    @Override
    public void resumeAppSwitches() {
        mAmInternal.enforceCallingPermission(STOP_APP_SWITCHES, "resumeAppSwitches");
        synchronized (mGlobalLock) {
            mAppSwitchesState = APP_SWITCH_ALLOW;//允许应用切换Activity
            mH.removeMessages(H.RESUME_FG_APP_SWITCH_MSG);
        }
    }
    
    final class H extends Handler {
        static final int RESUME_FG_APP_SWITCH_MSG = 4;//恢复应用切换Activity的功能
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            		...代码省略...
                    case RESUME_FG_APP_SWITCH_MSG: {
	                    synchronized (mGlobalLock) {
	                        if (mAppSwitchesState == APP_SWITCH_DISALLOW) {
	                            mAppSwitchesState = APP_SWITCH_FG_ONLY;//只允许前台应用切换Activity
	                        }
	                    }
                	}
                	break;
            }
   }
}
  • stopAppSwitches方法会将mAppSwitchesState的数值修改为APP_SWITCH_DISALLOW，即不允许应用切换Activity，并且会通过Handler发送类型为RESUME_FG_APP_SWITCH_MSG的消息，延时500毫秒执行，触发handleMessage方法，在RESUME_FG_APP_SWITCH_MSG消息分支，将mAppSwitchesState的数值修改为APP_SWITCH_FG_ONLY，即只允许前台应用切换Activity。
  • AMS在启动一个新的Activity的时候，ActivityStarter会调用ATMS的getBalAppSwitchesState方法来判断当前是否允许打开新的Activity。

frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java

class ActivityStarter {

 private final ActivityTaskManagerService mService;
    
    //是否终止后台Activity的启动
    boolean shouldAbortBackgroundActivityStart(int callingUid, int callingPid,
            final String callingPackage, int realCallingUid, int realCallingPid,
            WindowProcessController callerApp, PendingIntentRecord originatingPendingIntent,
            boolean allowBackgroundActivityStart, Intent intent) {
            ...代码省略...
	        //是否允许应用切换Activity
	        final boolean appSwitchAllowedOrFg = appSwitchState == APP_SWITCH_ALLOW || appSwitchState == APP_SWITCH_FG_ONLY;
	        if (((appSwitchAllowedOrFg || mService.mActiveUids.hasNonAppVisibleWindow(callingUid))
	                && callingUidHasAnyVisibleWindow)
	                || isCallingUidPersistentSystemProcess) {
	            return false;
	        }
	       ...代码省略...
    }
    
}

关于Activity的启动流程这里我们不做过多展开，具体请参考Android 12系统源码_页面管理（二）Activity的启动流程（上）这篇文章。

三、关闭系统当前存在的各种弹窗

1、PhoneWindowManager的startDockOrHome在调用stopAppSwitches方法暂停应用切换Activity的功能之后，会调用sendCloseSystemWindows方法关闭系统当前存在的各种弹窗。

public class PhoneWindowManager implements WindowManagerPolicy {

    static public final String SYSTEM_DIALOG_REASON_HOME_KEY = "homekey";

    void startDockOrHome(int displayId, boolean fromHomeKey, boolean awakenFromDreams,
            String startReason) {
        try {
        	//先停止应用切换功能
            ActivityManager.getService().stopAppSwitches();
        } catch (RemoteException e) {}
        //关闭系统当前存在的各种弹窗
        sendCloseSystemWindows(SYSTEM_DIALOG_REASON_HOME_KEY);
		...代码暂时省略...
    }
}

2、PhoneWindowManager的sendCloseSystemWindows方法如下所示。

public class PhoneWindowManager implements WindowManagerPolicy {

    void sendCloseSystemWindows(String reason) {
    	//调用PhoneWindow的sendCloseSystemWindows方法
        PhoneWindow.sendCloseSystemWindows(mContext, reason);
    }
}

sendCloseSystemWindows方法直接调用了PhoneWindow的sendCloseSystemWindows方法

3、PhoneWindow的sendCloseSystemWindows方法如下所示。

frameworks/base/core/java/com/android/internal/policy/PhoneWindow.java

public class PhoneWindow extends Window implements MenuBuilder.Callback {
    public static void sendCloseSystemWindows(Context context, String reason) {
        if (ActivityManager.isSystemReady()) {
            try {
            	//调用AMS的closeSystemDialogs方法
                ActivityManager.getService().closeSystemDialogs(reason);
            } catch (RemoteException e) {
            }
        }
    }
}

PhoneWindow的sendCloseSystemWindows方法会进一步调用ActivityManagerService的sendCloseSystemWindows方法。

4、ActivityManagerService的sendCloseSystemWindows方法如下所示。

public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {
        
    public ActivityTaskManagerInternal mAtmInternal;
    public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
    	...代码省略...
    	mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
    	...代码省略...
    }
    @Override
    public void closeSystemDialogs(String reason) {
        //调用AMS的closeSystemDialogs方法
        mAtmInternal.closeSystemDialogs(reason);
    }
}

ActivityManagerService的closeSystemDialogs方法又进一步调用ActivityTaskManagerInternal的closeSystemDialogs方法。

5、ActivityTaskManagerInternal是一个抽象类，其内部类LocalService继承并实现了这个类的抽象方法。

frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerInternal.java

public abstract class ActivityTaskManagerInternal {
    public abstract void closeSystemDialogs(String reason);
}

public class ActivityTaskManagerService extends IActivityTaskManager.Stub {

    final ActivityTaskManagerInternal mInternal;
    
    public ActivityTaskManagerService(Context context) {
        ...代码省略...
        mInternal = new LocalService();//创建ActivityTaskManagerInternal对象实例
        ...代码省略...
    }
    
    private void start() {
    	//将mInternal存储到LocalServices中
        LocalServices.addService(ActivityTaskManagerInternal.class, mInternal);
    }
    
   RootWindowContainer mRootWindowContainer;//窗口根对象
   WindowManagerService mWindowManager;//窗口管理者服务
   
   public void setWindowManager(WindowManagerService wm) {
        synchronized (mGlobalLock) {
            mWindowManager = wm;
            mRootWindowContainer = wm.mRoot;
			...代码省略...
        }
    }

    final class LocalService extends ActivityTaskManagerInternal {
        @Override
        public void closeSystemDialogs(String reason) {
            enforceNotIsolatedCaller("closeSystemDialogs");
            final int pid = Binder.getCallingPid();
            final int uid = Binder.getCallingUid();
            if (!checkCanCloseSystemDialogs(pid, uid, null)) {
                return;
            }
            final long origId = Binder.clearCallingIdentity();
            try {
                synchronized (mGlobalLock) {
                    // Only allow this from foreground processes, so that background
                    // applications can't abuse it to prevent system UI from being shown.
                    if (uid >= FIRST_APPLICATION_UID) {
                        final WindowProcessController proc = mProcessMap.getProcess(pid);
                        if (!proc.isPerceptible()) {
                            Slog.w(TAG, "Ignoring closeSystemDialogs " + reason
                                    + " from background process " + proc);
                            return;
                        }
                    }
                    //调用窗口管理者服务对象WMS的closeSystemDialogs方法
                    mWindowManager.closeSystemDialogs(reason);
                    //调用窗口根对象RootWindowContainer的closeSystemDialogActivities方法。
                    mRootWindowContainer.closeSystemDialogActivities(reason);
                }
                // Call into AM outside the synchronized block.
                mAmInternal.broadcastCloseSystemDialogs(reason);
            } finally {
                Binder.restoreCallingIdentity(origId);
            }
        }
      }
}

ActivityTaskManagerService的closeSystemDialogs会进一步调用MWS的closeSystemDialogs和RootWindowContainer的closeSystemDialogActivities方法。

6、WindowManagerService的closeSystemDialogs方法如下所示。

public class WindowManagerService extends IWindowManager.Stub
        implements Watchdog.Monitor, WindowManagerPolicy.WindowManagerFuncs {
    
    RootWindowContainer mRoot;
    
    @Override
    public void closeSystemDialogs(String reason) {
        int callingPid = Binder.getCallingPid();
        int callingUid = Binder.getCallingUid();
        if (!mAtmInternal.checkCanCloseSystemDialogs(callingPid, callingUid, null)) {
            return;
        }
        synchronized (mGlobalLock) {
            mRoot.closeSystemDialogs(reason);
        }
    }
}

closeSystemDialogs方法最终会调用RootWindowContainer的closeSystemDialogs方法。

7、来看下RootWindowContainer的closeSystemDialogs和closeSystemDialogActivities方法。

class RootWindowContainer extends WindowContainer<DisplayContent>
        implements DisplayManager.DisplayListener {
   
   private final Consumer<WindowState> mCloseSystemDialogsConsumer = w -> {
        if (w.mHasSurface) {
            try {
            	//调用WindowState内部类mClient的closeSystemDialogs方法。
                w.mClient.closeSystemDialogs(mCloseSystemDialogsReason);
            } catch (RemoteException e) {
            }
        }
    };
    
    //关闭系统弹窗
    void closeSystemDialogs(String reason) {
        mCloseSystemDialogsReason = reason;
        //触发mCloseSystemDialogsConsumer回调对象的方法
        forAllWindows(mCloseSystemDialogsConsumer, false /* traverseTopToBottom */);
    }
    
    //关闭系统弹窗Activity
    void closeSystemDialogActivities(String reason) {
        forAllActivities((r) -> {
            if ((r.info.flags & ActivityInfo.FLAG_FINISH_ON_CLOSE_SYSTEM_DIALOGS) != 0
                    || shouldCloseAssistant(r, reason)) {
                //r是WindowContainer对象实例，这里遍历并依次调用ActivityRecord的finishIfPossible
                r.finishIfPossible(reason, true /* oomAdj */);
            }
        });
    }
    
}

RootWindowContainer的closeSystemDialogs方法最终会调用WindowState内部类mClient的closeSystemDialogs方法。

8、WindowState的内部类mClient属于IWindow，而IWindow是一个aidl文件。

class WindowState extends WindowContainer<WindowState> implements WindowManagerPolicy.WindowState,
        InsetsControlTarget, InputTarget {
    final IWindow mClient;//窗口客户端
 }

frameworks/base/core/java/android/view/IWindow.aidl

oneway interface IWindow {

    void closeSystemDialogs(String reason);

}

9、ViewRootImpl的内部类W实现了IWindow的抽象方法。

public final class ViewRootImpl implements ViewParent,
        View.AttachInfo.Callbacks, ThreadedRenderer.DrawCallbacks,
        AttachedSurfaceControl {
        
    final W mWindow;
    
    public ViewRootImpl(@UiContext Context context, Display display, IWindowSession session,
            boolean useSfChoreographer) {
  		...代码省略...
  		mWindow = new W(this);//创建W对象实例，将自己作为参数传入
  		...代码省略...
	}
	
    static class W extends IWindow.Stub {
	        private final WeakReference<ViewRootImpl> mViewAncestor;
	        private final IWindowSession mWindowSession;
	
	        W(ViewRootImpl viewAncestor) {
	        	//viewAncestor指向了ViewRootImpl
	            mViewAncestor = new WeakReference<ViewRootImpl>(viewAncestor);
	            mWindowSession = viewAncestor.mWindowSession;
	        }
	        @Override
	        public void closeSystemDialogs(String reason) {
	            final ViewRootImpl viewAncestor = mViewAncestor.get();
	            if (viewAncestor != null) {
	            	//调用ViewRootImpl的dispatchCloseSystemDialogs
	                viewAncestor.dispatchCloseSystemDialogs(reason);
	            }
	        }
     }
      
    private static final int MSG_CLOSE_SYSTEM_DIALOGS = 14;
    View mView;//指向了DecorView
    public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView, int userId) {
        synchronized (this) {
            if (mView == null) {
                mView = view;
             }
         }
    }
    
    public void dispatchCloseSystemDialogs(String reason) {
        Message msg = Message.obtain();
        msg.what = MSG_CLOSE_SYSTEM_DIALOGS;
        msg.obj = reason;
        mHandler.sendMessage(msg);
    }
    
    final class ViewRootHandler extends Handler {
        private void handleMessageImpl(Message msg) {
            switch (msg.what) {
               case MSG_CLOSE_SYSTEM_DIALOGS: {
                   if (mView != null) {
                   	   //调用DecorView的onCloseSystemDialogs方法
                       mView.onCloseSystemDialogs((String) msg.obj);
                   }
               } break;
            }
       }
   }
   
 }

ViewRootImpl的内部类W的closeSystemDialogs方法继续调用ViewRootImpl的dispatchCloseSystemDialogs方法，该方法调用ViewRootHandler发送类型为MSG_CLOSE_SYSTEM_DIALOGS的消息，然后在ViewRootHandler的handleMessageImpl方法的MSG_CLOSE_SYSTEM_DIALOGS消息分支中，最终会调用DecorView的onCloseSystemDialogs方法。

10、DecorView的onCloseSystemDialogs方法最终会调用PhoneWindow的closeAllPanels方法。

public class DecorView extends FrameLayout implements RootViewSurfaceTaker, WindowCallbacks {
    
    private PhoneWindow mWindow;
    
    @Override
    public void onCloseSystemDialogs(String reason) {
        if (mFeatureId >= 0) {
            mWindow.closeAllPanels();
        }
    }
    
}

四、唤醒屏保。

1、PhoneWindowManager的startDockOrHome在调用sendCloseSystemWindows关闭系统当前存在的各种弹窗之后，会调用awakenDreams方法唤醒屏保。

public class PhoneWindowManager implements WindowManagerPolicy {

    static public final String SYSTEM_DIALOG_REASON_HOME_KEY = "homekey";
    ActivityTaskManagerInternal mActivityTaskManagerInternal;

    void startDockOrHome(int displayId, boolean fromHomeKey, boolean awakenFromDreams,
            String startReason) {
        try {
        	//先停止应用切换功能
            ActivityManager.getService().stopAppSwitches();
        } catch (RemoteException e) {}
        //关闭系统当前存在的各种弹窗
        sendCloseSystemWindows(SYSTEM_DIALOG_REASON_HOME_KEY);
       if (awakenFromDreams) {
            awakenDreams();//唤醒屏保
        }
		...代码暂时省略...
    }
}

2、PhoneWindowManager的awakenDreams方法如下所示。

public class PhoneWindowManager implements WindowManagerPolicy {
    //唤醒屏保
    private static void awakenDreams() {
        IDreamManager dreamManager = getDreamManager();
        if (dreamManager != null) {
            try {
                //调用屏保服务DreamManagerService的awaken方法唤醒屏保
                dreamManager.awaken();
            } catch (RemoteException e) {
                // fine, stay asleep then
            }
        }
    }

    static IDreamManager getDreamManager() {
        return IDreamManager.Stub.asInterface(
                ServiceManager.checkService(DreamService.DREAM_SERVICE));
    }
 }

3、IDreamManager是一个aidl。

frameworks/base/core/java/android/service/dreams/IDreamManager.aidl

interface IDreamManager {
    @UnsupportedAppUsage
    void awaken();
}

4、DreamManagerService的内部类BinderService实现了awaken的抽象方法。

public final class DreamManagerService extends SystemService {

    private final class BinderService extends IDreamManager.Stub {
	        @Override // Binder call
        public void awaken() {
            checkPermission(android.Manifest.permission.WRITE_DREAM_STATE);//检测应用是否有唤醒屏保的权限
            final long ident = Binder.clearCallingIdentity();
            try {
                requestAwakenInternal();//调用DreamManagerService的requestAwakenInternal方法
            } finally {
                Binder.restoreCallingIdentity(ident);
            }
        }
	}
	
    private void requestAwakenInternal() {
        // Treat an explicit request to awaken as user activity so that the
        // device doesn't immediately go to sleep if the timeout expired,
        // for example when being undocked.
        long time = SystemClock.uptimeMillis();
        mPowerManager.userActivity(time, false /*noChangeLights*/);
        stopDreamInternal(false /*immediate*/, "request awaken");
    }
}

BinderService的awaken方法显示检测权限，然后会调用DreamManagerService的requestAwakenInternal方法，关于requestAwakenInternal方法是如何唤醒屏保的，碍于文章篇幅，这里不做过多的展开。

五、创建首页意图对象。

1、PhoneWindowManager的startDockOrHome在调用awakenDreams方法唤醒屏保之后，会调用createHomeDockIntent创建首页意图对象。

public class PhoneWindowManager implements WindowManagerPolicy {

    static public final String SYSTEM_DIALOG_REASON_HOME_KEY = "homekey";
    ActivityTaskManagerInternal mActivityTaskManagerInternal;

    void startDockOrHome(int displayId, boolean fromHomeKey, boolean awakenFromDreams,
            String startReason) {
        try {
        	//先停止应用切换功能
            ActivityManager.getService().stopAppSwitches();
        } catch (RemoteException e) {}
        //关闭系统当前存在的各种弹窗
        sendCloseSystemWindows(SYSTEM_DIALOG_REASON_HOME_KEY);
       if (awakenFromDreams) {
            awakenDreams();//唤醒屏保
        }
        
        if (!mHasFeatureAuto && !isUserSetupComplete()) {
            Slog.i(TAG, "Not going home because user setup is in progress.");
            return;
        }
        //创建桌面意图对象
        Intent dock = createHomeDockIntent();
        if (dock != null) {
            //如果桌面意图对象不为空则打开该意图对象
            try {
                if (fromHomeKey) {
                    dock.putExtra(WindowManagerPolicy.EXTRA_FROM_HOME_KEY, fromHomeKey);
                }
                startActivityAsUser(dock, UserHandle.CURRENT);
                return;
            } catch (ActivityNotFoundException e) {
            }
        }
		...代码暂时省略...
    }
}

2、PhoneWindowManager的createHomeDockIntent方法如下所示。

public class PhoneWindowManager implements WindowManagerPolicy {

    Intent mHomeIntent;
    Intent mCarDockIntent;
    Intent mDeskDockIntent;
    Intent mVrHeadsetHomeIntent;
    
    @Override
    public void init(Context context, IWindowManager windowManager,
            WindowManagerFuncs windowManagerFuncs) {
 		...代码省略...
 		mHomeIntent =  new Intent(Intent.ACTION_MAIN, null);
        mHomeIntent.addCategory(Intent.CATEGORY_HOME);
        mHomeIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
        mEnableCarDockHomeCapture = context.getResources().getBoolean(
                com.android.internal.R.bool.config_enableCarDockHomeLaunch);
        mCarDockIntent =  new Intent(Intent.ACTION_MAIN, null);
        mCarDockIntent.addCategory(Intent.CATEGORY_CAR_DOCK);
        mCarDockIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
        mDeskDockIntent =  new Intent(Intent.ACTION_MAIN, null);
        mDeskDockIntent.addCategory(Intent.CATEGORY_DESK_DOCK);
        mDeskDockIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
        mVrHeadsetHomeIntent =  new Intent(Intent.ACTION_MAIN, null);
        mVrHeadsetHomeIntent.addCategory(Intent.CATEGORY_VR_HOME);
        mVrHeadsetHomeIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
        ...代码省略...
 	}
 	
 	//创建首页意图对象
    Intent createHomeDockIntent() {
        Intent intent = null;
        // What home does is based on the mode, not the dock state.  That
        // is, when in car mode you should be taken to car home regardless
        // of whether we are actually in a car dock.
        if (mUiMode == Configuration.UI_MODE_TYPE_CAR) {
            if (mEnableCarDockHomeCapture) {
                intent = mCarDockIntent;
            }
        } else if (mUiMode == Configuration.UI_MODE_TYPE_DESK) {
            if (ENABLE_DESK_DOCK_HOME_CAPTURE) {
                intent = mDeskDockIntent;
            }
        } else if (mUiMode == Configuration.UI_MODE_TYPE_WATCH) {
            final int dockMode = mDefaultDisplayPolicy.getDockMode();
            if (dockMode == Intent.EXTRA_DOCK_STATE_DESK
                    || dockMode == Intent.EXTRA_DOCK_STATE_HE_DESK
                    || dockMode == Intent.EXTRA_DOCK_STATE_LE_DESK) {
                // Always launch dock home from home when watch is docked, if it exists.
                intent = mDeskDockIntent;
            }
        } else if (mUiMode == Configuration.UI_MODE_TYPE_VR_HEADSET) {
            if (ENABLE_VR_HEADSET_HOME_CAPTURE) {
                intent = mVrHeadsetHomeIntent;
            }
        }

        if (intent == null) {
            return null;
        }

        ActivityInfo ai = null;
        //获取Intent对应的ResolveInfo信息
        ResolveInfo info = mPackageManager.resolveActivityAsUser(
                intent,
                PackageManager.MATCH_DEFAULT_ONLY | PackageManager.GET_META_DATA,
                mCurrentUserId);
        if (info != null) {
            ai = info.activityInfo;
        }
        if (ai != null
                && ai.metaData != null
                && ai.metaData.getBoolean(Intent.METADATA_DOCK_HOME)) {
            intent = new Intent(intent);
            intent.setClassName(ai.packageName, ai.name);
            return intent;
        }

        return null;
    }
}

在PhoneWindowManager的init方法中，会为各种类型的首页意图对象赋值，然后createHomeDockIntent方法会根据当前系统所属的模式来选择对应的首页意图对象进行返回，startDockOrHome方法会判断该对象是否为空，不为空则直接调用startActivityAsUser(dock, UserHandle.CURRENT)方法打开该对象并返回，如果为空最后会调用ActivityTaskManagerInternal的startHomeOnDisplay方法。

六、调用startHomeOnDisplay方法打开首页。

1、如果在第五步没有成功打开首页意图对象，PhoneWindowManager的startDockOrHome方法会继续调用ActivityTaskManagerInternal的startHomeOnDisplay方法打开首页。

public class PhoneWindowManager implements WindowManagerPolicy {

    static public final String SYSTEM_DIALOG_REASON_HOME_KEY = "homekey";
    ActivityTaskManagerInternal mActivityTaskManagerInternal;

    void startDockOrHome(int displayId, boolean fromHomeKey, boolean awakenFromDreams,
            String startReason) {
        try {
        	//先停止应用切换功能
            ActivityManager.getService().stopAppSwitches();
        } catch (RemoteException e) {}
        //关闭系统当前存在的各种弹窗
        sendCloseSystemWindows(SYSTEM_DIALOG_REASON_HOME_KEY);
       if (awakenFromDreams) {
            awakenDreams();//唤醒屏保
        }
        
        if (!mHasFeatureAuto && !isUserSetupComplete()) {
            Slog.i(TAG, "Not going home because user setup is in progress.");
            return;
        }
        //创建桌面意图对象
        Intent dock = createHomeDockIntent();
        if (dock != null) {
            //如果桌面意图对象不为空则打开该意图对象
            try {
                if (fromHomeKey) {
                    dock.putExtra(WindowManagerPolicy.EXTRA_FROM_HOME_KEY, fromHomeKey);
                }
                startActivityAsUser(dock, UserHandle.CURRENT);
                return;
            } catch (ActivityNotFoundException e) {
            }
        }
        //调用ATMS的startHomeOnDisplay方法打开首页
        mActivityTaskManagerInternal.startHomeOnDisplay(mCurrentUserId, startReason,
                displayId, true /* allowInstrumenting */, fromHomeKey);
    }
}

2、在第三步第5节，我们有讲过ActivityTaskManagerInternal是一个抽象类，ActivityTaskManagerService的内部类LocalService继承自这个抽象类并实现了抽象方法。

public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
	
    RootWindowContainer mRootWindowContainer;//窗口跟对象

    final class LocalService extends ActivityTaskManagerInternal {
        @Override
        public boolean startHomeOnDisplay(int userId, String reason, int displayId,
                boolean allowInstrumenting, boolean fromHomeKey) {
            synchronized (mGlobalLock) {
                return mRootWindowContainer.startHomeOnDisplay(userId, reason, displayId,
                        allowInstrumenting, fromHomeKey);
            }
        }
    }

}

ActivityTaskManagerService的内部类LocalService的startHomeOnDisplay方法会进一步调用RootWindowContainer的startHomeOnDisplay方法。

3、RootWindowContainer的startHomeOnDisplay方法如下所示。

frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java

class RootWindowContainer extends WindowContainer<DisplayContent>
        implements DisplayManager.DisplayListener {
    boolean startHomeOnDisplay(int userId, String reason, int displayId, boolean allowInstrumenting,
            boolean fromHomeKey) {
        // Fallback to top focused display or default display if the displayId is invalid.
        if (displayId == INVALID_DISPLAY) {
        	//如果当前设备id不合法，则回退到顶部焦点设备或者默认设备
            final Task rootTask = getTopDisplayFocusedRootTask();
            displayId = rootTask != null ? rootTask.getDisplayId() : DEFAULT_DISPLAY;
        }

        final DisplayContent display = getDisplayContent(displayId);
        return display.reduceOnAllTaskDisplayAreas((taskDisplayArea, result) ->
                        result | startHomeOnTaskDisplayArea(userId, reason, taskDisplayArea,
                                allowInstrumenting, fromHomeKey),
                false /* initValue */);
    }
 }

💡 技术无价，赞赏随心

写文不易，如果本文帮你避开了“八小时踩坑”，或者让你直呼“学到了！”
欢迎扫码赞赏，让我知道这篇内容值得！

Android 12系统源码_系统启动（二）Zygote进程
AfinalStone的专栏
03-26 1036
结合Android12系统源码简单梳理Zygote相关源码
Android 12系统源码_输入系统（三）输入事件的加工和分发
最新发布
AfinalStone的专栏
09-26 1242
通过Android12系统源码梳理输入事件的加工和分发流程
Android事件拦截（3）——系统拦截和应用拦截
Flying snow
03-06 4637
本文主要分析触摸事件和按键事件在不同阶段被拦截的流程，总结在不同阶段不同方法中返回值的含义。
android按键响应流程
04-26
详细的描述了 linux的按键响应机制 以及在framework层的处理机制。
Android源码解析（二十七）-->HOME事件流程
一片枫叶的专栏
05-23 1万+
上一篇文章中我们介绍了android系统的截屏事件，事件的处理逻辑不是在App中执行而是在PhoneWindowManager中执行，而本文我们现在主要讲解android系统中HOME按键的事件处理，和截屏事件类似，这里的HOME按键应该都是系统级别的按键事件监听，所以其处理事件的逻辑也应该和截屏事件处理流程类似，HOME按键的处理逻辑也是在PhoneWindowManager的dispatchU
Android系统默认Home应用程序（Launcher）的启动过程源代码分析
oraclestudy
09-16 479
在前面一篇文章中，我们分析了Android系统在启动时安装应用程序的过程，这些应用程序安装好之后，还需要有一个Home应用程序来负责把它们在桌面上展示出来，在Android系统中，这个默认的Home应用程序就是Launcher了，本文将详细分析Launcher应用程序的启动过程。 Android系统的Home应用程序Launcher是由ActivityManagerService启动...
Android 按键事件流程
dp__mcu的专栏
09-26 569
#号键 的处理流程 keyCode=18, scanCode=228 1.linux kernel阶段 scanCode=228 0001 00e4 00000000 14*16 224+4=228 内核驱动层发送 输入事件 228 /vendor/etc/remote.tab1 0x96 0x55 #TELECOM_VOICE 添加一个按键 0x96 代表扫描码 0x55 输入事件的值，也是上层的扫描码 2.input 服务 /vendor/usr/keylayout/Vend...
android长按home键流程
harhy的专栏
03-27 2万+
home键在KeyEvent中的键值为3.     public static final int KEYCODE_HOME            = 3;    当用户按下home键的时候(包括长按)，程序会进入到PhoneWindowManager.java类中的public boolean interceptKeyBeforeDispatching(WindowState win
Android 按键消息流程源码分析
05-08
从Linux内核驱动产生的按键事件开始，到Android框架层的处理，再到最终应用程序接收并响应按键消息，整个流程展示了Android系统的复杂性和精妙设计。了解这一流程对于深入理解Android系统的工作原理以及开发高质量的...
Android应用源码之按键的处理.zip
12-05
本资料包"Android应用源码之按键的处理.zip"显然聚焦于解析如何在Android应用程序中捕获并响应用户输入的按键操作。下面我们将深入探讨这个主题。 首先，Android系统为开发者提供了两种主要的按键事件处理方式：第...
android tv key事件,Android TV中按键事件和焦点处理总结
weixin_29005499的博客
05-27 1571
本文总结了Android TV开发中的按键事件和焦点处理，TV端的开发不同于手机开发，主要区别在于焦点的处理，常常会用到手机端很少用到的开发接口。了解这些不同的接口和区别，有助于很快的上手TV端的开发。文章目录1.KeyEvent事件keyEvent2.KeyEvent事件分发dispatchKeyEvent()3.焦点处理 Focus焦点放大处理4.adb input 常见命令5.总结1.Key...
【Android开源源码12】Android 水果忍者源码
04-20
【Android开源源码12】Android 水果忍者源码
安卓Android源码——按键的处理.zip
10-12
这份“安卓Android源码——按键的处理.zip”压缩包可能包含了关于Android系统如何管理和响应硬件按键以及软件模拟按键的源代码分析。让我们深入探讨一下这个主题。 首先，Android系统的按键处理主要分为两个层次：...
android - home键及launcher启动流程分析
热门推荐
andyhuabing的专栏
11-01 2万+
android - home键及launcher启动流程分析 launcher，也就是android的桌面应用程序，开机启动的第一个应用程序及按home键进入的都是这个程序。 如果需要修改启动流程或者制作一个新的launcher，都有必要了解一下这个流程。 第一部分：系统默认Home应用程序(launcher)启动流程 1、frameworks/base/ser
android 处理home键,android处理home键的方法
weixin_31085635的博客
05-28 1329
由于android4.0以上对于home键，不能屏蔽，所以只能监听home键做相应的处理：首先注册监听：registerReceiver(mHomeKeyEvent, new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS));监听的实现：private BroadcastReceiver mHomeKeyEvent = new BroadcastR...
继续分享12个Android亲测源码
baby226的专栏
01-21 538
继续分享12个亲测源码 本系列源码亲自测试 适用环境：Android 2.1 分享给给位初学者，当中有不错的效果值得学习收藏的哦~ 1.很炫的解谜游戏源代码分享 http://www.apkbus.com/android-93029-1-1.html 2.SurfaceView添加组件view不被组件覆盖 http://www.apkbus.com/android-92787-1
Android项目开发中如何处理Home键
tudusi
11-04 153
Android项目开发中经常需要处理Home键，home键在应用层是无法捕捉也是不应该捕捉的。每层都有每层具体的分工。 一般项目要求我们对Home键要做处理，而我们又无法在应用层捕捉到这个按键操作。 1. 如果你只是想屏蔽 home 键，让它无所作为，那么祝贺你，你是可以做到的。 常用方法： private boolean catchHomeKey = true; @Over...
home 解析
weixin_34088838的博客
03-12 235
引用：http://www.linuxidc.com/Linux/2012-01/51332.htm 当我们从Home点击ShortCut图标启动一个应用程序后，这个应用程序打开了很多个Activity，假设顺序为A,B,C，然后我们按Home键，再次从桌面用图标启动这个应用程序，我们会发现显示的是刚才的C,而不是A。这里我们普遍的想法是按Home键是让程序退到后台，然后让桌面显示出来。那么我们...
android-在代码中实现按下Home键的效果
mmdev
02-19 362
Android设备在按下Home键会自动切换回桌面，其实实现的方法很简单，由于Launcher捕获了Home键的按下action，我们直接发送个Intent给Launcher即可，代码如下： Intent intent= new Intent(Intent.ACTION_MAIN); intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); //...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值