IconCache.java revision fad1fb5ed46473af0a6da4324e9e3fa45bd9f6e8 
1/*
2 * Copyright (C) 2008 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 */
16
17package com.android.launcher2;
18
19import android.content.ComponentName;
20import android.content.Intent;
21import android.content.pm.PackageManager;
22import android.content.pm.ResolveInfo;
23import android.graphics.Bitmap;
24import android.graphics.Canvas;
25import android.graphics.drawable.Drawable;
26
27import java.util.HashMap;
28
29/**
30 * Cache of application icons.  Icons can be made from any thread.
31 */
32public class IconCache {
33    private static final String TAG = "Launcher.IconCache";
34
35    private static final int INITIAL_ICON_CACHE_CAPACITY = 50;
36
37    private static class CacheEntry {
38        public Bitmap icon;
39        public String title;
40        public Bitmap titleBitmap;
41    }
42
43    private final Bitmap mDefaultIcon;
44    private final LauncherApplication mContext;
45    private final PackageManager mPackageManager;
46    private final Utilities.BubbleText mBubble;
47    private final HashMap<ComponentName, CacheEntry> mCache =
48            new HashMap<ComponentName, CacheEntry>(INITIAL_ICON_CACHE_CAPACITY);
49
50    public IconCache(LauncherApplication context) {
51        mContext = context;
52        mPackageManager = context.getPackageManager();
53        mBubble = new Utilities.BubbleText(context);
54        mDefaultIcon = makeDefaultIcon();
55    }
56
57    private Bitmap makeDefaultIcon() {
58        Drawable d = mPackageManager.getDefaultActivityIcon();
59        Bitmap b = Bitmap.createBitmap(Math.max(d.getIntrinsicWidth(), 1),
60                Math.max(d.getIntrinsicHeight(), 1),
61                Bitmap.Config.ARGB_8888);
62        Canvas c = new Canvas(b);
63        d.setBounds(0, 0, b.getWidth(), b.getHeight());
64        d.draw(c);
65        return b;
66    }
67
68    /**
69     * Remove any records for the supplied ComponentName.
70     */
71    public void remove(ComponentName componentName) {
72        synchronized (mCache) {
73            mCache.remove(componentName);
74        }
75    }
76
77    /**
78     * Empty out the cache.
79     */
80    public void flush() {
81        synchronized (mCache) {
82            mCache.clear();
83        }
84    }
85
86    /**
87     * Fill in "application" with the icon and label for "info."
88     */
89    public void getTitleAndIcon(ApplicationInfo application, ResolveInfo info) {
90        synchronized (mCache) {
91            CacheEntry entry = cacheLocked(application.componentName, info);
92            if (entry.titleBitmap == null) {
93                entry.titleBitmap = mBubble.createTextBitmap(entry.title);
94            }
95
96            application.title = entry.title;
97            application.titleBitmap = entry.titleBitmap;
98            application.iconBitmap = entry.icon;
99        }
100    }
101
102    public Bitmap getIcon(Intent intent) {
103        synchronized (mCache) {
104            final ResolveInfo resolveInfo = mPackageManager.resolveActivity(intent, 0);
105            ComponentName component = intent.getComponent();
106
107            if (resolveInfo == null || component == null) {
108                return mDefaultIcon;
109            }
110
111            CacheEntry entry = cacheLocked(component, resolveInfo);
112            return entry.icon;
113        }
114    }
115
116    public Bitmap getIcon(ComponentName component, ResolveInfo resolveInfo) {
117        synchronized (mCache) {
118            if (resolveInfo == null || component == null) {
119                return null;
120            }
121
122            CacheEntry entry = cacheLocked(component, resolveInfo);
123            return entry.icon;
124        }
125    }
126
127    private CacheEntry cacheLocked(ComponentName componentName, ResolveInfo info) {
128        CacheEntry entry = mCache.get(componentName);
129        if (entry == null) {
130            entry = new CacheEntry();
131
132            mCache.put(componentName, entry);
133
134            entry.title = info.loadLabel(mPackageManager).toString();
135            if (entry.title == null) {
136                entry.title = info.activityInfo.name;
137            }
138            entry.icon = Utilities.createIconBitmap(
139                    info.activityInfo.loadIcon(mPackageManager), mContext);
140        }
141        return entry;
142    }
143}
144