Activity.onWindowFocusChanged()調用流程

之前梳理了Activity的啓動時序圖，想着Activity.onWindowFocusChanged()的調用流程又是怎樣的？追了下源碼，梳理出來分享下。

首先看ActivityThread.handleResumeActivity()

public final class ActivityThread {

    final void handleResumeActivity(IBinder token, boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
        ...
        final Activity a = r.activity;
        ...
        View decor = r.window.getDecorView();
        ...
        ViewManager wm = a.getWindowManager();
        ...
        wm.addView(decor, l);
    }
}

ViewManager是一個接口，看Activity實現

public class Activity extends ContextThemeWrapper
        implements LayoutInflater.Factory2,
        Window.Callback, KeyEvent.Callback,
        OnCreateContextMenuListener, ComponentCallbacks2,
        Window.OnWindowDismissedCallback, WindowControllerCallback,
        AutofillManager.AutofillClient {

    private WindowManager mWindowManager;

    public WindowManager getWindowManager() {
        return mWindowManager;
    }

    private Window mWindow;

    final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, String id,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config, String referrer, IVoiceInteractor voiceInteractor,
            Window window, ActivityConfigCallback activityConfigCallback) {

        ...
        mWindow = new PhoneWindow(this, window, activityConfigCallback);
        ...
        // 打個點
        mWindow.setCallback(this);
        ...
        mWindowManager = mWindow.getWindowManager();
        ...
    }
}

WindowManager也是一個接口，繼承了ViewManager，初始化來源於Window.getWindowManager()

public abstract class Window {

    private WindowManager mWindowManager;

    public WindowManager getWindowManager() {
        return mWindowManager;
    }

    public void setWindowManager(WindowManager wm, IBinder appToken, String appName,
            boolean hardwareAccelerated) {
        mAppToken = appToken;
        mAppName = appName;
        mHardwareAccelerated = hardwareAccelerated
            || SystemProperties.getBoolean(PROPERTY_HARDWARE_UI, false);
        if (wm == null) {
            wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
        }
        mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this);
    }

    public void setCallback(Callback callback) {
        mCallback = callback;
    }

    public final Callback getCallback() {
        return mCallback;
    }
}

可以看到Window.mWindowManager賦值位置在setWindowManager()傳進來的，具體是實現類是WindowManagerImpl

那麼看WindowManagerImpl.addView()實現了什麼

public final class WindowManagerImpl implements WindowManager {

    private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();

    @Override
    public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
        applyDefaultToken(params);
        mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
    }
}

public final class WindowManagerGlobal {
    
    public void addView(View view, ViewGroup.LayoutParams params,
            Display display, Window parentWindow) {
        ...
        ViewRootImpl root;
        ...
        root = new ViewRootImpl(view.getContext(), display);
        ...
        try {
            root.setView(view, wparams, panelParentView);
        } catch (RuntimeException e) {
            ...
        }
    }

    public static IWindowSession getWindowSession() {
        synchronized (WindowManagerGlobal.class) {
            if (sWindowSession == null) {
                try {
                    InputMethodManager imm = InputMethodManager.getInstance();
                    IWindowManager windowManager = getWindowManagerService();
                    sWindowSession = windowManager.openSession(
                            new IWindowSessionCallback.Stub() {
                                @Override
                                public void onAnimatorScaleChanged(float scale) {
                                    ValueAnimator.setDurationScale(scale);
                                }
                            },
                            imm.getClient(), imm.getInputContext());
                } catch (RemoteException e) {
                    throw e.rethrowFromSystemServer();
                }
            }
            return sWindowSession;
        }
    }
}

到此，就是ViewRootImpl的事了

public final class ViewRootImpl {
    
    final IWindowSession mWindowSession;

    public ViewRootImpl(Context context, Display display) {
        mWindowSession = WindowManagerGlobal.getWindowSession();
    }
    
    public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
        res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                            getHostVisibility(), mDisplay.getDisplayId(),
                            mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                            mAttachInfo.mOutsets, mInputChannel);
    }
}

mWindowSession是通過WindowManagerGlobal.getWindowSession()賦值，源碼看上面，IWindowSession是通過IWindowManager.openSession()獲取，而IWindowManager實現類是WindowManagerService

public class WindowManagerService extends IWindowManager.Stub {
    @Override
    public IWindowSession openSession(IWindowSessionCallback callback, IInputMethodClient client,
            IInputContext inputContext) {
        if (client == null) throw new IllegalArgumentException("null client");
        if (inputContext == null) throw new IllegalArgumentException("null inputContext");
        Session session = new Session(this, callback, client, inputContext);
        return session;
    }

    public int addWindow(Session session, IWindow client, int seq,
            WindowManager.LayoutParams attrs, int viewVisibility, int displayId,
            Rect outContentInsets, Rect outStableInsets, Rect outOutsets,
            InputChannel outInputChannel) {
    
         ...
         focusChanged = updateFocusedWindowLocked(UPDATE_FOCUS_WILL_ASSIGN_LAYERS,
                        false /*updateInputWindows*/);
         ...
    }

    RootWindowContainer mRoot;
    final H mH = new H();
    
    boolean updateFocusedWindowLocked(int mode, boolean updateInputWindows) {
        WindowState newFocus = mRoot.computeFocusedWindow();
        ...
        mH.sendEmptyMessage(H.REPORT_FOCUS_CHANGE);
        ...
        mCurrentFocus = newFocus;
    } 
    

    final class H extends android.os.Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case REPORT_FOCUS_CHANGE: {
                    WindowState newFocus;
                    ...
                    newFocus = mCurrentFocus;
                    ...
                    newFocus.reportFocusChangedSerialized(true, mInTouchMode);
                    ...
                } break;
            }
        }
    }
}

IWindowSession實現類是Session，那麼看Session對addToDisplay()的實現

public class Session extends IWindowSession.Stub implements IBinder.DeathRecipient {
    final WindowManagerService mService;
    
    @Override
    public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
            int viewVisibility, int displayId, Rect outContentInsets, Rect outStableInsets,
            Rect outOutsets, InputChannel outInputChannel) {
        return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId,
                outContentInsets, outStableInsets, outOutsets, outInputChannel);
    }
}

又跳回了WindowManagerService.addWindow()，看上面源碼，跳進了WindowState了，往下跟

class WindowState {
    
    WindowState(WindowManagerService service, Session s, IWindow c, WindowToken token,
           WindowState parentWindow, int appOp, int seq, WindowManager.LayoutParams a,
           int viewVisibility, int ownerId, boolean ownerCanAddInternalSystemWindow) {
        mClient = c;
    }

    final IWindow mClient;

    void reportFocusChangedSerialized(boolean focused, boolean inTouchMode) {
        try {
            mClient.windowFocusChanged(focused, inTouchMode);
        } catch (RemoteException e) {
        }
    }
}

到此，起碼看到了相似方法名了，那IWindow實現類是ViewRootImpl內部實現類

static class W extends IWindow.Stub {
        private final WeakReference<ViewRootImpl> mViewAncestor;
        private final IWindowSession mWindowSession;

        W(ViewRootImpl viewAncestor) {
            mViewAncestor = new WeakReference<ViewRootImpl>(viewAncestor);
            mWindowSession = viewAncestor.mWindowSession;
        }

        @Override
        public void windowFocusChanged(boolean hasFocus, boolean inTouchMode) {
            final ViewRootImpl viewAncestor = mViewAncestor.get();
            if (viewAncestor != null) {
                viewAncestor.windowFocusChanged(hasFocus, inTouchMode);
            }
        }
}

又回到了ViewRootImpl

public class ViewRootImpl {
    
    final ViewRootHandler mHandler = new ViewRootHandler();
    
    public void windowFocusChanged(boolean hasFocus, boolean inTouchMode) {
        Message msg = Message.obtain();
        msg.what = MSG_WINDOW_FOCUS_CHANGED;
        msg.arg1 = hasFocus ? 1 : 0;
        msg.arg2 = inTouchMode ? 1 : 0;
        mHandler.sendMessage(msg);
    }
    
    View mView;

    public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
        synchronized (this) {
            if (mView == null) {
                mView = view;
                ...
            }
        }
    }

    final class ViewRootHandler extends Handler {
        
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                ...
                case MSG_WINDOW_FOCUS_CHANGED: {
                    ...
                    mView.dispatchWindowFocusChanged(hasWindowFocus);
                    ...
                } break;
                ...
            }
        }
    }
}

終於看到了曙光，那麼這個View從第一步知道就是DecorView

public class DecorView extends FrameLayout implements RootViewSurfaceTaker, WindowCallbacks {

    private PhoneWindow mWindow;

    DecorView(Context context, int featureId, PhoneWindow window,
            WindowManager.LayoutParams params) {
        ...
        setWindow(window);
        ...     
    }
    
    void setWindow(PhoneWindow phoneWindow) {
        mWindow = phoneWindow;
        ...
    }
    
    @Override
    public void onWindowFocusChanged(boolean hasWindowFocus) {
        super.onWindowFocusChanged(hasWindowFocus);
        ...
        final Window.Callback cb = mWindow.getCallback();
        if (cb != null && !mWindow.isDestroyed() && mFeatureId < 0) {
            cb.onWindowFocusChanged(hasWindowFocus);
        }
        ...
    }
}

DecorView是整個Activity最外父容器，看到DecorView.onWindowFocusChanged()有個Window.Callback回調onWindowFocusChanged()，發現Callback來自PhoneWindow，看上面Window源碼，Window提供了方法setCallback(Callback callback)和getCallback()；那setCallback(Callback callback)是什麼時候調用的，看上面Activity.attach()方法，發現mWindow.setCallback(this)，而Activity是實現了Window.Callback接口的。

到此，Activity.onWindowFocusChanged(boolean hasFocus)觸發流程結束。

對了，DecorView.setWindow(PhoneWindow phoneWindow)又是什麼時候調用的？

回到第一步ActivityThread.handleResumeActivity()，發現View decor = r.window.getDecorView()，也就是DecorView是在這個地方出來的，跟進去發現在PhoneWindow裏

public class PhoneWindow extends Window {

    @Override
    public final View getDecorView() {
        if (mDecor == null || mForceDecorInstall) {
            installDecor();
        }
        return mDecor;
    }

    private void installDecor() {
        ...
        if (mDecor == null) {
            mDecor = generateDecor(-1);
            mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
            mDecor.setIsRootNamespace(true);
            if (!mInvalidatePanelMenuPosted && mInvalidatePanelMenuFeatures != 0) {
                mDecor.postOnAnimation(mInvalidatePanelMenuRunnable);
            }
        } else {
            // 看這裏
            mDecor.setWindow(this);
        }
        ...
    }

    protected DecorView generateDecor(int featureId) {
        // System process doesn't have application context and in that case we need to directly use
        // the context we have. Otherwise we want the application context, so we don't cling to the
        // activity.
        Context context;
        if (mUseDecorContext) {
            Context applicationContext = getContext().getApplicationContext();
            if (applicationContext == null) {
                context = getContext();
            } else {
                context = new DecorContext(applicationContext, getContext().getResources());
                if (mTheme != -1) {
                    context.setTheme(mTheme);
                }
            }
        } else {
            context = getContext();
        }
        return new DecorView(context, featureId, this, getAttributes());
    }
}