/*
* 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;
import android.app.servertransaction.ClientTransaction;
import android.app.servertransaction.PendingTransactionActions;
import android.app.servertransaction.TransactionExecutor;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.res.CompatibilityInfo;
import android.content.res.Configuration;
import android.os.IBinder;
import android.util.MergedConfiguration;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.content.ReferrerIntent;
import java.util.List;
Defines operations that a ClientTransaction
or its items can perform on client. @hide
/**
* Defines operations that a {@link android.app.servertransaction.ClientTransaction} or its items
* can perform on client.
* @hide
*/
public abstract class ClientTransactionHandler {
// Schedule phase related logic and handlers.
Prepare and schedule transaction for execution. /** Prepare and schedule transaction for execution. */
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
Execute transaction immediately without scheduling it. This is used for local requests, so
it will also recycle the transaction.
/**
* Execute transaction immediately without scheduling it. This is used for local requests, so
* it will also recycle the transaction.
*/
@VisibleForTesting
public void executeTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
getTransactionExecutor().execute(transaction);
transaction.recycle();
}
Get the TransactionExecutor
that will be performing lifecycle transitions and callbacks for activities. /**
* Get the {@link TransactionExecutor} that will be performing lifecycle transitions and
* callbacks for activities.
*/
abstract TransactionExecutor getTransactionExecutor();
abstract void sendMessage(int what, Object obj);
// Prepare phase related logic and handlers. Methods that inform about about pending changes or
// do other internal bookkeeping.
Set pending config in case it will be updated by other transaction item. /** Set pending config in case it will be updated by other transaction item. */
public abstract void updatePendingConfiguration(Configuration config);
Set current process state. /** Set current process state. */
public abstract void updateProcessState(int processState, boolean fromIpc);
// Execute phase related logic and handlers. Methods here execute actual lifecycle transactions
// and deliver callbacks.
Destroy the activity. /** Destroy the activity. */
public abstract void handleDestroyActivity(IBinder token, boolean finishing, int configChanges,
boolean getNonConfigInstance, String reason);
Pause the activity. /** Pause the activity. */
public abstract void handlePauseActivity(IBinder token, boolean finished, boolean userLeaving,
int configChanges, PendingTransactionActions pendingActions, String reason);
Resume the activity.
Params: - token – Target activity token.
- finalStateRequest – Flag indicating if this call is handling final lifecycle state
request for a transaction.
- isForward – Flag indicating if next transition is forward.
- reason – Reason for performing this operation.
/**
* Resume the activity.
* @param token Target activity token.
* @param finalStateRequest Flag indicating if this call is handling final lifecycle state
* request for a transaction.
* @param isForward Flag indicating if next transition is forward.
* @param reason Reason for performing this operation.
*/
public abstract void handleResumeActivity(IBinder token, boolean finalStateRequest,
boolean isForward, String reason);
Stop the activity.
Params: - token – Target activity token.
- show – Flag indicating whether activity is still shown.
- configChanges – Activity configuration changes.
- pendingActions – Pending actions to be used on this or later stages of activity
transaction.
- finalStateRequest – Flag indicating if this call is handling final lifecycle state
request for a transaction.
- reason – Reason for performing this operation.
/**
* Stop the activity.
* @param token Target activity token.
* @param show Flag indicating whether activity is still shown.
* @param configChanges Activity configuration changes.
* @param pendingActions Pending actions to be used on this or later stages of activity
* transaction.
* @param finalStateRequest Flag indicating if this call is handling final lifecycle state
* request for a transaction.
* @param reason Reason for performing this operation.
*/
public abstract void handleStopActivity(IBinder token, boolean show, int configChanges,
PendingTransactionActions pendingActions, boolean finalStateRequest, String reason);
Report that activity was stopped to server. /** Report that activity was stopped to server. */
public abstract void reportStop(PendingTransactionActions pendingActions);
Restart the activity after it was stopped. /** Restart the activity after it was stopped. */
public abstract void performRestartActivity(IBinder token, boolean start);
Deliver activity (override) configuration change. /** Deliver activity (override) configuration change. */
public abstract void handleActivityConfigurationChanged(IBinder activityToken,
Configuration overrideConfig, int displayId);
Deliver result from another activity. /** Deliver result from another activity. */
public abstract void handleSendResult(IBinder token, List<ResultInfo> results, String reason);
Deliver multi-window mode change notification. /** Deliver multi-window mode change notification. */
public abstract void handleMultiWindowModeChanged(IBinder token, boolean isInMultiWindowMode,
Configuration overrideConfig);
Deliver new intent. /** Deliver new intent. */
public abstract void handleNewIntent(IBinder token, List<ReferrerIntent> intents,
boolean andPause);
Deliver picture-in-picture mode change notification. /** Deliver picture-in-picture mode change notification. */
public abstract void handlePictureInPictureModeChanged(IBinder token, boolean isInPipMode,
Configuration overrideConfig);
Update window visibility. /** Update window visibility. */
public abstract void handleWindowVisibility(IBinder token, boolean show);
Perform activity launch. /** Perform activity launch. */
public abstract Activity handleLaunchActivity(ActivityThread.ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent);
Perform activity start. /** Perform activity start. */
public abstract void handleStartActivity(ActivityThread.ActivityClientRecord r,
PendingTransactionActions pendingActions);
Get package info. /** Get package info. */
public abstract LoadedApk getPackageInfoNoCheck(ApplicationInfo ai,
CompatibilityInfo compatInfo);
Deliver app configuration change notification. /** Deliver app configuration change notification. */
public abstract void handleConfigurationChanged(Configuration config);
Get ActivityClientRecord
instance that corresponds to the provided token. /**
* Get {@link android.app.ActivityThread.ActivityClientRecord} instance that corresponds to the
* provided token.
*/
public abstract ActivityThread.ActivityClientRecord getActivityClient(IBinder token);
Prepare activity relaunch to update internal bookkeeping. This is used to track multiple
relaunch and config update requests.
Params: - token – Activity token.
- pendingResults – Activity results to be delivered.
- pendingNewIntents – New intent messages to be delivered.
- configChanges – Mask of configuration changes that have occurred.
- config – New configuration applied to the activity.
- preserveWindow – Whether the activity should try to reuse the window it created,
including the decor view after the relaunch.
Returns: An initialized instance of ActivityClientRecord
to use during relaunch, or null
if relaunch cancelled.
/**
* Prepare activity relaunch to update internal bookkeeping. This is used to track multiple
* relaunch and config update requests.
* @param token Activity token.
* @param pendingResults Activity results to be delivered.
* @param pendingNewIntents New intent messages to be delivered.
* @param configChanges Mask of configuration changes that have occurred.
* @param config New configuration applied to the activity.
* @param preserveWindow Whether the activity should try to reuse the window it created,
* including the decor view after the relaunch.
* @return An initialized instance of {@link ActivityThread.ActivityClientRecord} to use during
* relaunch, or {@code null} if relaunch cancelled.
*/
public abstract ActivityThread.ActivityClientRecord prepareRelaunchActivity(IBinder token,
List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
int configChanges, MergedConfiguration config, boolean preserveWindow);
Perform activity relaunch.
Params: - r – Activity client record prepared for relaunch.
- pendingActions – Pending actions to be used on later stages of activity transaction.
/**
* Perform activity relaunch.
* @param r Activity client record prepared for relaunch.
* @param pendingActions Pending actions to be used on later stages of activity transaction.
* */
public abstract void handleRelaunchActivity(ActivityThread.ActivityClientRecord r,
PendingTransactionActions pendingActions);
Report that relaunch request was handled.
Params: - token – Target activity token.
- pendingActions – Pending actions initialized on earlier stages of activity transaction.
Used to check if we should report relaunch to WM.
/**
* Report that relaunch request was handled.
* @param token Target activity token.
* @param pendingActions Pending actions initialized on earlier stages of activity transaction.
* Used to check if we should report relaunch to WM.
* */
public abstract void reportRelaunch(IBinder token, PendingTransactionActions pendingActions);
}