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

 /*
  * 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 android.server.wm.jetpack;

 import static android.server.wm.jetpack.utils.ActivityEmbeddingUtil.DEFAULT_SPLIT_RATIO;
 import static android.server.wm.jetpack.utils.ActivityEmbeddingUtil.UNEVEN_CONTAINERS_DEFAULT_SPLIT_RATIO;
 import static android.server.wm.jetpack.utils.ActivityEmbeddingUtil.assertValidSplit;
 import static android.server.wm.jetpack.utils.ActivityEmbeddingUtil.startActivityAndVerifySplit;
 import static android.server.wm.jetpack.utils.ActivityEmbeddingUtil.waitAndAssertNotVisible;
 import static android.server.wm.jetpack.utils.ActivityEmbeddingUtil.waitForFillsTask;

 import static org.junit.Assert.assertTrue;

 import android.app.Activity;
 import android.content.Intent;
 import android.server.wm.jetpack.utils.TestActivity;
 import android.server.wm.jetpack.utils.TestActivityWithId;
 import android.server.wm.jetpack.utils.TestConfigChangeHandlingActivity;
 import android.util.LayoutDirection;
 import android.util.Pair;
 import android.util.Size;

 import androidx.annotation.NonNull;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import androidx.window.extensions.embedding.SplitPairRule;

 import org.junit.Test;
 import org.junit.runner.RunWith;

 import java.util.Collections;
 import java.util.Set;

 /**
  * Tests for the {@link androidx.window.extensions} implementation provided on the device (and only
  * if one is available) for the Activity Embedding functionality. Specifically tests activity
  * split bounds.
  *
  * Build/Install/Run:
  *     atest CtsWindowManagerJetpackTestCases:ActivityEmbeddingBoundsTests
  */
 @RunWith(AndroidJUnit4.class)
 public class ActivityEmbeddingBoundsTests extends ActivityEmbeddingTestBase {

     /**
      * Tests that when two activities are in a split and the parent bounds shrink such that
      * they can no longer support split activities, then the activities become stacked.
      */
     @Test
     public void testParentWindowMetricsPredicate() {
         // Launch primary activity
         final Activity primaryActivity = startActivityNewTask(
                 TestConfigChangeHandlingActivity.class);

         // Set split pair rule such that if the parent width is any smaller than it is now, then
         // the parent cannot support a split.
         final int originalTaskWidth = getTaskWidth();
         final SplitPairRule splitPairRule = new SplitPairRule.Builder(
                 activityActivityPair -> true /* activityPairPredicate */,
                 activityIntentPair -> true /* activityIntentPredicate */,
                 parentWindowMetrics -> parentWindowMetrics.getBounds().width() >= originalTaskWidth)
                 .setSplitRatio(DEFAULT_SPLIT_RATIO).build();
         mActivityEmbeddingComponent.setEmbeddingRules(Collections.singleton(splitPairRule));

         // Launch the secondary activity
         final String secondaryActivityId = "secondaryActivityId";
         final TestActivity secondaryActivity = (TestActivity) startActivityAndVerifySplit(
                 primaryActivity, TestActivityWithId.class, splitPairRule, secondaryActivityId,
                 mSplitInfoConsumer);

         // Resize the display multiple times to verify that the activities are correctly split or
         // stacked depending on the parent bounds. Resizing multiple times simulates a foldable
         // display is that folded and unfolded multiple times while running the same app.
         final int numTimesToResize = 2;
         final Size originalDisplaySize = mReportedDisplayMetrics.getSize();
         for (int i = 0; i < numTimesToResize; i++) {
             // Shrink the display by 10% to make the activities stacked
             mReportedDisplayMetrics.setSize(new Size((int) (originalDisplaySize.getWidth() * 0.9),
                     originalDisplaySize.getHeight()));
             waitForFillsTask(secondaryActivity);
             waitAndAssertNotVisible(primaryActivity);

             // Return the display to its original size and verify that the activities are split
             secondaryActivity.resetBoundsChangeCounter();
             mReportedDisplayMetrics.setSize(originalDisplaySize);
             assertTrue(secondaryActivity.waitForBoundsChange());
             assertValidSplit(primaryActivity, secondaryActivity, splitPairRule);
         }
     }

     /**
      * Tests that the activity bounds for activities in a split match the LTR layout direction
      * provided in the {@link SplitPairRule}.
      */
     @Test
     public void testLayoutDirection_LTR() {
         // Create a split pair rule with layout direction LTR and a split ratio that results in
         // uneven bounds between the primary and secondary containers.
         final SplitPairRule splitPairRule = createUnevenWidthSplitPairRule(LayoutDirection.LTR);
         mActivityEmbeddingComponent.setEmbeddingRules(Collections.singleton(splitPairRule));

         // Start activities in a split and verify that the layout direction is LTR, which is
         // checked in {@link ActivityEmbeddingUtil#startActivityAndVerifySplit}.
         Activity primaryActivity = startActivityNewTask(TestConfigChangeHandlingActivity.class);
         startActivityAndVerifySplit(primaryActivity, TestActivityWithId.class, splitPairRule,
                 "secondaryActivityId", mSplitInfoConsumer);
     }

     /**
      * Tests that the activity bounds for activities in a split match the RTL layout direction
      * provided in the {@link SplitPairRule}.
      */
     @Test
     public void testLayoutDirection_RTL() {
         // Create a split pair rule with layout direction RTL and a split ratio that results in
         // uneven bounds between the primary and secondary containers.
         final SplitPairRule splitPairRule = createUnevenWidthSplitPairRule(LayoutDirection.RTL);
         mActivityEmbeddingComponent.setEmbeddingRules(Collections.singleton(splitPairRule));

         // Start activities in a split and verify that the layout direction is RTL, which is
         // checked in {@link ActivityEmbeddingUtil#startActivityAndVerifySplit}.
         Activity primaryActivity = startActivityNewTask(TestConfigChangeHandlingActivity.class);
         startActivityAndVerifySplit(primaryActivity, TestActivityWithId.class, splitPairRule,
                 "secondaryActivityId", mSplitInfoConsumer);
     }

     /**
      * Tests that the activity bounds for activities in a split match the Locale layout direction
      * provided in the {@link SplitPairRule}.
      */
     @Test
     public void testLayoutDirection_Locale() {
         // Create a split pair rule with layout direction LOCALE and a split ratio that results in
         // uneven bounds between the primary and secondary containers.
         final SplitPairRule splitPairRule = createUnevenWidthSplitPairRule(LayoutDirection.LOCALE);
         mActivityEmbeddingComponent.setEmbeddingRules(Collections.singleton(splitPairRule));

         // Start activities in a split and verify that the layout direction is the device locale,
         // which is checked in {@link ActivityEmbeddingUtil#startActivityAndVerifySplit}.
         Activity primaryActivity = startActivityNewTask(TestConfigChangeHandlingActivity.class);
         startActivityAndVerifySplit(primaryActivity, TestActivityWithId.class, splitPairRule,
                 "secondaryActivityId", mSplitInfoConsumer);
     }

     /**
      * Tests that when two activities enter a split, then their split ratio matches what is in their
      * {@link SplitPairRule}, and is not assumed to be 0.5 or match the split ratio of the previous
      * top-most activity split.
      */
     @Test
     public void testSplitRatio() {
         final String activityAId = "activityA";
         final String activityBId = "activityB";
         final String activityCId = "activityC";
         final float activityABSplitRatio = 0.37f;
         final float activityBCSplitRatio = 0.85f;

         // Create a split rule for activity A and activity B where the split ratio is 0.37.
         final SplitPairRule splitPairRuleAB = new SplitPairRule.Builder(
                 activityActivityPair -> false /* activityPairPredicate */,
                 activityIntentPair -> matchesActivityIntentPair(activityIntentPair, activityAId,
                         activityBId) /* activityIntentPredicate */,
                 parentWindowMetrics -> true /* parentWindowMetricsPredicate */)
                 .setSplitRatio(activityABSplitRatio).build();

         // Create a split rule for activity B and activity C where the split ratio is 0.65.
         final SplitPairRule splitPairRuleBC = new SplitPairRule.Builder(
                 activityActivityPair -> false /* activityPairPredicate */,
                 activityIntentPair -> matchesActivityIntentPair(activityIntentPair, activityBId,
                         activityCId) /* activityIntentPredicate */,
                 parentWindowMetrics -> true /* parentWindowMetricsPredicate */)
                 .setSplitRatio(activityBCSplitRatio).build();

         // Register the two split pair rules
         mActivityEmbeddingComponent.setEmbeddingRules(Set.of(splitPairRuleAB, splitPairRuleBC));

         // Launch the activity A and B split and verify that the split ratio is 0.37 in
         // {@link ActivityEmbeddingUtil#startActivityAndVerifySplit}.
         Activity activityA = startActivityNewTask(TestActivityWithId.class, activityAId);
         Activity activityB = startActivityAndVerifySplit(activityA, TestActivityWithId.class,
                 splitPairRuleAB, activityBId, mSplitInfoConsumer);

         // Launch the activity B and C split and verify that the split ratio is 0.65 in
         // {@link ActivityEmbeddingUtil#startActivityAndVerifySplit}.
         Activity activityC = startActivityAndVerifySplit(activityB, TestActivityWithId.class,
                 splitPairRuleBC, activityCId, mSplitInfoConsumer);

         // Finish activity C so that activity A and B are in a split again. Verify that the split
         // ratio returns to 0.37 in {@link ActivityEmbeddingUtil#assertValidSplit}.
         activityC.finish();
         assertValidSplit(activityA, activityB, splitPairRuleAB);
     }

     private SplitPairRule createUnevenWidthSplitPairRule(int layoutDir) {
         return new SplitPairRule.Builder(activityActivityPair -> true /* activityPairPredicate */,
                 activityIntentPair -> true /* activityIntentPredicate */,
                 parentWindowMetrics -> true /* parentWindowMetricsPredicate */)
                 .setSplitRatio(UNEVEN_CONTAINERS_DEFAULT_SPLIT_RATIO)
                 .setLayoutDirection(layoutDir).build();
     }

     private boolean matchesActivityIntentPair(@NonNull Pair<Activity, Intent> activityIntentPair,
             @NonNull String primaryActivityId, @NonNull String secondaryActivityId) {
         if (!(activityIntentPair.first instanceof TestActivityWithId)) {
             return false;
         }
         return primaryActivityId.equals(((TestActivityWithId) activityIntentPair.first).getId())
                 && secondaryActivityId.equals(activityIntentPair.second.getStringExtra(
                         ACTIVITY_ID_LABEL));
     }
 }
	/*
	* 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 android.server.wm.jetpack;

	import static android.server.wm.jetpack.utils.ActivityEmbeddingUtil.DEFAULT_SPLIT_RATIO;
	import static android.server.wm.jetpack.utils.ActivityEmbeddingUtil.UNEVEN_CONTAINERS_DEFAULT_SPLIT_RATIO;
	import static android.server.wm.jetpack.utils.ActivityEmbeddingUtil.assertValidSplit;
	import static android.server.wm.jetpack.utils.ActivityEmbeddingUtil.startActivityAndVerifySplit;
	import static android.server.wm.jetpack.utils.ActivityEmbeddingUtil.waitAndAssertNotVisible;
	import static android.server.wm.jetpack.utils.ActivityEmbeddingUtil.waitForFillsTask;

	import static org.junit.Assert.assertTrue;

	import android.app.Activity;
	import android.content.Intent;
	import android.server.wm.jetpack.utils.TestActivity;
	import android.server.wm.jetpack.utils.TestActivityWithId;
	import android.server.wm.jetpack.utils.TestConfigChangeHandlingActivity;
	import android.util.LayoutDirection;
	import android.util.Pair;
	import android.util.Size;

	import androidx.annotation.NonNull;
	import androidx.test.ext.junit.runners.AndroidJUnit4;
	import androidx.window.extensions.embedding.SplitPairRule;

	import org.junit.Test;
	import org.junit.runner.RunWith;

	import java.util.Collections;
	import java.util.Set;

	/**
	* Tests for the {@link androidx.window.extensions} implementation provided on the device (and only
	* if one is available) for the Activity Embedding functionality. Specifically tests activity
	* split bounds.
	*
	* Build/Install/Run:
	* atest CtsWindowManagerJetpackTestCases:ActivityEmbeddingBoundsTests
	*/
	@RunWith(AndroidJUnit4.class)
	public class ActivityEmbeddingBoundsTests extends ActivityEmbeddingTestBase {

	/**
	* Tests that when two activities are in a split and the parent bounds shrink such that
	* they can no longer support split activities, then the activities become stacked.
	*/
	@Test
	public void testParentWindowMetricsPredicate() {
	// Launch primary activity
	final Activity primaryActivity = startActivityNewTask(
	TestConfigChangeHandlingActivity.class);

	// Set split pair rule such that if the parent width is any smaller than it is now, then
	// the parent cannot support a split.
	final int originalTaskWidth = getTaskWidth();
	final SplitPairRule splitPairRule = new SplitPairRule.Builder(
	activityActivityPair -> true /* activityPairPredicate */,
	activityIntentPair -> true /* activityIntentPredicate */,
	parentWindowMetrics -> parentWindowMetrics.getBounds().width() >= originalTaskWidth)
	.setSplitRatio(DEFAULT_SPLIT_RATIO).build();
	mActivityEmbeddingComponent.setEmbeddingRules(Collections.singleton(splitPairRule));

	// Launch the secondary activity
	final String secondaryActivityId = "secondaryActivityId";
	final TestActivity secondaryActivity = (TestActivity) startActivityAndVerifySplit(
	primaryActivity, TestActivityWithId.class, splitPairRule, secondaryActivityId,
	mSplitInfoConsumer);

	// Resize the display multiple times to verify that the activities are correctly split or
	// stacked depending on the parent bounds. Resizing multiple times simulates a foldable
	// display is that folded and unfolded multiple times while running the same app.
	final int numTimesToResize = 2;
	final Size originalDisplaySize = mReportedDisplayMetrics.getSize();
	for (int i = 0; i < numTimesToResize; i++) {
	// Shrink the display by 10% to make the activities stacked
	mReportedDisplayMetrics.setSize(new Size((int) (originalDisplaySize.getWidth() * 0.9),
	originalDisplaySize.getHeight()));
	waitForFillsTask(secondaryActivity);
	waitAndAssertNotVisible(primaryActivity);

	// Return the display to its original size and verify that the activities are split
	secondaryActivity.resetBoundsChangeCounter();
	mReportedDisplayMetrics.setSize(originalDisplaySize);
	assertTrue(secondaryActivity.waitForBoundsChange());
	assertValidSplit(primaryActivity, secondaryActivity, splitPairRule);
	}
	}

	/**
	* Tests that the activity bounds for activities in a split match the LTR layout direction
	* provided in the {@link SplitPairRule}.
	*/
	@Test
	public void testLayoutDirection_LTR() {
	// Create a split pair rule with layout direction LTR and a split ratio that results in
	// uneven bounds between the primary and secondary containers.
	final SplitPairRule splitPairRule = createUnevenWidthSplitPairRule(LayoutDirection.LTR);
	mActivityEmbeddingComponent.setEmbeddingRules(Collections.singleton(splitPairRule));

	// Start activities in a split and verify that the layout direction is LTR, which is
	// checked in {@link ActivityEmbeddingUtil#startActivityAndVerifySplit}.
	Activity primaryActivity = startActivityNewTask(TestConfigChangeHandlingActivity.class);
	startActivityAndVerifySplit(primaryActivity, TestActivityWithId.class, splitPairRule,
	"secondaryActivityId", mSplitInfoConsumer);
	}

	/**
	* Tests that the activity bounds for activities in a split match the RTL layout direction
	* provided in the {@link SplitPairRule}.
	*/
	@Test
	public void testLayoutDirection_RTL() {
	// Create a split pair rule with layout direction RTL and a split ratio that results in
	// uneven bounds between the primary and secondary containers.
	final SplitPairRule splitPairRule = createUnevenWidthSplitPairRule(LayoutDirection.RTL);
	mActivityEmbeddingComponent.setEmbeddingRules(Collections.singleton(splitPairRule));

	// Start activities in a split and verify that the layout direction is RTL, which is
	// checked in {@link ActivityEmbeddingUtil#startActivityAndVerifySplit}.
	Activity primaryActivity = startActivityNewTask(TestConfigChangeHandlingActivity.class);
	startActivityAndVerifySplit(primaryActivity, TestActivityWithId.class, splitPairRule,
	"secondaryActivityId", mSplitInfoConsumer);
	}

	/**
	* Tests that the activity bounds for activities in a split match the Locale layout direction
	* provided in the {@link SplitPairRule}.
	*/
	@Test
	public void testLayoutDirection_Locale() {
	// Create a split pair rule with layout direction LOCALE and a split ratio that results in
	// uneven bounds between the primary and secondary containers.
	final SplitPairRule splitPairRule = createUnevenWidthSplitPairRule(LayoutDirection.LOCALE);
	mActivityEmbeddingComponent.setEmbeddingRules(Collections.singleton(splitPairRule));

	// Start activities in a split and verify that the layout direction is the device locale,
	// which is checked in {@link ActivityEmbeddingUtil#startActivityAndVerifySplit}.
	Activity primaryActivity = startActivityNewTask(TestConfigChangeHandlingActivity.class);
	startActivityAndVerifySplit(primaryActivity, TestActivityWithId.class, splitPairRule,
	"secondaryActivityId", mSplitInfoConsumer);
	}

	/**
	* Tests that when two activities enter a split, then their split ratio matches what is in their
	* {@link SplitPairRule}, and is not assumed to be 0.5 or match the split ratio of the previous
	* top-most activity split.
	*/
	@Test
	public void testSplitRatio() {
	final String activityAId = "activityA";
	final String activityBId = "activityB";
	final String activityCId = "activityC";
	final float activityABSplitRatio = 0.37f;
	final float activityBCSplitRatio = 0.85f;

	// Create a split rule for activity A and activity B where the split ratio is 0.37.
	final SplitPairRule splitPairRuleAB = new SplitPairRule.Builder(
	activityActivityPair -> false /* activityPairPredicate */,
	activityIntentPair -> matchesActivityIntentPair(activityIntentPair, activityAId,
	activityBId) /* activityIntentPredicate */,
	parentWindowMetrics -> true /* parentWindowMetricsPredicate */)
	.setSplitRatio(activityABSplitRatio).build();

	// Create a split rule for activity B and activity C where the split ratio is 0.65.
	final SplitPairRule splitPairRuleBC = new SplitPairRule.Builder(
	activityActivityPair -> false /* activityPairPredicate */,
	activityIntentPair -> matchesActivityIntentPair(activityIntentPair, activityBId,
	activityCId) /* activityIntentPredicate */,
	parentWindowMetrics -> true /* parentWindowMetricsPredicate */)
	.setSplitRatio(activityBCSplitRatio).build();

	// Register the two split pair rules
	mActivityEmbeddingComponent.setEmbeddingRules(Set.of(splitPairRuleAB, splitPairRuleBC));

	// Launch the activity A and B split and verify that the split ratio is 0.37 in
	// {@link ActivityEmbeddingUtil#startActivityAndVerifySplit}.
	Activity activityA = startActivityNewTask(TestActivityWithId.class, activityAId);
	Activity activityB = startActivityAndVerifySplit(activityA, TestActivityWithId.class,
	splitPairRuleAB, activityBId, mSplitInfoConsumer);

	// Launch the activity B and C split and verify that the split ratio is 0.65 in
	// {@link ActivityEmbeddingUtil#startActivityAndVerifySplit}.
	Activity activityC = startActivityAndVerifySplit(activityB, TestActivityWithId.class,
	splitPairRuleBC, activityCId, mSplitInfoConsumer);

	// Finish activity C so that activity A and B are in a split again. Verify that the split
	// ratio returns to 0.37 in {@link ActivityEmbeddingUtil#assertValidSplit}.
	activityC.finish();
	assertValidSplit(activityA, activityB, splitPairRuleAB);
	}

	private SplitPairRule createUnevenWidthSplitPairRule(int layoutDir) {
	return new SplitPairRule.Builder(activityActivityPair -> true /* activityPairPredicate */,
	activityIntentPair -> true /* activityIntentPredicate */,
	parentWindowMetrics -> true /* parentWindowMetricsPredicate */)
	.setSplitRatio(UNEVEN_CONTAINERS_DEFAULT_SPLIT_RATIO)
	.setLayoutDirection(layoutDir).build();
	}

	private boolean matchesActivityIntentPair(@NonNull Pair<Activity, Intent> activityIntentPair,
	@NonNull String primaryActivityId, @NonNull String secondaryActivityId) {
	if (!(activityIntentPair.first instanceof TestActivityWithId)) {
	return false;
	}
	return primaryActivityId.equals(((TestActivityWithId) activityIntentPair.first).getId())
	&& secondaryActivityId.equals(activityIntentPair.second.getStringExtra(
	ACTIVITY_ID_LABEL));
	}
	}