Fluxo de Trabalho da Visualização 1

O fluxo de trabalho do View refere-se à medição, layout e desenho. Entre eles, a medida é usada para medir a largura e a altura do View. layout é usado para determinar a posição de View, e draw é usado para desenhar View.

Ver entrada do fluxo de trabalho

Anteriormente, falamos sobre a composição da Atividade. Depois vem a criação do DecorView e os recursos que ele carrega. Neste momento, o conteúdo do DecorView não pode ser exibido porque não foi carregado na janela. Em seguida, nos concentramos em aprender como o DecorView é carregado no Window.

1DecorView é carregado na janela

Quando o DrcorView é criado e carregado na Window, precisamos entender o processo de criação da Activity.

Quando chamamos o startActivity da Activity, finalmente chamamos o handleLaunchActivity do ActivityThread. Existe uma frase no código:

Activity a = performLaunchActivity(r,customIntent)

Aqui o método performLaunchActivity é chamado para criar a Activity, e o método onCreate da Activity é chamado neste método para concluir a criação do DecorView.

No próximo código, há também a chamada do método handleResumeActivity,

@Override
    public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
            boolean isForward, String reason) {
        // If we are getting ready to gc after going to the background, well
        // we are back active so skip it.
        unscheduleGcIdler();
        mSomeActivitiesChanged = true;

        // TODO Push resumeArgs into the activity for consideration
        // skip below steps for double-resume and r.mFinish = true case.
        if (!performResumeActivity(r, finalStateRequest, reason)) {
            return;
        }
        if (mActivitiesToBeDestroyed.containsKey(r.token)) {
            // Although the activity is resumed, it is going to be destroyed. So the following
            // UI operations are unnecessary and also prevents exception because its token may
            // be gone that window manager cannot recognize it. All necessary cleanup actions
            // performed below will be done while handling destruction.
            return;
        }

        final Activity a = r.activity;

        if (localLOGV) {
            Slog.v(TAG, "Resume " + r + " started activity: " + a.mStartedActivity
                    + ", hideForNow: " + r.hideForNow + ", finished: " + a.mFinished);
        }

        final int forwardBit = isForward
                ? WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;

        // If the window hasn't yet been added to the window manager,
        // and this guy didn't finish itself or start another activity,
        // then go ahead and add the window.
        boolean willBeVisible = !a.mStartedActivity;
        if (!willBeVisible) {
            willBeVisible = ActivityClient.getInstance().willActivityBeVisible(
                    a.getActivityToken());
        }
        if (r.window == null && !a.mFinished && willBeVisible) {
            r.window = r.activity.getWindow();
            View decor = r.window.getDecorView();
            decor.setVisibility(View.INVISIBLE);
            ViewManager wm = a.getWindowManager();
            WindowManager.LayoutParams l = r.window.getAttributes();
            a.mDecor = decor;
            l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
            l.softInputMode |= forwardBit;
            if (r.mPreserveWindow) {
                a.mWindowAdded = true;
                r.mPreserveWindow = false;
                // Normally the ViewRoot sets up callbacks with the Activity
                // in addView->ViewRootImpl#setView. If we are instead reusing
                // the decor view we have to notify the view root that the
                // callbacks may have changed.
                ViewRootImpl impl = decor.getViewRootImpl();
                if (impl != null) {
                    impl.notifyChildRebuilt();
                }
            }
            if (a.mVisibleFromClient) {
                if (!a.mWindowAdded) {
                    a.mWindowAdded = true;
                    wm.addView(decor, l);
                } else {
   
   

Neste método, performeResumeActivity será chamado, e em performResumeActivity, o método onResume de Activity será chamado.

Observe o seguinte código:

Ver decoração = r.window.getDecorView();

Aqui, DecorView é obtido e, em seguida, WindowManager é obtido. WindowManager é uma interface e herda a interface ViewManager. Chame o método wm.addView no final. A classe de implementação de WindowManager é WindowManagerImpl, portanto, o método addView de WindowManagerImpl é realmente chamado. Existe um código nele:

mGloal.addView(view,params,mDisplay,mParentWindow);

Pode-se ver que no método addView de WindowManagerImpl, o método addView de WindowManagerGlobal é chamado. Neste método, existe a seguinte frase:

root = new ViewRootImpl(view.getContext(),display);

Este código cria uma instância de ViewRootImpl e, em seguida, existe um código abaixo:

root.setView(view,wparams,panelParentView);

Aqui, chame o método setView de ViewRootImpl para passar DeccorView como um parâmetro. Isso carrega o DecorView na janela. Claro que nada será exibido na interface neste momento, pois o fluxo de trabalho da View ainda não foi executado, e a view precisa ser desenhada através de medida, layout e desenho.