tests/framework/base/windowmanager/src/android/server/wm/insets/WindowInsetsAnimationTests.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2023 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 android.server.wm.insets;

 import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
 import static android.graphics.Insets.NONE;
 import static android.view.Display.DEFAULT_DISPLAY;
 import static android.view.WindowInsets.Type.captionBar;
 import static android.view.WindowInsets.Type.navigationBars;
 import static android.view.WindowInsets.Type.statusBars;
 import static android.view.WindowInsets.Type.systemBars;
 import static android.view.WindowInsetsAnimation.Callback.DISPATCH_MODE_CONTINUE_ON_SUBTREE;

 import static androidx.test.InstrumentationRegistry.getInstrumentation;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assume.assumeFalse;
 import static org.junit.Assume.assumeTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.argThat;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.CALLS_REAL_METHODS;
 import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyZeroInteractions;
 import static org.mockito.Mockito.withSettings;

 import android.platform.test.annotations.Presubmit;
 import android.view.View;
 import android.view.WindowInsets;
 import android.view.WindowInsetsAnimation;
 import android.view.WindowInsetsAnimation.Bounds;
 import android.view.WindowInsetsAnimation.Callback;

 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;

 import java.util.List;

 /**
  * Test whether {@link WindowInsetsAnimation.Callback} are properly dispatched to views.
  *
  * <p>Build/Install/Run: atest CtsWindowManagerDeviceInsets:WindowInsetsAnimationTests
  */
 @Presubmit
 @android.server.wm.annotation.Group2
 public class WindowInsetsAnimationTests extends WindowInsetsAnimationTestBase {

     @Before
     public void setup() throws Exception {
         super.setUp();
         mActivity =
                 startActivity(TestActivity.class, DEFAULT_DISPLAY, true, WINDOWING_MODE_FULLSCREEN);
         mRootView = mActivity.getWindow().getDecorView();
         assumeTrue(hasWindowInsets(mRootView, systemBars()));
         assumeFalse(isCar() && remoteInsetsControllerControlsSystemBars());
     }

     @Test
     public void testAnimationCallbacksHide() {
         WindowInsets before = mActivity.mLastWindowInsets;

         getInstrumentation()
                 .runOnMainSync(() -> mRootView.getWindowInsetsController().hide(systemBars()));

         waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);

         commonAnimationAssertions(
                 mActivity, before, false /* show */, systemBars() & ~captionBar());
     }

     @Test
     public void testAnimationCallbacksShow() {
         getInstrumentation()
                 .runOnMainSync(() -> mRootView.getWindowInsetsController().hide(systemBars()));

         waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);
         mActivity.mCallback.animationDone = false;

         WindowInsets before = mActivity.mLastWindowInsets;

         getInstrumentation()
                 .runOnMainSync(() -> mRootView.getWindowInsetsController().show(systemBars()));

         waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);

         commonAnimationAssertions(mActivity, before, true /* show */, systemBars() & ~captionBar());
     }

     @Test
     public void testAnimationCallbacks_overlapping() {
         assumeTrue(
                 "Test requires navBar and statusBar to create overlapping animations.",
                 hasWindowInsets(mRootView, navigationBars())
                         && hasWindowInsets(mRootView, statusBars()));

         WindowInsets before = mActivity.mLastWindowInsets;
         MultiAnimCallback callbackInner = new MultiAnimCallback();
         MultiAnimCallback callback =
                 mock(
                         MultiAnimCallback.class,
                         withSettings()
                                 .spiedInstance(callbackInner)
                                 .defaultAnswer(CALLS_REAL_METHODS)
                                 .verboseLogging());
         mActivity.mView.setWindowInsetsAnimationCallback(callback);
         callback.startRunnable =
                 () ->
                         mRootView.postDelayed(
                                 () -> mRootView.getWindowInsetsController().hide(statusBars()), 50);

         getInstrumentation()
                 .runOnMainSync(() -> mRootView.getWindowInsetsController().hide(navigationBars()));

         waitForOrFail("Waiting until animation done", () -> callback.animationDone);

         WindowInsets after = mActivity.mLastWindowInsets;

         InOrder inOrder = inOrder(callback, mActivity.mListener);

         inOrder.verify(callback).onPrepare(eq(callback.navBarAnim));

         inOrder.verify(mActivity.mListener)
                 .onApplyWindowInsets(
                         any(),
                         argThat(
                                 argument ->
                                         NONE.equals(argument.getInsets(navigationBars()))
                                                 && !NONE.equals(argument.getInsets(statusBars()))));

         inOrder.verify(callback)
                 .onStart(
                         eq(callback.navBarAnim),
                         argThat(
                                 argument ->
                                         argument.getLowerBound().equals(NONE)
                                                 && argument.getUpperBound()
                                                         .equals(
                                                                 before.getInsets(
                                                                         navigationBars()))));

         inOrder.verify(callback).onPrepare(eq(callback.statusBarAnim));
         inOrder.verify(mActivity.mListener)
                 .onApplyWindowInsets(any(), eq(mActivity.mLastWindowInsets));

         inOrder.verify(callback)
                 .onStart(
                         eq(callback.statusBarAnim),
                         argThat(
                                 argument ->
                                         argument.getLowerBound().equals(NONE)
                                                 && argument.getUpperBound()
                                                         .equals(before.getInsets(statusBars()))));

         inOrder.verify(callback).onEnd(eq(callback.navBarAnim));
         inOrder.verify(callback).onEnd(eq(callback.statusBarAnim));

         assertAnimationSteps(callback.navAnimSteps, false /* showAnimation */);
         assertAnimationSteps(callback.statusAnimSteps, false /* showAnimation */);

         assertEquals(
                 before.getInsets(navigationBars()),
                 callback.navAnimSteps.get(0).insets.getInsets(navigationBars()));
         assertEquals(
                 after.getInsets(navigationBars()),
                 callback.navAnimSteps
                         .get(callback.navAnimSteps.size() - 1)
                         .insets
                         .getInsets(navigationBars()));

         assertEquals(
                 before.getInsets(statusBars()),
                 callback.statusAnimSteps.get(0).insets.getInsets(statusBars()));
         assertEquals(
                 after.getInsets(statusBars()),
                 callback.statusAnimSteps
                         .get(callback.statusAnimSteps.size() - 1)
                         .insets
                         .getInsets(statusBars()));
     }

     @Test
     public void testAnimationCallbacks_consumedByDecor() {
         getInstrumentation()
                 .runOnMainSync(
                         () -> {
                             mActivity.getWindow().setDecorFitsSystemWindows(true);
                             mRootView.getWindowInsetsController().hide(systemBars());
                         });

         getWmState()
                 .waitFor(
                         state -> !state.isWindowVisible("StatusBar"),
                         "Waiting for status bar to be hidden");
         assertFalse(getWmState().isWindowVisible("StatusBar"));

         verifyZeroInteractions(mActivity.mCallback);
     }

     @Test
     public void testAnimationCallbacks_childDoesntGetCallback() {
         WindowInsetsAnimation.Callback childCallback = mock(WindowInsetsAnimation.Callback.class);

         getInstrumentation()
                 .runOnMainSync(
                         () -> {
                             mActivity.mChild.setWindowInsetsAnimationCallback(childCallback);
                             mRootView.getWindowInsetsController().hide(systemBars());
                         });

         waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);

         verifyZeroInteractions(childCallback);
     }

     @Test
     public void testAnimationCallbacks_childInsetting() {
         // test requires navbar.
         assumeTrue(hasWindowInsets(mRootView, navigationBars()));

         WindowInsets before = mActivity.mLastWindowInsets;
         boolean[] done = new boolean[1];
         WindowInsetsAnimation.Callback childCallback = mock(WindowInsetsAnimation.Callback.class);
         WindowInsetsAnimation.Callback callback =
                 new Callback(DISPATCH_MODE_CONTINUE_ON_SUBTREE) {

                     @Override
                     public Bounds onStart(WindowInsetsAnimation animation, Bounds bounds) {
                         return bounds.inset(before.getInsets(navigationBars()));
                     }

                     @Override
                     public WindowInsets onProgress(
                             WindowInsets insets, List<WindowInsetsAnimation> runningAnimations) {
                         return insets.inset(insets.getInsets(navigationBars()));
                     }

                     @Override
                     public void onEnd(WindowInsetsAnimation animation) {
                         done[0] = true;
                     }
                 };

         getInstrumentation()
                 .runOnMainSync(
                         () -> {
                             mActivity.mView.setWindowInsetsAnimationCallback(callback);
                             mActivity.mChild.setWindowInsetsAnimationCallback(childCallback);
                             mRootView.getWindowInsetsController().hide(systemBars());
                         });

         waitForOrFail("Waiting until animation done", () -> done[0]);

         if (hasWindowInsets(mRootView, statusBars())) {
             verify(childCallback)
                     .onStart(
                             any(),
                             argThat(
                                     bounds ->
                                             bounds.getUpperBound()
                                                     .equals(before.getInsets(statusBars()))));
         }
         if (hasWindowInsets(mRootView, navigationBars())) {
             verify(childCallback, atLeastOnce())
                     .onProgress(
                             argThat(insets -> NONE.equals(insets.getInsets(navigationBars()))),
                             any());
         }
     }

     @Test
     public void testAnimationCallbacks_withLegacyFlags() {
         getInstrumentation()
                 .runOnMainSync(
                         () -> {
                             mActivity.getWindow().setDecorFitsSystemWindows(true);
                             mRootView.setSystemUiVisibility(
                                     View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                                             | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                                             | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
                             mRootView.post(
                                     () -> {
                                         mRootView.getWindowInsetsController().hide(systemBars());
                                     });
                         });

         waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);

         mWmState.computeState();
         assertFalse(mWmState.isWindowVisible("StatusBar"));
         verify(mActivity.mCallback).onPrepare(any());
         verify(mActivity.mCallback).onStart(any(), any());
         verify(mActivity.mCallback, atLeastOnce()).onProgress(any(), any());
         verify(mActivity.mCallback).onEnd(any());
     }
 }
	/*
	* Copyright (C) 2023 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 android.server.wm.insets;

	import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
	import static android.graphics.Insets.NONE;
	import static android.view.Display.DEFAULT_DISPLAY;
	import static android.view.WindowInsets.Type.captionBar;
	import static android.view.WindowInsets.Type.navigationBars;
	import static android.view.WindowInsets.Type.statusBars;
	import static android.view.WindowInsets.Type.systemBars;
	import static android.view.WindowInsetsAnimation.Callback.DISPATCH_MODE_CONTINUE_ON_SUBTREE;

	import static androidx.test.InstrumentationRegistry.getInstrumentation;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assume.assumeFalse;
	import static org.junit.Assume.assumeTrue;
	import static org.mockito.ArgumentMatchers.any;
	import static org.mockito.ArgumentMatchers.argThat;
	import static org.mockito.ArgumentMatchers.eq;
	import static org.mockito.Mockito.CALLS_REAL_METHODS;
	import static org.mockito.Mockito.atLeastOnce;
	import static org.mockito.Mockito.inOrder;
	import static org.mockito.Mockito.mock;
	import static org.mockito.Mockito.verify;
	import static org.mockito.Mockito.verifyZeroInteractions;
	import static org.mockito.Mockito.withSettings;

	import android.platform.test.annotations.Presubmit;
	import android.view.View;
	import android.view.WindowInsets;
	import android.view.WindowInsetsAnimation;
	import android.view.WindowInsetsAnimation.Bounds;
	import android.view.WindowInsetsAnimation.Callback;

	import org.junit.Before;
	import org.junit.Test;
	import org.mockito.InOrder;

	import java.util.List;

	/**
	* Test whether {@link WindowInsetsAnimation.Callback} are properly dispatched to views.
	*
	* <p>Build/Install/Run: atest CtsWindowManagerDeviceInsets:WindowInsetsAnimationTests
	*/
	@Presubmit
	@android.server.wm.annotation.Group2
	public class WindowInsetsAnimationTests extends WindowInsetsAnimationTestBase {

	@Before
	public void setup() throws Exception {
	super.setUp();
	mActivity =
	startActivity(TestActivity.class, DEFAULT_DISPLAY, true, WINDOWING_MODE_FULLSCREEN);
	mRootView = mActivity.getWindow().getDecorView();
	assumeTrue(hasWindowInsets(mRootView, systemBars()));
	assumeFalse(isCar() && remoteInsetsControllerControlsSystemBars());
	}

	@Test
	public void testAnimationCallbacksHide() {
	WindowInsets before = mActivity.mLastWindowInsets;

	getInstrumentation()
	.runOnMainSync(() -> mRootView.getWindowInsetsController().hide(systemBars()));

	waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);

	commonAnimationAssertions(
	mActivity, before, false /* show */, systemBars() & ~captionBar());
	}

	@Test
	public void testAnimationCallbacksShow() {
	getInstrumentation()
	.runOnMainSync(() -> mRootView.getWindowInsetsController().hide(systemBars()));

	waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);
	mActivity.mCallback.animationDone = false;

	WindowInsets before = mActivity.mLastWindowInsets;

	getInstrumentation()
	.runOnMainSync(() -> mRootView.getWindowInsetsController().show(systemBars()));

	waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);

	commonAnimationAssertions(mActivity, before, true /* show */, systemBars() & ~captionBar());
	}

	@Test
	public void testAnimationCallbacks_overlapping() {
	assumeTrue(
	"Test requires navBar and statusBar to create overlapping animations.",
	hasWindowInsets(mRootView, navigationBars())
	&& hasWindowInsets(mRootView, statusBars()));

	WindowInsets before = mActivity.mLastWindowInsets;
	MultiAnimCallback callbackInner = new MultiAnimCallback();
	MultiAnimCallback callback =
	mock(
	MultiAnimCallback.class,
	withSettings()
	.spiedInstance(callbackInner)
	.defaultAnswer(CALLS_REAL_METHODS)
	.verboseLogging());
	mActivity.mView.setWindowInsetsAnimationCallback(callback);
	callback.startRunnable =
	() ->
	mRootView.postDelayed(
	() -> mRootView.getWindowInsetsController().hide(statusBars()), 50);

	getInstrumentation()
	.runOnMainSync(() -> mRootView.getWindowInsetsController().hide(navigationBars()));

	waitForOrFail("Waiting until animation done", () -> callback.animationDone);

	WindowInsets after = mActivity.mLastWindowInsets;

	InOrder inOrder = inOrder(callback, mActivity.mListener);

	inOrder.verify(callback).onPrepare(eq(callback.navBarAnim));

	inOrder.verify(mActivity.mListener)
	.onApplyWindowInsets(
	any(),
	argThat(
	argument ->
	NONE.equals(argument.getInsets(navigationBars()))
	&& !NONE.equals(argument.getInsets(statusBars()))));

	inOrder.verify(callback)
	.onStart(
	eq(callback.navBarAnim),
	argThat(
	argument ->
	argument.getLowerBound().equals(NONE)
	&& argument.getUpperBound()
	.equals(
	before.getInsets(
	navigationBars()))));

	inOrder.verify(callback).onPrepare(eq(callback.statusBarAnim));
	inOrder.verify(mActivity.mListener)
	.onApplyWindowInsets(any(), eq(mActivity.mLastWindowInsets));

	inOrder.verify(callback)
	.onStart(
	eq(callback.statusBarAnim),
	argThat(
	argument ->
	argument.getLowerBound().equals(NONE)
	&& argument.getUpperBound()
	.equals(before.getInsets(statusBars()))));

	inOrder.verify(callback).onEnd(eq(callback.navBarAnim));
	inOrder.verify(callback).onEnd(eq(callback.statusBarAnim));

	assertAnimationSteps(callback.navAnimSteps, false /* showAnimation */);
	assertAnimationSteps(callback.statusAnimSteps, false /* showAnimation */);

	assertEquals(
	before.getInsets(navigationBars()),
	callback.navAnimSteps.get(0).insets.getInsets(navigationBars()));
	assertEquals(
	after.getInsets(navigationBars()),
	callback.navAnimSteps
	.get(callback.navAnimSteps.size() - 1)
	.insets
	.getInsets(navigationBars()));

	assertEquals(
	before.getInsets(statusBars()),
	callback.statusAnimSteps.get(0).insets.getInsets(statusBars()));
	assertEquals(
	after.getInsets(statusBars()),
	callback.statusAnimSteps
	.get(callback.statusAnimSteps.size() - 1)
	.insets
	.getInsets(statusBars()));
	}

	@Test
	public void testAnimationCallbacks_consumedByDecor() {
	getInstrumentation()
	.runOnMainSync(
	() -> {
	mActivity.getWindow().setDecorFitsSystemWindows(true);
	mRootView.getWindowInsetsController().hide(systemBars());
	});

	getWmState()
	.waitFor(
	state -> !state.isWindowVisible("StatusBar"),
	"Waiting for status bar to be hidden");
	assertFalse(getWmState().isWindowVisible("StatusBar"));

	verifyZeroInteractions(mActivity.mCallback);
	}

	@Test
	public void testAnimationCallbacks_childDoesntGetCallback() {
	WindowInsetsAnimation.Callback childCallback = mock(WindowInsetsAnimation.Callback.class);

	getInstrumentation()
	.runOnMainSync(
	() -> {
	mActivity.mChild.setWindowInsetsAnimationCallback(childCallback);
	mRootView.getWindowInsetsController().hide(systemBars());
	});

	waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);

	verifyZeroInteractions(childCallback);
	}

	@Test
	public void testAnimationCallbacks_childInsetting() {
	// test requires navbar.
	assumeTrue(hasWindowInsets(mRootView, navigationBars()));

	WindowInsets before = mActivity.mLastWindowInsets;
	boolean[] done = new boolean[1];
	WindowInsetsAnimation.Callback childCallback = mock(WindowInsetsAnimation.Callback.class);
	WindowInsetsAnimation.Callback callback =
	new Callback(DISPATCH_MODE_CONTINUE_ON_SUBTREE) {

	@Override
	public Bounds onStart(WindowInsetsAnimation animation, Bounds bounds) {
	return bounds.inset(before.getInsets(navigationBars()));
	}

	@Override
	public WindowInsets onProgress(
	WindowInsets insets, List<WindowInsetsAnimation> runningAnimations) {
	return insets.inset(insets.getInsets(navigationBars()));
	}

	@Override
	public void onEnd(WindowInsetsAnimation animation) {
	done[0] = true;
	}
	};

	getInstrumentation()
	.runOnMainSync(
	() -> {
	mActivity.mView.setWindowInsetsAnimationCallback(callback);
	mActivity.mChild.setWindowInsetsAnimationCallback(childCallback);
	mRootView.getWindowInsetsController().hide(systemBars());
	});

	waitForOrFail("Waiting until animation done", () -> done[0]);

	if (hasWindowInsets(mRootView, statusBars())) {
	verify(childCallback)
	.onStart(
	any(),
	argThat(
	bounds ->
	bounds.getUpperBound()
	.equals(before.getInsets(statusBars()))));
	}
	if (hasWindowInsets(mRootView, navigationBars())) {
	verify(childCallback, atLeastOnce())
	.onProgress(
	argThat(insets -> NONE.equals(insets.getInsets(navigationBars()))),
	any());
	}
	}

	@Test
	public void testAnimationCallbacks_withLegacyFlags() {
	getInstrumentation()
	.runOnMainSync(
	() -> {
	mActivity.getWindow().setDecorFitsSystemWindows(true);
	mRootView.setSystemUiVisibility(
	View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
	\| View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
	\| View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
	mRootView.post(
	() -> {
	mRootView.getWindowInsetsController().hide(systemBars());
	});
	});

	waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);

	mWmState.computeState();
	assertFalse(mWmState.isWindowVisible("StatusBar"));
	verify(mActivity.mCallback).onPrepare(any());
	verify(mActivity.mCallback).onStart(any(), any());
	verify(mActivity.mCallback, atLeastOnce()).onProgress(any(), any());
	verify(mActivity.mCallback).onEnd(any());
	}
	}