TopResumedActivityChangeItem

最新推荐文章于 2024-07-15 17:55:43 发布

TigherGuo

最新推荐文章于 2024-07-15 17:55:43 发布

阅读量5.1k

点赞数

文章标签： android

本文链接：https://blog.csdn.net/jieliaoyuan8279/article/details/123712632

版权

TopResumedActivityChangeItem

当TopResumedActivity改变的时候就会送该消息

  prev.setState(PAUSING, "startPausingLocked");  
		 task.onActivityStateChanged(this, state, reason);
				 1 task.setResumedActivity(ActivityRecord r, String reason)
               mResumedActivity = r
				      
               mTaskSupervisor.updateTopResumedActivityIfNeeded();
						       1 TopResumedActivity变为null
										 prevTopActivity.scheduleTopResumedActivityChanged(false /* onTop */)
                     //发计时消息（只有丢失topResumedActivity才发计时消息
                     scheduleTopResumedStateLossTimeout(prevTopActivity);
                        mHandler.sendMessageDelayed(msg, TOP_RESUMED_STATE_LOSS_TIMEOUT);
						       2 TopResuemdActivit从null变为新的activityRecord
										prevTopActivity.scheduleTopResumedActivityChanged(true /* onTop */)
       
			    2 ActivityRecord经过上面的setResumedActivity后变为了TopResumedActivity，则
				    mAtmService.setResumedActivityUncheckLocked(record, reason);
			         r.mDisplayContent.setFocusedApp(r);
			              mFocusedApp = newFocus;
			              //通知InputDispatcher
							       getInputMonitor().setFocusedAppLw(newFocus);
			         
			        //焦点应用改变了，焦点窗口可能也会改变（因为焦点应用是栅栏-）----------------
			         mWindowManager.updateFocusedWindowLocked(UPDATE_FOCUS_NORMAL,
			                  true /*updateInputWindows*/);
                //打印wm_set_resume日志
              EventLogTags.writeWmSetResumedActivity( r == null ? -1 : r.mUserId,r == null ? "NULL" : r.shortComponentName,reason);

传输过程

ActivityRecord.scheduleTopResumedActivityChanged(boolean onTop)
  1 没有进程或者activityRecord还没有attach到进程，则返回
    if (!attachedToProcess()) {
         return false;
     
  2 如果有进程且attach到进程则：   
		mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), appToken,
                    TopResumedActivityChangeItem.obtain(onTop));
     接下来就是ClientTransaction的传输过程，不用说了

boolean attachedToProcess() {
        return hasProcess() && app.hasThread();
    }

执行

ActivityThread:handleTopResumedActivityChanged(r, mOnTop, "topResumedActivityChangeItem");
   reportTopResumedActivityChanged(r, onTop, "topStateChangedWhenResumed");
      r.lastReportedTopResumedState = onTop;
      r.activity.performTopResumedActivityChanged(onTop, reason);
           Activity:onTopResumedActivityChanged(isTopResumedActivity);
           1. 失去TopResumedActivity
               EventLogTags.writeWmOnTopResumedLostCalled(mIdent, getComponentName().getClassName(),
                    reason);
           2. 获得TopResumedActivity
               EventLogTags.writeWmOnTopResumedGainedCalled(mIdent, getComponentName().getClassName(),
                    reason);

/** 30064 wm_on_top_resumed_gained_called (Token|1|5),(Component Name|3),(Reason|3) */
  public static final int WM_ON_TOP_RESUMED_GAINED_CALLED = 30064;
/** 30065 wm_on_top_resumed_lost_called (Token|1|5),(Component Name|3),(Reason|3) */
  public static final int WM_ON_TOP_RESUMED_LOST_CALLED = 30065;

postExecute

public void postExecute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions)
   ActivityClient.getInstance().activityTopResumedStateLost();
        getActivityClientController().activityTopResumedStateLost();
          //System Server端
          mTaskSupervisor.handleTopResumedStateReleased(false /* timeout */);
             mHandler.removeMessages(TOP_RESUMED_STATE_LOSS_TIMEOUT_MSG);
             mTopResumedActivityWaitingForPrev = false;

To help support the multi-resume feature, there’s a new lifecycle callback, [onTopResumedActivityChanged()](https://developer.android.com/reference/android/app/Activity#onTopResumedActivityChanged(boolean))
.

postExecute

resume被pause时，onTo为false

mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), appToken,
                TopResumedActivityChangeItem.obtain(onTop));

@Override
    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
            PendingTransactionActions pendingActions) {
        Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "topResumedActivityChangeItem");
        client.handleTopResumedActivityChanged(r, mOnTop, "topResumedActivityChangeItem");
        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    }

    @Override
    public void postExecute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        if (mOnTop) {
            return;
        }

        // The loss of top resumed state can always be reported immediately in postExecute
        // because only three cases are possible:
        // 1. Activity is in RESUMED state now and it just handled the callback in #execute().
        // 2. Activity wasn't RESUMED yet, which means that it didn't receive the top state yet.
        // 3. Activity is PAUSED or in other lifecycle state after PAUSED. In this case top resumed
        // state loss was already called right before pausing.
        ActivityClient.getInstance().activityTopResumedStateLost();
    }

1.1 execute

public void execute(ClientTransactionHandler client, ActivityClientRecord r,
            PendingTransactionActions pendingActions) {
        Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "topResumedActivityChangeItem");
        client.handleTopResumedActivityChanged(r, mOnTop, "topResumedActivityChangeItem");
        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    }

handleTopResumedActivityChanged—>reportTopResumedActivityChanged—>performTopResumedActivityChanged

@Override
    public void handleTopResumedActivityChanged(ActivityClientRecord r, boolean onTop,
            String reason) {
        if (DEBUG_ORDER) {
            Slog.d(TAG, "Received position change to top: " + onTop + " for activity: " + r);
        }

        if (r.isTopResumedActivity == onTop) {
            if (!Build.IS_DEBUGGABLE) {
                Slog.w(TAG, "Activity top position already set to onTop=" + onTop);
                return;
            }
            // TODO(b/197484331): Remove this short-term workaround while fixing the binder failure.
            Slog.e(TAG, "Activity top position already set to onTop=" + onTop);
        }

        r.isTopResumedActivity = onTop;

        if (r.getLifecycleState() == ON_RESUME) {
            reportTopResumedActivityChanged(r, onTop, "topStateChangedWhenResumed");
        } else {
            if (DEBUG_ORDER) {
                Slog.d(TAG, "Won't deliver top position change in state=" + r.getLifecycleState());
            }
        }
    }

reportTopResumedActivityChanged:主要是打印日志

/**
     * Call {@link Activity#onTopResumedActivityChanged(boolean)} if its top resumed state changed
     * since the last report.
     */
    private void reportTopResumedActivityChanged(ActivityClientRecord r, boolean onTop,
            String reason) {
        if (r.lastReportedTopResumedState != onTop) {
           原来是top resuem，目标状态不是了，
            r.lastReportedTopResumedState = onTop;
            r.activity.performTopResumedActivityChanged(onTop, reason);
        }
    }

// This holds the value last sent to the activity. This is needed, because an update from
        // server may come at random time, but we always need to report changes between ON_RESUME
        // and ON_PAUSE to the app.
        boolean lastReportedTopResumedState;

final void performTopResumedActivityChanged(boolean isTopResumedActivity, String reason) {
        onTopResumedActivityChanged(isTopResumedActivity);

        if (isTopResumedActivity) {
            EventLogTags.writeWmOnTopResumedGainedCalled(mIdent, getComponentName().getClassName(),
                    reason);
        } else {
            EventLogTags.writeWmOnTopResumedLostCalled(mIdent, getComponentName().getClassName(),
                    reason);
        }
    }

/** 30064 wm_on_top_resumed_gained_called (Token|1|5),(Component Name|3),(Reason|3) */
  public static final int WM_ON_TOP_RESUMED_GAINED_CALLED = 30064;
/** 30065 wm_on_top_resumed_lost_called (Token|1|5),(Component Name|3),(Reason|3) */
  public static final int WM_ON_TOP_RESUMED_LOST_CALLED = 30065;

1.2 postExecute

@Override
    public void postExecute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        if (mOnTop) {
            return;
        }

        // The loss of top resumed state can always be reported immediately in postExecute
        // because only three cases are possible:
        // 1. Activity is in RESUMED state now and it just handled the callback in #execute().
        // 2. Activity wasn't RESUMED yet, which means that it didn't receive the top state yet.
        // 3. Activity is PAUSED or in other lifecycle state after PAUSED. In this case top resumed
        // state loss was already called right before pausing.
        ActivityClient.getInstance().activityTopResumedStateLost();
    }

public static ActivityClient getInstance() {
        return sInstance.get();
    }
private static final Singleton<ActivityClient> sInstance = new Singleton<ActivityClient>() {
        @Override
        protected ActivityClient create() {
            return new ActivityClient();
        }
    };

/**
     * Reports after {@link Activity#onTopResumedActivityChanged(boolean)} is called for losing the
     * top most position.
     */
    public void activityTopResumedStateLost() {
        try {
            getActivityClientController().activityTopResumedStateLost();
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

private static IActivityClientController getActivityClientController() {
        final IActivityClientController controller = INTERFACE_SINGLETON.mKnownInstance;
        return controller != null ? controller : INTERFACE_SINGLETON.get();
    }
private static final ActivityClientControllerSingleton INTERFACE_SINGLETON =
            new ActivityClientControllerSingleton();

private static class ActivityClientControllerSingleton
            extends Singleton<IActivityClientController> {
        /**
         * A quick look up to reduce potential extra binder transactions. E.g. getting activity
         * task manager from service manager and controller from activity task manager.
         */
        IActivityClientController mKnownInstance;

        @Override
        protected IActivityClientController create() {
            try {
                return ActivityTaskManager.getService().getActivityClientController();
            } catch (RemoteException e) {
                throw e.rethrowFromSystemServer();
            }
        }
    }

返回ATMS的成员mActivityClientController的Bp端

@Override
    public IActivityClientController getActivityClientController() {
        return mActivityClientController;
    }
ActivityClientController mActivityClientController;

其提供客户端调用以activityXXX通知systemserver，如客户端pause后，就调用activityPaused通知systemSever。

/**
 * Server side implementation for the client activity to interact with system.
 *
 * @see android.app.ActivityClient
 */
class ActivityClientController extends IActivityClientController.Stub {
  
    /** Wrapper around VoiceInteractionServiceManager. */
    private AssistUtils mAssistUtils;

    void onSystemReady() {
        mAssistUtils = new AssistUtils(mContext);
    }

  

    @Override
    public void activityIdle(IBinder token, Configuration config, boolean stopProfiling)
    }

    @Override
    public void activityResumed(IBinder token, boolean handleSplashScreenExit)

    @Override
    public void activityTopResumedStateLost() 

    @Override
    public void activityPaused(IBinder token) 

    @Override
    public void activityStopped(IBinder token, Bundle icicle, PersistableBundle persistentState,
            CharSequence description) 

    @Override
    public void activityDestroyed(IBinder token) 
    @Override
    public void activityRelaunched(IBinder token)

这里通知系统是调用activityTopResumedStateLost

@Override
    public void activityTopResumedStateLost() {
        final long origId = Binder.clearCallingIdentity();
        synchronized (mGlobalLock) {
            mTaskSupervisor.handleTopResumedStateReleased(false /* timeout */);
        }
        Binder.restoreCallingIdentity(origId);
    }

然后调用ActivityTaskSupervisor的对应方法

/**
     * Handle a loss of top resumed state by an activity - update internal state and inform next top
     * activity if needed.
     */
    void handleTopResumedStateReleased(boolean timeout) {
        ProtoLog.v(WM_DEBUG_STATES, "Top resumed state released %s",
                    (timeout ? "(due to timeout)" : "(transition complete)"));
        //移除消息，避免超时
        mHandler.removeMessages(TOP_RESUMED_STATE_LOSS_TIMEOUT_MSG);
        if (!mTopResumedActivityWaitingForPrev) {
            // Top resumed activity state loss already handled.
            return;
        }
//topResuemActivity在等待Pre，pre已经pause完成，因此这为false
        mTopResumedActivityWaitingForPrev = false;
        scheduleTopResumedActivityStateIfNeeded();
    }

private final ActivityTaskSupervisorHandler mHandler;

mHandler的looper为SystemServer主线程looper

scheduleTopResumedActivityStateIfNeeded为如果topResumedActivity改变了就发送一个TopResumedActivityChangeItem

```java
/** Schedule top resumed state change if previous top activity already reported back. */
    private void scheduleTopResumedActivityStateIfNeeded() {
        if (mTopResumedActivity != null && !mTopResumedActivityWaitingForPrev) {
//没有执行，因为mTopResumedActivity 为null
            mTopResumedActivity.scheduleTopResumedActivityChanged(true /* onTop */);
        }
    }


总结：TopResumedActivityChangeItem 主要是

TigherGuo

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫