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

Revert "Allow opening activity to specify orientation."

Browse Source 
This reverts commit f0a6fdbf53.

Reason for revert: Submitted before complete.

Change-Id: I545ff45b5e870c79d66884b7a2a80981293b1b24
This commit is contained in:
Bryce Lee
2017-02-01 17:09:18 +00:00
parent f0a6fdbf53
commit 2fb7de3d51
6 changed files with 22 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
services/core/java/com/android/server/am/ActivityRecord.java
View File

@@ -1899,22 +1899,11 @@ final class ActivityRecord implements AppWindowContainerListener {
task.taskId, requestedOrientation);
}
/**
* Set the last reported global configuration to the client. Should be called whenever a new
* global configuration is sent to the client for this activity.
*/
void setLastReportedGlobalConfiguration(@NonNull Configuration config) {
// TODO: now used only in one place to address race-condition. Remove when that will be fixed.
void setLastReportedConfiguration(@NonNull Configuration config) {
mLastReportedConfiguration.setTo(config);
}
/**
* Set the last reported merged configuration to the client. Should be called whenever a new
* merged configuration is sent to the client for this activity.
*/
void setLastReportedMergedOverrideConfiguration(@NonNull Configuration config) {
mLastReportedOverrideConfiguration.setTo(config);
}
/** Call when override config was sent to the Window Manager to update internal records. */
void onOverrideConfigurationSent() {
mLastReportedOverrideConfiguration.setTo(task.getMergedOverrideConfiguration());

14
services/core/java/com/android/server/am/ActivityStackSupervisor.java
View File

@@ -1333,18 +1333,10 @@ public class ActivityStackSupervisor extends ConfigurationContainer implements D
// Because we could be starting an Activity in the system process this may not go across
// a Binder interface which would create a new Configuration. Consequently we have to
// always create a new Configuration here.
final Configuration globalConfiguration =
new Configuration(mService.getGlobalConfiguration());
r.setLastReportedGlobalConfiguration(globalConfiguration);
final Configuration mergedOverrideConfiguration =
new Configuration(task.getMergedOverrideConfiguration());
r.setLastReportedMergedOverrideConfiguration(mergedOverrideConfiguration);
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
System.identityHashCode(r), r.info,
globalConfiguration,
mergedOverrideConfiguration, r.compat,
new Configuration(mService.getGlobalConfiguration()),
new Configuration(task.getMergedOverrideConfiguration()), r.compat,
r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
r.persistentState, results, newIntents, !andResume,
mService.isNextTransitionForward(), profilerInfo);
@@ -1739,7 +1731,7 @@ public class ActivityStackSupervisor extends ConfigurationContainer implements D
// We'll update with whatever configuration it now says
// it used to launch.
if (config != null) {
r.setLastReportedGlobalConfiguration(config);
r.setLastReportedConfiguration(config);
}
// We are now idle. If someone is waiting for a thumbnail from

7
services/core/java/com/android/server/wm/AppWindowToken.java
View File

@@ -1151,11 +1151,10 @@ class AppWindowToken extends WindowToken implements WindowManagerService.AppFree
*/
@Override
int getOrientation() {
if (fillsParent() && (isVisible() || mService.mOpeningApps.contains(this))) {
return mOrientation;
if (hidden || hiddenRequested) {
return SCREEN_ORIENTATION_UNSET;
}
return SCREEN_ORIENTATION_UNSET;
return mOrientation;
}
/** Returns the app's preferred orientation regardless of its currently visibility state. */

9
services/core/java/com/android/server/wm/WindowContainer.java
View File

@@ -510,13 +510,14 @@ class WindowContainer<E extends WindowContainer> implements Comparable<WindowCon
* specification...
*/
int getOrientation() {
if (!fillsParent()) {
// Ignore containers that don't completely fills their parents.
if (!fillsParent() || !isVisible()) {
// Ignore invisible containers or containers that don't completely fills their parents.
return SCREEN_ORIENTATION_UNSET;
}
// The container fills its parent and is visible so we can use it orientation if it has one
// specified; otherwise we prefer to use the orientation of its topmost child that has one
// The container fills its parent so we can use it orientation if it has one specified,
// otherwise we prefer to use the orientation of its topmost child that has one
// specified and fall back on this container's unset or unspecified value as a candidate
// if none of the children have a better candidate for the orientation.
if (mOrientation != SCREEN_ORIENTATION_UNSET

9
services/core/java/com/android/server/wm/WindowManagerService.java
View File

@@ -2441,15 +2441,6 @@ public class WindowManagerService extends IWindowManager.Stub
}
}
/**
* Updates the device orientation from the present app tokens.
*
* Note: A place this is method called is before an {@link android.app.Activity} starts to
* ensure that it is created in the proper orientation. It is imperative that the present
* {@link AppWindowToken} specify that they can influence the orientation, accomplished with the
* override of {@link WindowContainer#canSpecifyOrientation()}. Visibility changes only will not
* guarantee this as other operations (such as freezing the screen) can defer these operations.
*/
@Override
public Configuration updateOrientationFromAppTokens(Configuration currentConfig,
IBinder freezeThisOneIfNeeded, int displayId) {

58
services/tests/servicestests/src/com/android/server/wm/WindowContainerTests.java
View File

@@ -387,32 +387,6 @@ public class WindowContainerTests extends WindowTestsBase {
assertTrue(gotException);
}
@Test
public void testGetOrientation_childSpecified() throws Exception {
testGetOrientation_childSpecifiedConfig(false, SCREEN_ORIENTATION_LANDSCAPE,
SCREEN_ORIENTATION_LANDSCAPE);
testGetOrientation_childSpecifiedConfig(false, SCREEN_ORIENTATION_UNSET,
SCREEN_ORIENTATION_UNSET);
}
private void testGetOrientation_childSpecifiedConfig(boolean childVisible, int childOrientation,
int expectedOrientation) {
final TestWindowContainerBuilder builder = new TestWindowContainerBuilder();
final TestWindowContainer root = builder.setLayer(0).build();
root.setFillsParent(true);
builder.setIsVisible(childVisible);
if (childOrientation != SCREEN_ORIENTATION_UNSET) {
builder.setOrientation(childOrientation);
}
final TestWindowContainer child1 = root.addChildWindow(builder);
child1.setFillsParent(true);
assertTrue(root.getOrientation() == expectedOrientation);
}
@Test
public void testGetOrientation_Unset() throws Exception {
final TestWindowContainerBuilder builder = new TestWindowContainerBuilder();
@@ -433,17 +407,18 @@ public class WindowContainerTests extends WindowTestsBase {
invisibleChild1VisibleAndSet.setOrientation(SCREEN_ORIENTATION_LANDSCAPE);
// Landscape well because the container is visible and that is what we set on it above.
assertEquals(SCREEN_ORIENTATION_LANDSCAPE, invisibleChild1VisibleAndSet.getOrientation());
// Landscape because even though the container isn't visible it has a child that is
// specifying it can influence the orientation by being visible.
assertEquals(SCREEN_ORIENTATION_LANDSCAPE, invisible.getOrientation());
// Landscape because the grandchild is visible and therefore can participate.
assertEquals(SCREEN_ORIENTATION_LANDSCAPE, root.getOrientation());
// Unset because the container isn't visible even though it has a child that thinks it is
// visible.
assertEquals(SCREEN_ORIENTATION_UNSET, invisible.getOrientation());
// Unspecified because we are visible and we didn't specify an orientation and there isn't
// a visible child.
assertEquals(SCREEN_ORIENTATION_UNSPECIFIED, root.getOrientation());
builder.setIsVisible(true).setLayer(-3);
final TestWindowContainer visibleUnset = root.addChildWindow(builder);
visibleUnset.setOrientation(SCREEN_ORIENTATION_UNSET);
assertEquals(SCREEN_ORIENTATION_UNSET, visibleUnset.getOrientation());
assertEquals(SCREEN_ORIENTATION_LANDSCAPE, root.getOrientation());
assertEquals(SCREEN_ORIENTATION_UNSPECIFIED, root.getOrientation());
}
@@ -715,7 +690,6 @@ public class WindowContainerTests extends WindowTestsBase {
private boolean mIsAnimating;
private boolean mIsVisible;
private boolean mFillsParent;
private Integer mOrientation;
private boolean mOnParentSetCalled;
@@ -734,13 +708,11 @@ public class WindowContainerTests extends WindowTestsBase {
return 1;
};
TestWindowContainer(int layer, boolean isAnimating, boolean isVisible,
Integer orientation) {
TestWindowContainer(int layer, boolean isAnimating, boolean isVisible) {
mLayer = layer;
mIsAnimating = isAnimating;
mIsVisible = isVisible;
mFillsParent = true;
mOrientation = orientation;
}
TestWindowContainer getParentWindow() {
@@ -785,11 +757,6 @@ public class WindowContainerTests extends WindowTestsBase {
return mIsVisible;
}
@Override
int getOrientation() {
return mOrientation != null ? mOrientation : super.getOrientation();
}
@Override
boolean fillsParent() {
return mFillsParent;
@@ -804,7 +771,6 @@ public class WindowContainerTests extends WindowTestsBase {
private int mLayer;
private boolean mIsAnimating;
private boolean mIsVisible;
private Integer mOrientation;
public TestWindowContainerBuilder() {
reset();
@@ -825,21 +791,15 @@ public class WindowContainerTests extends WindowTestsBase {
return this;
}
TestWindowContainerBuilder setOrientation(int orientation) {
mOrientation = orientation;
return this;
}
TestWindowContainerBuilder reset() {
mLayer = 0;
mIsAnimating = false;
mIsVisible = false;
mOrientation = null;
return this;
}
TestWindowContainer build() {
return new TestWindowContainer(mLayer, mIsAnimating, mIsVisible, mOrientation);
return new TestWindowContainer(mLayer, mIsAnimating, mIsVisible);
}
}
}