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
146
147
148
149
150
151
|
/*
* Copyright (C) 2025 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.window;
import android.annotation.IntDef;
import android.annotation.NonNull;
import android.app.ActivityTaskManager;
import android.os.RemoteException;
import android.util.Singleton;
import android.util.Slog;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/**
* Retrieve or request app snapshots in system.
*
* @hide
*/
public class TaskSnapshotManager {
private static final String TAG = "TaskSnapshotManager";
/**
* Set or retrieve the high resolution snapshot.
*/
public static final int RESOLUTION_HIGH = 1;
/**
* Set or retrieve the low resolution snapshot.
*/
public static final int RESOLUTION_LOW = 2;
/**
* Retrieve in any resolution.
*/
public static final int RESOLUTION_ANY = 3;
/**
* Flags for which kind of resolution snapshot.
*
* @hide
*/
@IntDef(prefix = { "RESOLUTION_" }, value = {
RESOLUTION_HIGH,
RESOLUTION_LOW,
RESOLUTION_ANY
})
@Retention(RetentionPolicy.SOURCE)
public @interface Resolution {}
private static final TaskSnapshotManager sInstance = new TaskSnapshotManager();
private TaskSnapshotManager() { }
public static TaskSnapshotManager getInstance() {
return sInstance;
}
/**
* Fetches the snapshot for the task with the given id.
*
* @param taskId the id of the task to retrieve for
* @param retrieveResolution the resolution we want to load.
*
* @return a graphic buffer representing a screenshot of a task, or {@code null} if no
* screenshot can be found.
*/
public TaskSnapshot getTaskSnapshot(int taskId, @Resolution int retrieveResolution)
throws RemoteException {
final TaskSnapshot t;
try {
t = ISnapshotManagerSingleton.get().getTaskSnapshot(taskId, retrieveResolution);
} catch (RemoteException r) {
Slog.e(TAG, "getTaskSnapshot fail: " + r);
throw r;
}
return t;
}
/**
* Requests for a new snapshot to be taken for the task with the given id, storing it in the
* task snapshot cache only if requested.
*
* @param taskId the id of the task to take a snapshot of
* @param updateCache Whether to store the new snapshot in the system's task snapshot cache.
* If it is true, the snapshot can be either real content or app-theme mode
* depending on the attributes of app. Otherwise, the snapshot will be taken
* with real content.
* @return a graphic buffer representing a screenshot of a task, or {@code null} if no
* corresponding task can be found.
*/
public TaskSnapshot takeTaskSnapshot(int taskId, boolean updateCache) throws RemoteException {
final TaskSnapshot t;
try {
t = ISnapshotManagerSingleton.get().takeTaskSnapshot(taskId, updateCache);
} catch (RemoteException r) {
Slog.e(TAG, "getTaskSnapshot fail: " + r);
throw r;
}
return t;
}
/**
* @return Whether the resolution of snapshot align with requested resolution.
*/
public static boolean isResolutionMatch(@NonNull TaskSnapshot snapshot,
@Resolution int retrieveResolution) {
if (retrieveResolution == RESOLUTION_ANY) {
return true;
}
final boolean isLowRes = snapshot.isLowResolution();
if (isLowRes) {
return retrieveResolution == TaskSnapshotManager.RESOLUTION_LOW;
}
return true;
}
/**
* @return Util method, convert the isLowResolution either FLAG_LOW_RES or FLAG_HIGH_RES.
*/
public static int convertRetrieveFlag(boolean isLowResolution) {
return isLowResolution ? TaskSnapshotManager.RESOLUTION_LOW
: TaskSnapshotManager.RESOLUTION_HIGH;
}
private static final Singleton<ITaskSnapshotManager> ISnapshotManagerSingleton =
new Singleton<ITaskSnapshotManager>() {
@Override
protected ITaskSnapshotManager create() {
try {
return ActivityTaskManager.getService().getTaskSnapshotManager();
} catch (RemoteException e) {
return null;
}
}
};
}
|
