/*
* Copyright (C) 2008 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.Mylauncher2;
import android.app.ActivityManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.pm.ResolveInfo;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.drawable.Drawable;
import android.preference.PreferenceManager;
import android.util.Log;
import java.util.HashMap;
/**
* Cache of application icons. Icons can be made from any thread.
*/
public class IconCache {
@SuppressWarnings("unused")
private static final String TAG = "Launcher.IconCache";
private static final int INITIAL_ICON_CACHE_CAPACITY = 50;
private static class CacheEntry {
public Bitmap icon;
public String title;
}
private final Bitmap mDefaultIcon;
private final LauncherApplication mContext;
private final PackageManager mPackageManager;
private final HashMap<ComponentName, CacheEntry> mCache =
new HashMap<ComponentName, CacheEntry>(INITIAL_ICON_CACHE_CAPACITY);
private int mIconDpi;
public IconCache(LauncherApplication context) {
ActivityManager activityManager =
(ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
mContext = context;
mPackageManager = context.getPackageManager();
mIconDpi = activityManager.getLauncherLargeIconDensity();
// need to set mIconDpi before getting default icon
mDefaultIcon = makeDefaultIcon();
}
public Drawable getFullResDefaultActivityIcon() {
return getFullResIcon(Resources.getSystem(),
android.R.mipmap.sym_def_app_icon);
}
public Drawable getFullResIcon(Resources resources, int iconId) {
Drawable d;
Context context = null;
Resources newResources;
String theme_package = null;
try {
String iconName = resources.getResourceEntryName(iconId);
Log.e("JIANG", "the iconName is " + iconName);
SharedPreferences sp = PreferenceManager
.getDefaultSharedPreferences(mContext
.getApplicationContext());
theme_package = sp.getString(
EffectSettings.CURRENT_THEME_PACKAGE,
EffectSettings.DEFAULT_THEME_PACKAGE);
Log.e("JIANG", "the theme_package is " + theme_package);
context = mContext.createPackageContext(theme_package,
Context.CONTEXT_IGNORE_SECURITY);
Log.e("JIANG", "the context based of " + theme_package
+ " is not NULL!!!!");
newResources = context.getResources();
int newIconId = newResources.getIdentifier(
theme_package + ":drawable/" + iconName, null,
null);
Log.e("JIANG", "the newIconId for iconName is " + newIconId);
if (newIconId > 0) {
Log.e("JIANG",
"the newIconId based of newResources is available!!!");
d = newResources.getDrawableForDensity(newIconId, mIconDpi);
// d = newResources.getDrawable(newIconId);
} else {
Log.e("JIANG",
"the newIconId based of newResources is not available!!!");
d = resources.getDrawableForDensity(iconId, mIconDpi);
}
} catch (NameNotFoundException e) {
Log.e("JIANG", "the context based of " + theme_package
+ " is null!!!");
d = resources.getDrawableForDensity(iconId, mIconDpi);
e.printStackTrace();
} catch (Resources.NotFoundException e) {
Log.e("JIANG", "the resource id of" + iconId + " based of "
+ theme_package + " is null!!!");
d = null;
}
return (d != null) ? d : getFullResDefaultActivityIcon();
}
public Drawable getFullResIcon(String packageName, int iconId) {
Resources resources;
try {
resources = mPackageManager.getResourcesForApplication(packageName);
} catch (PackageManager.NameNotFoundException e) {
resources = null;
}
if (resources != null) {
if (iconId != 0) {
return getFullResIcon(resources, iconId);
}
}
return getFullResDefaultActivityIcon();
}
public Drawable getFullResIcon(ResolveInfo info) {
return getFullResIcon(info.activityInfo);
}
public Drawable getFullResIcon(ActivityInfo info) {
Resources resources;
try {
resources = mPackageManager.getResourcesForApplication(
info.applicationInfo);
} catch (PackageManager.NameNotFoundException e) {
resources = null;
}
if (resources != null) {
int iconId = info.getIconResource();
if (iconId != 0) {
return getFullResIcon(resources, iconId);
}
}
return getFullResDefaultActivityIcon();
}
private Bitmap makeDefaultIcon() {
Drawable d = getFullResDefaultActivityIcon();
Bitmap b = Bitmap.createBitmap(Math.max(d.getIntrinsicWidth(), 1),
Math.max(d.getIntrinsicHeight(), 1),
Bitmap.Config.ARGB_8888);
Canvas c = new Canvas(b);
d.setBounds(0, 0, b.getWidth(), b.getHeight());
d.draw(c);
c.setBitmap(null);
return b;
}
/**
* Remove any records for the supplied ComponentName.
*/
public void remove(ComponentName componentName) {
synchronized (mCache) {
mCache.remove(componentName);
}
}
/**
* Empty out the cache.
*/
public void flush() {
synchronized (mCache) {
mCache.clear();
}
}
/**
* Fill in "application" with the icon and label for "info."
*/
public void getTitleAndIcon(ApplicationInfo application, ResolveInfo info,
HashMap<Object, CharSequence> labelCache) {
synchronized (mCache) {
CacheEntry entry = cacheLocked(application.componentName, info, labelCache);
application.title = entry.title;
application.iconBitmap = entry.icon;
}
}
public Bitmap getIcon(Intent intent) {
synchronized (mCache) {
final ResolveInfo resolveInfo = mPackageManager.resolveActivity(intent, 0);
ComponentName component = intent.getComponent();
if (resolveInfo == null || component == null) {
return mDefaultIcon;
}
CacheEntry entry = cacheLocked(component, resolveInfo, null);
return entry.icon;
}
}
public Bitmap getIcon(ComponentName component, ResolveInfo resolveInfo,
HashMap<Object, CharSequence> labelCache) {
synchronized (mCache) {
if (resolveInfo == null || component == null) {
return null;
}
CacheEntry entry = cacheLocked(component, resolveInfo, labelCache);
return entry.icon;
}
}
public boolean isDefaultIcon(Bitmap icon) {
return mDefaultIcon == icon;
}
private CacheEntry cacheLocked(ComponentName componentName, ResolveInfo info,
HashMap<Object, CharSequence> labelCache) {
CacheEntry entry = mCache.get(componentName);
if (entry == null) {
entry = new CacheEntry();
mCache.put(componentName, entry);
ComponentName key = LauncherModel.getComponentNameFromResolveInfo(info);
if (labelCache != null && labelCache.containsKey(key)) {
entry.title = labelCache.get(key).toString();
} else {
entry.title = info.loadLabel(mPackageManager).toString();
if (labelCache != null) {
labelCache.put(key, entry.title);
}
}
if (entry.title == null) {
entry.title = info.activityInfo.name;
}
entry.icon = Utilities.createIconBitmap(
getFullResIcon(info), mContext);
}
return entry;
}
public HashMap<ComponentName,Bitmap> getAllIcons() {
synchronized (mCache) {
HashMap<ComponentName,Bitmap> set = new HashMap<ComponentName,Bitmap>();
for (ComponentName cn : mCache.keySet()) {
final CacheEntry e = mCache.get(cn);
set.put(cn, e.icon);
}
return set;
}
}
}