diff --git a/packages/SystemUI/res/drawable/udfps_enroll_checkmark.xml b/packages/SystemUI/res/drawable/udfps_enroll_checkmark.xml new file mode 100644 index 0000000000000..f8169d377f12e --- /dev/null +++ b/packages/SystemUI/res/drawable/udfps_enroll_checkmark.xml @@ -0,0 +1,35 @@ + + + + + + + + diff --git a/packages/SystemUI/src/com/android/systemui/biometrics/UdfpsEnrollProgressBarDrawable.java b/packages/SystemUI/src/com/android/systemui/biometrics/UdfpsEnrollProgressBarDrawable.java index 11addf0e906bd..79c7e66d40f74 100644 --- a/packages/SystemUI/src/com/android/systemui/biometrics/UdfpsEnrollProgressBarDrawable.java +++ b/packages/SystemUI/src/com/android/systemui/biometrics/UdfpsEnrollProgressBarDrawable.java @@ -16,17 +16,22 @@ 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.ColorFilter; +import android.graphics.Paint; import android.graphics.drawable.Drawable; -import android.util.Log; +import android.util.TypedValue; +import android.view.animation.Interpolator; +import android.view.animation.OvershootInterpolator; +import androidx.annotation.ColorInt; import androidx.annotation.NonNull; import androidx.annotation.Nullable; -import java.util.ArrayList; -import java.util.List; +import com.android.systemui.R; /** * UDFPS enrollment progress bar. @@ -34,108 +39,193 @@ import java.util.List; public class UdfpsEnrollProgressBarDrawable extends Drawable { private static final String TAG = "UdfpsProgressBar"; - private static final float SEGMENT_GAP_ANGLE = 12f; + private static final long CHECKMARK_ANIMATION_DELAY_MS = 200L; + private static final long CHECKMARK_ANIMATION_DURATION_MS = 300L; + private static final long FILL_COLOR_ANIMATION_DURATION_MS = 200L; + private static final long PROGRESS_ANIMATION_DURATION_MS = 400L; + private static final float STROKE_WIDTH_DP = 12f; - @NonNull private final Context mContext; + private final float mStrokeWidthPx; + @ColorInt private final int mProgressColor; + @ColorInt private final int mHelpColor; + @NonNull private final Drawable mCheckmarkDrawable; + @NonNull private final Interpolator mCheckmarkInterpolator; + @NonNull private final Paint mBackgroundPaint; + @NonNull private final Paint mFillPaint; - @Nullable private UdfpsEnrollHelper mEnrollHelper; - @NonNull private List mSegments = new ArrayList<>(); + private boolean mAfterFirstTouch; + + private int mRemainingSteps = 0; private int mTotalSteps = 0; - private int mProgressSteps = 0; - private boolean mIsShowingHelp = false; + private float mProgress = 0f; + @Nullable private ValueAnimator mProgressAnimator; + @NonNull private final ValueAnimator.AnimatorUpdateListener mProgressUpdateListener; + + private boolean mShowingHelp = false; + @Nullable private ValueAnimator mFillColorAnimator; + @NonNull private final ValueAnimator.AnimatorUpdateListener mFillColorUpdateListener; + + private boolean mComplete = false; + private float mCheckmarkScale = 0f; + @Nullable private ValueAnimator mCheckmarkAnimator; + @NonNull private final ValueAnimator.AnimatorUpdateListener mCheckmarkUpdateListener; public UdfpsEnrollProgressBarDrawable(@NonNull Context context) { - mContext = context; - } + mStrokeWidthPx = Utils.dpToPixels(context, STROKE_WIDTH_DP); + mProgressColor = context.getColor(R.color.udfps_enroll_progress); + mHelpColor = context.getColor(R.color.udfps_enroll_progress_help); + mCheckmarkDrawable = context.getDrawable(R.drawable.udfps_enroll_checkmark); + mCheckmarkDrawable.mutate(); + mCheckmarkInterpolator = new OvershootInterpolator(); - void setEnrollHelper(@Nullable UdfpsEnrollHelper enrollHelper) { - mEnrollHelper = enrollHelper; - if (enrollHelper != null) { - final int stageCount = enrollHelper.getStageCount(); - mSegments = new ArrayList<>(stageCount); - float startAngle = SEGMENT_GAP_ANGLE / 2f; - final float sweepAngle = (360f / stageCount) - SEGMENT_GAP_ANGLE; - final Runnable invalidateRunnable = this::invalidateSelf; - for (int index = 0; index < stageCount; index++) { - mSegments.add(new UdfpsEnrollProgressBarSegment(mContext, getBounds(), startAngle, - sweepAngle, SEGMENT_GAP_ANGLE, invalidateRunnable)); - startAngle += sweepAngle + SEGMENT_GAP_ANGLE; - } - invalidateSelf(); + 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); + + // Set background paint color and alpha. + final int[] attrs = new int[] {android.R.attr.colorControlNormal}; + final TypedArray typedArray = context.obtainStyledAttributes(attrs); + try { + @ColorInt final int tintColor = typedArray.getColor(0, mBackgroundPaint.getColor()); + mBackgroundPaint.setColor(tintColor); + } finally { + typedArray.recycle(); } + TypedValue alpha = new TypedValue(); + context.getTheme().resolveAttribute(android.R.attr.disabledAlpha, alpha, true); + mBackgroundPaint.setAlpha((int) (alpha.getFloat() * 255f)); + + // Progress fill should *not* use the extracted system color. + mFillPaint = new Paint(); + mFillPaint.setStrokeWidth(mStrokeWidthPx); + mFillPaint.setColor(mProgressColor); + mFillPaint.setAntiAlias(true); + mFillPaint.setStyle(Paint.Style.STROKE); + mFillPaint.setStrokeCap(Paint.Cap.ROUND); + + mProgressUpdateListener = animation -> { + mProgress = (float) animation.getAnimatedValue(); + invalidateSelf(); + }; + + mFillColorUpdateListener = animation -> { + mFillPaint.setColor((int) animation.getAnimatedValue()); + invalidateSelf(); + }; + + mCheckmarkUpdateListener = animation -> { + mCheckmarkScale = (float) animation.getAnimatedValue(); + invalidateSelf(); + }; } void onEnrollmentProgress(int remaining, int totalSteps) { - mTotalSteps = totalSteps; - - // Show some progress for the initial touch. - updateState(Math.max(1, totalSteps - remaining), false /* isShowingHelp */); + mAfterFirstTouch = true; + updateState(remaining, totalSteps, false /* showingHelp */); } void onEnrollmentHelp(int remaining, int totalSteps) { - updateState(Math.max(0, totalSteps - remaining), true /* isShowingHelp */); + updateState(remaining, totalSteps, true /* showingHelp */); } void onLastStepAcquired() { - updateState(mTotalSteps, false /* isShowingHelp */); + updateState(0, mTotalSteps, false /* showingHelp */); } - private void updateState(int progressSteps, boolean isShowingHelp) { - updateProgress(progressSteps); - updateFillColor(isShowingHelp); + private void updateState(int remainingSteps, int totalSteps, boolean showingHelp) { + updateProgress(remainingSteps, totalSteps); + updateFillColor(showingHelp); } - private void updateProgress(int progressSteps) { - if (mProgressSteps == progressSteps) { + private void updateProgress(int remainingSteps, int totalSteps) { + if (mRemainingSteps == remainingSteps && mTotalSteps == totalSteps) { return; } - mProgressSteps = progressSteps; + mRemainingSteps = remainingSteps; + mTotalSteps = totalSteps; - if (mEnrollHelper == null) { - Log.e(TAG, "updateState: UDFPS enroll helper was null"); - return; + final int progressSteps = Math.max(0, totalSteps - remainingSteps); + + // If needed, add 1 to progress and total steps to account for initial touch. + final int adjustedSteps = mAfterFirstTouch ? progressSteps + 1 : progressSteps; + final int adjustedTotal = mAfterFirstTouch ? mTotalSteps + 1 : mTotalSteps; + + final float targetProgress = Math.min(1f, (float) adjustedSteps / (float) adjustedTotal); + + if (mProgressAnimator != null && mProgressAnimator.isRunning()) { + mProgressAnimator.cancel(); } - int index = 0; - int prevThreshold = 0; - while (index < mSegments.size()) { - final UdfpsEnrollProgressBarSegment segment = mSegments.get(index); - final int thresholdSteps = mEnrollHelper.getStageThresholdSteps(mTotalSteps, index); - if (progressSteps >= thresholdSteps && segment.getProgress() < 1f) { - segment.updateProgress(1f); - break; - } else if (progressSteps >= prevThreshold && progressSteps < thresholdSteps) { - final int relativeSteps = progressSteps - prevThreshold; - final int relativeThreshold = thresholdSteps - prevThreshold; - final float segmentProgress = (float) relativeSteps / (float) relativeThreshold; - segment.updateProgress(segmentProgress); - break; - } + mProgressAnimator = ValueAnimator.ofFloat(mProgress, targetProgress); + mProgressAnimator.setDuration(PROGRESS_ANIMATION_DURATION_MS); + mProgressAnimator.addUpdateListener(mProgressUpdateListener); + mProgressAnimator.start(); - index++; - prevThreshold = thresholdSteps; - } - - if (progressSteps >= mTotalSteps) { - for (final UdfpsEnrollProgressBarSegment segment : mSegments) { - segment.startCompletionAnimation(); - } - } else { - for (final UdfpsEnrollProgressBarSegment segment : mSegments) { - segment.cancelCompletionAnimation(); - } + if (remainingSteps == 0) { + startCompletionAnimation(); + } else if (remainingSteps > 0) { + rollBackCompletionAnimation(); } } - private void updateFillColor(boolean isShowingHelp) { - if (mIsShowingHelp == isShowingHelp) { + private void updateFillColor(boolean showingHelp) { + if (mShowingHelp == showingHelp) { return; } - mIsShowingHelp = isShowingHelp; + mShowingHelp = showingHelp; - for (final UdfpsEnrollProgressBarSegment segment : mSegments) { - segment.updateFillColor(isShowingHelp); + if (mFillColorAnimator != null && mFillColorAnimator.isRunning()) { + mFillColorAnimator.cancel(); } + + @ColorInt final int targetColor = showingHelp ? mHelpColor : mProgressColor; + mFillColorAnimator = ValueAnimator.ofArgb(mFillPaint.getColor(), targetColor); + mFillColorAnimator.setDuration(FILL_COLOR_ANIMATION_DURATION_MS); + mFillColorAnimator.addUpdateListener(mFillColorUpdateListener); + mFillColorAnimator.start(); + } + + private void startCompletionAnimation() { + if (mComplete) { + return; + } + mComplete = true; + + if (mCheckmarkAnimator != null && mCheckmarkAnimator.isRunning()) { + mCheckmarkAnimator.cancel(); + } + + mCheckmarkAnimator = ValueAnimator.ofFloat(mCheckmarkScale, 1f); + mCheckmarkAnimator.setStartDelay(CHECKMARK_ANIMATION_DELAY_MS); + mCheckmarkAnimator.setDuration(CHECKMARK_ANIMATION_DURATION_MS); + mCheckmarkAnimator.setInterpolator(mCheckmarkInterpolator); + mCheckmarkAnimator.addUpdateListener(mCheckmarkUpdateListener); + mCheckmarkAnimator.start(); + } + + private void rollBackCompletionAnimation() { + if (!mComplete) { + return; + } + mComplete = false; + + // Adjust duration based on how much of the completion animation has played. + final float animatedFraction = mCheckmarkAnimator != null + ? mCheckmarkAnimator.getAnimatedFraction() + : 0f; + final long durationMs = Math.round(CHECKMARK_ANIMATION_DELAY_MS * animatedFraction); + + if (mCheckmarkAnimator != null && mCheckmarkAnimator.isRunning()) { + mCheckmarkAnimator.cancel(); + } + + mCheckmarkAnimator = ValueAnimator.ofFloat(mCheckmarkScale, 0f); + mCheckmarkAnimator.setDuration(durationMs); + mCheckmarkAnimator.addUpdateListener(mCheckmarkUpdateListener); + mCheckmarkAnimator.start(); } @Override @@ -145,12 +235,55 @@ public class UdfpsEnrollProgressBarDrawable extends Drawable { // Progress starts from the top, instead of the right canvas.rotate(-90f, getBounds().centerX(), getBounds().centerY()); - // Draw each of the enroll segments. - for (final UdfpsEnrollProgressBarSegment segment : mSegments) { - segment.draw(canvas); + final float halfPaddingPx = mStrokeWidthPx / 2f; + + if (mProgress < 1f) { + // Draw the background color of the progress circle. + canvas.drawArc( + halfPaddingPx, + halfPaddingPx, + getBounds().right - halfPaddingPx, + getBounds().bottom - halfPaddingPx, + 0f /* startAngle */, + 360f /* sweepAngle */, + false /* useCenter */, + mBackgroundPaint); + } + + if (mProgress > 0f) { + // Draw the filled portion of the progress circle. + canvas.drawArc( + halfPaddingPx, + halfPaddingPx, + getBounds().right - halfPaddingPx, + getBounds().bottom - halfPaddingPx, + 0f /* startAngle */, + 360f * mProgress /* sweepAngle */, + false /* useCenter */, + mFillPaint); } canvas.restore(); + + if (mCheckmarkScale > 0f) { + final float offsetScale = (float) Math.sqrt(2) / 2f; + final float centerXOffset = (getBounds().width() - mStrokeWidthPx) / 2f * offsetScale; + final float centerYOffset = (getBounds().height() - mStrokeWidthPx) / 2f * offsetScale; + final float centerX = getBounds().centerX() + centerXOffset; + final float centerY = getBounds().centerY() + centerYOffset; + + final float boundsXOffset = + mCheckmarkDrawable.getIntrinsicWidth() / 2f * mCheckmarkScale; + final float boundsYOffset = + mCheckmarkDrawable.getIntrinsicHeight() / 2f * mCheckmarkScale; + + final int left = Math.round(centerX - boundsXOffset); + final int top = Math.round(centerY - boundsYOffset); + final int right = Math.round(centerX + boundsXOffset); + final int bottom = Math.round(centerY + boundsYOffset); + mCheckmarkDrawable.setBounds(left, top, right, bottom); + mCheckmarkDrawable.draw(canvas); + } } @Override diff --git a/packages/SystemUI/src/com/android/systemui/biometrics/UdfpsEnrollProgressBarSegment.java b/packages/SystemUI/src/com/android/systemui/biometrics/UdfpsEnrollProgressBarSegment.java deleted file mode 100644 index bd6ab4443630b..0000000000000 --- a/packages/SystemUI/src/com/android/systemui/biometrics/UdfpsEnrollProgressBarSegment.java +++ /dev/null @@ -1,280 +0,0 @@ -/* - * 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 FILL_COLOR_ANIMATION_DURATION_MS = 200L; - 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; - @ColorInt private final int mProgressColor; - @ColorInt private final int mHelpColor; - - @NonNull private final Paint mBackgroundPaint; - @NonNull private final Paint mProgressPaint; - - private float mProgress = 0f; - private float mAnimatedProgress = 0f; - @Nullable private ValueAnimator mProgressAnimator; - @NonNull private final ValueAnimator.AnimatorUpdateListener mProgressUpdateListener; - - private boolean mIsShowingHelp = false; - @Nullable private ValueAnimator mFillColorAnimator; - @NonNull private final ValueAnimator.AnimatorUpdateListener mFillColorUpdateListener; - - 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); - mProgressColor = context.getColor(R.color.udfps_enroll_progress); - mHelpColor = context.getColor(R.color.udfps_enroll_progress_help); - - 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(mProgressColor); - mProgressPaint.setAntiAlias(true); - mProgressPaint.setStyle(Paint.Style.STROKE); - mProgressPaint.setStrokeCap(Paint.Cap.ROUND); - - mProgressUpdateListener = animation -> { - mAnimatedProgress = (float) animation.getAnimatedValue(); - mInvalidateRunnable.run(); - }; - - mFillColorUpdateListener = animation -> { - mProgressPaint.setColor((int) 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) { - final float halfPaddingPx = mStrokeWidthPx / 2f; - - if (mAnimatedProgress < 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 (mAnimatedProgress > 0f) { - // Draw the filled progress portion of the segment. - canvas.drawArc( - halfPaddingPx, - halfPaddingPx, - mBounds.right - halfPaddingPx, - mBounds.bottom - halfPaddingPx, - mStartAngle, - mSweepAngle * mAnimatedProgress + mOverSweepAngle, - false /* useCenter */, - mProgressPaint); - } - } - - /** - * @return The fill progress of this segment, in the range [0, 1]. If fill progress is being - * animated, returns the value it is animating to. - */ - public float getProgress() { - return mProgress; - } - - /** - * 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) { - if (mProgress == progress) { - return; - } - mProgress = progress; - - if (mProgressAnimator != null && mProgressAnimator.isRunning()) { - mProgressAnimator.cancel(); - } - - mProgressAnimator = ValueAnimator.ofFloat(mAnimatedProgress, progress); - mProgressAnimator.setDuration(animationDurationMs); - mProgressAnimator.addUpdateListener(mProgressUpdateListener); - mProgressAnimator.start(); - } - - /** - * Updates the fill color of this segment, animating if necessary. - * - * @param isShowingHelp Whether fill color should indicate that a help message is being shown. - */ - public void updateFillColor(boolean isShowingHelp) { - if (mIsShowingHelp == isShowingHelp) { - return; - } - mIsShowingHelp = isShowingHelp; - - if (mFillColorAnimator != null && mFillColorAnimator.isRunning()) { - mFillColorAnimator.cancel(); - } - - @ColorInt final int targetColor = isShowingHelp ? mHelpColor : mProgressColor; - mFillColorAnimator = ValueAnimator.ofArgb(mProgressPaint.getColor(), targetColor); - mFillColorAnimator.setDuration(FILL_COLOR_ANIMATION_DURATION_MS); - mFillColorAnimator.addUpdateListener(mFillColorUpdateListener); - mFillColorAnimator.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; - } - - // Reset sweep angle back to zero if the animation is being rolled back. - if (mOverSweepReverseAnimator != null && mOverSweepReverseAnimator.isRunning()) { - mOverSweepReverseAnimator.cancel(); - mOverSweepAngle = 0f; - } - - // Clear help color and start filling the segment if it isn't already. - if (mAnimatedProgress < 1f) { - updateProgress(1f, OVER_SWEEP_ANIMATION_DELAY_MS); - updateFillColor(false /* isShowingHelp */); - } - - // 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() { - // 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(); - } - } -} diff --git a/packages/SystemUI/src/com/android/systemui/biometrics/UdfpsEnrollView.java b/packages/SystemUI/src/com/android/systemui/biometrics/UdfpsEnrollView.java index 729838ed59aae..93df2cf0f8355 100644 --- a/packages/SystemUI/src/com/android/systemui/biometrics/UdfpsEnrollView.java +++ b/packages/SystemUI/src/com/android/systemui/biometrics/UdfpsEnrollView.java @@ -73,7 +73,6 @@ public class UdfpsEnrollView extends UdfpsAnimationView { } void setEnrollHelper(UdfpsEnrollHelper enrollHelper) { - mFingerprintProgressDrawable.setEnrollHelper(enrollHelper); mFingerprintDrawable.setEnrollHelper(enrollHelper); }