Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f52ce16d authored by Eric Lin's avatar Eric Lin
Browse files

Cleanup wlinfo_oncreate flag. 

The flag wlinfo_oncreate (com.android.window.flags) is eligible for
cleanup. Remove the flag and its references from the codebase.

Bug: 337820752
Bug: 423986902
Flag: EXEMPT cleanup
Test: atest FrameworksCoreDeviceStateManagerTests:DeviceStateManagerGlobalTest
Test: atest FrameworksServicesTests:DeviceStateManagerServiceTest
Change-Id: Ib8b725f1f942007ff9d10f7197649aab1eec3106
parent 31bfbdb4

core/java/android/hardware/devicestate/DeviceStateManagerGlobal.java

+2 −7
Original line number Diff line number Diff line
@@ -32,7 +32,6 @@ import android.util.ArrayMap; 
import com.android.internal.annotations.GuardedBy;

import com.android.internal.annotations.VisibleForTesting;

import com.android.internal.annotations.VisibleForTesting.Visibility;

import com.android.window.flags.Flags;



import java.util.ArrayList;

import java.util.List;
@@ -287,13 +286,9 @@ public final class DeviceStateManagerGlobal { 
    private void registerCallbackLocked() {

        mCallback = new DeviceStateManagerCallback();

        try {

            if (Flags.wlinfoOncreate()) {

            synchronized (mLock) {

                mLastReceivedInfo = mDeviceStateManager.registerCallback(mCallback);

            }

            } else {

                mDeviceStateManager.registerCallback(mCallback);

            }

        } catch (RemoteException ex) {

            mCallback = null;

            throw ex.rethrowFromSystemServer();

core/java/android/window/flags/windowing_sdk.aconfig

+0 −7
Original line number Diff line number Diff line
@@ -75,13 +75,6 @@ flag { 
    }

}



flag {

    namespace: "windowing_sdk"

    name: "wlinfo_oncreate"

    description: "Makes WindowLayoutInfo accessible without racing in the Activity#onCreate()"

    bug: "337820752"

}



flag {

    namespace: "windowing_sdk"

    name: "better_support_non_match_parent_activity"

core/tests/devicestatetests/src/android/hardware/devicestate/DeviceStateManagerGlobalTest.java

+8 −70
Original line number Diff line number Diff line
@@ -24,7 +24,6 @@ import static org.mockito.ArgumentMatchers.any; 
import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.doAnswer;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.reset;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;
@@ -35,19 +34,13 @@ import android.hardware.devicestate.DeviceStateManager.DeviceStateCallback; 
import android.os.IBinder;

import android.os.RemoteException;

import android.os.test.FakePermissionEnforcer;

import android.platform.test.annotations.DisableFlags;

import android.platform.test.annotations.EnableFlags;

import android.platform.test.flag.junit.FlagsParameterization;

import android.platform.test.flag.junit.SetFlagsRule;



import androidx.annotation.NonNull;

import androidx.annotation.Nullable;

import androidx.test.ext.junit.runners.AndroidJUnit4;

import androidx.test.filters.SmallTest;



import com.android.window.flags.Flags;



import org.junit.Before;

import org.junit.Rule;

import org.junit.Test;

import org.junit.runner.RunWith;
@@ -57,9 +50,6 @@ import java.util.List; 
import java.util.Set;

import java.util.concurrent.Executor;



import platform.test.runner.parameterized.ParameterizedAndroidJunit4;

import platform.test.runner.parameterized.Parameters;



/**

 * Unit tests for {@link DeviceStateManagerGlobal}.

 *
@@ -67,64 +57,30 @@ import platform.test.runner.parameterized.Parameters; 
 * atest FrameworksCoreDeviceStateManagerTests:DeviceStateManagerGlobalTest

 */

@SmallTest

@RunWith(ParameterizedAndroidJunit4.class)

@RunWith(AndroidJUnit4.class)

public final class DeviceStateManagerGlobalTest {

    private static final DeviceState DEFAULT_DEVICE_STATE = new DeviceState(

            new DeviceState.Configuration.Builder(0 /* identifier */, "" /* name */).build());

    private static final DeviceState OTHER_DEVICE_STATE = new DeviceState(

            new DeviceState.Configuration.Builder(1 /* identifier */, "" /* name */).build());



    @Rule

    public final SetFlagsRule mSetFlagsRule;



    @Parameters(name = "{0}")

    public static List<FlagsParameterization> getParams() {

        return FlagsParameterization.allCombinationsOf(Flags.FLAG_WLINFO_ONCREATE);

    }



    @NonNull

    private TestDeviceStateManagerService mService;

    @NonNull

    private DeviceStateManagerGlobal mDeviceStateManagerGlobal;



    public DeviceStateManagerGlobalTest(FlagsParameterization flags) {

        mSetFlagsRule = new SetFlagsRule(flags);

    }



    @Before

    public void setUp() {

        final FakePermissionEnforcer permissionEnforcer = new FakePermissionEnforcer();

        mService = new TestDeviceStateManagerService(permissionEnforcer);

        mService = new TestDeviceStateManagerService();

        mDeviceStateManagerGlobal = new DeviceStateManagerGlobal(mService);

        assertThat(mService.mCallbacks).isNotEmpty();

    }



    @Test

    @DisableFlags(Flags.FLAG_WLINFO_ONCREATE)

    public void create_whenWlinfoOncreateIsDisabled_receivesDeviceStateInfoFromCallback() {

        final FakePermissionEnforcer permissionEnforcer = new FakePermissionEnforcer();

        final TestDeviceStateManagerService service = new TestDeviceStateManagerService(

                permissionEnforcer, true /* simulatePostCallback */);

        final DeviceStateManagerGlobal dsmGlobal = new DeviceStateManagerGlobal(service);

    public void create_returnsDeviceStateInfoFromRegistration() {

        final DeviceStateCallback callback = mock(DeviceStateCallback.class);

        dsmGlobal.registerDeviceStateCallback(callback, DIRECT_EXECUTOR);



        verify(callback, never()).onDeviceStateChanged(any());



        // Simulate DeviceStateManagerService#registerProcess by notifying clients of current device

        // state via callback.

        service.notifyDeviceStateInfoChanged();

        verify(callback).onDeviceStateChanged(eq(DEFAULT_DEVICE_STATE));

    }



    @Test

    @EnableFlags(Flags.FLAG_WLINFO_ONCREATE)

    public void create_whenWlinfoOncreateIsEnabled_returnsDeviceStateInfoFromRegistration() {

        final FakePermissionEnforcer permissionEnforcer = new FakePermissionEnforcer();

        final IDeviceStateManager service = new TestDeviceStateManagerService(permissionEnforcer);

        final DeviceStateManagerGlobal dsmGlobal = new DeviceStateManagerGlobal(service);

        final DeviceStateCallback callback = mock(DeviceStateCallback.class);

        dsmGlobal.registerDeviceStateCallback(callback, DIRECT_EXECUTOR);

        mDeviceStateManagerGlobal.registerDeviceStateCallback(callback, DIRECT_EXECUTOR);



        verify(callback).onDeviceStateChanged(eq(DEFAULT_DEVICE_STATE));

    }
@@ -338,17 +294,10 @@ public final class DeviceStateManagerGlobalTest { 
        @Nullable

        private Request mBaseStateRequest;



        private final boolean mSimulatePostCallback;

        private final Set<IDeviceStateManagerCallback> mCallbacks = new HashSet<>();



        TestDeviceStateManagerService(@NonNull FakePermissionEnforcer enforcer) {

            this(enforcer, false /* simulatePostCallback */);

        }



        TestDeviceStateManagerService(@NonNull FakePermissionEnforcer enforcer,

                boolean simulatePostCallback) {

            super(enforcer);

            mSimulatePostCallback = simulatePostCallback;

        TestDeviceStateManagerService() {

            super(new FakePermissionEnforcer());

        }



        @NonNull
@@ -390,20 +339,9 @@ public final class DeviceStateManagerGlobalTest { 
            }



            mCallbacks.add(callback);

            if (Flags.wlinfoOncreate()) {

            return getInfo();

        }



            if (!mSimulatePostCallback) {

                try {

                    callback.onDeviceStateInfoChanged(getInfo());

                } catch (RemoteException e) {

                    e.rethrowFromSystemServer();

                }

            }

            return null;

        }



        @Override

        public void requestState(@NonNull IBinder token, int state, int unusedFlags) {

            if (mRequest != null) {

libs/WindowManager/Jetpack/src/androidx/window/extensions/WindowExtensionsImpl.java

+1 −10
Original line number Diff line number Diff line
@@ -39,8 +39,6 @@ import androidx.window.extensions.embedding.SplitController; 
import androidx.window.extensions.layout.WindowLayoutComponent;

import androidx.window.extensions.layout.WindowLayoutComponentImpl;



import com.android.window.flags.Flags;



import java.util.Objects;
@@ -59,10 +57,6 @@ class WindowExtensionsImpl implements WindowExtensions { 


    private static final int EXTENSIONS_VERSION_V9 = 9;



    private static final int EXTENSIONS_VERSION_V8 = 8;



    private static final int EXTENSIONS_VERSION_V7 = 7;



    private final Object mLock = new Object();

    private volatile DeviceStateManagerFoldingFeatureProducer mFoldingFeatureProducer;

    private volatile WindowLayoutComponentImpl mWindowLayoutComponent;
@@ -82,11 +76,8 @@ class WindowExtensionsImpl implements WindowExtensions { 
     */

    @VisibleForTesting

    static int getExtensionsVersionCurrentPlatform() {

        if (Flags.wlinfoOncreate()) {

        return EXTENSIONS_VERSION_V9;

    }

        return EXTENSIONS_VERSION_V8;

    }



    private String generateLogMessage() {

        final StringBuilder logBuilder = new StringBuilder("Initializing Window Extensions, "

services/core/java/com/android/server/devicestate/DeviceStateManagerService.java

+1 −15
Original line number Diff line number Diff line
@@ -831,21 +831,7 @@ public final class DeviceStateManagerService extends SystemService { 
            }

            mProcessRecords.put(pid, record);



            final DeviceStateInfo currentInfo =

                    mCommittedState.isPresent() ? getDeviceStateInfoLocked() : null;

            if (com.android.window.flags.Flags.wlinfoOncreate()) {

                return currentInfo;

            } else {

                // Callback clients should not be notified of invalid device states, so calls to

                // #getDeviceStateInfoLocked should be gated on checks if a committed state is

                // present before getting the device state info.

                if (currentInfo != null) {

                    // If there is not a committed state we'll wait to notify the process of the

                    // initial value.

                    record.notifyDeviceStateInfoAsync(currentInfo);

                }

                return null;

            }

            return mCommittedState.isPresent() ? getDeviceStateInfoLocked() : null;

        }

    }