ClientTransactionHandler.java revision d9e2acba96ed59c40de15b37e813e1369d9e5169 
1/*
2 * Copyright 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16package android.app;
17
18import android.app.servertransaction.ClientTransaction;
19import android.app.servertransaction.PendingTransactionActions;
20import android.app.servertransaction.TransactionExecutor;
21import android.content.pm.ApplicationInfo;
22import android.content.res.CompatibilityInfo;
23import android.content.res.Configuration;
24import android.os.IBinder;
25import android.util.MergedConfiguration;
26
27import com.android.internal.annotations.VisibleForTesting;
28import com.android.internal.content.ReferrerIntent;
29
30import java.io.PrintWriter;
31import java.util.List;
32
33/**
34 * Defines operations that a {@link android.app.servertransaction.ClientTransaction} or its items
35 * can perform on client.
36 * @hide
37 */
38public abstract class ClientTransactionHandler {
39
40    // Schedule phase related logic and handlers.
41
42    /** Prepare and schedule transaction for execution. */
43    void scheduleTransaction(ClientTransaction transaction) {
44        transaction.preExecute(this);
45        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
46    }
47
48    /**
49     * Execute transaction immediately without scheduling it. This is used for local requests, so
50     * it will also recycle the transaction.
51     */
52    @VisibleForTesting
53    public void executeTransaction(ClientTransaction transaction) {
54        transaction.preExecute(this);
55        getTransactionExecutor().execute(transaction);
56        transaction.recycle();
57    }
58
59    /**
60     * Get the {@link TransactionExecutor} that will be performing lifecycle transitions and
61     * callbacks for activities.
62     */
63    abstract TransactionExecutor getTransactionExecutor();
64
65    abstract void sendMessage(int what, Object obj);
66
67
68    // Prepare phase related logic and handlers. Methods that inform about about pending changes or
69    // do other internal bookkeeping.
70
71    /** Set pending config in case it will be updated by other transaction item. */
72    public abstract void updatePendingConfiguration(Configuration config);
73
74    /** Set current process state. */
75    public abstract void updateProcessState(int processState, boolean fromIpc);
76
77
78    // Execute phase related logic and handlers. Methods here execute actual lifecycle transactions
79    // and deliver callbacks.
80
81    /** Destroy the activity. */
82    public abstract void handleDestroyActivity(IBinder token, boolean finishing, int configChanges,
83            boolean getNonConfigInstance, String reason);
84
85    /** Pause the activity. */
86    public abstract void handlePauseActivity(IBinder token, boolean finished, boolean userLeaving,
87            int configChanges, PendingTransactionActions pendingActions, String reason);
88
89    /**
90     * Resume the activity.
91     * @param token Target activity token.
92     * @param finalStateRequest Flag indicating if this call is handling final lifecycle state
93     *                          request for a transaction.
94     * @param isForward Flag indicating if next transition is forward.
95     * @param reason Reason for performing this operation.
96     */
97    public abstract void handleResumeActivity(IBinder token, boolean finalStateRequest,
98            boolean isForward, String reason);
99
100    /**
101     * Stop the activity.
102     * @param token Target activity token.
103     * @param show Flag indicating whether activity is still shown.
104     * @param configChanges Activity configuration changes.
105     * @param pendingActions Pending actions to be used on this or later stages of activity
106     *                       transaction.
107     * @param finalStateRequest Flag indicating if this call is handling final lifecycle state
108     *                          request for a transaction.
109     * @param reason Reason for performing this operation.
110     */
111    public abstract void handleStopActivity(IBinder token, boolean show, int configChanges,
112            PendingTransactionActions pendingActions, boolean finalStateRequest, String reason);
113
114    /** Report that activity was stopped to server. */
115    public abstract void reportStop(PendingTransactionActions pendingActions);
116
117    /** Restart the activity after it was stopped. */
118    public abstract void performRestartActivity(IBinder token, boolean start);
119
120    /** Deliver activity (override) configuration change. */
121    public abstract void handleActivityConfigurationChanged(IBinder activityToken,
122            Configuration overrideConfig, int displayId);
123
124    /** Deliver result from another activity. */
125    public abstract void handleSendResult(IBinder token, List<ResultInfo> results);
126
127    /** Deliver multi-window mode change notification. */
128    public abstract void handleMultiWindowModeChanged(IBinder token, boolean isInMultiWindowMode,
129            Configuration overrideConfig);
130
131    /** Deliver new intent. */
132    public abstract void handleNewIntent(IBinder token, List<ReferrerIntent> intents,
133            boolean andPause);
134
135    /** Deliver picture-in-picture mode change notification. */
136    public abstract void handlePictureInPictureModeChanged(IBinder token, boolean isInPipMode,
137            Configuration overrideConfig);
138
139    /** Update window visibility. */
140    public abstract void handleWindowVisibility(IBinder token, boolean show);
141
142    /** Perform activity launch. */
143    public abstract Activity handleLaunchActivity(ActivityThread.ActivityClientRecord r,
144            PendingTransactionActions pendingActions);
145
146    /** Perform activity start. */
147    public abstract void handleStartActivity(ActivityThread.ActivityClientRecord r,
148            PendingTransactionActions pendingActions);
149
150    /** Get package info. */
151    public abstract LoadedApk getPackageInfoNoCheck(ApplicationInfo ai,
152            CompatibilityInfo compatInfo);
153
154    /** Deliver app configuration change notification. */
155    public abstract void handleConfigurationChanged(Configuration config);
156
157    /**
158     * Get {@link android.app.ActivityThread.ActivityClientRecord} instance that corresponds to the
159     * provided token.
160     */
161    public abstract ActivityThread.ActivityClientRecord getActivityClient(IBinder token);
162
163    /**
164     * Prepare activity relaunch to update internal bookkeeping. This is used to track multiple
165     * relaunch and config update requests.
166     * @param token Activity token.
167     * @param pendingResults Activity results to be delivered.
168     * @param pendingNewIntents New intent messages to be delivered.
169     * @param configChanges Mask of configuration changes that have occurred.
170     * @param config New configuration applied to the activity.
171     * @param preserveWindow Whether the activity should try to reuse the window it created,
172     *                        including the decor view after the relaunch.
173     * @return An initialized instance of {@link ActivityThread.ActivityClientRecord} to use during
174     *         relaunch, or {@code null} if relaunch cancelled.
175     */
176    public abstract ActivityThread.ActivityClientRecord prepareRelaunchActivity(IBinder token,
177            List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
178            int configChanges, MergedConfiguration config, boolean preserveWindow);
179
180    /**
181     * Perform activity relaunch.
182     * @param r Activity client record prepared for relaunch.
183     * @param pendingActions Pending actions to be used on later stages of activity transaction.
184     * */
185    public abstract void handleRelaunchActivity(ActivityThread.ActivityClientRecord r,
186            PendingTransactionActions pendingActions);
187
188    /**
189     * Report that relaunch request was handled.
190     * @param token Target activity token.
191     * @param pendingActions Pending actions initialized on earlier stages of activity transaction.
192     *                       Used to check if we should report relaunch to WM.
193     * */
194    public abstract void reportRelaunch(IBinder token, PendingTransactionActions pendingActions);
195
196    /**
197     * Debugging output.
198     * @param pw {@link PrintWriter} to write logs to.
199     * @param prefix Prefix to prepend to output.
200     */
201    public abstract void dump(PrintWriter pw, String prefix);
202}
203