Simplify GWPC.

The allowed/blocked activities and task navigation sets are
mutually exclusive, we can keep as single set for them. This will
come in handy when adding the dynamic activity policy.

Now when the default cross navigation policy is blocking and the
blocked list is empty - then everything is allowed \o/
This is not really a bug because the policy can only be blocking
if the blocked list is not empty. But fixing for consistency.

Fixing all the nullability annotations in GWPC because the
VirtualAudioControllerTest passes nulls for a bunch of callbacks
but GWPC mostly doesn't check if they are null.

No-op, pure refactoring, so not flagging.

Bug: 298401780
Test: presubmit
Change-Id: Iadebd10fad00c5be1be28507d13bf04f1c16aec1

4 files changed, 128 insertions, 138 deletions

diff --git a/core/java/android/companion/virtual/VirtualDeviceParams.java b/core/java/android/companion/virtual/VirtualDeviceParams.java
index 037e814a722d..51df25723ef6 100644
--- a/core/java/android/companion/virtual/VirtualDeviceParams.java
+++ b/core/java/android/companion/virtual/VirtualDeviceParams.java
@@ -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,
diff --git a/services/companion/java/com/android/server/companion/virtual/GenericWindowPolicyController.java b/services/companion/java/com/android/server/companion/virtual/GenericWindowPolicyController.java
index 9e7b897119a1..b07a0bb57678 100644
--- a/services/companion/java/com/android/server/companion/virtual/GenericWindowPolicyController.java
+++ b/services/companion/java/com/android/server/companion/virtual/GenericWindowPolicyController.java
@@ -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)) {
-            mActivityBlockedCallback.onActivityBlocked(mDisplayId, activityInfo);
+            if (mActivityBlockedCallback != null) {
+                mActivityBlockedCallback.onActivityBlocked(mDisplayId, activityInfo);
+            }
             return false;
         }
         if (mIntentListenerCallback != null && intent != null
@@ -275,22 +265,17 @@ 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)))) {
-                Slog.d(TAG, "Virtual device cross task navigation disallowed by policy: "
-                        + activityComponent);
-                return false;
-            }
+        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) {
-                mActivityBlockedCallback.onActivityBlocked(mDisplayId, activityInfo);
+                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
diff --git a/services/companion/java/com/android/server/companion/virtual/VirtualDeviceImpl.java b/services/companion/java/com/android/server/companion/virtual/VirtualDeviceImpl.java
index 56afeb112068..2b97bbb1e091 100644
--- a/services/companion/java/com/android/server/companion/virtual/VirtualDeviceImpl.java
+++ b/services/companion/java/com/android/server/companion/virtual/VirtualDeviceImpl.java
@@ -19,7 +19,9 @@ package com.android.server.companion.virtual;
 import static android.app.admin.DevicePolicyManager.NEARBY_STREAMING_ENABLED;
 import static android.app.admin.DevicePolicyManager.NEARBY_STREAMING_NOT_CONTROLLED_BY_POLICY;
 import static android.app.admin.DevicePolicyManager.NEARBY_STREAMING_SAME_MANAGED_ACCOUNT_ONLY;
+import static android.companion.virtual.VirtualDeviceParams.ACTIVITY_POLICY_DEFAULT_ALLOWED;
 import static android.companion.virtual.VirtualDeviceParams.DEVICE_POLICY_DEFAULT;
+import static android.companion.virtual.VirtualDeviceParams.NAVIGATION_POLICY_DEFAULT_ALLOWED;
 import static android.companion.virtual.VirtualDeviceParams.POLICY_TYPE_RECENTS;
 import static android.view.WindowManager.LayoutParams.FLAG_SECURE;
 import static android.view.WindowManager.LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS;
@@ -831,22 +833,31 @@ final class VirtualDeviceImpl extends IVirtualDevice.Stub
 
     private GenericWindowPolicyController createWindowPolicyController(
             @NonNull Set<String> displayCategories) {
-        final GenericWindowPolicyController gwpc =
-                new GenericWindowPolicyController(FLAG_SECURE,
-                        SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS,
-                        getAllowedUserHandles(),
-                        mParams.getAllowedCrossTaskNavigations(),
-                        mParams.getBlockedCrossTaskNavigations(),
-                        mParams.getAllowedActivities(),
-                        mParams.getBlockedActivities(),
-                        mParams.getDefaultActivityPolicy(),
-                        createListenerAdapter(),
-                        this::onEnteringPipBlocked,
-                        this::onActivityBlocked,
-                        this::onSecureWindowShown,
-                        this::shouldInterceptIntent,
-                        displayCategories,
-                        mParams.getDevicePolicy(POLICY_TYPE_RECENTS) == DEVICE_POLICY_DEFAULT);
+        final boolean activityLaunchAllowedByDefault =
+                mParams.getDefaultActivityPolicy() == ACTIVITY_POLICY_DEFAULT_ALLOWED;
+        final boolean crossTaskNavigationAllowedByDefault =
+                mParams.getDefaultNavigationPolicy() == NAVIGATION_POLICY_DEFAULT_ALLOWED;
+        final boolean showTasksInHostDeviceRecents =
+                mParams.getDevicePolicy(POLICY_TYPE_RECENTS) == DEVICE_POLICY_DEFAULT;
+
+        final GenericWindowPolicyController gwpc = new GenericWindowPolicyController(
+                FLAG_SECURE,
+                SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS,
+                getAllowedUserHandles(),
+                activityLaunchAllowedByDefault,
+                /*activityPolicyExceptions=*/activityLaunchAllowedByDefault
+                        ? mParams.getBlockedActivities() : mParams.getAllowedActivities(),
+                crossTaskNavigationAllowedByDefault,
+                /*crossTaskNavigationExceptions=*/crossTaskNavigationAllowedByDefault
+                        ? mParams.getBlockedCrossTaskNavigations()
+                        : mParams.getAllowedCrossTaskNavigations(),
+                createListenerAdapter(),
+                this::onEnteringPipBlocked,
+                this::onActivityBlocked,
+                this::onSecureWindowShown,
+                this::shouldInterceptIntent,
+                displayCategories,
+                showTasksInHostDeviceRecents);
         gwpc.registerRunningAppsChangedListener(/* listener= */ this);
         return gwpc;
     }
diff --git a/services/tests/servicestests/src/com/android/server/companion/virtual/audio/VirtualAudioControllerTest.java b/services/tests/servicestests/src/com/android/server/companion/virtual/audio/VirtualAudioControllerTest.java
index 2bfa44ecb1d6..78655a5dd341 100644
--- a/services/tests/servicestests/src/com/android/server/companion/virtual/audio/VirtualAudioControllerTest.java
+++ b/services/tests/servicestests/src/com/android/server/companion/virtual/audio/VirtualAudioControllerTest.java
@@ -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,