EmergencyGestureAction/src/com/android/emergency/widgets/countdown/LoopingAnimationThread.java

/*
 * Copyright (C) 2020 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.emergency.widgets.countdown;


import android.animation.TimeInterpolator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.RectF;
import android.view.SurfaceHolder;
import android.view.animation.DecelerateInterpolator;

import androidx.annotation.GuardedBy;

import com.android.emergency.action.R;

import java.time.Duration;
import java.time.Instant;

/**
 * Thread that handles the looping "pending" animation with optional count down text.
 */
final class LoopingAnimationThread extends Thread {

    private final SurfaceHolder mSurfaceHolder;
    private final Context mContext;
    private final Paint mBackgroundPaint;
    private final Paint mLoopPaint;
    private final Paint mLoopHeadPaint;
    private final TimeInterpolator mDecelerateInterpolator = new DecelerateInterpolator();
    private final Duration mLoopInterval;
    private final Duration mLoopTrailDelay;

    private volatile boolean mIsDrawing = false;

    @GuardedBy("this")
    private RectF mLoopBounds;

    @GuardedBy("this")
    private float mLoopRadius;

    @GuardedBy("this")
    private float mLoopHeadRadius;

    @GuardedBy("this")
    private final CountDownRenderer mCountDownRenderer;

    @GuardedBy("this")
    private int mTotalDiameter;

    /**
     * Constructor for looping animation thread.
     *
     * @param surfaceHolder Surface holder from surface view.
     * @param context       The context from the view.
     */
    LoopingAnimationThread(
            SurfaceHolder surfaceHolder,
            Context context) {
        super(LoopingAnimationThread.class.getSimpleName());
        this.mSurfaceHolder = surfaceHolder;
        mContext = context;
        mBackgroundPaint = new Paint();
        mBackgroundPaint.setColor(Color.BLACK);
        mBackgroundPaint.setStyle(Paint.Style.FILL);
        mBackgroundPaint.setAntiAlias(true);
        mLoopPaint = new Paint();
        mLoopPaint.setColor(Color.WHITE);
        mLoopPaint.setStyle(Paint.Style.STROKE);
        mLoopPaint.setAntiAlias(true);
        mLoopHeadPaint = new Paint();
        mLoopHeadPaint.setColor(Color.WHITE);
        mLoopHeadPaint.setStyle(Paint.Style.FILL);
        mLoopHeadPaint.setAntiAlias(true);

        mCountDownRenderer = new CountDownRenderer(context);

        mLoopInterval = Duration.ofMillis(
                mContext.getResources().getInteger(R.integer.count_down_view_loop_interval_millis));
        mLoopTrailDelay = Duration.ofMillis(
                mContext.getResources().getInteger(R.integer.count_down_view_loop_delay_millis));
    }

    @Override
    public void run() {
        mIsDrawing = true;
        Instant now = Instant.ofEpochMilli(System.currentTimeMillis());
        updateSize(
                mSurfaceHolder.getSurfaceFrame().width(),
                mSurfaceHolder.getSurfaceFrame().height());
        while (mIsDrawing) {
            if (isInterrupted()) {
                mIsDrawing = false;
                return;
            }
            Canvas canvas = null;
            try {
                synchronized (mSurfaceHolder) {
                    canvas = mSurfaceHolder.lockCanvas(null);
                    draw(canvas, now);
                }
            } finally {
                // Make sure we don't leave the Surface in an inconsistent state.
                if (canvas != null) {
                    mSurfaceHolder.unlockCanvasAndPost(canvas);
                }
            }
        }
    }

    /**
     * Reveals the count down if animation started, otherwise count down will show when animation
     * starts.
     */
    synchronized void showCountDown() {
        mCountDownRenderer.show();
    }

    /** Sets the count down left duration to be drawn. */
    synchronized void setCountDownLeft(Duration timeLeft) {
        if (timeLeft.isNegative() || timeLeft.isZero()) {
            mCountDownRenderer.setCountDownLeft(Duration.ZERO);
        } else {
            mCountDownRenderer.setCountDownLeft(timeLeft);
        }
    }

    /**
     * Draw frame.
     *
     * @param canvas    Canvas to draw on.
     * @param startTime start time of animation.
     */
    private synchronized void draw(Canvas canvas, Instant startTime) {
        if (!mIsDrawing) {
            // It is possible to lose the canvas because surface got destroyed here.
            return;
        }
        // Clear background.
        canvas.drawColor(0, PorterDuff.Mode.CLEAR);
        // Draw background.
        canvas.drawCircle(mLoopBounds.centerX(), mLoopBounds.centerY(), mLoopRadius,
                mBackgroundPaint);

        // Calculate each end of the loop's elapsed time for calculating what arc to draw.

        long progressedMillis =
                Duration.between(
                        startTime, Instant.ofEpochMilli(System.currentTimeMillis())).toMillis();
        long loopHeadT = progressedMillis % mLoopInterval.toMillis();
        long loopTailT = loopHeadT - mLoopTrailDelay.toMillis();

        // 0 means track start, 1 means track end.

        Duration loopTrackInterval = mLoopInterval.minus(mLoopTrailDelay);
        float loopTailTrackRatio =
                loopTailT <= 0f ? 0f : loopTailT / (float) loopTrackInterval.toMillis();
        float loopHeadTrackRatio =
                loopHeadT <= loopTrackInterval.toMillis()
                        ? loopHeadT / (float) loopTrackInterval.toMillis()
                        : 1f;
        // Interpolate and convert track completion ratio to degrees. From a clockwise perspective,
        // tail is starting angle and head is the ending angle so we intentionally swap terminology
        // here.
        float interpolatedSweepAngleStart =
                mDecelerateInterpolator.getInterpolation(loopTailTrackRatio) * 360f;
        float interpolatedSweepAngleEnd = mDecelerateInterpolator.getInterpolation(
                loopHeadTrackRatio) * 360f;
        float finalSweepAngleStart = interpolatedSweepAngleStart - 90f;
        float finalSweepAngleEnd = interpolatedSweepAngleEnd - 90f;
        canvas.drawArc(
                mLoopBounds,
                finalSweepAngleStart,
                finalSweepAngleEnd - finalSweepAngleStart,
                false,
                mLoopPaint);
        float leadingDotX =
                (float) Math.cos(Math.toRadians(finalSweepAngleEnd)) * mLoopRadius
                        + mLoopBounds.centerX();
        float leadingDotY =
                (float) Math.sin(Math.toRadians(finalSweepAngleEnd)) * mLoopRadius
                        + mLoopBounds.centerY();
        canvas.drawCircle(leadingDotX, leadingDotY, mLoopHeadRadius, mLoopHeadPaint);
        if (mCountDownRenderer.isRevealed()) {
            mCountDownRenderer.draw(canvas);
        }
    }

    /** Update size of loop based on new width and height. */
    synchronized void updateSize(int w, int h) {
        float lookTrackDiameterToBoundsRatio =
                mContext.getResources().getFloat(
                        R.dimen.count_down_view_loop_track_diameter_to_bounds_ratio);
        float lookHeadDiameterToBoundsRatio =
                mContext.getResources().getFloat(
                        R.dimen.count_down_view_loop_head_diameter_to_bounds_ratio);
        float lookStrokeWidthToBoundsRatio =
                mContext.getResources().getFloat(
                        R.dimen.count_down_view_loop_stoke_width_to_bounds_ratio);

        mTotalDiameter = Math.min(w, h);
        // Use ratios to calculate loop/track radius.
        mLoopRadius = mTotalDiameter * lookTrackDiameterToBoundsRatio * 0.5f;
        // Use ratios to calculate loop head radius.
        mLoopHeadRadius = mTotalDiameter * lookHeadDiameterToBoundsRatio * 0.5f;
        // Use ratios to calculate loop stroke width.
        mLoopPaint.setStrokeWidth(mTotalDiameter * lookStrokeWidthToBoundsRatio);
        mLoopBounds = new RectF(0, 0, mLoopRadius * 2, mLoopRadius * 2);
        float updatedSizeCenterOffsetX = (w - (mLoopRadius + mLoopHeadRadius) * 2) * 0.5f;
        float updatedSizeCenterOffsetY = (h - (mLoopRadius + mLoopHeadRadius) * 2) * 0.5f;
        mLoopBounds.offset(
                updatedSizeCenterOffsetX + mLoopHeadRadius,
                updatedSizeCenterOffsetY + mLoopHeadRadius);
        // Update bounds for count down text.
        mCountDownRenderer.updateBounds(mLoopBounds, mTotalDiameter);
    }

    /** Stop animation from drawing. */
    void stopDrawing() {
        mIsDrawing = false;
    }
}