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

Commit acdc546c authored by Treehugger Robot's avatar Treehugger Robot Committed by Android (Google) Code Review
Browse files

Merge "Simplify GWPC." into main

parents ab8d05b7 631f35b3

core/java/android/companion/virtual/VirtualDeviceParams.java

+44 −56
Original line number Diff line number Diff line
@@ -202,14 +202,12 @@ public final class VirtualDeviceParams implements Parcelable { 


    private final int mLockState;

    @NonNull private final ArraySet<UserHandle> mUsersWithMatchingAccounts;

    @NonNull private final ArraySet<ComponentName> mAllowedCrossTaskNavigations;

    @NonNull private final ArraySet<ComponentName> mBlockedCrossTaskNavigations;

    @NavigationPolicy

    private final int mDefaultNavigationPolicy;

    @NonNull private final ArraySet<ComponentName> mAllowedActivities;

    @NonNull private final ArraySet<ComponentName> mBlockedActivities;

    @NonNull private final ArraySet<ComponentName> mCrossTaskNavigationExceptions;

    @ActivityPolicy

    private final int mDefaultActivityPolicy;

    @NonNull private final ArraySet<ComponentName> mActivityPolicyExceptions;

    @Nullable private final String mName;

    // Mapping of @PolicyType to @DevicePolicy

    @NonNull private final SparseIntArray mDevicePolicies;
@@ -221,12 +219,10 @@ public final class VirtualDeviceParams implements Parcelable { 
    private VirtualDeviceParams(

            @LockState int lockState,

            @NonNull Set<UserHandle> usersWithMatchingAccounts,

            @NonNull Set<ComponentName> allowedCrossTaskNavigations,

            @NonNull Set<ComponentName> blockedCrossTaskNavigations,

            @NavigationPolicy int defaultNavigationPolicy,

            @NonNull Set<ComponentName> allowedActivities,

            @NonNull Set<ComponentName> blockedActivities,

            @NonNull Set<ComponentName> crossTaskNavigationExceptions,

            @ActivityPolicy int defaultActivityPolicy,

            @NonNull Set<ComponentName> activityPolicyExceptions,

            @Nullable String name,

            @NonNull SparseIntArray devicePolicies,

            @NonNull List<VirtualSensorConfig> virtualSensorConfigs,
@@ -236,14 +232,12 @@ public final class VirtualDeviceParams implements Parcelable { 
        mLockState = lockState;

        mUsersWithMatchingAccounts =

                new ArraySet<>(Objects.requireNonNull(usersWithMatchingAccounts));

        mAllowedCrossTaskNavigations =

                new ArraySet<>(Objects.requireNonNull(allowedCrossTaskNavigations));

        mBlockedCrossTaskNavigations =

                new ArraySet<>(Objects.requireNonNull(blockedCrossTaskNavigations));

        mDefaultNavigationPolicy = defaultNavigationPolicy;

        mAllowedActivities = new ArraySet<>(Objects.requireNonNull(allowedActivities));

        mBlockedActivities = new ArraySet<>(Objects.requireNonNull(blockedActivities));

        mCrossTaskNavigationExceptions =

                new ArraySet<>(Objects.requireNonNull(crossTaskNavigationExceptions));

        mDefaultActivityPolicy = defaultActivityPolicy;

        mActivityPolicyExceptions =

                new ArraySet<>(Objects.requireNonNull(activityPolicyExceptions));

        mName = name;

        mDevicePolicies = Objects.requireNonNull(devicePolicies);

        mVirtualSensorConfigs = Objects.requireNonNull(virtualSensorConfigs);
@@ -256,12 +250,10 @@ public final class VirtualDeviceParams implements Parcelable { 
    private VirtualDeviceParams(Parcel parcel) {

        mLockState = parcel.readInt();

        mUsersWithMatchingAccounts = (ArraySet<UserHandle>) parcel.readArraySet(null);

        mAllowedCrossTaskNavigations = (ArraySet<ComponentName>) parcel.readArraySet(null);

        mBlockedCrossTaskNavigations = (ArraySet<ComponentName>) parcel.readArraySet(null);

        mDefaultNavigationPolicy = parcel.readInt();

        mAllowedActivities = (ArraySet<ComponentName>) parcel.readArraySet(null);

        mBlockedActivities = (ArraySet<ComponentName>) parcel.readArraySet(null);

        mCrossTaskNavigationExceptions = (ArraySet<ComponentName>) parcel.readArraySet(null);

        mDefaultActivityPolicy = parcel.readInt();

        mActivityPolicyExceptions = (ArraySet<ComponentName>) parcel.readArraySet(null);

        mName = parcel.readString8();

        mDevicePolicies = parcel.readSparseIntArray();

        mVirtualSensorConfigs = new ArrayList<>();
@@ -301,7 +293,9 @@ public final class VirtualDeviceParams implements Parcelable { 
     */

    @NonNull

    public Set<ComponentName> getAllowedCrossTaskNavigations() {

        return Collections.unmodifiableSet(mAllowedCrossTaskNavigations);

        return mDefaultNavigationPolicy == NAVIGATION_POLICY_DEFAULT_ALLOWED

                ? Collections.emptySet()

                : Collections.unmodifiableSet(mCrossTaskNavigationExceptions);

    }



    /**
@@ -314,7 +308,9 @@ public final class VirtualDeviceParams implements Parcelable { 
     */

    @NonNull

    public Set<ComponentName> getBlockedCrossTaskNavigations() {

        return Collections.unmodifiableSet(mBlockedCrossTaskNavigations);

        return mDefaultNavigationPolicy == NAVIGATION_POLICY_DEFAULT_BLOCKED

                ? Collections.emptySet()

                : Collections.unmodifiableSet(mCrossTaskNavigationExceptions);

    }



    /**
@@ -338,7 +334,9 @@ public final class VirtualDeviceParams implements Parcelable { 
     */

    @NonNull

    public Set<ComponentName> getAllowedActivities() {

        return Collections.unmodifiableSet(mAllowedActivities);

        return mDefaultActivityPolicy == ACTIVITY_POLICY_DEFAULT_ALLOWED

                ? Collections.emptySet()

                : Collections.unmodifiableSet(mActivityPolicyExceptions);

    }



    /**
@@ -349,7 +347,9 @@ public final class VirtualDeviceParams implements Parcelable { 
     */

    @NonNull

    public Set<ComponentName> getBlockedActivities() {

        return Collections.unmodifiableSet(mBlockedActivities);

        return mDefaultActivityPolicy == ACTIVITY_POLICY_DEFAULT_BLOCKED

                ? Collections.emptySet()

                : Collections.unmodifiableSet(mActivityPolicyExceptions);

    }



    /**
@@ -439,12 +439,10 @@ public final class VirtualDeviceParams implements Parcelable { 
    public void writeToParcel(@NonNull Parcel dest, int flags) {

        dest.writeInt(mLockState);

        dest.writeArraySet(mUsersWithMatchingAccounts);

        dest.writeArraySet(mAllowedCrossTaskNavigations);

        dest.writeArraySet(mBlockedCrossTaskNavigations);

        dest.writeInt(mDefaultNavigationPolicy);

        dest.writeArraySet(mAllowedActivities);

        dest.writeArraySet(mBlockedActivities);

        dest.writeArraySet(mCrossTaskNavigationExceptions);

        dest.writeInt(mDefaultActivityPolicy);

        dest.writeArraySet(mActivityPolicyExceptions);

        dest.writeString8(mName);

        dest.writeSparseIntArray(mDevicePolicies);

        dest.writeTypedList(mVirtualSensorConfigs);
@@ -477,11 +475,10 @@ public final class VirtualDeviceParams implements Parcelable { 
        }

        return mLockState == that.mLockState

                && mUsersWithMatchingAccounts.equals(that.mUsersWithMatchingAccounts)

                && Objects.equals(mAllowedCrossTaskNavigations, that.mAllowedCrossTaskNavigations)

                && Objects.equals(mBlockedCrossTaskNavigations, that.mBlockedCrossTaskNavigations)

                && Objects.equals(

                        mCrossTaskNavigationExceptions, that.mCrossTaskNavigationExceptions)

                && mDefaultNavigationPolicy == that.mDefaultNavigationPolicy

                && Objects.equals(mAllowedActivities, that.mAllowedActivities)

                && Objects.equals(mBlockedActivities, that.mBlockedActivities)

                && Objects.equals(mActivityPolicyExceptions, that.mActivityPolicyExceptions)

                && mDefaultActivityPolicy == that.mDefaultActivityPolicy

                && Objects.equals(mName, that.mName)

                && mAudioPlaybackSessionId == that.mAudioPlaybackSessionId
@@ -491,10 +488,9 @@ public final class VirtualDeviceParams implements Parcelable { 
    @Override

    public int hashCode() {

        int hashCode = Objects.hash(

                mLockState, mUsersWithMatchingAccounts, mAllowedCrossTaskNavigations,

                mBlockedCrossTaskNavigations, mDefaultNavigationPolicy, mAllowedActivities,

                mBlockedActivities, mDefaultActivityPolicy, mName, mDevicePolicies,

                mAudioPlaybackSessionId, mAudioRecordingSessionId);

                mLockState, mUsersWithMatchingAccounts, mCrossTaskNavigationExceptions,

                mDefaultNavigationPolicy, mActivityPolicyExceptions, mDefaultActivityPolicy, mName,

                mDevicePolicies, mAudioPlaybackSessionId, mAudioRecordingSessionId);

        for (int i = 0; i < mDevicePolicies.size(); i++) {

            hashCode = 31 * hashCode + mDevicePolicies.keyAt(i);

            hashCode = 31 * hashCode + mDevicePolicies.valueAt(i);
@@ -508,12 +504,10 @@ public final class VirtualDeviceParams implements Parcelable { 
        return "VirtualDeviceParams("

                + " mLockState=" + mLockState

                + " mUsersWithMatchingAccounts=" + mUsersWithMatchingAccounts

                + " mAllowedCrossTaskNavigations=" + mAllowedCrossTaskNavigations

                + " mBlockedCrossTaskNavigations=" + mBlockedCrossTaskNavigations

                + " mDefaultNavigationPolicy=" + mDefaultNavigationPolicy

                + " mAllowedActivities=" + mAllowedActivities

                + " mBlockedActivities=" + mBlockedActivities

                + " mCrossTaskNavigationExceptions=" + mCrossTaskNavigationExceptions

                + " mDefaultActivityPolicy=" + mDefaultActivityPolicy

                + " mActivityPolicyExceptions=" + mActivityPolicyExceptions

                + " mName=" + mName

                + " mDevicePolicies=" + mDevicePolicies

                + " mAudioPlaybackSessionId=" + mAudioPlaybackSessionId
@@ -529,13 +523,11 @@ public final class VirtualDeviceParams implements Parcelable { 
        pw.println(prefix + "mName=" + mName);

        pw.println(prefix + "mLockState=" + mLockState);

        pw.println(prefix + "mUsersWithMatchingAccounts=" + mUsersWithMatchingAccounts);

        pw.println(prefix + "mAllowedCrossTaskNavigations=" + mAllowedCrossTaskNavigations);

        pw.println(prefix + "mBlockedCrossTaskNavigations=" + mBlockedCrossTaskNavigations);

        pw.println(prefix + "mAllowedActivities=" + mAllowedActivities);

        pw.println(prefix + "mBlockedActivities=" + mBlockedActivities);

        pw.println(prefix + "mDevicePolicies=" + mDevicePolicies);

        pw.println(prefix + "mDefaultNavigationPolicy=" + mDefaultNavigationPolicy);

        pw.println(prefix + "mCrossTaskNavigationExceptions=" + mCrossTaskNavigationExceptions);

        pw.println(prefix + "mDefaultActivityPolicy=" + mDefaultActivityPolicy);

        pw.println(prefix + "mActivityPolicyExceptions=" + mActivityPolicyExceptions);

        pw.println(prefix + "mDevicePolicies=" + mDevicePolicies);

        pw.println(prefix + "mVirtualSensorConfigs=" + mVirtualSensorConfigs);

        pw.println(prefix + "mAudioPlaybackSessionId=" + mAudioPlaybackSessionId);

        pw.println(prefix + "mAudioRecordingSessionId=" + mAudioRecordingSessionId);
@@ -560,13 +552,11 @@ public final class VirtualDeviceParams implements Parcelable { 


        private @LockState int mLockState = LOCK_STATE_DEFAULT;

        @NonNull private Set<UserHandle> mUsersWithMatchingAccounts = Collections.emptySet();

        @NonNull private Set<ComponentName> mAllowedCrossTaskNavigations = Collections.emptySet();

        @NonNull private Set<ComponentName> mBlockedCrossTaskNavigations = Collections.emptySet();

        @NonNull private Set<ComponentName> mCrossTaskNavigationExceptions = Collections.emptySet();

        @NavigationPolicy

        private int mDefaultNavigationPolicy = NAVIGATION_POLICY_DEFAULT_ALLOWED;

        private boolean mDefaultNavigationPolicyConfigured = false;

        @NonNull private Set<ComponentName> mBlockedActivities = Collections.emptySet();

        @NonNull private Set<ComponentName> mAllowedActivities = Collections.emptySet();

        @NonNull private Set<ComponentName> mActivityPolicyExceptions = Collections.emptySet();

        @ActivityPolicy

        private int mDefaultActivityPolicy = ACTIVITY_POLICY_DEFAULT_ALLOWED;

        private boolean mDefaultActivityPolicyConfigured = false;
@@ -705,12 +695,12 @@ public final class VirtualDeviceParams implements Parcelable { 
            if (mDefaultNavigationPolicyConfigured

                    && mDefaultNavigationPolicy != NAVIGATION_POLICY_DEFAULT_BLOCKED) {

                throw new IllegalArgumentException(

                     "Allowed cross task navigation and blocked task navigation cannot "

                     "Allowed cross task navigations and blocked cross task navigations cannot "

                     + " both be set.");

            }

            mDefaultNavigationPolicy = NAVIGATION_POLICY_DEFAULT_BLOCKED;

            mDefaultNavigationPolicyConfigured = true;

            mAllowedCrossTaskNavigations = Objects.requireNonNull(allowedCrossTaskNavigations);

            mCrossTaskNavigationExceptions = Objects.requireNonNull(allowedCrossTaskNavigations);

            return this;

        }
@@ -741,7 +731,7 @@ public final class VirtualDeviceParams implements Parcelable { 
            }

            mDefaultNavigationPolicy = NAVIGATION_POLICY_DEFAULT_ALLOWED;

            mDefaultNavigationPolicyConfigured = true;

            mBlockedCrossTaskNavigations = Objects.requireNonNull(blockedCrossTaskNavigations);

            mCrossTaskNavigationExceptions = Objects.requireNonNull(blockedCrossTaskNavigations);

            return this;

        }
@@ -767,7 +757,7 @@ public final class VirtualDeviceParams implements Parcelable { 
            }

            mDefaultActivityPolicy = ACTIVITY_POLICY_DEFAULT_BLOCKED;

            mDefaultActivityPolicyConfigured = true;

            mAllowedActivities = Objects.requireNonNull(allowedActivities);

            mActivityPolicyExceptions = Objects.requireNonNull(allowedActivities);

            return this;

        }
@@ -793,7 +783,7 @@ public final class VirtualDeviceParams implements Parcelable { 
            }

            mDefaultActivityPolicy = ACTIVITY_POLICY_DEFAULT_ALLOWED;

            mDefaultActivityPolicyConfigured = true;

            mBlockedActivities = Objects.requireNonNull(blockedActivities);

            mActivityPolicyExceptions = Objects.requireNonNull(blockedActivities);

            return this;

        }
@@ -988,12 +978,10 @@ public final class VirtualDeviceParams implements Parcelable { 
            return new VirtualDeviceParams(

                    mLockState,

                    mUsersWithMatchingAccounts,

                    mAllowedCrossTaskNavigations,

                    mBlockedCrossTaskNavigations,

                    mDefaultNavigationPolicy,

                    mAllowedActivities,

                    mBlockedActivities,

                    mCrossTaskNavigationExceptions,

                    mDefaultActivityPolicy,

                    mActivityPolicyExceptions,

                    mName,

                    mDevicePolicies,

                    mVirtualSensorConfigs,

services/companion/java/com/android/server/companion/virtual/GenericWindowPolicyController.java

+53 −60
Original line number Diff line number Diff line
@@ -27,8 +27,6 @@ import android.annotation.UserIdInt; 
import android.app.WindowConfiguration;

import android.app.compat.CompatChanges;

import android.companion.virtual.VirtualDeviceManager.ActivityListener;

import android.companion.virtual.VirtualDeviceParams;

import android.companion.virtual.VirtualDeviceParams.ActivityPolicy;

import android.compat.annotation.ChangeId;

import android.compat.annotation.EnabledSince;

import android.content.ComponentName;
@@ -108,18 +106,14 @@ public class GenericWindowPolicyController extends DisplayWindowPolicyController 
    public static final long ALLOW_SECURE_ACTIVITY_DISPLAY_ON_REMOTE_DEVICE = 201712607L;

    @NonNull

    private final ArraySet<UserHandle> mAllowedUsers;

    @Nullable

    private final ArraySet<ComponentName> mAllowedCrossTaskNavigations;

    @Nullable

    private final ArraySet<ComponentName> mBlockedCrossTaskNavigations;

    @Nullable

    private final ArraySet<ComponentName> mAllowedActivities;

    @Nullable

    private final ArraySet<ComponentName> mBlockedActivities;

    private final boolean mActivityLaunchAllowedByDefault;

    @NonNull

    private final ArraySet<ComponentName> mActivityPolicyExceptions;

    private final boolean mCrossTaskNavigationAllowedByDefault;

    @NonNull

    private final ArraySet<ComponentName> mCrossTaskNavigationExceptions;

    private final Object mGenericWindowPolicyControllerLock = new Object();

    @ActivityPolicy

    private final int mDefaultActivityPolicy;

    private final ActivityBlockedCallback mActivityBlockedCallback;

    @Nullable private final ActivityBlockedCallback mActivityBlockedCallback;

    private int mDisplayId = Display.INVALID_DISPLAY;



    @NonNull
@@ -134,7 +128,7 @@ public class GenericWindowPolicyController extends DisplayWindowPolicyController 
    private final ArraySet<RunningAppsChangedListener> mRunningAppsChangedListeners =

            new ArraySet<>();

    @Nullable private final SecureWindowCallback mSecureWindowCallback;

    @Nullable private final Set<String> mDisplayCategories;

    @NonNull private final Set<String> mDisplayCategories;



    @GuardedBy("mGenericWindowPolicyControllerLock")

    private boolean mShowTasksInHostDeviceRecents;
@@ -146,18 +140,14 @@ public class GenericWindowPolicyController extends DisplayWindowPolicyController 
     * @param windowFlags The window flags that this controller is interested in.

     * @param systemWindowFlags The system window flags that this controller is interested in.

     * @param allowedUsers The set of users that are allowed to stream in this display.

     * @param allowedCrossTaskNavigations The set of components explicitly allowed to navigate

     *   across tasks on this device.

     * @param blockedCrossTaskNavigations The set of components explicitly blocked from

     *   navigating across tasks on this device.

     * @param allowedActivities The set of activities explicitly allowed to stream on this device.

     *   Used only if the {@code activityPolicy} is

     *   {@link VirtualDeviceParams#ACTIVITY_POLICY_DEFAULT_BLOCKED}.

     * @param blockedActivities The set of activities explicitly blocked from streaming on this

     *   device. Used only if the {@code activityPolicy} is

     *   {@link VirtualDeviceParams#ACTIVITY_POLICY_DEFAULT_ALLOWED}

     * @param defaultActivityPolicy Whether activities are default allowed to be displayed or

     *   blocked.

     * @param activityLaunchAllowedByDefault Whether activities are default allowed to be launched

     *   or blocked.

     * @param activityPolicyExceptions The set of activities explicitly exempt from the default

     *   activity policy.

     * @param crossTaskNavigationAllowedByDefault Whether cross task navigations are allowed by

     *   default or not.

     * @param crossTaskNavigationExceptions The set of components explicitly exempt from the default

     *   navigation policy.

     * @param activityListener Activity listener to listen for activity changes.

     * @param activityBlockedCallback Callback that is called when an activity is blocked from

     *   launching.
@@ -169,25 +159,23 @@ public class GenericWindowPolicyController extends DisplayWindowPolicyController 
     */

    public GenericWindowPolicyController(int windowFlags, int systemWindowFlags,

            @NonNull ArraySet<UserHandle> allowedUsers,

            @NonNull Set<ComponentName> allowedCrossTaskNavigations,

            @NonNull Set<ComponentName> blockedCrossTaskNavigations,

            @NonNull Set<ComponentName> allowedActivities,

            @NonNull Set<ComponentName> blockedActivities,

            @ActivityPolicy int defaultActivityPolicy,

            @NonNull ActivityListener activityListener,

            @NonNull PipBlockedCallback pipBlockedCallback,

            @NonNull ActivityBlockedCallback activityBlockedCallback,

            @NonNull SecureWindowCallback secureWindowCallback,

            @NonNull IntentListenerCallback intentListenerCallback,

            boolean activityLaunchAllowedByDefault,

            @NonNull Set<ComponentName> activityPolicyExceptions,

            boolean crossTaskNavigationAllowedByDefault,

            @NonNull Set<ComponentName> crossTaskNavigationExceptions,

            @Nullable ActivityListener activityListener,

            @Nullable PipBlockedCallback pipBlockedCallback,

            @Nullable ActivityBlockedCallback activityBlockedCallback,

            @Nullable SecureWindowCallback secureWindowCallback,

            @Nullable IntentListenerCallback intentListenerCallback,

            @NonNull Set<String> displayCategories,

            boolean showTasksInHostDeviceRecents) {

        super();

        mAllowedUsers = allowedUsers;

        mAllowedCrossTaskNavigations = new ArraySet<>(allowedCrossTaskNavigations);

        mBlockedCrossTaskNavigations = new ArraySet<>(blockedCrossTaskNavigations);

        mAllowedActivities = new ArraySet<>(allowedActivities);

        mBlockedActivities = new ArraySet<>(blockedActivities);

        mDefaultActivityPolicy = defaultActivityPolicy;

        mActivityLaunchAllowedByDefault = activityLaunchAllowedByDefault;

        mActivityPolicyExceptions = new ArraySet<>(activityPolicyExceptions);

        mCrossTaskNavigationAllowedByDefault = crossTaskNavigationAllowedByDefault;

        mCrossTaskNavigationExceptions = new ArraySet<>(crossTaskNavigationExceptions);

        mActivityBlockedCallback = activityBlockedCallback;

        setInterestedWindowFlags(windowFlags, systemWindowFlags);

        mActivityListener = activityListener;
@@ -233,7 +221,9 @@ public class GenericWindowPolicyController extends DisplayWindowPolicyController 
            @Nullable Intent intent, @WindowConfiguration.WindowingMode int windowingMode,

            int launchingFromDisplayId, boolean isNewTask) {

        if (!canContainActivity(activityInfo, windowingMode, launchingFromDisplayId, isNewTask)) {

            if (mActivityBlockedCallback != null) {

                mActivityBlockedCallback.onActivityBlocked(mDisplayId, activityInfo);

            }

            return false;

        }

        if (mIntentListenerCallback != null && intent != null
@@ -275,23 +265,18 @@ public class GenericWindowPolicyController extends DisplayWindowPolicyController 
                    + mDisplayCategories);

            return false;

        }

        if ((mDefaultActivityPolicy == VirtualDeviceParams.ACTIVITY_POLICY_DEFAULT_ALLOWED

                && mBlockedActivities.contains(activityComponent))

                || (mDefaultActivityPolicy == VirtualDeviceParams.ACTIVITY_POLICY_DEFAULT_BLOCKED

                && !mAllowedActivities.contains(activityComponent))) {

        if (!isAllowedByPolicy(mActivityLaunchAllowedByDefault, mActivityPolicyExceptions,

                activityComponent)) {

            Slog.d(TAG, "Virtual device launch disallowed by policy: " + activityComponent);

            return false;

        }

        if (isNewTask && launchingFromDisplayId != DEFAULT_DISPLAY) {

            if ((!mBlockedCrossTaskNavigations.isEmpty()

                    && mBlockedCrossTaskNavigations.contains(activityComponent))

                    || ((!mAllowedCrossTaskNavigations.isEmpty()

                    && !mAllowedCrossTaskNavigations.contains(activityComponent)))) {

        if (isNewTask && launchingFromDisplayId != DEFAULT_DISPLAY

                && !isAllowedByPolicy(mCrossTaskNavigationAllowedByDefault,

                        mCrossTaskNavigationExceptions, activityComponent)) {

            Slog.d(TAG, "Virtual device cross task navigation disallowed by policy: "

                    + activityComponent);

            return false;

        }

        }



        return true;

    }
@@ -302,7 +287,7 @@ public class GenericWindowPolicyController extends DisplayWindowPolicyController 
            int systemWindowFlags) {

        // The callback is fired only when windowFlags are changed. To let VirtualDevice owner

        // aware that the virtual display has a secure window on top.

        if ((windowFlags & FLAG_SECURE) != 0) {

        if ((windowFlags & FLAG_SECURE) != 0 && mSecureWindowCallback != null) {

            // Post callback on the main thread, so it doesn't block activity launching.

            mHandler.post(() -> mSecureWindowCallback.onSecureWindowShown(mDisplayId,

                    activityInfo.applicationInfo.uid));
@@ -314,7 +299,9 @@ public class GenericWindowPolicyController extends DisplayWindowPolicyController 
            // TODO(b/201712607): Add checks for the apps that use SurfaceView#setSecure.

            if ((windowFlags & FLAG_SECURE) != 0

                    || (systemWindowFlags & SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS) != 0) {

                if (mActivityBlockedCallback != null) {

                    mActivityBlockedCallback.onActivityBlocked(mDisplayId, activityInfo);

                }

                return false;

            }

        }
@@ -367,9 +354,9 @@ public class GenericWindowPolicyController extends DisplayWindowPolicyController 
        if (super.isEnteringPipAllowed(uid)) {

            return true;

        }

        mHandler.post(() -> {

            mPipBlockedCallback.onEnteringPipBlocked(uid);

        });

        if (mPipBlockedCallback != null) {

            mHandler.post(() -> mPipBlockedCallback.onEnteringPipBlocked(uid));

        }

        return false;

    }
@@ -389,7 +376,13 @@ public class GenericWindowPolicyController extends DisplayWindowPolicyController 
        }

        return activityInfo.requiredDisplayCategory != null

                    && mDisplayCategories.contains(activityInfo.requiredDisplayCategory);

    }



    private boolean isAllowedByPolicy(boolean allowedByDefault, ArraySet<ComponentName> exceptions,

            ComponentName component) {

        // Either allowed and the exceptions do not contain the component,

        // or disallowed and the exceptions contain the component.

        return allowedByDefault != exceptions.contains(component);

    }



    @VisibleForTesting

services/companion/java/com/android/server/companion/virtual/VirtualDeviceImpl.java

+27 −16

File changed.

Preview size limit exceeded, changes collapsed.

services/tests/servicestests/src/com/android/server/companion/virtual/audio/VirtualAudioControllerTest.java

+4 −6
Original line number Diff line number Diff line
@@ -25,7 +25,6 @@ import static com.google.common.truth.Truth.assertThat; 
import static org.mockito.Mockito.never;

import static org.mockito.Mockito.verify;



import android.companion.virtual.VirtualDeviceParams;

import android.companion.virtual.audio.IAudioConfigChangedCallback;

import android.companion.virtual.audio.IAudioRoutingCallback;

import android.content.Context;
@@ -79,11 +78,10 @@ public class VirtualAudioControllerTest { 
                        FLAG_SECURE,

                        SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS,

                        /* allowedUsers= */ new ArraySet<>(),

                        /* allowedCrossTaskNavigations= */ new ArraySet<>(),

                        /* blockedCrossTaskNavigations= */ new ArraySet<>(),

                        /* allowedActivities= */ new ArraySet<>(),

                        /* blockedActivities= */ new ArraySet<>(),

                        VirtualDeviceParams.ACTIVITY_POLICY_DEFAULT_ALLOWED,

                        /* activityLaunchAllowedByDefault= */ true,

                        /* activityPolicyExceptions= */ new ArraySet<>(),

                        /* crossTaskNavigationAllowedByDefault= */ true,

                        /* crossTaskNavigationExceptions= */ new ArraySet<>(),

                        /* activityListener= */ null,

                        /* pipBlockedCallback= */ null,

                        /* activityBlockedCallback= */ null,