| /* |
| * Copyright (C) 2018 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.Animator; |
| import android.animation.AnimatorListenerAdapter; |
| import android.animation.AnimatorSet; |
| import android.animation.ValueAnimator; |
| import android.content.Context; |
| import android.graphics.Outline; |
| import android.graphics.drawable.Animatable2; |
| import android.graphics.drawable.AnimatedVectorDrawable; |
| import android.graphics.drawable.Drawable; |
| import android.hardware.biometrics.BiometricPrompt; |
| import android.os.Bundle; |
| import android.text.TextUtils; |
| import android.util.DisplayMetrics; |
| import android.util.Log; |
| import android.view.View; |
| import android.view.ViewOutlineProvider; |
| |
| import com.android.systemui.R; |
| |
| /** |
| * This class loads the view for the system-provided dialog. The view consists of: |
| * Application Icon, Title, Subtitle, Description, Biometric Icon, Error/Help message area, |
| * and positive/negative buttons. |
| */ |
| public class FaceDialogView extends BiometricDialogView { |
| |
| private static final String TAG = "FaceDialogView"; |
| private static final String KEY_DIALOG_SIZE = "key_dialog_size"; |
| private static final String KEY_DIALOG_ANIMATED_IN = "key_dialog_animated_in"; |
| |
| private static final int HIDE_DIALOG_DELAY = 500; // ms |
| private static final int IMPLICIT_Y_PADDING = 16; // dp |
| private static final int GROW_DURATION = 150; // ms |
| private static final int TEXT_ANIMATE_DISTANCE = 32; // dp |
| |
| private static final int SIZE_UNKNOWN = 0; |
| private static final int SIZE_SMALL = 1; |
| private static final int SIZE_GROWING = 2; |
| private static final int SIZE_BIG = 3; |
| |
| private int mSize; |
| private float mIconOriginalY; |
| private DialogOutlineProvider mOutlineProvider = new DialogOutlineProvider(); |
| private IconController mIconController; |
| private boolean mDialogAnimatedIn; |
| |
| /** |
| * Class that handles the biometric icon animations. |
| */ |
| private final class IconController extends Animatable2.AnimationCallback { |
| |
| private boolean mLastPulseDirection; // false = dark to light, true = light to dark |
| |
| int mState; |
| |
| IconController() { |
| mState = STATE_IDLE; |
| } |
| |
| public void animateOnce(int iconRes) { |
| animateIcon(iconRes, false); |
| } |
| |
| public void showStatic(int iconRes) { |
| mBiometricIcon.setImageDrawable(mContext.getDrawable(iconRes)); |
| } |
| |
| public void startPulsing() { |
| mLastPulseDirection = false; |
| animateIcon(R.drawable.face_dialog_pulse_dark_to_light, true); |
| } |
| |
| public void showIcon(int iconRes) { |
| final Drawable drawable = mContext.getDrawable(iconRes); |
| mBiometricIcon.setImageDrawable(drawable); |
| } |
| |
| private void animateIcon(int iconRes, boolean repeat) { |
| final AnimatedVectorDrawable icon = |
| (AnimatedVectorDrawable) mContext.getDrawable(iconRes); |
| mBiometricIcon.setImageDrawable(icon); |
| icon.forceAnimationOnUI(); |
| if (repeat) { |
| icon.registerAnimationCallback(this); |
| } |
| icon.start(); |
| } |
| |
| private void pulseInNextDirection() { |
| int iconRes = mLastPulseDirection ? R.drawable.face_dialog_pulse_dark_to_light |
| : R.drawable.face_dialog_pulse_light_to_dark; |
| animateIcon(iconRes, true /* repeat */); |
| mLastPulseDirection = !mLastPulseDirection; |
| } |
| |
| @Override |
| public void onAnimationEnd(Drawable drawable) { |
| super.onAnimationEnd(drawable); |
| |
| if (mState == STATE_AUTHENTICATING) { |
| // Still authenticating, pulse the icon |
| pulseInNextDirection(); |
| } |
| } |
| } |
| |
| private final class DialogOutlineProvider extends ViewOutlineProvider { |
| |
| float mY; |
| |
| @Override |
| public void getOutline(View view, Outline outline) { |
| outline.setRoundRect( |
| 0 /* left */, |
| (int) mY, /* top */ |
| mDialog.getWidth() /* right */, |
| mDialog.getBottom(), /* bottom */ |
| getResources().getDimension(R.dimen.biometric_dialog_corner_size)); |
| } |
| |
| int calculateSmall() { |
| final float padding = dpToPixels(IMPLICIT_Y_PADDING); |
| return mDialog.getHeight() - mBiometricIcon.getHeight() - 2 * (int) padding; |
| } |
| |
| void setOutlineY(float y) { |
| mY = y; |
| } |
| } |
| |
| private final Runnable mErrorToIdleAnimationRunnable = () -> { |
| updateState(STATE_IDLE); |
| mErrorText.setVisibility(View.INVISIBLE); |
| }; |
| |
| public FaceDialogView(Context context, |
| DialogViewCallback callback) { |
| super(context, callback); |
| mIconController = new IconController(); |
| } |
| |
| private void updateSize(int newSize) { |
| final float padding = dpToPixels(IMPLICIT_Y_PADDING); |
| final float iconSmallPositionY = mDialog.getHeight() - mBiometricIcon.getHeight() - padding; |
| |
| if (newSize == SIZE_SMALL) { |
| // These fields are required and/or always hold a spot on the UI, so should be set to |
| // INVISIBLE so they keep their position |
| mTitleText.setVisibility(View.INVISIBLE); |
| mErrorText.setVisibility(View.INVISIBLE); |
| mNegativeButton.setVisibility(View.INVISIBLE); |
| |
| // These fields are optional, so set them to gone or invisible depending on their |
| // usage. If they're empty, they're already set to GONE in BiometricDialogView. |
| if (!TextUtils.isEmpty(mSubtitleText.getText())) { |
| mSubtitleText.setVisibility(View.INVISIBLE); |
| } |
| if (!TextUtils.isEmpty(mDescriptionText.getText())) { |
| mDescriptionText.setVisibility(View.INVISIBLE); |
| } |
| |
| // Move the biometric icon to the small spot |
| mBiometricIcon.setY(iconSmallPositionY); |
| |
| // Clip the dialog to the small size |
| mDialog.setOutlineProvider(mOutlineProvider); |
| mOutlineProvider.setOutlineY(mOutlineProvider.calculateSmall()); |
| |
| mDialog.setClipToOutline(true); |
| mDialog.invalidateOutline(); |
| |
| mSize = newSize; |
| } else if (mSize == SIZE_SMALL && newSize == SIZE_BIG) { |
| mSize = SIZE_GROWING; |
| |
| // Animate the outline |
| final ValueAnimator outlineAnimator = |
| ValueAnimator.ofFloat(mOutlineProvider.calculateSmall(), 0); |
| outlineAnimator.addUpdateListener((animation) -> { |
| final float y = (float) animation.getAnimatedValue(); |
| mOutlineProvider.setOutlineY(y); |
| mDialog.invalidateOutline(); |
| }); |
| |
| // Animate the icon back to original big position |
| final ValueAnimator iconAnimator = |
| ValueAnimator.ofFloat(iconSmallPositionY, mIconOriginalY); |
| iconAnimator.addUpdateListener((animation) -> { |
| final float y = (float) animation.getAnimatedValue(); |
| mBiometricIcon.setY(y); |
| }); |
| |
| // Animate the error text so it slides up with the icon |
| final ValueAnimator textSlideAnimator = |
| ValueAnimator.ofFloat(dpToPixels(TEXT_ANIMATE_DISTANCE), 0); |
| textSlideAnimator.addUpdateListener((animation) -> { |
| final float y = (float) animation.getAnimatedValue(); |
| mErrorText.setTranslationY(y); |
| }); |
| |
| // Opacity animator for things that should fade in (title, subtitle, details, negative |
| // button) |
| final ValueAnimator opacityAnimator = ValueAnimator.ofFloat(0, 1); |
| opacityAnimator.addUpdateListener((animation) -> { |
| final float opacity = (float) animation.getAnimatedValue(); |
| |
| // These fields are required and/or always hold a spot on the UI |
| mTitleText.setAlpha(opacity); |
| mErrorText.setAlpha(opacity); |
| mNegativeButton.setAlpha(opacity); |
| mTryAgainButton.setAlpha(opacity); |
| |
| // These fields are optional, so only animate them if they're supposed to be showing |
| if (!TextUtils.isEmpty(mSubtitleText.getText())) { |
| mSubtitleText.setAlpha(opacity); |
| } |
| if (!TextUtils.isEmpty(mDescriptionText.getText())) { |
| mDescriptionText.setAlpha(opacity); |
| } |
| }); |
| |
| // Choreograph together |
| final AnimatorSet as = new AnimatorSet(); |
| as.setDuration(GROW_DURATION); |
| as.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationStart(Animator animation) { |
| super.onAnimationStart(animation); |
| // Set the visibility of opacity-animating views back to VISIBLE |
| mTitleText.setVisibility(View.VISIBLE); |
| mErrorText.setVisibility(View.VISIBLE); |
| mNegativeButton.setVisibility(View.VISIBLE); |
| mTryAgainButton.setVisibility(View.VISIBLE); |
| |
| if (!TextUtils.isEmpty(mSubtitleText.getText())) { |
| mSubtitleText.setVisibility(View.VISIBLE); |
| } |
| if (!TextUtils.isEmpty(mDescriptionText.getText())) { |
| mDescriptionText.setVisibility(View.VISIBLE); |
| } |
| } |
| |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| super.onAnimationEnd(animation); |
| mSize = SIZE_BIG; |
| } |
| }); |
| as.play(outlineAnimator).with(iconAnimator).with(opacityAnimator) |
| .with(textSlideAnimator); |
| as.start(); |
| } else if (mSize == SIZE_BIG) { |
| mDialog.setClipToOutline(false); |
| mDialog.invalidateOutline(); |
| |
| mBiometricIcon.setY(mIconOriginalY); |
| |
| mSize = newSize; |
| } |
| } |
| |
| @Override |
| public void onSaveState(Bundle bundle) { |
| super.onSaveState(bundle); |
| bundle.putInt(KEY_DIALOG_SIZE, mSize); |
| bundle.putBoolean(KEY_DIALOG_ANIMATED_IN, mDialogAnimatedIn); |
| } |
| |
| |
| @Override |
| protected void handleResetMessage() { |
| mErrorText.setText(getHintStringResourceId()); |
| mErrorText.setContentDescription(mContext.getString(getHintStringResourceId())); |
| mErrorText.setTextColor(mTextColor); |
| if (getState() == STATE_AUTHENTICATING) { |
| mErrorText.setVisibility(View.VISIBLE); |
| } else { |
| mErrorText.setVisibility(View.INVISIBLE); |
| } |
| } |
| |
| @Override |
| public void restoreState(Bundle bundle) { |
| super.restoreState(bundle); |
| // Keep in mind that this happens before onAttachedToWindow() |
| mSize = bundle.getInt(KEY_DIALOG_SIZE); |
| mDialogAnimatedIn = bundle.getBoolean(KEY_DIALOG_ANIMATED_IN); |
| } |
| |
| /** |
| * Do small/big layout here instead of onAttachedToWindow, since: |
| * 1) We need the big layout to be measured, etc for small -> big animation |
| * 2) We need the dialog measurements to know where to move the biometric icon to |
| * |
| * BiometricDialogView already sets the views to their default big state, so here we only |
| * need to hide the ones that are unnecessary. |
| */ |
| @Override |
| public void onLayout(boolean changed, int left, int top, int right, int bottom) { |
| super.onLayout(changed, left, top, right, bottom); |
| |
| if (mIconOriginalY == 0) { |
| mIconOriginalY = mBiometricIcon.getY(); |
| } |
| |
| // UNKNOWN means size hasn't been set yet. First time we create the dialog. |
| // onLayout can happen when visibility of views change (during animation, etc). |
| if (mSize != SIZE_UNKNOWN) { |
| // Probably not the cleanest way to do this, but since dialog is big by default, |
| // and small dialogs can persist across orientation changes, we need to set it to |
| // small size here again. |
| if (mSize == SIZE_SMALL) { |
| updateSize(SIZE_SMALL); |
| } |
| return; |
| } |
| |
| // If we don't require confirmation, show the small dialog first (until errors occur). |
| if (!requiresConfirmation()) { |
| updateSize(SIZE_SMALL); |
| } else { |
| updateSize(SIZE_BIG); |
| } |
| } |
| |
| @Override |
| public void onErrorReceived(String error) { |
| super.onErrorReceived(error); |
| // All error messages will cause the dialog to go from small -> big. Error messages |
| // are messages such as lockout, auth failed, etc. |
| if (mSize == SIZE_SMALL) { |
| updateSize(SIZE_BIG); |
| } |
| } |
| |
| @Override |
| public void onAuthenticationFailed(String message) { |
| super.onAuthenticationFailed(message); |
| showTryAgainButton(true); |
| } |
| |
| @Override |
| public void showTryAgainButton(boolean show) { |
| if (show && mSize == SIZE_SMALL) { |
| // Do not call super, we will nicely animate the alpha together with the rest |
| // of the elements in here. |
| updateSize(SIZE_BIG); |
| } else { |
| if (show) { |
| mTryAgainButton.setVisibility(View.VISIBLE); |
| } else { |
| mTryAgainButton.setVisibility(View.GONE); |
| } |
| } |
| |
| if (show) { |
| mPositiveButton.setVisibility(View.GONE); |
| } |
| } |
| |
| @Override |
| protected int getHintStringResourceId() { |
| return R.string.face_dialog_looking_for_face; |
| } |
| |
| @Override |
| protected int getAuthenticatedAccessibilityResourceId() { |
| if (mRequireConfirmation) { |
| return com.android.internal.R.string.face_authenticated_confirmation_required; |
| } else { |
| return com.android.internal.R.string.face_authenticated_no_confirmation_required; |
| } |
| } |
| |
| @Override |
| protected int getIconDescriptionResourceId() { |
| return R.string.accessibility_face_dialog_face_icon; |
| } |
| |
| @Override |
| protected void updateIcon(int oldState, int newState) { |
| mIconController.mState = newState; |
| |
| if (newState == STATE_AUTHENTICATING) { |
| mHandler.removeCallbacks(mErrorToIdleAnimationRunnable); |
| if (mDialogAnimatedIn) { |
| mIconController.startPulsing(); |
| mErrorText.setVisibility(View.VISIBLE); |
| } else { |
| mIconController.showIcon(R.drawable.face_dialog_pulse_dark_to_light); |
| } |
| mBiometricIcon.setContentDescription(mContext.getString( |
| R.string.biometric_dialog_face_icon_description_authenticating)); |
| } else if (oldState == STATE_PENDING_CONFIRMATION && newState == STATE_AUTHENTICATED) { |
| mIconController.animateOnce(R.drawable.face_dialog_dark_to_checkmark); |
| mBiometricIcon.setContentDescription(mContext.getString( |
| R.string.biometric_dialog_face_icon_description_confirmed)); |
| } else if (oldState == STATE_ERROR && newState == STATE_IDLE) { |
| mIconController.animateOnce(R.drawable.face_dialog_error_to_idle); |
| mBiometricIcon.setContentDescription(mContext.getString( |
| R.string.biometric_dialog_face_icon_description_idle)); |
| } else if (oldState == STATE_ERROR && newState == STATE_AUTHENTICATED) { |
| mHandler.removeCallbacks(mErrorToIdleAnimationRunnable); |
| mIconController.animateOnce(R.drawable.face_dialog_dark_to_checkmark); |
| mBiometricIcon.setContentDescription(mContext.getString( |
| R.string.biometric_dialog_face_icon_description_authenticated)); |
| } else if (newState == STATE_ERROR) { |
| // It's easier to only check newState and gate showing the animation on the |
| // mErrorToIdleAnimationRunnable as a proxy, than add a ton of extra state. For example, |
| // we may go from error -> error due to configuration change which is valid and we |
| // should show the animation, or we can go from error -> error by receiving repeated |
| // acquire messages in which case we do not want to repeatedly start the animation. |
| if (!mHandler.hasCallbacks(mErrorToIdleAnimationRunnable)) { |
| mIconController.animateOnce(R.drawable.face_dialog_dark_to_error); |
| mHandler.postDelayed(mErrorToIdleAnimationRunnable, |
| BiometricPrompt.HIDE_DIALOG_DELAY); |
| } |
| } else if (oldState == STATE_AUTHENTICATING && newState == STATE_AUTHENTICATED) { |
| mIconController.animateOnce(R.drawable.face_dialog_dark_to_checkmark); |
| mBiometricIcon.setContentDescription(mContext.getString( |
| R.string.biometric_dialog_face_icon_description_authenticated)); |
| } else if (newState == STATE_PENDING_CONFIRMATION) { |
| mHandler.removeCallbacks(mErrorToIdleAnimationRunnable); |
| mIconController.animateOnce(R.drawable.face_dialog_wink_from_dark); |
| mBiometricIcon.setContentDescription(mContext.getString( |
| R.string.biometric_dialog_face_icon_description_authenticated)); |
| } else if (newState == STATE_IDLE) { |
| mIconController.showStatic(R.drawable.face_dialog_idle_static); |
| mBiometricIcon.setContentDescription(mContext.getString( |
| R.string.biometric_dialog_face_icon_description_idle)); |
| } else { |
| Log.w(TAG, "Unknown animation from " + oldState + " -> " + newState); |
| } |
| |
| // Note that this must be after the newState == STATE_ERROR check above since this affects |
| // the logic. |
| if (oldState == STATE_ERROR && newState == STATE_ERROR) { |
| // Keep the error icon and text around for a while longer if we keep receiving |
| // STATE_ERROR |
| mHandler.removeCallbacks(mErrorToIdleAnimationRunnable); |
| mHandler.postDelayed(mErrorToIdleAnimationRunnable, BiometricPrompt.HIDE_DIALOG_DELAY); |
| } |
| } |
| |
| @Override |
| public void onDialogAnimatedIn() { |
| mDialogAnimatedIn = true; |
| mIconController.startPulsing(); |
| } |
| |
| @Override |
| protected int getDelayAfterAuthenticatedDurationMs() { |
| return HIDE_DIALOG_DELAY; |
| } |
| |
| @Override |
| protected boolean shouldGrayAreaDismissDialog() { |
| if (mSize == SIZE_SMALL) { |
| return false; |
| } |
| return true; |
| } |
| |
| private float dpToPixels(float dp) { |
| return dp * ((float) mContext.getResources().getDisplayMetrics().densityDpi |
| / DisplayMetrics.DENSITY_DEFAULT); |
| } |
| |
| private float pixelsToDp(float pixels) { |
| return pixels / ((float) mContext.getResources().getDisplayMetrics().densityDpi |
| / DisplayMetrics.DENSITY_DEFAULT); |
| } |
| } |
