packages/SystemUI/src/com/android/systemui/biometrics/UdfpsEnrollProgressBarSegment.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2021 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.systemui.biometrics;

 import android.animation.ValueAnimator;
 import android.content.Context;
 import android.content.res.TypedArray;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.Rect;
 import android.os.Handler;
 import android.os.Looper;
 import android.util.Log;
 import android.util.TypedValue;

 import androidx.annotation.ColorInt;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;

 import com.android.systemui.R;

 /**
  * A single segment of the UDFPS enrollment progress bar.
  */
 public class UdfpsEnrollProgressBarSegment {
     private static final String TAG = "UdfpsProgressBarSegment";

     private static final long PROGRESS_ANIMATION_DURATION_MS = 400L;
     private static final long OVER_SWEEP_ANIMATION_DELAY_MS = 200L;
     private static final long OVER_SWEEP_ANIMATION_DURATION_MS = 200L;

     private static final float STROKE_WIDTH_DP = 12f;

     private final Handler mHandler = new Handler(Looper.getMainLooper());

     @NonNull private final Rect mBounds;
     @NonNull private final Runnable mInvalidateRunnable;
     private final float mStartAngle;
     private final float mSweepAngle;
     private final float mMaxOverSweepAngle;
     private final float mStrokeWidthPx;

     @NonNull private final Paint mBackgroundPaint;
     @NonNull private final Paint mProgressPaint;

     private boolean mIsFilledOrFilling = false;

     private float mProgress = 0f;
     @Nullable private ValueAnimator mProgressAnimator;
     @NonNull private final ValueAnimator.AnimatorUpdateListener mProgressUpdateListener;

     private float mOverSweepAngle = 0f;
     @Nullable private ValueAnimator mOverSweepAnimator;
     @Nullable private ValueAnimator mOverSweepReverseAnimator;
     @NonNull private final ValueAnimator.AnimatorUpdateListener mOverSweepUpdateListener;
     @NonNull private final Runnable mOverSweepAnimationRunnable;

     public UdfpsEnrollProgressBarSegment(@NonNull Context context, @NonNull Rect bounds,
             float startAngle, float sweepAngle, float maxOverSweepAngle,
             @NonNull Runnable invalidateRunnable) {

         mBounds = bounds;
         mInvalidateRunnable = invalidateRunnable;
         mStartAngle = startAngle;
         mSweepAngle = sweepAngle;
         mMaxOverSweepAngle = maxOverSweepAngle;
         mStrokeWidthPx = Utils.dpToPixels(context, STROKE_WIDTH_DP);

         mBackgroundPaint = new Paint();
         mBackgroundPaint.setStrokeWidth(mStrokeWidthPx);
         mBackgroundPaint.setColor(context.getColor(R.color.white_disabled));
         mBackgroundPaint.setAntiAlias(true);
         mBackgroundPaint.setStyle(Paint.Style.STROKE);
         mBackgroundPaint.setStrokeCap(Paint.Cap.ROUND);

         // Background paint color + alpha
         final int[] attrs = new int[] {android.R.attr.colorControlNormal};
         final TypedArray ta = context.obtainStyledAttributes(attrs);
         @ColorInt final int tintColor = ta.getColor(0, mBackgroundPaint.getColor());
         mBackgroundPaint.setColor(tintColor);
         ta.recycle();
         TypedValue alpha = new TypedValue();
         context.getTheme().resolveAttribute(android.R.attr.disabledAlpha, alpha, true);
         mBackgroundPaint.setAlpha((int) (alpha.getFloat() * 255f));

         // Progress should not be color extracted
         mProgressPaint = new Paint();
         mProgressPaint.setStrokeWidth(mStrokeWidthPx);
         mProgressPaint.setColor(context.getColor(R.color.udfps_enroll_progress));
         mProgressPaint.setAntiAlias(true);
         mProgressPaint.setStyle(Paint.Style.STROKE);
         mProgressPaint.setStrokeCap(Paint.Cap.ROUND);

         mProgressUpdateListener = animation -> {
             mProgress = (float) animation.getAnimatedValue();
             mInvalidateRunnable.run();
         };

         mOverSweepUpdateListener = animation -> {
             mOverSweepAngle = (float) animation.getAnimatedValue();
             mInvalidateRunnable.run();
         };
         mOverSweepAnimationRunnable = () -> {
             if (mOverSweepAnimator != null && mOverSweepAnimator.isRunning()) {
                 mOverSweepAnimator.cancel();
             }
             mOverSweepAnimator = ValueAnimator.ofFloat(mOverSweepAngle, mMaxOverSweepAngle);
             mOverSweepAnimator.setDuration(OVER_SWEEP_ANIMATION_DURATION_MS);
             mOverSweepAnimator.addUpdateListener(mOverSweepUpdateListener);
             mOverSweepAnimator.start();
         };
     }

     /**
      * Draws this segment to the given canvas.
      */
     public void draw(@NonNull Canvas canvas) {
         Log.d(TAG, "draw: mProgress = " + mProgress);

         final float halfPaddingPx = mStrokeWidthPx / 2f;

         if (mProgress < 1f) {
             // Draw the unfilled background color of the segment.
             canvas.drawArc(
                     halfPaddingPx,
                     halfPaddingPx,
                     mBounds.right - halfPaddingPx,
                     mBounds.bottom - halfPaddingPx,
                     mStartAngle,
                     mSweepAngle,
                     false /* useCenter */,
                     mBackgroundPaint);
         }

         if (mProgress > 0f) {
             // Draw the filled progress portion of the segment.
             canvas.drawArc(
                     halfPaddingPx,
                     halfPaddingPx,
                     mBounds.right - halfPaddingPx,
                     mBounds.bottom - halfPaddingPx,
                     mStartAngle,
                     mSweepAngle * mProgress + mOverSweepAngle,
                     false /* useCenter */,
                     mProgressPaint);
         }
     }

     /**
      * @return Whether this segment is filled or in the process of being filled.
      */
     public boolean isFilledOrFilling() {
         return mIsFilledOrFilling;
     }

     /**
      * Updates the fill progress of this segment, animating if necessary.
      *
      * @param progress The new fill progress, in the range [0, 1].
      */
     public void updateProgress(float progress) {
         updateProgress(progress, PROGRESS_ANIMATION_DURATION_MS);
     }

     private void updateProgress(float progress, long animationDurationMs) {
         Log.d(TAG, "updateProgress: progress = " + progress
                 + ", duration = " + animationDurationMs);

         if (mProgress == progress) {
             Log.d(TAG, "updateProgress skipped: progress == mProgress");
             return;
         }

         mIsFilledOrFilling = progress >= 1f;

         if (mProgressAnimator != null && mProgressAnimator.isRunning()) {
             mProgressAnimator.cancel();
         }

         mProgressAnimator = ValueAnimator.ofFloat(mProgress, progress);
         mProgressAnimator.setDuration(animationDurationMs);
         mProgressAnimator.addUpdateListener(mProgressUpdateListener);
         mProgressAnimator.start();
     }

     /**
      * Queues and runs the completion animation for this segment.
      */
     public void startCompletionAnimation() {
         final boolean hasCallback = mHandler.hasCallbacks(mOverSweepAnimationRunnable);
         if (hasCallback || mOverSweepAngle >= mMaxOverSweepAngle) {
             Log.d(TAG, "startCompletionAnimation skipped: hasCallback = " + hasCallback
                     + ", mOverSweepAngle = " + mOverSweepAngle);
             return;
         }

         Log.d(TAG, "startCompletionAnimation: mProgress = " + mProgress
                 + ", mOverSweepAngle = " + mOverSweepAngle);

         // Reset sweep angle back to zero if the animation is being rolled back.
         if (mOverSweepReverseAnimator != null && mOverSweepReverseAnimator.isRunning()) {
             mOverSweepReverseAnimator.cancel();
             mOverSweepAngle = 0f;
         }

         // Start filling the segment if it isn't already.
         if (mProgress < 1f) {
             updateProgress(1f, OVER_SWEEP_ANIMATION_DELAY_MS);
         }

         // Queue the animation to run after fill completes.
         mHandler.postDelayed(mOverSweepAnimationRunnable, OVER_SWEEP_ANIMATION_DELAY_MS);
     }

     /**
      * Cancels (and reverses, if necessary) a queued or running completion animation.
      */
     public void cancelCompletionAnimation() {
         Log.d(TAG, "cancelCompletionAnimation: mProgress = " + mProgress
                 + ", mOverSweepAngle = " + mOverSweepAngle);

         // Cancel the animation if it's queued or running.
         mHandler.removeCallbacks(mOverSweepAnimationRunnable);
         if (mOverSweepAnimator != null && mOverSweepAnimator.isRunning()) {
             mOverSweepAnimator.cancel();
         }

         // Roll back the animation if it has at least partially run.
         if (mOverSweepAngle > 0f) {
             if (mOverSweepReverseAnimator != null && mOverSweepReverseAnimator.isRunning()) {
                 mOverSweepReverseAnimator.cancel();
             }

             final float completion = mOverSweepAngle / mMaxOverSweepAngle;
             final long proratedDuration = (long) (OVER_SWEEP_ANIMATION_DURATION_MS * completion);
             mOverSweepReverseAnimator = ValueAnimator.ofFloat(mOverSweepAngle, 0f);
             mOverSweepReverseAnimator.setDuration(proratedDuration);
             mOverSweepReverseAnimator.addUpdateListener(mOverSweepUpdateListener);
             mOverSweepReverseAnimator.start();
         }
     }
 }
	/*
	* Copyright (C) 2021 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.systemui.biometrics;

	import android.animation.ValueAnimator;
	import android.content.Context;
	import android.content.res.TypedArray;
	import android.graphics.Canvas;
	import android.graphics.Paint;
	import android.graphics.Rect;
	import android.os.Handler;
	import android.os.Looper;
	import android.util.Log;
	import android.util.TypedValue;

	import androidx.annotation.ColorInt;
	import androidx.annotation.NonNull;
	import androidx.annotation.Nullable;

	import com.android.systemui.R;

	/**
	* A single segment of the UDFPS enrollment progress bar.
	*/
	public class UdfpsEnrollProgressBarSegment {
	private static final String TAG = "UdfpsProgressBarSegment";

	private static final long PROGRESS_ANIMATION_DURATION_MS = 400L;
	private static final long OVER_SWEEP_ANIMATION_DELAY_MS = 200L;
	private static final long OVER_SWEEP_ANIMATION_DURATION_MS = 200L;

	private static final float STROKE_WIDTH_DP = 12f;

	private final Handler mHandler = new Handler(Looper.getMainLooper());

	@NonNull private final Rect mBounds;
	@NonNull private final Runnable mInvalidateRunnable;
	private final float mStartAngle;
	private final float mSweepAngle;
	private final float mMaxOverSweepAngle;
	private final float mStrokeWidthPx;

	@NonNull private final Paint mBackgroundPaint;
	@NonNull private final Paint mProgressPaint;

	private boolean mIsFilledOrFilling = false;

	private float mProgress = 0f;
	@Nullable private ValueAnimator mProgressAnimator;
	@NonNull private final ValueAnimator.AnimatorUpdateListener mProgressUpdateListener;

	private float mOverSweepAngle = 0f;
	@Nullable private ValueAnimator mOverSweepAnimator;
	@Nullable private ValueAnimator mOverSweepReverseAnimator;
	@NonNull private final ValueAnimator.AnimatorUpdateListener mOverSweepUpdateListener;
	@NonNull private final Runnable mOverSweepAnimationRunnable;

	public UdfpsEnrollProgressBarSegment(@NonNull Context context, @NonNull Rect bounds,
	float startAngle, float sweepAngle, float maxOverSweepAngle,
	@NonNull Runnable invalidateRunnable) {

	mBounds = bounds;
	mInvalidateRunnable = invalidateRunnable;
	mStartAngle = startAngle;
	mSweepAngle = sweepAngle;
	mMaxOverSweepAngle = maxOverSweepAngle;
	mStrokeWidthPx = Utils.dpToPixels(context, STROKE_WIDTH_DP);

	mBackgroundPaint = new Paint();
	mBackgroundPaint.setStrokeWidth(mStrokeWidthPx);
	mBackgroundPaint.setColor(context.getColor(R.color.white_disabled));
	mBackgroundPaint.setAntiAlias(true);
	mBackgroundPaint.setStyle(Paint.Style.STROKE);
	mBackgroundPaint.setStrokeCap(Paint.Cap.ROUND);

	// Background paint color + alpha
	final int[] attrs = new int[] {android.R.attr.colorControlNormal};
	final TypedArray ta = context.obtainStyledAttributes(attrs);
	@ColorInt final int tintColor = ta.getColor(0, mBackgroundPaint.getColor());
	mBackgroundPaint.setColor(tintColor);
	ta.recycle();
	TypedValue alpha = new TypedValue();
	context.getTheme().resolveAttribute(android.R.attr.disabledAlpha, alpha, true);
	mBackgroundPaint.setAlpha((int) (alpha.getFloat() * 255f));

	// Progress should not be color extracted
	mProgressPaint = new Paint();
	mProgressPaint.setStrokeWidth(mStrokeWidthPx);
	mProgressPaint.setColor(context.getColor(R.color.udfps_enroll_progress));
	mProgressPaint.setAntiAlias(true);
	mProgressPaint.setStyle(Paint.Style.STROKE);
	mProgressPaint.setStrokeCap(Paint.Cap.ROUND);

	mProgressUpdateListener = animation -> {
	mProgress = (float) animation.getAnimatedValue();
	mInvalidateRunnable.run();
	};

	mOverSweepUpdateListener = animation -> {
	mOverSweepAngle = (float) animation.getAnimatedValue();
	mInvalidateRunnable.run();
	};
	mOverSweepAnimationRunnable = () -> {
	if (mOverSweepAnimator != null && mOverSweepAnimator.isRunning()) {
	mOverSweepAnimator.cancel();
	}
	mOverSweepAnimator = ValueAnimator.ofFloat(mOverSweepAngle, mMaxOverSweepAngle);
	mOverSweepAnimator.setDuration(OVER_SWEEP_ANIMATION_DURATION_MS);
	mOverSweepAnimator.addUpdateListener(mOverSweepUpdateListener);
	mOverSweepAnimator.start();
	};
	}

	/**
	* Draws this segment to the given canvas.
	*/
	public void draw(@NonNull Canvas canvas) {
	Log.d(TAG, "draw: mProgress = " + mProgress);

	final float halfPaddingPx = mStrokeWidthPx / 2f;

	if (mProgress < 1f) {
	// Draw the unfilled background color of the segment.
	canvas.drawArc(
	halfPaddingPx,
	halfPaddingPx,
	mBounds.right - halfPaddingPx,
	mBounds.bottom - halfPaddingPx,
	mStartAngle,
	mSweepAngle,
	false /* useCenter */,
	mBackgroundPaint);
	}

	if (mProgress > 0f) {
	// Draw the filled progress portion of the segment.
	canvas.drawArc(
	halfPaddingPx,
	halfPaddingPx,
	mBounds.right - halfPaddingPx,
	mBounds.bottom - halfPaddingPx,
	mStartAngle,
	mSweepAngle * mProgress + mOverSweepAngle,
	false /* useCenter */,
	mProgressPaint);
	}
	}

	/**
	* @return Whether this segment is filled or in the process of being filled.
	*/
	public boolean isFilledOrFilling() {
	return mIsFilledOrFilling;
	}

	/**
	* Updates the fill progress of this segment, animating if necessary.
	*
	* @param progress The new fill progress, in the range [0, 1].
	*/
	public void updateProgress(float progress) {
	updateProgress(progress, PROGRESS_ANIMATION_DURATION_MS);
	}

	private void updateProgress(float progress, long animationDurationMs) {
	Log.d(TAG, "updateProgress: progress = " + progress
	+ ", duration = " + animationDurationMs);

	if (mProgress == progress) {
	Log.d(TAG, "updateProgress skipped: progress == mProgress");
	return;
	}

	mIsFilledOrFilling = progress >= 1f;

	if (mProgressAnimator != null && mProgressAnimator.isRunning()) {
	mProgressAnimator.cancel();
	}

	mProgressAnimator = ValueAnimator.ofFloat(mProgress, progress);
	mProgressAnimator.setDuration(animationDurationMs);
	mProgressAnimator.addUpdateListener(mProgressUpdateListener);
	mProgressAnimator.start();
	}

	/**
	* Queues and runs the completion animation for this segment.
	*/
	public void startCompletionAnimation() {
	final boolean hasCallback = mHandler.hasCallbacks(mOverSweepAnimationRunnable);
	if (hasCallback \|\| mOverSweepAngle >= mMaxOverSweepAngle) {
	Log.d(TAG, "startCompletionAnimation skipped: hasCallback = " + hasCallback
	+ ", mOverSweepAngle = " + mOverSweepAngle);
	return;
	}

	Log.d(TAG, "startCompletionAnimation: mProgress = " + mProgress
	+ ", mOverSweepAngle = " + mOverSweepAngle);

	// Reset sweep angle back to zero if the animation is being rolled back.
	if (mOverSweepReverseAnimator != null && mOverSweepReverseAnimator.isRunning()) {
	mOverSweepReverseAnimator.cancel();
	mOverSweepAngle = 0f;
	}

	// Start filling the segment if it isn't already.
	if (mProgress < 1f) {
	updateProgress(1f, OVER_SWEEP_ANIMATION_DELAY_MS);
	}

	// Queue the animation to run after fill completes.
	mHandler.postDelayed(mOverSweepAnimationRunnable, OVER_SWEEP_ANIMATION_DELAY_MS);
	}

	/**
	* Cancels (and reverses, if necessary) a queued or running completion animation.
	*/
	public void cancelCompletionAnimation() {
	Log.d(TAG, "cancelCompletionAnimation: mProgress = " + mProgress
	+ ", mOverSweepAngle = " + mOverSweepAngle);

	// Cancel the animation if it's queued or running.
	mHandler.removeCallbacks(mOverSweepAnimationRunnable);
	if (mOverSweepAnimator != null && mOverSweepAnimator.isRunning()) {
	mOverSweepAnimator.cancel();
	}

	// Roll back the animation if it has at least partially run.
	if (mOverSweepAngle > 0f) {
	if (mOverSweepReverseAnimator != null && mOverSweepReverseAnimator.isRunning()) {
	mOverSweepReverseAnimator.cancel();
	}

	final float completion = mOverSweepAngle / mMaxOverSweepAngle;
	final long proratedDuration = (long) (OVER_SWEEP_ANIMATION_DURATION_MS * completion);
	mOverSweepReverseAnimator = ValueAnimator.ofFloat(mOverSweepAngle, 0f);
	mOverSweepReverseAnimator.setDuration(proratedDuration);
	mOverSweepReverseAnimator.addUpdateListener(mOverSweepUpdateListener);
	mOverSweepReverseAnimator.start();
	}
	}
	}