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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
/*
* Copyright (C) 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 com.android.systemui.shared.recents.model;
import android.app.ActivityManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.UserHandle;
import android.util.IconDrawableFactory;
import android.util.Log;
import android.util.LruCache;
import com.android.systemui.shared.system.PackageManagerWrapper;
public abstract class IconLoader {
private static final String TAG = "IconLoader";
protected final Context mContext;
protected final TaskKeyLruCache<Drawable> mIconCache;
protected final LruCache<ComponentName, ActivityInfo> mActivityInfoCache;
public IconLoader(Context context, TaskKeyLruCache<Drawable> iconCache, LruCache<ComponentName,
ActivityInfo> activityInfoCache) {
mContext = context;
mIconCache = iconCache;
mActivityInfoCache = activityInfoCache;
}
/**
* Returns the activity info for the given task key, retrieving one from the system if the
* task key is expired.
*
* TODO: Move this to an ActivityInfoCache class
*/
public ActivityInfo getAndUpdateActivityInfo(Task.TaskKey taskKey) {
ComponentName cn = taskKey.getComponent();
ActivityInfo activityInfo = mActivityInfoCache.get(cn);
if (activityInfo == null) {
activityInfo = PackageManagerWrapper.getInstance().getActivityInfo(cn, taskKey.userId);
if (cn == null || activityInfo == null) {
Log.e(TAG, "Unexpected null component name or activity info: " + cn + ", " +
activityInfo);
return null;
}
mActivityInfoCache.put(cn, activityInfo);
}
return activityInfo;
}
public Drawable getIcon(Task t) {
Drawable cachedIcon = mIconCache.get(t.key);
if (cachedIcon == null) {
cachedIcon = createNewIconForTask(t.key, t.taskDescription, true /* returnDefault */);
mIconCache.put(t.key, cachedIcon);
}
return cachedIcon;
}
/**
* Returns the cached task icon if the task key is not expired, updating the cache if it is.
*/
public Drawable getAndInvalidateIfModified(Task.TaskKey taskKey,
ActivityManager.TaskDescription td, boolean loadIfNotCached) {
// Return the cached activity icon if it exists
Drawable icon = mIconCache.getAndInvalidateIfModified(taskKey);
if (icon != null) {
return icon;
}
if (loadIfNotCached) {
icon = createNewIconForTask(taskKey, td, false /* returnDefault */);
if (icon != null) {
mIconCache.put(taskKey, icon);
return icon;
}
}
// We couldn't load any icon
return null;
}
private Drawable createNewIconForTask(Task.TaskKey taskKey,
ActivityManager.TaskDescription desc, boolean returnDefault) {
int userId = taskKey.userId;
Bitmap tdIcon = desc.getInMemoryIcon();
if (tdIcon != null) {
return createDrawableFromBitmap(tdIcon, userId, desc);
}
if (desc.getIconResource() != 0) {
try {
Context packageContext = mContext.createPackageContextAsUser(
taskKey.getPackageName(), 0, UserHandle.of(userId));
return createBadgedDrawable(packageContext.getDrawable(desc.getIconResource()),
userId, desc);
} catch (Resources.NotFoundException|PackageManager.NameNotFoundException e) {
Log.e(TAG, "Could not find icon drawable from resource", e);
}
}
tdIcon = ActivityManager.TaskDescription.loadTaskDescriptionIcon(
desc.getIconFilename(), userId);
if (tdIcon != null) {
return createDrawableFromBitmap(tdIcon, userId, desc);
}
// Load the icon from the activity info and cache it
ActivityInfo activityInfo = getAndUpdateActivityInfo(taskKey);
if (activityInfo != null) {
Drawable icon = getBadgedActivityIcon(activityInfo, userId, desc);
if (icon != null) {
return icon;
}
}
// At this point, even if we can't load the icon, we will set the default icon.
return returnDefault ? getDefaultIcon(userId) : null;
}
public abstract Drawable getDefaultIcon(int userId);
protected Drawable createDrawableFromBitmap(Bitmap icon, int userId,
ActivityManager.TaskDescription desc) {
return createBadgedDrawable(
new BitmapDrawable(mContext.getResources(), icon), userId, desc);
}
protected abstract Drawable createBadgedDrawable(Drawable icon, int userId,
ActivityManager.TaskDescription desc);
/**
* @return the activity icon for the ActivityInfo for a user, badging if necessary.
*/
protected abstract Drawable getBadgedActivityIcon(ActivityInfo info, int userId,
ActivityManager.TaskDescription desc);
public static class DefaultIconLoader extends IconLoader {
private final BitmapDrawable mDefaultIcon;
private final IconDrawableFactory mDrawableFactory;
public DefaultIconLoader(Context context, TaskKeyLruCache<Drawable> iconCache,
LruCache<ComponentName, ActivityInfo> activityInfoCache) {
super(context, iconCache, activityInfoCache);
// Create the default assets
Bitmap icon = Bitmap.createBitmap(1, 1, Bitmap.Config.ALPHA_8);
icon.eraseColor(0);
mDefaultIcon = new BitmapDrawable(context.getResources(), icon);
mDrawableFactory = IconDrawableFactory.newInstance(context);
}
@Override
public Drawable getDefaultIcon(int userId) {
return mDefaultIcon;
}
@Override
protected Drawable createBadgedDrawable(Drawable icon, int userId,
ActivityManager.TaskDescription desc) {
if (userId != UserHandle.myUserId()) {
icon = mContext.getPackageManager().getUserBadgedIcon(icon, new UserHandle(userId));
}
return icon;
}
@Override
protected Drawable getBadgedActivityIcon(ActivityInfo info, int userId,
ActivityManager.TaskDescription desc) {
return mDrawableFactory.getBadgedIcon(info, info.applicationInfo, userId);
}
}
}
|
