Add keep clear rects API (4e2adbd3) · Commits · e / os / android_frameworks_base

core/api/current.txt

+5 −0

Original line number	Diff line number	Diff line
		@@ -1135,6 +1135,7 @@ package android {
		field public static final int popupWindowStyle = 16842870; // 0x1010076
		field public static final int port = 16842793; // 0x1010029
		field public static final int positiveButtonText = 16843253; // 0x10101f5
		field public static final int preferKeepClear;
		field public static final int preferMinimalPostProcessing = 16844300; // 0x101060c
		field public static final int preferenceCategoryStyle = 16842892; // 0x101008c
		field public static final int preferenceFragmentStyle = 16844038; // 0x1010506
		@@ -50270,6 +50271,7 @@ package android.view {
		method public float getPivotX();
		method public float getPivotY();
		method public android.view.PointerIcon getPointerIcon();
		method @NonNull public final java.util.List<android.graphics.Rect> getPreferKeepClearRects();
		method @Nullable public String[] getReceiveContentMimeTypes();
		method public android.content.res.Resources getResources();
		method public final boolean getRevealOnFocusHint();
		@@ -50387,6 +50389,7 @@ package android.view {
		method protected boolean isPaddingOffsetRequired();
		method public boolean isPaddingRelative();
		method public boolean isPivotSet();
		method public final boolean isPreferKeepClear();
		method public boolean isPressed();
		method public boolean isSaveEnabled();
		method public boolean isSaveFromParentEnabled();
		@@ -50629,6 +50632,8 @@ package android.view {
		method public void setPivotX(float);
		method public void setPivotY(float);
		method public void setPointerIcon(android.view.PointerIcon);
		method public final void setPreferKeepClear(boolean);
		method public final void setPreferKeepClearRects(@NonNull java.util.List<android.graphics.Rect>);
		method public void setPressed(boolean);
		method public void setRenderEffect(@Nullable android.graphics.RenderEffect);
		method public final void setRevealOnFocusHint(boolean);

core/java/android/view/IWindowSession.aidl

+5 −0

Original line number	Diff line number	Diff line
		@@ -289,6 +289,11 @@ interface IWindowSession {
		*/
		oneway void reportSystemGestureExclusionChanged(IWindow window, in List<Rect> exclusionRects);

		/**
		* Called when the keep-clear areas for this window have changed.
		*/
		oneway void reportKeepClearAreasChanged(IWindow window, in List<Rect> keepClearRects);

		/**
		* Request the server to call setInputWindowInfo on a given Surface, and return
		* an input channel where the client can receive input.

core/java/android/view/View.java

+132 −10

Original line number	Diff line number	Diff line
		@@ -4734,15 +4734,18 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		WindowInsetsAnimation.Callback mWindowInsetsAnimationCallback;

		/**
		* This lives here since it's only valid for interactive views. This list is null until the
		* first use.
		* This lives here since it's only valid for interactive views. This list is null
		* until its first use.
		*/
		private List<Rect> mSystemGestureExclusionRects = null;
		private List<Rect> mKeepClearRects = null;
		private boolean mPreferKeepClear = false;

		/**
		* Used to track {@link #mSystemGestureExclusionRects}
		* Used to track {@link #mSystemGestureExclusionRects} and {@link #mKeepClearRects}
		*/
		public RenderNode.PositionUpdateListener mPositionUpdateListener;
		private Runnable mPositionChangedUpdate;

		/**
		* Allows the application to implement custom scroll capture support.
		@@ -6028,6 +6031,9 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		case R.styleable.View_clipToOutline:
		setClipToOutline(a.getBoolean(attr, false));
		break;
		case R.styleable.View_preferKeepClear:
		setPreferKeepClear(a.getBoolean(attr, false));
		break;
		}
		}

		@@ -11665,37 +11671,49 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		} else {
		info.mSystemGestureExclusionRects = new ArrayList<>(rects);
		}
		if (rects.isEmpty()) {

		updatePositionUpdateListener();
		postUpdate(this::updateSystemGestureExclusionRects);
		}

		private void updatePositionUpdateListener() {
		final ListenerInfo info = getListenerInfo();
		if (getSystemGestureExclusionRects().isEmpty()
		&& collectPreferKeepClearRects().isEmpty()) {
		if (info.mPositionUpdateListener != null) {
		mRenderNode.removePositionUpdateListener(info.mPositionUpdateListener);
		info.mPositionChangedUpdate = null;
		}
		} else {
		if (info.mPositionUpdateListener == null) {
		info.mPositionChangedUpdate = () -> {
		updateSystemGestureExclusionRects();
		updateKeepClearRects();
		};
		info.mPositionUpdateListener = new RenderNode.PositionUpdateListener() {
		@Override
		public void positionChanged(long n, int l, int t, int r, int b) {
		postUpdateSystemGestureExclusionRects();
		postUpdate(info.mPositionChangedUpdate);
		}

		@Override
		public void positionLost(long frameNumber) {
		postUpdateSystemGestureExclusionRects();
		postUpdate(info.mPositionChangedUpdate);
		}
		};
		mRenderNode.addPositionUpdateListener(info.mPositionUpdateListener);
		}
		}
		postUpdateSystemGestureExclusionRects();
		}

		/**
		* WARNING: this can be called by a hwui worker thread, not just the UI thread!
		*/
		void postUpdateSystemGestureExclusionRects() {
		private void postUpdate(Runnable r) {
		// Potentially racey from a background thread. It's ok if it's not perfect.
		final Handler h = getHandler();
		if (h != null) {
		h.postAtFrontOfQueue(this::updateSystemGestureExclusionRects);
		h.postAtFrontOfQueue(r);
		}
		}

		@@ -11726,6 +11744,106 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		return Collections.emptyList();
		}

		/**
		* Set a preference to keep the bounds of this view clear from floating windows above this
		* view's window. This informs the system that the view is considered a vital area for the
		* user and that ideally it should not be covered. Setting this is only appropriate for UI
		* where the user would likely take action to uncover it.
		* <p>
		* The system will try to respect this, but when not possible will ignore it.
		* <p>
		* @see #setPreferKeepClearRects
		* @see #isPreferKeepClear
		* @attr ref android.R.styleable#View_preferKeepClear
		*/
		public final void setPreferKeepClear(boolean preferKeepClear) {
		getListenerInfo().mPreferKeepClear = preferKeepClear;
		updatePositionUpdateListener();
		postUpdate(this::updateKeepClearRects);
		}

		/**
		* Retrieve the preference for this view to be kept clear. This is set either by
		* {@link #setPreferKeepClear} or via the attribute android.R.styleable#View_preferKeepClear.
		* <p>
		* If this is {@code true}, the system will ignore the Rects set by
		* {@link #setPreferKeepClearRects} and try to keep the whole view clear.
		* <p>
		* @see #setPreferKeepClear
		* @attr ref android.R.styleable#View_preferKeepClear
		*/
		public final boolean isPreferKeepClear() {
		return mListenerInfo != null && mListenerInfo.mPreferKeepClear;
		}

		/**
		* Set a preference to keep the provided rects clear from floating windows above this
		* view's window. This informs the system that these rects are considered vital areas for the
		* user and that ideally they should not be covered. Setting this is only appropriate for UI
		* where the user would likely take action to uncover it.
		* <p>
		* If the whole view is preferred to be clear ({@link #isPreferKeepClear}), the rects set here
		* will be ignored.
		* <p>
		* The system will try to respect this preference, but when not possible will ignore it.
		* <p>
		* @see #setPreferKeepClear
		* @see #getPreferKeepClearRects
		*/
		public final void setPreferKeepClearRects(@NonNull List<Rect> rects) {
		final ListenerInfo info = getListenerInfo();
		if (info.mKeepClearRects != null) {
		info.mKeepClearRects.clear();
		info.mKeepClearRects.addAll(rects);
		} else {
		info.mKeepClearRects = new ArrayList<>(rects);
		}
		updatePositionUpdateListener();
		postUpdate(this::updateKeepClearRects);
		}

		/**
		* @return the list of rects, set by {@link #setPreferKeepClearRects}.
		*
		* @see #setPreferKeepClearRects
		*/
		@NonNull
		public final List<Rect> getPreferKeepClearRects() {
		final ListenerInfo info = mListenerInfo;
		if (info != null && info.mKeepClearRects != null) {
		return new ArrayList(info.mKeepClearRects);
		}

		return Collections.emptyList();
		}

		void updateKeepClearRects() {
		final AttachInfo ai = mAttachInfo;
		if (ai != null) {
		ai.mViewRootImpl.updateKeepClearRectsForView(this);
		}
		}

		/**
		* Retrieve the list of areas within this view's post-layout coordinate space which the
		* system will try to not cover with other floating elements, like the pip window.
		*/
		@NonNull
		List<Rect> collectPreferKeepClearRects() {
		final ListenerInfo info = mListenerInfo;
		if (info != null) {
		final List<Rect> list = new ArrayList();
		if (info.mPreferKeepClear) {
		list.add(new Rect(0, 0, getWidth(), getHeight()));
		} else if (info.mKeepClearRects != null) {
		list.addAll(info.mKeepClearRects);
		}
		return list;
		}

		return Collections.emptyList();
		}

		/**
		* Compute the view's coordinate within the surface.
		*
		@@ -15120,7 +15238,11 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		notifyAppearedOrDisappearedForContentCaptureIfNeeded(isVisible);

		if (!getSystemGestureExclusionRects().isEmpty()) {
		postUpdateSystemGestureExclusionRects();
		postUpdate(this::updateSystemGestureExclusionRects);
		}

		if (!collectPreferKeepClearRects().isEmpty()) {
		postUpdate(this::updateKeepClearRects);
		}
		}
		}

core/java/android/view/ViewRootImpl.java

+32 −4

Original line number	Diff line number	Diff line
		@@ -749,7 +749,10 @@ public final class ViewRootImpl implements ViewParent,
		return mImeFocusController;
		}

		private final GestureExclusionTracker mGestureExclusionTracker = new GestureExclusionTracker();
		private final ViewRootRectTracker mGestureExclusionTracker =
		new ViewRootRectTracker(v -> v.getSystemGestureExclusionRects());
		private final ViewRootRectTracker mKeepClearRectsTracker =
		new ViewRootRectTracker(v -> v.collectPreferKeepClearRects());

		private IAccessibilityEmbeddedConnection mAccessibilityEmbeddedConnection;

		@@ -4767,7 +4770,7 @@ public final class ViewRootImpl implements ViewParent,
		* the root's view hierarchy.
		*/
		public void setRootSystemGestureExclusionRects(@NonNull List<Rect> rects) {
		mGestureExclusionTracker.setRootSystemGestureExclusionRects(rects);
		mGestureExclusionTracker.setRootRects(rects);
		mHandler.sendEmptyMessage(MSG_SYSTEM_GESTURE_EXCLUSION_CHANGED);
		}

		@@ -4777,7 +4780,26 @@ public final class ViewRootImpl implements ViewParent,
		*/
		@NonNull
		public List<Rect> getRootSystemGestureExclusionRects() {
		return mGestureExclusionTracker.getRootSystemGestureExclusionRects();
		return mGestureExclusionTracker.getRootRects();
		}

		/**
		* Called from View when the position listener is triggered
		*/
		void updateKeepClearRectsForView(View view) {
		mKeepClearRectsTracker.updateRectsForView(view);
		mHandler.sendEmptyMessage(MSG_KEEP_CLEAR_RECTS_CHANGED);
		}

		void keepClearRectsChanged() {
		final List<Rect> rectsForWindowManager = mKeepClearRectsTracker.computeChangedRects();
		if (rectsForWindowManager != null && mView != null) {
		try {
		mWindowSession.reportKeepClearAreasChanged(mWindow, rectsForWindowManager);
		} catch (RemoteException e) {
		throw e.rethrowFromSystemServer();
		}
		}
		}

		/**
		@@ -5273,6 +5295,7 @@ public final class ViewRootImpl implements ViewParent,
		private static final int MSG_HIDE_INSETS = 35;
		private static final int MSG_REQUEST_SCROLL_CAPTURE = 36;
		private static final int MSG_WINDOW_TOUCH_MODE_CHANGED = 37;
		private static final int MSG_KEEP_CLEAR_RECTS_CHANGED = 38;


		final class ViewRootHandler extends Handler {
		@@ -5341,6 +5364,8 @@ public final class ViewRootImpl implements ViewParent,
		return "MSG_HIDE_INSETS";
		case MSG_WINDOW_TOUCH_MODE_CHANGED:
		return "MSG_WINDOW_TOUCH_MODE_CHANGED";
		case MSG_KEEP_CLEAR_RECTS_CHANGED:
		return "MSG_KEEP_CLEAR_RECTS_CHANGED";
		}
		return super.getMessageName(message);
		}
		@@ -5565,6 +5590,9 @@ public final class ViewRootImpl implements ViewParent,
		case MSG_SYSTEM_GESTURE_EXCLUSION_CHANGED: {
		systemGestureExclusionChanged();
		} break;
		case MSG_KEEP_CLEAR_RECTS_CHANGED: {
		keepClearRectsChanged();
		} break;
		case MSG_REQUEST_SCROLL_CAPTURE:
		handleScrollCaptureRequest((IScrollCaptureResponseListener) msg.obj);
		break;

core/java/android/view/GestureExclusionTracker.java→core/java/android/view/ViewRootRectTracker.java

+165 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 The Android Open Source Project
		* 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.
		@@ -27,25 +27,36 @@ import java.util.ArrayList;
		import java.util.Collections;
		import java.util.Iterator;
		import java.util.List;
		import java.util.function.Function;

		/**
		* Used by {@link ViewRootImpl} to track system gesture exclusion rects reported by views.
		* Abstract class to track a collection of rects reported by the views under the same
		* {@link ViewRootImpl}.
		*/
		class GestureExclusionTracker {
		private boolean mGestureExclusionViewsChanged = false;
		private boolean mRootGestureExclusionRectsChanged = false;
		private List<Rect> mRootGestureExclusionRects = Collections.emptyList();
		private List<GestureExclusionViewInfo> mGestureExclusionViewInfos = new ArrayList<>();
		private List<Rect> mGestureExclusionRects = Collections.emptyList();
		class ViewRootRectTracker {
		private final Function<View, List<Rect>> mRectCollector;
		private boolean mViewsChanged = false;
		private boolean mRootRectsChanged = false;
		private List<Rect> mRootRects = Collections.emptyList();
		private List<ViewInfo> mViewInfos = new ArrayList<>();
		private List<Rect> mRects = Collections.emptyList();

		/**
		* @param rectCollector given a view returns a list of the rects of interest for this
		* ViewRootRectTracker
		*/
		ViewRootRectTracker(Function<View, List<Rect>> rectCollector) {
		mRectCollector = rectCollector;
		}

		public void updateRectsForView(@NonNull View view) {
		boolean found = false;
		final Iterator<GestureExclusionViewInfo> i = mGestureExclusionViewInfos.iterator();
		final Iterator<ViewInfo> i = mViewInfos.iterator();
		while (i.hasNext()) {
		final GestureExclusionViewInfo info = i.next();
		final ViewInfo info = i.next();
		final View v = info.getView();
		if (v == null \|\| !v.isAttachedToWindow() \|\| !v.isAggregatedVisible()) {
		mGestureExclusionViewsChanged = true;
		mViewsChanged = true;
		i.remove();
		continue;
		}
		@@ -56,63 +67,75 @@ class GestureExclusionTracker {
		}
		}
		if (!found && view.isAttachedToWindow()) {
		mGestureExclusionViewInfos.add(new GestureExclusionViewInfo(view));
		mGestureExclusionViewsChanged = true;
		mViewInfos.add(new ViewInfo(view));
		mViewsChanged = true;
		}
		}

		/**
		* @return all visible rects from all views in the global (root) coordinate system
		*/
		@Nullable
		public List<Rect> computeChangedRects() {
		boolean changed = mRootGestureExclusionRectsChanged;
		final Iterator<GestureExclusionViewInfo> i = mGestureExclusionViewInfos.iterator();
		final List<Rect> rects = new ArrayList<>(mRootGestureExclusionRects);
		boolean changed = mRootRectsChanged;
		final Iterator<ViewInfo> i = mViewInfos.iterator();
		final List<Rect> rects = new ArrayList<>(mRootRects);
		while (i.hasNext()) {
		final GestureExclusionViewInfo info = i.next();
		final ViewInfo info = i.next();
		switch (info.update()) {
		case GestureExclusionViewInfo.CHANGED:
		case ViewInfo.CHANGED:
		changed = true;
		// Deliberate fall-through
		case GestureExclusionViewInfo.UNCHANGED:
		rects.addAll(info.mExclusionRects);
		case ViewInfo.UNCHANGED:
		rects.addAll(info.mRects);
		break;
		case GestureExclusionViewInfo.GONE:
		mGestureExclusionViewsChanged = true;
		case ViewInfo.GONE:
		mViewsChanged = true;
		i.remove();
		break;
		}
		}
		if (changed \|\| mGestureExclusionViewsChanged) {
		mGestureExclusionViewsChanged = false;
		mRootGestureExclusionRectsChanged = false;
		if (!mGestureExclusionRects.equals(rects)) {
		mGestureExclusionRects = rects;
		if (changed \|\| mViewsChanged) {
		mViewsChanged = false;
		mRootRectsChanged = false;
		if (!mRects.equals(rects)) {
		mRects = rects;
		return rects;
		}
		}
		return null;
		}

		public void setRootSystemGestureExclusionRects(@NonNull List<Rect> rects) {
		/**
		* Sets rects defined in the global (root) coordinate system, i.e. not for a specific view.
		*/
		public void setRootRects(@NonNull List<Rect> rects) {
		Preconditions.checkNotNull(rects, "rects must not be null");
		mRootGestureExclusionRects = rects;
		mRootGestureExclusionRectsChanged = true;
		mRootRects = rects;
		mRootRectsChanged = true;
		}

		@NonNull
		public List<Rect> getRootRects() {
		return mRootRects;
		}

		@NonNull
		public List<Rect> getRootSystemGestureExclusionRects() {
		return mRootGestureExclusionRects;
		private List<Rect> getTrackedRectsForView(@NonNull View v) {
		final List<Rect> rects = mRectCollector.apply(v);
		return rects == null ? Collections.emptyList() : rects;
		}

		private static class GestureExclusionViewInfo {
		private class ViewInfo {
		public static final int CHANGED = 0;
		public static final int UNCHANGED = 1;
		public static final int GONE = 2;

		private final WeakReference<View> mView;
		boolean mDirty = true;
		List<Rect> mExclusionRects = Collections.emptyList();
		List<Rect> mRects = Collections.emptyList();

		GestureExclusionViewInfo(View view) {
		ViewInfo(View view) {
		mView = new WeakReference<>(view);
		}

		@@ -121,21 +144,21 @@ class GestureExclusionTracker {
		}

		public int update() {
		final View excludedView = getView();
		if (excludedView == null \|\| !excludedView.isAttachedToWindow()
		\|\| !excludedView.isAggregatedVisible()) return GONE;
		final List<Rect> localRects = excludedView.getSystemGestureExclusionRects();
		final View view = getView();
		if (view == null \|\| !view.isAttachedToWindow()
		\|\| !view.isAggregatedVisible()) return GONE;
		final List<Rect> localRects = getTrackedRectsForView(view);
		final List<Rect> newRects = new ArrayList<>(localRects.size());
		for (Rect src : localRects) {
		Rect mappedRect = new Rect(src);
		ViewParent p = excludedView.getParent();
		if (p != null && p.getChildVisibleRect(excludedView, mappedRect, null)) {
		ViewParent p = view.getParent();
		if (p != null && p.getChildVisibleRect(view, mappedRect, null)) {
		newRects.add(mappedRect);
		}
		}

		if (mExclusionRects.equals(localRects)) return UNCHANGED;
		mExclusionRects = newRects;
		if (mRects.equals(localRects)) return UNCHANGED;
		mRects = newRects;
		return CHANGED;
		}
		}