Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Revert "Do not send updates for disabled displays."" into tm-dev

Browse Source
This commit is contained in:
Sam Dubey
2022-06-10 05:51:43 +00:00
committed by Android (Google) Code Review
parent 1ad9256245 d04fae1ba7
commit 54e0824f85
7 changed files with 47 additions and 231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
core/java/android/hardware/display/DisplayManager.java
View File

@@ -559,21 +559,18 @@ public final class DisplayManager {
* @see #DISPLAY_CATEGORY_PRESENTATION
*/
public Display[] getDisplays(String category) {
boolean includeDisabledDisplays = (category != null
&& category.equals(DISPLAY_CATEGORY_ALL_INCLUDING_DISABLED));
final int[] displayIds = mGlobal.getDisplayIds(includeDisabledDisplays);
final int[] displayIds = mGlobal.getDisplayIds();
synchronized (mLock) {
try {
if (category != null && category.equals(DISPLAY_CATEGORY_PRESENTATION)) {
if (category == null
|| DISPLAY_CATEGORY_ALL_INCLUDING_DISABLED.equals(category)) {
addAllDisplaysLocked(mTempDisplays, displayIds);
} else if (category.equals(DISPLAY_CATEGORY_PRESENTATION)) {
addPresentationDisplaysLocked(mTempDisplays, displayIds, Display.TYPE_WIFI);
addPresentationDisplaysLocked(mTempDisplays, displayIds, Display.TYPE_EXTERNAL);
addPresentationDisplaysLocked(mTempDisplays, displayIds, Display.TYPE_OVERLAY);
addPresentationDisplaysLocked(mTempDisplays, displayIds, Display.TYPE_VIRTUAL);
addPresentationDisplaysLocked(mTempDisplays, displayIds, Display.TYPE_INTERNAL);
} else if ((category == null
|| DISPLAY_CATEGORY_ALL_INCLUDING_DISABLED.equals(category))) {
// All displays requested.
addAllDisplaysLocked(mTempDisplays, displayIds);
}
return mTempDisplays.toArray(new Display[mTempDisplays.size()]);
} finally {

13
core/java/android/hardware/display/DisplayManagerGlobal.java
View File

@@ -206,16 +206,6 @@ public final class DisplayManagerGlobal {
*/
@UnsupportedAppUsage
public int[] getDisplayIds() {
return getDisplayIds(/* includeDisabledDisplays= */ false);
}
/**
* Gets all valid logical display ids and invalid ones if specified.
*
* @return An array containing all display ids.
*/
@UnsupportedAppUsage
public int[] getDisplayIds(boolean includeDisabledDisplays) {
try {
synchronized (mLock) {
if (USE_CACHE) {
@@ -224,8 +214,7 @@ public final class DisplayManagerGlobal {
}
}
int[] displayIds =
mDm.getDisplayIds(includeDisabledDisplays);
int[] displayIds = mDm.getDisplayIds();
if (USE_CACHE) {
mDisplayIdCache = displayIds;
}

2
core/java/android/hardware/display/IDisplayManager.aidl
View File

@@ -36,7 +36,7 @@ import android.view.Surface;
interface IDisplayManager {
@UnsupportedAppUsage
DisplayInfo getDisplayInfo(int displayId);
int[] getDisplayIds(boolean includeDisabled);
int[] getDisplayIds();
boolean isUidPresentOnDisplay(int uid, int displayId);

32
services/core/java/com/android/server/display/DisplayManagerService.java
View File

@@ -485,7 +485,7 @@ public final class DisplayManagerService extends SystemService {
mUiHandler = UiThread.getHandler();
mDisplayDeviceRepo = new DisplayDeviceRepository(mSyncRoot, mPersistentDataStore);
mLogicalDisplayMapper = new LogicalDisplayMapper(mContext, mDisplayDeviceRepo,
new LogicalDisplayListener(), mSyncRoot, mHandler, new DeviceStateToLayoutMap());
new LogicalDisplayListener(), mSyncRoot, mHandler);
mDisplayModeDirector = new DisplayModeDirector(context, mHandler);
mBrightnessSynchronizer = new BrightnessSynchronizer(mContext);
Resources resources = mContext.getResources();
@@ -945,8 +945,7 @@ public final class DisplayManagerService extends SystemService {
private DisplayInfo getDisplayInfoInternal(int displayId, int callingUid) {
synchronized (mSyncRoot) {
final LogicalDisplay display = mLogicalDisplayMapper.getDisplayLocked(displayId,
/* includeDisabledDisplays= */ true);
final LogicalDisplay display = mLogicalDisplayMapper.getDisplayLocked(displayId);
if (display != null) {
final DisplayInfo info =
getDisplayInfoForFrameRateOverride(display.getFrameRateOverrides(),
@@ -2129,18 +2128,16 @@ public final class DisplayManagerService extends SystemService {
}
void resetBrightnessConfigurations() {
synchronized (mSyncRoot) {
mPersistentDataStore.setBrightnessConfigurationForUser(null, mContext.getUserId(),
mPersistentDataStore.setBrightnessConfigurationForUser(null, mContext.getUserId(),
mContext.getPackageName());
mLogicalDisplayMapper.forEachLocked((logicalDisplay -> {
if (logicalDisplay.getDisplayInfoLocked().type != Display.TYPE_INTERNAL) {
return;
}
final String uniqueId = logicalDisplay.getPrimaryDisplayDeviceLocked().getUniqueId();
setBrightnessConfigurationForDisplayInternal(null, uniqueId, mContext.getUserId(),
mContext.getPackageName());
mLogicalDisplayMapper.forEachLocked((logicalDisplay -> {
if (logicalDisplay.getDisplayInfoLocked().type != Display.TYPE_INTERNAL) {
return;
}
String uniqueId = logicalDisplay.getPrimaryDisplayDeviceLocked().getUniqueId();
setBrightnessConfigurationForDisplayInternal(null, uniqueId, mContext.getUserId(),
mContext.getPackageName());
}));
}
}));
}
void setAutoBrightnessLoggingEnabled(boolean enabled) {
@@ -2817,16 +2814,15 @@ public final class DisplayManagerService extends SystemService {
}
/**
* Returns the list of all enabled display ids, and disabled ones if specified.
* Returns the list of all display ids.
*/
@Override // Binder call
public int[] getDisplayIds(boolean includeDisabledDisplays) {
public int[] getDisplayIds() {
final int callingUid = Binder.getCallingUid();
final long token = Binder.clearCallingIdentity();
try {
synchronized (mSyncRoot) {
return mLogicalDisplayMapper.getDisplayIdsLocked(callingUid,
includeDisabledDisplays);
return mLogicalDisplayMapper.getDisplayIdsLocked(callingUid);
}
} finally {
Binder.restoreCallingIdentity(token);

120
services/core/java/com/android/server/display/LogicalDisplayMapper.java
View File

@@ -79,12 +79,8 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
private static final int MSG_TRANSITION_TO_PENDING_DEVICE_STATE = 1;
private static final int UPDATE_STATE_NEW = 0;
private static final int UPDATE_STATE_UPDATED = 1;
private static final int UPDATE_STATE_DISABLED = 2;
private static final int UPDATE_STATE_MASK = 0x3;
private static final int UPDATE_STATE_FLAG_TRANSITION = 0x100;
private static final int UPDATE_STATE_TRANSITION = 1;
private static final int UPDATE_STATE_UPDATED = 2;
/**
* Temporary display info, used for comparing display configurations.
@@ -170,7 +166,7 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
LogicalDisplayMapper(@NonNull Context context, @NonNull DisplayDeviceRepository repo,
@NonNull Listener listener, @NonNull DisplayManagerService.SyncRoot syncRoot,
@NonNull Handler handler, @NonNull DeviceStateToLayoutMap deviceStateToLayoutMap) {
@NonNull Handler handler) {
mSyncRoot = syncRoot;
mPowerManager = context.getSystemService(PowerManager.class);
mInteractive = mPowerManager.isInteractive();
@@ -185,7 +181,7 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
mDeviceStatesOnWhichToSleep = toSparseBooleanArray(context.getResources().getIntArray(
com.android.internal.R.array.config_deviceStatesOnWhichToSleep));
mDisplayDeviceRepo.addListener(this);
mDeviceStateToLayoutMap = deviceStateToLayoutMap;
mDeviceStateToLayoutMap = new DeviceStateToLayoutMap();
}
@Override
@@ -222,29 +218,10 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
}
public LogicalDisplay getDisplayLocked(int displayId) {
return getDisplayLocked(displayId, /* includeDisabled= */ false);
}
LogicalDisplay getDisplayLocked(int displayId, boolean includeDisabled) {
LogicalDisplay display = mLogicalDisplays.get(displayId);
if (display != null && (display.isEnabled() || includeDisabled)) {
return display;
}
return null;
return mLogicalDisplays.get(displayId);
}
public LogicalDisplay getDisplayLocked(DisplayDevice device) {
return getDisplayLocked(device, /* includeDisabled= */ false);
}
/**
* Loops through the existing list of displays and returns one that is associated with the
* specified display device.
*
* @param device The display device that should be associated with the LogicalDisplay.
* @param includeDisabled True if this method should return disabled displays as well.
*/
private LogicalDisplay getDisplayLocked(DisplayDevice device, boolean includeDisabled) {
if (device == null) {
return null;
}
@@ -252,32 +229,18 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
for (int i = 0; i < count; i++) {
final LogicalDisplay display = mLogicalDisplays.valueAt(i);
if (display.getPrimaryDisplayDeviceLocked() == device) {
if (display.isEnabled() || includeDisabled) {
return display;
} else {
return null;
}
return display;
}
}
return null;
}
// Returns display Ids, defaults to enabled only.
public int[] getDisplayIdsLocked(int callingUid) {
return getDisplayIdsLocked(callingUid, /* includeDisabledDisplays= */ false);
}
// Returns display Ids, specified whether enabled only, or all displays.
public int[] getDisplayIdsLocked(int callingUid, boolean includeDisabledDisplays) {
final int count = mLogicalDisplays.size();
int[] displayIds = new int[count];
int n = 0;
for (int i = 0; i < count; i++) {
LogicalDisplay display = mLogicalDisplays.valueAt(i);
if (!includeDisabledDisplays && !display.isEnabled()) {
continue; // Ignore disabled displays.
}
DisplayInfo info = display.getDisplayInfoLocked();
if (info.hasAccess(callingUid)) {
displayIds[n++] = mLogicalDisplays.keyAt(i);
@@ -292,10 +255,7 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
public void forEachLocked(Consumer<LogicalDisplay> consumer) {
final int count = mLogicalDisplays.size();
for (int i = 0; i < count; i++) {
LogicalDisplay display = mLogicalDisplays.valueAt(i);
if (display.isEnabled()) {
consumer.accept(display);
}
consumer.accept(mLogicalDisplays.valueAt(i));
}
}
@@ -356,8 +316,7 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
// Find or create the LogicalDisplay to map the DisplayDevice to.
final int logicalDisplayId = displayLayout.getLogicalDisplayId();
final LogicalDisplay logicalDisplay =
getDisplayLocked(logicalDisplayId, /* includeDisabled= */ true);
final LogicalDisplay logicalDisplay = getDisplayLocked(logicalDisplayId);
if (logicalDisplay == null) {
Slog.w(TAG, "The logical display (" + address + "), is not available"
+ " for the display state " + deviceState);
@@ -493,7 +452,7 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
}
/**
* Returns true if the device should be put to sleep or not.
* Returns if the device should be put to sleep or not.
*
* Includes a check to verify that the device state that we are moving to, {@code pendingState},
* is the same as the physical state of the device, {@code baseState}. Different values for
@@ -639,12 +598,9 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
display.getNonOverrideDisplayInfoLocked(mTempNonOverrideDisplayInfo);
display.updateLocked(mDisplayDeviceRepo);
DisplayInfo newDisplayInfo = display.getDisplayInfoLocked();
final int storedState = mUpdatedLogicalDisplays.get(displayId, UPDATE_STATE_NEW);
final int updateState = storedState & UPDATE_STATE_MASK;
final boolean isTransitioning = (storedState & UPDATE_STATE_FLAG_TRANSITION) != 0;
final boolean wasPreviouslyUpdated = updateState == UPDATE_STATE_UPDATED;
final DisplayInfo newDisplayInfo = display.getDisplayInfoLocked();
final int updateState = mUpdatedLogicalDisplays.get(displayId, UPDATE_STATE_NEW);
final boolean wasPreviouslyUpdated = updateState != UPDATE_STATE_NEW;
// The display is no longer valid and needs to be removed.
if (!display.isValidLocked()) {
@@ -668,35 +624,6 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
}
continue;
// The display has been newly disabled, we report this as a removed display but
// don't actually remove it from our internal list in LogicalDisplayMapper. The reason
// is that LogicalDisplayMapper assumes and relies on the fact that every DisplayDevice
// has a LogicalDisplay wrapper, but certain displays that are unusable (like the inner
// display on a folded foldable device) are not available for use by the system and
// we keep them hidden. To do this, we mark those LogicalDisplays as "disabled".
// Also, if the display is in TRANSITION but was previously reported as disabled
// then keep it unreported.
} else if (!display.isEnabled()
|| (display.getPhase() == LogicalDisplay.DISPLAY_PHASE_LAYOUT_TRANSITION
&& updateState == UPDATE_STATE_DISABLED)) {
mUpdatedLogicalDisplays.put(displayId, UPDATE_STATE_DISABLED);
// If we never told anyone about this display, nothing to do
if (!wasPreviouslyUpdated) {
continue;
}
// Remove from group
final DisplayGroup displayGroup = getDisplayGroupLocked(
getDisplayGroupIdFromDisplayIdLocked(displayId));
if (displayGroup != null) {
displayGroup.removeDisplayLocked(display);
}
Slog.i(TAG, "Removing (disabled) display: " + displayId);
mLogicalDisplaysToUpdate.put(displayId, LOGICAL_DISPLAY_EVENT_REMOVED);
continue;
// The display is new.
} else if (!wasPreviouslyUpdated) {
Slog.i(TAG, "Adding new display: " + displayId + ": " + newDisplayInfo);
@@ -716,7 +643,7 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
mLogicalDisplaysToUpdate.put(displayId, LOGICAL_DISPLAY_EVENT_CHANGED);
// The display is involved in a display layout transition
} else if (isTransitioning) {
} else if (updateState == UPDATE_STATE_TRANSITION) {
mLogicalDisplaysToUpdate.put(displayId,
LOGICAL_DISPLAY_EVENT_DEVICE_STATE_TRANSITION);
@@ -790,7 +717,7 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
}
final int id = mLogicalDisplaysToUpdate.keyAt(i);
final LogicalDisplay display = getDisplayLocked(id, /* includeDisabled= */ true);
final LogicalDisplay display = getDisplayLocked(id);
if (DEBUG) {
final DisplayDevice device = display.getPrimaryDisplayDeviceLocked();
final String uniqueId = device == null ? "null" : device.getUniqueId();
@@ -798,7 +725,7 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
+ " with device=" + uniqueId);
}
mListener.onLogicalDisplayEventLocked(display, msg);
if (msg == LOGICAL_DISPLAY_EVENT_REMOVED && !display.isValidLocked()) {
if (msg == LOGICAL_DISPLAY_EVENT_REMOVED) {
// We wait until we sent the EVENT_REMOVED event before actually removing the
// display.
mLogicalDisplays.delete(id);
@@ -918,8 +845,7 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
if (isTransitioning) {
setDisplayPhase(logicalDisplay, phase);
if (phase == LogicalDisplay.DISPLAY_PHASE_LAYOUT_TRANSITION) {
int oldState = mUpdatedLogicalDisplays.get(displayId, UPDATE_STATE_NEW);
mUpdatedLogicalDisplays.put(displayId, oldState | UPDATE_STATE_FLAG_TRANSITION);
mUpdatedLogicalDisplays.put(displayId, UPDATE_STATE_TRANSITION);
}
}
}
@@ -953,15 +879,14 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
// Now that we have a display-device, we need a LogicalDisplay to map it to. Find the
// right one, if it doesn't exist, create a new one.
final int logicalDisplayId = displayLayout.getLogicalDisplayId();
LogicalDisplay newDisplay =
getDisplayLocked(logicalDisplayId, /* includeDisabled= */ true);
LogicalDisplay newDisplay = getDisplayLocked(logicalDisplayId);
if (newDisplay == null) {
newDisplay = createNewLogicalDisplayLocked(
/* displayDevice= */ null, logicalDisplayId);
null /*displayDevice*/, logicalDisplayId);
}
// Now swap the underlying display devices between the old display and the new display
final LogicalDisplay oldDisplay = getDisplayLocked(device, /* includeDisabled= */ true);
final LogicalDisplay oldDisplay = getDisplayLocked(device);
if (newDisplay != oldDisplay) {
newDisplay.swapDisplaysLocked(oldDisplay);
}
@@ -978,14 +903,13 @@ class LogicalDisplayMapper implements DisplayDeviceRepository.Listener {
* Creates a new logical display for the specified device and display Id and adds it to the list
* of logical displays.
*
* @param displayDevice The displayDevice to associate with the LogicalDisplay.
* @param device The device to associate with the LogicalDisplay.
* @param displayId The display ID to give the new display. If invalid, a new ID is assigned.
* @return The new logical display if created, null otherwise.
*/
private LogicalDisplay createNewLogicalDisplayLocked(DisplayDevice displayDevice,
int displayId) {
private LogicalDisplay createNewLogicalDisplayLocked(DisplayDevice device, int displayId) {
final int layerStack = assignLayerStackLocked(displayId);
final LogicalDisplay display = new LogicalDisplay(displayId, layerStack, displayDevice);
final LogicalDisplay display = new LogicalDisplay(displayId, layerStack, device);
display.updateLocked(mDisplayDeviceRepo);
mLogicalDisplays.put(displayId, display);
setDisplayPhase(display, LogicalDisplay.DISPLAY_PHASE_ENABLED);

9
services/tests/servicestests/src/com/android/server/display/DisplayManagerServiceTest.java
View File

@@ -287,7 +287,7 @@ public class DisplayManagerServiceTest {
when(mMockAppToken.asBinder()).thenReturn(mMockAppToken);
final int[] displayIds = bs.getDisplayIds(/* includeDisabled= */ false);
final int displayIds[] = bs.getDisplayIds();
final int size = displayIds.length;
assertTrue(size > 0);
@@ -297,9 +297,7 @@ public class DisplayManagerServiceTest {
);
for (int i = 0; i < size; i++) {
DisplayInfo info = bs.getDisplayInfo(displayIds[i]);
if (info != null) {
assertTrue(expectedDisplayTypeToViewPortTypeMapping.keySet().contains(info.type));
}
assertTrue(expectedDisplayTypeToViewPortTypeMapping.keySet().contains(info.type));
}
displayManager.performTraversalInternal(mock(SurfaceControl.Transaction.class));
@@ -1176,8 +1174,7 @@ public class DisplayManagerServiceTest {
DisplayManagerService.BinderService displayManagerBinderService,
FakeDisplayDevice displayDevice) {
final int[] displayIds = displayManagerBinderService.getDisplayIds(
/* includeDisabled= */ false);
final int[] displayIds = displayManagerBinderService.getDisplayIds();
assertTrue(displayIds.length > 0);
int displayId = Display.INVALID_DISPLAY;
for (int i = 0; i < displayIds.length; i++) {

89
services/tests/servicestests/src/com/android/server/display/LogicalDisplayMapperTest.java
View File

@@ -33,7 +33,6 @@ import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.clearInvocations;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -54,8 +53,6 @@ import android.view.DisplayInfo;
import androidx.test.filters.SmallTest;
import androidx.test.runner.AndroidJUnit4;
import com.android.server.display.layout.Layout;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -82,7 +79,6 @@ public class LogicalDisplayMapperTest {
private TestLooper mLooper;
private Handler mHandler;
private PowerManager mPowerManager;
private DeviceStateToLayoutMap mDeviceStateToLayoutMapSpy;
@Mock LogicalDisplayMapper.Listener mListenerMock;
@Mock Context mContextMock;
@@ -137,11 +133,8 @@ public class LogicalDisplayMapperTest {
mLooper = new TestLooper();
mHandler = new Handler(mLooper.getLooper());
mDeviceStateToLayoutMapSpy = spy(new DeviceStateToLayoutMap());
mLogicalDisplayMapper = new LogicalDisplayMapper(mContextMock, mDisplayDeviceRepo,
mListenerMock, new DisplayManagerService.SyncRoot(), mHandler,
mDeviceStateToLayoutMapSpy);
mListenerMock, new DisplayManagerService.SyncRoot(), mHandler);
}
@@ -420,86 +413,6 @@ public class LogicalDisplayMapperTest {
/* isBootCompleted= */true));
}
@Test public void testEnabledAndDisabledDisplays() {
DisplayAddress displayAddressOne = new TestUtils.TestDisplayAddress();
DisplayAddress displayAddressTwo = new TestUtils.TestDisplayAddress();
DisplayAddress displayAddressThree = new TestUtils.TestDisplayAddress();
TestDisplayDevice device1 = createDisplayDevice(displayAddressOne, Display.TYPE_INTERNAL,
600, 800,
DisplayDeviceInfo.FLAG_ALLOWED_TO_BE_DEFAULT_DISPLAY);
TestDisplayDevice device2 = createDisplayDevice(displayAddressTwo, Display.TYPE_INTERNAL,
200, 800,
DisplayDeviceInfo.FLAG_OWN_DISPLAY_GROUP);
TestDisplayDevice device3 = createDisplayDevice(displayAddressThree, Display.TYPE_INTERNAL,
600, 900, DisplayDeviceInfo.FLAG_OWN_DISPLAY_GROUP);
Layout threeDevicesEnabledLayout = new Layout();
threeDevicesEnabledLayout.createDisplayLocked(
displayAddressOne,
/* isDefault= */ true,
/* isEnabled= */ true);
threeDevicesEnabledLayout.createDisplayLocked(
displayAddressTwo,
/* isDefault= */ false,
/* isEnabled= */ true);
threeDevicesEnabledLayout.createDisplayLocked(
displayAddressThree,
/* isDefault= */ false,
/* isEnabled= */ true);
when(mDeviceStateToLayoutMapSpy.get(DeviceStateToLayoutMap.STATE_DEFAULT))
.thenReturn(threeDevicesEnabledLayout);
LogicalDisplay display1 = add(device1);
LogicalDisplay display2 = add(device2);
LogicalDisplay display3 = add(device3);
// ensure 3 displays are returned
int [] ids = mLogicalDisplayMapper.getDisplayIdsLocked(Process.SYSTEM_UID);
assertEquals(3, ids.length);
Arrays.sort(ids);
assertEquals(DEFAULT_DISPLAY, ids[0]);
Layout oneDeviceEnabledLayout = new Layout();
oneDeviceEnabledLayout.createDisplayLocked(
display1.getDisplayInfoLocked().address,
/* isDefault= */ true,
/* isEnabled= */ true);
oneDeviceEnabledLayout.createDisplayLocked(
display2.getDisplayInfoLocked().address,
/* isDefault= */ false,
/* isEnabled= */ false);
oneDeviceEnabledLayout.createDisplayLocked(
display3.getDisplayInfoLocked().address,
/* isDefault= */ false,
/* isEnabled= */ false);
when(mDeviceStateToLayoutMapSpy.get(0)).thenReturn(oneDeviceEnabledLayout);
when(mDeviceStateToLayoutMapSpy.get(1)).thenReturn(threeDevicesEnabledLayout);
mLogicalDisplayMapper
.setDeviceStateLocked(0, false);
mDisplayDeviceRepo.onDisplayDeviceEvent(device3, DISPLAY_DEVICE_EVENT_CHANGED);
final int[] allDisplayIds = mLogicalDisplayMapper.getDisplayIdsLocked(
Process.SYSTEM_UID, false);
mLooper.dispatchAll();
// ensure only one display is returned
assertEquals(1, allDisplayIds.length);
mLogicalDisplayMapper
.setDeviceStateLocked(1, false);
mDisplayDeviceRepo.onDisplayDeviceEvent(device3, DISPLAY_DEVICE_EVENT_CHANGED);
final int[] threeDisplaysEnabled = mLogicalDisplayMapper.getDisplayIdsLocked(
Process.SYSTEM_UID, false);
mLooper.dispatchAll();
// ensure all three displays are returned
assertEquals(3, threeDisplaysEnabled.length);
}
/////////////////
// Helper Methods
/////////////////