private Drawable getSubtypeIcon(
InputMethodInfoCompatWrapper imi, InputMethodSubtypeCompatWrapper subtype) {
final PackageManager pm = mService.getPackageManager();
if (imi != null) {
final String imiPackageName = imi.getPackageName();
if (DBG) {
Log.d(
TAG,
"Update icons of IME: "
+ imiPackageName
+ ","
+ getSubtypeLocale(subtype)
+ ","
+ subtype.getMode());
}
if (subtype != null) {
return pm.getDrawable(
imiPackageName, subtype.getIconResId(), imi.getServiceInfo().applicationInfo);
} else if (imi.getSubtypeCount() > 0 && imi.getSubtypeAt(0) != null) {
return pm.getDrawable(
imiPackageName,
imi.getSubtypeAt(0).getIconResId(),
imi.getServiceInfo().applicationInfo);
} else {
try {
return pm.getApplicationInfo(imiPackageName, 0).loadIcon(pm);
} catch (PackageManager.NameNotFoundException e) {
Log.w(TAG, "IME can't be found: " + imiPackageName);
}
}
}
return null;
}
private Drawable getSubtypeIcon(InputMethodInfo imi, InputMethodSubtype subtype) {
if (imi != null) {
if (DEBUG) {
Log.d(TAG, "Update icons of IME: " + imi.getPackageName());
if (subtype != null) {
Log.d(TAG, "subtype =" + subtype.getLocale() + "," + subtype.getMode());
}
}
if (subtype != null) {
return mPackageManager.getDrawable(
imi.getPackageName(), subtype.getIconResId(), imi.getServiceInfo().applicationInfo);
} else if (imi.getSubtypeCount() > 0) {
return mPackageManager.getDrawable(
imi.getPackageName(),
imi.getSubtypeAt(0).getIconResId(),
imi.getServiceInfo().applicationInfo);
} else {
try {
return mPackageManager
.getApplicationInfo(imi.getPackageName(), 0)
.loadIcon(mPackageManager);
} catch (PackageManager.NameNotFoundException e) {
Log.w(TAG, "IME can't be found: " + imi.getPackageName());
}
}
}
return null;
}
/** {@inheritDoc} */
public Drawable getFallbackIcon() {
// Bail early if no valid resources
final String resPackageName = mKind.resPackageName;
if (resPackageName == null) return null;
final PackageManager pm = mContext.getPackageManager();
if (mAlternate && mKind.iconAltRes != -1) {
return pm.getDrawable(resPackageName, mKind.iconAltRes, null);
} else if (mKind.iconRes != -1) {
return pm.getDrawable(resPackageName, mKind.iconRes, null);
} else {
return null;
}
}
public Drawable getIcon(Context context) {
final PackageManager pm = context.getPackageManager();
// Use local package for resources when none requested
if (mResPackage == null) mResPackage = context.getPackageName();
final boolean validIcon = mResPackage != null && mIconRes != -1;
return validIcon ? pm.getDrawable(mResPackage, mIconRes, null) : null;
}
/** Load label and icon for this entry */
public void init(Context context, Account account, AuthenticatorDescription description) {
PackageManager pm = context.getPackageManager();
label = description.packageName;
try {
label = pm.getResourcesForApplication(description.packageName).getString(description.labelId);
} catch (NotFoundException | NameNotFoundException e) {
Log.e(Constants.TAG, "Error retrieving label!", e);
}
icon = pm.getDrawable(description.packageName, description.iconId, null);
}
@Override
public Drawable getAlternateIcon() {
if (mAlternateIconRes == 0) return null;
final String resourcePackageName = mKind.resourcePackageName;
if (resourcePackageName == null) {
return mContext.getResources().getDrawable(mAlternateIconRes);
}
final PackageManager pm = mContext.getPackageManager();
return pm.getDrawable(resourcePackageName, mAlternateIconRes, null);
}
private static void fillIcons(Context c) {
AccountManager am = AccountManager.get(c);
AuthenticatorDescription[] auths = am.getAuthenticatorTypes();
PackageManager pm = c.getPackageManager();
for (AuthenticatorDescription auth : auths) {
accountIcons.put(auth.type, pm.getDrawable(auth.packageName, auth.iconId, null));
/* Log.i("Account:", auth.type);
Log.i("pkg:", auth.packageName);
Log.i("icon:", String.valueOf(auth.smallIconId));*/
}
}
@Nullable
private static Drawable loadDrawable(
@NonNull final PackageManager packageManager,
@NonNull final String packageName,
@DrawableRes final int resId,
@NonNull final ApplicationInfo applicationInfo) {
if (resId == 0) {
return null;
}
try {
return packageManager.getDrawable(packageName, resId, applicationInfo);
} catch (Exception e) {
return null;
}
}
/**
* Gets the activity or application icon for an activity.
*
* @param component Name of an activity.
* @return A drawable, or {@code null} if neither the acitivy or the application have an icon set.
*/
private Drawable getActivityIcon(ComponentName component) {
PackageManager pm = mContext.getPackageManager();
final ActivityInfo activityInfo;
try {
activityInfo = pm.getActivityInfo(component, PackageManager.GET_META_DATA);
} catch (NameNotFoundException ex) {
Log.w(LOG_TAG, ex.toString());
return null;
}
int iconId = activityInfo.getIconResource();
if (iconId == 0) return null;
String pkg = component.getPackageName();
Drawable drawable = pm.getDrawable(pkg, iconId, activityInfo.applicationInfo);
if (drawable == null) {
Log.w(
LOG_TAG, "Invalid icon resource " + iconId + " for " + component.flattenToShortString());
return null;
}
return drawable;
}
public Bitmap generateWidgetPreview(
ComponentName provider,
int previewImage,
int iconId,
int cellHSpan,
int cellVSpan,
int maxPreviewWidth,
int maxPreviewHeight,
Bitmap preview,
int[] preScaledWidthOut) {
// Load the preview image if possible
String packageName = provider.getPackageName();
if (maxPreviewWidth < 0) maxPreviewWidth = Integer.MAX_VALUE;
if (maxPreviewHeight < 0) maxPreviewHeight = Integer.MAX_VALUE;
Drawable drawable = null;
if (previewImage != 0) {
drawable = mPackageManager.getDrawable(packageName, previewImage, null);
if (drawable == null) {
Log.w(
TAG,
"Can't load widget preview drawable 0x"
+ Integer.toHexString(previewImage)
+ " for provider: "
+ provider);
}
}
int previewWidth;
int previewHeight;
Bitmap defaultPreview = null;
boolean widgetPreviewExists = (drawable != null);
if (widgetPreviewExists) {
previewWidth = drawable.getIntrinsicWidth();
previewHeight = drawable.getIntrinsicHeight();
} else {
// Generate a preview image if we couldn't load one
if (cellHSpan < 1) cellHSpan = 1;
if (cellVSpan < 1) cellVSpan = 1;
BitmapDrawable previewDrawable =
(BitmapDrawable) mContext.getResources().getDrawable(R.drawable.widget_tile);
final int previewDrawableWidth = previewDrawable.getIntrinsicWidth();
final int previewDrawableHeight = previewDrawable.getIntrinsicHeight();
previewWidth = previewDrawableWidth * cellHSpan;
previewHeight = previewDrawableHeight * cellVSpan;
defaultPreview = Bitmap.createBitmap(previewWidth, previewHeight, Config.ARGB_8888);
final Canvas c = mCachedAppWidgetPreviewCanvas.get();
c.setBitmap(defaultPreview);
previewDrawable.setBounds(0, 0, previewWidth, previewHeight);
previewDrawable.setTileModeXY(Shader.TileMode.REPEAT, Shader.TileMode.REPEAT);
previewDrawable.draw(c);
c.setBitmap(null);
// Draw the icon in the top left corner
int minOffset = (int) (mAppIconSize * sWidgetPreviewIconPaddingPercentage);
int smallestSide = Math.min(previewWidth, previewHeight);
float iconScale = Math.min((float) smallestSide / (mAppIconSize + 2 * minOffset), 1f);
try {
Drawable icon = null;
int hoffset = (int) ((previewDrawableWidth - mAppIconSize * iconScale) / 2);
int yoffset = (int) ((previewDrawableHeight - mAppIconSize * iconScale) / 2);
if (iconId > 0) icon = mIconCache.getFullResIcon(packageName, iconId);
if (icon != null) {
renderDrawableToBitmap(
icon,
defaultPreview,
hoffset,
yoffset,
(int) (mAppIconSize * iconScale),
(int) (mAppIconSize * iconScale));
}
} catch (Resources.NotFoundException e) {
}
}
// Scale to fit width only - let the widget preview be clipped in the
// vertical dimension
float scale = 1f;
if (preScaledWidthOut != null) {
preScaledWidthOut[0] = previewWidth;
}
if (previewWidth > maxPreviewWidth) {
scale = maxPreviewWidth / (float) previewWidth;
}
if (scale != 1f) {
previewWidth = (int) (scale * previewWidth);
previewHeight = (int) (scale * previewHeight);
}
// If a bitmap is passed in, we use it; otherwise, we create a bitmap of the right size
if (preview == null) {
preview = Bitmap.createBitmap(previewWidth, previewHeight, Config.ARGB_8888);
}
// Draw the scaled preview into the final bitmap
int x = (preview.getWidth() - previewWidth) / 2;
if (widgetPreviewExists) {
renderDrawableToBitmap(drawable, preview, x, 0, previewWidth, previewHeight);
} else {
final Canvas c = mCachedAppWidgetPreviewCanvas.get();
final Rect src = mCachedAppWidgetPreviewSrcRect.get();
final Rect dest = mCachedAppWidgetPreviewDestRect.get();
c.setBitmap(preview);
src.set(0, 0, defaultPreview.getWidth(), defaultPreview.getHeight());
dest.set(x, 0, x + previewWidth, previewHeight);
Paint p = mCachedAppWidgetPreviewPaint.get();
if (p == null) {
p = new Paint();
p.setFilterBitmap(true);
mCachedAppWidgetPreviewPaint.set(p);
}
c.drawBitmap(defaultPreview, src, dest, p);
c.setBitmap(null);
}
return preview;
}
