core/java/android/app/servertransaction/TransactionExecutor.java - platform/frameworks/base - Git at Google

 /*
  * Copyright 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.app.servertransaction;

 import static android.app.servertransaction.ActivityLifecycleItem.ON_CREATE;
 import static android.app.servertransaction.ActivityLifecycleItem.ON_DESTROY;
 import static android.app.servertransaction.ActivityLifecycleItem.ON_PAUSE;
 import static android.app.servertransaction.ActivityLifecycleItem.ON_RESTART;
 import static android.app.servertransaction.ActivityLifecycleItem.ON_RESUME;
 import static android.app.servertransaction.ActivityLifecycleItem.ON_START;
 import static android.app.servertransaction.ActivityLifecycleItem.ON_STOP;
 import static android.app.servertransaction.ActivityLifecycleItem.UNDEFINED;

 import android.app.ActivityThread.ActivityClientRecord;
 import android.app.ClientTransactionHandler;
 import android.os.IBinder;
 import android.util.IntArray;
 import android.util.Slog;

 import com.android.internal.annotations.VisibleForTesting;

 import java.util.List;

 /**
  * Class that manages transaction execution in the correct order.
  * @hide
  */
 public class TransactionExecutor {

     private static final boolean DEBUG_RESOLVER = false;
     private static final String TAG = "TransactionExecutor";

     private ClientTransactionHandler mTransactionHandler;
     private PendingTransactionActions mPendingActions = new PendingTransactionActions();

     // Temp holder for lifecycle path.
     // No direct transition between two states should take more than one complete cycle of 6 states.
     @ActivityLifecycleItem.LifecycleState
     private IntArray mLifecycleSequence = new IntArray(6);

     /** Initialize an instance with transaction handler, that will execute all requested actions. */
     public TransactionExecutor(ClientTransactionHandler clientTransactionHandler) {
         mTransactionHandler = clientTransactionHandler;
     }

     /**
      * Resolve transaction.
      * First all callbacks will be executed in the order they appear in the list. If a callback
      * requires a certain pre- or post-execution state, the client will be transitioned accordingly.
      * Then the client will cycle to the final lifecycle state if provided. Otherwise, it will
      * either remain in the initial state, or last state needed by a callback.
      */
     public void execute(ClientTransaction transaction) {
         final IBinder token = transaction.getActivityToken();
         log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);

         executeCallbacks(transaction);

         executeLifecycleState(transaction);
         mPendingActions.clear();
         log("End resolving transaction");
     }

     /** Cycle through all states requested by callbacks and execute them at proper times. */
     @VisibleForTesting
     public void executeCallbacks(ClientTransaction transaction) {
         final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
         if (callbacks == null) {
             // No callbacks to execute, return early.
             return;
         }
         log("Resolving callbacks");

         final IBinder token = transaction.getActivityToken();
         ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
         final int size = callbacks.size();
         for (int i = 0; i < size; ++i) {
             final ClientTransactionItem item = callbacks.get(i);
             log("Resolving callback: " + item);
             final int preExecutionState = item.getPreExecutionState();
             if (preExecutionState != UNDEFINED) {
                 cycleToPath(r, preExecutionState);
             }

             item.execute(mTransactionHandler, token, mPendingActions);
             item.postExecute(mTransactionHandler, token, mPendingActions);
             if (r == null) {
                 // Launch activity request will create an activity record.
                 r = mTransactionHandler.getActivityClient(token);
             }

             final int postExecutionState = item.getPostExecutionState();
             if (postExecutionState != UNDEFINED) {
                 cycleToPath(r, postExecutionState);
             }
         }
     }

     /** Transition to the final state if requested by the transaction. */
     private void executeLifecycleState(ClientTransaction transaction) {
         final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
         if (lifecycleItem == null) {
             // No lifecycle request, return early.
             return;
         }
         log("Resolving lifecycle state: " + lifecycleItem);

         final IBinder token = transaction.getActivityToken();
         final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);

         // Cycle to the state right before the final requested state.
         cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);

         // Execute the final transition with proper parameters.
         lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
         lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
     }

     /** Transition the client between states. */
     @VisibleForTesting
     public void cycleToPath(ActivityClientRecord r, int finish) {
         cycleToPath(r, finish, false /* excludeLastState */);
     }

     /**
      * Transition the client between states with an option not to perform the last hop in the
      * sequence. This is used when resolving lifecycle state request, when the last transition must
      * be performed with some specific parameters.
      */
     private void cycleToPath(ActivityClientRecord r, int finish,
             boolean excludeLastState) {
         final int start = r.getLifecycleState();
         log("Cycle from: " + start + " to: " + finish + " excludeLastState:" + excludeLastState);
         initLifecyclePath(start, finish, excludeLastState);
         performLifecycleSequence(r);
     }

     /** Transition the client through previously initialized state sequence. */
     private void performLifecycleSequence(ActivityClientRecord r) {
         final int size = mLifecycleSequence.size();
         for (int i = 0, state; i < size; i++) {
             state = mLifecycleSequence.get(i);
             log("Transitioning to state: " + state);
             switch (state) {
                 case ON_CREATE:
                     mTransactionHandler.handleLaunchActivity(r, mPendingActions);
                     break;
                 case ON_START:
                     mTransactionHandler.handleStartActivity(r, mPendingActions);
                     break;
                 case ON_RESUME:
                     mTransactionHandler.handleResumeActivity(r.token, false /* clearHide */,
                             r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
                     break;
                 case ON_PAUSE:
                     mTransactionHandler.handlePauseActivity(r.token, false /* finished */,
                             false /* userLeaving */, 0 /* configChanges */,
                             true /* dontReport */, mPendingActions);
                     break;
                 case ON_STOP:
                     mTransactionHandler.handleStopActivity(r.token, false /* show */,
                             0 /* configChanges */, mPendingActions);
                     break;
                 case ON_DESTROY:
                     mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */,
                             0 /* configChanges */, false /* getNonConfigInstance */);
                     break;
                 case ON_RESTART:
                     mTransactionHandler.performRestartActivity(r.token, false /* start */);
                     break;
                 default:
                     throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
             }
         }
     }

     /**
      * Calculate the path through main lifecycle states for an activity and fill
      * @link #mLifecycleSequence} with values starting with the state that follows the initial
      * state.
      */
     public void initLifecyclePath(int start, int finish, boolean excludeLastState) {
         mLifecycleSequence.clear();
         if (finish >= start) {
             // just go there
             for (int i = start + 1; i <= finish; i++) {
                 mLifecycleSequence.add(i);
             }
         } else { // finish < start, can't just cycle down
             if (start == ON_PAUSE && finish == ON_RESUME) {
                 // Special case when we can just directly go to resumed state.
                 mLifecycleSequence.add(ON_RESUME);
             } else if (start <= ON_STOP && finish >= ON_START) {
                 // Restart and go to required state.

                 // Go to stopped state first.
                 for (int i = start + 1; i <= ON_STOP; i++) {
                     mLifecycleSequence.add(i);
                 }
                 // Restart
                 mLifecycleSequence.add(ON_RESTART);
                 // Go to required state
                 for (int i = ON_START; i <= finish; i++) {
                     mLifecycleSequence.add(i);
                 }
             } else {
                 // Relaunch and go to required state

                 // Go to destroyed state first.
                 for (int i = start + 1; i <= ON_DESTROY; i++) {
                     mLifecycleSequence.add(i);
                 }
                 // Go to required state
                 for (int i = ON_CREATE; i <= finish; i++) {
                     mLifecycleSequence.add(i);
                 }
             }
         }

         // Remove last transition in case we want to perform it with some specific params.
         if (excludeLastState && mLifecycleSequence.size() != 0) {
             mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
         }
     }

     @VisibleForTesting
     public int[] getLifecycleSequence() {
         return mLifecycleSequence.toArray();
     }

     private static void log(String message) {
         if (DEBUG_RESOLVER) Slog.d(TAG, message);
     }
 }
	/*
	* Copyright 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.app.servertransaction;

	import static android.app.servertransaction.ActivityLifecycleItem.ON_CREATE;
	import static android.app.servertransaction.ActivityLifecycleItem.ON_DESTROY;
	import static android.app.servertransaction.ActivityLifecycleItem.ON_PAUSE;
	import static android.app.servertransaction.ActivityLifecycleItem.ON_RESTART;
	import static android.app.servertransaction.ActivityLifecycleItem.ON_RESUME;
	import static android.app.servertransaction.ActivityLifecycleItem.ON_START;
	import static android.app.servertransaction.ActivityLifecycleItem.ON_STOP;
	import static android.app.servertransaction.ActivityLifecycleItem.UNDEFINED;

	import android.app.ActivityThread.ActivityClientRecord;
	import android.app.ClientTransactionHandler;
	import android.os.IBinder;
	import android.util.IntArray;
	import android.util.Slog;

	import com.android.internal.annotations.VisibleForTesting;

	import java.util.List;

	/**
	* Class that manages transaction execution in the correct order.
	* @hide
	*/
	public class TransactionExecutor {

	private static final boolean DEBUG_RESOLVER = false;
	private static final String TAG = "TransactionExecutor";

	private ClientTransactionHandler mTransactionHandler;
	private PendingTransactionActions mPendingActions = new PendingTransactionActions();

	// Temp holder for lifecycle path.
	// No direct transition between two states should take more than one complete cycle of 6 states.
	@ActivityLifecycleItem.LifecycleState
	private IntArray mLifecycleSequence = new IntArray(6);

	/** Initialize an instance with transaction handler, that will execute all requested actions. */
	public TransactionExecutor(ClientTransactionHandler clientTransactionHandler) {
	mTransactionHandler = clientTransactionHandler;
	}

	/**
	* Resolve transaction.
	* First all callbacks will be executed in the order they appear in the list. If a callback
	* requires a certain pre- or post-execution state, the client will be transitioned accordingly.
	* Then the client will cycle to the final lifecycle state if provided. Otherwise, it will
	* either remain in the initial state, or last state needed by a callback.
	*/
	public void execute(ClientTransaction transaction) {
	final IBinder token = transaction.getActivityToken();
	log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);

	executeCallbacks(transaction);

	executeLifecycleState(transaction);
	mPendingActions.clear();
	log("End resolving transaction");
	}

	/** Cycle through all states requested by callbacks and execute them at proper times. */
	@VisibleForTesting
	public void executeCallbacks(ClientTransaction transaction) {
	final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
	if (callbacks == null) {
	// No callbacks to execute, return early.
	return;
	}
	log("Resolving callbacks");

	final IBinder token = transaction.getActivityToken();
	ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
	final int size = callbacks.size();
	for (int i = 0; i < size; ++i) {
	final ClientTransactionItem item = callbacks.get(i);
	log("Resolving callback: " + item);
	final int preExecutionState = item.getPreExecutionState();
	if (preExecutionState != UNDEFINED) {
	cycleToPath(r, preExecutionState);
	}

	item.execute(mTransactionHandler, token, mPendingActions);
	item.postExecute(mTransactionHandler, token, mPendingActions);
	if (r == null) {
	// Launch activity request will create an activity record.
	r = mTransactionHandler.getActivityClient(token);
	}

	final int postExecutionState = item.getPostExecutionState();
	if (postExecutionState != UNDEFINED) {
	cycleToPath(r, postExecutionState);
	}
	}
	}

	/** Transition to the final state if requested by the transaction. */
	private void executeLifecycleState(ClientTransaction transaction) {
	final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
	if (lifecycleItem == null) {
	// No lifecycle request, return early.
	return;
	}
	log("Resolving lifecycle state: " + lifecycleItem);

	final IBinder token = transaction.getActivityToken();
	final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);

	// Cycle to the state right before the final requested state.
	cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);

	// Execute the final transition with proper parameters.
	lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
	lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
	}

	/** Transition the client between states. */
	@VisibleForTesting
	public void cycleToPath(ActivityClientRecord r, int finish) {
	cycleToPath(r, finish, false /* excludeLastState */);
	}

	/**
	* Transition the client between states with an option not to perform the last hop in the
	* sequence. This is used when resolving lifecycle state request, when the last transition must
	* be performed with some specific parameters.
	*/
	private void cycleToPath(ActivityClientRecord r, int finish,
	boolean excludeLastState) {
	final int start = r.getLifecycleState();
	log("Cycle from: " + start + " to: " + finish + " excludeLastState:" + excludeLastState);
	initLifecyclePath(start, finish, excludeLastState);
	performLifecycleSequence(r);
	}

	/** Transition the client through previously initialized state sequence. */
	private void performLifecycleSequence(ActivityClientRecord r) {
	final int size = mLifecycleSequence.size();
	for (int i = 0, state; i < size; i++) {
	state = mLifecycleSequence.get(i);
	log("Transitioning to state: " + state);
	switch (state) {
	case ON_CREATE:
	mTransactionHandler.handleLaunchActivity(r, mPendingActions);
	break;
	case ON_START:
	mTransactionHandler.handleStartActivity(r, mPendingActions);
	break;
	case ON_RESUME:
	mTransactionHandler.handleResumeActivity(r.token, false /* clearHide */,
	r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
	break;
	case ON_PAUSE:
	mTransactionHandler.handlePauseActivity(r.token, false /* finished */,
	false /* userLeaving /, 0 / configChanges */,
	true /* dontReport */, mPendingActions);
	break;
	case ON_STOP:
	mTransactionHandler.handleStopActivity(r.token, false /* show */,
	0 /* configChanges */, mPendingActions);
	break;
	case ON_DESTROY:
	mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */,
	0 /* configChanges /, false / getNonConfigInstance */);
	break;
	case ON_RESTART:
	mTransactionHandler.performRestartActivity(r.token, false /* start */);
	break;
	default:
	throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
	}
	}
	}

	/**
	* Calculate the path through main lifecycle states for an activity and fill
	* @link #mLifecycleSequence} with values starting with the state that follows the initial
	* state.
	*/
	public void initLifecyclePath(int start, int finish, boolean excludeLastState) {
	mLifecycleSequence.clear();
	if (finish >= start) {
	// just go there
	for (int i = start + 1; i <= finish; i++) {
	mLifecycleSequence.add(i);
	}
	} else { // finish < start, can't just cycle down
	if (start == ON_PAUSE && finish == ON_RESUME) {
	// Special case when we can just directly go to resumed state.
	mLifecycleSequence.add(ON_RESUME);
	} else if (start <= ON_STOP && finish >= ON_START) {
	// Restart and go to required state.

	// Go to stopped state first.
	for (int i = start + 1; i <= ON_STOP; i++) {
	mLifecycleSequence.add(i);
	}
	// Restart
	mLifecycleSequence.add(ON_RESTART);
	// Go to required state
	for (int i = ON_START; i <= finish; i++) {
	mLifecycleSequence.add(i);
	}
	} else {
	// Relaunch and go to required state

	// Go to destroyed state first.
	for (int i = start + 1; i <= ON_DESTROY; i++) {
	mLifecycleSequence.add(i);
	}
	// Go to required state
	for (int i = ON_CREATE; i <= finish; i++) {
	mLifecycleSequence.add(i);
	}
	}
	}

	// Remove last transition in case we want to perform it with some specific params.
	if (excludeLastState && mLifecycleSequence.size() != 0) {
	mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
	}
	}

	@VisibleForTesting
	public int[] getLifecycleSequence() {
	return mLifecycleSequence.toArray();
	}

	private static void log(String message) {
	if (DEBUG_RESOLVER) Slog.d(TAG, message);
	}
	}