Refactor the design and improve the animations of Accessibility Floating Menu(1/n). (fa717b43) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/AccessibilityFloatingMenuController.java

+26 −2

Original line number	Diff line number	Diff line
		@@ -17,10 +17,17 @@
		package com.android.systemui.accessibility.floatingmenu;

		import static android.provider.Settings.Secure.ACCESSIBILITY_BUTTON_MODE_FLOATING_MENU;
		import static android.view.Display.DEFAULT_DISPLAY;
		import static android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR_PANEL;

		import static com.android.systemui.flags.Flags.A11Y_FLOATING_MENU_FLING_SPRING_ANIMATIONS;

		import android.content.Context;
		import android.hardware.display.DisplayManager;
		import android.os.UserHandle;
		import android.text.TextUtils;
		import android.view.Display;
		import android.view.WindowManager;

		import androidx.annotation.MainThread;

		@@ -31,6 +38,7 @@ import com.android.systemui.accessibility.AccessibilityButtonModeObserver;
		import com.android.systemui.accessibility.AccessibilityButtonModeObserver.AccessibilityButtonMode;
		import com.android.systemui.accessibility.AccessibilityButtonTargetsObserver;
		import com.android.systemui.dagger.SysUISingleton;
		import com.android.systemui.flags.FeatureFlags;

		import javax.inject.Inject;

		@@ -46,6 +54,9 @@ public class AccessibilityFloatingMenuController implements
		private final KeyguardUpdateMonitor mKeyguardUpdateMonitor;

		private Context mContext;
		private final WindowManager mWindowManager;
		private final DisplayManager mDisplayManager;
		private final FeatureFlags mFeatureFlags;
		@VisibleForTesting
		IAccessibilityFloatingMenu mFloatingMenu;
		private int mBtnMode;
		@@ -83,13 +94,19 @@ public class AccessibilityFloatingMenuController implements

		@Inject
		public AccessibilityFloatingMenuController(Context context,
		WindowManager windowManager,
		DisplayManager displayManager,
		AccessibilityButtonTargetsObserver accessibilityButtonTargetsObserver,
		AccessibilityButtonModeObserver accessibilityButtonModeObserver,
		KeyguardUpdateMonitor keyguardUpdateMonitor) {
		KeyguardUpdateMonitor keyguardUpdateMonitor,
		FeatureFlags featureFlags) {
		mContext = context;
		mWindowManager = windowManager;
		mDisplayManager = displayManager;
		mAccessibilityButtonTargetsObserver = accessibilityButtonTargetsObserver;
		mAccessibilityButtonModeObserver = accessibilityButtonModeObserver;
		mKeyguardUpdateMonitor = keyguardUpdateMonitor;
		mFeatureFlags = featureFlags;

		mIsKeyguardVisible = false;
		}
		@@ -159,8 +176,15 @@ public class AccessibilityFloatingMenuController implements

		private void showFloatingMenu() {
		if (mFloatingMenu == null) {
		if (mFeatureFlags.isEnabled(A11Y_FLOATING_MENU_FLING_SPRING_ANIMATIONS)) {
		final Display defaultDisplay = mDisplayManager.getDisplay(DEFAULT_DISPLAY);
		mFloatingMenu = new MenuViewLayerController(
		mContext.createWindowContext(defaultDisplay,
		TYPE_NAVIGATION_BAR_PANEL, /* options= */ null), mWindowManager);
		} else {
		mFloatingMenu = new AccessibilityFloatingMenu(mContext);
		}
		}

		mFloatingMenu.show();
		}

packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/MenuInfoRepository.java

0 → 100644

+83 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.provider.Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES;
		import static android.view.accessibility.AccessibilityManager.ACCESSIBILITY_BUTTON;

		import static com.android.internal.accessibility.dialog.AccessibilityTargetHelper.getTargets;

		import android.content.Context;
		import android.database.ContentObserver;
		import android.os.Handler;
		import android.os.Looper;
		import android.os.UserHandle;
		import android.provider.Settings;

		import com.android.internal.accessibility.dialog.AccessibilityTarget;

		import java.util.List;

		/**
		* Stores and observe the settings contents for the menu view.
		*/
		class MenuInfoRepository {
		private final Context mContext;
		private final Handler mHandler = new Handler(Looper.getMainLooper());
		private final OnSettingsContentsChanged mSettingsContentsCallback;

		private final ContentObserver mMenuTargetFeaturesContentObserver =
		new ContentObserver(mHandler) {
		@Override
		public void onChange(boolean selfChange) {
		mSettingsContentsCallback.onTargetFeaturesChanged(
		getTargets(mContext, ACCESSIBILITY_BUTTON));
		}
		};

		MenuInfoRepository(Context context, OnSettingsContentsChanged settingsContentsChanged) {
		mContext = context;
		mSettingsContentsCallback = settingsContentsChanged;
		}

		void loadMenuTargetFeatures(OnInfoReady<List<AccessibilityTarget>> callback) {
		callback.onReady(getTargets(mContext, ACCESSIBILITY_BUTTON));
		}

		void registerContentObservers() {
		mContext.getContentResolver().registerContentObserver(
		Settings.Secure.getUriFor(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS),
		/* notifyForDescendants */ false, mMenuTargetFeaturesContentObserver,
		UserHandle.USER_CURRENT);
		mContext.getContentResolver().registerContentObserver(
		Settings.Secure.getUriFor(ENABLED_ACCESSIBILITY_SERVICES),
		/* notifyForDescendants */ false,
		mMenuTargetFeaturesContentObserver, UserHandle.USER_CURRENT);
		}

		void unregisterContentObservers() {
		mContext.getContentResolver().unregisterContentObserver(mMenuTargetFeaturesContentObserver);
		}

		interface OnSettingsContentsChanged {
		void onTargetFeaturesChanged(List<AccessibilityTarget> newTargetFeatures);
		}

		interface OnInfoReady<T> {
		void onReady(T info);
		}
		}

packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/MenuView.java

0 → 100644

+123 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.view.ViewGroup.LayoutParams.WRAP_CONTENT;

		import android.annotation.SuppressLint;
		import android.content.Context;
		import android.content.res.Configuration;
		import android.graphics.drawable.GradientDrawable;
		import android.widget.FrameLayout;

		import androidx.lifecycle.Observer;
		import androidx.recyclerview.widget.LinearLayoutManager;
		import androidx.recyclerview.widget.RecyclerView;

		import com.android.internal.accessibility.dialog.AccessibilityTarget;

		import java.util.ArrayList;
		import java.util.List;

		/**
		* The container view displays the accessibility features.
		*/
		@SuppressLint("ViewConstructor")
		class MenuView extends FrameLayout {
		private static final int INDEX_MENU_ITEM = 0;
		private final List<AccessibilityTarget> mTargetFeatures = new ArrayList<>();
		private final AccessibilityTargetAdapter mAdapter;
		private final MenuViewModel mMenuViewModel;
		private final RecyclerView mTargetFeaturesView;
		private final Observer<List<AccessibilityTarget>> mTargetFeaturesObserver =
		this::onTargetFeaturesChanged;
		private final MenuViewAppearance mMenuViewAppearance;

		MenuView(Context context, MenuViewModel menuViewModel, MenuViewAppearance menuViewAppearance) {
		super(context);

		mMenuViewModel = menuViewModel;
		mMenuViewAppearance = menuViewAppearance;
		mAdapter = new AccessibilityTargetAdapter(mTargetFeatures);
		mTargetFeaturesView = new RecyclerView(context);
		mTargetFeaturesView.setAdapter(mAdapter);
		mTargetFeaturesView.setLayoutManager(new LinearLayoutManager(context));
		setLayoutParams(new FrameLayout.LayoutParams(WRAP_CONTENT, WRAP_CONTENT));
		loadLayoutResources();

		addView(mTargetFeaturesView);
		}

		@Override
		protected void onConfigurationChanged(Configuration newConfig) {
		super.onConfigurationChanged(newConfig);

		loadLayoutResources();
		}

		@SuppressLint("NotifyDataSetChanged")
		private void onItemSizeChanged() {
		mAdapter.setItemPadding(mMenuViewAppearance.getMenuPadding());
		mAdapter.setIconWidthHeight(mMenuViewAppearance.getMenuIconSize());
		mAdapter.notifyDataSetChanged();
		}

		private void onEdgeChanged() {
		final GradientDrawable gradientDrawable = getContainerViewGradient();
		gradientDrawable.setCornerRadii(mMenuViewAppearance.getMenuRadii());
		}

		@SuppressLint("NotifyDataSetChanged")
		private void onTargetFeaturesChanged(List<AccessibilityTarget> newTargetFeatures) {
		// TODO(b/252756133): Should update specific item instead of the whole list
		mTargetFeatures.clear();
		mTargetFeatures.addAll(newTargetFeatures);
		mMenuViewAppearance.setTargetFeaturesSize(mTargetFeatures.size());
		mAdapter.notifyDataSetChanged();

		onEdgeChanged();
		}

		void show() {
		mMenuViewModel.getTargetFeaturesData().observeForever(mTargetFeaturesObserver);
		setVisibility(VISIBLE);
		mMenuViewModel.registerContentObservers();
		}

		void hide() {
		setVisibility(GONE);
		mMenuViewModel.getTargetFeaturesData().removeObserver(mTargetFeaturesObserver);
		mMenuViewModel.unregisterContentObservers();
		}

		private void loadLayoutResources() {
		mMenuViewAppearance.update();

		setBackground(mMenuViewAppearance.getMenuBackground());
		setElevation(mMenuViewAppearance.getMenuElevation());
		onItemSizeChanged();
		onEdgeChanged();
		}

		private InstantInsetLayerDrawable getContainerViewInsetLayer() {
		return (InstantInsetLayerDrawable) getBackground();
		}

		private GradientDrawable getContainerViewGradient() {
		return (GradientDrawable) getContainerViewInsetLayer().getDrawable(INDEX_MENU_ITEM);
		}
		}

packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/MenuViewAppearance.java

0 → 100644

+94 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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 android.content.res.Resources;
		import android.graphics.drawable.Drawable;

		import com.android.systemui.R;

		/**
		* Provides the layout resources information of the {@link MenuView}.
		*/
		class MenuViewAppearance {
		private final Resources mRes;
		private int mTargetFeaturesSize;
		private int mSmallPadding;
		private int mSmallIconSize;
		private int mSmallSingleRadius;
		private int mSmallMultipleRadius;
		private int mElevation;
		private float[] mRadii;
		private Drawable mBackgroundDrawable;

		MenuViewAppearance(Context context) {
		mRes = context.getResources();

		update();
		}

		void update() {
		mSmallPadding =
		mRes.getDimensionPixelSize(R.dimen.accessibility_floating_menu_small_padding);
		mSmallIconSize =
		mRes.getDimensionPixelSize(R.dimen.accessibility_floating_menu_small_width_height);
		mSmallSingleRadius =
		mRes.getDimensionPixelSize(R.dimen.accessibility_floating_menu_small_single_radius);
		mSmallMultipleRadius = mRes.getDimensionPixelSize(
		R.dimen.accessibility_floating_menu_small_multiple_radius);
		mRadii = createRadii(getMenuRadius(mTargetFeaturesSize));
		mElevation = mRes.getDimensionPixelSize(R.dimen.accessibility_floating_menu_elevation);
		final Drawable drawable =
		mRes.getDrawable(R.drawable.accessibility_floating_menu_background);
		mBackgroundDrawable = new InstantInsetLayerDrawable(new Drawable[]{drawable});
		}

		void setTargetFeaturesSize(int targetFeaturesSize) {
		mTargetFeaturesSize = targetFeaturesSize;

		mRadii = createRadii(getMenuRadius(targetFeaturesSize));
		}

		Drawable getMenuBackground() {
		return mBackgroundDrawable;
		}

		int getMenuElevation() {
		return mElevation;
		}

		int getMenuIconSize() {
		return mSmallIconSize;
		}

		int getMenuPadding() {
		return mSmallPadding;
		}

		float[] getMenuRadii() {
		return mRadii;
		}

		private int getMenuRadius(int itemCount) {
		return itemCount > 1 ? mSmallMultipleRadius : mSmallSingleRadius;
		}

		private static float[] createRadii(float radius) {
		return new float[]{0.0f, 0.0f, radius, radius, radius, radius, 0.0f, 0.0f};
		}
		}

packages/SystemUI/src/com/android/systemui/accessibility/floatingmenu/MenuViewLayer.java

0 → 100644

+67 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.annotation.IntDef;
		import android.annotation.SuppressLint;
		import android.content.Context;
		import android.widget.FrameLayout;

		import androidx.annotation.NonNull;

		import java.lang.annotation.Retention;
		import java.lang.annotation.RetentionPolicy;

		/**
		* The basic interactions with the child view {@link MenuView}.
		*/
		@SuppressLint("ViewConstructor")
		class MenuViewLayer extends FrameLayout {
		private final MenuView mMenuView;

		@IntDef({
		LayerIndex.MENU_VIEW
		})
		@Retention(RetentionPolicy.SOURCE)
		@interface LayerIndex {
		int MENU_VIEW = 0;
		}

		MenuViewLayer(@NonNull Context context) {
		super(context);

		final MenuViewModel menuViewModel = new MenuViewModel(context);
		final MenuViewAppearance menuViewAppearance = new MenuViewAppearance(context);
		mMenuView = new MenuView(context, menuViewModel, menuViewAppearance);

		addView(mMenuView, LayerIndex.MENU_VIEW);
		}

		@Override
		protected void onAttachedToWindow() {
		super.onAttachedToWindow();

		mMenuView.show();
		}

		@Override
		protected void onDetachedFromWindow() {
		super.onDetachedFromWindow();

		mMenuView.hide();
		}
		}