Specify default activity policy

Instead of using null values to indicate whether to use the allow list
or deny list for activity launching, add an intdef value to specify that
explicitly.

Bug: 219985243
Test: atest CtsVirtualDevicesTestCases
Change-Id: Ie6039262c95270f8886da7146999f30844f69a3c

1 files changed, 85 insertions, 47 deletions

diff --git a/core/java/android/companion/virtual/VirtualDeviceParams.java b/core/java/android/companion/virtual/VirtualDeviceParams.java
index 45d0ad51da04..41b1a1feae80 100644
--- a/core/java/android/companion/virtual/VirtualDeviceParams.java
+++ b/core/java/android/companion/virtual/VirtualDeviceParams.java
@@ -20,9 +20,7 @@ import static android.Manifest.permission.ADD_ALWAYS_UNLOCKED_DISPLAY;
 
 import android.annotation.IntDef;
 import android.annotation.NonNull;
-import android.annotation.Nullable;
 import android.annotation.RequiresPermission;
-import android.annotation.SuppressLint;
 import android.annotation.SystemApi;
 import android.content.ComponentName;
 import android.os.Parcel;
@@ -64,20 +62,43 @@ public final class VirtualDeviceParams implements Parcelable {
      */
     public static final int LOCK_STATE_ALWAYS_UNLOCKED = 1;
 
+    /** @hide */
+    @IntDef(prefix = "ACTIVITY_POLICY_",
+            value = {ACTIVITY_POLICY_DEFAULT_ALLOWED, ACTIVITY_POLICY_DEFAULT_BLOCKED})
+    @Retention(RetentionPolicy.SOURCE)
+    @Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
+    public @interface ActivityPolicy {}
+
+    /**
+     * Indicates that activities are allowed by default on this virtual device, unless they are
+     * explicitly blocked by {@link Builder#setBlockedActivities}.
+     */
+    public static final int ACTIVITY_POLICY_DEFAULT_ALLOWED = 0;
+
+    /**
+     * Indicates that activities are blocked by default on this virtual device, unless they are
+     * allowed by {@link Builder#setAllowedActivities}.
+     */
+    public static final int ACTIVITY_POLICY_DEFAULT_BLOCKED = 1;
+
     private final int mLockState;
     private final ArraySet<UserHandle> mUsersWithMatchingAccounts;
-    @Nullable private final ArraySet<ComponentName> mAllowedActivities;
-    @Nullable private final ArraySet<ComponentName> mBlockedActivities;
+    @NonNull private final ArraySet<ComponentName> mAllowedActivities;
+    @NonNull private final ArraySet<ComponentName> mBlockedActivities;
+    @ActivityPolicy
+    private final int mDefaultActivityPolicy;
 
     private VirtualDeviceParams(
             @LockState int lockState,
             @NonNull Set<UserHandle> usersWithMatchingAccounts,
-            @Nullable Set<ComponentName> allowedActivities,
-            @Nullable Set<ComponentName> blockedActivities) {
+            @NonNull Set<ComponentName> allowedActivities,
+            @NonNull Set<ComponentName> blockedActivities,
+            @ActivityPolicy int defaultActivityPolicy) {
         mLockState = lockState;
         mUsersWithMatchingAccounts = new ArraySet<>(usersWithMatchingAccounts);
         mAllowedActivities = allowedActivities == null ? null : new ArraySet<>(allowedActivities);
         mBlockedActivities = blockedActivities == null ? null : new ArraySet<>(blockedActivities);
+        mDefaultActivityPolicy = defaultActivityPolicy;
     }
 
     @SuppressWarnings("unchecked")
@@ -86,6 +107,7 @@ public final class VirtualDeviceParams implements Parcelable {
         mUsersWithMatchingAccounts = (ArraySet<UserHandle>) parcel.readArraySet(null);
         mAllowedActivities = (ArraySet<ComponentName>) parcel.readArraySet(null);
         mBlockedActivities = (ArraySet<ComponentName>) parcel.readArraySet(null);
+        mDefaultActivityPolicy = parcel.readInt();
     }
 
     /**
@@ -113,12 +135,10 @@ public final class VirtualDeviceParams implements Parcelable {
      *
      * @see Builder#setAllowedActivities(Set)
      */
-    // Null and empty have different semantics - Null allows all activities to be streamed
-    @SuppressLint("NullableCollection")
-    @Nullable
+    @NonNull
     public Set<ComponentName> getAllowedActivities() {
         if (mAllowedActivities == null) {
-            return null;
+            return Collections.emptySet();
         }
         return Collections.unmodifiableSet(mAllowedActivities);
     }
@@ -129,16 +149,27 @@ public final class VirtualDeviceParams implements Parcelable {
      *
      * @see Builder#setBlockedActivities(Set)
      */
-    // Allowing null to enforce that at most one of allowed / blocked activities can be non-null
-    @SuppressLint("NullableCollection")
-    @Nullable
+    @NonNull
     public Set<ComponentName> getBlockedActivities() {
         if (mBlockedActivities == null) {
-            return null;
+            return Collections.emptySet();
         }
         return Collections.unmodifiableSet(mBlockedActivities);
     }
 
+    /**
+     * Returns {@link #ACTIVITY_POLICY_DEFAULT_ALLOWED} if activities are allowed to launch on this
+     * virtual device by default, or {@link #ACTIVITY_POLICY_DEFAULT_BLOCKED} if activities must be
+     * allowed by {@link Builder#setAllowedActivities} to launch here.
+     *
+     * @see Builder#setBlockedActivities
+     * @see Builder#setAllowedActivities
+     */
+    @ActivityPolicy
+    public int getDefaultActivityPolicy() {
+        return mDefaultActivityPolicy;
+    }
+
     @Override
     public int describeContents() {
         return 0;
@@ -150,6 +181,7 @@ public final class VirtualDeviceParams implements Parcelable {
         dest.writeArraySet(mUsersWithMatchingAccounts);
         dest.writeArraySet(mAllowedActivities);
         dest.writeArraySet(mBlockedActivities);
+        dest.writeInt(mDefaultActivityPolicy);
     }
 
     @Override
@@ -164,12 +196,15 @@ public final class VirtualDeviceParams implements Parcelable {
         return mLockState == that.mLockState
                 && mUsersWithMatchingAccounts.equals(that.mUsersWithMatchingAccounts)
                 && Objects.equals(mAllowedActivities, that.mAllowedActivities)
-                && Objects.equals(mBlockedActivities, that.mBlockedActivities);
+                && Objects.equals(mBlockedActivities, that.mBlockedActivities)
+                && mDefaultActivityPolicy == that.mDefaultActivityPolicy;
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(mLockState, mUsersWithMatchingAccounts);
+        return Objects.hash(
+                mLockState, mUsersWithMatchingAccounts, mAllowedActivities, mBlockedActivities,
+                mDefaultActivityPolicy);
     }
 
     @Override
@@ -180,6 +215,7 @@ public final class VirtualDeviceParams implements Parcelable {
                 + " mUsersWithMatchingAccounts=" + mUsersWithMatchingAccounts
                 + " mAllowedActivities=" + mAllowedActivities
                 + " mBlockedActivities=" + mBlockedActivities
+                + " mDefaultActivityPolicy=" + mDefaultActivityPolicy
                 + ")";
     }
 
@@ -202,8 +238,11 @@ public final class VirtualDeviceParams implements Parcelable {
 
         private @LockState int mLockState = LOCK_STATE_DEFAULT;
         private Set<UserHandle> mUsersWithMatchingAccounts;
-        @Nullable private Set<ComponentName> mBlockedActivities;
-        @Nullable private Set<ComponentName> mAllowedActivities;
+        @NonNull private Set<ComponentName> mBlockedActivities = Collections.emptySet();
+        @NonNull private Set<ComponentName> mAllowedActivities = Collections.emptySet();
+        @ActivityPolicy
+        private int mDefaultActivityPolicy = ACTIVITY_POLICY_DEFAULT_ALLOWED;
+        private boolean mDefaultActivityPolicyConfigured = false;
 
         /**
          * Sets the lock state of the device. The permission {@code ADD_ALWAYS_UNLOCKED_DISPLAY}
@@ -248,53 +287,53 @@ public final class VirtualDeviceParams implements Parcelable {
         }
 
         /**
-         * Sets the activities allowed to be launched in the virtual device. If
-         * {@code allowedActivities} is non-null, all activities other than the ones in the set will
-         * be blocked from launching.
+         * Sets the activities allowed to be launched in the virtual device. Calling this method
+         * will cause {@link #getDefaultActivityPolicy()} to be
+         * {@link #ACTIVITY_POLICY_DEFAULT_BLOCKED}, meaning activities not in
+         * {@code allowedActivities} will be blocked from launching here.
          *
-         * <p>{@code allowedActivities} and the set in {@link #setBlockedActivities(Set)} cannot
-         * both be non-null at the same time.
+         * <p>This method must not be called if {@link #setBlockedActivities(Set)} has been called.
          *
-         * @throws IllegalArgumentException if {@link #setBlockedActivities(Set)} has been set to a
-         *   non-null value.
+         * @throws IllegalArgumentException if {@link #setBlockedActivities(Set)} has been called.
          *
          * @param allowedActivities A set of activity {@link ComponentName} allowed to be launched
          *   in the virtual device.
          */
-        // Null and empty have different semantics - Null allows all activities to be streamed
-        @SuppressLint("NullableCollection")
         @NonNull
-        public Builder setAllowedActivities(@Nullable Set<ComponentName> allowedActivities) {
-            if (mBlockedActivities != null && allowedActivities != null) {
+        public Builder setAllowedActivities(@NonNull Set<ComponentName> allowedActivities) {
+            if (mDefaultActivityPolicyConfigured
+                    && mDefaultActivityPolicy != ACTIVITY_POLICY_DEFAULT_BLOCKED) {
                 throw new IllegalArgumentException(
                         "Allowed activities and Blocked activities cannot both be set.");
             }
+            mDefaultActivityPolicy = ACTIVITY_POLICY_DEFAULT_BLOCKED;
+            mDefaultActivityPolicyConfigured = true;
             mAllowedActivities = allowedActivities;
             return this;
         }
 
         /**
-         * Sets the activities blocked from launching in the virtual device. If the {@code
-         * blockedActivities} is non-null, activities in the set are blocked from launching in the
-         * virtual device.
+         * Sets the activities blocked from launching in the virtual device. Calling this method
+         * will cause {@link #getDefaultActivityPolicy()} to be
+         * {@link #ACTIVITY_POLICY_DEFAULT_ALLOWED}, meaning activities are allowed to launch here
+         * unless they are in {@code blockedActivities}.
          *
-         * {@code blockedActivities} and the set in {@link #setAllowedActivities(Set)} cannot both
-         * be non-null at the same time.
+         * <p>This method must not be called if {@link #setAllowedActivities(Set)} has been called.
          *
-         * @throws IllegalArgumentException if {@link #setAllowedActivities(Set)} has been set to a
-         *   non-null value.
+         * @throws IllegalArgumentException if {@link #setAllowedActivities(Set)} has been called.
          *
          * @param blockedActivities A set of {@link ComponentName} to be blocked launching from
          *   virtual device.
          */
-        // Allowing null to enforce that at most one of allowed / blocked activities can be non-null
-        @SuppressLint("NullableCollection")
         @NonNull
-        public Builder setBlockedActivities(@Nullable Set<ComponentName> blockedActivities) {
-            if (mAllowedActivities != null && blockedActivities != null) {
+        public Builder setBlockedActivities(@NonNull Set<ComponentName> blockedActivities) {
+            if (mDefaultActivityPolicyConfigured
+                    && mDefaultActivityPolicy != ACTIVITY_POLICY_DEFAULT_ALLOWED) {
                 throw new IllegalArgumentException(
                         "Allowed activities and Blocked activities cannot both be set.");
             }
+            mDefaultActivityPolicy = ACTIVITY_POLICY_DEFAULT_ALLOWED;
+            mDefaultActivityPolicyConfigured = true;
             mBlockedActivities = blockedActivities;
             return this;
         }
@@ -307,13 +346,12 @@ public final class VirtualDeviceParams implements Parcelable {
             if (mUsersWithMatchingAccounts == null) {
                 mUsersWithMatchingAccounts = Collections.emptySet();
             }
-            if (mAllowedActivities != null && mBlockedActivities != null) {
-                // Should never reach here because the setters block this as well.
-                throw new IllegalStateException(
-                        "Allowed activities and Blocked activities cannot both be set.");
-            }
-            return new VirtualDeviceParams(mLockState, mUsersWithMatchingAccounts,
-                    mAllowedActivities, mBlockedActivities);
+            return new VirtualDeviceParams(
+                    mLockState,
+                    mUsersWithMatchingAccounts,
+                    mAllowedActivities,
+                    mBlockedActivities,
+                    mDefaultActivityPolicy);
         }
     }
 }