diff --git a/aconfig/settings_biometrics_integration_declarations.aconfig b/aconfig/settings_biometrics_integration_declarations.aconfig index 9bded6a79ce..0ad028ef0a4 100644 --- a/aconfig/settings_biometrics_integration_declarations.aconfig +++ b/aconfig/settings_biometrics_integration_declarations.aconfig @@ -15,6 +15,16 @@ flag { bug: "301226085" } +flag { + name: "enroll_layout_truncate_improvement" + namespace: "biometrics_integration" + description: "This flag controls whether the enroll layout truncate improvement feature should be enabled" + bug: "359149850" + metadata { + purpose: PURPOSE_BUGFIX + } +} + flag { name: "screen_off_unlock_power_optimization" namespace: "biometrics_integration" diff --git a/res/layout/biometrics_glif_compact.xml b/res/layout/biometrics_glif_compact.xml new file mode 100644 index 00000000000..5de78dae724 --- /dev/null +++ b/res/layout/biometrics_glif_compact.xml @@ -0,0 +1,26 @@ + + + + + + + + diff --git a/res/layout/biometrics_glif_content.xml b/res/layout/biometrics_glif_content.xml new file mode 100644 index 00000000000..6cddccb4da1 --- /dev/null +++ b/res/layout/biometrics_glif_content.xml @@ -0,0 +1,82 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/res/layout/udfps_enroll_enrolling.xml b/res/layout/udfps_enroll_enrolling.xml index 366a87c4740..ef8cb71729d 100644 --- a/res/layout/udfps_enroll_enrolling.xml +++ b/res/layout/udfps_enroll_enrolling.xml @@ -24,58 +24,66 @@ android:layout_height="match_parent" style="?attr/fingerprint_layout_theme"> - + android:clipChildren="false"> + + - + - - + - + - + - - - + + + + diff --git a/res/layout/udfps_enroll_enrolling_non_scroll.xml b/res/layout/udfps_enroll_enrolling_non_scroll.xml new file mode 100644 index 00000000000..deb90919a0d --- /dev/null +++ b/res/layout/udfps_enroll_enrolling_non_scroll.xml @@ -0,0 +1,81 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/res/values/config.xml b/res/values/config.xml index 09f941ff757..4e4c5c4c1c0 100644 --- a/res/values/config.xml +++ b/res/values/config.xml @@ -772,6 +772,9 @@ 58.0001 29.2229,56.9551 26.8945,55.195 + + 1000 + false diff --git a/res/values/dimens.xml b/res/values/dimens.xml index 5961b95a606..96bbaed9b5b 100755 --- a/res/values/dimens.xml +++ b/res/values/dimens.xml @@ -159,6 +159,10 @@ -24dp 0dp 20dp + 274dp + 0.27 + + 0.37 0 diff --git a/src/com/android/settings/biometrics/fingerprint/FingerprintEnrollEnrolling.java b/src/com/android/settings/biometrics/fingerprint/FingerprintEnrollEnrolling.java index 03010bbe739..1de8379bd76 100644 --- a/src/com/android/settings/biometrics/fingerprint/FingerprintEnrollEnrolling.java +++ b/src/com/android/settings/biometrics/fingerprint/FingerprintEnrollEnrolling.java @@ -57,6 +57,7 @@ import android.view.animation.AnimationUtils; import android.view.animation.Interpolator; import android.widget.ProgressBar; import android.widget.RelativeLayout; +import android.widget.ScrollView; import android.widget.TextView; import androidx.annotation.IdRes; @@ -72,6 +73,7 @@ import com.android.settings.biometrics.BiometricsEnrollEnrolling; import com.android.settings.biometrics.BiometricsSplitScreenDialog; import com.android.settings.biometrics.fingerprint.feature.SfpsEnrollmentFeature; import com.android.settings.core.instrumentation.InstrumentedDialogFragment; +import com.android.settings.flags.Flags; import com.android.settings.overlay.FeatureFactory; import com.android.settingslib.display.DisplayDensityUtils; import com.android.systemui.unfold.compat.ScreenSizeFoldProvider; @@ -243,16 +245,36 @@ public class FingerprintEnrollEnrolling extends BiometricsEnrollEnrolling { mIsAccessibilityEnabled = mAccessibilityManager.isEnabled(); listenOrientationEvent(); - if (mCanAssumeUdfps) { + final int rotation = getApplicationContext().getDisplay().getRotation(); + final boolean isPortrait = (rotation == Surface.ROTATION_0) + || (rotation == Surface.ROTATION_180); + final UdfpsEnrollEnrollingView layout = (UdfpsEnrollEnrollingView) getLayoutInflater().inflate( - R.layout.udfps_enroll_enrolling, null, false); + Flags.enrollLayoutTruncateImprovement() + ? R.layout.udfps_enroll_enrolling : + R.layout.udfps_enroll_enrolling_non_scroll, null, false); setUdfpsEnrollHelper(); layout.initView(props.get(0), mUdfpsEnrollHelper, mAccessibilityManager); - setContentView(layout); setDescriptionText(R.string.security_settings_udfps_enroll_start_message); + + if (Flags.enrollLayoutTruncateImprovement() && isPortrait) { + final UdfpsEnrollEnrollingView layoutView = (UdfpsEnrollEnrollingView) getLayout(); + if (layoutView != null) { + final ScrollView headerScrollView = layout.findViewById( + R.id.sud_header_scroll_view); + if (headerScrollView != null) { + final long headerScrollDuration = getResources().getInteger( + R.integer.config_biometrics_header_scroll_duration); + layoutView.adjustScrollableHeaderHeight( + headerScrollView, mShouldShowLottie); + layoutView.headerVerticalScrolling(headerScrollView, headerScrollDuration); + } + } + } + } else if (mCanAssumeSfps) { mSfpsEnrollmentFeature = FeatureFactory.getFeatureFactory() .getFingerprintFeatureProvider().getSfpsEnrollmentFeature(); @@ -1199,6 +1221,24 @@ public class FingerprintEnrollEnrolling extends BiometricsEnrollEnrolling { } } + @Override + public void onWindowFocusChanged(boolean hasWindowFocus) { + super.onWindowFocusChanged(hasWindowFocus); + if (Flags.enrollLayoutTruncateImprovement()) { + adjustEnrollViewIfOverlappedWithFooterBar(); + } + } + + private void adjustEnrollViewIfOverlappedWithFooterBar() { + if (mCanAssumeUdfps) { + final UdfpsEnrollEnrollingView layoutView = (UdfpsEnrollEnrollingView) getLayout(); + if (layoutView != null) { + layoutView.adjustUdfpsVieWithFooterBar(); + layoutView.onUdfpsSensorRectUpdated(); + } + } + } + public static class IconTouchDialog extends InstrumentedDialogFragment { @Override diff --git a/src/com/android/settings/biometrics/fingerprint/UdfpsEnrollEnrollingView.java b/src/com/android/settings/biometrics/fingerprint/UdfpsEnrollEnrollingView.java index c28f9e0e761..5b29fa5f1f6 100644 --- a/src/com/android/settings/biometrics/fingerprint/UdfpsEnrollEnrollingView.java +++ b/src/com/android/settings/biometrics/fingerprint/UdfpsEnrollEnrollingView.java @@ -16,27 +16,42 @@ package com.android.settings.biometrics.fingerprint; +import android.animation.Animator; +import android.animation.ObjectAnimator; import android.content.Context; +import android.content.res.Configuration; +import android.content.res.TypedArray; +import android.graphics.Insets; import android.graphics.Point; import android.graphics.Rect; import android.hardware.fingerprint.FingerprintSensorPropertiesInternal; import android.text.TextUtils; import android.util.AttributeSet; +import android.util.DisplayMetrics; +import android.util.TypedValue; +import android.view.Display; import android.view.DisplayInfo; import android.view.Gravity; +import android.view.LayoutInflater; import android.view.Surface; import android.view.View; import android.view.ViewGroup; +import android.view.WindowInsets; +import android.view.WindowManager; import android.view.accessibility.AccessibilityManager; import android.widget.Button; import android.widget.FrameLayout; import android.widget.ImageView; import android.widget.LinearLayout; +import android.widget.ScrollView; import androidx.annotation.ColorInt; +import androidx.annotation.LayoutRes; +import androidx.annotation.NonNull; +import androidx.annotation.VisibleForTesting; -import com.android.internal.annotations.VisibleForTesting; import com.android.settings.R; +import com.android.settings.flags.Flags; import com.android.systemui.biometrics.UdfpsUtils; import com.android.systemui.biometrics.shared.model.UdfpsOverlayParams; @@ -50,6 +65,7 @@ import java.util.Locale; * View for udfps enrolling. */ public class UdfpsEnrollEnrollingView extends GlifLayout { + private final UdfpsUtils mUdfpsUtils; private final Context mContext; // We don't need to listen to onConfigurationChanged() for mRotation here because @@ -57,14 +73,19 @@ public class UdfpsEnrollEnrollingView extends GlifLayout { private final int mRotation; private final boolean mIsLandscape; private final boolean mShouldUseReverseLandscape; + + private WindowManager mWindowManager; + private UdfpsEnrollView mUdfpsEnrollView; private View mHeaderView; private AccessibilityManager mAccessibilityManager; + private ObjectAnimator mHeaderScrollAnimator; public UdfpsEnrollEnrollingView(Context context, AttributeSet attrs) { super(context, attrs); mContext = context; + mWindowManager = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE); mRotation = mContext.getDisplay().getRotation(); mIsLandscape = mRotation == Surface.ROTATION_90 || mRotation == Surface.ROTATION_270; final boolean isLayoutRtl = (TextUtils.getLayoutDirectionFromLocale(Locale.getDefault()) @@ -82,6 +103,139 @@ public class UdfpsEnrollEnrollingView extends GlifLayout { mUdfpsEnrollView = findViewById(R.id.udfps_animation_view); } + @Override + protected View onInflateTemplate(LayoutInflater inflater, @LayoutRes int template) { + final Configuration config = inflater.getContext().getResources().getConfiguration(); + if (Flags.enrollLayoutTruncateImprovement() + && config.orientation == Configuration.ORIENTATION_PORTRAIT) { + template = R.layout.biometrics_glif_compact; + } + return super.onInflateTemplate(inflater, template); + } + + void setDecreasePadding(int decreasePadding) { + if (mUdfpsEnrollView != null) { + mUdfpsEnrollView.setDecreasePadding(decreasePadding); + } + } + + void onUdfpsSensorRectUpdated() { + if (mUdfpsEnrollView != null) { + mUdfpsEnrollView.setVisibility(VISIBLE); + } + } + + private int getScrollableGlifHeaderHeight(boolean isShouldShowLottie) { + final TypedValue tvRatio = new TypedValue(); + if (isLargeDisplaySizeOrFontSize() && !isShouldShowLottie) { + getResources().getValue( + R.dimen.biometrics_glif_header_height_ratio_large, tvRatio, true); + } else { + getResources().getValue(R.dimen.biometrics_glif_header_height_ratio, tvRatio, true); + } + final float newHeaderHeight = (float) getResources().getDisplayMetrics().heightPixels + * tvRatio.getFloat(); + + return (int) newHeaderHeight; + } + + void adjustScrollableHeaderHeight(ScrollView headerScrollView, boolean isShouldShowLottie) { + ViewGroup.LayoutParams params = headerScrollView.getLayoutParams(); + params.height = getScrollableGlifHeaderHeight(isShouldShowLottie); + headerScrollView.setLayoutParams(params); + } + + private boolean isLargeDisplaySizeOrFontSize() { + final Configuration config = getResources().getConfiguration(); + if (config.fontScale > 1.3f || getLargeDisplayScale() >= 2.8f) { + return true; + } + return false; + } + + private float getLargeDisplayScale() { + final Display display = mWindowManager.getDefaultDisplay(); + final DisplayMetrics metrics = new DisplayMetrics(); + display.getMetrics(metrics); + return metrics.scaledDensity; + } + + void adjustUdfpsVieWithFooterBar() { + final FrameLayout allContent = findViewById(R.id.suc_layout_status); + final ImageView udfpsProgressView = findViewById( + R.id.udfps_enroll_animation_fp_progress_view); + + final int navigationBarHeight = getNaviBarHeight(); + final int footerBarHeight = getFooterBarHeight(); + + final int udfpsProgressDrawableBottom = getOnScreenPositionTop(udfpsProgressView) + + udfpsProgressView.getDrawable().getBounds().height() + - udfpsProgressView.getPaddingBottom() + 2 /* reserved for more space */; + final int footerBarTop = getOnScreenPositionTop(allContent) + allContent.getHeight() + - (footerBarHeight + navigationBarHeight); + + if (udfpsProgressDrawableBottom > footerBarTop) { + int adjustPadding = udfpsProgressDrawableBottom - footerBarTop; + setDecreasePadding(adjustPadding); + } + } + + private int getOnScreenPositionTop(View view) { + int [] location = new int[2]; + view.getLocationOnScreen(location); + return location[1]; + } + + private int getNaviBarHeight() { + final Insets inset = mWindowManager.getMaximumWindowMetrics().getWindowInsets().getInsets( + WindowInsets.Type.navigationBars()); + return inset.toRect().height(); + } + + private int getFooterBarHeight() { + TypedArray a = mContext.getTheme().obtainStyledAttributes(new int[] { + com.google.android.setupcompat.R.attr.sucFooterBarMinHeight}); + final int footerBarMinHeight = a.getDimensionPixelSize(0, -1); + a.recycle(); + return footerBarMinHeight; + } + + void headerVerticalScrolling(ScrollView headerScrollView, long duration) { + headerScrollView.post(new Runnable() { + @Override + public void run() { + final int maxScroll = headerScrollView.getChildAt(0).getMeasuredHeight() + - headerScrollView.getMeasuredHeight(); + mHeaderScrollAnimator = ObjectAnimator.ofInt( + headerScrollView, "scrollY", maxScroll); + mHeaderScrollAnimator.setDuration(duration); + mHeaderScrollAnimator.addListener(new Animator.AnimatorListener() { + + @Override + public void onAnimationStart(@NonNull Animator animation) {} + + @Override + public void onAnimationEnd(@NonNull Animator animation) { + mHeaderScrollAnimator.removeAllListeners(); + headerScrollView.post(new Runnable() { + @Override + public void run() { + mHeaderScrollAnimator.reverse(); + } + }); + } + + @Override + public void onAnimationCancel(@NonNull Animator animation) {} + + @Override + public void onAnimationRepeat(@NonNull Animator animation) {} + }); + mHeaderScrollAnimator.start(); + } + }); + } + void initView(FingerprintSensorPropertiesInternal udfpsProps, UdfpsEnrollHelper udfpsEnrollHelper, AccessibilityManager accessibilityManager) { @@ -93,7 +247,7 @@ public class UdfpsEnrollEnrollingView extends GlifLayout { } else if (mShouldUseReverseLandscape) { swapHeaderAndContent(); } - mUdfpsEnrollView.setVisibility(View.VISIBLE); + mUdfpsEnrollView.setVisibility(View.INVISIBLE); setOnHoverListener(); } @@ -166,17 +320,6 @@ public class UdfpsEnrollEnrollingView extends GlifLayout { R.id.udfps_enroll_animation_fp_view); fingerprintView.setPadding(0, -layoutLottieAnimationPadding, 0, layoutLottieAnimationPadding); - - // TODO(b/260970216) Instead of hiding the description text view, we should - // make the header view scrollable if the text is too long. - // If description text view has overlap with udfps progress view, hide it. - final View descView = getDescriptionTextView(); - getViewTreeObserver().addOnDrawListener(() -> { - if (descView.getVisibility() == View.VISIBLE - && hasOverlap(descView, mUdfpsEnrollView)) { - descView.setVisibility(View.GONE); - } - }); } private void setOnHoverListener() { diff --git a/src/com/android/settings/biometrics/fingerprint/UdfpsEnrollView.java b/src/com/android/settings/biometrics/fingerprint/UdfpsEnrollView.java index 4a2a243d2d8..0c80b483661 100644 --- a/src/com/android/settings/biometrics/fingerprint/UdfpsEnrollView.java +++ b/src/com/android/settings/biometrics/fingerprint/UdfpsEnrollView.java @@ -133,6 +133,15 @@ public class UdfpsEnrollView extends FrameLayout implements UdfpsEnrollHelper.Li enrollHelper.setListener(this); } + /** + * Adjust progress bar radius only for decreasing. + * @param decreasePadding the decrease padding + */ + void setDecreasePadding(int decreasePadding) { + mProgressBarRadius -= decreasePadding; + onSensorRectUpdated(); + } + private void onSensorRectUpdated() { updateDimensions(); diff --git a/tests/robotests/res/layout/test_udfps_enroll_enrolling.xml b/tests/robotests/res/layout/test_udfps_enroll_enrolling.xml new file mode 100644 index 00000000000..c69d2ba16d9 --- /dev/null +++ b/tests/robotests/res/layout/test_udfps_enroll_enrolling.xml @@ -0,0 +1,24 @@ + + + + \ No newline at end of file diff --git a/tests/robotests/src/com/android/settings/biometrics/fingerprint/TestUdfpsEnrollEnrollingView.java b/tests/robotests/src/com/android/settings/biometrics/fingerprint/TestUdfpsEnrollEnrollingView.java new file mode 100644 index 00000000000..92c8fe58870 --- /dev/null +++ b/tests/robotests/src/com/android/settings/biometrics/fingerprint/TestUdfpsEnrollEnrollingView.java @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2024 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.settings.biometrics.fingerprint; + +import android.content.Context; +import android.util.AttributeSet; +import android.view.LayoutInflater; +import android.view.View; + +import androidx.annotation.LayoutRes; + +import com.android.settings.R; + +import com.google.android.setupdesign.GlifLayout; + +public class TestUdfpsEnrollEnrollingView extends GlifLayout { + public TestUdfpsEnrollEnrollingView(Context context, AttributeSet attrs) { + super(context, attrs); + } + + @Override + protected View onInflateTemplate(LayoutInflater inflater, @LayoutRes int template) { + return super.onInflateTemplate(inflater, R.layout.biometrics_glif_compact); + } +} diff --git a/tests/robotests/src/com/android/settings/biometrics/fingerprint/UdfpsEnrollEnrollingViewTest.java b/tests/robotests/src/com/android/settings/biometrics/fingerprint/UdfpsEnrollEnrollingViewTest.java new file mode 100644 index 00000000000..dec5208159d --- /dev/null +++ b/tests/robotests/src/com/android/settings/biometrics/fingerprint/UdfpsEnrollEnrollingViewTest.java @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2024 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.settings.biometrics.fingerprint; + +import static com.google.common.truth.Truth.assertThat; + +import android.content.Context; +import android.os.Bundle; +import android.platform.test.annotations.EnableFlags; +import android.util.AttributeSet; +import android.view.ContextThemeWrapper; +import android.view.View; + +import com.android.settings.R; +import com.android.settings.flags.Flags; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.MockitoAnnotations; +import org.robolectric.Robolectric; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.android.controller.ActivityController; +import org.robolectric.annotation.LooperMode; + + +@RunWith(RobolectricTestRunner.class) +@LooperMode(LooperMode.Mode.LEGACY) +public class UdfpsEnrollEnrollingViewTest { + + private Context mThemeContext; + private TestFingerprintEnrollEnrolling mFingerprintEnrollEnrolling; + private ActivityController + mController; + private AttributeSet mAttributeSet; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mController = Robolectric.buildActivity(TestFingerprintEnrollEnrolling.class); + mFingerprintEnrollEnrolling = mController.create().get(); + mThemeContext = new ContextThemeWrapper(mFingerprintEnrollEnrolling, + R.style.SudThemeGlif_Light); + mAttributeSet = Robolectric.buildAttributeSet().build(); + } + + private void assertDefaultTemplate(TestUdfpsEnrollEnrollingView layout) { + final View title = layout.findViewById( + com.google.android.setupdesign.R.id.suc_layout_title); + assertThat(title).isNotNull(); + + final View subTitle = layout.findViewById( + com.google.android.setupdesign.R.id.sud_layout_subtitle); + assertThat(subTitle).isNotNull(); + + final View icon = layout.findViewById(com.google.android.setupdesign.R.id.sud_layout_icon); + assertThat(icon).isNotNull(); + + final View scrollView = layout.findViewById( + com.google.android.setupdesign.R.id.sud_scroll_view); + assertThat(scrollView).isNotNull(); + } + + @Test + @EnableFlags(Flags.FLAG_ENROLL_LAYOUT_TRUNCATE_IMPROVEMENT) + public void testDefaultTemplate() { + TestUdfpsEnrollEnrollingView layout = new TestUdfpsEnrollEnrollingView(mThemeContext, + mAttributeSet); + assertDefaultTemplate(layout); + } + + @Test + @EnableFlags(Flags.FLAG_ENROLL_LAYOUT_TRUNCATE_IMPROVEMENT) + public void testGlifHeaderScrollView() { + TestUdfpsEnrollEnrollingView layout = new TestUdfpsEnrollEnrollingView(mThemeContext, + mAttributeSet); + final View headerScrollView = layout.findViewById( + R.id.sud_header_scroll_view); + + assertThat(headerScrollView).isNotNull(); + } + + public static class TestFingerprintEnrollEnrolling extends FingerprintEnrollEnrolling { + @Override + protected void onCreate(Bundle savedInstanceState) { + final TestUdfpsEnrollEnrollingView layout = + (TestUdfpsEnrollEnrollingView) getLayoutInflater().inflate( + R.layout.test_udfps_enroll_enrolling, null, false); + setContentView(layout); + } + } +}