android.graphics.drawable.Icon Java Examples

private static Drawable getColoredDrawable(Context ctx, String pkg, Icon icon) {
    if (icon == null) return null;

    Drawable d = null;
    if (pkg == null || PACKAGE_NAME.equals(pkg)) {
        final int iconId = (int) XposedHelpers.callMethod(icon, "getResId");
        d = SysUiManagers.IconManager.getBasicIcon(iconId);
        if (d != null) {
            return d;
        }
    }
    d = icon.loadDrawable(ctx);
    if (d != null) {
        if (SysUiManagers.IconManager.isColoringEnabled()) {
            d = SysUiManagers.IconManager.applyColorFilter(d.mutate(),
                    PorterDuff.Mode.SRC_IN);
        } else {
            d.clearColorFilter();
        }
    }
    return d;
}
 

private void updateTileState(int state) {
    Tile tile = getQsTile();
    if (tile != null) {
        tile.setState(state);
        Icon icon = tile.getIcon();
        switch (state) {
            case Tile.STATE_ACTIVE:
                icon.setTint(Color.WHITE);
                break;
            case Tile.STATE_INACTIVE:
            case Tile.STATE_UNAVAILABLE:
            default:
                icon.setTint(Color.GRAY);
                break;
        }
        tile.updateTile();
    }
}
 

@Override
public List<ChooserTarget> onGetChooserTargets(ComponentName targetActivityName, IntentFilter matchedFilter) {
    ComponentName componentName = new ComponentName(getPackageName(),
            ShareActivity.class.getCanonicalName());
    ArrayList<ChooserTarget> targets = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        Bundle extras = new Bundle();
        extras.putInt("directsharekey", i);
        targets.add(new ChooserTarget(
                "name_" + i,
                Icon.createWithResource(this, R.mipmap.ic_logo),
                0.5f,
                componentName,
                extras));
    }
    return targets;
}
 

@Nullable
private static Drawable maybeLoadDrawable(Icon icon) {
    if (icon == null) {
        return null;
    }
    switch (icon.getType()) {
        case Icon.TYPE_BITMAP:
            return new BitmapDrawable(Resources.getSystem(), icon.getBitmap());
        case Icon.TYPE_ADAPTIVE_BITMAP:
            return new AdaptiveIconDrawable(null,
                    new BitmapDrawable(Resources.getSystem(), icon.getBitmap()));
        case Icon.TYPE_DATA:
            return new BitmapDrawable(
                    Resources.getSystem(),
                    BitmapFactory.decodeByteArray(
                            icon.getDataBytes(), icon.getDataOffset(), icon.getDataLength()));
    }
    return null;
}
 

@Override
public List<ChooserTarget> onGetChooserTargets(ComponentName targetComponentName,
                                               IntentFilter intentFilter) {
    if (sServer != null && sChannel != null) {
        if (System.currentTimeMillis() - sSetTime >= SET_TIMEOUT) {
            sServer = null;
            sChannel = null;
            return null;
        }
        ComponentName componentName = new ComponentName(getPackageName(),
                MainActivity.class.getCanonicalName());

        List<ChooserTarget> targets = new ArrayList<>();
        Bundle extras = new Bundle();
        extras.putString(MainActivity.ARG_SERVER_UUID, sServer.toString());
        extras.putString(MainActivity.ARG_CHANNEL_NAME, sChannel);
        targets.add(new ChooserTarget(sChannel,
                Icon.createWithResource(this, R.drawable.ic_direct_share),
                1.f, componentName, extras));
        return targets;
    }
    return null;
}
 

@Override
protected void attachBaseContext(Context base) {
    super.attachBaseContext(base);

    iconIdle = Icon.createWithResource(this, R.drawable.ic_start_idle).setTint(0x80ffffff);
    iconBusy = Icon.createWithResource(this, R.drawable.ic_start_busy);
    iconConnected = Icon.createWithResource(this, R.drawable.ic_start_connected);

    mServiceBoundContext = new ServiceBoundContext(base) {
        @Override
        protected void onServiceConnected() {
            try {
                callback.stateChanged(bgService.getState(), bgService.getProfileName(), null);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    };
}
 

private void updateTileState(int state) {
    Tile tile = getQsTile();
    if (tile != null) {
        tile.setState(state);
        Icon icon = tile.getIcon();
        switch (state) {
            case Tile.STATE_ACTIVE:
                icon.setTint(Color.WHITE);
                break;
            case Tile.STATE_INACTIVE:
            case Tile.STATE_UNAVAILABLE:
            default:
                icon.setTint(Color.GRAY);
                break;
        }
        tile.updateTile();
    }
}
 

private void setLauncherShortcuts() {
    if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
        ShortcutManager shortcutManager = getSystemService(ShortcutManager.class);

        if(shortcutManager.getDynamicShortcuts().size() == 0) {
            Intent intent = new Intent(Intent.ACTION_MAIN);
            intent.setClassName(BuildConfig.APPLICATION_ID, TaskerQuickActionsActivity.class.getName());
            intent.putExtra("launched-from-app", true);

            ShortcutInfo shortcut = new ShortcutInfo.Builder(this, "quick_actions")
                    .setShortLabel(getString(R.string.label_quick_actions))
                    .setIcon(Icon.createWithResource(this, R.drawable.shortcut_icon))
                    .setIntent(intent)
                    .build();

            shortcutManager.setDynamicShortcuts(Collections.singletonList(shortcut));
        }
    }
}
 

@RequiresApi(api = Build.VERSION_CODES.N_MR1)
public static void addRemoteToAppShortcuts(Context context, RemoteItem remoteItem, String id) {
    ShortcutManager shortcutManager = context.getSystemService(ShortcutManager.class);
    if (shortcutManager == null) {
        return;
    }

    Intent intent = new Intent(Intent.ACTION_MAIN, Uri.EMPTY, context, MainActivity.class);
    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
    intent.putExtra(APP_SHORTCUT_REMOTE_NAME, remoteItem.getName());

    ShortcutInfo shortcut = new ShortcutInfo.Builder(context, id)
            .setShortLabel(remoteItem.getName())
            .setIcon(Icon.createWithResource(context, AppShortcutsHelper.getRemoteIcon(remoteItem.getType(), remoteItem.isCrypt())))
            .setIntent(intent)
            .build();

    shortcutManager.addDynamicShortcuts(Collections.singletonList(shortcut));
}
 

@TargetApi(Build.VERSION_CODES.M)
	void fixIcon(Icon icon, Context pluginContext, boolean isInstall) {
		if (icon == null) return;
		int type = Reflect.on(icon).get("mType");
//        Log.i(TAG, "smallIcon type=" + type);
		if (type == 2) {
			if (isInstall) {
				Reflect.on(icon).set("mObj1", pluginContext.getResources());
				Reflect.on(icon).set("mString1", pluginContext.getPackageName());
			} else {
				Drawable drawable = icon.loadDrawable(pluginContext);
				Bitmap bitmap = drawableToBitMap(drawable);
				Reflect.on(icon).set("mObj1", bitmap);
				Reflect.on(icon).set("mString1", null);
				Reflect.on(icon).set("mType", 1);
			}
		}
	}
 

private Suggestion(Parcel in) {
    mId = in.readString();
    mTitle = in.readCharSequence();
    mSummary = in.readCharSequence();
    mIcon = in.readParcelable(Icon.class.getClassLoader());
    mFlags = in.readInt();
    mPendingIntent = in.readParcelable(PendingIntent.class.getClassLoader());
}
 

public static void testNotification(String text) {
    {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {

            final Notification.Builder mBuilder = new Notification.Builder(xdrip.getAppContext());

            mBuilder.setSmallIcon(Icon.createWithBitmap(getSmallIconBitmap(text)));

            mBuilder.setContentTitle("Test Number Graphic");
            mBuilder.setContentText("Check the number is visible");
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                mBuilder.setTimeoutAfter(Constants.SECOND_IN_MS * 30);
            } else {
                JoH.runOnUiThreadDelayed(new Runnable() {
                    @Override
                    public void run() {
                        JoH.cancelNotification(Constants.NUMBER_TEXT_TEST_ID);
                    }
                }, Constants.SECOND_IN_MS * 30);
            }
            mBuilder.setOngoing(false);
            mBuilder.setVibrate(vibratePattern);

            int mNotificationId = Constants.NUMBER_TEXT_TEST_ID;
            final NotificationManager mNotifyMgr = (NotificationManager) xdrip.getAppContext().getSystemService(NOTIFICATION_SERVICE);
            mNotifyMgr.notify(mNotificationId, mBuilder.build());
            JoH.runOnUiThreadDelayed(new Runnable() {
                @Override
                public void run() {
                    mNotifyMgr.notify(mNotificationId, mBuilder.build());
                }
            }, 1000);
        } else {
            JoH.static_toast_long("Not supported below Android 6");
        }
    }
}
 

/**
 * Adds an action to {@code builder} using a {@code Bitmap} if a bitmap is provided and the API
 * level is high enough, otherwise a resource id is used.
 */
@SuppressWarnings("deprecation") // For addAction(int, CharSequence, PendingIntent)
@TargetApi(Build.VERSION_CODES.M) // For the Icon class.
protected static void addActionToBuilder(Notification.Builder builder, Action action) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && action.iconBitmap != null) {
        Icon icon = Icon.createWithBitmap(action.iconBitmap);
        builder.addAction(
                new Notification.Action.Builder(icon, action.title, action.intent).build());
    } else {
        builder.addAction(action.iconId, action.title, action.intent);
    }
}
 

private Icon createSavedMessagesIcon() {
    try {
        final Bitmap bitmap = Bitmap.createBitmap(AndroidUtilities.dp(56f), AndroidUtilities.dp(56f), Bitmap.Config.ARGB_8888);
        final AvatarDrawable avatarDrawable = new AvatarDrawable();
        avatarDrawable.setAvatarType(AvatarDrawable.AVATAR_TYPE_SAVED);
        avatarDrawable.setBounds(0, 0, bitmap.getWidth(), bitmap.getHeight());
        avatarDrawable.draw(new Canvas(bitmap));
        return Icon.createWithBitmap(bitmap);
    } catch (Throwable e) {
        FileLog.e(e);
    }
    return null;
}
 

private void update() {
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
    boolean enabled = prefs.getBoolean("enabled", false);
    Tile tile = getQsTile();
    if (tile != null) {
        tile.setState(enabled ? Tile.STATE_ACTIVE : Tile.STATE_INACTIVE);
        tile.setIcon(Icon.createWithResource(this, enabled ? R.drawable.ic_rocket_white : R.drawable.ic_rocket_white_60));
        tile.updateTile();
    }
}
 

@NonNull
private static Icon getIcon(ResourceProvider provider, WeatherCode code, boolean daytime) {
    return Icon.createWithBitmap(
            drawableToBitmap(
                    ResourceHelper.getShortcutsIcon(provider, code, daytime)
            )
    );
}
 

@RequiresApi(api = Build.VERSION_CODES.N_MR1)
private ShortcutInfo returnShortcutInfo(Shortcut shortcut) {
    return new ShortcutInfo.Builder(context, shortcut.getShortcutId())
            .setShortLabel(shortcut.getShortcutShortLabel())
            .setLongLabel(shortcut.getShortcutLongLabel())
            .setIcon(Icon.createWithResource(context, shortcut.getShortcutIcon()))
            .setIntent(returnIntent(shortcut))
            .build();
}
 

private ShortcutInfo.Builder setSiteInformation(ShortcutInfo.Builder b, Uri uri) {
    // TODO Get the actual site <title> and use it.
    // TODO Set the current locale to accept-language to get localized title.
    b.setShortLabel(uri.getHost());
    b.setLongLabel(uri.toString());

    Bitmap bmp = fetchFavicon(uri);
    if (bmp != null) {
        b.setIcon(Icon.createWithBitmap(bmp));
    } else {
        b.setIcon(Icon.createWithResource(mContext, R.drawable.link));
    }

    return b;
}
 

private Class<?> getParameterType() {
    switch (this.type) {
        case BOOLEAN:
            return boolean.class;
        case BYTE:
            return byte.class;
        case SHORT:
            return short.class;
        case INT:
            return int.class;
        case LONG:
            return long.class;
        case FLOAT:
            return float.class;
        case DOUBLE:
            return double.class;
        case CHAR:
            return char.class;
        case STRING:
            return String.class;
        case CHAR_SEQUENCE:
            return CharSequence.class;
        case URI:
            return Uri.class;
        case BITMAP:
            return Bitmap.class;
        case BUNDLE:
            return Bundle.class;
        case INTENT:
            return Intent.class;
        case COLOR_STATE_LIST:
            return ColorStateList.class;
        case ICON:
            return Icon.class;
        default:
            return null;
    }
}
 

private void updItem(int index) {
    Intent intent = new Intent(this, MessageActivity.class);
    intent.setAction(Intent.ACTION_VIEW);
    intent.putExtra("msg", "我和" + mAdapter.getItem(index) + "的对话");

    ShortcutInfo info = new ShortcutInfo.Builder(this, "id" + index)
            .setShortLabel(mAdapter.getItem(index))
            .setLongLabel("联系人:" + mAdapter.getItem(index))
            .setIcon(Icon.createWithResource(this, R.drawable.icon))
            .setIntent(intent)
            .build();

    mShortcutManager.updateShortcuts(Arrays.asList(info));
}
 

public Icon getIconCache(final Context ctx, final String pkg, Converter<Bitmap, Icon> callback) {
    return new AbstractCacheAspect<Icon>(mIconMemoryCaches) {
        @Override
        Icon gen() {
            Bitmap rawIconBitmap = getRawIconBitmap(ctx, pkg);
            Bitmap whiteIconBitmap = new WhiteIconProcess().convert(ctx, rawIconBitmap);
            return callback.convert(ctx, whiteIconBitmap);
        }
    }.get("white_" + pkg);
}
 

private Icon createSavedMessagesIcon() {
    try {
        final Bitmap bitmap = Bitmap.createBitmap(AndroidUtilities.dp(56f), AndroidUtilities.dp(56f), Bitmap.Config.ARGB_8888);
        final AvatarDrawable avatarDrawable = new AvatarDrawable();
        avatarDrawable.setAvatarType(AvatarDrawable.AVATAR_TYPE_SAVED);
        avatarDrawable.setBounds(0, 0, bitmap.getWidth(), bitmap.getHeight());
        avatarDrawable.draw(new Canvas(bitmap));
        return Icon.createWithBitmap(bitmap);
    } catch (Throwable e) {
        FileLog.e(e);
    }
    return null;
}
 

private void updateTile() {
    final Tile tile = getQsTile();
    if (FtpServiceHelper.getInstance().isStarted()) {
        tile.setIcon(Icon.createWithResource(this, R.drawable.ic_tile_ftp));
        tile.setLabel(getString(R.string.ftp_tile_label_active));
        tile.setState(Tile.STATE_ACTIVE);
    } else {
        tile.setIcon(Icon.createWithResource(this, R.drawable.ic_tile_ftp));
        tile.setLabel(getString(R.string.ftp_tile_label_inactive));
        tile.setState(Tile.STATE_INACTIVE);
    }
    tile.updateTile();
}
 

public Notification createNotiComp(NotificationManager nm, String ticker, String title, String content, long[] vibration, PendingIntent pi) {
    Application app = getApplication();
    Notification.Builder builder;
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
        NotificationChannel channel = new NotificationChannel("qn_del_notify", "删好友通知", NotificationManager.IMPORTANCE_DEFAULT);
        channel.setSound(null, null);
        channel.setVibrationPattern(vibration);
        nm.createNotificationChannel(channel);
        builder = new Notification.Builder(app, channel.getId());
    } else {
        builder = new Notification.Builder(app);
    }
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        MainHook.injectModuleResources(app.getResources());
        //we have to createWithBitmap rather than with a ResId, otherwise RemoteServiceException
        builder.setSmallIcon(Icon.createWithBitmap(BitmapFactory.decodeResource(app.getResources(), R.drawable.ic_del_friend_top)));
    } else {
        //2020 now, still using <23?
        builder.setSmallIcon(android.R.drawable.ic_delete);
    }
    builder.setTicker(ticker);
    builder.setContentTitle(title);
    builder.setContentText(content);
    builder.setContentIntent(pi);
    builder.setVibrate(vibration);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
        return builder.build();
    } else {
        return builder.getNotification();
    }
}
 

private void readFromParcel(Parcel source) {
    if (source.readByte() != 0) {
        mIcon = Icon.CREATOR.createFromParcel(source);
    } else {
        mIcon = null;
    }
    mState = source.readInt();
    mLabel = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(source);
    mContentDescription = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(source);
}
 

@TargetApi(26)
private static void doCreateShortcut(Context context, String appName, Drawable draw, Intent intent) {
    ShortcutManager shortcutManager = Objects.requireNonNull(context.getSystemService(ShortcutManager.class));

    if (shortcutManager.isRequestPinShortcutSupported()) {
        Bitmap bitmap = getBitmapFromDrawable(draw);
        intent.setAction(Intent.ACTION_CREATE_SHORTCUT);


        ShortcutInfo shortcutInfo = new ShortcutInfo.Builder(context, appName)
                .setShortLabel(appName)
                .setLongLabel(appName)
                .setIcon(Icon.createWithBitmap(bitmap))
                .setIntent(intent)
                .build();

        shortcutManager.requestPinShortcut(shortcutInfo, null);
    } else {
        new AlertDialog.Builder(context)
                .setTitle(context.getText(R.string.error_creating_shortcut))
                .setMessage(context.getText(R.string.error_verbose_pin_shortcut))
                .setPositiveButton(context.getText(android.R.string.ok), new DialogInterface.OnClickListener() {

                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        // Just close dialog don't do anything
                        dialog.cancel();
                    }
                })
                .show();
    }
}
 

/**
 * Creates a public version of the notification to be displayed in sensitive contexts, such as
 * on the lockscreen, displaying just the site origin and badge or generated icon.
 */
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
protected Notification createPublicNotification(Context context) {
    // Use Android's Notification.Builder because we want the default small icon behaviour.
    Notification.Builder builder =
            new Notification.Builder(context)
                    .setContentText(context.getString(
                            org.chromium.chrome.R.string.notification_hidden_text))
                    .setSmallIcon(org.chromium.chrome.R.drawable.ic_chrome);

    if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
        // On N, 'subtext' displays at the top of the notification and this looks better.
        builder.setSubText(mOrigin);
    } else {
        // Set origin as title on L & M, because they look odd without one.
        builder.setContentTitle(mOrigin);
        // Hide the timestamp to match Android's default public notifications on L and M.
        builder.setShowWhen(false);
    }

    // Use the badge if provided and SDK supports it, else use a generated icon.
    if (mSmallIconBitmap != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        // The Icon class was added in Android M.
        Bitmap publicIcon = mSmallIconBitmap.copy(mSmallIconBitmap.getConfig(), true);
        builder.setSmallIcon(Icon.createWithBitmap(publicIcon));
    } else if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.M && mOrigin != null) {
        // Only set the large icon for L & M because on N(+?) it would add an extra icon on
        // the right hand side, which looks odd without a notification title.
        builder.setLargeIcon(mIconGenerator.generateIconForUrl(mOrigin.toString(), true));
    }
    return builder.build();
}
 

/**
 * Creates a public version of the notification to be displayed in sensitive contexts, such as
 * on the lockscreen, displaying just the site origin and badge or generated icon.
 */
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
protected Notification createPublicNotification(Context context) {
    // Use a non-compat builder because we want the default small icon behaviour.
    ChromeNotificationBuilder builder =
            NotificationBuilderFactory
                    .createChromeNotificationBuilder(
                            false /* preferCompat */, ChannelDefinitions.CHANNEL_ID_SITES)
                    .setContentText(context.getString(
                            org.chromium.chrome.R.string.notification_hidden_text))
                    .setSmallIcon(org.chromium.chrome.R.drawable.ic_chrome);

    if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
        // On N, 'subtext' displays at the top of the notification and this looks better.
        builder.setSubText(mOrigin);
    } else {
        // Set origin as title on L & M, because they look odd without one.
        builder.setContentTitle(mOrigin);
        // Hide the timestamp to match Android's default public notifications on L and M.
        builder.setShowWhen(false);
    }

    // Use the badge if provided and SDK supports it, else use a generated icon.
    if (mSmallIconBitmap != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        // The Icon class was added in Android M.
        Bitmap publicIcon = mSmallIconBitmap.copy(mSmallIconBitmap.getConfig(), true);
        builder.setSmallIcon(Icon.createWithBitmap(publicIcon));
    } else if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.M && mOrigin != null) {
        // Only set the large icon for L & M because on N(+?) it would add an extra icon on
        // the right hand side, which looks odd without a notification title.
        builder.setLargeIcon(mIconGenerator.generateIconForUrl(mOrigin.toString(), true));
    }
    return builder.build();
}
 

public static Icon generateThemedIcon(Context context, int iconId) {
    if (PreferenceUtil.getInstance(context).coloredAppShortcuts()) {
        return generateUserThemedIcon(context, iconId).toIcon();
    } else {
        return generateDefaultThemedIcon(context, iconId).toIcon();
    }
}
 

public static void createLauncherShortcut(Context context, Intent launchIntent, Icon icon, String id, String label) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        ShortcutManager shortcutManager = context.getSystemService(ShortcutManager.class);

        if (shortcutManager.isRequestPinShortcutSupported()) {
            ShortcutInfo info = new ShortcutInfo.Builder(context, id)
                    .setIntent(launchIntent)
                    .setIcon(icon)
                    .setShortLabel(label)
                    .setLongLabel(label)
                    .build();
            Intent addIntent = shortcutManager.createShortcutResultIntent(info);
            shortcutManager.requestPinShortcut(info,
                    PendingIntent.getBroadcast(context, 0, addIntent, 0).getIntentSender());
        } else {
            // TODO: Maybe implement this for launchers without pin shortcut support?
            // TODO: Should be the same with the fallback for Android < O
            // for now just show unsupported
            Toast.makeText(context, context.getString(R.string.unsupported_launcher), Toast.LENGTH_LONG).show();
        }
    } else {
        Intent shortcutIntent = new Intent("com.android.launcher.action.INSTALL_SHORTCUT");
        shortcutIntent.putExtra(Intent.EXTRA_SHORTCUT_INTENT, launchIntent);
        shortcutIntent.putExtra(Intent.EXTRA_SHORTCUT_NAME, label);
        shortcutIntent.putExtra(Intent.EXTRA_SHORTCUT_ICON, drawableToBitmap(icon.loadDrawable(context)));
        context.sendBroadcast(shortcutIntent);
        Toast.makeText(context, R.string.shortcut_create_success, Toast.LENGTH_SHORT).show();
    }
}