diff --git a/packages/SettingsProvider/src/com/android/providers/settings/SettingsProvider.java b/packages/SettingsProvider/src/com/android/providers/settings/SettingsProvider.java index 941f47f525510..42853f1ad28c2 100644 --- a/packages/SettingsProvider/src/com/android/providers/settings/SettingsProvider.java +++ b/packages/SettingsProvider/src/com/android/providers/settings/SettingsProvider.java @@ -4919,6 +4919,15 @@ public class SettingsProvider extends ContentProvider { String.valueOf(defAccessibilityButtonMode), /* tag= */ null, /* makeDefault= */ true, SettingsState.SYSTEM_PACKAGE_NAME); + + if (hasValueInA11yButtonTargets(secureSettings)) { + secureSettings.insertSettingLocked( + Secure.ACCESSIBILITY_FLOATING_MENU_MIGRATION_TOOLTIP_PROMPT, + /* enabled */ "1", + /* tag= */ null, + /* makeDefault= */ false, + SettingsState.SYSTEM_PACKAGE_NAME); + } } } @@ -5145,13 +5154,21 @@ public class SettingsProvider extends ContentProvider { } private boolean isAccessibilityButtonInNavigationBarOn(SettingsState secureSettings) { - final boolean hasValueInA11yBtnTargets = !TextUtils.isEmpty( - secureSettings.getSettingLocked( - Secure.ACCESSIBILITY_BUTTON_TARGETS).getValue()); + return hasValueInA11yButtonTargets(secureSettings) && !isGestureNavigateEnabled(); + } + + private boolean isGestureNavigateEnabled() { final int navigationMode = getContext().getResources().getInteger( com.android.internal.R.integer.config_navBarInteractionMode); + return navigationMode == NAV_BAR_MODE_GESTURAL; + } - return hasValueInA11yBtnTargets && (navigationMode != NAV_BAR_MODE_GESTURAL); + private boolean hasValueInA11yButtonTargets(SettingsState secureSettings) { + final Setting a11yButtonTargetsSettings = + secureSettings.getSettingLocked(Secure.ACCESSIBILITY_BUTTON_TARGETS); + + return !a11yButtonTargetsSettings.isNull() + && !TextUtils.isEmpty(a11yButtonTargetsSettings.getValue()); } } } diff --git a/packages/SystemUI/res/drawable/accessibility_floating_tooltip_background.xml b/packages/SystemUI/res/drawable/accessibility_floating_tooltip_background.xml new file mode 100644 index 0000000000000..46e7dccfe7a30 --- /dev/null +++ b/packages/SystemUI/res/drawable/accessibility_floating_tooltip_background.xml @@ -0,0 +1,23 @@ + + + + + + + diff --git a/packages/SystemUI/res/layout/accessibility_floating_menu_tooltip.xml b/packages/SystemUI/res/layout/accessibility_floating_menu_tooltip.xml new file mode 100644 index 0000000000000..601198bb7e097 --- /dev/null +++ b/packages/SystemUI/res/layout/accessibility_floating_menu_tooltip.xml @@ -0,0 +1,43 @@ + + + + + + + + + diff --git a/packages/SystemUI/res/values/dimens.xml b/packages/SystemUI/res/values/dimens.xml index edd8486379a20..058a7c07cf4d1 100644 --- a/packages/SystemUI/res/values/dimens.xml +++ b/packages/SystemUI/res/values/dimens.xml @@ -1442,6 +1442,15 @@ 33dp 35dp + 8dp + 16dp + -2dp + 2dp + 8dp + 16dp + 16dp + 14sp + 48dp 24dp diff --git a/packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/AccessibilityFloatingMenu.java b/packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/AccessibilityFloatingMenu.java index 3b3bad3b255fb..fd10684e6fca3 100644 --- a/packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/AccessibilityFloatingMenu.java +++ b/packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/AccessibilityFloatingMenu.java @@ -18,6 +18,7 @@ package com.android.systemui.accessibility.floatingmenu; import static android.provider.Settings.Secure.ACCESSIBILITY_FLOATING_MENU_FADE_ENABLED; import static android.provider.Settings.Secure.ACCESSIBILITY_FLOATING_MENU_ICON_TYPE; +import static android.provider.Settings.Secure.ACCESSIBILITY_FLOATING_MENU_MIGRATION_TOOLTIP_PROMPT; import static android.provider.Settings.Secure.ACCESSIBILITY_FLOATING_MENU_OPACITY; import static android.provider.Settings.Secure.ACCESSIBILITY_FLOATING_MENU_SIZE; import static android.view.accessibility.AccessibilityManager.ACCESSIBILITY_BUTTON; @@ -39,10 +40,12 @@ import com.android.internal.annotations.VisibleForTesting; * Contains logic for an accessibility floating menu view. */ public class AccessibilityFloatingMenu implements IAccessibilityFloatingMenu { - private static final int DEFAULT_FADE_EFFECT_ENABLED = 1; + private static final int DEFAULT_FADE_EFFECT_IS_ENABLED = 1; + private static final int DEFAULT_MIGRATION_TOOLTIP_PROMPT_IS_DISABLED = 0; private static final float DEFAULT_OPACITY_VALUE = 0.55f; private final Context mContext; private final AccessibilityFloatingMenuView mMenuView; + private final MigrationTooltipView mMigrationTooltipView; private final Handler mHandler = new Handler(Looper.getMainLooper()); private final ContentObserver mContentObserver = @@ -86,6 +89,7 @@ public class AccessibilityFloatingMenu implements IAccessibilityFloatingMenu { AccessibilityFloatingMenu(Context context, AccessibilityFloatingMenuView menuView) { mContext = context; mMenuView = menuView; + mMigrationTooltipView = new MigrationTooltipView(mContext, mMenuView); } @Override @@ -106,6 +110,8 @@ public class AccessibilityFloatingMenu implements IAccessibilityFloatingMenu { mMenuView.setSizeType(getSizeType(mContext)); mMenuView.setShapeType(getShapeType(mContext)); + showMigrationTooltipIfNecessary(); + registerContentObservers(); } @@ -116,14 +122,32 @@ public class AccessibilityFloatingMenu implements IAccessibilityFloatingMenu { } mMenuView.hide(); + mMigrationTooltipView.hide(); unregisterContentObservers(); } + // Migration tooltip was the android S feature. It's just used on the Android version from R + // to S. In addition, it only shows once. + private void showMigrationTooltipIfNecessary() { + if (isMigrationTooltipPromptEnabled(mContext)) { + mMigrationTooltipView.show(); + + Settings.Secure.putInt(mContext.getContentResolver(), + ACCESSIBILITY_FLOATING_MENU_MIGRATION_TOOLTIP_PROMPT, /* disabled */ 0); + } + } + + private static boolean isMigrationTooltipPromptEnabled(Context context) { + return Settings.Secure.getInt( + context.getContentResolver(), ACCESSIBILITY_FLOATING_MENU_MIGRATION_TOOLTIP_PROMPT, + DEFAULT_MIGRATION_TOOLTIP_PROMPT_IS_DISABLED) == /* enabled */ 1; + } + private static boolean isFadeEffectEnabled(Context context) { return Settings.Secure.getInt( context.getContentResolver(), ACCESSIBILITY_FLOATING_MENU_FADE_ENABLED, - DEFAULT_FADE_EFFECT_ENABLED) == /* enable */ 1; + DEFAULT_FADE_EFFECT_IS_ENABLED) == /* enabled */ 1; } private static float getOpacityValue(Context context) { diff --git a/packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/AccessibilityFloatingMenuView.java b/packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/AccessibilityFloatingMenuView.java index 934e20dfbd05b..96a4a2aa91bae 100644 --- a/packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/AccessibilityFloatingMenuView.java +++ b/packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/AccessibilityFloatingMenuView.java @@ -299,10 +299,6 @@ public class AccessibilityFloatingMenuView extends FrameLayout @Override public boolean performAccessibilityAction(int action, Bundle arguments) { - if (super.performAccessibilityAction(action, arguments)) { - return true; - } - fadeIn(); final Rect bounds = getAvailableBounds(); @@ -340,7 +336,7 @@ public class AccessibilityFloatingMenuView extends FrameLayout return true; } - return false; + return super.performAccessibilityAction(action, arguments); } void show() { @@ -411,6 +407,12 @@ public class AccessibilityFloatingMenuView extends FrameLayout fadeOut(); } + Rect getWindowLocationOnScreen() { + final int left = mCurrentLayoutParams.x; + final int top = mCurrentLayoutParams.y; + return new Rect(left, top, left + getWindowWidth(), top + getWindowHeight()); + } + void updateOpacityWith(boolean isFadeEffectEnabled, float newOpacityValue) { mIsFadeEffectEnabled = isFadeEffectEnabled; mFadeOutValue = newOpacityValue; diff --git a/packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/BaseTooltipView.java b/packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/BaseTooltipView.java new file mode 100644 index 0000000000000..76aa1f14e58b3 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/BaseTooltipView.java @@ -0,0 +1,284 @@ +/* + * 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.accessibility.floatingmenu; + +import static android.util.TypedValue.COMPLEX_UNIT_PX; +import static android.view.View.MeasureSpec.AT_MOST; +import static android.view.View.MeasureSpec.UNSPECIFIED; + +import android.annotation.UiContext; +import android.content.Context; +import android.content.res.Configuration; +import android.content.res.Resources; +import android.graphics.CornerPathEffect; +import android.graphics.Paint; +import android.graphics.PixelFormat; +import android.graphics.Rect; +import android.graphics.drawable.GradientDrawable; +import android.graphics.drawable.ShapeDrawable; +import android.os.Bundle; +import android.util.DisplayMetrics; +import android.view.Gravity; +import android.view.LayoutInflater; +import android.view.MotionEvent; +import android.view.View; +import android.view.ViewGroup; +import android.view.WindowManager; +import android.view.accessibility.AccessibilityNodeInfo; +import android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction; +import android.widget.FrameLayout; +import android.widget.LinearLayout; +import android.widget.TextView; + +import com.android.settingslib.Utils; +import com.android.systemui.R; +import com.android.systemui.recents.TriangleShape; + +/** + * Base tooltip view that shows the information about the operation of the + * Accessibility floating menu. In addition, the anchor view is only for {@link + * AccessibilityFloatingMenuView}, it should be more suited for displaying one-off menus to avoid + * the performance hit for the extra window. + */ +class BaseTooltipView extends FrameLayout { + private int mFontSize; + private int mTextViewMargin; + private int mTextViewPadding; + private int mTextViewCornerRadius; + private int mArrowMargin; + private int mArrowWidth; + private int mArrowHeight; + private int mArrowCornerRadius; + private int mScreenWidth; + private boolean mIsShowing; + private View mArrowView; + private TextView mTextView; + private final WindowManager.LayoutParams mCurrentLayoutParams; + private final WindowManager mWindowManager; + private final AccessibilityFloatingMenuView mAnchorView; + + BaseTooltipView(@UiContext Context context, AccessibilityFloatingMenuView anchorView) { + super(context); + mWindowManager = context.getSystemService(WindowManager.class); + mAnchorView = anchorView; + mCurrentLayoutParams = createDefaultLayoutParams(); + + updateDimensions(); + initViews(); + } + + @Override + protected void onConfigurationChanged(Configuration newConfig) { + super.onConfigurationChanged(newConfig); + + updateDimensions(); + + updateTextView(); + updateArrow(); + + mAnchorView.onConfigurationChanged(newConfig); + final Rect anchorViewLocation = mAnchorView.getWindowLocationOnScreen(); + updateWidthWith(anchorViewLocation); + updateLocationWith(anchorViewLocation); + + mWindowManager.updateViewLayout(this, mCurrentLayoutParams); + } + + @Override + public boolean onTouchEvent(MotionEvent event) { + if (event.getAction() == MotionEvent.ACTION_OUTSIDE) { + hide(); + } + + return super.onTouchEvent(event); + } + + @Override + public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) { + super.onInitializeAccessibilityNodeInfo(info); + + info.addAction(AccessibilityAction.ACTION_DISMISS); + } + + @Override + public boolean performAccessibilityAction(int action, Bundle arguments) { + if (action == AccessibilityAction.ACTION_DISMISS.getId()) { + hide(); + return true; + } + + return super.performAccessibilityAction(action, arguments); + } + + void show() { + if (isShowing()) { + return; + } + + mIsShowing = true; + final Rect anchorViewLocation = mAnchorView.getWindowLocationOnScreen(); + updateWidthWith(anchorViewLocation); + updateLocationWith(anchorViewLocation); + + mWindowManager.addView(this, mCurrentLayoutParams); + } + + void hide() { + if (!isShowing()) { + return; + } + + mIsShowing = false; + mWindowManager.removeView(this); + } + + void setDescription(CharSequence text) { + mTextView.setText(text); + } + + private boolean isShowing() { + return mIsShowing; + } + + private void initViews() { + final View contentView = + LayoutInflater.from(getContext()).inflate( + R.layout.accessibility_floating_menu_tooltip, this, false); + + mArrowView = contentView.findViewById(R.id.arrow); + drawArrow(mArrowView); + + mTextView = contentView.findViewById(R.id.text); + + addView(contentView); + } + + private static WindowManager.LayoutParams createDefaultLayoutParams() { + final WindowManager.LayoutParams params = new WindowManager.LayoutParams( + WindowManager.LayoutParams.WRAP_CONTENT, + WindowManager.LayoutParams.WRAP_CONTENT, + WindowManager.LayoutParams.TYPE_NAVIGATION_BAR_PANEL, + WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE + | WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH, + PixelFormat.TRANSLUCENT); + params.windowAnimations = android.R.style.Animation_Translucent; + params.gravity = Gravity.START | Gravity.TOP; + + return params; + } + + private void updateDimensions() { + final Resources res = getResources(); + final DisplayMetrics dm = res.getDisplayMetrics(); + mScreenWidth = dm.widthPixels; + mArrowWidth = + res.getDimensionPixelSize(R.dimen.accessibility_floating_tooltip_arrow_width); + mArrowHeight = + res.getDimensionPixelSize(R.dimen.accessibility_floating_tooltip_arrow_height); + mArrowMargin = + res.getDimensionPixelSize( + R.dimen.accessibility_floating_tooltip_arrow_margin); + mArrowCornerRadius = + res.getDimensionPixelSize( + R.dimen.accessibility_floating_tooltip_arrow_corner_radius); + mFontSize = + res.getDimensionPixelSize(R.dimen.accessibility_floating_tooltip_font_size); + mTextViewMargin = + res.getDimensionPixelSize(R.dimen.accessibility_floating_tooltip_margin); + mTextViewPadding = + res.getDimensionPixelSize(R.dimen.accessibility_floating_tooltip_padding); + mTextViewCornerRadius = + res.getDimensionPixelSize( + R.dimen.accessibility_floating_tooltip_text_corner_radius); + } + + private void updateTextView() { + mTextView.setTextSize(COMPLEX_UNIT_PX, mFontSize); + mTextView.setPadding(mTextViewPadding, mTextViewPadding, mTextViewPadding, + mTextViewPadding); + + final GradientDrawable gradientDrawable = (GradientDrawable) mTextView.getBackground(); + gradientDrawable.setCornerRadius(mTextViewCornerRadius); + } + + private void updateArrow() { + final ShapeDrawable shapeDrawable = (ShapeDrawable) mArrowView.getBackground(); + final Paint paint = shapeDrawable.getPaint(); + paint.setPathEffect(new CornerPathEffect(mArrowCornerRadius)); + + final LinearLayout.LayoutParams layoutParams = + (LinearLayout.LayoutParams) mArrowView.getLayoutParams(); + layoutParams.width = mArrowWidth; + layoutParams.height = mArrowHeight; + layoutParams.setMargins(mArrowMargin, 0, 0, 0); + mArrowView.setLayoutParams(layoutParams); + } + + private void updateWidthWith(Rect anchorViewLocation) { + final ViewGroup.LayoutParams layoutParams = mTextView.getLayoutParams(); + layoutParams.width = getTextWidthWith(anchorViewLocation); + mTextView.setLayoutParams(layoutParams); + } + + private void updateLocationWith(Rect anchorViewLocation) { + mCurrentLayoutParams.x = + mScreenWidth - getWindowWidthWith(anchorViewLocation) - anchorViewLocation.width(); + mCurrentLayoutParams.y = + anchorViewLocation.centerY() - (getTextHeightWith(anchorViewLocation) / 2); + } + + private void drawArrow(View view) { + final ViewGroup.LayoutParams layoutParams = view.getLayoutParams(); + final TriangleShape triangleShape = + TriangleShape.createHorizontal(layoutParams.width, layoutParams.height, + false); + final ShapeDrawable arrowDrawable = new ShapeDrawable(triangleShape); + final Paint arrowPaint = arrowDrawable.getPaint(); + arrowPaint.setColor(Utils.getColorAttrDefaultColor(getContext(), + com.android.internal.R.attr.colorAccentPrimary)); + final CornerPathEffect effect = new CornerPathEffect(mArrowCornerRadius); + arrowPaint.setPathEffect(effect); + view.setBackground(arrowDrawable); + } + + private int getTextWidthWith(Rect anchorViewLocation) { + final int widthSpec = + MeasureSpec.makeMeasureSpec(getAvailableTextWidthWith(anchorViewLocation), AT_MOST); + final int heightSpec = + MeasureSpec.makeMeasureSpec(0, UNSPECIFIED); + mTextView.measure(widthSpec, heightSpec); + return mTextView.getMeasuredWidth(); + } + + private int getTextHeightWith(Rect anchorViewLocation) { + final int widthSpec = + MeasureSpec.makeMeasureSpec(getAvailableTextWidthWith(anchorViewLocation), AT_MOST); + final int heightSpec = + MeasureSpec.makeMeasureSpec(0, UNSPECIFIED); + mTextView.measure(widthSpec, heightSpec); + return mTextView.getMeasuredHeight(); + } + + private int getAvailableTextWidthWith(Rect anchorViewLocation) { + return mScreenWidth - anchorViewLocation.width() - mArrowWidth - mArrowMargin + - mTextViewMargin; + } + + private int getWindowWidthWith(Rect anchorViewLocation) { + return getTextWidthWith(anchorViewLocation) + mArrowWidth + mArrowMargin; + } +} diff --git a/packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/MigrationTooltipView.java b/packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/MigrationTooltipView.java new file mode 100644 index 0000000000000..58f974bcfc591 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/MigrationTooltipView.java @@ -0,0 +1,34 @@ +/* + * 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.accessibility.floatingmenu; + +import android.content.Context; + +import com.android.systemui.R; + +/** + * Migration tooltip view that shows the information about the Accessibility button was replaced + * with the floating menu. + */ +class MigrationTooltipView extends BaseTooltipView { + MigrationTooltipView(Context context, AccessibilityFloatingMenuView anchorView) { + super(context, anchorView); + + setDescription( + getResources().getString(R.string.accessibility_floating_button_migration_tooltip)); + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/accessibility/floatingmenu/BaseTooltipViewTest.java b/packages/SystemUI/tests/src/com/android/systemui/accessibility/floatingmenu/BaseTooltipViewTest.java new file mode 100644 index 0000000000000..6db5761a50542 --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/accessibility/floatingmenu/BaseTooltipViewTest.java @@ -0,0 +1,122 @@ +/* + * 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.accessibility.floatingmenu; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; + +import android.content.Context; +import android.testing.AndroidTestingRunner; +import android.testing.TestableLooper; +import android.view.MotionEvent; +import android.view.WindowManager; +import android.view.accessibility.AccessibilityNodeInfo; + +import androidx.test.filters.SmallTest; + +import com.android.systemui.SysuiTestCase; +import com.android.systemui.accessibility.MotionEventHelper; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +/** Tests for {@link BaseTooltipView}. */ +@SmallTest +@RunWith(AndroidTestingRunner.class) +@TestableLooper.RunWithLooper +public class BaseTooltipViewTest extends SysuiTestCase { + + @Mock + private WindowManager mWindowManager; + + private AccessibilityFloatingMenuView mMenuView; + private BaseTooltipView mToolTipView; + + private final MotionEventHelper mMotionEventHelper = new MotionEventHelper(); + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + final WindowManager wm = mContext.getSystemService(WindowManager.class); + doAnswer(invocation -> wm.getMaximumWindowMetrics()).when( + mWindowManager).getMaximumWindowMetrics(); + mContext.addMockSystemService(Context.WINDOW_SERVICE, mWindowManager); + + mMenuView = new AccessibilityFloatingMenuView(mContext); + mToolTipView = new BaseTooltipView(mContext, mMenuView); + } + + @Test + public void showToolTipView_success() { + mToolTipView.show(); + + verify(mWindowManager).addView(eq(mToolTipView), any(WindowManager.LayoutParams.class)); + } + + @Test + public void touchOutsideWhenToolTipViewShown_dismiss() { + final MotionEvent outsideEvent = + mMotionEventHelper.obtainMotionEvent(/* downTime= */ 0, + /* eventTime= */1, + MotionEvent.ACTION_OUTSIDE, + /* x= */ 0, + /* y= */ 0); + + mToolTipView.show(); + mToolTipView.dispatchTouchEvent(outsideEvent); + + verify(mWindowManager).removeView(mToolTipView); + } + + @Test + public void getAccessibilityActionList_matchResult() { + final AccessibilityNodeInfo infos = new AccessibilityNodeInfo(); + mToolTipView.onInitializeAccessibilityNodeInfo(infos); + + assertThat(infos.getActionList().size()).isEqualTo(1); + } + + @Test + public void accessibilityAction_dismiss_success() { + final BaseTooltipView tooltipView = + spy(new BaseTooltipView(mContext, mMenuView)); + + final boolean isActionPerformed = + tooltipView.performAccessibilityAction( + AccessibilityNodeInfo.AccessibilityAction.ACTION_DISMISS.getId(), + /* arguments= */ null); + + assertThat(isActionPerformed).isTrue(); + verify(tooltipView).hide(); + } + + @After + public void tearDown() { + mToolTipView.hide(); + mMotionEventHelper.recycleEvents(); + } +}