Merge "[4/n] Letterbox Education: Create a superclass for compat UI window managers." (634fa510) · Commits · e / os / android_frameworks_base

libs/WindowManager/Shell/src/com/android/wm/shell/compatui/CompatUIController.java

+3 −6

Original line number	Diff line number	Diff line
		@@ -49,7 +49,7 @@ import java.util.function.Consumer;
		import java.util.function.Predicate;

		/**
		* Controls to show/update restart-activity buttons on Tasks based on whether the foreground
		* Controller to show/update compat UI components on Tasks based on whether the foreground
		* activities are in compatibility mode.
		*/
		public class CompatUIController implements OnDisplaysChangedListener,
		@@ -228,8 +228,7 @@ public class CompatUIController implements OnDisplaysChangedListener,
		final CompatUIWindowManager compatUIWindowManager =
		createLayout(context, taskInfo, taskListener);
		mActiveLayouts.put(taskInfo.taskId, compatUIWindowManager);
		compatUIWindowManager.createLayout(showOnDisplay(taskInfo.displayId),
		taskInfo.topActivityInSizeCompat, taskInfo.cameraCompatControlState);
		compatUIWindowManager.createLayout(showOnDisplay(taskInfo.displayId), taskInfo);
		}

		@VisibleForTesting
		@@ -254,9 +253,7 @@ public class CompatUIController implements OnDisplaysChangedListener,
		if (layout == null) {
		return;
		}
		layout.updateCompatInfo(taskInfo.configuration, taskListener,
		showOnDisplay(layout.getDisplayId()), taskInfo.topActivityInSizeCompat,
		taskInfo.cameraCompatControlState);
		layout.updateCompatInfo(taskInfo, taskListener, showOnDisplay(layout.getDisplayId()));
		}

		private void removeLayout(int taskId) {

libs/WindowManager/Shell/src/com/android/wm/shell/compatui/CompatUIWindowManager.java

+76 −256

Original line number	Diff line number	Diff line
		@@ -20,28 +20,16 @@ import static android.app.TaskInfo.CAMERA_COMPAT_CONTROL_DISMISSED;
		import static android.app.TaskInfo.CAMERA_COMPAT_CONTROL_HIDDEN;
		import static android.app.TaskInfo.CAMERA_COMPAT_CONTROL_TREATMENT_APPLIED;
		import static android.app.TaskInfo.CAMERA_COMPAT_CONTROL_TREATMENT_SUGGESTED;
		import static android.view.WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
		import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL;
		import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_NO_MOVE_ANIMATION;
		import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_TRUSTED_OVERLAY;
		import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;

		import android.annotation.Nullable;
		import android.app.TaskInfo;
		import android.app.TaskInfo.CameraCompatControlState;
		import android.content.Context;
		import android.content.res.Configuration;
		import android.graphics.PixelFormat;
		import android.graphics.Rect;
		import android.os.Binder;
		import android.util.Log;
		import android.view.IWindow;
		import android.view.LayoutInflater;
		import android.view.SurfaceControl;
		import android.view.SurfaceControlViewHost;
		import android.view.SurfaceSession;
		import android.view.View;
		import android.view.WindowManager;
		import android.view.WindowlessWindowManager;

		import com.android.internal.annotations.VisibleForTesting;
		import com.android.wm.shell.R;
		@@ -50,26 +38,19 @@ import com.android.wm.shell.common.DisplayLayout;
		import com.android.wm.shell.common.SyncTransactionQueue;

		/**
		* Holds view hierarchy of a root surface and helps to inflate and manage layout for compat
		* controls.
		* Window manager for the Size Compat restart button and Camera Compat control.
		*/
		class CompatUIWindowManager extends WindowlessWindowManager {
		class CompatUIWindowManager extends CompatUIWindowManagerAbstract {

		private static final String TAG = "CompatUIWindowManager";
		/**
		* The Compat UI should be the topmost child of the Task in case there can be more than one
		* child.
		*/
		private static final int Z_ORDER = Integer.MAX_VALUE;

		private final SyncTransactionQueue mSyncQueue;
		private final CompatUIController.CompatUICallback mCallback;
		private final int mDisplayId;
		private final int mTaskId;
		private final Rect mStableBounds;

		private Context mContext;
		private Configuration mTaskConfig;
		private ShellTaskOrganizer.TaskListener mTaskListener;
		private DisplayLayout mDisplayLayout;

		// Remember the last reported states in case visibility changes due to keyguard or
		// IME updates.
		// Remember the last reported states in case visibility changes due to keyguard or IME updates.
		@VisibleForTesting
		boolean mHasSizeCompat;
		@CameraCompatControlState
		@@ -82,147 +63,83 @@ class CompatUIWindowManager extends WindowlessWindowManager {

		@Nullable
		@VisibleForTesting
		CompatUILayout mCompatUILayout;

		@Nullable
		private SurfaceControlViewHost mViewHost;
		@Nullable
		private SurfaceControl mLeash;
		CompatUILayout mLayout;

		CompatUIWindowManager(Context context, Configuration taskConfig,
		SyncTransactionQueue syncQueue, CompatUIController.CompatUICallback callback,
		int taskId, ShellTaskOrganizer.TaskListener taskListener, DisplayLayout displayLayout,
		boolean hasShownSizeCompatHint, boolean hasShownCameraCompatHint) {
		super(taskConfig, null /* rootSurface /, null / hostInputToken */);
		mContext = context;
		mSyncQueue = syncQueue;
		super(context, taskConfig, syncQueue, taskId, taskListener, displayLayout);
		mCallback = callback;
		mTaskConfig = taskConfig;
		mDisplayId = mContext.getDisplayId();
		mTaskId = taskId;
		mTaskListener = taskListener;
		mDisplayLayout = displayLayout;
		mShouldShowSizeCompatHint = !hasShownSizeCompatHint;
		mShouldShowCameraCompatHint = !hasShownCameraCompatHint;
		mStableBounds = new Rect();
		mDisplayLayout.getStableBounds(mStableBounds);
		}

		@Override
		public void setConfiguration(Configuration configuration) {
		super.setConfiguration(configuration);
		mContext = mContext.createConfigurationContext(configuration);
		protected int getZOrder() {
		return Z_ORDER;
		}


		@Override
		protected void attachToParentSurface(IWindow window, SurfaceControl.Builder b) {
		// Can't set position for the ViewRootImpl SC directly. Create a leash to manipulate later.
		final SurfaceControl.Builder builder = new SurfaceControl.Builder(new SurfaceSession())
		.setContainerLayer()
		.setName("CompatUILeash")
		.setHidden(false)
		.setCallsite("CompatUIWindowManager#attachToParentSurface");
		attachToParentSurface(builder);
		mLeash = builder.build();
		b.setParent(mLeash);
		protected @Nullable View getLayout() {
		return mLayout;
		}

		/** Creates the layout for compat controls. */
		void createLayout(boolean show, boolean hasSizeCompat,
		@CameraCompatControlState int cameraCompatControlState) {
		mHasSizeCompat = hasSizeCompat;
		mCameraCompatControlState = cameraCompatControlState;
		if (!show \|\| mCompatUILayout != null) {
		// Wait until compat controls should be visible.
		return;
		@Override
		protected void removeLayout() {
		mLayout = null;
		}

		initCompatUi();
		updateSurfacePosition();

		if (hasSizeCompat) {
		mCallback.onSizeCompatRestartButtonAppeared(mTaskId);
		}
		@Override
		protected boolean eligibleToShowLayout() {
		return mHasSizeCompat \|\| shouldShowCameraControl();
		}

		private void createLayout(boolean show) {
		createLayout(show, mHasSizeCompat, mCameraCompatControlState);
		/**
		* Updates the internal state with respect to {@code taskInfo} and calls {@link
		* #createLayout(boolean)}.
		*/
		void createLayout(boolean canShow, TaskInfo taskInfo) {
		mHasSizeCompat = taskInfo.topActivityInSizeCompat;
		mCameraCompatControlState = taskInfo.cameraCompatControlState;
		createLayout(canShow);
		}

		/** Called when compat info changed. */
		void updateCompatInfo(Configuration taskConfig,
		ShellTaskOrganizer.TaskListener taskListener, boolean show, boolean hasSizeCompat,
		@CameraCompatControlState int cameraCompatControlState) {
		final Configuration prevTaskConfig = mTaskConfig;
		final ShellTaskOrganizer.TaskListener prevTaskListener = mTaskListener;
		mTaskConfig = taskConfig;
		mTaskListener = taskListener;
		final boolean prevHasSizeCompat = mHasSizeCompat;
		final int prevCameraCompatControlState = mCameraCompatControlState;
		mHasSizeCompat = hasSizeCompat;
		mCameraCompatControlState = cameraCompatControlState;

		// Update configuration.
		mContext = mContext.createConfigurationContext(taskConfig);
		setConfiguration(taskConfig);

		if (mCompatUILayout == null \|\| prevTaskListener != taskListener) {
		// TaskListener changed, recreate the layout for new surface parent.
		release();
		createLayout(show);
		return;
		}
		@Override
		protected View createLayout() {
		mLayout = inflateLayout();
		mLayout.inject(this);

		if (prevHasSizeCompat != mHasSizeCompat
		\|\| prevCameraCompatControlState != mCameraCompatControlState) {
		updateVisibilityOfViews();
		}

		if (!taskConfig.windowConfiguration.getBounds()
		.equals(prevTaskConfig.windowConfiguration.getBounds())) {
		// Reposition the UI surfaces.
		updateSurfacePosition();
		if (mHasSizeCompat) {
		mCallback.onSizeCompatRestartButtonAppeared(mTaskId);
		}

		if (taskConfig.getLayoutDirection() != prevTaskConfig.getLayoutDirection()) {
		// Update layout for RTL.
		mCompatUILayout.setLayoutDirection(taskConfig.getLayoutDirection());
		updateSurfacePosition();
		return mLayout;
		}

		@VisibleForTesting
		CompatUILayout inflateLayout() {
		return (CompatUILayout) LayoutInflater.from(mContext).inflate(R.layout.compat_ui_layout,
		null);
		}

		/** Called when the visibility of the UI should change. */
		void updateVisibility(boolean show) {
		if (mCompatUILayout == null) {
		// Layout may not have been created because it was hidden previously.
		createLayout(show);
		return;
		}
		@Override
		public void updateCompatInfo(TaskInfo taskInfo, ShellTaskOrganizer.TaskListener taskListener,
		boolean canShow) {
		final boolean prevHasSizeCompat = mHasSizeCompat;
		final int prevCameraCompatControlState = mCameraCompatControlState;
		mHasSizeCompat = taskInfo.topActivityInSizeCompat;
		mCameraCompatControlState = taskInfo.cameraCompatControlState;

		// Hide compat UIs when IME is showing.
		final int newVisibility = show ? View.VISIBLE : View.GONE;
		if (mCompatUILayout.getVisibility() != newVisibility) {
		mCompatUILayout.setVisibility(newVisibility);
		}
		}
		super.updateCompatInfo(taskInfo, taskListener, canShow);

		/** Called when display layout changed. */
		void updateDisplayLayout(DisplayLayout displayLayout) {
		final Rect prevStableBounds = mStableBounds;
		final Rect curStableBounds = new Rect();
		displayLayout.getStableBounds(curStableBounds);
		mDisplayLayout = displayLayout;
		if (!prevStableBounds.equals(curStableBounds)) {
		// Stable bounds changed, update UI surface positions.
		updateSurfacePosition();
		mStableBounds.set(curStableBounds);
		}
		if (prevHasSizeCompat != mHasSizeCompat
		\|\| prevCameraCompatControlState != mCameraCompatControlState) {
		updateVisibilityOfViews();
		}

		/** Called when it is ready to be placed compat UI surface. */
		void attachToParentSurface(SurfaceControl.Builder b) {
		mTaskListener.attachChildSurfaceToTask(mTaskId, b);
		}

		/** Called when the restart button is clicked. */
		@@ -233,7 +150,7 @@ class CompatUIWindowManager extends WindowlessWindowManager {
		/** Called when the camera treatment button is clicked. */
		void onCameraTreatmentButtonClicked() {
		if (!shouldShowCameraControl()) {
		Log.w(TAG, "Camera compat shouldn't receive clicks in the hidden state.");
		Log.w(getTag(), "Camera compat shouldn't receive clicks in the hidden state.");
		return;
		}
		// When a camera control is shown, only two states are allowed: "treament applied" and
		@@ -244,141 +161,72 @@ class CompatUIWindowManager extends WindowlessWindowManager {
		? CAMERA_COMPAT_CONTROL_TREATMENT_APPLIED
		: CAMERA_COMPAT_CONTROL_TREATMENT_SUGGESTED;
		mCallback.onCameraControlStateUpdated(mTaskId, mCameraCompatControlState);
		mCompatUILayout.updateCameraTreatmentButton(mCameraCompatControlState);
		mLayout.updateCameraTreatmentButton(mCameraCompatControlState);
		}

		/** Called when the camera dismiss button is clicked. */
		void onCameraDismissButtonClicked() {
		if (!shouldShowCameraControl()) {
		Log.w(TAG, "Camera compat shouldn't receive clicks in the hidden state.");
		Log.w(getTag(), "Camera compat shouldn't receive clicks in the hidden state.");
		return;
		}
		mCameraCompatControlState = CAMERA_COMPAT_CONTROL_DISMISSED;
		mCallback.onCameraControlStateUpdated(mTaskId, CAMERA_COMPAT_CONTROL_DISMISSED);
		mCompatUILayout.setCameraControlVisibility(/* show= */ false);
		mLayout.setCameraControlVisibility(/* show= */ false);
		}

		/** Called when the restart button is long clicked. */
		void onRestartButtonLongClicked() {
		if (mCompatUILayout == null) {
		if (mLayout == null) {
		return;
		}
		mCompatUILayout.setSizeCompatHintVisibility(/* show= */ true);
		mLayout.setSizeCompatHintVisibility(/* show= */ true);
		}

		/** Called when either dismiss or treatment camera buttons is long clicked. */
		void onCameraButtonLongClicked() {
		if (mCompatUILayout == null) {
		if (mLayout == null) {
		return;
		}
		mCompatUILayout.setCameraCompatHintVisibility(/* show= */ true);
		mLayout.setCameraCompatHintVisibility(/* show= */ true);
		}

		int getDisplayId() {
		return mDisplayId;
		}

		int getTaskId() {
		return mTaskId;
		}

		/** Releases the surface control and tears down the view hierarchy. */
		void release() {
		// Hiding before releasing to avoid flickering when transitioning to the Home screen.
		mCompatUILayout.setVisibility(View.GONE);
		mCompatUILayout = null;

		if (mViewHost != null) {
		mViewHost.release();
		mViewHost = null;
		}

		if (mLeash != null) {
		final SurfaceControl leash = mLeash;
		mSyncQueue.runInSync(t -> t.remove(leash));
		mLeash = null;
		}
		}

		void relayout() {
		mViewHost.relayout(getWindowLayoutParams());
		updateSurfacePosition();
		}

		@VisibleForTesting
		void updateSurfacePosition() {
		if (mCompatUILayout == null \|\| mLeash == null) {
		@Override
		protected void updateSurfacePosition(Rect taskBounds, Rect stableBounds) {
		if (mLayout == null) {
		return;
		}

		// Use stable bounds to prevent controls from overlapping with system bars.
		final Rect taskBounds = mTaskConfig.windowConfiguration.getBounds();
		final Rect stableBounds = new Rect();
		mDisplayLayout.getStableBounds(stableBounds);
		stableBounds.intersect(taskBounds);

		// Position of the button in the container coordinate.
		final int positionX = getLayoutDirection() == View.LAYOUT_DIRECTION_RTL
		? stableBounds.left - taskBounds.left
		: stableBounds.right - taskBounds.left - mCompatUILayout.getMeasuredWidth();
		: stableBounds.right - taskBounds.left - mLayout.getMeasuredWidth();
		final int positionY = stableBounds.bottom - taskBounds.top
		- mCompatUILayout.getMeasuredHeight();
		- mLayout.getMeasuredHeight();

		updateSurfacePosition(positionX, positionY);
		}

		private int getLayoutDirection() {
		return mContext.getResources().getConfiguration().getLayoutDirection();
		}

		private void updateSurfacePosition(int positionX, int positionY) {
		mSyncQueue.runInSync(t -> {
		if (mLeash == null \|\| !mLeash.isValid()) {
		Log.w(TAG, "The leash has been released.");
		private void updateVisibilityOfViews() {
		if (mLayout == null) {
		return;
		}
		t.setPosition(mLeash, positionX, positionY);
		// The compat UI should be the topmost child of the Task in case there can be more
		// than one children.
		t.setLayer(mLeash, Integer.MAX_VALUE);
		});
		}

		/** Inflates {@link CompatUILayout} on to the root surface. */
		private void initCompatUi() {
		if (mViewHost != null) {
		throw new IllegalStateException(
		"A UI has already been created with this window manager.");
		}

		// Construction extracted into the separate methods to allow injection for tests.
		mViewHost = createSurfaceViewHost();
		mCompatUILayout = inflateCompatUILayout();
		mCompatUILayout.inject(this);

		updateVisibilityOfViews();

		mViewHost.setView(mCompatUILayout, getWindowLayoutParams());
		}

		private void updateVisibilityOfViews() {
		// Size Compat mode restart button.
		mCompatUILayout.setRestartButtonVisibility(mHasSizeCompat);
		mLayout.setRestartButtonVisibility(mHasSizeCompat);
		if (mHasSizeCompat && mShouldShowSizeCompatHint) {
		mCompatUILayout.setSizeCompatHintVisibility(/* show= */ true);
		mLayout.setSizeCompatHintVisibility(/* show= */ true);
		// Only show by default for the first time.
		mShouldShowSizeCompatHint = false;
		}

		// Camera control for stretched issues.
		mCompatUILayout.setCameraControlVisibility(shouldShowCameraControl());
		mLayout.setCameraControlVisibility(shouldShowCameraControl());
		if (shouldShowCameraControl() && mShouldShowCameraCompatHint) {
		mCompatUILayout.setCameraCompatHintVisibility(/* show= */ true);
		mLayout.setCameraCompatHintVisibility(/* show= */ true);
		// Only show by default for the first time.
		mShouldShowCameraCompatHint = false;
		}
		if (shouldShowCameraControl()) {
		mCompatUILayout.updateCameraTreatmentButton(mCameraCompatControlState);
		mLayout.updateCameraTreatmentButton(mCameraCompatControlState);
		}
		}

		@@ -386,32 +234,4 @@ class CompatUIWindowManager extends WindowlessWindowManager {
		return mCameraCompatControlState != CAMERA_COMPAT_CONTROL_HIDDEN
		&& mCameraCompatControlState != CAMERA_COMPAT_CONTROL_DISMISSED;
		}

		@VisibleForTesting
		CompatUILayout inflateCompatUILayout() {
		return (CompatUILayout) LayoutInflater.from(mContext)
		.inflate(R.layout.compat_ui_layout, null);
		}

		@VisibleForTesting
		SurfaceControlViewHost createSurfaceViewHost() {
		return new SurfaceControlViewHost(mContext, mContext.getDisplay(), this);
		}

		/** Gets the layout params. */
		private WindowManager.LayoutParams getWindowLayoutParams() {
		// Measure how big the hint is since its size depends on the text size.
		mCompatUILayout.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED);
		final WindowManager.LayoutParams winParams = new WindowManager.LayoutParams(
		// Cannot be wrap_content as this determines the actual window size
		mCompatUILayout.getMeasuredWidth(), mCompatUILayout.getMeasuredHeight(),
		TYPE_APPLICATION_OVERLAY,
		FLAG_NOT_FOCUSABLE \| FLAG_NOT_TOUCH_MODAL,
		PixelFormat.TRANSLUCENT);
		winParams.token = new Binder();
		winParams.setTitle(CompatUILayout.class.getSimpleName() + mTaskId);
		winParams.privateFlags \|= PRIVATE_FLAG_NO_MOVE_ANIMATION \| PRIVATE_FLAG_TRUSTED_OVERLAY;
		return winParams;
		}

		}

libs/WindowManager/Shell/src/com/android/wm/shell/compatui/CompatUIWindowManagerAbstract.java

0 → 100644

+364 −0

File added.

Preview size limit exceeded, changes collapsed.

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/compatui/CompatUIControllerTest.java

+14 −32

Original line number	Diff line number	Diff line
		@@ -116,35 +116,17 @@ public class CompatUIControllerTest extends ShellTestCase {
		TaskInfo taskInfo = createTaskInfo(DISPLAY_ID, TASK_ID, true /* hasSizeCompat */,
		CAMERA_COMPAT_CONTROL_HIDDEN);

		// Verify that the restart button is added with non-null size compat info.
		// Verify that the compat controls are added with non-null size compat info.
		mController.onCompatInfoChanged(taskInfo, mMockTaskListener);

		verify(mController).createLayout(any(), eq(taskInfo), eq(mMockTaskListener));

		// Verify that the restart button is updated with non-null new size compat info.
		mController.onCompatInfoChanged(createTaskInfo(DISPLAY_ID, TASK_ID,
		true /* hasSizeCompat */, CAMERA_COMPAT_CONTROL_HIDDEN),
		mMockTaskListener);

		verify(mMockLayout).updateCompatInfo(new Configuration(), mMockTaskListener,
		true /* show /, true / hasSizeCompat */, CAMERA_COMPAT_CONTROL_HIDDEN);

		// Verify that the restart button is updated with new camera state.
		mController.onCompatInfoChanged(createTaskInfo(DISPLAY_ID, TASK_ID,
		true /* hasSizeCompat */, CAMERA_COMPAT_CONTROL_TREATMENT_APPLIED),
		mMockTaskListener);

		verify(mMockLayout).updateCompatInfo(new Configuration(), mMockTaskListener,
		true /* show /, true / hasSizeCompat */,
		// Verify that the compat controls are updated with non-null new size compat info.
		taskInfo = createTaskInfo(DISPLAY_ID, TASK_ID, true /* hasSizeCompat */,
		CAMERA_COMPAT_CONTROL_TREATMENT_APPLIED);
		mController.onCompatInfoChanged(taskInfo, mMockTaskListener);

		mController.onCompatInfoChanged(createTaskInfo(DISPLAY_ID, TASK_ID,
		true /* hasSizeCompat */, CAMERA_COMPAT_CONTROL_TREATMENT_SUGGESTED),
		mMockTaskListener);

		verify(mMockLayout).updateCompatInfo(new Configuration(), mMockTaskListener,
		true /* show /, true / hasSizeCompat */,
		CAMERA_COMPAT_CONTROL_TREATMENT_SUGGESTED);
		verify(mMockLayout).updateCompatInfo(taskInfo, mMockTaskListener, true /* canShow */);

		// Verify that compat controls are removed with null compat info.
		mController.onCompatInfoChanged(createTaskInfo(DISPLAY_ID, TASK_ID,
		@@ -155,7 +137,7 @@ public class CompatUIControllerTest extends ShellTestCase {

		clearInvocations(mMockLayout);
		clearInvocations(mController);
		// Verify that compat controls are removed with dismissed camera state.
		// Verify that compat controls are removed with no size compat and dismissed camera state.
		taskInfo = createTaskInfo(DISPLAY_ID, TASK_ID,
		true /* hasSizeCompat */, CAMERA_COMPAT_CONTROL_TREATMENT_SUGGESTED);

		@@ -245,11 +227,11 @@ public class CompatUIControllerTest extends ShellTestCase {
		verify(mMockLayout).updateVisibility(false);

		// Verify button remains hidden while IME is showing.
		mController.onCompatInfoChanged(createTaskInfo(DISPLAY_ID, TASK_ID,
		true /* hasSizeCompat */, CAMERA_COMPAT_CONTROL_HIDDEN), mMockTaskListener);
		TaskInfo taskInfo = createTaskInfo(DISPLAY_ID, TASK_ID, true /* hasSizeCompat */,
		CAMERA_COMPAT_CONTROL_HIDDEN);
		mController.onCompatInfoChanged(taskInfo, mMockTaskListener);

		verify(mMockLayout).updateCompatInfo(new Configuration(), mMockTaskListener,
		false /* show /, true / hasSizeCompat */, CAMERA_COMPAT_CONTROL_HIDDEN);
		verify(mMockLayout).updateCompatInfo(taskInfo, mMockTaskListener, false /* canShow */);

		// Verify button is shown after IME is hidden.
		mController.onImeVisibilityChanged(DISPLAY_ID, false /* isShowing */);
		@@ -268,11 +250,11 @@ public class CompatUIControllerTest extends ShellTestCase {
		verify(mMockLayout).updateVisibility(false);

		// Verify button remains hidden while keyguard is occluded.
		mController.onCompatInfoChanged(createTaskInfo(DISPLAY_ID, TASK_ID,
		true /* hasSizeCompat */, CAMERA_COMPAT_CONTROL_HIDDEN), mMockTaskListener);
		TaskInfo taskInfo = createTaskInfo(DISPLAY_ID, TASK_ID, true /* hasSizeCompat */,
		CAMERA_COMPAT_CONTROL_HIDDEN);
		mController.onCompatInfoChanged(taskInfo, mMockTaskListener);

		verify(mMockLayout).updateCompatInfo(new Configuration(), mMockTaskListener,
		false /* show /, true / hasSizeCompat */, CAMERA_COMPAT_CONTROL_HIDDEN);
		verify(mMockLayout).updateCompatInfo(taskInfo, mMockTaskListener, false /* canShow */);

		// Verify button is shown after keyguard becomes not occluded.
		mController.onKeyguardOccludedChanged(false);

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/compatui/CompatUILayoutTest.java

+22 −11

File changed.

Preview size limit exceeded, changes collapsed.