Activity类中mDecor变量何时被赋值的？

最新推荐文章于 2022-11-23 23:01:34 发布

A-Liang

最新推荐文章于 2022-11-23 23:01:34 发布

阅读量1.2k

点赞数

分类专栏： Android 文章标签： android 绘制 mDecor DecorView

本文链接：https://blog.csdn.net/yuerliang/article/details/78668995

版权

Android 专栏收录该内容

255 篇文章 1 订阅

订阅专栏

这是Android绘制原理的相关知识点。文章《DecorView如何添加到Fragmentwork层的》中提到有一个方法makeVisible()用用到了mDecor，但是并没有提该变量何时被赋值的，今天我们就来说说变量mDecor赋值时机。

Activity类中的变量nDecor定义。

//androidx.app                                        
public class Activity {

	View mDecor = null;
	
}

何时被赋值的呢？

快捷键查找被调用的地方，如下图所示。

并么有查找到被赋值的调用方法。那么我们就看看ActivityThread类中有没有赋值的地方。

ActivityThread类handleResumeActivity()方法对mDecor进行的赋值。我们继续一层一层看，该方法如何被调用的。


public final class ActivityThread extends ClientTransactionHandler {


    //该方法中对Activity类中变量mDecor进行了赋值，该方法是被类TransactionExecutor调用
    @Override
    public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
            String reason) {
		
		final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);

    	final Activity a = r.activity;

    	View decor = r.window.getDecorView();
        //看这里，看这里，看这里，在这里对Activity中mDecor变量赋值的
    	a.mDecor = decor;

    }
   
    
}


//TransactionExecutor，通过该类中的一连串方法调用，最终调用以上handleResumeActivity()
public class TransactionExecutor {
    
    //执行生命周期序列方法
    private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
            ClientTransaction transaction) {
        //第一次调用
        mTransactionHandler.handleResumeActivity(r.token, false,
                            r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
    }
    
    //循环到路径方法
    private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
            ClientTransaction transaction) {
         //第二次调用
        performLifecycleSequence(r, path, transaction);
    }
    
    //执行生命周期状态方法
    private void executeLifecycleState(ClientTransaction transaction) {
        //第三次调用
        cycleToPath(r, lifecycleItem.getTargetState(), true , transaction);
    
    }
    
    //执行方法
    public void execute(ClientTransaction transaction) {
        //第四次调用
        executeLifecycleState(transaction);
    }
    
    
    
}


//通过向主线程Handler发送消息调用上面的execute()方法
public final class ActivityThread extends ClientTransactionHandler {
 //主线程的Handler
    H mH = new H();
    
    //通过Handler的handMessage()
    private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
        mH.sendMessage(msg);
    }

    //内部类H
    class H extends Handler {
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case EXECUTE_TRANSACTION:
                    final ClientTransaction transaction = (ClientTransaction) msg.obj;
                    //从这里开始一步步的调用，最终回调handleResumeActivity()方法
                    mTransactionExecutor.execute(transaction);
                }
                break;
            }
        }
    }

    private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
    
}

//ActivityThread
public final class ActivityThread extends ClientTransactionHandler {
    
    //通过该方法向主线程Handler发送消息，最终调用execute()方法
    void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
    }

}

//ActivityThread::ApplicationThread内部类
private class ApplicationThread extends IApplicationThread.Stub {
        //调度事务方法
        @Override
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            ActivityThread.this.scheduleTransaction(transaction);
        }
}

//ClientTransaction
public class ClientTransaction implements Parcelable, ObjectPoolItem {

    private IApplicationThread mClient;

    //调度方法
    public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);
    }
}

//com.android.server.wm
//ClientLifecycleManager
class ClientLifecycleManager {

    void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        transaction.schedule();

    }

}


//com.android.server.wm
//ActivityStackSupervisor，
public class ActivityStackSupervisor implements RecentTasks.Callbacks {

    final ActivityTaskManagerService mService;
    
    boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
            boolean andResume, boolean checkConfig) throws RemoteException {
        mService.getLifecycleManager().scheduleTransaction(clientTransaction);
    }

}

//com.android.server.wm
//ActivityTaskManagerService
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
    
    private final ClientLifecycleManager mLifecycleManager;

    ClientLifecycleManager getLifecycleManager() {
        return mLifecycleManager;
    }


}

第一步：TransactionExecutor类中方法调用的，一步步的追踪到execute()方法。继续查看execute()由谁来调用的。

public class TransactionExecutor {
    
    //执行生命周期序列方法
    private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
            ClientTransaction transaction) {
        mTransactionHandler.handleResumeActivity(r.token, false,
                            r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
    }
    
    //循环到路径方法
    private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
            ClientTransaction transaction) {
        performLifecycleSequence(r, path, transaction);
    }
    
    //执行生命周期状态方法
    private void executeLifecycleState(ClientTransaction transaction) {
        cycleToPath(r, lifecycleItem.getTargetState(), true , transaction);
    
    }
    
    //执行方法
    public void execute(ClientTransaction transaction) {

        executeLifecycleState(transaction);
    }
    
    
    
}

//ActivityThread::ApplicationThread
private class ApplicationThread extends IApplicationThread.Stub {
        //调度事务方法
        @Override
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            ActivityThread.this.scheduleTransaction(transaction);
        }
}

//ClientTransaction
public class ClientTransaction implements Parcelable, ObjectPoolItem {
    //调度方法
    public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);
    }
}

//ClientLifecycleManager
class ClientLifecycleManager {
    //调度事务
    void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        transaction.schedule();

    }

}

第二步：ActivityThread类的内部类H调用的。继续追踪查看由谁来发送消息到主线的Handler中。


public final class ActivityThread extends ClientTransactionHandler {

    //主线程的Handler
    H mH = new H();
    
    //通过Handler的handMessage()
    private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
        mH.sendMessage(msg);
    }

    //内部类H
    class H extends Handler {
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case EXECUTE_TRANSACTION:
                    final ClientTransaction transaction = (ClientTransaction) msg.obj;
                    //
                    mTransactionExecutor.execute(transaction);
                }
                break;
            }
        }
    }
    private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);

}

第三步：ActivitThread类的内部类ApplicationThread方法scheduleTransaction()调用了sendMessage()方法。继续追踪scheduleTransaction()方法由谁来调用的。

private class ApplicationThread extends IApplicationThread.Stub {
        //调度事务方法
        @Override
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            ActivityThread.this.scheduleTransaction(transaction);
        }
}

第四步：ClientThrasaction类的schedule() 调用了scheduleTransaction()方法。

public class ClientTransaction implements Parcelable, ObjectPoolItem {
    //调度方法
    public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);
    }
}

第五步：ClientLifecycleManager类的scheduleTransaction()调用。继续追踪scheduleTransaction()方法由谁调用。

class ClientLifecycleManager {
    //调度事务
    void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        transaction.schedule();

    }

}

第六步：ActivityStackSupervisor 类的realStartActivityLocked()方法调用。

//com.android.server.wm
//ActivityStackSupervisor
public class ActivityStackSupervisor implements RecentTasks.Callbacks {

    final ActivityTaskManagerService mService;
    
    boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
            boolean andResume, boolean checkConfig) throws RemoteException {
        mService.getLifecycleManager().scheduleTransaction(clientTransaction);
    }

}

//com.android.server.wm
//ActivityTaskManagerService
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
    
    private final ClientLifecycleManager mLifecycleManager;

    ClientLifecycleManager getLifecycleManager() {
        return mLifecycleManager;
    }


}

//com.android.server.wm
//ClientLifecycleManager
class ClientLifecycleManager {

    void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        transaction.schedule();

    }

}