services/tests/wmtests/src/com/android/server/wm/TestDisplayContent.java - platform/frameworks/base - Git at Google

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

 import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
 import static android.view.DisplayAdjustments.DEFAULT_DISPLAY_ADJUSTMENTS;
 import static android.view.WindowManagerPolicyConstants.NAV_BAR_BOTTOM;

 import static com.android.dx.mockito.inline.extended.ExtendedMockito.any;
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.anyBoolean;
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.anyInt;
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.doAnswer;
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.doNothing;
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.doReturn;
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn;

 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.Mockito.doReturn;

 import android.annotation.Nullable;
 import android.content.Context;
 import android.content.res.Configuration;
 import android.content.res.Resources;
 import android.graphics.Insets;
 import android.graphics.Rect;
 import android.hardware.display.DisplayManagerGlobal;
 import android.util.DisplayMetrics;
 import android.view.Display;
 import android.view.DisplayCutout;
 import android.view.DisplayInfo;

 import com.android.server.wm.DisplayWindowSettings.SettingsProvider.SettingsEntry;

 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;

 class TestDisplayContent extends DisplayContent {

     public static final int DEFAULT_LOGICAL_DISPLAY_DENSITY = 300;

     /** Please use the {@link Builder} to create, visible for use in test builder overrides only. */
     TestDisplayContent(RootWindowContainer rootWindowContainer, Display display) {
         super(display, rootWindowContainer);
         // Normally this comes from display-properties as exposed by WM. Without that, just
         // hard-code to FULLSCREEN for tests.
         setWindowingMode(WINDOWING_MODE_FULLSCREEN);
         spyOn(this);
         forAllTaskDisplayAreas(taskDisplayArea -> {
             spyOn(taskDisplayArea);
         });
         final DisplayRotation displayRotation = getDisplayRotation();
         spyOn(displayRotation);
         doAnswer(invocation -> {
             // Bypass all the rotation animation and display freezing stuff for testing and just
             // set the rotation we want for the display
             final int oldRotation = displayRotation.getRotation();
             final int rotation = displayRotation.rotationForOrientation(
                     displayRotation.getLastOrientation(), oldRotation);
             if (oldRotation == rotation) {
                 return false;
             }
             setLayoutNeeded();
             displayRotation.setRotation(rotation);
             return true;
         }).when(displayRotation).updateRotationUnchecked(anyBoolean());

         final InputMonitor inputMonitor = getInputMonitor();
         spyOn(inputMonitor);
         doNothing().when(inputMonitor).resumeDispatchingLw(any());
     }

     public static class Builder {
         private final DisplayInfo mInfo;
         private boolean mCanRotate = true;
         private int mWindowingMode = WINDOWING_MODE_FULLSCREEN;
         private int mPosition = POSITION_BOTTOM;
         protected final ActivityTaskManagerService mService;
         private boolean mSystemDecorations = false;
         private int mStatusBarHeight = 0;
         private SettingsEntry mOverrideSettings;
         private DisplayMetrics mDisplayMetrics;
         @Mock
         Context mMockContext;
         @Mock
         Resources mResources;

         Builder(ActivityTaskManagerService service, int width, int height) {
             mService = service;
             mInfo = new DisplayInfo();
             mService.mContext.getDisplay().getDisplayInfo(mInfo);
             mInfo.logicalWidth = width;
             mInfo.logicalHeight = height;
             mInfo.logicalDensityDpi = DEFAULT_LOGICAL_DISPLAY_DENSITY;
             mInfo.displayCutout = null;
             // Set unique ID so physical display overrides are not inheritted from
             // DisplayWindowSettings.
             mInfo.uniqueId = generateUniqueId();
             mDisplayMetrics = new DisplayMetrics();
             updateDisplayMetrics();
         }
         Builder(ActivityTaskManagerService service, DisplayInfo info) {
             mService = service;
             mInfo = info;
             // Set unique ID so physical display overrides are not inheritted from
             // DisplayWindowSettings.
             mInfo.uniqueId = generateUniqueId();
         }
         private String generateUniqueId() {
             return "TEST_DISPLAY_CONTENT_" + System.currentTimeMillis();
         }
         Builder setOverrideSettings(@Nullable SettingsEntry overrideSettings) {
             mOverrideSettings = overrideSettings;
             return this;
         }
         Builder setSystemDecorations(boolean yes) {
             mSystemDecorations = yes;
             return this;
         }
         Builder setPosition(int position) {
             mPosition = position;
             return this;
         }
         Builder setUniqueId(String uniqueId) {
             mInfo.uniqueId = uniqueId;
             return this;
         }
         Builder setType(int type) {
             mInfo.type = type;
             return this;
         }
         Builder setOwnerUid(int ownerUid) {
             mInfo.ownerUid = ownerUid;
             return this;
         }
         Builder setNotch(int height) {
             mInfo.displayCutout = new DisplayCutout(
                     Insets.of(0, height, 0, 0), null, new Rect(20, 0, 80, height), null, null);
             return this;
         }
         Builder setStatusBarHeight(int height) {
             mStatusBarHeight = height;
             return this;
         }
         Builder setCanRotate(boolean canRotate) {
             mCanRotate = canRotate;
             return this;
         }
         Builder setWindowingMode(int windowingMode) {
             mWindowingMode = windowingMode;
             return this;
         }
         Builder setDensityDpi(int dpi) {
             mInfo.logicalDensityDpi = dpi;
             return this;
         }
         Builder updateDisplayMetrics() {
             mInfo.getAppMetrics(mDisplayMetrics);
             return this;
         }
         Builder setDefaultMinTaskSizeDp(int valueDp) {
             MockitoAnnotations.initMocks(this);
             doReturn(mMockContext).when(mService.mContext).createConfigurationContext(any());
             doReturn(mResources).when(mMockContext).getResources();
             doReturn(valueDp * mDisplayMetrics.density)
                     .when(mResources)
                     .getDimension(
                         com.android.internal.R.dimen.default_minimal_size_resizable_task);
             return this;
         }
         TestDisplayContent createInternal(Display display) {
             return new TestDisplayContent(mService.mRootWindowContainer, display);
         }
         TestDisplayContent build() {
             SystemServicesTestRule.checkHoldsLock(mService.mGlobalLock);

             if (mOverrideSettings != null) {
                 mService.mWindowManager.mDisplayWindowSettingsProvider
                         .updateOverrideSettings(mInfo, mOverrideSettings);
             }

             final int displayId = SystemServicesTestRule.sNextDisplayId++;
             final Display display = new Display(DisplayManagerGlobal.getInstance(), displayId,
                     mInfo, DEFAULT_DISPLAY_ADJUSTMENTS);
             final TestDisplayContent newDisplay = createInternal(display);
             // disable the normal system decorations
             final DisplayPolicy displayPolicy = newDisplay.getDisplayPolicy();
             spyOn(displayPolicy);
             if (mSystemDecorations) {
                 doReturn(true).when(newDisplay).supportsSystemDecorations();
                 doReturn(true).when(displayPolicy).hasNavigationBar();
                 doReturn(NAV_BAR_BOTTOM).when(displayPolicy).navigationBarPosition(anyInt());
                 doReturn(20).when(displayPolicy).getNavigationBarHeight(anyInt());
             } else {
                 doReturn(false).when(displayPolicy).hasNavigationBar();
                 doReturn(false).when(displayPolicy).hasStatusBar();
                 doReturn(false).when(newDisplay).supportsSystemDecorations();
             }
             // Update the display policy to make the screen fully turned on so animation is allowed
             displayPolicy.screenTurnedOn(null /* screenOnListener */);
             displayPolicy.finishKeyguardDrawn();
             displayPolicy.finishWindowsDrawn();
             displayPolicy.finishScreenTurningOn();
             if (mStatusBarHeight > 0) {
                 doReturn(true).when(displayPolicy).hasStatusBar();
                 doAnswer(invocation -> {
                     Rect inOutInsets = (Rect) invocation.getArgument(0);
                     inOutInsets.top = mStatusBarHeight;
                     return null;
                 }).when(displayPolicy).convertNonDecorInsetsToStableInsets(any(), anyInt());
             }
             Configuration c = new Configuration();
             newDisplay.computeScreenConfiguration(c);
             c.windowConfiguration.setWindowingMode(mWindowingMode);
             newDisplay.onRequestedOverrideConfigurationChanged(c);
             if (!mCanRotate) {
                 final DisplayRotation displayRotation = newDisplay.getDisplayRotation();
                 doReturn(true).when(displayRotation).isFixedToUserRotation();
             }
             // Please add stubbing before this line. Services will start using this display in other
             // threads immediately after adding it to hierarchy. Calling doAnswer() type of stubbing
             // reduces chance of races, but still doesn't eliminate race conditions.
             mService.mRootWindowContainer.addChild(newDisplay, mPosition);

             // Set the default focused TDA.
             newDisplay.onLastFocusedTaskDisplayAreaChanged(newDisplay.getDefaultTaskDisplayArea());

             return newDisplay;
         }
     }
 }
	/*
	* Copyright (C) 2019 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.server.wm;

	import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
	import static android.view.DisplayAdjustments.DEFAULT_DISPLAY_ADJUSTMENTS;
	import static android.view.WindowManagerPolicyConstants.NAV_BAR_BOTTOM;

	import static com.android.dx.mockito.inline.extended.ExtendedMockito.any;
	import static com.android.dx.mockito.inline.extended.ExtendedMockito.anyBoolean;
	import static com.android.dx.mockito.inline.extended.ExtendedMockito.anyInt;
	import static com.android.dx.mockito.inline.extended.ExtendedMockito.doAnswer;
	import static com.android.dx.mockito.inline.extended.ExtendedMockito.doNothing;
	import static com.android.dx.mockito.inline.extended.ExtendedMockito.doReturn;
	import static com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn;

	import static org.mockito.ArgumentMatchers.any;
	import static org.mockito.ArgumentMatchers.anyInt;
	import static org.mockito.Mockito.doReturn;

	import android.annotation.Nullable;
	import android.content.Context;
	import android.content.res.Configuration;
	import android.content.res.Resources;
	import android.graphics.Insets;
	import android.graphics.Rect;
	import android.hardware.display.DisplayManagerGlobal;
	import android.util.DisplayMetrics;
	import android.view.Display;
	import android.view.DisplayCutout;
	import android.view.DisplayInfo;

	import com.android.server.wm.DisplayWindowSettings.SettingsProvider.SettingsEntry;

	import org.mockito.Mock;
	import org.mockito.MockitoAnnotations;

	class TestDisplayContent extends DisplayContent {

	public static final int DEFAULT_LOGICAL_DISPLAY_DENSITY = 300;

	/** Please use the {@link Builder} to create, visible for use in test builder overrides only. */
	TestDisplayContent(RootWindowContainer rootWindowContainer, Display display) {
	super(display, rootWindowContainer);
	// Normally this comes from display-properties as exposed by WM. Without that, just
	// hard-code to FULLSCREEN for tests.
	setWindowingMode(WINDOWING_MODE_FULLSCREEN);
	spyOn(this);
	forAllTaskDisplayAreas(taskDisplayArea -> {
	spyOn(taskDisplayArea);
	});
	final DisplayRotation displayRotation = getDisplayRotation();
	spyOn(displayRotation);
	doAnswer(invocation -> {
	// Bypass all the rotation animation and display freezing stuff for testing and just
	// set the rotation we want for the display
	final int oldRotation = displayRotation.getRotation();
	final int rotation = displayRotation.rotationForOrientation(
	displayRotation.getLastOrientation(), oldRotation);
	if (oldRotation == rotation) {
	return false;
	}
	setLayoutNeeded();
	displayRotation.setRotation(rotation);
	return true;
	}).when(displayRotation).updateRotationUnchecked(anyBoolean());

	final InputMonitor inputMonitor = getInputMonitor();
	spyOn(inputMonitor);
	doNothing().when(inputMonitor).resumeDispatchingLw(any());
	}

	public static class Builder {
	private final DisplayInfo mInfo;
	private boolean mCanRotate = true;
	private int mWindowingMode = WINDOWING_MODE_FULLSCREEN;
	private int mPosition = POSITION_BOTTOM;
	protected final ActivityTaskManagerService mService;
	private boolean mSystemDecorations = false;
	private int mStatusBarHeight = 0;
	private SettingsEntry mOverrideSettings;
	private DisplayMetrics mDisplayMetrics;
	@Mock
	Context mMockContext;
	@Mock
	Resources mResources;

	Builder(ActivityTaskManagerService service, int width, int height) {
	mService = service;
	mInfo = new DisplayInfo();
	mService.mContext.getDisplay().getDisplayInfo(mInfo);
	mInfo.logicalWidth = width;
	mInfo.logicalHeight = height;
	mInfo.logicalDensityDpi = DEFAULT_LOGICAL_DISPLAY_DENSITY;
	mInfo.displayCutout = null;
	// Set unique ID so physical display overrides are not inheritted from
	// DisplayWindowSettings.
	mInfo.uniqueId = generateUniqueId();
	mDisplayMetrics = new DisplayMetrics();
	updateDisplayMetrics();
	}
	Builder(ActivityTaskManagerService service, DisplayInfo info) {
	mService = service;
	mInfo = info;
	// Set unique ID so physical display overrides are not inheritted from
	// DisplayWindowSettings.
	mInfo.uniqueId = generateUniqueId();
	}
	private String generateUniqueId() {
	return "TEST_DISPLAY_CONTENT_" + System.currentTimeMillis();
	}
	Builder setOverrideSettings(@Nullable SettingsEntry overrideSettings) {
	mOverrideSettings = overrideSettings;
	return this;
	}
	Builder setSystemDecorations(boolean yes) {
	mSystemDecorations = yes;
	return this;
	}
	Builder setPosition(int position) {
	mPosition = position;
	return this;
	}
	Builder setUniqueId(String uniqueId) {
	mInfo.uniqueId = uniqueId;
	return this;
	}
	Builder setType(int type) {
	mInfo.type = type;
	return this;
	}
	Builder setOwnerUid(int ownerUid) {
	mInfo.ownerUid = ownerUid;
	return this;
	}
	Builder setNotch(int height) {
	mInfo.displayCutout = new DisplayCutout(
	Insets.of(0, height, 0, 0), null, new Rect(20, 0, 80, height), null, null);
	return this;
	}
	Builder setStatusBarHeight(int height) {
	mStatusBarHeight = height;
	return this;
	}
	Builder setCanRotate(boolean canRotate) {
	mCanRotate = canRotate;
	return this;
	}
	Builder setWindowingMode(int windowingMode) {
	mWindowingMode = windowingMode;
	return this;
	}
	Builder setDensityDpi(int dpi) {
	mInfo.logicalDensityDpi = dpi;
	return this;
	}
	Builder updateDisplayMetrics() {
	mInfo.getAppMetrics(mDisplayMetrics);
	return this;
	}
	Builder setDefaultMinTaskSizeDp(int valueDp) {
	MockitoAnnotations.initMocks(this);
	doReturn(mMockContext).when(mService.mContext).createConfigurationContext(any());
	doReturn(mResources).when(mMockContext).getResources();
	doReturn(valueDp * mDisplayMetrics.density)
	.when(mResources)
	.getDimension(
	com.android.internal.R.dimen.default_minimal_size_resizable_task);
	return this;
	}
	TestDisplayContent createInternal(Display display) {
	return new TestDisplayContent(mService.mRootWindowContainer, display);
	}
	TestDisplayContent build() {
	SystemServicesTestRule.checkHoldsLock(mService.mGlobalLock);

	if (mOverrideSettings != null) {
	mService.mWindowManager.mDisplayWindowSettingsProvider
	.updateOverrideSettings(mInfo, mOverrideSettings);
	}

	final int displayId = SystemServicesTestRule.sNextDisplayId++;
	final Display display = new Display(DisplayManagerGlobal.getInstance(), displayId,
	mInfo, DEFAULT_DISPLAY_ADJUSTMENTS);
	final TestDisplayContent newDisplay = createInternal(display);
	// disable the normal system decorations
	final DisplayPolicy displayPolicy = newDisplay.getDisplayPolicy();
	spyOn(displayPolicy);
	if (mSystemDecorations) {
	doReturn(true).when(newDisplay).supportsSystemDecorations();
	doReturn(true).when(displayPolicy).hasNavigationBar();
	doReturn(NAV_BAR_BOTTOM).when(displayPolicy).navigationBarPosition(anyInt());
	doReturn(20).when(displayPolicy).getNavigationBarHeight(anyInt());
	} else {
	doReturn(false).when(displayPolicy).hasNavigationBar();
	doReturn(false).when(displayPolicy).hasStatusBar();
	doReturn(false).when(newDisplay).supportsSystemDecorations();
	}
	// Update the display policy to make the screen fully turned on so animation is allowed
	displayPolicy.screenTurnedOn(null /* screenOnListener */);
	displayPolicy.finishKeyguardDrawn();
	displayPolicy.finishWindowsDrawn();
	displayPolicy.finishScreenTurningOn();
	if (mStatusBarHeight > 0) {
	doReturn(true).when(displayPolicy).hasStatusBar();
	doAnswer(invocation -> {
	Rect inOutInsets = (Rect) invocation.getArgument(0);
	inOutInsets.top = mStatusBarHeight;
	return null;
	}).when(displayPolicy).convertNonDecorInsetsToStableInsets(any(), anyInt());
	}
	Configuration c = new Configuration();
	newDisplay.computeScreenConfiguration(c);
	c.windowConfiguration.setWindowingMode(mWindowingMode);
	newDisplay.onRequestedOverrideConfigurationChanged(c);
	if (!mCanRotate) {
	final DisplayRotation displayRotation = newDisplay.getDisplayRotation();
	doReturn(true).when(displayRotation).isFixedToUserRotation();
	}
	// Please add stubbing before this line. Services will start using this display in other
	// threads immediately after adding it to hierarchy. Calling doAnswer() type of stubbing
	// reduces chance of races, but still doesn't eliminate race conditions.
	mService.mRootWindowContainer.addChild(newDisplay, mPosition);

	// Set the default focused TDA.
	newDisplay.onLastFocusedTaskDisplayAreaChanged(newDisplay.getDefaultTaskDisplayArea());

	return newDisplay;
	}
	}
	}