Merge "DisplayViewport should only have actual viewports (2/2)" (7f8c5ac3) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/display/DisplayManagerService.java

+30 −58

Original line number	Original line	Diff line number	Diff line
	@@ -1296,58 +1296,21 @@ public final class DisplayManagerService extends SystemService {
	return;		return;
	}		}
	display.configureDisplayLocked(t, device, info.state == Display.STATE_OFF);		display.configureDisplayLocked(t, device, info.state == Display.STATE_OFF);
			final int viewportType;
	// Update the corresponding viewport.		// Update the corresponding viewport.
	DisplayViewport internalViewport = getInternalViewportLocked();
	if ((info.flags & DisplayDeviceInfo.FLAG_DEFAULT_DISPLAY) != 0) {		if ((info.flags & DisplayDeviceInfo.FLAG_DEFAULT_DISPLAY) != 0) {
	populateViewportLocked(internalViewport, display, device);		viewportType = VIEWPORT_INTERNAL;
	}		} else if (info.touch == DisplayDeviceInfo.TOUCH_EXTERNAL) {
	DisplayViewport externalViewport = getExternalViewportLocked();		viewportType = VIEWPORT_EXTERNAL;
	if (info.touch == DisplayDeviceInfo.TOUCH_EXTERNAL) {		} else if (info.touch == DisplayDeviceInfo.TOUCH_VIRTUAL
	populateViewportLocked(externalViewport, display, device);		&& !TextUtils.isEmpty(info.uniqueId)) {
	} else if (!externalViewport.valid) {		viewportType = VIEWPORT_VIRTUAL;
	// TODO (b/116850516) move this logic into InputReader		} else {
	externalViewport.copyFrom(internalViewport);		Slog.wtf(TAG, "Unable to populate viewport for display device: " + info);
	externalViewport.type = DisplayViewport.VIEWPORT_EXTERNAL;		return;
	}

	if (info.touch == DisplayDeviceInfo.TOUCH_VIRTUAL && !TextUtils.isEmpty(info.uniqueId)) {
	final DisplayViewport viewport = getVirtualViewportLocked(info.uniqueId);
	populateViewportLocked(viewport, display, device);
	}
	}

	/** Get the virtual device viewport that has the specified uniqueId.
	* If such viewport does not exist, create it. */
	private DisplayViewport getVirtualViewportLocked(@NonNull String uniqueId) {
	DisplayViewport viewport;
	final int count = mViewports.size();
	for (int i = 0; i < count; i++) {
	viewport = mViewports.get(i);
	if (uniqueId.equals(viewport.uniqueId)) {
	if (viewport.type != VIEWPORT_VIRTUAL) {
	Slog.wtf(TAG, "Found a viewport with uniqueId '" + uniqueId
	+ "' but it has type " + DisplayViewport.typeToString(viewport.type)
	+ " (expected VIRTUAL)");
	continue;
	}
	return viewport;
	}
	}

	viewport = new DisplayViewport();
	viewport.uniqueId = uniqueId;
	viewport.type = VIEWPORT_VIRTUAL;
	mViewports.add(viewport);
	return viewport;
	}

	private DisplayViewport getInternalViewportLocked() {
	return getViewportByTypeLocked(VIEWPORT_INTERNAL);
	}		}

	private DisplayViewport getExternalViewportLocked() {		populateViewportLocked(viewportType, display.getDisplayIdLocked(), device, info.uniqueId);
	return getViewportByTypeLocked(VIEWPORT_EXTERNAL);
	}		}

	/**		/**
	@@ -1355,35 +1318,44 @@ public final class DisplayManagerService extends SystemService {
	* @param viewportType - either INTERNAL or EXTERNAL		* @param viewportType - either INTERNAL or EXTERNAL
	* @return the viewport with the requested type		* @return the viewport with the requested type
	*/		*/
	private DisplayViewport getViewportByTypeLocked(int viewportType) {		private DisplayViewport getViewportLocked(int viewportType, String uniqueId) {
	// Only allow a single INTERNAL or EXTERNAL viewport, which makes this function possible.		if (viewportType != VIEWPORT_INTERNAL && viewportType != VIEWPORT_EXTERNAL
	// TODO (b/116824030) allow multiple EXTERNAL viewports and remove this function.		&& viewportType != VIEWPORT_VIRTUAL) {
	// Creates the viewport if none exists.
	if (viewportType != VIEWPORT_INTERNAL && viewportType != VIEWPORT_EXTERNAL) {
	Slog.wtf(TAG, "Cannot call getViewportByTypeLocked for type "		Slog.wtf(TAG, "Cannot call getViewportByTypeLocked for type "
	+ DisplayViewport.typeToString(viewportType));		+ DisplayViewport.typeToString(viewportType));
	return null;		return null;
	}		}

			// Only allow a single INTERNAL or EXTERNAL viewport by forcing their uniqueIds
			// to be identical (in particular, empty).
			// TODO (b/116824030) allow multiple EXTERNAL viewports and remove this function.
			if (viewportType != VIEWPORT_VIRTUAL) {
			uniqueId = "";
			}

	DisplayViewport viewport;		DisplayViewport viewport;
	final int count = mViewports.size();		final int count = mViewports.size();
	for (int i = 0; i < count; i++) {		for (int i = 0; i < count; i++) {
	viewport = mViewports.get(i);		viewport = mViewports.get(i);
	if (viewport.type == viewportType) {		if (viewport.type == viewportType && uniqueId.equals(viewport.uniqueId)) {
	return viewport;		return viewport;
	}		}
	}		}

			// Creates the viewport if none exists.
	viewport = new DisplayViewport();		viewport = new DisplayViewport();
	viewport.type = viewportType;		viewport.type = viewportType;
			viewport.uniqueId = uniqueId;
	mViewports.add(viewport);		mViewports.add(viewport);
	return viewport;		return viewport;
	}		}

	private static void populateViewportLocked(DisplayViewport viewport,		private void populateViewportLocked(int viewportType,
	LogicalDisplay display, DisplayDevice device) {		int displayId, DisplayDevice device, String uniqueId) {
	viewport.valid = true;		final DisplayViewport viewport = getViewportLocked(viewportType, uniqueId);
	viewport.displayId = display.getDisplayIdLocked();
	device.populateViewportLocked(viewport);		device.populateViewportLocked(viewport);
			viewport.valid = true;
			viewport.displayId = displayId;
	}		}

	private LogicalDisplay findLogicalDisplayForDeviceLocked(DisplayDevice device) {		private LogicalDisplay findLogicalDisplayForDeviceLocked(DisplayDevice device) {

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

+11 −37

Original line number	Original line	Diff line number	Diff line
	@@ -149,12 +149,11 @@ public class DisplayManagerServiceTest {
	verify(mMockInputManagerInternal).setDisplayViewports(viewportCaptor.capture());		verify(mMockInputManagerInternal).setDisplayViewports(viewportCaptor.capture());
	List<DisplayViewport> viewports = viewportCaptor.getValue();		List<DisplayViewport> viewports = viewportCaptor.getValue();

	// Expect to receive 3 viewports: internal, external, and virtual		// Expect to receive 2 viewports: internal, and virtual
	assertEquals(3, viewports.size());		assertEquals(2, viewports.size());

	DisplayViewport virtualViewport = null;		DisplayViewport virtualViewport = null;
	DisplayViewport internalViewport = null;		DisplayViewport internalViewport = null;
	DisplayViewport externalViewport = null;
	for (int i = 0; i < viewports.size(); i++) {		for (int i = 0; i < viewports.size(); i++) {
	DisplayViewport v = viewports.get(i);		DisplayViewport v = viewports.get(i);
	switch (v.type) {		switch (v.type) {
	@@ -163,7 +162,7 @@ public class DisplayManagerServiceTest {
	break;		break;
	}		}
	case DisplayViewport.VIEWPORT_EXTERNAL: {		case DisplayViewport.VIEWPORT_EXTERNAL: {
	externalViewport = v;		fail("EXTERNAL viewport should not exist.");
	break;		break;
	}		}
	case DisplayViewport.VIEWPORT_VIRTUAL: {		case DisplayViewport.VIEWPORT_VIRTUAL: {
	@@ -172,14 +171,12 @@ public class DisplayManagerServiceTest {
	}		}
	}		}
	}		}
	// INTERNAL and EXTERNAL viewports get created upon access		// INTERNAL viewport gets created upon access.
	assertNotNull(internalViewport);		assertNotNull(internalViewport);
	assertNotNull(externalViewport);
	assertNotNull(virtualViewport);		assertNotNull(virtualViewport);

	// INTERNAL and EXTERNAL		// INTERNAL
	assertTrue(internalViewport.valid);		assertTrue(internalViewport.valid);
	assertTrue(externalViewport.valid);

	// VIRTUAL		// VIRTUAL
	assertEquals(height, virtualViewport.deviceHeight);		assertEquals(height, virtualViewport.deviceHeight);
	@@ -216,39 +213,16 @@ public class DisplayManagerServiceTest {
	verify(mMockInputManagerInternal).setDisplayViewports(viewportCaptor.capture());		verify(mMockInputManagerInternal).setDisplayViewports(viewportCaptor.capture());
	List<DisplayViewport> viewports = viewportCaptor.getValue();		List<DisplayViewport> viewports = viewportCaptor.getValue();

	// Expect to receive 2 viewports: 1 internal, 1 external		// Expect to receive actual viewports: 1 internal
	assertEquals(2, viewports.size());		assertEquals(1, viewports.size());

	DisplayViewport internalViewport = null;		DisplayViewport internalViewport = viewports.get(0);
	DisplayViewport externalViewport = null;
	for (int i = 0; i < viewports.size(); i++) {		// INTERNAL is the only one actual display.
	DisplayViewport v = viewports.get(i);
	switch (v.type) {
	case DisplayViewport.VIEWPORT_INTERNAL: {
	internalViewport = v;
	break;
	}
	case DisplayViewport.VIEWPORT_EXTERNAL: {
	externalViewport = v;
	break;
	}
	default: {
	fail("Unexpected viewport type: " + DisplayViewport.typeToString(v.type));
	break;
	}
	}
	}
	// INTERNAL and EXTERNAL viewports get created upon access
	assertNotNull(internalViewport);		assertNotNull(internalViewport);
	assertNotNull(externalViewport);		assertEquals(DisplayViewport.VIEWPORT_INTERNAL, internalViewport.type);
	assertTrue(internalViewport.valid);		assertTrue(internalViewport.valid);
	assertEquals(displayId, internalViewport.displayId);		assertEquals(displayId, internalViewport.displayId);

	// To simplify comparison, override the type for external Viewport
	// TODO (b/116850516) remove this
	externalViewport.type = internalViewport.type;
	assertEquals(internalViewport, externalViewport);
	externalViewport.type = DisplayViewport.VIEWPORT_EXTERNAL; // undo the changes above
	}		}

	@Test		@Test