diff options
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, |