[A11y] Move responsibility of disabling hide on scroll to HideViewOnScrollBehavior and BottomAppBar

PiperOrigin-RevId: 738068009

Author: imhappi

catalog/java/io/material/catalog/bottomappbar/BottomAppBarMainDemoFragment.java

@@ -150,11 +150,10 @@ public View onCreateDemoView(
     if (VERSION.SDK_INT >= VERSION_CODES.M) {
       am = getContext().getSystemService(AccessibilityManager.class);
       if (am != null && am.isTouchExplorationEnabled()) {
-        bar.setHideOnScroll(false);
         bar.post(() -> content.setPadding(0, content.getPaddingTop(), 0, bar.getMeasuredHeight()));
       }
     }
-    
+
     setUpDemoControls(view);
     setUpBottomAppBarShapeAppearance();
     return view;

catalog/java/io/material/catalog/dockedtoolbar/DockedToolbarMainDemoFragment.java

@@ -33,8 +33,6 @@
 import androidx.annotation.MenuRes;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
-import androidx.coordinatorlayout.widget.CoordinatorLayout;
-import androidx.coordinatorlayout.widget.CoordinatorLayout.Behavior;
 import com.google.android.material.dockedtoolbar.DockedToolbarLayout;
 import com.google.android.material.snackbar.Snackbar;
 import io.material.catalog.feature.DemoFragment;
@@ -43,7 +41,6 @@
 public class DockedToolbarMainDemoFragment extends DemoFragment {
 
   private DockedToolbarLayout dockedToolbar;
-  @Nullable private Behavior<View> behavior;
 
   @NonNull
   @Override
@@ -55,9 +52,6 @@ public View onCreateDemoView(
     View view = layoutInflater.inflate(getLayoutResId(), viewGroup, /* attachToRoot= */ false);
     Toolbar toolbar = view.findViewById(R.id.toolbar);
     dockedToolbar = view.findViewById(R.id.docked_toolbar);
-    behavior =
-        (CoordinatorLayout.Behavior<View>)
-            ((CoordinatorLayout.LayoutParams) dockedToolbar.getLayoutParams()).getBehavior();
     ((AppCompatActivity) requireActivity()).setSupportActionBar(toolbar);
 
     Button leftArrowButton = view.findViewById(R.id.docked_toolbar_left_arrow_button);
@@ -78,18 +72,17 @@ public View onCreateDemoView(
     if (VERSION.SDK_INT >= VERSION_CODES.M) {
       AccessibilityManager am = getContext().getSystemService(AccessibilityManager.class);
       if (am != null) {
-        am.addTouchExplorationStateChangeListener(enabled -> updateScrollBehaviorWithTalkback(bodyContainer, enabled));
+        am.addTouchExplorationStateChangeListener(enabled -> updateContentPaddingOnTalkback(bodyContainer, enabled));
         if (am.isTouchExplorationEnabled()) {
-          updateScrollBehaviorWithTalkback(bodyContainer, /* talkbackEnabled= */ true);
+          updateContentPaddingOnTalkback(bodyContainer, /* talkbackEnabled= */ true);
         }
       }
     }
 
     return view;
   }
 
-  private void updateScrollBehaviorWithTalkback(View content, boolean talkbackEnabled) {
-    ((CoordinatorLayout.LayoutParams) dockedToolbar.getLayoutParams()).setBehavior(talkbackEnabled ? null : behavior);
+  private void updateContentPaddingOnTalkback(View content, boolean talkbackEnabled) {
     dockedToolbar.post(
         () ->
             content.setPadding(

catalog/java/io/material/catalog/floatingtoolbar/FloatingToolbarMainDemoFragment.java

@@ -20,23 +20,18 @@
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Typeface;
-import android.os.Build.VERSION;
-import android.os.Build.VERSION_CODES;
 import android.os.Bundle;
 import androidx.appcompat.app.AppCompatActivity;
 import androidx.appcompat.widget.Toolbar;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
-import android.view.accessibility.AccessibilityManager;
 import android.widget.TextView;
 import androidx.annotation.ColorInt;
 import androidx.annotation.IdRes;
 import androidx.annotation.LayoutRes;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
-import androidx.coordinatorlayout.widget.CoordinatorLayout;
-import com.google.android.material.behavior.HideViewOnScrollBehavior;
 import com.google.android.material.button.MaterialButton;
 import com.google.android.material.floatingtoolbar.FloatingToolbarLayout;
 import io.material.catalog.feature.DemoFragment;
@@ -149,28 +144,9 @@ public View onCreateDemoView(
 
     // Select bottom configuration button to represent the toolbar that's initially visible.
     view.findViewById(R.id.bottom_button).performClick();
-
-    if (VERSION.SDK_INT >= VERSION_CODES.M) {
-      AccessibilityManager am = getContext().getSystemService(AccessibilityManager.class);
-      if (am != null) {
-        am.addTouchExplorationStateChangeListener(enabled -> updateScrollBehaviorOnTalkback(floatingToolbars, enabled));
-        if (am.isTouchExplorationEnabled()) {
-          updateScrollBehaviorOnTalkback(floatingToolbars, /* talkbackEnabled= */ true);
-        }
-      }
-    }
-
     return view;
   }
 
-  private void updateScrollBehaviorOnTalkback(
-      @NonNull List<FloatingToolbarLayout> floatingToolbars, boolean talkbackEnabled) {
-    for (FloatingToolbarLayout floatingToolbar : floatingToolbars) {
-      ((CoordinatorLayout.LayoutParams) floatingToolbar.getLayoutParams())
-          .setBehavior(talkbackEnabled ? null : new HideViewOnScrollBehavior<>());
-    }
-  }
-
   private void initializeOrientationButton(
       @NonNull View view,
       @NonNull List<FloatingToolbarLayout> floatingToolbars,

docs/components/BottomAppBar.md

@@ -76,11 +76,13 @@ in the menu:
 Bottom app bar can optionally hide on scroll with the `app:hideOnScroll`
 attribute. When this attribute is set to true, scrolling will hide the bottom
 app bar and prevent it from being seen by any screen readers which may be
-confusing for users.
+confusing for users. To prevent this, the hide behavior is automatically
+disabled when Talkback is enabled. Although discouraged for accessibility, you
+can optionally force the hide behavior by calling
+`bottomAppBar.disableHideOnTouchExploration(false)`.
 
-When Talkback is enabled, this behavior should be disabled by setting
-`bottomAppBar.setHideOnScroll(false)`. Additionally, disabling this behavior
-causes any content to be obscured, make sure to add the appropriate bottom
+Depending on your layout, disabling the hide behavior may potentially cause
+content to be obscured behind the bar. Make sure to add the appropriate bottom
 padding of the height of the bottom app bar to the content. See below for an
 example:
 

docs/components/DockedToolbar.md

@@ -183,6 +183,35 @@ can set these accessibility flags like below:
   </com.google.android.material.dockedtoolbar.DockedToolbarLayout>
 ```
 
+#### Talkback
+
+Docked toolbars can optionally use the `CoordinatorLayout.Behavior`
+`HideViewOnScrollBehavior` to hide the docked toolbar on scroll. This behavior
+is disabled when Talkback is enabled disabled due to screen readers not being
+able to see it if the docked toolbar is hidden when scrolled.
+
+If using a docked toolbar in a layout that obscures any content when
+hide on scroll is disabled, make sure to add the appropriate padding to the
+content. For example, if the docked toolbar is on the bottom and it is
+obscuring the content, bottom padding should be added to the content.
+
+See below for an example:
+
+```
+val am = context.getSystemService(AccessibilityManager::class.java)
+if (am != null && am.isTouchExplorationEnabled) {
+    (bar.layoutParams as? CoordinatorLayout.LayoutParams)?.behavior = null
+    bar.post {
+        content.setPadding(
+            content.paddingLeft,
+            content.paddingTop,
+            content.paddingRight,
+            content.paddingBottom + bar.measuredHeight
+        )
+    }
+}
+```
+
 ### Anatomy and key properties
 
 The following is an anatomy diagram for the docked toolbar:

docs/components/FloatingToolbar.md

@@ -178,10 +178,10 @@ android:id="@+id/floating_toolbar"
 
 #### Talkback
 
-If optionally using the `CoordinatorLayout.Behavior` `HideViewOnScrollBehavior`
-to hide the floating toolbar on scroll, make sure to disable it when Talkback
-is enabled. Screen readers such as Talkback will not be able to see it if the
-floating toolbar is hidden when scrolled.
+Floating toolbars can optionally use the `CoordinatorLayout.Behavior`
+`HideViewOnScrollBehavior` to hide the floating toolbar on scroll. This behavior
+is disabled when Talkback is enabled disabled due to screen readers not being
+able to see it if the floating toolbar is hidden when scrolled.
 
 If using a Floating toolbar in a layout that obscures any content when
 hide on scroll is disabled, make sure to add the appropriate padding to the
@@ -235,7 +235,9 @@ The following is an anatomy diagram for the floating toolbar:
 Standard style theme attribute: `?attr/floatingToolbarStyle`
 Vibrant style theme attribute: `?attr/floatingToolbarVibrantStyle`
 
-Floating toolbar also provides specific styles for icon buttons, `Widget.Material3.FloatingToolbar.IconButton` and `Widget.Material3.FloatingToolbar.IconButton.Vibrant`.
+Floating toolbar also provides specific styles for icon buttons,
+`Widget.Material3.FloatingToolbar.IconButton` and
+`Widget.Material3.FloatingToolbar.IconButton.Vibrant`.
 
 See the full list of
 [styles](https://github.com/material-components/material-components-android/tree/master/lib/java/com/google/android/material/floatingtoolbar/res/values/styles.xml) and

lib/java/com/google/android/material/behavior/HideBottomViewOnScrollBehavior.java

@@ -19,15 +19,19 @@
 import com.google.android.material.R;
 
 import static androidx.annotation.RestrictTo.Scope.LIBRARY_GROUP;
+import static androidx.core.content.ContextCompat.getSystemService;
 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.TimeInterpolator;
 import android.content.Context;
 import android.util.AttributeSet;
 import android.view.View;
+import android.view.View.OnAttachStateChangeListener;
 import android.view.ViewGroup;
 import android.view.ViewPropertyAnimator;
+import android.view.accessibility.AccessibilityManager;
+import android.view.accessibility.AccessibilityManager.TouchExplorationStateChangeListener;
 import androidx.annotation.Dimension;
 import androidx.annotation.IntDef;
 import androidx.annotation.NonNull;
@@ -44,9 +48,9 @@
  * The {@link Behavior} for a View within a {@link CoordinatorLayout} to hide the view off the
  * bottom of the screen when scrolling down, and show it when scrolling up.
  *
- * <p> If Talkback is enabled, the hide on scroll behavior should be disabled until Talkback
- * is disabled. Ensure that the content is not obscured due to disabling this behavior by
- * adding padding to the content.
+ * <p>If Touch Exploration is enabled, the hide on scroll behavior should be disabled until Touch
+ * Exploration is disabled. Ensure that the content is not obscured due to disabling this behavior
+ * by adding padding to the content.
  *
  * @deprecated Use {@link HideViewOnScrollBehavior} instead.
  *     <p>TODO(b/378132394): Migrate usages of this class to {@link HideViewOnScrollBehavior}.
@@ -92,6 +96,11 @@ public interface OnScrollStateChangedListener {
 
   private int height = 0;
 
+  private AccessibilityManager accessibilityManager;
+  private TouchExplorationStateChangeListener touchExplorationListener;
+
+  private boolean disableOnTouchExploration = true;
+
   /**
    * Positions the scroll state can be set to.
    *
@@ -133,9 +142,39 @@ public boolean onLayoutChild(
             child.getContext(),
             ENTER_EXIT_ANIM_EASING_ATTR,
             AnimationUtils.FAST_OUT_LINEAR_IN_INTERPOLATOR);
+    disableIfTouchExplorationEnabled(child);
     return super.onLayoutChild(parent, child, layoutDirection);
   }
 
+  private void disableIfTouchExplorationEnabled(V child) {
+    if (accessibilityManager == null) {
+      accessibilityManager = getSystemService(child.getContext(), AccessibilityManager.class);
+    }
+    if (accessibilityManager != null && touchExplorationListener == null) {
+      touchExplorationListener =
+          enabled -> {
+            if (enabled && isScrolledDown()) {
+              slideUp(child);
+            }
+          };
+      accessibilityManager.addTouchExplorationStateChangeListener(touchExplorationListener);
+      child.addOnAttachStateChangeListener(
+          new OnAttachStateChangeListener() {
+            @Override
+            public void onViewAttachedToWindow(@NonNull View v) {}
+
+            @Override
+            public void onViewDetachedFromWindow(@NonNull View v) {
+              if (touchExplorationListener != null && accessibilityManager != null) {
+                accessibilityManager.removeTouchExplorationStateChangeListener(
+                    touchExplorationListener);
+                touchExplorationListener = null;
+              }
+            }
+          });
+    }
+  }
+
   /**
    * Sets an additional offset for the y position used to hide the view.
    *
@@ -240,6 +279,13 @@ public void slideDown(@NonNull V child, boolean animate) {
       return;
     }
 
+    // If Touch Exploration is on, we should disable sliding down due to a11y issues.
+    if (disableOnTouchExploration
+        && accessibilityManager != null
+        && accessibilityManager.isTouchExplorationEnabled()) {
+      return;
+    }
+
     if (currentAnimator != null) {
       currentAnimator.cancel();
       child.clearAnimation();
@@ -299,4 +345,14 @@ public void removeOnScrollStateChangedListener(@NonNull OnScrollStateChangedList
   public void clearOnScrollStateChangedListeners() {
     onScrollStateChangedListeners.clear();
   }
+
+  /** Sets whether or not to disable this behavior if touch exploration is enabled. */
+  public void disableOnTouchExploration(boolean disableOnTouchExploration) {
+    this.disableOnTouchExploration = disableOnTouchExploration;
+  }
+
+  /** Returns whether or not this behavior is disabled if touch exploration is enabled. */
+  public boolean isDisabledOnTouchExploration() {
+    return disableOnTouchExploration;
+  }
 }