1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
/*
* Copyright (C) 2022 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.LifecycleState;
import static android.app.servertransaction.ActivityLifecycleItem.ON_PAUSE;
import static android.app.servertransaction.ActivityLifecycleItem.ON_STOP;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.app.ActivityThread.ActivityClientRecord;
import android.app.ClientTransactionHandler;
import android.os.IBinder;
import android.os.Parcel;
/**
* Callback that allows to {@link TransactionExecutor#cycleToPath} to {@link ON_PAUSE} or
* {@link ON_STOP} in {@link TransactionExecutor#executeCallbacks} for activity "refresh" flow
* that goes through "paused -> resumed" or "stopped -> resumed" cycle.
*
* <p>This is used in combination with {@link com.android.server.wm.DisplayRotationCompatPolicy}
* for camera compatibility treatment that handles orientation mismatch between camera buffers and
* an app window. This allows to clear cached values in apps (e.g. display or camera rotation) that
* influence camera preview and can lead to sideways or stretching issues.
*
* @hide
*/
public class RefreshCallbackItem extends ActivityTransactionItem {
// Whether refresh should happen using the "stopped -> resumed" cycle or
// "paused -> resumed" cycle.
@LifecycleState
private int mPostExecutionState;
@Override
public void execute(@NonNull ClientTransactionHandler client,
@NonNull ActivityClientRecord r, PendingTransactionActions pendingActions) {}
@Override
public void postExecute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
final ActivityClientRecord r = getActivityClientRecord(client, token);
client.reportRefresh(r);
}
@Override
public int getPostExecutionState() {
return mPostExecutionState;
}
@Override
boolean shouldHaveDefinedPreExecutionState() {
return false;
}
// ObjectPoolItem implementation
@Override
public void recycle() {
ObjectPool.recycle(this);
}
/**
* Obtain an instance initialized with provided params.
* @param postExecutionState indicating whether refresh should happen using the
* "stopped -> resumed" cycle or "paused -> resumed" cycle.
*/
public static RefreshCallbackItem obtain(@LifecycleState int postExecutionState) {
if (postExecutionState != ON_STOP && postExecutionState != ON_PAUSE) {
throw new IllegalArgumentException(
"Only ON_STOP or ON_PAUSE are allowed as a post execution state for "
+ "RefreshCallbackItem but got " + postExecutionState);
}
RefreshCallbackItem instance =
ObjectPool.obtain(RefreshCallbackItem.class);
if (instance == null) {
instance = new RefreshCallbackItem();
}
instance.mPostExecutionState = postExecutionState;
return instance;
}
private RefreshCallbackItem() {}
// Parcelable implementation
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(mPostExecutionState);
}
@Override
public boolean equals(@Nullable Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
final RefreshCallbackItem other = (RefreshCallbackItem) o;
return mPostExecutionState == other.mPostExecutionState;
}
@Override
public int hashCode() {
int result = 17;
result = 31 * result + mPostExecutionState;
return result;
}
@Override
public String toString() {
return "RefreshCallbackItem{mPostExecutionState=" + mPostExecutionState + "}";
}
private RefreshCallbackItem(Parcel in) {
mPostExecutionState = in.readInt();
}
public static final @NonNull Creator<RefreshCallbackItem> CREATOR =
new Creator<RefreshCallbackItem>() {
public RefreshCallbackItem createFromParcel(Parcel in) {
return new RefreshCallbackItem(in);
}
public RefreshCallbackItem[] newArray(int size) {
return new RefreshCallbackItem[size];
}
};
}
|
