ollide / intellij-java2smali Goto Github PK

java: package android.content does not exist

lintOptions {
        abortOnError false
}

/**
 * Multiply alpha values with (1+DARK_ALPHA_BOOST) when dozing. The chosen value boosts
 * everything above 30% to 50%, making it appear on 1bit color depths.
 */
private static final float DARK_ALPHA_BOOST = 0.67f;
/**
 * Status icons are currently drawn with the intention of being 17dp tall, but we
 * want to scale them (in a way that doesn't require an asset dump) down 2dp. So
 * 17dp * (15 / 17) = 15dp, the new height.
 */
private static final float SYSTEM_ICON_SCALE = 15.f / 17.f;
private final int ANIMATION_DURATION_FAST = 100;

public static final int STATE_ICON = 0;
public static final int STATE_DOT = 1;
public static final int STATE_HIDDEN = 2;

private static final String TAG = "StatusBarIconView";
private static final Property<StatusBarIconView, Float> ICON_APPEAR_AMOUNT
        = new FloatProperty<StatusBarIconView>("iconAppearAmount") {

    @Override
    public void setValue(StatusBarIconView object, float value) {
        object.setIconAppearAmount(value);
    }

    @Override
    public Float get(StatusBarIconView object) {
        return object.getIconAppearAmount();
    }
};
private static final Property<StatusBarIconView, Float> DOT_APPEAR_AMOUNT
        = new FloatProperty<StatusBarIconView>("dot_appear_amount") {

    @Override
    public void setValue(StatusBarIconView object, float value) {
        object.setDotAppearAmount(value);
    }

    @Override
    public Float get(StatusBarIconView object) {
        return object.getDotAppearAmount();
    }
};

private boolean mAlwaysScaleIcon;
private static boolean mIsSystemUI;
private int mStatusBarIconDrawingSizeIncreased = 1;
private int mStatusBarIconDrawingSize = 1;
private int mStatusBarIconSize = 1;
private StatusBarIcon mIcon;
@ViewDebug.ExportedProperty private String mSlot;
private Drawable mNumberBackground;
private Paint mNumberPain;
private int mNumberX;
private int mNumberY;
private String mNumberText;
private StatusBarNotification mNotification;
private final boolean mBlocked;
private int mDensity;
private boolean mNightMode;
private float mIconScale = 1.0f;
private final Paint mDotPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
private float mDotRadius;
private int mStaticDotRadius;
private int mVisibleState = STATE_ICON;
private float mIconAppearAmount = 1.0f;
private ObjectAnimator mIconAppearAnimator;
private ObjectAnimator mDotAnimator;
private float mDotAppearAmount;
private OnVisibilityChangedListener mOnVisibilityChangedListener;
private int mDrawableColor;
private int mIconColor;
private int mDecorColor;
private float mDozeAmount;
private ValueAnimator mColorAnimator;
private int mCurrentSetColor = NO_COLOR;
private int mAnimationStartColor = NO_COLOR;
private boolean mShowNotificationCount;
private GlobalSettingsObserver mObserver;
private final ValueAnimator.AnimatorUpdateListener mColorUpdater
        = animation -> {
    int newColor = NotificationUtils.interpolateColors(mAnimationStartColor, mIconColor,
            animation.getAnimatedFraction());
    setColorInternal(newColor);
};
private final NotificationIconDozeHelper mDozer;
private int mContrastedDrawableColor;
private int mCachedContrastBackgroundColor = NO_COLOR;
private float[] mMatrix;
private ColorMatrixColorFilter mMatrixColorFilter;
private boolean mIsInShelf;
private Runnable mLayoutRunnable;
private boolean mDismissed;
private Runnable mOnDismissListener;
private boolean mIncreasedSize;

public StatusBarIconView(Context context, String slot, StatusBarNotification sbn) {
    this(context, slot, sbn, false);
}

public StatusBarIconView(Context context, String slot, StatusBarNotification sbn,
                         boolean blocked) {
    super(context);
    mDozer = new NotificationIconDozeHelper(context);
    mBlocked = blocked;
    final float densityMultiplier = context.getResources().getDisplayMetrics().density;
    final float scaledPx = 8 * densityMultiplier;
    mSlot = slot;
    mNumberPain = new Paint();
    mNumberPain.setTextAlign(Paint.Align.CENTER);
    mNumberPain.setColor(context.getColor(R.drawable.notification_number_text_color));
    mNumberPain.setAntiAlias(true);
    mNumberPain.setTypeface(Typeface.DEFAULT_BOLD);
    mNumberPain.setTextSize(scaledPx);
    setNotification(sbn);
    setScaleType(ScaleType.CENTER);
    mDensity = context.getResources().getDisplayMetrics().densityDpi;
    Configuration configuration = context.getResources().getConfiguration();
    mNightMode = (configuration.uiMode & Configuration.UI_MODE_NIGHT_MASK)
            == Configuration.UI_MODE_NIGHT_YES;
    initializeDecorColor();
    reloadDimens();
    maybeUpdateIconScaleDimens();

    mObserver = GlobalSettingsObserver.getInstance(context);
}

/** Should always be preceded by {@link #reloadDimens()} */
private void maybeUpdateIconScaleDimens() {
    // We do not resize and scale system icons (on the right), only notification icons (on the
    // left).
    if (mNotification != null || mAlwaysScaleIcon) {
        updateIconScaleForNotifications();
    } else {
        updateIconScaleForSystemIcons();
    }
}

private void updateIconScaleForNotifications() {
    final float imageBounds = mIncreasedSize ?
            mStatusBarIconDrawingSizeIncreased : mStatusBarIconDrawingSize;
    final int outerBounds = mStatusBarIconSize;
    mIconScale = imageBounds / (float)outerBounds;
    updatePivot();
}

private void updateIconScaleForSystemIcons() {
    mIconScale = SYSTEM_ICON_SCALE;
}

public float getIconScaleIncreased() {
    return (float) mStatusBarIconDrawingSizeIncreased / mStatusBarIconDrawingSize;
}

public float getIconScale() {
    return mIconScale;
}

@Override
protected void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
    int density = newConfig.densityDpi;
    if (density != mDensity) {
        mDensity = density;
        reloadDimens();
        maybeUpdateIconScaleDimens();
        updateDrawable();
    }
    boolean nightMode = (newConfig.uiMode & Configuration.UI_MODE_NIGHT_MASK)
            == Configuration.UI_MODE_NIGHT_YES;
    if (nightMode != mNightMode) {
        mNightMode = nightMode;
        initializeDecorColor();
    }
}

private void reloadDimens() {
    boolean applyRadius = mDotRadius == mStaticDotRadius;
    Resources res = getResources();
    mStaticDotRadius = res.getDimensionPixelSize(R.dimen.overflow_dot_radius);
    mStatusBarIconSize = res.getDimensionPixelSize(R.dimen.status_bar_icon_size);
    mStatusBarIconDrawingSizeIncreased =
            res.getDimensionPixelSize(R.dimen.status_bar_icon_drawing_size_dark);
    mStatusBarIconDrawingSize =
            res.getDimensionPixelSize(R.dimen.status_bar_icon_drawing_size);
    if (applyRadius) {
        mDotRadius = mStaticDotRadius;
    }
}

public void setNotification(StatusBarNotification notification) {
    mNotification = notification;
    mShowNotificationCount = Settings.System.getIntForUser(mContext.getContentResolver(),
            Settings.System.STATUS_BAR_NOTIF_COUNT, 0, UserHandle.USER_CURRENT) == 1;
    if (notification != null) {
        setContentDescription(notification.getNotification());
    }
}

public StatusBarIconView(Context context, AttributeSet attrs) {
    super(context, attrs);
    mDozer = new NotificationIconDozeHelper(context);
    mBlocked = false;
    mAlwaysScaleIcon = true;
    reloadDimens();
    updateIconScaleForNotifications();
    mDensity = context.getResources().getDisplayMetrics().densityDpi;
}

private static boolean streq(String a, String b) {
    if (a == b) {
        return true;
    }
    if (a == null && b != null) {
        return false;
    }
    if (a != null && b == null) {
        return false;
    }
    return a.equals(b);
}

public boolean equalIcons(Icon a, Icon b) {
    if (a == b) return true;
    if (a.getType() != b.getType()) return false;
    switch (a.getType()) {
        case Icon.TYPE_RESOURCE:
            return a.getResPackage().equals(b.getResPackage()) && a.getResId() == b.getResId();
        case Icon.TYPE_URI:
            return a.getUriString().equals(b.getUriString());
        default:
            return false;
    }
}
/**
 * Returns whether the set succeeded.
 */
public boolean set(StatusBarIcon icon) {
    return set(icon, false);
}

private boolean set(StatusBarIcon icon, boolean force) {
    final boolean iconEquals = mIcon != null && equalIcons(mIcon.icon, icon.icon);
    final boolean levelEquals = iconEquals
            && mIcon.iconLevel == icon.iconLevel;
    final boolean visibilityEquals = mIcon != null
            && mIcon.visible == icon.visible;
    final boolean numberEquals = mIcon != null
            && mIcon.number == icon.number;
    if (icon == null) {
        return false;
    }
    mIcon = icon.clone();
    setContentDescription(icon.contentDescription);
    if (!iconEquals || force) {
        if (!updateDrawable(false /* no clear */)) return false;
        // we have to clear the grayscale tag since it may have changed
        setTag(R.id.icon_is_grayscale, null);
    }
    if (!levelEquals || force) {
        setImageLevel(icon.iconLevel);
    }

    if (!numberEquals || force) {
        if (icon.number > 1 && mShowNotificationCount) {
            if (mNumberBackground == null) {
                mNumberBackground = getContext().getResources().getDrawable(
                        R.drawable.ic_notification_overlay);
            }
            placeNumber();
        } else {
            mNumberBackground = null;
            mNumberText = null;
        }
        invalidate();
    }
    if (!visibilityEquals || force) {
        setVisibility(icon.visible && !mBlocked ? VISIBLE : GONE);
    }
    return true;
}

public void updateDrawable() {
    updateDrawable(true /* with clear */);
}

private boolean updateDrawable(boolean withClear) {
    if (mIcon == null) {
        return false;
    }
    Drawable drawable;
    try {
        drawable = getIcon(mIcon);
    } catch (OutOfMemoryError e) {
        Log.w(TAG, "OOM while inflating " + mIcon.icon + " for slot " + mSlot);
        return false;
    }

    if (drawable == null) {
        Log.w(TAG, "No icon for slot " + mSlot + "; " + mIcon.icon);
        return false;
    }
    if (withClear) {
        setImageDrawable(null);
    }
    setImageDrawable(drawable);
    return true;
}

public Icon getSourceIcon() {
    return mIcon.icon;
}

private Drawable getIcon(StatusBarIcon icon) {
    Context notifContext = mNotification != null ?
            mNotification.getPackageContext(getContext()) : getContext();
    return getIcon(getContext(), notifContext, icon);
}

/**
 * Returns the right icon to use for this item
 *
 * @param sysuiContext Context to use to get scale factor
 * @param context Context to use to get resources of notification icon
 * @return Drawable for this item, or null if the package or item could not
 *         be found
 */
public static Drawable getIcon(Context sysuiContext,
                               Context context, StatusBarIcon statusBarIcon) {
    int userId = statusBarIcon.user.getIdentifier();
    if (userId == UserHandle.USER_ALL) {
        userId = UserHandle.USER_SYSTEM;
    }

    Drawable icon;
    String pkgName = statusBarIcon.pkg;
    mIsSystemUI = pkgName.contains("systemui");
    try {
        icon = mIsSystemUI ? statusBarIcon.icon.loadDrawableAsUser(context, userId)
                : context.getPackageManager().getApplicationIcon(pkgName);
    } catch (android.content.pm.PackageManager.NameNotFoundException e) {
        icon = statusBarIcon.icon.loadDrawableAsUser(context, userId);
    }

    TypedValue typedValue = new TypedValue();
    sysuiContext.getResources().getValue(R.dimen.status_bar_icon_scale_factor,
            typedValue, true);
    float scaleFactor = typedValue.getFloat();

    // No need to scale the icon, so return it as is.
    if (scaleFactor == 1.f) {
        return icon;
    }

    return new ScalingDrawableWrapper(icon, scaleFactor);
}

public StatusBarIcon getStatusBarIcon() {
    return mIcon;
}

@Override
public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
    super.onInitializeAccessibilityEvent(event);
    if (mNotification != null) {
        event.setParcelableData(mNotification.getNotification());
    }
}

@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    super.onSizeChanged(w, h, oldw, oldh);
    if (mNumberBackground != null) {
        placeNumber();
    }
}

@Override
public void onRtlPropertiesChanged(int layoutDirection) {
    super.onRtlPropertiesChanged(layoutDirection);
    updateDrawable();
}

@Override
protected void onDraw(Canvas canvas) {
    if (mIconAppearAmount > 0.0f) {
        canvas.save();
        canvas.scale(mIconScale * mIconAppearAmount, mIconScale * mIconAppearAmount,
                getWidth() / 2, getHeight() / 2);
        super.onDraw(canvas);
        canvas.restore();
    }

    if (mNumberBackground != null) {
        mNumberBackground.draw(canvas);
        canvas.drawText(mNumberText, mNumberX, mNumberY, mNumberPain);
    }
    if (mDotAppearAmount != 0.0f) {
        float radius;
        float alpha = Color.alpha(mDecorColor) / 255.f;
        if (mDotAppearAmount <= 1.0f) {
            radius = mDotRadius * mDotAppearAmount;
        } else {
            float fadeOutAmount = mDotAppearAmount - 1.0f;
            alpha = alpha * (1.0f - fadeOutAmount);
            radius = NotificationUtils.interpolate(mDotRadius, getWidth() / 4, fadeOutAmount);
        }
        mDotPaint.setAlpha((int) (alpha * 255));
        canvas.drawCircle(mStatusBarIconSize / 2, getHeight() / 2, radius, mDotPaint);
    }
}

@Override
public void onAttachedToWindow() {
    super.onAttachedToWindow();

    if (mObserver != null) {
        mObserver.attach(this);
    }
}

@Override
public void onDetachedFromWindow() {
    super.onDetachedFromWindow();

    if (mObserver != null) {
        mObserver.detach(this);
    }
}

@Override
protected void debug(int depth) {
    super.debug(depth);
    Log.d("View", debugIndent(depth) + "slot=" + mSlot);
    Log.d("View", debugIndent(depth) + "icon=" + mIcon);
}

void placeNumber() {
    final String str;
    final int tooBig = getContext().getResources().getInteger(
            android.R.integer.status_bar_notification_info_maxnum);
    if (mIcon.number > tooBig) {
        str = getContext().getResources().getString(
                R.string.status_bar_notification_info_overflow);
    } else {
        NumberFormat f = NumberFormat.getIntegerInstance();
        str = f.format(mIcon.number);
    }
    mNumberText = str;

    final int w = getWidth();
    final int h = getHeight();
    final Rect r = new Rect();
    mNumberPain.getTextBounds(str, 0, str.length(), r);
    final int tw = r.right - r.left;
    final int th = r.bottom - r.top;
    mNumberBackground.getPadding(r);
    int dw = r.left + tw + r.right;
    if (dw < mNumberBackground.getMinimumWidth()) {
        dw = mNumberBackground.getMinimumWidth();
    }
    mNumberX = w-r.right-((dw-r.right-r.left)/2);
    int dh = r.top + th + r.bottom;
    if (dh < mNumberBackground.getMinimumWidth()) {
        dh = mNumberBackground.getMinimumWidth();
    }
    mNumberY = h-r.bottom-((dh-r.top-th-r.bottom)/2);
    mNumberBackground.setBounds(w-dw, h-dh, w, h);
}

private void setContentDescription(Notification notification) {
    if (notification != null) {
        String d = contentDescForNotification(mContext, notification);
        if (!TextUtils.isEmpty(d)) {
            setContentDescription(d);
        }
    }
}

public String toString() {
    return "StatusBarIconView(slot=" + mSlot + " icon=" + mIcon
            + " notification=" + mNotification + ")";
}

public StatusBarNotification getNotification() {
    return mNotification;
}

public String getSlot() {
    return mSlot;
}


public static String contentDescForNotification(Context c, Notification n) {
    String appName = "";
    try {
        Notification.Builder builder = Notification.Builder.recoverBuilder(c, n);
        appName = builder.loadHeaderAppName();
    } catch (RuntimeException e) {
        Log.e(TAG, "Unable to recover builder", e);
        // Trying to get the app name from the app info instead.
        Parcelable appInfo = n.extras.getParcelable(
                Notification.EXTRA_BUILDER_APPLICATION_INFO);
        if (appInfo instanceof ApplicationInfo) {
            appName = String.valueOf(((ApplicationInfo) appInfo).loadLabel(
                    c.getPackageManager()));
        }
    }

    CharSequence title = n.extras.getCharSequence(Notification.EXTRA_TITLE);
    CharSequence text = n.extras.getCharSequence(Notification.EXTRA_TEXT);
    CharSequence ticker = n.tickerText;

    // Some apps just put the app name into the title
    CharSequence titleOrText = TextUtils.equals(title, appName) ? text : title;

    CharSequence desc = !TextUtils.isEmpty(titleOrText) ? titleOrText
            : !TextUtils.isEmpty(ticker) ? ticker : "";

    return c.getString(R.string.accessibility_desc_notification_icon, appName, desc);
}


/**
 * Set the color that is used to draw decoration like the overflow dot. This will not be applied
 * to the drawable.
 */
public void setDecorColor(int iconTint) {
    mDecorColor = iconTint;
    updateDecorColor();
}

private void initializeDecorColor() {
    if (mNotification != null) {
        if (mNotification.getPackageName().contains("systemui")) {
            setDecorColor(getContext().getColor(mNightMode
                    ? com.android.internal.R.color.notification_default_color_dark
                    : com.android.internal.R.color.notification_default_color_light));
        }
    }
}

private void updateDecorColor() {
    int color = NotificationUtils.interpolateColors(mDecorColor, Color.WHITE, mDozeAmount);
    if (mDotPaint.getColor() != color) {
        mDotPaint.setColor(color);

        if (mDotAppearAmount != 0) {
            invalidate();
        }
    }
}

/**
 * Set the static color that should be used for the drawable of this icon if it's not
 * transitioning this also immediately sets the color.
 */
public void setStaticDrawableColor(int color) {
    if (mNotification == null) return;
    if (mNotification.getPackageName().contains("systemui")) { //if (mIsSystemUI) {
        mDrawableColor = color;
        setColorInternal(color);
        updateContrastedStaticColor();
        mIconColor = color;
        mDozer.setColor(color);
    }
}

private void setColorInternal(int color) {
    if (mNotification == null) return;
    if (mNotification.getPackageName().contains("systemui")) { //if (mIsSystemUI) {
        mCurrentSetColor = color;
        updateIconColor();
    }
}

private void updateIconColor() {
    if (mNotification == null) return;
    if (mNotification.getPackageName().contains("systemui")) { //if (mIsSystemUI) {
        if (mCurrentSetColor != NO_COLOR) {
            if (mMatrixColorFilter == null) {
                mMatrix = new float[4 * 5];
                mMatrixColorFilter = new ColorMatrixColorFilter(mMatrix);
            }
            int color = NotificationUtils.interpolateColors(
                    mCurrentSetColor, Color.WHITE, mDozeAmount);
            updateTintMatrix(mMatrix, color, DARK_ALPHA_BOOST * mDozeAmount);
            mMatrixColorFilter.setColorMatrixArray(mMatrix);
            setColorFilter(null);  // setColorFilter only invalidates if the instance changed.
            setColorFilter(mMatrixColorFilter);
        } else {
            mDozer.updateGrayscale(this, mDozeAmount);
        }
    }
}

/**
 * Updates {@param array} such that it represents a matrix that changes RGB to {@param color}
 * and multiplies the alpha channel with the color's alpha+{@param alphaBoost}.
 */
private static void updateTintMatrix(float[] array, int color, float alphaBoost) {
    Arrays.fill(array, 0);
    array[4] = Color.red(color);
    array[9] = Color.green(color);
    array[14] = Color.blue(color);
    array[18] = Color.alpha(color) / 255f + alphaBoost;
}

public void setIconColor(int iconColor, boolean animate) {
    if (mNotification == null) return;
    if (mNotification.getPackageName().contains("systemui")) { //if (mIsSystemUI) {
        if (mIconColor != iconColor) {
            mIconColor = iconColor;
            if (mColorAnimator != null) {
                mColorAnimator.cancel();
            }
            if (mCurrentSetColor == iconColor) {
                return;
            }
            if (animate && mCurrentSetColor != NO_COLOR) {
                mAnimationStartColor = mCurrentSetColor;
                mColorAnimator = ValueAnimator.ofFloat(0.0f, 1.0f);
                mColorAnimator.setInterpolator(Interpolators.FAST_OUT_SLOW_IN);
                mColorAnimator.setDuration(ANIMATION_DURATION_FAST);
                mColorAnimator.addUpdateListener(mColorUpdater);
                mColorAnimator.addListener(new AnimatorListenerAdapter() {
                    @Override
                    public void onAnimationEnd(Animator animation) {
                        mColorAnimator = null;
                        mAnimationStartColor = NO_COLOR;
                    }
                });
                mColorAnimator.start();
            } else {
                setColorInternal(iconColor);
            }
        }
    }
}

public int getStaticDrawableColor() {
    if (mNotification == null) return mDrawableColor;
    return mNotification.getPackageName().contains("systemui") /*mIsSystemUI*/ ? mDrawableColor : 0;
}

/**
 * A drawable color that passes GAR on a specific background.
 * This value is cached.
 *
 * @param backgroundColor Background to test against.
 * @return GAR safe version of {@link StatusBarIconView#getStaticDrawableColor()}.
 */
int getContrastedStaticDrawableColor(int backgroundColor) {
    if (mCachedContrastBackgroundColor != backgroundColor) {
        mCachedContrastBackgroundColor = backgroundColor;
        updateContrastedStaticColor();
    }
    return mContrastedDrawableColor;
}

private void updateContrastedStaticColor() {
    if (mNotification == null) return;
    if (mNotification.getPackageName().contains("systemui")) { //if (mIsSystemUI) {
        if (Color.alpha(mCachedContrastBackgroundColor) != 255) {
            mContrastedDrawableColor = mDrawableColor;
            return;
        }
        // We'll modify the color if it doesn't pass GAR
        int contrastedColor = mDrawableColor;
        if (!ContrastColorUtil.satisfiesTextContrast(mCachedContrastBackgroundColor,
                contrastedColor)) {
            float[] hsl = new float[3];
            ColorUtils.colorToHSL(mDrawableColor, hsl);
            // This is basically a light grey, pushing the color will only distort it.
            // Best thing to do in here is to fallback to the default color.
            if (hsl[1] < 0.2f) {
                contrastedColor = Notification.COLOR_DEFAULT;
            }
            boolean isDark = !ContrastColorUtil.isColorLight(mCachedContrastBackgroundColor);
            contrastedColor = ContrastColorUtil.resolveContrastColor(mContext,
                    contrastedColor, mCachedContrastBackgroundColor, isDark);
        }
        mContrastedDrawableColor = contrastedColor;
    }
}

@Override
public void setVisibleState(int state) {
    setVisibleState(state, true /* animate */, null /* endRunnable */);
}

public void setVisibleState(int state, boolean animate) {
    setVisibleState(state, animate, null);
}

@Override
public boolean hasOverlappingRendering() {
    return false;
}

public void setVisibleState(int visibleState, boolean animate, Runnable endRunnable) {
    setVisibleState(visibleState, animate, endRunnable, 0);
}

/**
 * Set the visibleState of this view.
 *
 * @param visibleState The new state.
 * @param animate Should we animate?
 * @param endRunnable The runnable to run at the end.
 * @param duration The duration of an animation or 0 if the default should be taken.
 */
public void setVisibleState(int visibleState, boolean animate, Runnable endRunnable,
                            long duration) {
    boolean runnableAdded = false;
    if (visibleState != mVisibleState) {
        mVisibleState = visibleState;
        if (mIconAppearAnimator != null) {
            mIconAppearAnimator.cancel();
        }
        if (mDotAnimator != null) {
            mDotAnimator.cancel();
        }
        if (animate) {
            float targetAmount = 0.0f;
            Interpolator interpolator = Interpolators.FAST_OUT_LINEAR_IN;
            if (visibleState == STATE_ICON) {
                targetAmount = 1.0f;
                interpolator = Interpolators.LINEAR_OUT_SLOW_IN;
            }
            float currentAmount = getIconAppearAmount();
            if (targetAmount != currentAmount) {
                mIconAppearAnimator = ObjectAnimator.ofFloat(this, ICON_APPEAR_AMOUNT,
                        currentAmount, targetAmount);
                mIconAppearAnimator.setInterpolator(interpolator);
                mIconAppearAnimator.setDuration(duration == 0 ? ANIMATION_DURATION_FAST
                        : duration);
                mIconAppearAnimator.addListener(new AnimatorListenerAdapter() {
                    @Override
                    public void onAnimationEnd(Animator animation) {
                        mIconAppearAnimator = null;
                        runRunnable(endRunnable);
                    }
                });
                mIconAppearAnimator.start();
                runnableAdded = true;
            }

            targetAmount = visibleState == STATE_ICON ? 2.0f : 0.0f;
            interpolator = Interpolators.FAST_OUT_LINEAR_IN;
            if (visibleState == STATE_DOT) {
                targetAmount = 1.0f;
                interpolator = Interpolators.LINEAR_OUT_SLOW_IN;
            }
            currentAmount = getDotAppearAmount();
            if (targetAmount != currentAmount) {
                mDotAnimator = ObjectAnimator.ofFloat(this, DOT_APPEAR_AMOUNT,
                        currentAmount, targetAmount);
                mDotAnimator.setInterpolator(interpolator);;
                mDotAnimator.setDuration(duration == 0 ? ANIMATION_DURATION_FAST
                        : duration);
                final boolean runRunnable = !runnableAdded;
                mDotAnimator.addListener(new AnimatorListenerAdapter() {
                    @Override
                    public void onAnimationEnd(Animator animation) {
                        mDotAnimator = null;
                        if (runRunnable) {
                            runRunnable(endRunnable);
                        }
                    }
                });
                mDotAnimator.start();
                runnableAdded = true;
            }
        } else {
            setIconAppearAmount(visibleState == STATE_ICON ? 1.0f : 0.0f);
            setDotAppearAmount(visibleState == STATE_DOT ? 1.0f
                    : visibleState == STATE_ICON ? 2.0f
                    : 0.0f);
        }
    }
    if (!runnableAdded) {
        runRunnable(endRunnable);
    }
}

private void runRunnable(Runnable runnable) {
    if (runnable != null) {
        runnable.run();
    }
}

public void setIconAppearAmount(float iconAppearAmount) {
    if (mIconAppearAmount != iconAppearAmount) {
        mIconAppearAmount = iconAppearAmount;
        invalidate();
    }
}

public float getIconAppearAmount() {
    return mIconAppearAmount;
}

public int getVisibleState() {
    return mVisibleState;
}

public void setDotAppearAmount(float dotAppearAmount) {
    if (mDotAppearAmount != dotAppearAmount) {
        mDotAppearAmount = dotAppearAmount;
        invalidate();
    }
}

@Override
public void setVisibility(int visibility) {
    super.setVisibility(visibility);
    if (mOnVisibilityChangedListener != null) {
        mOnVisibilityChangedListener.onVisibilityChanged(visibility);
    }
}

public float getDotAppearAmount() {
    return mDotAppearAmount;
}

public void setOnVisibilityChangedListener(OnVisibilityChangedListener listener) {
    mOnVisibilityChangedListener = listener;
}

public void setDozing(boolean dozing, boolean fade, long delay) {
    mDozer.setDozing(f -> {
        mDozeAmount = f;
        updateDecorColor();
        updateIconColor();
        updateAllowAnimation();
    }, dozing, fade, delay, this);
}

private void updateAllowAnimation() {
    if (mDozeAmount == 0 || mDozeAmount == 1) {
        setAllowAnimation(mDozeAmount == 0);
    }
}

/**
 * This method returns the drawing rect for the view which is different from the regular
 * drawing rect, since we layout all children at position 0 and usually the translation is
 * neglected. The standard implementation doesn't account for translation.
 *
 * @param outRect The (scrolled) drawing bounds of the view.
 */
@Override
public void getDrawingRect(Rect outRect) {
    super.getDrawingRect(outRect);
    float translationX = getTranslationX();
    float translationY = getTranslationY();
    outRect.left += translationX;
    outRect.right += translationX;
    outRect.top += translationY;
    outRect.bottom += translationY;
}

public void setIsInShelf(boolean isInShelf) {
    mIsInShelf = isInShelf;
}

public boolean isInShelf() {
    return mIsInShelf;
}

@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    super.onLayout(changed, left, top, right, bottom);
    if (mLayoutRunnable != null) {
        mLayoutRunnable.run();
        mLayoutRunnable = null;
    }
    updatePivot();
}

private void updatePivot() {
    setPivotX((1 - mIconScale) / 2.0f * getWidth());
    setPivotY((getHeight() - mIconScale * getWidth()) / 2.0f);
}

public void executeOnLayout(Runnable runnable) {
    mLayoutRunnable = runnable;
}

public void setDismissed() {
    mDismissed = true;
    if (mOnDismissListener != null) {
        mOnDismissListener.run();
    }
}

public boolean isDismissed() {
    return mDismissed;
}

public void setOnDismissListener(Runnable onDismissListener) {
    mOnDismissListener = onDismissListener;
}

@Override
public void onDarkChanged(Rect area, float darkIntensity, int tint) {
    int areaTint = getTint(area, this, tint);
    ColorStateList color = ColorStateList.valueOf(areaTint);
    setImageTintList(color);
    setDecorColor(areaTint);
}

@Override
public boolean isIconVisible() {
    return mIcon != null && mIcon.visible;
}

@Override
public boolean isIconBlocked() {
    return mBlocked;
}

public void setIncreasedSize(boolean increasedSize) {
    mIncreasedSize = increasedSize;
    maybeUpdateIconScaleDimens();
}

public interface OnVisibilityChangedListener {
    void onVisibilityChanged(int newVisibility);
}

static class GlobalSettingsObserver extends ContentObserver {
    private static GlobalSettingsObserver sInstance;
    private ArrayList<StatusBarIconView> mIconViews = new ArrayList<StatusBarIconView>();
    private Context mContext;

    GlobalSettingsObserver(Handler handler, Context context) {
        super(handler);
        mContext = context.getApplicationContext();
    }

    static GlobalSettingsObserver getInstance(Context context) {
        if (sInstance == null) {
            sInstance = new GlobalSettingsObserver(new Handler(), context);
        }
        return sInstance;
    }

    void attach(StatusBarIconView sbiv) {
        if (mIconViews.isEmpty()) {
            observe();
        }
        mIconViews.add(sbiv);
    }

    void detach(StatusBarIconView sbiv) {
        mIconViews.remove(sbiv);
        if (mIconViews.isEmpty()) {
            unobserve();
        }
    }

    void observe() {
        mContext.getContentResolver().registerContentObserver(
                Settings.System.getUriFor(Settings.System.STATUS_BAR_NOTIF_COUNT),
                false, this);
    }

    void unobserve() {
        mContext.getContentResolver().unregisterContentObserver(this);
    }

    @Override
    public void onChange(boolean selfChange) {
        boolean showIconCount = Settings.System.getIntForUser(mContext.getContentResolver(),
                Settings.System.STATUS_BAR_NOTIF_COUNT, 0, UserHandle.USER_CURRENT) == 1;
        for (StatusBarIconView sbiv : mIconViews) {
            sbiv.mShowNotificationCount = showIconCount;
            sbiv.set(sbiv.mIcon, true);
        }
    }
}

org.jf.dexlib2.DexFileFactory$DexFileNotFoundException: NetworkServerManager.dex does not exist
	at org.jf.dexlib2.DexFileFactory.loadDexFile(DexFileFactory.java:83)
	at org.jf.dexlib2.DexFileFactory.loadDexFile(DexFileFactory.java:61)
	at org.ollide.java2smali.Dex2SmaliHelper.disassembleDexFile(Dex2SmaliHelper.kt:24)
	at org.ollide.java2smali.DexCompiler$onProjectBuildComplete$1.run(DexCompiler.kt:67)
	at com.intellij.openapi.command.WriteCommandAction.lambda$runWriteCommandAction$5(WriteCommandAction.java:353)
	at com.intellij.openapi.command.WriteCommandAction$BuilderImpl$1.run(WriteCommandAction.java:107)
	at com.intellij.openapi.application.RunResult.run(RunResult.java:35)
	at com.intellij.openapi.command.WriteCommandAction.lambda$null$1(WriteCommandAction.java:248)
	at com.intellij.openapi.application.impl.ApplicationImpl.runWriteAction(ApplicationImpl.java:976)
	at com.intellij.openapi.command.WriteCommandAction.lambda$performWriteCommandAction$2(WriteCommandAction.java:247)
	at com.intellij.openapi.command.WriteCommandAction.lambda$doExecuteCommand$4(WriteCommandAction.java:305)
	at com.intellij.openapi.command.impl.CoreCommandProcessor.executeCommand(CoreCommandProcessor.java:220)
	at com.intellij.openapi.command.impl.CoreCommandProcessor.executeCommand(CoreCommandProcessor.java:188)
	at com.intellij.openapi.command.WriteCommandAction.doExecuteCommand(WriteCommandAction.java:307)
	at com.intellij.openapi.command.WriteCommandAction.performWriteCommandAction(WriteCommandAction.java:246)
	at com.intellij.openapi.command.WriteCommandAction.execute(WriteCommandAction.java:227)
	at com.intellij.openapi.command.WriteCommandAction$BuilderImpl.run(WriteCommandAction.java:109)
	at com.intellij.openapi.command.WriteCommandAction.runWriteCommandAction(WriteCommandAction.java:353)
	at com.intellij.openapi.command.WriteCommandAction.runWriteCommandAction(WriteCommandAction.java:345)
	at org.ollide.java2smali.DexCompiler.onProjectBuildComplete(DexCompiler.kt:66)
	at org.ollide.java2smali.DexCompiler.access$onProjectBuildComplete(DexCompiler.kt:22)
	at org.ollide.java2smali.DexCompiler$run$1.invoke(DexCompiler.kt:26)
	at org.ollide.java2smali.DexCompiler$run$1.invoke(DexCompiler.kt:22)
	at org.ollide.java2smali.DexCompiler$buildModule$1.accept(DexCompiler.kt:46)
	at org.ollide.java2smali.DexCompiler$buildModule$1.accept(DexCompiler.kt:22)
	at org.jetbrains.concurrency.AsyncPromise$onSuccess$1.accept(AsyncPromise.kt:82)
	at org.jetbrains.concurrency.AsyncPromise$onSuccess$1.accept(AsyncPromise.kt:14)
	at java.base/java.util.concurrent.CompletableFuture.uniWhenComplete(CompletableFuture.java:859)
	at java.base/java.util.concurrent.CompletableFuture$UniWhenComplete.tryFire(CompletableFuture.java:837)
	at java.base/java.util.concurrent.CompletableFuture.postComplete(CompletableFuture.java:506)
	at java.base/java.util.concurrent.CompletableFuture.complete(CompletableFuture.java:2073)
	at org.jetbrains.concurrency.AsyncPromise.setResult(AsyncPromise.kt:147)
	at com.intellij.task.impl.ProjectTaskManagerImpl$ResultConsumer.lambda$notify$1(ProjectTaskManagerImpl.java:353)
	at com.intellij.openapi.application.TransactionGuardImpl$2.run(TransactionGuardImpl.java:201)
	at com.intellij.openapi.application.impl.ApplicationImpl.runIntendedWriteActionOnCurrentThread(ApplicationImpl.java:831)
	at com.intellij.openapi.application.impl.ApplicationImpl.lambda$invokeLater$4(ApplicationImpl.java:310)
	at com.intellij.openapi.application.impl.FlushQueue.doRun(FlushQueue.java:80)
	at com.intellij.openapi.application.impl.FlushQueue.runNextEvent(FlushQueue.java:128)
	at com.intellij.openapi.application.impl.FlushQueue.flushNow(FlushQueue.java:46)
	at com.intellij.openapi.application.impl.FlushQueue$FlushNow.run(FlushQueue.java:184)
	at java.desktop/java.awt.event.InvocationEvent.dispatch(InvocationEvent.java:313)
	at java.desktop/java.awt.EventQueue.dispatchEventImpl(EventQueue.java:776)
	at java.desktop/java.awt.EventQueue$4.run(EventQueue.java:727)
	at java.desktop/java.awt.EventQueue$4.run(EventQueue.java:721)
	at java.base/java.security.AccessController.doPrivileged(Native Method)
	at java.base/java.security.ProtectionDomain$JavaSecurityAccessImpl.doIntersectionPrivilege(ProtectionDomain.java:85)
	at java.desktop/java.awt.EventQueue.dispatchEvent(EventQueue.java:746)
	at com.intellij.ide.IdeEventQueue.defaultDispatchEvent(IdeEventQueue.java:974)
	at com.intellij.ide.IdeEventQueue._dispatchEvent(IdeEventQueue.java:847)
	at com.intellij.ide.IdeEventQueue.lambda$null$8(IdeEventQueue.java:449)
	at com.intellij.openapi.progress.impl.CoreProgressManager.computePrioritized(CoreProgressManager.java:741)
	at com.intellij.ide.IdeEventQueue.lambda$dispatchEvent$9(IdeEventQueue.java:448)
	at com.intellij.openapi.application.impl.ApplicationImpl.runIntendedWriteActionOnCurrentThread(ApplicationImpl.java:831)
	at com.intellij.ide.IdeEventQueue.dispatchEvent(IdeEventQueue.java:496)
	at java.desktop/java.awt.EventDispatchThread.pumpOneEventForFilters(EventDispatchThread.java:203)
	at java.desktop/java.awt.EventDispatchThread.pumpEventsForFilter(EventDispatchThread.java:124)
	at java.desktop/java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:113)
	at java.desktop/java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:109)
	at java.desktop/java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:101)
	at java.desktop/java.awt.EventDispatchThread.run(EventDispatchThread.java:90)

org.jf.dexlib2.DexFileFactory$DexFileNotFoundException: NetworkServerManager.dex does not exist
	at org.jf.dexlib2.DexFileFactory.loadDexFile(DexFileFactory.java:83)
	at org.jf.dexlib2.DexFileFactory.loadDexFile(DexFileFactory.java:61)
	at org.ollide.java2smali.Dex2SmaliHelper.disassembleDexFile(Dex2SmaliHelper.kt:24)
	at org.ollide.java2smali.DexCompiler$onProjectBuildComplete$1.run(DexCompiler.kt:67)
	at com.intellij.openapi.command.WriteCommandAction.lambda$runWriteCommandAction$5(WriteCommandAction.java:368)
	at com.intellij.openapi.command.WriteCommandAction$BuilderImpl$1.run(WriteCommandAction.java:125)
	at com.intellij.openapi.application.RunResult.run(RunResult.java:35)
	at com.intellij.openapi.command.WriteCommandAction.lambda$null$1(WriteCommandAction.java:264)
	at com.intellij.openapi.application.impl.ApplicationImpl.runWriteAction(ApplicationImpl.java:994)
	at com.intellij.openapi.command.WriteCommandAction.lambda$performWriteCommandAction$2(WriteCommandAction.java:263)
	at com.intellij.openapi.command.WriteCommandAction.lambda$doExecuteCommand$4(WriteCommandAction.java:320)
	at com.intellij.openapi.command.impl.CoreCommandProcessor.executeCommand(CoreCommandProcessor.java:220)
	at com.intellij.openapi.command.impl.CoreCommandProcessor.executeCommand(CoreCommandProcessor.java:188)
	at com.intellij.openapi.command.WriteCommandAction.doExecuteCommand(WriteCommandAction.java:322)
	at com.intellij.openapi.command.WriteCommandAction.performWriteCommandAction(WriteCommandAction.java:263)
	at com.intellij.openapi.command.WriteCommandAction.execute(WriteCommandAction.java:245)
	at com.intellij.openapi.command.WriteCommandAction$BuilderImpl.run(WriteCommandAction.java:127)
	at com.intellij.openapi.command.WriteCommandAction.runWriteCommandAction(WriteCommandAction.java:368)
	at com.intellij.openapi.command.WriteCommandAction.runWriteCommandAction(WriteCommandAction.java:360)
	at org.ollide.java2smali.DexCompiler.onProjectBuildComplete(DexCompiler.kt:66)
	at org.ollide.java2smali.DexCompiler.access$onProjectBuildComplete(DexCompiler.kt:22)
	at org.ollide.java2smali.DexCompiler$run$1.invoke(DexCompiler.kt:26)
	at org.ollide.java2smali.DexCompiler$run$1.invoke(DexCompiler.kt:22)
	at org.ollide.java2smali.DexCompiler$buildModule$1.accept(DexCompiler.kt:46)
	at org.ollide.java2smali.DexCompiler$buildModule$1.accept(DexCompiler.kt:22)
	at org.jetbrains.concurrency.AsyncPromise$onSuccess$1.accept(AsyncPromise.kt:58)
	at org.jetbrains.concurrency.AsyncPromise$onSuccess$1.accept(AsyncPromise.kt:13)
	at java.util.concurrent.CompletableFuture.uniWhenComplete(CompletableFuture.java:760)
	at java.util.concurrent.CompletableFuture$UniWhenComplete.tryFire(CompletableFuture.java:736)
	at java.util.concurrent.CompletableFuture.postComplete(CompletableFuture.java:474)
	at java.util.concurrent.CompletableFuture.complete(CompletableFuture.java:1962)
	at org.jetbrains.concurrency.AsyncPromise.setResult(AsyncPromise.kt:130)
	at org.ollide.java2smali.SupportProjectTaskManager$Notification.finished(SupportProjectTaskManager.kt:35)
	at com.intellij.task.impl.ProjectTaskManagerImpl$ListenerNotificator.lambda$notify$1(ProjectTaskManagerImpl.java:325)
	at com.intellij.ui.GuiUtils.invokeLaterIfNeeded(GuiUtils.java:323)
	at com.intellij.task.impl.ProjectTaskManagerImpl$ListenerNotificator.notify(ProjectTaskManagerImpl.java:320)
	at com.intellij.task.impl.ProjectTaskManagerImpl$ListenerNotificator.finished(ProjectTaskManagerImpl.java:315)
	at com.intellij.task.impl.ProjectTaskManagerImpl$ProjectTaskResultsAggregator.add(ProjectTaskManagerImpl.java:390)
	at com.intellij.task.impl.ProjectTaskManagerImpl$ProjectTaskRunnerNotification.finished(ProjectTaskManagerImpl.java:360)
	at com.intellij.task.impl.JpsProjectTaskRunner.lambda$run$0(JpsProjectTaskRunner.java:74)
	at com.intellij.compiler.CompilerManagerImpl$ListenerNotificator.finished(CompilerManagerImpl.java:533)
	at com.intellij.compiler.impl.CompileDriver.make(CompileDriver.java:96)
	at com.intellij.compiler.impl.CompileDriver.make(CompileDriver.java:88)
	at com.intellij.compiler.CompilerManagerImpl.make(CompilerManagerImpl.java:252)
	at com.intellij.task.impl.JpsProjectTaskRunner.runModulesBuildTasks(JpsProjectTaskRunner.java:129)
	at com.intellij.task.impl.JpsProjectTaskRunner.lambda$run$1(JpsProjectTaskRunner.java:82)
	at com.intellij.openapi.application.TransactionGuardImpl$2.run(TransactionGuardImpl.java:312)
	at com.intellij.openapi.application.impl.LaterInvocator$FlushQueue.doRun(LaterInvocator.java:433)
	at com.intellij.openapi.application.impl.LaterInvocator$FlushQueue.runNextEvent(LaterInvocator.java:416)
	at com.intellij.openapi.application.impl.LaterInvocator$FlushQueue.run(LaterInvocator.java:399)
	at java.awt.event.InvocationEvent.dispatch(InvocationEvent.java:311)
	at java.awt.EventQueue.dispatchEventImpl(EventQueue.java:764)
	at java.awt.EventQueue.access$500(EventQueue.java:98)
	at java.awt.EventQueue$3.run(EventQueue.java:715)
	at java.awt.EventQueue$3.run(EventQueue.java:709)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.security.ProtectionDomain$JavaSecurityAccessImpl.doIntersectionPrivilege(ProtectionDomain.java:74)
	at java.awt.EventQueue.dispatchEvent(EventQueue.java:734)
	at com.intellij.ide.IdeEventQueue.defaultDispatchEvent(IdeEventQueue.java:878)
	at com.intellij.ide.IdeEventQueue._dispatchEvent(IdeEventQueue.java:827)
	at com.intellij.ide.IdeEventQueue.lambda$dispatchEvent$8(IdeEventQueue.java:466)
	at com.intellij.openapi.progress.impl.CoreProgressManager.computePrioritized(CoreProgressManager.java:704)
	at com.intellij.ide.IdeEventQueue.dispatchEvent(IdeEventQueue.java:465)
	at java.awt.EventDispatchThread.pumpOneEventForFilters(EventDispatchThread.java:205)
	at java.awt.EventDispatchThread.pumpEventsForFilter(EventDispatchThread.java:116)
	at java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:105)
	at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:101)
	at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:93)
	at java.awt.EventDispatchThread.run(EventDispatchThread.java:82)

org.jf.dexlib2.DexFileFactory$DexFileNotFoundException: Tracer.dex does not exist
	at org.jf.dexlib2.DexFileFactory.loadDexFile(DexFileFactory.java:83)
	at org.jf.dexlib2.DexFileFactory.loadDexFile(DexFileFactory.java:61)
	at org.ollide.java2smali.Dex2SmaliHelper.disassembleDexFile(Dex2SmaliHelper.kt:24)
	at org.ollide.java2smali.DexCompiler$onProjectBuildComplete$1.run(DexCompiler.kt:67)
	at com.intellij.openapi.command.WriteCommandAction.lambda$runWriteCommandAction$4(WriteCommandAction.java:347)
	at com.intellij.openapi.command.WriteCommandAction$BuilderImpl.lambda$doRunWriteCommandAction$1(WriteCommandAction.java:143)
	at com.intellij.openapi.application.impl.ApplicationImpl.runWriteAction(ApplicationImpl.java:959)
	at com.intellij.openapi.command.WriteCommandAction$BuilderImpl.lambda$doRunWriteCommandAction$2(WriteCommandAction.java:141)
	at com.intellij.openapi.command.impl.CoreCommandProcessor.executeCommand(CoreCommandProcessor.java:216)
	at com.intellij.openapi.command.impl.CoreCommandProcessor.executeCommand(CoreCommandProcessor.java:182)
	at com.intellij.openapi.command.WriteCommandAction$BuilderImpl.doRunWriteCommandAction(WriteCommandAction.java:150)
	at com.intellij.openapi.command.WriteCommandAction$BuilderImpl.run(WriteCommandAction.java:117)
	at com.intellij.openapi.command.WriteCommandAction.runWriteCommandAction(WriteCommandAction.java:347)
	at com.intellij.openapi.command.WriteCommandAction.runWriteCommandAction(WriteCommandAction.java:335)
	at org.ollide.java2smali.DexCompiler.onProjectBuildComplete(DexCompiler.kt:66)
	at org.ollide.java2smali.DexCompiler.access$onProjectBuildComplete(DexCompiler.kt:22)
	at org.ollide.java2smali.DexCompiler$run$1.invoke(DexCompiler.kt:26)
	at org.ollide.java2smali.DexCompiler$run$1.invoke(DexCompiler.kt:22)
	at org.ollide.java2smali.DexCompiler$buildModule$1.accept(DexCompiler.kt:46)
	at org.ollide.java2smali.DexCompiler$buildModule$1.accept(DexCompiler.kt:22)
	at org.jetbrains.concurrency.AsyncPromise$onSuccess$1.accept(AsyncPromise.kt:84)
	at org.jetbrains.concurrency.AsyncPromise$onSuccess$1.accept(AsyncPromise.kt:16)
	at java.base/java.util.concurrent.CompletableFuture.uniWhenComplete(CompletableFuture.java:859)
	at java.base/java.util.concurrent.CompletableFuture$UniWhenComplete.tryFire(CompletableFuture.java:837)
	at java.base/java.util.concurrent.CompletableFuture.postComplete(CompletableFuture.java:506)
	at java.base/java.util.concurrent.CompletableFuture.complete(CompletableFuture.java:2073)
	at org.jetbrains.concurrency.AsyncPromise.setResult(AsyncPromise.kt:149)
	at com.intellij.task.impl.ProjectTaskManagerImpl$ResultConsumer.lambda$notify$1(ProjectTaskManagerImpl.java:351)
	at com.intellij.openapi.application.TransactionGuardImpl.runWithWritingAllowed(TransactionGuardImpl.java:218)
	at com.intellij.openapi.application.TransactionGuardImpl.access$200(TransactionGuardImpl.java:21)
	at com.intellij.openapi.application.TransactionGuardImpl$2.run(TransactionGuardImpl.java:200)
	at com.intellij.openapi.application.impl.ApplicationImpl.runIntendedWriteActionOnCurrentThread(ApplicationImpl.java:781)
	at com.intellij.openapi.application.impl.ApplicationImpl.lambda$invokeLater$4(ApplicationImpl.java:319)
	at com.intellij.openapi.application.impl.FlushQueue.doRun(FlushQueue.java:84)
	at com.intellij.openapi.application.impl.FlushQueue.runNextEvent(FlushQueue.java:133)
	at com.intellij.openapi.application.impl.FlushQueue.flushNow(FlushQueue.java:46)
	at com.intellij.openapi.application.impl.FlushQueue$FlushNow.run(FlushQueue.java:189)
	at java.desktop/java.awt.event.InvocationEvent.dispatch(InvocationEvent.java:313)
	at java.desktop/java.awt.EventQueue.dispatchEventImpl(EventQueue.java:776)
	at java.desktop/java.awt.EventQueue$4.run(EventQueue.java:727)
	at java.desktop/java.awt.EventQueue$4.run(EventQueue.java:721)
	at java.base/java.security.AccessController.doPrivileged(Native Method)
	at java.base/java.security.ProtectionDomain$JavaSecurityAccessImpl.doIntersectionPrivilege(ProtectionDomain.java:85)
	at java.desktop/java.awt.EventQueue.dispatchEvent(EventQueue.java:746)
	at com.intellij.ide.IdeEventQueue.defaultDispatchEvent(IdeEventQueue.java:969)
	at com.intellij.ide.IdeEventQueue._dispatchEvent(IdeEventQueue.java:839)
	at com.intellij.ide.IdeEventQueue.lambda$dispatchEvent$8(IdeEventQueue.java:449)
	at com.intellij.openapi.progress.impl.CoreProgressManager.computePrioritized(CoreProgressManager.java:808)
	at com.intellij.ide.IdeEventQueue.lambda$dispatchEvent$9(IdeEventQueue.java:448)
	at com.intellij.openapi.application.impl.ApplicationImpl.runIntendedWriteActionOnCurrentThread(ApplicationImpl.java:781)
	at com.intellij.ide.IdeEventQueue.dispatchEvent(IdeEventQueue.java:496)
	at java.desktop/java.awt.EventDispatchThread.pumpOneEventForFilters(EventDispatchThread.java:203)
	at java.desktop/java.awt.EventDispatchThread.pumpEventsForFilter(EventDispatchThread.java:124)
	at java.desktop/java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:113)
	at java.desktop/java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:109)
	at java.desktop/java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:101)
	at java.desktop/java.awt.EventDispatchThread.run(EventDispatchThread.java:90)

Error:Gradle: A problem occurred configuring root project 'xxx'.
Could not resolve all files for configuration ':classpath'.
Could not find com.android.tools.build:gradle:3.0.1.
Searched in the following locations:
https://jcenter.bintray.com/com/android/tools/build/gradle/3.0.1/gradle-3.0.1.pom
https://jcenter.bintray.com/com/android/tools/build/gradle/3.0.1/gradle-3.0.1.jar
Required by:
project :

package vm.manager;

import android.content.DialogInterface;

/**
 * Created by luca on 27.07.17.
 */

public class Test {
    public static void main(String[] args) {
        int test = 1;
        switch(test) {
            case 1:
                int a = 200;
                break;
            case 2:
                int b = 300;
                DialogInterface.OnClickListener v2 = new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int action) {
                        int vmPos = 0; // ???
                        switch (action) {
                            case 0:
                                //VMManagerActivityOffline.
                                break;
                            case 1:
                                break;
                        }
                    }
                };
                break;
            case 3:
                int c = 400;
                break;
        }
    }
}

    new-instance v3, Lvm/manager/Test$1;

    invoke-direct {v3}, Lvm/manager/Test$1;-><init>()V

    .line 31
    .local v3, "v2":Landroid/content/DialogInterface$OnClickListener;