Hyouka private v5.8.9 - AvatarAndNameImage.java 源代码

package com.beint.project.screens.groupcall;

import android.animation.Animator;
import android.animation.ArgbEvaluator;
import android.animation.ObjectAnimator;
import android.animation.ValueAnimator;
import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.text.TextPaint;
import android.text.TextUtils;
import android.view.MotionEvent;
import com.beint.project.MainApplication;
import com.beint.project.core.Categories.Int_UtilsKt;
import com.beint.project.core.Categories.View_UtilsKt;
import com.beint.project.core.Conference.ConferenceMemberHoldState;
import com.beint.project.core.Conference.ConferenceMemberMuteState;
import com.beint.project.core.Conference.IAvatarAndNameImage;
import com.beint.project.core.ZFramework.ZTimer;
import com.beint.project.core.ZFramework.ZView;
import com.beint.project.core.managers.AvatarManager;
import com.beint.project.core.managers.AvatarSizeType;
import com.beint.project.core.managers.ConferenceManager;
import com.beint.project.core.managers.DrawableManager;
import com.beint.project.core.managers.PaintManager;
import com.beint.project.core.services.impl.ZangiMessagingService;
import com.beint.project.core.utils.AvatarImageView;
import com.beint.project.core.utils.CacheManager;
import com.beint.project.core.utils.DispatchKt;
import com.beint.project.core.utils.DispatchQueue;
import com.beint.project.core.utils.NotificationCenter;
import java.lang.ref.WeakReference;

@SuppressLint({"ViewConstructor"})
public final class AvatarAndNameImage extends ZView implements IAvatarAndNameImage {
    private ValueAnimator anim1;
    private ValueAnimator anim2;
    private int animatedColor;
    private final RectF animatedRoundRectF;
    private int animatedValue;
    private ZTimer animationTimer;
    private Bitmap avatarBitmap;
    private AvatarBitmapEnum avatarBitmapType;
    private Bitmap backgroundBitmap;
    private String callingText;
    private Drawable cancelDrawable;
    private String cancelText;
    private Canvas canvas;
    private final int circleImageSize;
    private final float circleStrokeWidth;
    private int colorResourceId;
    private AvatarAndNameImageDelegate delegate;
    private Rect dstRect;
    private boolean isAnim2End;
    private boolean isAnimatedColor1;
    private boolean isAnimatedColor2;
    private boolean isAnimating;
    private boolean isPersonal;
    private int iteHeight;
    private boolean itemIsBottom;
    private int itemWith;
    private String key;
    private ConferenceMemberHoldState mHoldState;
    private ConferenceMemberMuteState mMuteState;
    private String name;
    private final fb.f paintAnimateVoiceBottom$delegate;
    private final fb.f paintAnimateVoiceTop$delegate;
    private final Paint paintCallingAndCancel;
    private final Paint paintDefaultAvatarBackground;
    private final TextPaint paintUserName;
    private final fb.f paintVoice$delegate;
    private Integer position;
    private final int rectImageSize;
    private final RectF roundRectF;
    private float roundRectRadius;
    private Rect srcRect;
    private AvatarImageView.Companion.AwatarWorkerTask task;
    private final int topBottomMargin;
    private int txtHeight;

    public interface AvatarAndNameImageDelegate {
        void cancelButtonClick();
    }

    public interface AvatarListenerInCall {
        void updateAvatar(Bitmap bitmap, boolean z);
    }

    public class WhenMappings {
        public static final int[] $EnumSwitchMapping$0;
        public static final int[] $EnumSwitchMapping$1;
        public static final int[] $EnumSwitchMapping$2;

        static {
            int[] iArr = new int[ConferenceMemberMuteState.values().length];
            try {
                iArr[ConferenceMemberMuteState.memberMute.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                iArr[ConferenceMemberMuteState.memberUnmute.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            $EnumSwitchMapping$0 = iArr;
            int[] iArr2 = new int[ConferenceMemberHoldState.values().length];
            try {
                iArr2[ConferenceMemberHoldState.memberHold.ordinal()] = 1;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                iArr2[ConferenceMemberHoldState.memberUnhold.ordinal()] = 2;
            } catch (NoSuchFieldError unused4) {
            }
            $EnumSwitchMapping$1 = iArr2;
            int[] iArr3 = new int[AvatarBitmapEnum.values().length];
            try {
                iArr3[AvatarBitmapEnum.CIRCLE.ordinal()] = 1;
            } catch (NoSuchFieldError unused5) {
            }
            try {
                iArr3[AvatarBitmapEnum.ROUND_RECT.ordinal()] = 2;
            } catch (NoSuchFieldError unused6) {
            }
            $EnumSwitchMapping$2 = iArr3;
        }
    }

    public AvatarAndNameImage(Context context) {
        super(context);
        kotlin.jvm.internal.k.f(context, "context");
        this.roundRectRadius = Int_UtilsKt.getDp(4.0f);
        this.avatarBitmapType = AvatarBitmapEnum.CIRCLE;
        this.circleImageSize = Int_UtilsKt.getDp(75);
        this.rectImageSize = Int_UtilsKt.getDp(72);
        this.topBottomMargin = Int_UtilsKt.getDp(18);
        this.cancelText = "";
        this.callingText = "";
        this.circleStrokeWidth = Int_UtilsKt.getDp(4.2f);
        this.name = "";
        this.animatedColor = getVoiceAnimateColor(false);
        this.animatedValue = Int_UtilsKt.getDp(0);
        this.paintVoice$delegate = fb.g.a(new AvatarAndNameImage$paintVoice$2(this));
        this.paintAnimateVoiceTop$delegate = fb.g.a(new AvatarAndNameImage$paintAnimateVoiceTop$2(this));
        this.paintAnimateVoiceBottom$delegate = fb.g.a(new AvatarAndNameImage$paintAnimateVoiceBottom$2(this));
        PaintManager paintManager = PaintManager.INSTANCE;
        this.paintDefaultAvatarBackground = paintManager.getDefaultAvatarBackground();
        this.paintUserName = paintManager.getPaintInAvatarAndNameUserName();
        this.paintCallingAndCancel = paintManager.getPaintInAvatarAndNameCallingCancel();
        this.animatedRoundRectF = new RectF();
        this.roundRectF = new RectF();
        this.mMuteState = ConferenceMemberMuteState.memberUnmute;
        this.mHoldState = ConferenceMemberHoldState.memberUnhold;
        this.cancelDrawable = androidx.core.content.a.e(context, t1.e.call_cancel_btn_beckground);
        String string = context.getString(t1.h.cancel);
        kotlin.jvm.internal.k.e(string, "context.getString(R.string.cancel)");
        this.cancelText = string;
        createAnim1();
        createAnim2();
    }

    private final void createAnim1() {
        ValueAnimator ofInt = ValueAnimator.ofInt(Int_UtilsKt.getDp(76) + 1, Int_UtilsKt.getDp(76) + Int_UtilsKt.getDp(4));
        this.anim1 = ofInt;
        if (ofInt != null) {
            ofInt.setDuration(400L);
        }
        ValueAnimator valueAnimator = this.anim1;
        if (valueAnimator != null) {
            valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                @Override
                public final void onAnimationUpdate(ValueAnimator valueAnimator2) {
                    AvatarAndNameImage.createAnim1$lambda$1(AvatarAndNameImage.this, valueAnimator2);
                }
            });
        }
        ValueAnimator valueAnimator2 = this.anim1;
        if (valueAnimator2 != null) {
            valueAnimator2.addListener(new AvatarAndNameImage$createAnim1$2(this));
        }
    }

    public static final void createAnim1$lambda$1(AvatarAndNameImage avatarAndNameImage, ValueAnimator valueAnimator) {
        kotlin.jvm.internal.k.f(avatarAndNameImage, "this$0");
        kotlin.jvm.internal.k.f(valueAnimator, "it");
        Object animatedValue = valueAnimator.getAnimatedValue();
        kotlin.jvm.internal.k.d(animatedValue, "null cannot be cast to non-null type kotlin.Int");
        avatarAndNameImage.setAnimatedValue(((Integer) animatedValue).intValue());
    }

    public final void createAnim2() {
        ValueAnimator ofInt = ValueAnimator.ofInt(Int_UtilsKt.getDp(76) + Int_UtilsKt.getDp(4) + 1, Int_UtilsKt.getDp(76) - Int_UtilsKt.getDp(4));
        this.anim2 = ofInt;
        if (ofInt != null) {
            ofInt.setDuration(400L);
        }
        ValueAnimator valueAnimator = this.anim2;
        if (valueAnimator != null) {
            valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                @Override
                public final void onAnimationUpdate(ValueAnimator valueAnimator2) {
                    AvatarAndNameImage.createAnim2$lambda$2(AvatarAndNameImage.this, valueAnimator2);
                }
            });
        }
        ValueAnimator valueAnimator2 = this.anim2;
        if (valueAnimator2 != null) {
            valueAnimator2.addListener(new AvatarAndNameImage$createAnim2$2(this));
        }
    }

    public static final void createAnim2$lambda$2(AvatarAndNameImage avatarAndNameImage, ValueAnimator valueAnimator) {
        kotlin.jvm.internal.k.f(avatarAndNameImage, "this$0");
        kotlin.jvm.internal.k.f(valueAnimator, "it");
        Object animatedValue = valueAnimator.getAnimatedValue();
        kotlin.jvm.internal.k.d(animatedValue, "null cannot be cast to non-null type kotlin.Int");
        avatarAndNameImage.setAnimatedValue(((Integer) animatedValue).intValue());
    }

    private final void drawBackgroundColor(Canvas canvas) {
        AvatarBitmapEnum avatarBitmapEnum = this.avatarBitmapType;
        if (avatarBitmapEnum != AvatarBitmapEnum.CIRCLE && avatarBitmapEnum == AvatarBitmapEnum.ROUND_RECT) {
            canvas.drawColor(androidx.core.content.a.c(getContext(), t1.c.transparent_color));
        }
    }

    private final void drawBitmap(Canvas canvas) {
        AvatarBitmapEnum avatarBitmapEnum = this.avatarBitmapType;
        if (avatarBitmapEnum == AvatarBitmapEnum.CIRCLE) {
            drawCroppedBitmap(canvas);
        } else if (avatarBitmapEnum == AvatarBitmapEnum.ROUND_RECT) {
            drawRoundRectBitmap(canvas);
        }
    }

    private final void drawCallStatusTextINBottom(Canvas canvas, String str) {
        int dp;
        int i;
        Rect rect = new Rect();
        this.paintCallingAndCancel.getTextBounds(str, 0, str.length(), rect);
        int width = getWidth();
        int height = getHeight();
        if (ConferenceManager.INSTANCE.isInitiateByMy()) {
            dp = ((((height - this.circleImageSize) / 2) - Int_UtilsKt.getDp(16)) - Int_UtilsKt.getDp(27)) - this.topBottomMargin;
            i = getItemBottomMargin();
        } else {
            dp = ((height - this.circleImageSize) / 2) - Int_UtilsKt.getDp(16);
            i = this.topBottomMargin;
        }
        canvas.drawText(str, rect.width() < width ? (width - rect.width()) / 2 : 0.0f, dp - i, this.paintCallingAndCancel);
    }

    private final void drawCallStatusTextINTop(Canvas canvas, String str) {
        Rect rect = new Rect();
        this.paintCallingAndCancel.getTextBounds(str, 0, str.length(), rect);
        int width = getWidth();
        int height = getHeight();
        int i = this.circleImageSize;
        canvas.drawText(str, rect.width() < width ? (width - rect.width()) / 2 : 0.0f, ((height - i) / 2) + i + (this.txtHeight * 2) + (Int_UtilsKt.getDp(12) * 2), this.paintCallingAndCancel);
    }

    private final void drawCancelTextInBottom(Canvas canvas) {
        String str = this.cancelText;
        Rect rect = new Rect();
        this.paintCallingAndCancel.getTextBounds(str, 0, str.length(), rect);
        int width = getWidth();
        float height = ((((getHeight() - this.circleImageSize) / 2) - Int_UtilsKt.getDp(16)) - Int_UtilsKt.getDp(27)) - getItemBottomMargin();
        float width2 = rect.width() < width ? (width - rect.width()) / 2 : 0.0f;
        Drawable drawable = this.cancelDrawable;
        if (drawable != null) {
            drawable.setBounds((int) (width2 - Int_UtilsKt.getDp(12)), (int) height, (int) (Int_UtilsKt.getDp(12) + width2 + rect.width()), (int) (Int_UtilsKt.getDp(27) + height));
        }
        Drawable drawable2 = this.cancelDrawable;
        if (drawable2 != null) {
            drawable2.draw(canvas);
        }
        canvas.drawText(str, width2, ((int) height) + ((Int_UtilsKt.getDp(27) - rect.height()) / 2) + rect.height(), this.paintCallingAndCancel);
    }

    private final void drawCancelTextInTop(Canvas canvas) {
        String str = this.cancelText;
        Rect rect = new Rect();
        this.paintCallingAndCancel.getTextBounds(str, 0, str.length(), rect);
        int width = getWidth();
        int height = getHeight();
        int i = this.circleImageSize;
        float dp = ((height - i) / 2) + i + (this.txtHeight * 2) + (Int_UtilsKt.getDp(12) * 2) + this.topBottomMargin;
        float width2 = rect.width() < width ? (width - rect.width()) / 2 : 0.0f;
        Drawable drawable = this.cancelDrawable;
        if (drawable != null) {
            drawable.setBounds((int) (width2 - Int_UtilsKt.getDp(12)), (int) dp, (int) (Int_UtilsKt.getDp(12) + width2 + rect.width()), (int) (Int_UtilsKt.getDp(27) + dp));
        }
        Drawable drawable2 = this.cancelDrawable;
        if (drawable2 != null) {
            drawable2.draw(canvas);
        }
        canvas.drawText(str, width2, ((int) dp) + ((Int_UtilsKt.getDp(27) - rect.height()) / 2) + rect.height(), this.paintCallingAndCancel);
    }

    private final void drawCroppedBitmap(Canvas canvas) {
        Bitmap bitmap = this.avatarBitmap;
        if (bitmap == null) {
            bitmap = DrawableManager.INSTANCE.getDefaultAvatarBitmap();
        }
        float height = (getHeight() - this.circleImageSize) / 2;
        if (this.itemIsBottom) {
            height -= getItemBottomMargin();
        }
        if (bitmap != null) {
            canvas.drawBitmap(bitmap, (getWidth() - this.circleImageSize) / 2, height, (Paint) null);
        }
        if (this.isPersonal) {
            return;
        }
        float width = getWidth() / 2;
        float height2 = this.itemIsBottom ? (getHeight() / 2) - getItemBottomMargin() : getHeight() / 2;
        float dp = Int_UtilsKt.getDp(6.5f);
        float dp2 = Int_UtilsKt.getDp(76.0f);
        canvas.drawCircle(width, height2, Int_UtilsKt.getDp(38) + dp, getPaintVoice());
        if (this.animatedValue <= 0) {
            startAnimateColor2(getPaintVoice(), getPaintAnimateVoiceBottom(), getPaintAnimateVoiceTop());
            getPaintVoice().setColor(this.animatedColor);
            getPaintAnimateVoiceBottom().setColor(this.animatedColor);
            getPaintAnimateVoiceTop().setColor(this.animatedColor);
            getPaintAnimateVoiceTop().setStrokeWidth(this.circleStrokeWidth);
            getPaintAnimateVoiceBottom().setStrokeWidth(this.circleStrokeWidth);
            return;
        }
        startAnimateColor1(getPaintVoice(), getPaintAnimateVoiceBottom(), getPaintAnimateVoiceTop());
        getPaintVoice().setColor(this.animatedColor);
        getPaintAnimateVoiceBottom().setColor(this.animatedColor);
        getPaintAnimateVoiceTop().setColor(this.animatedColor);
        if (this.animatedValue > Int_UtilsKt.getDp(76)) {
            canvas.drawCircle(width, height2, (this.animatedValue / 2.0f) + dp, getPaintAnimateVoiceTop());
            canvas.drawCircle(width, height2, (dp + dp2) - (this.animatedValue / 2.0f), getPaintAnimateVoiceBottom());
        }
    }

    private final void drawItem(Canvas canvas) {
        this.canvas = canvas;
        drawBackgroundColor(canvas);
        drawBitmap(canvas);
        if (this.itemIsBottom) {
            if (this.callingText.length() == 0) {
                this.cancelDrawable = null;
                return;
            }
            if (ConferenceManager.INSTANCE.isInitiateByMy()) {
                drawCancelTextInBottom(canvas);
            }
            drawCallStatusTextINBottom(canvas, this.callingText);
            return;
        }
        if (this.callingText.length() == 0) {
            this.cancelDrawable = null;
            return;
        }
        drawCallStatusTextINTop(canvas, this.callingText);
        if (ConferenceManager.INSTANCE.isInitiateByMy()) {
            drawCancelTextInTop(canvas);
        }
    }

    private final void drawRoundRect(Canvas canvas, RectF rectF, float f, float f7, Paint paint) {
        canvas.drawRoundRect(rectF.left, rectF.top, rectF.width(), rectF.height(), f, f7, paint);
    }

    private final void drawRoundRectBitmap(Canvas canvas) {
        Bitmap bitmap = this.avatarBitmap;
        if (bitmap == null) {
            bitmap = DrawableManager.INSTANCE.getDefaultAvatarBitmap();
        }
        if (bitmap != null) {
            float strokeWidth = getPaintVoice().getStrokeWidth() * 0.5f;
            RectF rectF = this.roundRectF;
            rectF.left = strokeWidth;
            rectF.top = strokeWidth;
            rectF.right = bitmap.getWidth() + strokeWidth;
            this.roundRectF.bottom = bitmap.getHeight() + strokeWidth;
            if (this.avatarBitmap == null) {
                RectF rectF2 = this.roundRectF;
                float f = this.roundRectRadius;
                drawRoundRect(canvas, rectF2, f, f, this.paintDefaultAvatarBackground);
            }
            float f7 = strokeWidth * 0.75f;
            canvas.drawBitmap(bitmap, f7, f7, (Paint) null);
            if (this.animatedValue > 0) {
                RectF rectF3 = this.roundRectF;
                float f8 = this.roundRectRadius;
                drawRoundRect(canvas, rectF3, f8, f8, getPaintVoice());
                if (this.animatedValue > Int_UtilsKt.getDp(76)) {
                    float f9 = this.animatedValue * 0.02f;
                    float strokeWidth2 = getPaintAnimateVoiceTop().getStrokeWidth() * 0.25f;
                    RectF rectF4 = this.animatedRoundRectF;
                    RectF rectF5 = this.roundRectF;
                    rectF4.left = (rectF5.left - f9) + strokeWidth2;
                    rectF4.top = (rectF5.top - f9) + strokeWidth2;
                    rectF4.right = (rectF5.right + f9) - strokeWidth2;
                    rectF4.bottom = (rectF5.bottom + f9) - strokeWidth2;
                    float f10 = this.roundRectRadius;
                    drawRoundRect(canvas, rectF4, f10, f10, getPaintAnimateVoiceTop());
                }
            }
        }
    }

    private final void drawTextName(Canvas canvas, String str) {
        Rect rect = new Rect();
        String obj = TextUtils.ellipsize(str, this.paintUserName, getWidth() - Int_UtilsKt.getDp(80), TextUtils.TruncateAt.END).toString();
        this.paintUserName.getTextBounds(str, 0, obj.length(), rect);
        int width = getWidth();
        int height = getHeight();
        if (this.txtHeight == 0) {
            this.txtHeight = rect.height();
        }
        int i = this.circleImageSize;
        float dp = ((height - i) / 2) + i + this.txtHeight + Int_UtilsKt.getDp(12);
        float width2 = rect.width() < width ? (width - rect.width()) / 2 : Int_UtilsKt.getDp(40);
        if (this.itemIsBottom) {
            dp -= getItemBottomMargin();
        }
        canvas.drawText(obj, width2, dp, this.paintUserName);
    }

    private final ObjectAnimator fadColorAnimation1(Paint paint, final int i) {
        ObjectAnimator ofObject = ObjectAnimator.ofObject(paint, "color", new ArgbEvaluator(), Integer.valueOf(getVoiceAnimateColor(false)), Integer.valueOf(getVoiceAnimateColor(true)));
        ofObject.setDuration(270L);
        ofObject.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public final void onAnimationUpdate(ValueAnimator valueAnimator) {
                AvatarAndNameImage.fadColorAnimation1$lambda$6(i, this, valueAnimator);
            }
        });
        ofObject.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationCancel(Animator animator) {
                kotlin.jvm.internal.k.f(animator, "animation");
            }

            @Override
            public void onAnimationEnd(Animator animator) {
                kotlin.jvm.internal.k.f(animator, "animation");
                AvatarAndNameImage.this.isAnimatedColor1 = false;
            }

            @Override
            public void onAnimationRepeat(Animator animator) {
                kotlin.jvm.internal.k.f(animator, "animation");
            }

            @Override
            public void onAnimationStart(Animator animator) {
                kotlin.jvm.internal.k.f(animator, "animation");
                AvatarAndNameImage.this.isAnimatedColor1 = true;
            }
        });
        kotlin.jvm.internal.k.e(ofObject, "colorFade");
        return ofObject;
    }

    public static final void fadColorAnimation1$lambda$6(int i, AvatarAndNameImage avatarAndNameImage, ValueAnimator valueAnimator) {
        kotlin.jvm.internal.k.f(avatarAndNameImage, "this$0");
        kotlin.jvm.internal.k.f(valueAnimator, "it");
        if (i > 0) {
            return;
        }
        Object animatedValue = valueAnimator.getAnimatedValue();
        kotlin.jvm.internal.k.d(animatedValue, "null cannot be cast to non-null type kotlin.Int");
        avatarAndNameImage.setAnimatedColor(((Integer) animatedValue).intValue());
    }

    private final ObjectAnimator fadColorAnimation2(Paint paint, final int i) {
        ObjectAnimator ofObject = ObjectAnimator.ofObject(paint, "color", new ArgbEvaluator(), Integer.valueOf(getVoiceAnimateColor(true)), Integer.valueOf(getVoiceAnimateColor(false)));
        ofObject.setDuration(270L);
        ofObject.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public final void onAnimationUpdate(ValueAnimator valueAnimator) {
                AvatarAndNameImage.fadColorAnimation2$lambda$7(i, this, valueAnimator);
            }
        });
        ofObject.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationCancel(Animator animator) {
                kotlin.jvm.internal.k.f(animator, "animation");
            }

            @Override
            public void onAnimationEnd(Animator animator) {
                kotlin.jvm.internal.k.f(animator, "animation");
                AvatarAndNameImage.this.isAnimatedColor2 = false;
            }

            @Override
            public void onAnimationRepeat(Animator animator) {
                kotlin.jvm.internal.k.f(animator, "animation");
            }

            @Override
            public void onAnimationStart(Animator animator) {
                kotlin.jvm.internal.k.f(animator, "animation");
                AvatarAndNameImage.this.isAnimatedColor2 = true;
            }
        });
        kotlin.jvm.internal.k.e(ofObject, "colorFade");
        return ofObject;
    }

    public static final void fadColorAnimation2$lambda$7(int i, AvatarAndNameImage avatarAndNameImage, ValueAnimator valueAnimator) {
        kotlin.jvm.internal.k.f(avatarAndNameImage, "this$0");
        kotlin.jvm.internal.k.f(valueAnimator, "it");
        if (i > 0) {
            return;
        }
        Object animatedValue = valueAnimator.getAnimatedValue();
        kotlin.jvm.internal.k.d(animatedValue, "null cannot be cast to non-null type kotlin.Int");
        avatarAndNameImage.setAnimatedColor(((Integer) animatedValue).intValue());
    }

    private final Bitmap getBitmap(Bitmap bitmap) {
        int i = WhenMappings.$EnumSwitchMapping$2[this.avatarBitmapType.ordinal()];
        return i != 1 ? i != 2 ? getCroppedBitmap(bitmap) : getRoundRectBitmap(bitmap) : getCroppedBitmap(bitmap);
    }

    private final Bitmap getCroppedBitmap(Bitmap bitmap) {
        Bitmap createBitmap = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(createBitmap);
        Paint paint = new Paint(1);
        paint.setAntiAlias(true);
        Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
        paint.setAntiAlias(true);
        canvas.drawARGB(0, 0, 0, 0);
        paint.setColor(-12434878);
        canvas.drawCircle(bitmap.getWidth() / 2, bitmap.getHeight() / 2, bitmap.getWidth() / 2, paint);
        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
        canvas.drawBitmap(bitmap, rect, rect, paint);
        kotlin.jvm.internal.k.e(createBitmap, "output");
        return createBitmap;
    }

    private final Paint getPaintAnimateVoiceBottom() {
        return (Paint) this.paintAnimateVoiceBottom$delegate.getValue();
    }

    private final Paint getPaintAnimateVoiceTop() {
        return (Paint) this.paintAnimateVoiceTop$delegate.getValue();
    }

    private final Paint getPaintVoice() {
        return (Paint) this.paintVoice$delegate.getValue();
    }

    private final Bitmap getRoundRectBitmap(Bitmap bitmap) {
        Bitmap createBitmap = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(createBitmap);
        Paint paint = new Paint(1);
        paint.setAntiAlias(true);
        Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
        RectF rectF = new RectF(0.0f, 0.0f, bitmap.getWidth(), bitmap.getHeight());
        paint.setAntiAlias(true);
        canvas.drawARGB(0, 0, 0, 0);
        paint.setColor(-12434878);
        float f = this.roundRectRadius;
        drawRoundRect(canvas, rectF, f, f, paint);
        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
        canvas.drawBitmap(bitmap, rect, rect, paint);
        kotlin.jvm.internal.k.e(createBitmap, "output");
        return createBitmap;
    }

    public final int getVoiceAnimateColor(boolean z) {
        return z ? androidx.core.content.a.c(MainApplication.Companion.getMainContext(), t1.c.app_main_blue_color) : androidx.core.content.a.c(MainApplication.Companion.getMainContext(), t1.c.voice_animation_disable_color);
    }

    public static void loadAvatar$default(AvatarAndNameImage avatarAndNameImage, String str, boolean z, boolean z6, int i, Object obj) {
        if ((i & 2) != 0) {
            z = false;
        }
        avatarAndNameImage.loadAvatar(str, z, z6);
    }

    public final void removeAnimation() {
        this.isAnimating = false;
        ValueAnimator valueAnimator = this.anim1;
        if (valueAnimator != null) {
            valueAnimator.cancel();
        }
        ValueAnimator valueAnimator2 = this.anim2;
        if (valueAnimator2 != null) {
            valueAnimator2.cancel();
        }
        setAnimatedValue(Int_UtilsKt.getDp(0));
        ZTimer zTimer = this.animationTimer;
        if (zTimer != null) {
            zTimer.invalidate();
        }
        this.animationTimer = null;
    }

    private final void setAnimatedColor(int i) {
        this.animatedColor = i;
        invalidate();
    }

    private final void setAnimatedValue(int i) {
        this.animatedValue = i;
        invalidate();
    }

    private final void setBackgroundBitmap(Bitmap bitmap) {
        Bitmap bitmap2 = this.backgroundBitmap;
        if (kotlin.jvm.internal.k.b(bitmap2 != null ? Integer.valueOf(bitmap2.hashCode()) : null, bitmap != null ? Integer.valueOf(bitmap.hashCode()) : null)) {
            return;
        }
        this.backgroundBitmap = bitmap;
        invalidate();
    }

    public static final void setBitmapToView$lambda$5(Bitmap bitmap, final AvatarAndNameImage avatarAndNameImage) {
        kotlin.jvm.internal.k.f(avatarAndNameImage, "this$0");
        final Bitmap copy = bitmap.copy(bitmap.getConfig(), true);
        MainApplication.Companion.getMainHandler().post(new Runnable() {
            @Override
            public final void run() {
                AvatarAndNameImage.setBitmapToView$lambda$5$lambda$4(AvatarAndNameImage.this, copy);
            }
        });
    }

    public static final void setBitmapToView$lambda$5$lambda$4(AvatarAndNameImage avatarAndNameImage, Bitmap bitmap) {
        kotlin.jvm.internal.k.f(avatarAndNameImage, "this$0");
        avatarAndNameImage.setBackgroundBitmap(ZangiMessagingService.getInstance().blureImage(bitmap, 15));
    }

    private final void startAnimateColor1(Paint... paintArr) {
        if (this.isAnimatedColor1 || this.animatedColor == getVoiceAnimateColor(true)) {
            return;
        }
        int length = paintArr.length;
        for (int i = 0; i < length; i++) {
            fadColorAnimation1(paintArr[i], i).start();
        }
    }

    private final void startAnimateColor2(Paint... paintArr) {
        if (this.isAnimatedColor2) {
            return;
        }
        if (this.animatedColor == getVoiceAnimateColor(false)) {
            return;
        }
        int length = paintArr.length;
        for (int i = 0; i < length; i++) {
            fadColorAnimation2(paintArr[i], i).start();
        }
    }

    private final void viewAndBitmapRelation(Bitmap bitmap, int i, int i7) {
        int i8;
        Rect rect;
        int i9;
        if (bitmap != null) {
            double width = i / bitmap.getWidth();
            double height = i7 / bitmap.getHeight();
            this.srcRect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
            if (width > height) {
                int height2 = (int) (bitmap.getHeight() * width);
                if (height2 > i7) {
                    int i10 = (height2 - i7) / 2;
                    i9 = 0 - i10;
                    i7 = height2 - i10;
                } else {
                    i9 = 0;
                }
                rect = new Rect(0, i9, (int) (bitmap.getWidth() * width), i7);
            } else {
                int width2 = (int) (bitmap.getWidth() * height);
                if (width2 > i) {
                    int i11 = (width2 - i) / 2;
                    i8 = 0 - i11;
                    i = width2 - i11;
                } else {
                    i8 = 0;
                }
                rect = new Rect(i8, 0, i, (int) (bitmap.getHeight() * height));
            }
            this.dstRect = rect;
        }
    }

    protected void dispatchDraw(Canvas canvas) {
        super.dispatchDraw(canvas);
        if (canvas != null) {
            drawItem(canvas);
        }
    }

    public final Bitmap getAvatarBitmap() {
        return this.avatarBitmap;
    }

    public final AvatarBitmapEnum getAvatarBitmapType() {
        return this.avatarBitmapType;
    }

    public final String getCallingText() {
        return this.callingText;
    }

    public final Canvas getCanvas() {
        return this.canvas;
    }

    public final int getColorResourceId() {
        return this.colorResourceId;
    }

    public final AvatarAndNameImageDelegate getDelegate() {
        return this.delegate;
    }

    public final int getIteHeight() {
        return this.iteHeight;
    }

    public final int getItemBottomMargin() {
        return getContext() != null ? View_UtilsKt.getBottomNavigationBarHeightInPixels(getContext()) + Int_UtilsKt.getDp(12) : Int_UtilsKt.getDp(30);
    }

    public final boolean getItemIsBottom() {
        return this.itemIsBottom;
    }

    public final int getItemWith() {
        return this.itemWith;
    }

    public ConferenceMemberMuteState getMuteState() {
        return this.mMuteState;
    }

    public final String getName() {
        return this.name;
    }

    public final Integer getPosition() {
        return this.position;
    }

    public final boolean isPersonal() {
        return this.isPersonal;
    }

    public final void loadAvatar(String str, boolean z, final boolean z6) {
        this.key = str;
        if (str == null) {
            return;
        }
        AvatarImageView.Companion.AwatarWorkerTask awatarWorkerTask = this.task;
        if (awatarWorkerTask != null) {
            awatarWorkerTask.cancel();
        }
        AvatarBitmapEnum avatarBitmapEnum = this.avatarBitmapType;
        AvatarBitmapEnum avatarBitmapEnum2 = AvatarBitmapEnum.ROUND_RECT;
        if (avatarBitmapEnum == avatarBitmapEnum2) {
            this.key = str + avatarBitmapEnum2.name();
        }
        Bitmap bitmapFromMemCache = CacheManager.INSTANCE.getBitmapFromMemCache(this.key + AvatarManager.INSTANCE.getAvatarSize(AvatarSizeType.BIG));
        if (bitmapFromMemCache != null) {
            setBitmapToView(bitmapFromMemCache, true);
            return;
        }
        AvatarImageView.Companion.AwatarWorkerTaskItem awatarWorkerTaskItem = new AvatarImageView.Companion.AwatarWorkerTaskItem();
        awatarWorkerTaskItem.setAvatarId(str);
        awatarWorkerTaskItem.setGroup(z);
        awatarWorkerTaskItem.setContext(new WeakReference(getContext()));
        awatarWorkerTaskItem.setSizeType(AvatarSizeType.CONFERENCE);
        awatarWorkerTaskItem.setCache(false);
        awatarWorkerTaskItem.setCrop(false);
        awatarWorkerTaskItem.setCallBackInCall(new AvatarListenerInCall() {
            @Override
            public void updateAvatar(Bitmap bitmap, boolean z7) {
                String str2;
                kotlin.jvm.internal.k.f(bitmap, "bitmap");
                if (z6) {
                    CacheManager cacheManager = CacheManager.INSTANCE;
                    str2 = this.key;
                    if (str2 == null) {
                        str2 = "";
                    }
                    cacheManager.addBitmapToMemoryCache(str2, bitmap);
                }
                this.setBitmapToView(bitmap, z7);
            }
        });
        this.task = new AvatarImageView.Companion.AwatarWorkerTask(awatarWorkerTaskItem);
        DispatchQueue queue = AvatarImageView.Companion.getQueue();
        AvatarImageView.Companion.AwatarWorkerTask awatarWorkerTask2 = this.task;
        kotlin.jvm.internal.k.c(awatarWorkerTask2);
        queue.postRunnable(awatarWorkerTask2);
    }

    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        NotificationCenter.INSTANCE.addObserver(this, AvatarAndNameImage$onAttachedToWindow$1.INSTANCE, new NotificationCenter.NotificationType[]{NotificationCenter.NotificationType.CONTACT_LIST_CHANGED, NotificationCenter.NotificationType.PROFILE_CHANGED});
    }

    protected void onDetachedFromWindow() {
        super/*android.widget.FrameLayout*/.onDetachedFromWindow();
        NotificationCenter.INSTANCE.removeObserver(this);
    }

    protected void onMeasure(int i, int i7) {
        setMeasuredDimension(this.itemWith, this.iteHeight);
    }

    @SuppressLint({"ClickableViewAccessibility"})
    public boolean onTouchEvent(MotionEvent motionEvent) {
        AvatarAndNameImageDelegate avatarAndNameImageDelegate;
        if (motionEvent == null) {
            return super.onTouchEvent(motionEvent);
        }
        Drawable drawable = this.cancelDrawable;
        if (drawable != null) {
            kotlin.jvm.internal.k.c(drawable);
            if (drawable.getBounds().contains((int) motionEvent.getX(), (int) motionEvent.getY()) && motionEvent.getAction() == 0) {
                if (this.position == null || (avatarAndNameImageDelegate = this.delegate) == null) {
                    return true;
                }
                avatarAndNameImageDelegate.cancelButtonClick();
                return true;
            }
        }
        return super.onTouchEvent(motionEvent);
    }

    public final void setAvatarBitmap(Bitmap bitmap) {
        Bitmap bitmap2 = this.avatarBitmap;
        if (kotlin.jvm.internal.k.b(bitmap2 != null ? Integer.valueOf(bitmap2.hashCode()) : null, bitmap != null ? Integer.valueOf(bitmap.hashCode()) : null)) {
            return;
        }
        this.avatarBitmap = bitmap;
        requestLayout();
    }

    public final void setAvatarBitmapType(AvatarBitmapEnum avatarBitmapEnum) {
        kotlin.jvm.internal.k.f(avatarBitmapEnum, "<set-?>");
        this.avatarBitmapType = avatarBitmapEnum;
    }

    public final void setBitmapToView(final Bitmap bitmap, boolean z) {
        if (bitmap == null) {
            setAvatarBitmap(null);
            return;
        }
        if (z) {
            setBackgroundBitmap(null);
        } else {
            new Thread(new Runnable() {
                @Override
                public final void run() {
                    AvatarAndNameImage.setBitmapToView$lambda$5(bitmap, this);
                }
            }).start();
        }
        if (this.avatarBitmapType == AvatarBitmapEnum.CIRCLE) {
            int i = this.circleImageSize;
            Bitmap createScaledBitmap = Bitmap.createScaledBitmap(bitmap, i, i, false);
            kotlin.jvm.internal.k.e(createScaledBitmap, "createScaledBitmap(bitma…, circleImageSize, false)");
            setAvatarBitmap(getBitmap(createScaledBitmap));
            return;
        }
        int i7 = this.rectImageSize;
        Bitmap createScaledBitmap2 = Bitmap.createScaledBitmap(bitmap, i7, i7, false);
        kotlin.jvm.internal.k.e(createScaledBitmap2, "createScaledBitmap(bitma…ze, rectImageSize, false)");
        setAvatarBitmap(getBitmap(createScaledBitmap2));
    }

    public final void setCallingText(String str) {
        kotlin.jvm.internal.k.f(str, "value");
        this.callingText = str;
        invalidate();
    }

    public final void setCanvas(Canvas canvas) {
        this.canvas = canvas;
    }

    public final void setColorResourceId(int i) {
        this.colorResourceId = i;
    }

    public final void setDelegate(AvatarAndNameImageDelegate avatarAndNameImageDelegate) {
        this.delegate = avatarAndNameImageDelegate;
    }

    public void setHoldState(ConferenceMemberHoldState conferenceMemberHoldState) {
        kotlin.jvm.internal.k.f(conferenceMemberHoldState, "value");
        if (this.mHoldState != conferenceMemberHoldState) {
            this.mHoldState = conferenceMemberHoldState;
            if (WhenMappings.$EnumSwitchMapping$1[conferenceMemberHoldState.ordinal()] != 1) {
                return;
            }
            stopVoiceAnimation();
        }
    }

    public final void setIteHeight(int i) {
        this.iteHeight = i;
    }

    public final void setItemIsBottom(boolean z) {
        this.itemIsBottom = z;
    }

    public final void setItemWith(int i) {
        this.itemWith = i;
    }

    public void setMuteState(ConferenceMemberMuteState conferenceMemberMuteState) {
        kotlin.jvm.internal.k.f(conferenceMemberMuteState, "value");
        if (this.mMuteState != conferenceMemberMuteState) {
            this.mMuteState = conferenceMemberMuteState;
        }
        if (WhenMappings.$EnumSwitchMapping$0[this.mMuteState.ordinal()] != 1) {
            return;
        }
        stopVoiceAnimation();
    }

    public final void setName(String str) {
        kotlin.jvm.internal.k.f(str, "<set-?>");
        this.name = str;
    }

    public final void setPersonal(boolean z) {
        this.isPersonal = z;
    }

    public final void setPosition(Integer num) {
        this.position = num;
    }

    public boolean startVoiceAnimation() {
        if (this.mMuteState == ConferenceMemberMuteState.memberMute || this.mHoldState == ConferenceMemberHoldState.memberHold) {
            return false;
        }
        DispatchKt.mainThread(new AvatarAndNameImage$startVoiceAnimation$1(this));
        return true;
    }

    public void stopVoiceAnimation() {
        synchronized (this) {
            if (this.animationTimer == null) {
                this.animationTimer = ZTimer.Companion.schedule(1.0d, false, new AvatarAndNameImage$stopVoiceAnimation$1$1(this));
            }
            fb.r rVar = fb.r.a;
        }
    }
}