GradientCircularProgressBar

package icu.stsi.myapplication11

import android.animation.ObjectAnimator
import android.animation.ValueAnimator
import android.content.Context
import android.graphics.*
import android.util.AttributeSet
import android.util.DisplayMetrics
import android.util.Log
import android.util.TypedValue
import android.view.View
import android.view.animation.LinearInterpolator
import androidx.core.content.res.ResourcesCompat
import java.lang.Exception
import kotlin.properties.Delegates


class GradientCircularProgressBar @JvmOverloads constructor(
    context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
) : View(context, attrs, defStyleAttr) {

    companion object {
        private const val BODY_STROKE_WIDTH: Int = 8
        private const val GLOW_STROKE_WIDTH: Int = 8

//      private const val GLOW_STROKE_WIDTH: Int = BODY_STROKE_WIDTH * 3
//      private const val PADDING: Int = GLOW_STROKE_WIDTH / 2

        private const val PADDING: Int = GLOW_STROKE_WIDTH / 2 + BODY_STROKE_WIDTH
        private const val BODY_LENGTH: Int = 270
        private const val NORMALIZED_GRADIENT_LENGTH: Float = BODY_LENGTH / 360f

        // Rotating CONST
        private const val ROTATION_DURATION: Int = 2500
        private const val ROTATION_LENGTH: Int = 360
        private const val ROTATION_PROPERTY_NAME: String = "rotation"


        private var mPaddingPx by Delegates.notNull<Float>()
        private var mBodyStrokeWidthPx by Delegates.notNull<Float>()
        private var mGlowStrokeWidthPx by Delegates.notNull<Float>()
        private lateinit var mPaintBody: Paint
        private lateinit var mPaintBackground: Paint
        private lateinit var mPaintGlow: Paint
        private lateinit var mRect: RectF
        private lateinit var mBodyGradient: SweepGradient
        private lateinit var mBodyGradientFromToColors: IntArray
        private lateinit var mGradientFromToPositions: FloatArray

        private lateinit var mRotationAnimator: ObjectAnimator
        private val rotation: Float = 0f
        private var growBodyLength: Int = 0
    }

    init {

        setLayerType(LAYER_TYPE_SOFTWARE, null)

        val backgroundColor: Int = ResourcesCompat.getColor(resources, R.color.neon_background, null)
        val bodyColor: Int = ResourcesCompat.getColor(resources, R.color.neon_body, null)
        val glowColor: Int = ResourcesCompat.getColor(resources, R.color.neon_body, null)
        val displayMetrics: DisplayMetrics = resources.displayMetrics
        mBodyStrokeWidthPx = TypedValue.applyDimension(
            TypedValue.COMPLEX_UNIT_DIP,
            BODY_STROKE_WIDTH.toFloat(),
            displayMetrics
        )
        mPaddingPx = TypedValue.applyDimension(
            TypedValue.COMPLEX_UNIT_DIP,
            PADDING.toFloat(),
            displayMetrics
        )
        mGlowStrokeWidthPx = TypedValue.applyDimension(
            TypedValue.COMPLEX_UNIT_DIP,
            GLOW_STROKE_WIDTH.toFloat(),
            displayMetrics
        )
        mPaintBackground = Paint()
        mPaintBackground.color = backgroundColor
        mPaintBackground.strokeWidth = mBodyStrokeWidthPx
        mPaintBackground.style = Paint.Style.STROKE

        mRect = RectF()
        mPaintBody = Paint()
        mPaintBody.isAntiAlias = true
        mPaintBody.color = bodyColor
        mPaintBody.strokeWidth = mBodyStrokeWidthPx
        mPaintBody.style = Paint.Style.STROKE
        mPaintBody.strokeJoin = Paint.Join.ROUND
        mPaintBody.strokeCap = Paint.Cap.ROUND

        mPaintGlow = Paint()
        mPaintGlow.set(mPaintBody)
        mPaintGlow.color = glowColor
        mPaintGlow.strokeWidth = mGlowStrokeWidthPx
        mPaintGlow.maskFilter = BlurMaskFilter(mBodyStrokeWidthPx, BlurMaskFilter.Blur.OUTER)


        mBodyGradientFromToColors = intArrayOf(Color.TRANSPARENT, bodyColor)
        mGradientFromToPositions = floatArrayOf(0F, NORMALIZED_GRADIENT_LENGTH)

        mRotationAnimator = createRotationAnimator()
        growBody()
    }

    override fun onDraw(canvas: Canvas?) {
        val left: Float = mPaddingPx
        val top: Float = mPaddingPx
        val right: Float = width - mPaddingPx
        val bottom: Float = height - mPaddingPx
        mRect.set(left, top, right, bottom)

        if (!mRotationAnimator.isStarted && growBodyLength == BODY_LENGTH) {
//            && growBodyLength == BODY_LENGTH
            mRotationAnimator.start()
        }
        canvas?.rotate(rotation, (width / 2).toFloat(), (height / 2).toFloat())

//        canvas?.drawArc(mRect, BODY_LENGTH-30.toFloat(), 30f, false, mPaintGlow)

        canvas?.drawArc(mRect, 0f, 360f, false, mPaintBackground)
        canvas?.drawArc(mRect, 10f, growBodyLength.toFloat(), false, mPaintGlow)
        canvas?.drawArc(mRect, 10f, growBodyLength.toFloat(), false, mPaintBody)
        Log.d("onDraw", "START!!!")
    }

    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
        super.onSizeChanged(w, h, oldw, oldh)
        val centerX: Float = (width / 2).toFloat()
        val centerY: Float = (height / 2).toFloat()
        mBodyGradient =
            SweepGradient(centerX, centerY, mBodyGradientFromToColors, mGradientFromToPositions)
        mPaintBody.shader = mBodyGradient
        mPaintGlow.shader = mBodyGradient
    }

//    override fun setRotation(rotationAngle: Float) {
////        rotation = rotationAngle
////        invalidate()
//    }


    private fun growBody() {
        Thread(Runnable {
            kotlin.run {
                for (i in 30..BODY_LENGTH) {
                    growBodyLength = i
                    invalidate()
                    try {
                        Thread.sleep(8)
                    } catch (e: Exception) {
                        e.printStackTrace()
                    }
                }
            }
        }).start()
    }

    private fun createRotationAnimator(): ObjectAnimator {
        val rotateAnimator: ObjectAnimator =
            ObjectAnimator.ofFloat(this, ROTATION_PROPERTY_NAME, ROTATION_LENGTH.toFloat())
        rotateAnimator.duration = ROTATION_DURATION.toLong()
        rotateAnimator.interpolator = LinearInterpolator()
        rotateAnimator.repeatMode = ValueAnimator.RESTART
        rotateAnimator.repeatCount = ValueAnimator.INFINITE
        return rotateAnimator
    }
}