diff options
35 files changed, 1105 insertions, 433 deletions
diff --git a/core/java/android/app/ActivityOptions.java b/core/java/android/app/ActivityOptions.java index 7fd0211215c5..925b15deff29 100644 --- a/core/java/android/app/ActivityOptions.java +++ b/core/java/android/app/ActivityOptions.java @@ -51,6 +51,7 @@ import android.view.RemoteAnimationAdapter; import android.view.View; import android.view.ViewGroup; import android.view.Window; +import android.window.WindowContainerToken; import java.util.ArrayList; @@ -184,6 +185,14 @@ public class ActivityOptions { private static final String KEY_CALLER_DISPLAY_ID = "android.activity.callerDisplayId"; /** + * The task display area token the activity should be launched into. + * @see #setLaunchTaskDisplayArea(WindowContainerToken) + * @hide + */ + private static final String KEY_LAUNCH_TASK_DISPLAY_AREA_TOKEN = + "android.activity.launchTaskDisplayAreaToken"; + + /** * The windowing mode the activity should be launched into. * @hide */ @@ -334,6 +343,7 @@ public class ActivityOptions { private PendingIntent mUsageTimeReport; private int mLaunchDisplayId = INVALID_DISPLAY; private int mCallerDisplayId = INVALID_DISPLAY; + private WindowContainerToken mLaunchTaskDisplayArea; @WindowConfiguration.WindowingMode private int mLaunchWindowingMode = WINDOWING_MODE_UNDEFINED; @WindowConfiguration.ActivityType @@ -974,6 +984,7 @@ public class ActivityOptions { mLockTaskMode = opts.getBoolean(KEY_LOCK_TASK_MODE, false); mLaunchDisplayId = opts.getInt(KEY_LAUNCH_DISPLAY_ID, INVALID_DISPLAY); mCallerDisplayId = opts.getInt(KEY_CALLER_DISPLAY_ID, INVALID_DISPLAY); + mLaunchTaskDisplayArea = opts.getParcelable(KEY_LAUNCH_TASK_DISPLAY_AREA_TOKEN); mLaunchWindowingMode = opts.getInt(KEY_LAUNCH_WINDOWING_MODE, WINDOWING_MODE_UNDEFINED); mLaunchActivityType = opts.getInt(KEY_LAUNCH_ACTIVITY_TYPE, ACTIVITY_TYPE_UNDEFINED); mLaunchTaskId = opts.getInt(KEY_LAUNCH_TASK_ID, -1); @@ -1245,6 +1256,18 @@ public class ActivityOptions { } /** @hide */ + public WindowContainerToken getLaunchTaskDisplayArea() { + return mLaunchTaskDisplayArea; + } + + /** @hide */ + public ActivityOptions setLaunchTaskDisplayArea( + WindowContainerToken windowContainerToken) { + mLaunchTaskDisplayArea = windowContainerToken; + return this; + } + + /** @hide */ public int getLaunchWindowingMode() { return mLaunchWindowingMode; } @@ -1568,6 +1591,9 @@ public class ActivityOptions { if (mCallerDisplayId != INVALID_DISPLAY) { b.putInt(KEY_CALLER_DISPLAY_ID, mCallerDisplayId); } + if (mLaunchTaskDisplayArea != null) { + b.putParcelable(KEY_LAUNCH_TASK_DISPLAY_AREA_TOKEN, mLaunchTaskDisplayArea); + } if (mLaunchWindowingMode != WINDOWING_MODE_UNDEFINED) { b.putInt(KEY_LAUNCH_WINDOWING_MODE, mLaunchWindowingMode); } diff --git a/core/java/android/widget/TextView.java b/core/java/android/widget/TextView.java index 4be9e1a2051b..e933f18af979 100644 --- a/core/java/android/widget/TextView.java +++ b/core/java/android/widget/TextView.java @@ -3285,7 +3285,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener /** * Applies a tint to the compound drawables. Does not modify the - * current tint mode, which is {@link PorterDuff.Mode#SRC_IN} by default. + * current tint mode, which is {@link BlendMode#SRC_IN} by default. * <p> * Subsequent calls to * {@link #setCompoundDrawables(Drawable, Drawable, Drawable, Drawable)} diff --git a/core/tests/overlaytests/host/TEST_MAPPING b/core/tests/overlaytests/host/TEST_MAPPING new file mode 100644 index 000000000000..e0c03e0f2aa4 --- /dev/null +++ b/core/tests/overlaytests/host/TEST_MAPPING @@ -0,0 +1,7 @@ +{ + "presubmit": [ + { + "name" : "OverlayHostTests" + } + ] +}
\ No newline at end of file diff --git a/media/java/android/media/tv/tuner/Tuner.java b/media/java/android/media/tv/tuner/Tuner.java index 861eeea3bc34..fdd64f96701c 100644 --- a/media/java/android/media/tv/tuner/Tuner.java +++ b/media/java/android/media/tv/tuner/Tuner.java @@ -263,14 +263,14 @@ public class Tuner implements AutoCloseable { } private void setFrontendInfoList() { - List<Integer> ids = nativeGetFrontendIds(); + List<Integer> ids = getFrontendIds(); if (ids == null) { return; } TunerFrontendInfo[] infos = new TunerFrontendInfo[ids.size()]; for (int i = 0; i < ids.size(); i++) { int id = ids.get(i); - FrontendInfo frontendInfo = nativeGetFrontendInfo(id); + FrontendInfo frontendInfo = getFrontendInfoById(id); if (frontendInfo == null) { continue; } @@ -281,6 +281,11 @@ public class Tuner implements AutoCloseable { mTunerResourceManager.setFrontendInfoList(infos); } + /** @hide */ + public List<Integer> getFrontendIds() { + return nativeGetFrontendIds(); + } + private void setLnbIds() { int[] ids = nativeGetLnbIds(); if (ids == null) { @@ -345,14 +350,17 @@ public class Tuner implements AutoCloseable { @Override public void close() { if (mFrontendHandle != null) { + nativeCloseFrontendByHandle(mFrontendHandle); mTunerResourceManager.releaseFrontend(mFrontendHandle); mFrontendHandle = null; + mFrontend = null; } if (mLnb != null) { mTunerResourceManager.releaseLnb(mLnbHandle); mLnb = null; + mLnbHandle = null; } - nativeClose(); + TunerUtils.throwExceptionForResult(nativeClose(), "failed to close tuner"); } /** @@ -374,6 +382,8 @@ public class Tuner implements AutoCloseable { * Native method to open frontend of the given ID. */ private native Frontend nativeOpenFrontendByHandle(int handle); + @Result + private native int nativeCloseFrontendByHandle(int handle); private native int nativeTune(int type, FrontendSettings settings); private native int nativeStopTune(); private native int nativeScan(int settingsType, FrontendSettings settings, int scanType); @@ -522,6 +532,7 @@ public class Tuner implements AutoCloseable { public int tune(@NonNull FrontendSettings settings) { mFrontendType = settings.getType(); checkResource(TunerResourceManager.TUNER_RESOURCE_TYPE_FRONTEND); + mFrontendInfo = null; return nativeTune(settings.getType(), settings); } @@ -706,11 +717,16 @@ public class Tuner implements AutoCloseable { throw new IllegalStateException("frontend is not initialized"); } if (mFrontendInfo == null) { - mFrontendInfo = nativeGetFrontendInfo(mFrontend.mId); + mFrontendInfo = getFrontendInfoById(mFrontend.mId); } return mFrontendInfo; } + /** @hide */ + public FrontendInfo getFrontendInfoById(int id) { + return nativeGetFrontendInfo(id); + } + /** * Gets Demux capabilities. * diff --git a/media/java/android/media/tv/tunerresourcemanager/ITunerResourceManager.aidl b/media/java/android/media/tv/tunerresourcemanager/ITunerResourceManager.aidl index 77cac6ef7e2e..f33ad7de4179 100644 --- a/media/java/android/media/tv/tunerresourcemanager/ITunerResourceManager.aidl +++ b/media/java/android/media/tv/tunerresourcemanager/ITunerResourceManager.aidl @@ -132,11 +132,11 @@ interface ITunerResourceManager { * before this request. * * @param request {@link TunerFrontendRequest} information of the current request. - * @param frontendId a one-element array to return the granted frontendId. + * @param frontendHandle a one-element array to return the granted frontendHandle. * * @return true if there is frontend granted. */ - boolean requestFrontend(in TunerFrontendRequest request, out int[] frontendId); + boolean requestFrontend(in TunerFrontendRequest request, out int[] frontendHandle); /* * Requests to share frontend with an existing client. @@ -240,11 +240,11 @@ interface ITunerResourceManager { * <p><strong>Note:</strong> {@link #setLnbInfos(int[])} must be called before this request. * * @param request {@link TunerLnbRequest} information of the current request. - * @param lnbId a one-element array to return the granted Lnb id. + * @param lnbHandle a one-element array to return the granted Lnb handle. * * @return true if there is Lnb granted. */ - boolean requestLnb(in TunerLnbRequest request, out int[] lnbId); + boolean requestLnb(in TunerLnbRequest request, out int[] lnbHandle); /* * Notifies the TRM that the given frontend has been released. @@ -254,9 +254,9 @@ interface ITunerResourceManager { * <p><strong>Note:</strong> {@link #setFrontendInfoList(TunerFrontendInfo[])} must be called * before this release. * - * @param frontendId the id of the released frontend. + * @param frontendHandle the handle of the released frontend. */ - void releaseFrontend(in int frontendId); + void releaseFrontend(in int frontendHandle); /* * Notifies the TRM that the Demux with the given handle was released. @@ -288,15 +288,15 @@ interface ITunerResourceManager { void releaseCasSession(in int sessionResourceId); /* - * Notifies the TRM that the Lnb with the given id was released. + * Notifies the TRM that the Lnb with the given handle was released. * * <p>Client must call this whenever it releases an Lnb. * * <p><strong>Note:</strong> {@link #setLnbInfos(int[])} must be called before this release. * - * @param lnbId the id of the released Tuner Lnb. + * @param lnbHandle the handle of the released Tuner Lnb. */ - void releaseLnb(in int lnbId); + void releaseLnb(in int lnbHandle); /* * Compare two clients' priority. diff --git a/media/java/android/media/tv/tunerresourcemanager/TunerResourceManager.java b/media/java/android/media/tv/tunerresourcemanager/TunerResourceManager.java index 2c8899cfca78..a9f89bef06a5 100644 --- a/media/java/android/media/tv/tunerresourcemanager/TunerResourceManager.java +++ b/media/java/android/media/tv/tunerresourcemanager/TunerResourceManager.java @@ -64,6 +64,7 @@ public class TunerResourceManager { private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG); public static final int INVALID_RESOURCE_HANDLE = -1; + public static final int INVALID_OWNER_ID = -1; /** * Tuner resource type to help generate resource handle */ @@ -73,6 +74,7 @@ public class TunerResourceManager { TUNER_RESOURCE_TYPE_DESCRAMBLER, TUNER_RESOURCE_TYPE_LNB, TUNER_RESOURCE_TYPE_CAS_SESSION, + TUNER_RESOURCE_TYPE_MAX, }) @Retention(RetentionPolicy.SOURCE) public @interface TunerResourceType {} @@ -82,6 +84,7 @@ public class TunerResourceManager { public static final int TUNER_RESOURCE_TYPE_DESCRAMBLER = 2; public static final int TUNER_RESOURCE_TYPE_LNB = 3; public static final int TUNER_RESOURCE_TYPE_CAS_SESSION = 4; + public static final int TUNER_RESOURCE_TYPE_MAX = 5; private final ITunerResourceManager mService; private final int mUserId; @@ -243,16 +246,16 @@ public class TunerResourceManager { * before this request. * * @param request {@link TunerFrontendRequest} information of the current request. - * @param frontendId a one-element array to return the granted frontendId. If - * no frontend granted, this will return {@link #INVALID_FRONTEND_ID}. + * @param frontendHandle a one-element array to return the granted frontendHandle. If + * no frontend granted, this will return {@link #INVALID_RESOURCE_HANDLE}. * * @return true if there is frontend granted. */ public boolean requestFrontend(@NonNull TunerFrontendRequest request, - @Nullable int[] frontendId) { + @Nullable int[] frontendHandle) { boolean result = false; try { - result = mService.requestFrontend(request, frontendId); + result = mService.requestFrontend(request, frontendHandle); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } @@ -393,15 +396,15 @@ public class TunerResourceManager { * <p><strong>Note:</strong> {@link #setLnbInfoList(int[])} must be called before this request. * * @param request {@link TunerLnbRequest} information of the current request. - * @param lnbId a one-element array to return the granted Lnb id. - * If no Lnb granted, this will return {@link #INVALID_LNB_ID}. + * @param lnbHandle a one-element array to return the granted Lnb handle. + * If no Lnb granted, this will return {@link #INVALID_RESOURCE_HANDLE}. * * @return true if there is Lnb granted. */ - public boolean requestLnb(@NonNull TunerLnbRequest request, @NonNull int[] lnbId) { + public boolean requestLnb(@NonNull TunerLnbRequest request, @NonNull int[] lnbHandle) { boolean result = false; try { - result = mService.requestLnb(request, lnbId); + result = mService.requestLnb(request, lnbHandle); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } @@ -416,11 +419,11 @@ public class TunerResourceManager { * <p><strong>Note:</strong> {@link #setFrontendInfoList(TunerFrontendInfo[])} must be called * before this release. * - * @param frontendId the id of the released frontend. + * @param frontendHandle the handle of the released frontend. */ - public void releaseFrontend(int frontendId) { + public void releaseFrontend(int frontendHandle) { try { - mService.releaseFrontend(frontendId); + mService.releaseFrontend(frontendHandle); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } @@ -481,11 +484,11 @@ public class TunerResourceManager { * * <p><strong>Note:</strong> {@link #setLnbInfoList(int[])} must be called before this release. * - * @param lnbId the id of the released Tuner Lnb. + * @param lnbHandle the handle of the released Tuner Lnb. */ - public void releaseLnb(int lnbId) { + public void releaseLnb(int lnbHandle) { try { - mService.releaseLnb(lnbId); + mService.releaseLnb(lnbHandle); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } diff --git a/media/jni/android_media_tv_Tuner.cpp b/media/jni/android_media_tv_Tuner.cpp index 7579ca58b37b..909394fbc495 100644 --- a/media/jni/android_media_tv_Tuner.cpp +++ b/media/jni/android_media_tv_Tuner.cpp @@ -833,6 +833,12 @@ JTuner::JTuner(JNIEnv *env, jobject thiz) } JTuner::~JTuner() { + if (mFe != NULL) { + mFe->close(); + } + if (mDemux != NULL) { + mDemux->close(); + } JNIEnv *env = AndroidRuntime::getJNIEnv(); env->DeleteWeakGlobalRef(mObject); @@ -908,6 +914,14 @@ jobject JTuner::openFrontendById(int id) { (jint) jId); } +jint JTuner::closeFrontendById(int id) { + if (mFe != NULL && mFeId == id) { + Result r = mFe->close(); + return (jint) r; + } + return (jint) Result::SUCCESS; +} + jobject JTuner::getAnalogFrontendCaps(JNIEnv *env, FrontendInfo::FrontendCapabilities& caps) { jclass clazz = env->FindClass("android/media/tv/tuner/frontend/AnalogFrontendCapabilities"); jmethodID capsInit = env->GetMethodID(clazz, "<init>", "(II)V"); @@ -1271,6 +1285,23 @@ Result JTuner::openDemux() { return res; } +jint JTuner::close() { + Result res = Result::SUCCESS; + if (mFe != NULL) { + res = mFe->close(); + if (res != Result::SUCCESS) { + return (jint) res; + } + } + if (mDemux != NULL) { + res = mDemux->close(); + if (res != Result::SUCCESS) { + return (jint) res; + } + } + return (jint) res; +} + jobject JTuner::getAvSyncHwId(sp<Filter> filter) { if (mDemux == NULL) { return NULL; @@ -2362,6 +2393,13 @@ static jobject android_media_tv_Tuner_open_frontend_by_handle( return tuner->openFrontendById(id); } +static jint android_media_tv_Tuner_close_frontend_by_handle( + JNIEnv *env, jobject thiz, jint handle) { + sp<JTuner> tuner = getTuner(env, thiz); + uint32_t id = getResourceIdFromHandle(handle); + return tuner->closeFrontendById(id); +} + static int android_media_tv_Tuner_tune(JNIEnv *env, jobject thiz, jint type, jobject settings) { sp<JTuner> tuner = getTuner(env, thiz); return tuner->tune(getFrontendSettings(env, type, settings)); @@ -3135,6 +3173,11 @@ static jint android_media_tv_Tuner_open_demux(JNIEnv* env, jobject thiz, jint /* return (jint) tuner->openDemux(); } +static jint android_media_tv_Tuner_close_tuner(JNIEnv* env, jobject thiz) { + sp<JTuner> tuner = getTuner(env, thiz); + return (jint) tuner->close(); +} + static jint android_media_tv_Tuner_attach_filter(JNIEnv *env, jobject dvr, jobject filter) { sp<Dvr> dvrSp = getDvr(env, dvr); if (dvrSp == NULL) { @@ -3424,6 +3467,8 @@ static const JNINativeMethod gTunerMethods[] = { (void *)android_media_tv_Tuner_get_frontend_ids }, { "nativeOpenFrontendByHandle", "(I)Landroid/media/tv/tuner/Tuner$Frontend;", (void *)android_media_tv_Tuner_open_frontend_by_handle }, + { "nativeCloseFrontendByHandle", "(I)I", + (void *)android_media_tv_Tuner_close_frontend_by_handle }, { "nativeTune", "(ILandroid/media/tv/tuner/frontend/FrontendSettings;)I", (void *)android_media_tv_Tuner_tune }, { "nativeStopTune", "()I", (void *)android_media_tv_Tuner_stop_tune }, @@ -3460,6 +3505,7 @@ static const JNINativeMethod gTunerMethods[] = { { "nativeGetDemuxCapabilities", "()Landroid/media/tv/tuner/DemuxCapabilities;", (void *)android_media_tv_Tuner_get_demux_caps }, { "nativeOpenDemuxByhandle", "(I)I", (void *)android_media_tv_Tuner_open_demux }, + {"nativeClose", "()I", (void *)android_media_tv_Tuner_close_tuner }, }; static const JNINativeMethod gFilterMethods[] = { diff --git a/media/jni/android_media_tv_Tuner.h b/media/jni/android_media_tv_Tuner.h index 6749ba085739..750b146dbd59 100644 --- a/media/jni/android_media_tv_Tuner.h +++ b/media/jni/android_media_tv_Tuner.h @@ -172,6 +172,7 @@ struct JTuner : public RefBase { int disconnectCiCam(); jobject getFrontendIds(); jobject openFrontendById(int id); + jint closeFrontendById(int id); jobject getFrontendInfo(int id); int tune(const FrontendSettings& settings); int stopTune(); @@ -189,6 +190,7 @@ struct JTuner : public RefBase { jobject getDemuxCaps(); jobject getFrontendStatus(jintArray types); Result openDemux(); + jint close(); protected: virtual ~JTuner(); diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationPanelViewController.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationPanelViewController.java index 31797d1faa61..c9716d39590e 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationPanelViewController.java +++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationPanelViewController.java @@ -1780,7 +1780,13 @@ public class NotificationPanelViewController extends PanelViewController { }); animator.addListener(new AnimatorListenerAdapter() { @Override + public void onAnimationStart(Animator animation) { + notifyExpandingStarted(); + } + + @Override public void onAnimationEnd(Animator animation) { + notifyExpandingFinished(); mNotificationStackScroller.resetCheckSnoozeLeavebehind(); mQsExpansionAnimator = null; if (onFinishRunnable != null) { diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/PanelViewController.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/PanelViewController.java index f7d403f667cb..81dc9e1cf0e2 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/PanelViewController.java +++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/PanelViewController.java @@ -157,7 +157,7 @@ public abstract class PanelViewController { protected void onExpandingStarted() { } - private void notifyExpandingStarted() { + protected void notifyExpandingStarted() { if (!mExpanding) { mExpanding = true; onExpandingStarted(); diff --git a/packages/Tethering/src/com/android/networkstack/tethering/TetheringNotificationUpdater.java b/packages/Tethering/src/com/android/networkstack/tethering/TetheringNotificationUpdater.java index ff83fd1e4f1e..de2f90e50e2f 100644 --- a/packages/Tethering/src/com/android/networkstack/tethering/TetheringNotificationUpdater.java +++ b/packages/Tethering/src/com/android/networkstack/tethering/TetheringNotificationUpdater.java @@ -50,9 +50,6 @@ import androidx.annotation.Nullable; import com.android.internal.annotations.VisibleForTesting; -import java.util.Arrays; -import java.util.List; - /** * A class to display tethering-related notifications. * @@ -89,6 +86,9 @@ public class TetheringNotificationUpdater { static final int NO_ICON_ID = 0; @VisibleForTesting static final int DOWNSTREAM_NONE = 0; + // Refer to TelephonyManager#getSimCarrierId for more details about carrier id. + @VisibleForTesting + static final int VERIZON_CARRIER_ID = 1839; private final Context mContext; private final NotificationManager mNotificationManager; private final NotificationChannel mChannel; @@ -114,11 +114,11 @@ public class TetheringNotificationUpdater { @interface NotificationId {} private static final class MccMncOverrideInfo { - public final List<String> visitedMccMncs; + public final String visitedMccMnc; public final int homeMcc; public final int homeMnc; - MccMncOverrideInfo(List<String> visitedMccMncs, int mcc, int mnc) { - this.visitedMccMncs = visitedMccMncs; + MccMncOverrideInfo(String visitedMccMnc, int mcc, int mnc) { + this.visitedMccMnc = visitedMccMnc; this.homeMcc = mcc; this.homeMnc = mnc; } @@ -127,9 +127,7 @@ public class TetheringNotificationUpdater { private static final SparseArray<MccMncOverrideInfo> sCarrierIdToMccMnc = new SparseArray<>(); static { - // VZW - sCarrierIdToMccMnc.put( - 1839, new MccMncOverrideInfo(Arrays.asList(new String[] {"20404"}), 311, 480)); + sCarrierIdToMccMnc.put(VERIZON_CARRIER_ID, new MccMncOverrideInfo("20404", 311, 480)); } public TetheringNotificationUpdater(@NonNull final Context context, @@ -200,7 +198,7 @@ public class TetheringNotificationUpdater { final int carrierId = tm.getSimCarrierId(); final String mccmnc = tm.getSimOperator(); final MccMncOverrideInfo overrideInfo = sCarrierIdToMccMnc.get(carrierId); - if (overrideInfo != null && overrideInfo.visitedMccMncs.contains(mccmnc)) { + if (overrideInfo != null && overrideInfo.visitedMccMnc.equals(mccmnc)) { // Re-configure MCC/MNC value to specific carrier to get right resources. final Configuration config = res.getConfiguration(); config.mcc = overrideInfo.homeMcc; diff --git a/packages/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringNotificationUpdaterTest.kt b/packages/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringNotificationUpdaterTest.kt index 5f8858857c75..294bf1b7e169 100644 --- a/packages/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringNotificationUpdaterTest.kt +++ b/packages/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringNotificationUpdaterTest.kt @@ -39,6 +39,7 @@ import com.android.networkstack.tethering.TetheringNotificationUpdater.ENABLE_NO import com.android.networkstack.tethering.TetheringNotificationUpdater.EVENT_SHOW_NO_UPSTREAM import com.android.networkstack.tethering.TetheringNotificationUpdater.NO_UPSTREAM_NOTIFICATION_ID import com.android.networkstack.tethering.TetheringNotificationUpdater.RESTRICTED_NOTIFICATION_ID +import com.android.networkstack.tethering.TetheringNotificationUpdater.VERIZON_CARRIER_ID import com.android.testutils.waitForIdle import org.junit.After import org.junit.Assert.assertEquals @@ -417,7 +418,7 @@ class TetheringNotificationUpdaterTest { assertEquals(config.mcc, res.configuration.mcc) assertEquals(config.mnc, res.configuration.mnc) - doReturn(1839).`when`(telephonyManager).getSimCarrierId() + doReturn(VERIZON_CARRIER_ID).`when`(telephonyManager).getSimCarrierId() res = notificationUpdater.getResourcesForSubId(context, subId) assertEquals(config.mcc, res.configuration.mcc) assertEquals(config.mnc, res.configuration.mnc) diff --git a/services/core/java/com/android/server/power/PowerManagerService.java b/services/core/java/com/android/server/power/PowerManagerService.java index 5a3464d8a35f..764ac969e188 100644 --- a/services/core/java/com/android/server/power/PowerManagerService.java +++ b/services/core/java/com/android/server/power/PowerManagerService.java @@ -2338,8 +2338,7 @@ public final class PowerManagerService extends SystemService nextTimeout = -1; } - if (((mUserActivitySummary & USER_ACTIVITY_SCREEN_BRIGHT) != 0 - || (mUserActivitySummary & USER_ACTIVITY_SCREEN_DIM) != 0) + if ((mUserActivitySummary & USER_ACTIVITY_SCREEN_BRIGHT) != 0 && (mWakeLockSummary & WAKE_LOCK_STAY_AWAKE) == 0) { nextTimeout = mAttentionDetector.updateUserActivity(nextTimeout, screenDimDuration); diff --git a/services/core/java/com/android/server/tv/tunerresourcemanager/ClientProfile.java b/services/core/java/com/android/server/tv/tunerresourcemanager/ClientProfile.java index e100ff816f00..43b48546aada 100644 --- a/services/core/java/com/android/server/tv/tunerresourcemanager/ClientProfile.java +++ b/services/core/java/com/android/server/tv/tunerresourcemanager/ClientProfile.java @@ -68,6 +68,11 @@ public final class ClientProfile { private Set<Integer> mUsingFrontendIds = new HashSet<>(); /** + * List of the Lnb ids that are used by the current client. + */ + private Set<Integer> mUsingLnbIds = new HashSet<>(); + + /** * Optional arbitrary priority value given by the client. * * <p>This value can override the default priorotiy calculated from @@ -131,7 +136,7 @@ public final class ClientProfile { mUsingFrontendIds.add(frontendId); } - public Iterable<Integer> getInUseFrontendIds() { + public Set<Integer> getInUseFrontendIds() { return mUsingFrontendIds; } @@ -146,6 +151,30 @@ public final class ClientProfile { mUsingFrontendIds.remove(frontendId); } + /** + * Set when the client starts to use an Lnb. + * + * @param lnbId being used. + */ + public void useLnb(int lnbId) { + mUsingLnbIds.add(lnbId); + } + + public Set<Integer> getInUseLnbIds() { + return mUsingLnbIds; + } + + /** + * Called when the client released an lnb. + * + * <p>This could happen when client resource reclaimed. + * + * @param lnbId being released. + */ + public void releaseLnb(int lnbId) { + mUsingLnbIds.remove(lnbId); + } + @Override public String toString() { return "ClientProfile[id=" + this.mId + ", tvInputSessionId=" + this.mTvInputSessionId diff --git a/services/core/java/com/android/server/tv/tunerresourcemanager/FrontendResource.java b/services/core/java/com/android/server/tv/tunerresourcemanager/FrontendResource.java index 56f61599c998..7ea62b25c39a 100644 --- a/services/core/java/com/android/server/tv/tunerresourcemanager/FrontendResource.java +++ b/services/core/java/com/android/server/tv/tunerresourcemanager/FrontendResource.java @@ -27,14 +27,7 @@ import java.util.Set; * * @hide */ -public final class FrontendResource { - public static final int INVALID_OWNER_ID = -1; - - /** - * Id of the current frontend. Should not be changed and should be aligned with the driver level - * implementation. - */ - private final int mId; +public final class FrontendResource extends TunerResourceBasic { /** * see {@link android.media.tv.tuner.frontend.FrontendSettings.Type} @@ -51,28 +44,12 @@ public final class FrontendResource { */ private Set<Integer> mExclusiveGroupMemberFeIds = new HashSet<>(); - /** - * If the current resource is in use. Once resources under the same exclusive group id is in use - * all other resources in the same group would be considered in use. - */ - private boolean mIsInUse; - - /** - * The owner client's id if this resource is occupied. Owner of the resource under the same - * exclusive group id would be considered as the whole group's owner. - */ - private int mOwnerClientId = INVALID_OWNER_ID; - private FrontendResource(Builder builder) { - this.mId = builder.mId; + super(builder); this.mType = builder.mType; this.mExclusiveGroupId = builder.mExclusiveGroupId; } - public int getId() { - return mId; - } - public int getType() { return mType; } @@ -112,32 +89,6 @@ public final class FrontendResource { mExclusiveGroupMemberFeIds.remove(id); } - public boolean isInUse() { - return mIsInUse; - } - - public int getOwnerClientId() { - return mOwnerClientId; - } - - /** - * Set an owner client on the resource. - * - * @param ownerClientId the id of the owner client. - */ - public void setOwner(int ownerClientId) { - mIsInUse = true; - mOwnerClientId = ownerClientId; - } - - /** - * Remove an owner client from the resource. - */ - public void removeOwner() { - mIsInUse = false; - mOwnerClientId = INVALID_OWNER_ID; - } - @Override public String toString() { return "FrontendResource[id=" + this.mId + ", type=" + this.mType @@ -149,13 +100,12 @@ public final class FrontendResource { /** * Builder class for {@link FrontendResource}. */ - public static class Builder { - private final int mId; + public static class Builder extends TunerResourceBasic.Builder { @Type private int mType; private int mExclusiveGroupId; Builder(int id) { - this.mId = id; + super(id); } /** @@ -183,6 +133,7 @@ public final class FrontendResource { * * @return {@link FrontendResource}. */ + @Override public FrontendResource build() { FrontendResource frontendResource = new FrontendResource(this); return frontendResource; diff --git a/services/core/java/com/android/server/tv/tunerresourcemanager/LnbResource.java b/services/core/java/com/android/server/tv/tunerresourcemanager/LnbResource.java new file mode 100644 index 000000000000..345b4b261c74 --- /dev/null +++ b/services/core/java/com/android/server/tv/tunerresourcemanager/LnbResource.java @@ -0,0 +1,56 @@ +/* + * Copyright 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.android.server.tv.tunerresourcemanager; + +/** + * An Lnb resource object used by the Tuner Resource Manager to record the tuner Lnb + * information. + * + * @hide + */ +public final class LnbResource extends TunerResourceBasic { + + private LnbResource(Builder builder) { + super(builder); + } + + @Override + public String toString() { + return "LnbResource[id=" + this.mId + + ", isInUse=" + this.mIsInUse + ", ownerClientId=" + this.mOwnerClientId + "]"; + } + + /** + * Builder class for {@link LnbResource}. + */ + public static class Builder extends TunerResourceBasic.Builder { + + Builder(int id) { + super(id); + } + + /** + * Build a {@link LnbResource}. + * + * @return {@link LnbResource}. + */ + @Override + public LnbResource build() { + LnbResource lnb = new LnbResource(this); + return lnb; + } + } +} diff --git a/services/core/java/com/android/server/tv/tunerresourcemanager/TunerResourceBasic.java b/services/core/java/com/android/server/tv/tunerresourcemanager/TunerResourceBasic.java new file mode 100644 index 000000000000..7f133c3ab9f9 --- /dev/null +++ b/services/core/java/com/android/server/tv/tunerresourcemanager/TunerResourceBasic.java @@ -0,0 +1,97 @@ +/* + * Copyright 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.android.server.tv.tunerresourcemanager; + +import static android.media.tv.tunerresourcemanager.TunerResourceManager.INVALID_OWNER_ID; + +/** + * A Tuner resource basic object used by the Tuner Resource Manager to record the resource + * information. + * + * @hide + */ +public class TunerResourceBasic { + /** + * Id of the current resource. Should not be changed and should be aligned with the driver level + * implementation. + */ + final int mId; + + /** + * If the current resource is in use. + */ + boolean mIsInUse; + + /** + * The owner client's id if this resource is occupied. + */ + int mOwnerClientId = INVALID_OWNER_ID; + + TunerResourceBasic(Builder builder) { + this.mId = builder.mId; + } + + public int getId() { + return mId; + } + + public boolean isInUse() { + return mIsInUse; + } + + public int getOwnerClientId() { + return mOwnerClientId; + } + + /** + * Set an owner client on the resource. + * + * @param ownerClientId the id of the owner client. + */ + public void setOwner(int ownerClientId) { + mIsInUse = true; + mOwnerClientId = ownerClientId; + } + + /** + * Remove an owner client from the resource. + */ + public void removeOwner() { + mIsInUse = false; + mOwnerClientId = INVALID_OWNER_ID; + } + + /** + * Builder class for {@link TunerResourceBasic}. + */ + public static class Builder { + private final int mId; + + Builder(int id) { + this.mId = id; + } + + /** + * Build a {@link TunerResourceBasic}. + * + * @return {@link TunerResourceBasic}. + */ + public TunerResourceBasic build() { + TunerResourceBasic resource = new TunerResourceBasic(this); + return resource; + } + } +} diff --git a/services/core/java/com/android/server/tv/tunerresourcemanager/TunerResourceManagerService.java b/services/core/java/com/android/server/tv/tunerresourcemanager/TunerResourceManagerService.java index 6dded00321b5..acb6f950b6b4 100644 --- a/services/core/java/com/android/server/tv/tunerresourcemanager/TunerResourceManagerService.java +++ b/services/core/java/com/android/server/tv/tunerresourcemanager/TunerResourceManagerService.java @@ -63,6 +63,8 @@ public class TunerResourceManagerService extends SystemService { // Map of the current available frontend resources private Map<Integer, FrontendResource> mFrontendResources = new HashMap<>(); + // Map of the current available lnb resources + private Map<Integer, LnbResource> mLnbResources = new HashMap<>(); @GuardedBy("mLock") private Map<Integer, ResourcesReclaimListenerRecord> mListeners = new HashMap<>(); @@ -164,12 +166,13 @@ public class TunerResourceManagerService extends SystemService { } @Override - public void setLnbInfoList(int[] lnbIds) { + public void setLnbInfoList(int[] lnbIds) throws RemoteException { enforceTrmAccessPermission("setLnbInfoList"); - if (DEBUG) { - for (int i = 0; i < lnbIds.length; i++) { - Slog.d(TAG, "updateLnbInfo(lnbId=" + lnbIds[i] + ")"); - } + if (lnbIds == null) { + throw new RemoteException("Lnb id list can't be null"); + } + synchronized (mLock) { + setLnbInfoListInternal(lnbIds); } } @@ -237,21 +240,32 @@ public class TunerResourceManagerService extends SystemService { } @Override - public boolean requestLnb(@NonNull TunerLnbRequest request, @NonNull int[] lnbHandle) { + public boolean requestLnb(@NonNull TunerLnbRequest request, @NonNull int[] lnbHandle) + throws RemoteException { enforceTunerAccessPermission("requestLnb"); enforceTrmAccessPermission("requestLnb"); - if (DEBUG) { - Slog.d(TAG, "requestLnb(request=" + request + ")"); + if (lnbHandle == null) { + throw new RemoteException("lnbHandle can't be null"); + } + synchronized (mLock) { + try { + return requestLnbInternal(request, lnbHandle); + } catch (RemoteException e) { + throw e.rethrowFromSystemServer(); + } } - return true; } @Override - public void releaseFrontend(int frontendId) { + public void releaseFrontend(int frontendHandle) throws RemoteException { enforceTunerAccessPermission("releaseFrontend"); enforceTrmAccessPermission("releaseFrontend"); - if (DEBUG) { - Slog.d(TAG, "releaseFrontend(id=" + frontendId + ")"); + if (!validateResourceHandle(TunerResourceManager.TUNER_RESOURCE_TYPE_FRONTEND, + frontendHandle)) { + throw new RemoteException("frontendHandle can't be invalid"); + } + synchronized (mLock) { + releaseFrontendInternal(getResourceIdFromHandle(frontendHandle)); } } @@ -282,11 +296,14 @@ public class TunerResourceManagerService extends SystemService { } @Override - public void releaseLnb(int lnbId) { + public void releaseLnb(int lnbHandle) throws RemoteException { enforceTunerAccessPermission("releaseLnb"); enforceTrmAccessPermission("releaseLnb"); - if (DEBUG) { - Slog.d(TAG, "releaseLnb(lnbId=" + lnbId + ")"); + if (!validateResourceHandle(TunerResourceManager.TUNER_RESOURCE_TYPE_LNB, lnbHandle)) { + throw new RemoteException("lnbHandle can't be invalid"); + } + synchronized (mLock) { + releaseLnbInternal(getResourceIdFromHandle(lnbHandle)); } } @@ -393,7 +410,6 @@ public class TunerResourceManagerService extends SystemService { } } - // TODO check if the removing resource is in use or not. Handle the conflict. for (int removingId : updatingFrontendIds) { // update the exclusive group id member list removeFrontendResource(removingId); @@ -401,6 +417,38 @@ public class TunerResourceManagerService extends SystemService { } @VisibleForTesting + protected void setLnbInfoListInternal(int[] lnbIds) { + if (DEBUG) { + for (int i = 0; i < lnbIds.length; i++) { + Slog.d(TAG, "updateLnbInfo(lnbId=" + lnbIds[i] + ")"); + } + } + + // A set to record the Lnbs pending on updating. Ids will be removed + // from this set once its updating finished. Any lnb left in this set when all + // the updates are done will be removed from mLnbResources. + Set<Integer> updatingLnbIds = new HashSet<>(getLnbResources().keySet()); + + // Update lnbResources map and other mappings accordingly + for (int i = 0; i < lnbIds.length; i++) { + if (getLnbResource(lnbIds[i]) != null) { + if (DEBUG) { + Slog.d(TAG, "Lnb id=" + lnbIds[i] + "exists."); + } + updatingLnbIds.remove(lnbIds[i]); + } else { + // Add a new lnb resource + LnbResource newLnb = new LnbResource.Builder(lnbIds[i]).build(); + addLnbResource(newLnb); + } + } + + for (int removingId : updatingLnbIds) { + removeLnbResource(removingId); + } + } + + @VisibleForTesting protected boolean requestFrontendInternal(TunerFrontendRequest request, int[] frontendHandle) throws RemoteException { if (DEBUG) { @@ -454,8 +502,8 @@ public class TunerResourceManagerService extends SystemService { if (inUseLowestPriorityFrId > -1 && (requestClient.getPriority() > currentLowestPriority)) { frontendHandle[0] = generateResourceHandle( TunerResourceManager.TUNER_RESOURCE_TYPE_FRONTEND, inUseLowestPriorityFrId); - reclaimFrontendResource(getFrontendResource( - inUseLowestPriorityFrId).getOwnerClientId()); + reclaimResource(getFrontendResource(inUseLowestPriorityFrId).getOwnerClientId(), + TunerResourceManager.TUNER_RESOURCE_TYPE_FRONTEND); updateFrontendClientMappingOnNewGrant(inUseLowestPriorityFrId, request.getClientId()); return true; } @@ -464,6 +512,78 @@ public class TunerResourceManagerService extends SystemService { } @VisibleForTesting + protected boolean requestLnbInternal(TunerLnbRequest request, int[] lnbHandle) + throws RemoteException { + if (DEBUG) { + Slog.d(TAG, "requestLnb(request=" + request + ")"); + } + + lnbHandle[0] = TunerResourceManager.INVALID_RESOURCE_HANDLE; + if (!checkClientExists(request.getClientId())) { + Slog.e(TAG, "Request lnb from unregistered client:" + request.getClientId()); + return false; + } + ClientProfile requestClient = getClientProfile(request.getClientId()); + int grantingLnbId = -1; + int inUseLowestPriorityLnbId = -1; + // Priority max value is 1000 + int currentLowestPriority = MAX_CLIENT_PRIORITY + 1; + for (LnbResource lnb : getLnbResources().values()) { + if (!lnb.isInUse()) { + // Grant the unused lnb with lower id first + grantingLnbId = lnb.getId(); + break; + } else { + // Record the lnb id with the lowest client priority among all the + // in use lnb when no available lnb has been found. + int priority = getOwnerClientPriority(lnb); + if (currentLowestPriority > priority) { + inUseLowestPriorityLnbId = lnb.getId(); + currentLowestPriority = priority; + } + } + } + + // Grant Lnb when there is unused resource. + if (grantingLnbId > -1) { + lnbHandle[0] = generateResourceHandle( + TunerResourceManager.TUNER_RESOURCE_TYPE_LNB, grantingLnbId); + updateLnbClientMappingOnNewGrant(grantingLnbId, request.getClientId()); + return true; + } + + // When all the resources are occupied, grant the lowest priority resource if the + // request client has higher priority. + if (inUseLowestPriorityLnbId > -1 + && (requestClient.getPriority() > currentLowestPriority)) { + lnbHandle[0] = generateResourceHandle( + TunerResourceManager.TUNER_RESOURCE_TYPE_LNB, inUseLowestPriorityLnbId); + reclaimResource(getLnbResource(inUseLowestPriorityLnbId).getOwnerClientId(), + TunerResourceManager.TUNER_RESOURCE_TYPE_LNB); + updateLnbClientMappingOnNewGrant(inUseLowestPriorityLnbId, request.getClientId()); + return true; + } + + return false; + } + + @VisibleForTesting + void releaseFrontendInternal(int frontendId) { + if (DEBUG) { + Slog.d(TAG, "releaseFrontend(id=" + frontendId + ")"); + } + updateFrontendClientMappingOnRelease(frontendId); + } + + @VisibleForTesting + void releaseLnbInternal(int lnbId) { + if (DEBUG) { + Slog.d(TAG, "releaseLnb(lnbId=" + lnbId + ")"); + } + updateLnbClientMappingOnRelease(lnbId); + } + + @VisibleForTesting boolean requestDemuxInternal(TunerDemuxRequest request, int[] demuxHandle) { if (DEBUG) { Slog.d(TAG, "requestDemux(request=" + request + ")"); @@ -530,12 +650,18 @@ public class TunerResourceManagerService extends SystemService { } @VisibleForTesting - protected void reclaimFrontendResource(int reclaimingId) { + protected void reclaimResource(int reclaimingId, + @TunerResourceManager.TunerResourceType int resourceType) { + if (DEBUG) { + Slog.d(TAG, "Reclaiming resources because higher priority client request resource type " + + resourceType); + } try { mListeners.get(reclaimingId).getListener().onReclaimResources(); } catch (RemoteException e) { Slog.e(TAG, "Failed to reclaim resources on client " + reclaimingId, e); } + // TODO clean all the client and resources mapping/ownership } @VisibleForTesting @@ -568,14 +694,39 @@ public class TunerResourceManagerService extends SystemService { } } + private void updateFrontendClientMappingOnRelease(int frontendId) { + FrontendResource releasingFrontend = getFrontendResource(frontendId); + ClientProfile ownerProfile = getClientProfile(releasingFrontend.getOwnerClientId()); + releasingFrontend.removeOwner(); + ownerProfile.releaseFrontend(frontendId); + for (int exclusiveGroupMember : releasingFrontend.getExclusiveGroupMemberFeIds()) { + getFrontendResource(exclusiveGroupMember).removeOwner(); + ownerProfile.releaseFrontend(exclusiveGroupMember); + } + } + + private void updateLnbClientMappingOnNewGrant(int grantingId, int ownerClientId) { + LnbResource grantingLnb = getLnbResource(grantingId); + ClientProfile ownerProfile = getClientProfile(ownerClientId); + grantingLnb.setOwner(ownerClientId); + ownerProfile.useLnb(grantingId); + } + + private void updateLnbClientMappingOnRelease(int lnbId) { + LnbResource releasingLnb = getLnbResource(lnbId); + ClientProfile ownerProfile = getClientProfile(releasingLnb.getOwnerClientId()); + releasingLnb.removeOwner(); + ownerProfile.releaseLnb(lnbId); + } + /** - * Get the owner client's priority from the frontend id. + * Get the owner client's priority from the resource id. * - * @param frontend an in use frontend. - * @return the priority of the owner client of the frontend. + * @param resource a in use tuner resource. + * @return the priority of the owner client of the resource. */ - private int getOwnerClientPriority(FrontendResource frontend) { - return getClientProfile(frontend.getOwnerClientId()).getPriority(); + private int getOwnerClientPriority(TunerResourceBasic resource) { + return getClientProfile(resource.getOwnerClientId()).getPriority(); } @VisibleForTesting @@ -609,6 +760,9 @@ public class TunerResourceManagerService extends SystemService { private void removeFrontendResource(int removingId) { FrontendResource fe = getFrontendResource(removingId); + if (fe.isInUse()) { + releaseFrontendInternal(removingId); + } for (int excGroupmemberFeId : fe.getExclusiveGroupMemberFeIds()) { getFrontendResource(excGroupmemberFeId) .removeExclusiveGroupMemberFeId(fe.getId()); @@ -618,6 +772,30 @@ public class TunerResourceManagerService extends SystemService { @VisibleForTesting @Nullable + protected LnbResource getLnbResource(int lnbId) { + return mLnbResources.get(lnbId); + } + + @VisibleForTesting + protected Map<Integer, LnbResource> getLnbResources() { + return mLnbResources; + } + + private void addLnbResource(LnbResource newLnb) { + // Update resource list and available id list + mLnbResources.put(newLnb.getId(), newLnb); + } + + private void removeLnbResource(int removingId) { + LnbResource lnb = getLnbResource(removingId); + if (lnb.isInUse()) { + releaseLnbInternal(removingId); + } + mLnbResources.remove(removingId); + } + + @VisibleForTesting + @Nullable protected ClientProfile getClientProfile(int clientId) { return mClientProfiles.get(clientId); } @@ -651,6 +829,22 @@ public class TunerResourceManagerService extends SystemService { | (mResourceRequestCount++ & 0xffff); } + @VisibleForTesting + protected int getResourceIdFromHandle(int resourceHandle) { + if (resourceHandle == TunerResourceManager.INVALID_RESOURCE_HANDLE) { + return resourceHandle; + } + return (resourceHandle & 0x00ff0000) >> 16; + } + + private boolean validateResourceHandle(int resourceType, int resourceHandle) { + if (resourceHandle == TunerResourceManager.INVALID_RESOURCE_HANDLE + || ((resourceHandle & 0xff000000) >> 24) != resourceType) { + return false; + } + return true; + } + private void enforceTrmAccessPermission(String apiName) { getContext().enforceCallingPermission("android.permission.TUNER_RESOURCE_ACCESS", TAG + ": " + apiName); diff --git a/services/core/java/com/android/server/wm/AccessibilityController.java b/services/core/java/com/android/server/wm/AccessibilityController.java index 4fe58433ddb6..3f9f95cf8370 100644 --- a/services/core/java/com/android/server/wm/AccessibilityController.java +++ b/services/core/java/com/android/server/wm/AccessibilityController.java @@ -726,8 +726,7 @@ final class AccessibilityController { } else { final Region dirtyRegion = mTempRegion3; dirtyRegion.set(mMagnificationRegion); - dirtyRegion.op(mOldMagnificationRegion, Region.Op.UNION); - dirtyRegion.op(nonMagnifiedBounds, Region.Op.INTERSECT); + dirtyRegion.op(mOldMagnificationRegion, Region.Op.XOR); dirtyRegion.getBounds(dirtyRect); mWindow.invalidate(dirtyRect); } diff --git a/services/core/java/com/android/server/wm/ActivityRecord.java b/services/core/java/com/android/server/wm/ActivityRecord.java index 521ffa50f869..a03beee3a32f 100644 --- a/services/core/java/com/android/server/wm/ActivityRecord.java +++ b/services/core/java/com/android/server/wm/ActivityRecord.java @@ -292,6 +292,7 @@ import android.view.SurfaceControl.Transaction; import android.view.WindowManager; import android.view.WindowManager.LayoutParams; import android.view.animation.Animation; +import android.window.WindowContainerToken; import com.android.internal.R; import com.android.internal.annotations.VisibleForTesting; @@ -432,6 +433,8 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A final boolean stateNotNeeded; // As per ActivityInfo.flags @VisibleForTesting int mHandoverLaunchDisplayId = INVALID_DISPLAY; // Handover launch display id to next activity. + @VisibleForTesting + TaskDisplayArea mHandoverTaskDisplayArea; // Handover launch task display area. private final boolean componentSpecified; // did caller specify an explicit component? final boolean rootVoiceInteraction; // was this the root activity of a voice interaction? @@ -1657,7 +1660,11 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A if (usageReport != null) { appTimeTracker = new AppTimeTracker(usageReport); } - // Gets launch display id from options. It returns INVALID_DISPLAY if not set. + // Gets launch task display area and display id from options. Returns + // null/INVALID_DISPLAY if not set. + final WindowContainerToken daToken = options.getLaunchTaskDisplayArea(); + mHandoverTaskDisplayArea = daToken != null + ? (TaskDisplayArea) WindowContainer.fromBinder(daToken.asBinder()) : null; mHandoverLaunchDisplayId = options.getLaunchDisplayId(); } } diff --git a/services/core/java/com/android/server/wm/ActivityStackSupervisor.java b/services/core/java/com/android/server/wm/ActivityStackSupervisor.java index 3bcccedb6de5..fe9e5f3ca09e 100644 --- a/services/core/java/com/android/server/wm/ActivityStackSupervisor.java +++ b/services/core/java/com/android/server/wm/ActivityStackSupervisor.java @@ -1053,6 +1053,13 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { return true; } + /** Check if caller is allowed to launch activities on specified task display area. */ + boolean isCallerAllowedToLaunchOnTaskDisplayArea(int callingPid, int callingUid, + TaskDisplayArea taskDisplayArea, ActivityInfo aInfo) { + return isCallerAllowedToLaunchOnDisplay(callingPid, callingUid, + taskDisplayArea != null ? taskDisplayArea.getDisplayId() : DEFAULT_DISPLAY, aInfo); + } + /** Check if caller is allowed to launch activities on specified display. */ boolean isCallerAllowedToLaunchOnDisplay(int callingPid, int callingUid, int launchDisplayId, ActivityInfo aInfo) { @@ -2133,18 +2140,6 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { WindowManagerService.WINDOW_FREEZE_TIMEOUT_DURATION); } - // TODO(b/152116619): Remove after complete switch to TaskDisplayArea - void handleNonResizableTaskIfNeeded(Task task, int preferredWindowingMode, - int preferredDisplayId, ActivityStack actualStack) { - final DisplayContent preferredDisplayContent = mRootWindowContainer - .getDisplayContent(preferredDisplayId); - final TaskDisplayArea preferredDisplayArea = preferredDisplayContent != null - ? preferredDisplayContent.getDefaultTaskDisplayArea() - : null; - handleNonResizableTaskIfNeeded(task, preferredWindowingMode, preferredDisplayArea, - actualStack); - } - void handleNonResizableTaskIfNeeded(Task task, int preferredWindowingMode, TaskDisplayArea preferredTaskDisplayArea, ActivityStack actualStack) { handleNonResizableTaskIfNeeded(task, preferredWindowingMode, preferredTaskDisplayArea, diff --git a/services/core/java/com/android/server/wm/ActivityStartController.java b/services/core/java/com/android/server/wm/ActivityStartController.java index ad54356bced6..7fad395fb51d 100644 --- a/services/core/java/com/android/server/wm/ActivityStartController.java +++ b/services/core/java/com/android/server/wm/ActivityStartController.java @@ -184,8 +184,8 @@ public class ActivityStartController { } final int displayId = taskDisplayArea.getDisplayId(); options.setLaunchDisplayId(displayId); - // TODO(b/152116619): Enable after complete switch to WindowContainerToken - //options.setLaunchWindowContainerToken(taskDisplayArea.getWindowContainerToken()); + options.setLaunchTaskDisplayArea(taskDisplayArea.mRemoteToken + .toWindowContainerToken()); // The home activity will be started later, defer resuming to avoid unneccerary operations // (e.g. start home recursively) when creating home stack. diff --git a/services/core/java/com/android/server/wm/ActivityStarter.java b/services/core/java/com/android/server/wm/ActivityStarter.java index 0bd1aca4030a..0754a348740b 100644 --- a/services/core/java/com/android/server/wm/ActivityStarter.java +++ b/services/core/java/com/android/server/wm/ActivityStarter.java @@ -55,7 +55,6 @@ import static android.content.pm.ActivityInfo.LAUNCH_SINGLE_TOP; import static android.content.pm.PackageManager.PERMISSION_GRANTED; import static android.os.Process.INVALID_UID; import static android.view.Display.DEFAULT_DISPLAY; -import static android.view.Display.INVALID_DISPLAY; import static com.android.server.wm.ActivityStack.ActivityState.RESUMED; import static com.android.server.wm.ActivityStackSupervisor.DEFER_RESUME; @@ -167,8 +166,8 @@ class ActivityStarter { private int mStartFlags; private ActivityRecord mSourceRecord; - // The display to launch the activity onto, barring any strong reason to do otherwise. - private int mPreferredDisplayId; + // The task display area to launch the activity onto, barring any strong reason to do otherwise. + private TaskDisplayArea mPreferredTaskDisplayArea; // The windowing mode to apply to the root task, if possible private int mPreferredWindowingMode; @@ -538,7 +537,7 @@ class ActivityStarter { mDoResume = starter.mDoResume; mStartFlags = starter.mStartFlags; mSourceRecord = starter.mSourceRecord; - mPreferredDisplayId = starter.mPreferredDisplayId; + mPreferredTaskDisplayArea = starter.mPreferredTaskDisplayArea; mPreferredWindowingMode = starter.mPreferredWindowingMode; mInTask = starter.mInTask; @@ -1631,7 +1630,7 @@ class ActivityStarter { // Update the recent tasks list immediately when the activity starts mSupervisor.mRecentTasks.add(mStartActivity.getTask()); mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTask(), - mPreferredWindowingMode, mPreferredDisplayId, mTargetStack); + mPreferredWindowingMode, mPreferredTaskDisplayArea, mTargetStack); return START_SUCCESS; } @@ -1684,9 +1683,9 @@ class ActivityStarter { mSupervisor.getLaunchParamsController().calculate(targetTask, r.info.windowLayout, r, sourceRecord, mOptions, PHASE_BOUNDS, mLaunchParams); - mPreferredDisplayId = mLaunchParams.hasPreferredDisplay() - ? mLaunchParams.mPreferredDisplayId - : DEFAULT_DISPLAY; + mPreferredTaskDisplayArea = mLaunchParams.hasPreferredTaskDisplayArea() + ? mLaunchParams.mPreferredTaskDisplayArea + : mRootWindowContainer.getDefaultTaskDisplayArea(); mPreferredWindowingMode = mLaunchParams.mWindowingMode; } @@ -1703,10 +1702,12 @@ class ActivityStarter { // Do not start home activity if it cannot be launched on preferred display. We are not // doing this in ActivityStackSupervisor#canPlaceEntityOnDisplay because it might // fallback to launch on other displays. - if (r.isActivityTypeHome() && !mRootWindowContainer.canStartHomeOnDisplay(r.info, - mPreferredDisplayId, true /* allowInstrumenting */)) { - Slog.w(TAG, "Cannot launch home on display " + mPreferredDisplayId); - return START_CANCELED; + if (r.isActivityTypeHome()) { + if (!mRootWindowContainer.canStartHomeOnDisplayArea(r.info, mPreferredTaskDisplayArea, + true /* allowInstrumenting */)) { + Slog.w(TAG, "Cannot launch home on display area " + mPreferredTaskDisplayArea); + return START_CANCELED; + } } if (mRestrictedBgActivity && (newTask || !targetTask.isUidPresent(mCallingUid)) @@ -1841,10 +1842,10 @@ class ActivityStarter { && top.attachedToProcess() && ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0 || isLaunchModeOneOf(LAUNCH_SINGLE_TOP, LAUNCH_SINGLE_TASK)) - // This allows home activity to automatically launch on secondary display when - // display added, if home was the top activity on default display, instead of - // sending new intent to the home activity on default display. - && (!top.isActivityTypeHome() || top.getDisplayId() == mPreferredDisplayId); + // This allows home activity to automatically launch on secondary task display area + // when it was added, if home was the top activity on default task display area, + // instead of sending new intent to the home activity on default display area. + && (!top.isActivityTypeHome() || top.getDisplayArea() == mPreferredTaskDisplayArea); if (!dontStart) { return START_SUCCESS; } @@ -1866,7 +1867,7 @@ class ActivityStarter { // Don't use mStartActivity.task to show the toast. We're not starting a new activity but // reusing 'top'. Fields in mStartActivity may not be fully initialized. mSupervisor.handleNonResizableTaskIfNeeded(top.getTask(), - mLaunchParams.mWindowingMode, mPreferredDisplayId, topStack); + mLaunchParams.mWindowingMode, mPreferredTaskDisplayArea, topStack); return START_DELIVERED_TO_TOP; } @@ -2010,7 +2011,7 @@ class ActivityStarter { mDoResume = false; mStartFlags = 0; mSourceRecord = null; - mPreferredDisplayId = INVALID_DISPLAY; + mPreferredTaskDisplayArea = null; mPreferredWindowingMode = WINDOWING_MODE_UNDEFINED; mInTask = null; @@ -2060,9 +2061,9 @@ class ActivityStarter { // after we located a reusable task (which might be resided in another display). mSupervisor.getLaunchParamsController().calculate(inTask, r.info.windowLayout, r, sourceRecord, options, PHASE_DISPLAY, mLaunchParams); - mPreferredDisplayId = mLaunchParams.hasPreferredDisplay() - ? mLaunchParams.mPreferredDisplayId - : DEFAULT_DISPLAY; + mPreferredTaskDisplayArea = mLaunchParams.hasPreferredTaskDisplayArea() + ? mLaunchParams.mPreferredTaskDisplayArea + : mRootWindowContainer.getDefaultTaskDisplayArea(); mPreferredWindowingMode = mLaunchParams.mWindowingMode; mLaunchMode = r.launchMode; @@ -2334,14 +2335,14 @@ class ActivityStarter { } else { // Otherwise find the best task to put the activity in. intentActivity = - mRootWindowContainer.findTask(mStartActivity, mPreferredDisplayId); + mRootWindowContainer.findTask(mStartActivity, mPreferredTaskDisplayArea); } } if (intentActivity != null && (mStartActivity.isActivityTypeHome() || intentActivity.isActivityTypeHome()) - && intentActivity.getDisplayId() != mPreferredDisplayId) { - // Do not reuse home activity on other displays. + && intentActivity.getDisplayArea() != mPreferredTaskDisplayArea) { + // Do not reuse home activity on other display areas. intentActivity = null; } @@ -2363,7 +2364,7 @@ class ActivityStarter { // the same behavior as if a new instance was being started, which means not bringing it // to the front if the caller is not itself in the front. final boolean differentTopTask; - if (mPreferredDisplayId == mTargetStack.getDisplayId()) { + if (mTargetStack.getDisplayArea() == mPreferredTaskDisplayArea) { final ActivityStack focusStack = mTargetStack.getDisplay().getFocusedStack(); final ActivityRecord curTop = (focusStack == null) ? null : focusStack.topRunningNonDelayedActivityLocked(mNotTop); diff --git a/services/core/java/com/android/server/wm/LaunchParamsController.java b/services/core/java/com/android/server/wm/LaunchParamsController.java index a9820ef1c081..4cd31806f99d 100644 --- a/services/core/java/com/android/server/wm/LaunchParamsController.java +++ b/services/core/java/com/android/server/wm/LaunchParamsController.java @@ -17,7 +17,6 @@ package com.android.server.wm; import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED; -import static android.view.Display.DEFAULT_DISPLAY; import static android.view.Display.INVALID_DISPLAY; import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.PHASE_BOUNDS; @@ -26,6 +25,7 @@ import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier. import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.RESULT_SKIP; import android.annotation.IntDef; +import android.annotation.Nullable; import android.app.ActivityOptions; import android.content.pm.ActivityInfo.WindowLayout; import android.graphics.Rect; @@ -108,11 +108,13 @@ class LaunchParamsController { if (activity != null && activity.requestedVrComponent != null) { // Check if the Activity is a VR activity. If so, it should be launched in main display. - result.mPreferredDisplayId = DEFAULT_DISPLAY; + result.mPreferredTaskDisplayArea = mService.mRootWindowContainer + .getDefaultTaskDisplayArea(); } else if (mService.mVr2dDisplayId != INVALID_DISPLAY) { // Get the virtual display ID from ActivityTaskManagerService. If that's set we // should always use that. - result.mPreferredDisplayId = mService.mVr2dDisplayId; + result.mPreferredTaskDisplayArea = mService.mRootWindowContainer + .getDisplayContent(mService.mVr2dDisplayId).getDefaultTaskDisplayArea(); } } @@ -136,9 +138,10 @@ class LaunchParamsController { mService.deferWindowLayout(); try { - if (mTmpParams.hasPreferredDisplay() - && mTmpParams.mPreferredDisplayId != task.getStack().getDisplay().mDisplayId) { - mService.moveStackToDisplay(task.getRootTaskId(), mTmpParams.mPreferredDisplayId); + if (mTmpParams.mPreferredTaskDisplayArea != null + && task.getDisplayArea() != mTmpParams.mPreferredTaskDisplayArea) { + mService.mRootWindowContainer.moveStackToTaskDisplayArea(task.getRootTaskId(), + mTmpParams.mPreferredTaskDisplayArea, true /* onTop */); } if (mTmpParams.hasWindowingMode() @@ -184,8 +187,9 @@ class LaunchParamsController { /** The bounds within the parent container. */ final Rect mBounds = new Rect(); - /** The id of the display the {@link Task} would prefer to be on. */ - int mPreferredDisplayId; + /** The display area the {@link Task} would prefer to be on. */ + @Nullable + TaskDisplayArea mPreferredTaskDisplayArea; /** The windowing mode to be in. */ int mWindowingMode; @@ -193,20 +197,20 @@ class LaunchParamsController { /** Sets values back to default. {@link #isEmpty} will return {@code true} once called. */ void reset() { mBounds.setEmpty(); - mPreferredDisplayId = INVALID_DISPLAY; + mPreferredTaskDisplayArea = null; mWindowingMode = WINDOWING_MODE_UNDEFINED; } /** Copies the values set on the passed in {@link LaunchParams}. */ void set(LaunchParams params) { mBounds.set(params.mBounds); - mPreferredDisplayId = params.mPreferredDisplayId; + mPreferredTaskDisplayArea = params.mPreferredTaskDisplayArea; mWindowingMode = params.mWindowingMode; } /** Returns {@code true} if no values have been explicitly set. */ boolean isEmpty() { - return mBounds.isEmpty() && mPreferredDisplayId == INVALID_DISPLAY + return mBounds.isEmpty() && mPreferredTaskDisplayArea == null && mWindowingMode == WINDOWING_MODE_UNDEFINED; } @@ -214,8 +218,8 @@ class LaunchParamsController { return mWindowingMode != WINDOWING_MODE_UNDEFINED; } - boolean hasPreferredDisplay() { - return mPreferredDisplayId != INVALID_DISPLAY; + boolean hasPreferredTaskDisplayArea() { + return mPreferredTaskDisplayArea != null; } @Override @@ -225,7 +229,7 @@ class LaunchParamsController { LaunchParams that = (LaunchParams) o; - if (mPreferredDisplayId != that.mPreferredDisplayId) return false; + if (mPreferredTaskDisplayArea != that.mPreferredTaskDisplayArea) return false; if (mWindowingMode != that.mWindowingMode) return false; return mBounds != null ? mBounds.equals(that.mBounds) : that.mBounds == null; } @@ -233,7 +237,8 @@ class LaunchParamsController { @Override public int hashCode() { int result = mBounds != null ? mBounds.hashCode() : 0; - result = 31 * result + mPreferredDisplayId; + result = 31 * result + (mPreferredTaskDisplayArea != null + ? mPreferredTaskDisplayArea.hashCode() : 0); result = 31 * result + mWindowingMode; return result; } diff --git a/services/core/java/com/android/server/wm/LaunchParamsPersister.java b/services/core/java/com/android/server/wm/LaunchParamsPersister.java index 9371c0eec26f..a974332fd852 100644 --- a/services/core/java/com/android/server/wm/LaunchParamsPersister.java +++ b/services/core/java/com/android/server/wm/LaunchParamsPersister.java @@ -318,7 +318,9 @@ class LaunchParamsPersister { final DisplayContent display = mSupervisor.mRootWindowContainer.getDisplayContent( persistableParams.mDisplayUniqueId); if (display != null) { - outParams.mPreferredDisplayId = display.mDisplayId; + // TODO(b/153764726): Investigate if task display area needs to be persisted vs + // always choosing the default one. + outParams.mPreferredTaskDisplayArea = display.getDefaultTaskDisplayArea(); } outParams.mWindowingMode = persistableParams.mWindowingMode; outParams.mBounds.set(persistableParams.mBounds); diff --git a/services/core/java/com/android/server/wm/RootWindowContainer.java b/services/core/java/com/android/server/wm/RootWindowContainer.java index e8f7ba550bd8..6b9054bde868 100644 --- a/services/core/java/com/android/server/wm/RootWindowContainer.java +++ b/services/core/java/com/android/server/wm/RootWindowContainer.java @@ -139,6 +139,7 @@ import android.view.Display; import android.view.DisplayInfo; import android.view.SurfaceControl; import android.view.WindowManager; +import android.window.WindowContainerToken; import com.android.internal.annotations.VisibleForTesting; import com.android.internal.app.ResolverActivity; @@ -1519,8 +1520,7 @@ class RootWindowContainer extends WindowContainer<DisplayContent> if (taskDisplayArea == getDefaultTaskDisplayArea()) { homeIntent = mService.getHomeIntent(); aInfo = resolveHomeActivity(userId, homeIntent); - } else if (taskDisplayArea.getDisplayId() == DEFAULT_DISPLAY - || shouldPlaceSecondaryHomeOnDisplay(taskDisplayArea.getDisplayId())) { + } else if (shouldPlaceSecondaryHomeOnDisplayArea(taskDisplayArea)) { Pair<ActivityInfo, Intent> info = resolveSecondaryHomeActivity(userId, taskDisplayArea); aInfo = info.first; homeIntent = info.second; @@ -1529,7 +1529,7 @@ class RootWindowContainer extends WindowContainer<DisplayContent> return false; } - if (!canStartHomeOnDisplay(aInfo, taskDisplayArea.getDisplayId(), allowInstrumenting)) { + if (!canStartHomeOnDisplayArea(aInfo, taskDisplayArea, allowInstrumenting)) { return false; } @@ -1625,8 +1625,7 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } if (aInfo != null) { - if (!canStartHomeOnDisplay(aInfo, taskDisplayArea.getDisplayId(), - false /* allowInstrumenting */)) { + if (!canStartHomeOnDisplayArea(aInfo, taskDisplayArea, false /* allowInstrumenting */)) { aInfo = null; } } @@ -1683,19 +1682,19 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } /** - * Check if the display is valid for secondary home activity. - * @param displayId The id of the target display. + * Check if the display area is valid for secondary home activity. + * @param taskDisplayArea The target display area. * @return {@code true} if allow to launch, {@code false} otherwise. */ - boolean shouldPlaceSecondaryHomeOnDisplay(int displayId) { - if (displayId == DEFAULT_DISPLAY) { + boolean shouldPlaceSecondaryHomeOnDisplayArea(TaskDisplayArea taskDisplayArea) { + if (getDefaultTaskDisplayArea() == taskDisplayArea) { throw new IllegalArgumentException( - "shouldPlaceSecondaryHomeOnDisplay: Should not be DEFAULT_DISPLAY"); - } else if (displayId == INVALID_DISPLAY) { + "shouldPlaceSecondaryHomeOnDisplay: Should not be on default task container"); + } else if (taskDisplayArea == null) { return false; } - if (!mService.mSupportsMultiDisplay) { + if (taskDisplayArea.getDisplayId() != DEFAULT_DISPLAY && !mService.mSupportsMultiDisplay) { // Can't launch home on secondary display if device does not support multi-display. return false; } @@ -1704,16 +1703,16 @@ class RootWindowContainer extends WindowContainer<DisplayContent> mService.mContext.getContentResolver(), Settings.Global.DEVICE_PROVISIONED, 0) != 0; if (!deviceProvisioned) { - // Can't launch home on secondary display before device is provisioned. + // Can't launch home on secondary display areas before device is provisioned. return false; } if (!StorageManager.isUserKeyUnlocked(mCurrentUser)) { - // Can't launch home on secondary displays if device is still locked. + // Can't launch home on secondary display areas if device is still locked. return false; } - final DisplayContent display = getDisplayContent(displayId); + final DisplayContent display = taskDisplayArea.getDisplayContent(); if (display == null || display.isRemoved() || !display.supportsSystemDecorations()) { // Can't launch home on display that doesn't support system decorations. return false; @@ -1725,11 +1724,11 @@ class RootWindowContainer extends WindowContainer<DisplayContent> /** * Check if home activity start should be allowed on a display. * @param homeInfo {@code ActivityInfo} of the home activity that is going to be launched. - * @param displayId The id of the target display. + * @param taskDisplayArea The target display area. * @param allowInstrumenting Whether launching home should be allowed if being instrumented. * @return {@code true} if allow to launch, {@code false} otherwise. */ - boolean canStartHomeOnDisplay(ActivityInfo homeInfo, int displayId, + boolean canStartHomeOnDisplayArea(ActivityInfo homeInfo, TaskDisplayArea taskDisplayArea, boolean allowInstrumenting) { if (mService.mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL && mService.mTopAction == null) { @@ -1745,13 +1744,15 @@ class RootWindowContainer extends WindowContainer<DisplayContent> return false; } + final int displayId = taskDisplayArea != null ? taskDisplayArea.getDisplayId() + : INVALID_DISPLAY; if (displayId == DEFAULT_DISPLAY || (displayId != INVALID_DISPLAY && displayId == mService.mVr2dDisplayId)) { // No restrictions to default display or vr 2d display. return true; } - if (!shouldPlaceSecondaryHomeOnDisplay(displayId)) { + if (!shouldPlaceSecondaryHomeOnDisplayArea(taskDisplayArea)) { return false; } @@ -2208,15 +2209,14 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } } - ActivityRecord findTask(ActivityRecord r, int preferredDisplayId) { + ActivityRecord findTask(ActivityRecord r, TaskDisplayArea preferredTaskDisplayArea) { if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Looking for task of " + r); mTmpFindTaskResult.clear(); - // Looking up task on preferred display first - final DisplayContent preferredDisplay = getDisplayContent(preferredDisplayId); - if (preferredDisplay != null) { - preferredDisplay.getDefaultTaskDisplayArea().findTaskLocked(r, - true /* isPreferredDisplay */, mTmpFindTaskResult); + // Looking up task on preferred display area first + if (preferredTaskDisplayArea != null) { + preferredTaskDisplayArea.findTaskLocked(r, true /* isPreferredDisplay */, + mTmpFindTaskResult); if (mTmpFindTaskResult.mIdealMatch) { return mTmpFindTaskResult.mRecord; } @@ -2224,14 +2224,17 @@ class RootWindowContainer extends WindowContainer<DisplayContent> for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) { final DisplayContent display = getChildAt(displayNdx); - if (display.mDisplayId == preferredDisplayId) { - continue; - } + for (int tdaNdx = display.getTaskDisplayAreaCount() - 1; tdaNdx >= 0; --tdaNdx) { + final TaskDisplayArea taskDisplayArea = display.getTaskDisplayAreaAt(tdaNdx); + if (taskDisplayArea == preferredTaskDisplayArea) { + continue; + } - display.getDefaultTaskDisplayArea().findTaskLocked(r, false /* isPreferredDisplay */, - mTmpFindTaskResult); - if (mTmpFindTaskResult.mIdealMatch) { - return mTmpFindTaskResult.mRecord; + taskDisplayArea.findTaskLocked(r, false /* isPreferredDisplay */, + mTmpFindTaskResult); + if (mTmpFindTaskResult.mIdealMatch) { + return mTmpFindTaskResult.mRecord; + } } } @@ -2823,11 +2826,15 @@ class RootWindowContainer extends WindowContainer<DisplayContent> int realCallingUid) { int taskId = INVALID_TASK_ID; int displayId = INVALID_DISPLAY; + TaskDisplayArea taskDisplayArea = null; // We give preference to the launch preference in activity options. if (options != null) { taskId = options.getLaunchTaskId(); displayId = options.getLaunchDisplayId(); + final WindowContainerToken daToken = options.getLaunchTaskDisplayArea(); + taskDisplayArea = daToken != null + ? (TaskDisplayArea) WindowContainer.fromBinder(daToken.asBinder()) : null; } // First preference for stack goes to the task Id set in the activity options. Use the stack @@ -2846,30 +2853,34 @@ class RootWindowContainer extends WindowContainer<DisplayContent> final int activityType = resolveActivityType(r, options, candidateTask); ActivityStack stack = null; - // Next preference for stack goes to the display Id set the candidate display. - if (launchParams != null && launchParams.mPreferredDisplayId != INVALID_DISPLAY) { - displayId = launchParams.mPreferredDisplayId; - } - final boolean canLaunchOnDisplayFromStartRequest = - realCallingPid != 0 && realCallingUid > 0 && r != null - && mStackSupervisor.canPlaceEntityOnDisplay(displayId, realCallingPid, - realCallingUid, r.info); - // Checking if the activity's launch caller, or the realCallerId of the activity from - // start request (i.e. entity that invokes PendingIntent) is allowed to launch on the - // display. - if (displayId != INVALID_DISPLAY && (canLaunchOnDisplay(r, displayId) - || canLaunchOnDisplayFromStartRequest)) { - if (r != null) { - stack = getValidLaunchStackOnDisplay(displayId, r, candidateTask, options, - launchParams); - if (stack != null) { - return stack; - } + // Next preference for stack goes to the taskDisplayArea candidate. + if (launchParams != null && launchParams.mPreferredTaskDisplayArea != null) { + taskDisplayArea = launchParams.mPreferredTaskDisplayArea; + } + + if (taskDisplayArea == null && displayId != INVALID_DISPLAY) { + final DisplayContent displayContent = getDisplayContent(displayId); + if (displayContent != null) { + taskDisplayArea = displayContent.getDefaultTaskDisplayArea(); } - final DisplayContent display = getDisplayContentOrCreate(displayId); - if (display != null) { + } + + if (taskDisplayArea != null) { + final int tdaDisplayId = taskDisplayArea.getDisplayId(); + final boolean canLaunchOnDisplayFromStartRequest = + realCallingPid != 0 && realCallingUid > 0 && r != null + && mStackSupervisor.canPlaceEntityOnDisplay(tdaDisplayId, + realCallingPid, realCallingUid, r.info); + if (canLaunchOnDisplayFromStartRequest || canLaunchOnDisplay(r, tdaDisplayId)) { + if (r != null) { + final ActivityStack result = getValidLaunchStackInTaskDisplayArea( + taskDisplayArea, r, candidateTask, options, launchParams); + if (result != null) { + return result; + } + } // Falling back to default task container - final TaskDisplayArea taskDisplayArea = display.getDefaultTaskDisplayArea(); + taskDisplayArea = taskDisplayArea.mDisplayContent.getDefaultTaskDisplayArea(); stack = taskDisplayArea.getOrCreateStack(r, options, candidateTask, activityType, onTop); if (stack != null) { @@ -2936,40 +2947,37 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } /** - * Get a topmost stack on the display, that is a valid launch stack for specified activity. + * Get a topmost stack on the display area, that is a valid launch stack for specified activity. * If there is no such stack, new dynamic stack can be created. - * @param displayId Target display. + * @param taskDisplayArea Target display area. * @param r Activity that should be launched there. * @param candidateTask The possible task the activity might be put in. * @return Existing stack if there is a valid one, new dynamic stack if it is valid or null. */ @VisibleForTesting - ActivityStack getValidLaunchStackOnDisplay(int displayId, @NonNull ActivityRecord r, - @Nullable Task candidateTask, @Nullable ActivityOptions options, + ActivityStack getValidLaunchStackInTaskDisplayArea(@NonNull TaskDisplayArea taskDisplayArea, + @NonNull ActivityRecord r, @Nullable Task candidateTask, + @Nullable ActivityOptions options, @Nullable LaunchParamsController.LaunchParams launchParams) { - final DisplayContent displayContent = getDisplayContentOrCreate(displayId); - if (displayContent == null) { - throw new IllegalArgumentException( - "Display with displayId=" + displayId + " not found."); - } - - if (!r.canBeLaunchedOnDisplay(displayId)) { + if (!r.canBeLaunchedOnDisplay(taskDisplayArea.getDisplayId())) { return null; } - // If {@code r} is already in target display and its task is the same as the candidate task, - // the intention should be getting a launch stack for the reusable activity, so we can use - // the existing stack. + // If {@code r} is already in target display area and its task is the same as the candidate + // task, the intention should be getting a launch stack for the reusable activity, so we can + // use the existing stack. if (candidateTask != null && (r.getTask() == null || r.getTask() == candidateTask)) { - final int attachedDisplayId = r.getDisplayId(); - if (attachedDisplayId == INVALID_DISPLAY || attachedDisplayId == displayId) { + // TODO(b/153920825): Fix incorrect evaluation of attached state + final TaskDisplayArea attachedTaskDisplayArea = r.getTask() != null + ? r.getTask().getDisplayArea() : r.getDisplayArea(); + if (attachedTaskDisplayArea == null || attachedTaskDisplayArea == taskDisplayArea) { return candidateTask.getStack(); } // Or the candidate task is already a root task that can be reused by reparenting // it to the target display. if (candidateTask.isRootTask()) { final ActivityStack stack = candidateTask.getStack(); - stack.reparent(displayContent.getDefaultTaskDisplayArea(), true /* onTop */); + stack.reparent(taskDisplayArea, true /* onTop */); return stack; } } @@ -2984,39 +2992,30 @@ class RootWindowContainer extends WindowContainer<DisplayContent> windowingMode = options != null ? options.getLaunchWindowingMode() : r.getWindowingMode(); } + windowingMode = taskDisplayArea.validateWindowingMode(windowingMode, r, candidateTask, + r.getActivityType()); // Return the topmost valid stack on the display. - for (int tdaNdx = displayContent.getTaskDisplayAreaCount() - 1; tdaNdx >= 0; --tdaNdx) { - final TaskDisplayArea taskDisplayArea = displayContent.getTaskDisplayAreaAt(tdaNdx); - final int validatedWindowingMode = taskDisplayArea - .validateWindowingMode(windowingMode, r, candidateTask, r.getActivityType()); - for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) { - final ActivityStack stack = taskDisplayArea.getStackAt(sNdx); - if (isValidLaunchStack(stack, r, validatedWindowingMode)) { - return stack; - } + for (int i = taskDisplayArea.getStackCount() - 1; i >= 0; --i) { + final ActivityStack stack = taskDisplayArea.getStackAt(i); + if (isValidLaunchStack(stack, r, windowingMode)) { + return stack; } } - // If there is no valid stack on the external display - check if new dynamic stack will do. - if (displayId != DEFAULT_DISPLAY) { + // If there is no valid stack on the secondary display area - check if new dynamic stack + // will do. + if (taskDisplayArea != getDisplayContent(taskDisplayArea.getDisplayId()) + .getDefaultTaskDisplayArea()) { final int activityType = options != null && options.getLaunchActivityType() != ACTIVITY_TYPE_UNDEFINED ? options.getLaunchActivityType() : r.getActivityType(); - final TaskDisplayArea taskDisplayArea = displayContent.getDefaultTaskDisplayArea(); return taskDisplayArea.createStack(windowingMode, activityType, true /*onTop*/); } return null; } - ActivityStack getValidLaunchStackOnDisplay(int displayId, @NonNull ActivityRecord r, - @Nullable ActivityOptions options, - @Nullable LaunchParamsController.LaunchParams launchParams) { - return getValidLaunchStackOnDisplay(displayId, r, null /* candidateTask */, options, - launchParams); - } - // TODO: Can probably be consolidated into getLaunchStack()... private boolean isValidLaunchStack(ActivityStack stack, ActivityRecord r, int windowingMode) { switch (stack.getActivityType()) { diff --git a/services/core/java/com/android/server/wm/SafeActivityOptions.java b/services/core/java/com/android/server/wm/SafeActivityOptions.java index a7b53688dbdc..b71ecbb8a72d 100644 --- a/services/core/java/com/android/server/wm/SafeActivityOptions.java +++ b/services/core/java/com/android/server/wm/SafeActivityOptions.java @@ -18,10 +18,11 @@ package com.android.server.wm; import static android.Manifest.permission.CONTROL_REMOTE_APP_TRANSITION_ANIMATIONS; import static android.Manifest.permission.START_TASKS_FROM_RECENTS; +import static android.app.ActivityTaskManager.INVALID_TASK_ID; import static android.content.pm.PackageManager.PERMISSION_DENIED; import static android.content.pm.PackageManager.PERMISSION_GRANTED; import static android.view.Display.INVALID_DISPLAY; -import static android.app.ActivityTaskManager.INVALID_TASK_ID; + import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM; import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME; @@ -36,6 +37,7 @@ import android.os.Process; import android.os.UserHandle; import android.util.Slog; import android.view.RemoteAnimationAdapter; +import android.window.WindowContainerToken; import com.android.internal.annotations.VisibleForTesting; @@ -206,8 +208,20 @@ public class SafeActivityOptions { throw new SecurityException(msg); } } - // Check if someone tries to launch an activity on a private display with a different - // owner. + // Check if the caller is allowed to launch on the specified display area. + final WindowContainerToken daToken = options.getLaunchTaskDisplayArea(); + final TaskDisplayArea taskDisplayArea = daToken != null + ? (TaskDisplayArea) WindowContainer.fromBinder(daToken.asBinder()) : null; + if (aInfo != null && taskDisplayArea != null + && !supervisor.isCallerAllowedToLaunchOnTaskDisplayArea(callingPid, callingUid, + taskDisplayArea, aInfo)) { + final String msg = "Permission Denial: starting " + getIntentString(intent) + + " from " + callerApp + " (pid=" + callingPid + + ", uid=" + callingUid + ") with launchTaskDisplayArea=" + taskDisplayArea; + Slog.w(TAG, msg); + throw new SecurityException(msg); + } + // Check if the caller is allowed to launch on the specified display. final int launchDisplayId = options.getLaunchDisplayId(); if (aInfo != null && launchDisplayId != INVALID_DISPLAY && !supervisor.isCallerAllowedToLaunchOnDisplay(callingPid, callingUid, diff --git a/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java b/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java index da4401a68e7c..11c20b6d9133 100644 --- a/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java +++ b/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java @@ -48,6 +48,7 @@ import android.graphics.Rect; import android.util.Slog; import android.view.Gravity; import android.view.View; +import android.window.WindowContainerToken; import com.android.internal.annotations.VisibleForTesting; import com.android.server.wm.LaunchParamsController.LaunchParams; @@ -134,13 +135,15 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { return RESULT_SKIP; } - // STEP 1: Determine the display to launch the activity/task. - final int displayId = getPreferredLaunchDisplay(task, options, source, currentParams); - outParams.mPreferredDisplayId = displayId; - DisplayContent display = mSupervisor.mRootWindowContainer.getDisplayContent(displayId); + // STEP 1: Determine the display area to launch the activity/task. + final TaskDisplayArea taskDisplayArea = getPreferredLaunchTaskDisplayArea(task, + options, source, currentParams); + outParams.mPreferredTaskDisplayArea = taskDisplayArea; + // TODO(b/152116619): Update the usages of display to use taskDisplayArea below. + final DisplayContent display = taskDisplayArea.mDisplayContent; if (DEBUG) { - appendLog("display-id=" + outParams.mPreferredDisplayId + " display-windowing-mode=" - + display.getWindowingMode()); + appendLog("task-display-area=" + outParams.mPreferredTaskDisplayArea + + " display-area-windowing-mode=" + taskDisplayArea.getWindowingMode()); } if (phase == PHASE_DISPLAY) { @@ -210,8 +213,8 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { // layout and display conditions are not contradictory to their suggestions. It's important // to carry over their values because LaunchParamsController doesn't automatically do that. if (!currentParams.isEmpty() && !hasInitialBounds - && (!currentParams.hasPreferredDisplay() - || displayId == currentParams.mPreferredDisplayId)) { + && (currentParams.mPreferredTaskDisplayArea == null + || currentParams.mPreferredTaskDisplayArea == taskDisplayArea)) { // Only set windowing mode if display is in freeform. If the display is in fullscreen // mode we should only launch a task in fullscreen mode. if (currentParams.hasWindowingMode() && display.inFreeformWindowingMode()) { @@ -270,19 +273,19 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { : display.getWindowingMode(); if (fullyResolvedCurrentParam) { if (resolvedMode == WINDOWING_MODE_FREEFORM) { - // Make sure bounds are in the display if it's possibly in a different display. - if (currentParams.mPreferredDisplayId != displayId) { + // Make sure bounds are in the display if it's possibly in a different display/area. + if (currentParams.mPreferredTaskDisplayArea != taskDisplayArea) { adjustBoundsToFitInDisplay(display, outParams.mBounds); } // Even though we want to keep original bounds, we still don't want it to stomp on // an existing task. adjustBoundsToAvoidConflictInDisplay(display, outParams.mBounds); } - } else if (display.inFreeformWindowingMode()) { + } else if (taskDisplayArea.inFreeformWindowingMode()) { if (source != null && source.inFreeformWindowingMode() && resolvedMode == WINDOWING_MODE_FREEFORM && outParams.mBounds.isEmpty() - && source.getDisplayId() == display.getDisplayId()) { + && source.getDisplayArea() == taskDisplayArea) { // Set bounds to be not very far from source activity. cascadeBounds(source.getConfiguration().windowConfiguration.getBounds(), display, outParams.mBounds); @@ -293,54 +296,87 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { return RESULT_CONTINUE; } - private int getPreferredLaunchDisplay(@Nullable Task task, + private TaskDisplayArea getPreferredLaunchTaskDisplayArea(@Nullable Task task, @Nullable ActivityOptions options, ActivityRecord source, LaunchParams currentParams) { - if (!mSupervisor.mService.mSupportsMultiDisplay) { - return DEFAULT_DISPLAY; - } - - int displayId = INVALID_DISPLAY; - final int optionLaunchId = options != null ? options.getLaunchDisplayId() : INVALID_DISPLAY; - if (optionLaunchId != INVALID_DISPLAY) { - if (DEBUG) appendLog("display-from-option=" + optionLaunchId); - displayId = optionLaunchId; + TaskDisplayArea taskDisplayArea = null; + + final WindowContainerToken optionLaunchTaskDisplayAreaToken = options != null + ? options.getLaunchTaskDisplayArea() : null; + if (optionLaunchTaskDisplayAreaToken != null) { + taskDisplayArea = (TaskDisplayArea) WindowContainer.fromBinder( + optionLaunchTaskDisplayAreaToken.asBinder()); + if (DEBUG) appendLog("display-area-from-option=" + taskDisplayArea); + } + + // If task display area is not specified in options - try display id + if (taskDisplayArea == null) { + final int optionLaunchId = + options != null ? options.getLaunchDisplayId() : INVALID_DISPLAY; + if (optionLaunchId != INVALID_DISPLAY) { + final DisplayContent dc = mSupervisor.mRootWindowContainer + .getDisplayContent(optionLaunchId); + if (dc != null) { + taskDisplayArea = dc.getDefaultTaskDisplayArea(); + if (DEBUG) appendLog("display-from-option=" + optionLaunchId); + } + } } - // If the source activity is a no-display activity, pass on the launch display id from - // source activity as currently preferred. - if (displayId == INVALID_DISPLAY && source != null && source.noDisplay) { - displayId = source.mHandoverLaunchDisplayId; - if (DEBUG) appendLog("display-from-no-display-source=" + displayId); + // If the source activity is a no-display activity, pass on the launch display area token + // from source activity as currently preferred. + if (taskDisplayArea == null && source != null + && source.noDisplay) { + taskDisplayArea = source.mHandoverTaskDisplayArea; + if (taskDisplayArea != null) { + if (DEBUG) appendLog("display-area-from-no-display-source=" + taskDisplayArea); + } else { + // Try handover display id + final int displayId = source.mHandoverLaunchDisplayId; + final DisplayContent dc = + mSupervisor.mRootWindowContainer.getDisplayContent(displayId); + if (dc != null) { + taskDisplayArea = dc.getDefaultTaskDisplayArea(); + if (DEBUG) appendLog("display-from-no-display-source=" + displayId); + } + } } - ActivityStack stack = - (displayId == INVALID_DISPLAY && task != null) ? task.getStack() : null; + ActivityStack stack = (taskDisplayArea == null && task != null) + ? task.getStack() : null; if (stack != null) { if (DEBUG) appendLog("display-from-task=" + stack.getDisplayId()); - displayId = stack.getDisplayId(); + taskDisplayArea = stack.getDisplayArea(); } - if (displayId == INVALID_DISPLAY && source != null) { - final int sourceDisplayId = source.getDisplayId(); - if (DEBUG) appendLog("display-from-source=" + sourceDisplayId); - displayId = sourceDisplayId; + if (taskDisplayArea == null && source != null) { + final TaskDisplayArea sourceDisplayArea = source.getDisplayArea(); + if (DEBUG) appendLog("display-area-from-source=" + sourceDisplayArea); + taskDisplayArea = sourceDisplayArea; } - if (displayId == INVALID_DISPLAY && options != null) { + if (taskDisplayArea == null && options != null) { final int callerDisplayId = options.getCallerDisplayId(); - if (DEBUG) appendLog("display-from-caller=" + callerDisplayId); - displayId = callerDisplayId; + final DisplayContent dc = + mSupervisor.mRootWindowContainer.getDisplayContent(callerDisplayId); + if (dc != null) { + taskDisplayArea = dc.getDefaultTaskDisplayArea(); + if (DEBUG) appendLog("display-from-caller=" + callerDisplayId); + } + } + + if (taskDisplayArea == null) { + taskDisplayArea = currentParams.mPreferredTaskDisplayArea; } - if (displayId != INVALID_DISPLAY - && mSupervisor.mRootWindowContainer.getDisplayContent(displayId) == null) { - displayId = currentParams.mPreferredDisplayId; + // Fallback to default display if the device didn't declare support for multi-display + if (taskDisplayArea != null && !mSupervisor.mService.mSupportsMultiDisplay + && taskDisplayArea.getDisplayId() != DEFAULT_DISPLAY) { + taskDisplayArea = mSupervisor.mRootWindowContainer.getDefaultTaskDisplayArea(); } - displayId = (displayId == INVALID_DISPLAY) ? currentParams.mPreferredDisplayId : displayId; - return (displayId != INVALID_DISPLAY - && mSupervisor.mRootWindowContainer.getDisplayContent(displayId) != null) - ? displayId : DEFAULT_DISPLAY; + return (taskDisplayArea != null) + ? taskDisplayArea + : mSupervisor.mRootWindowContainer.getDefaultTaskDisplayArea(); } private boolean canInheritWindowingModeFromSource(@NonNull DisplayContent display, diff --git a/services/tests/servicestests/src/com/android/server/om/TEST_MAPPING b/services/tests/servicestests/src/com/android/server/om/TEST_MAPPING new file mode 100644 index 000000000000..8070bd1f06a1 --- /dev/null +++ b/services/tests/servicestests/src/com/android/server/om/TEST_MAPPING @@ -0,0 +1,12 @@ +{ + "presubmit": [ + { + "name": "FrameworksServicesTests", + "options": [ + { + "include-filter": "com.android.server.om." + } + ] + } + ] +}
\ No newline at end of file diff --git a/services/tests/servicestests/src/com/android/server/tv/tunerresourcemanager/TunerResourceManagerServiceTest.java b/services/tests/servicestests/src/com/android/server/tv/tunerresourcemanager/TunerResourceManagerServiceTest.java index fcbd5072ae35..b9a33df497e4 100644 --- a/services/tests/servicestests/src/com/android/server/tv/tunerresourcemanager/TunerResourceManagerServiceTest.java +++ b/services/tests/servicestests/src/com/android/server/tv/tunerresourcemanager/TunerResourceManagerServiceTest.java @@ -32,6 +32,7 @@ import android.media.tv.tunerresourcemanager.TunerDemuxRequest; import android.media.tv.tunerresourcemanager.TunerDescramblerRequest; import android.media.tv.tunerresourcemanager.TunerFrontendInfo; import android.media.tv.tunerresourcemanager.TunerFrontendRequest; +import android.media.tv.tunerresourcemanager.TunerLnbRequest; import android.media.tv.tunerresourcemanager.TunerResourceManager; import android.os.RemoteException; import android.platform.test.annotations.Presubmit; @@ -96,13 +97,6 @@ public class TunerResourceManagerServiceTest { } }; - private static int getResourceIdFromHandle(int resourceHandle) { - if (resourceHandle == TunerResourceManager.INVALID_RESOURCE_HANDLE) { - return resourceHandle; - } - return (resourceHandle & 0x00ff0000) >> 16; - } - @Before public void setUp() throws Exception { MockitoAnnotations.initMocks(this); @@ -247,7 +241,7 @@ public class TunerResourceManagerServiceTest { } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } - assertThat(getResourceIdFromHandle(frontendHandle[0])) + assertThat(mTunerResourceManagerService.getResourceIdFromHandle(frontendHandle[0])) .isEqualTo(TunerResourceManager.INVALID_RESOURCE_HANDLE); } @@ -275,7 +269,7 @@ public class TunerResourceManagerServiceTest { } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } - assertThat(getResourceIdFromHandle(frontendHandle[0])) + assertThat(mTunerResourceManagerService.getResourceIdFromHandle(frontendHandle[0])) .isEqualTo(TunerResourceManager.INVALID_RESOURCE_HANDLE); } @@ -307,7 +301,8 @@ public class TunerResourceManagerServiceTest { } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } - assertThat(getResourceIdFromHandle(frontendHandle[0])).isEqualTo(0); + assertThat(mTunerResourceManagerService.getResourceIdFromHandle(frontendHandle[0])) + .isEqualTo(0); } @Test @@ -344,7 +339,8 @@ public class TunerResourceManagerServiceTest { } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } - assertThat(getResourceIdFromHandle(frontendHandle[0])).isEqualTo(infos[0].getId()); + assertThat(mTunerResourceManagerService.getResourceIdFromHandle(frontendHandle[0])) + .isEqualTo(infos[0].getId()); request = new TunerFrontendRequest(clientId0[0] /*clientId*/, FrontendSettings.TYPE_DVBT); @@ -354,7 +350,8 @@ public class TunerResourceManagerServiceTest { } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } - assertThat(getResourceIdFromHandle(frontendHandle[0])).isEqualTo(infos[1].getId()); + assertThat(mTunerResourceManagerService.getResourceIdFromHandle(frontendHandle[0])) + .isEqualTo(infos[1].getId()); assertThat(mTunerResourceManagerService.getFrontendResource(infos[1].getId()) .isInUse()).isTrue(); assertThat(mTunerResourceManagerService.getFrontendResource(infos[2].getId()) @@ -464,7 +461,8 @@ public class TunerResourceManagerServiceTest { } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } - assertThat(getResourceIdFromHandle(frontendHandle[0])).isEqualTo(infos[0].getId()); + assertThat(mTunerResourceManagerService.getResourceIdFromHandle(frontendHandle[0])) + .isEqualTo(infos[0].getId()); request = new TunerFrontendRequest(clientId1[0] /*clientId*/, FrontendSettings.TYPE_DVBS); @@ -474,7 +472,8 @@ public class TunerResourceManagerServiceTest { } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } - assertThat(getResourceIdFromHandle(frontendHandle[0])).isEqualTo(infos[1].getId()); + assertThat(mTunerResourceManagerService.getResourceIdFromHandle(frontendHandle[0])) + .isEqualTo(infos[1].getId()); assertThat(mTunerResourceManagerService.getFrontendResource(infos[0].getId()) .isInUse()).isTrue(); assertThat(mTunerResourceManagerService.getFrontendResource(infos[1].getId()) @@ -487,6 +486,137 @@ public class TunerResourceManagerServiceTest { } @Test + public void releaseFrontendTest_UnderTheSameExclusiveGroup() { + // Register clients + ResourceClientProfile[] profiles = new ResourceClientProfile[1]; + profiles[0] = new ResourceClientProfile("0" /*sessionId*/, + TvInputService.PRIORITY_HINT_USE_CASE_TYPE_PLAYBACK); + int[] clientId = new int[1]; + TestResourcesReclaimListener listener = new TestResourcesReclaimListener(); + mTunerResourceManagerService.registerClientProfileInternal(profiles[0], listener, clientId); + assertThat(clientId[0]).isNotEqualTo(TunerResourceManagerService.INVALID_CLIENT_ID); + + // Init frontend resources. + TunerFrontendInfo[] infos = new TunerFrontendInfo[2]; + infos[0] = + new TunerFrontendInfo(0 /*id*/, FrontendSettings.TYPE_DVBT, 1 /*exclusiveGroupId*/); + infos[1] = + new TunerFrontendInfo(1 /*id*/, FrontendSettings.TYPE_DVBS, 1 /*exclusiveGroupId*/); + mTunerResourceManagerService.setFrontendInfoListInternal(infos); + + TunerFrontendRequest request = + new TunerFrontendRequest(clientId[0] /*clientId*/, FrontendSettings.TYPE_DVBT); + int[] frontendHandle = new int[1]; + try { + assertThat(mTunerResourceManagerService + .requestFrontendInternal(request, frontendHandle)).isTrue(); + } catch (RemoteException e) { + throw e.rethrowFromSystemServer(); + } + int frontendId = mTunerResourceManagerService.getResourceIdFromHandle(frontendHandle[0]); + assertThat(frontendId).isEqualTo(infos[0].getId()); + assertThat(mTunerResourceManagerService + .getFrontendResource(infos[1].getId()).isInUse()).isTrue(); + + // Release frontend + mTunerResourceManagerService.releaseFrontendInternal(frontendId); + assertThat(mTunerResourceManagerService + .getFrontendResource(frontendId).isInUse()).isFalse(); + assertThat(mTunerResourceManagerService + .getFrontendResource(infos[1].getId()).isInUse()).isFalse(); + assertThat(mTunerResourceManagerService + .getClientProfile(clientId[0]).getInUseFrontendIds().size()).isEqualTo(0); + } + + @Test + public void requestLnbTest_NoLnbAvailable_RequestWithHigherPriority() { + // Register clients + ResourceClientProfile[] profiles = new ResourceClientProfile[2]; + profiles[0] = new ResourceClientProfile("0" /*sessionId*/, + TvInputService.PRIORITY_HINT_USE_CASE_TYPE_PLAYBACK); + profiles[1] = new ResourceClientProfile("1" /*sessionId*/, + TvInputService.PRIORITY_HINT_USE_CASE_TYPE_PLAYBACK); + int[] clientPriorities = {100, 500}; + int[] clientId0 = new int[1]; + int[] clientId1 = new int[1]; + TestResourcesReclaimListener listener = new TestResourcesReclaimListener(); + mTunerResourceManagerService.registerClientProfileInternal( + profiles[0], listener, clientId0); + assertThat(clientId0[0]).isNotEqualTo(TunerResourceManagerService.INVALID_CLIENT_ID); + mTunerResourceManagerService.getClientProfile(clientId0[0]) + .setPriority(clientPriorities[0]); + mTunerResourceManagerService.registerClientProfileInternal( + profiles[1], new TestResourcesReclaimListener(), clientId1); + assertThat(clientId1[0]).isNotEqualTo(TunerResourceManagerService.INVALID_CLIENT_ID); + mTunerResourceManagerService.getClientProfile(clientId1[0]) + .setPriority(clientPriorities[1]); + + // Init lnb resources. + int[] lnbIds = {0}; + mTunerResourceManagerService.setLnbInfoListInternal(lnbIds); + + TunerLnbRequest request = new TunerLnbRequest(clientId0[0]); + int[] lnbHandle = new int[1]; + try { + assertThat(mTunerResourceManagerService + .requestLnbInternal(request, lnbHandle)).isTrue(); + } catch (RemoteException e) { + throw e.rethrowFromSystemServer(); + } + assertThat(mTunerResourceManagerService.getResourceIdFromHandle(lnbHandle[0])) + .isEqualTo(lnbIds[0]); + + request = new TunerLnbRequest(clientId1[0]); + try { + assertThat(mTunerResourceManagerService + .requestLnbInternal(request, lnbHandle)).isTrue(); + } catch (RemoteException e) { + throw e.rethrowFromSystemServer(); + } + assertThat(mTunerResourceManagerService.getResourceIdFromHandle(lnbHandle[0])) + .isEqualTo(lnbIds[0]); + assertThat(mTunerResourceManagerService.getLnbResource(lnbIds[0]) + .isInUse()).isTrue(); + assertThat(mTunerResourceManagerService.getLnbResource(lnbIds[0]) + .getOwnerClientId()).isEqualTo(clientId1[0]); + assertThat(listener.isRelaimed()).isTrue(); + } + + @Test + public void releaseLnbTest() { + // Register clients + ResourceClientProfile[] profiles = new ResourceClientProfile[1]; + profiles[0] = new ResourceClientProfile("0" /*sessionId*/, + TvInputService.PRIORITY_HINT_USE_CASE_TYPE_PLAYBACK); + int[] clientId = new int[1]; + TestResourcesReclaimListener listener = new TestResourcesReclaimListener(); + mTunerResourceManagerService.registerClientProfileInternal(profiles[0], listener, clientId); + assertThat(clientId[0]).isNotEqualTo(TunerResourceManagerService.INVALID_CLIENT_ID); + + // Init lnb resources. + int[] lnbIds = {0}; + mTunerResourceManagerService.setLnbInfoListInternal(lnbIds); + + TunerLnbRequest request = new TunerLnbRequest(clientId[0]); + int[] lnbHandle = new int[1]; + try { + assertThat(mTunerResourceManagerService + .requestLnbInternal(request, lnbHandle)).isTrue(); + } catch (RemoteException e) { + throw e.rethrowFromSystemServer(); + } + int lnbId = mTunerResourceManagerService.getResourceIdFromHandle(lnbHandle[0]); + assertThat(lnbId).isEqualTo(lnbIds[0]); + + // Release lnb + mTunerResourceManagerService.releaseLnbInternal(lnbId); + assertThat(mTunerResourceManagerService + .getLnbResource(lnbId).isInUse()).isFalse(); + assertThat(mTunerResourceManagerService + .getClientProfile(clientId[0]).getInUseLnbIds().size()).isEqualTo(0); + } + + @Test public void unregisterClientTest_usingFrontend() { // Register client ResourceClientProfile profile = new ResourceClientProfile("0" /*sessionId*/, @@ -513,7 +643,8 @@ public class TunerResourceManagerServiceTest { } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } - assertThat(getResourceIdFromHandle(frontendHandle[0])).isEqualTo(infos[0].getId()); + assertThat(mTunerResourceManagerService.getResourceIdFromHandle(frontendHandle[0])) + .isEqualTo(infos[0].getId()); assertThat(mTunerResourceManagerService.getFrontendResource(infos[0].getId()) .isInUse()).isTrue(); assertThat(mTunerResourceManagerService.getFrontendResource(infos[1].getId()) @@ -543,7 +674,8 @@ public class TunerResourceManagerServiceTest { TunerDemuxRequest request = new TunerDemuxRequest(clientId[0]); assertThat(mTunerResourceManagerService.requestDemuxInternal(request, demuxHandle)) .isTrue(); - assertThat(getResourceIdFromHandle(demuxHandle[0])).isEqualTo(0); + assertThat(mTunerResourceManagerService.getResourceIdFromHandle(demuxHandle[0])) + .isEqualTo(0); } @Test @@ -560,6 +692,6 @@ public class TunerResourceManagerServiceTest { TunerDescramblerRequest request = new TunerDescramblerRequest(clientId[0]); assertThat(mTunerResourceManagerService.requestDescramblerInternal(request, desHandle)) .isTrue(); - assertThat(getResourceIdFromHandle(desHandle[0])).isEqualTo(0); + assertThat(mTunerResourceManagerService.getResourceIdFromHandle(desHandle[0])).isEqualTo(0); } } diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java index 97734ff32de2..a84a0a2260b2 100644 --- a/services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java @@ -426,7 +426,7 @@ public class ActivityStarterTests extends ActivityTestsBase { // Start activity and delivered new intent. starter.getIntent().setComponent(splitSecondReusableActivity.mActivityComponent); - doReturn(splitSecondReusableActivity).when(mRootWindowContainer).findTask(any(), anyInt()); + doReturn(splitSecondReusableActivity).when(mRootWindowContainer).findTask(any(), any()); final int result = starter.setReason("testSplitScreenDeliverToTop").execute(); // Ensure result is delivering intent to top. @@ -462,7 +462,7 @@ public class ActivityStarterTests extends ActivityTestsBase { // Start activity and delivered new intent. starter.getIntent().setComponent(splitSecondReusableActivity.mActivityComponent); - doReturn(splitSecondReusableActivity).when(mRootWindowContainer).findTask(any(), anyInt()); + doReturn(splitSecondReusableActivity).when(mRootWindowContainer).findTask(any(), any()); final int result = starter.setReason("testSplitScreenMoveToFront").execute(); // Ensure result is moving task to front. diff --git a/services/tests/wmtests/src/com/android/server/wm/LaunchParamsControllerTests.java b/services/tests/wmtests/src/com/android/server/wm/LaunchParamsControllerTests.java index 8a9504dd11b5..61de7d83fa1a 100644 --- a/services/tests/wmtests/src/com/android/server/wm/LaunchParamsControllerTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/LaunchParamsControllerTests.java @@ -19,7 +19,6 @@ package com.android.server.wm; import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM; import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN; import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED; -import static android.view.Display.DEFAULT_DISPLAY; import static android.view.Display.INVALID_DISPLAY; import static com.android.dx.mockito.inline.extended.ExtendedMockito.any; @@ -112,7 +111,7 @@ public class LaunchParamsControllerTests extends ActivityTestsBase { final ActivityRecord activity = new ActivityBuilder(mService).setComponent(name) .setUid(userId).build(); final LaunchParams expected = new LaunchParams(); - expected.mPreferredDisplayId = 3; + expected.mPreferredTaskDisplayArea = mock(TaskDisplayArea.class); expected.mWindowingMode = WINDOWING_MODE_PINNED; expected.mBounds.set(200, 300, 400, 500); @@ -183,7 +182,7 @@ public class LaunchParamsControllerTests extends ActivityTestsBase { final LaunchParams params = new LaunchParams(); params.mWindowingMode = WINDOWING_MODE_FREEFORM; params.mBounds.set(0, 0, 30, 20); - params.mPreferredDisplayId = 3; + params.mPreferredTaskDisplayArea = mock(TaskDisplayArea.class); final InstrumentedPositioner positioner2 = new InstrumentedPositioner(RESULT_CONTINUE, params); @@ -228,8 +227,8 @@ public class LaunchParamsControllerTests extends ActivityTestsBase { */ @Test public void testVrPreferredDisplay() { - final int vr2dDisplayId = 1; - mService.mVr2dDisplayId = vr2dDisplayId; + final TestDisplayContent vrDisplay = createNewDisplayContent(); + mService.mVr2dDisplayId = vrDisplay.mDisplayId; final LaunchParams result = new LaunchParams(); final ActivityRecord vrActivity = new ActivityBuilder(mService).build(); @@ -238,16 +237,17 @@ public class LaunchParamsControllerTests extends ActivityTestsBase { // VR activities should always land on default display. mController.calculate(null /*task*/, null /*layout*/, vrActivity /*activity*/, null /*source*/, null /*options*/, PHASE_BOUNDS, result); - assertEquals(DEFAULT_DISPLAY, result.mPreferredDisplayId); + assertEquals(mRootWindowContainer.getDefaultTaskDisplayArea(), + result.mPreferredTaskDisplayArea); // Otherwise, always lands on VR 2D display. final ActivityRecord vr2dActivity = new ActivityBuilder(mService).build(); mController.calculate(null /*task*/, null /*layout*/, vr2dActivity /*activity*/, null /*source*/, null /*options*/, PHASE_BOUNDS, result); - assertEquals(vr2dDisplayId, result.mPreferredDisplayId); + assertEquals(vrDisplay.getDefaultTaskDisplayArea(), result.mPreferredTaskDisplayArea); mController.calculate(null /*task*/, null /*layout*/, null /*activity*/, null /*source*/, null /*options*/, PHASE_BOUNDS, result); - assertEquals(vr2dDisplayId, result.mPreferredDisplayId); + assertEquals(vrDisplay.getDefaultTaskDisplayArea(), result.mPreferredTaskDisplayArea); mService.mVr2dDisplayId = INVALID_DISPLAY; } @@ -282,9 +282,7 @@ public class LaunchParamsControllerTests extends ActivityTestsBase { final LaunchParams params = new LaunchParams(); final TestDisplayContent display = createNewDisplayContent(); final TaskDisplayArea preferredTaskDisplayArea = display.getDefaultTaskDisplayArea(); - // TODO(b/152116619): Enable after complete switch to WindowContainerToken - //params.mPreferredWindowContainerToken = preferredTaskDisplayAreaToken; - params.mPreferredDisplayId = display.mDisplayId; + params.mPreferredTaskDisplayArea = preferredTaskDisplayArea; final InstrumentedPositioner positioner = new InstrumentedPositioner(RESULT_DONE, params); final Task task = new TaskBuilder(mService.mStackSupervisor).build(); @@ -433,7 +431,7 @@ public class LaunchParamsControllerTests extends ActivityTestsBase { void saveTask(Task task, DisplayContent display) { final int userId = task.mUserId; final ComponentName realActivity = task.realActivity; - mTmpParams.mPreferredDisplayId = task.getDisplayId(); + mTmpParams.mPreferredTaskDisplayArea = task.getDisplayArea(); mTmpParams.mWindowingMode = task.getWindowingMode(); if (task.mLastNonFullscreenBounds != null) { mTmpParams.mBounds.set(task.mLastNonFullscreenBounds); diff --git a/services/tests/wmtests/src/com/android/server/wm/LaunchParamsPersisterTests.java b/services/tests/wmtests/src/com/android/server/wm/LaunchParamsPersisterTests.java index 6a71a7dd24dd..9bf86d2c4704 100644 --- a/services/tests/wmtests/src/com/android/server/wm/LaunchParamsPersisterTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/LaunchParamsPersisterTests.java @@ -19,7 +19,6 @@ package com.android.server.wm; import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD; import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM; import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN; -import static android.view.Display.INVALID_DISPLAY; import static com.android.dx.mockito.inline.extended.ExtendedMockito.mock; import static com.android.dx.mockito.inline.extended.ExtendedMockito.verify; @@ -27,6 +26,7 @@ import static com.android.dx.mockito.inline.extended.ExtendedMockito.when; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Matchers.any; @@ -163,7 +163,7 @@ public class LaunchParamsPersisterTests extends ActivityTestsBase { mTarget.getLaunchParams(mTestTask, null, mResult); - assertEquals(mTestDisplay.mDisplayId, mResult.mPreferredDisplayId); + assertEquals(mTestDisplay.getDefaultTaskDisplayArea(), mResult.mPreferredTaskDisplayArea); assertEquals(TEST_WINDOWING_MODE, mResult.mWindowingMode); assertEquals(TEST_BOUNDS, mResult.mBounds); } @@ -177,7 +177,7 @@ public class LaunchParamsPersisterTests extends ActivityTestsBase { mTarget.getLaunchParams(null, activity, mResult); - assertEquals(mTestDisplay.mDisplayId, mResult.mPreferredDisplayId); + assertEquals(mTestDisplay.getDefaultTaskDisplayArea(), mResult.mPreferredTaskDisplayArea); assertEquals(TEST_WINDOWING_MODE, mResult.mWindowingMode); assertEquals(TEST_BOUNDS, mResult.mBounds); } @@ -190,7 +190,7 @@ public class LaunchParamsPersisterTests extends ActivityTestsBase { mTarget.getLaunchParams(mTestTask, null, mResult); - assertEquals(INVALID_DISPLAY, mResult.mPreferredDisplayId); + assertNull(mResult.mPreferredTaskDisplayArea); assertEquals(TEST_WINDOWING_MODE, mResult.mWindowingMode); assertEquals(TEST_BOUNDS, mResult.mBounds); } @@ -223,7 +223,7 @@ public class LaunchParamsPersisterTests extends ActivityTestsBase { mTaskWithDifferentComponent.mWindowLayoutAffinity = TEST_WINDOW_LAYOUT_AFFINITY; mTarget.getLaunchParams(mTaskWithDifferentComponent, null, mResult); - assertEquals(mTestDisplay.mDisplayId, mResult.mPreferredDisplayId); + assertEquals(mTestDisplay.getDefaultTaskDisplayArea(), mResult.mPreferredTaskDisplayArea); assertEquals(TEST_WINDOWING_MODE, mResult.mWindowingMode); assertEquals(TEST_BOUNDS, mResult.mBounds); } @@ -241,7 +241,7 @@ public class LaunchParamsPersisterTests extends ActivityTestsBase { mTarget.getLaunchParams(mTaskWithDifferentComponent, null, mResult); - assertEquals(mTestDisplay.mDisplayId, mResult.mPreferredDisplayId); + assertEquals(mTestDisplay.getDefaultTaskDisplayArea(), mResult.mPreferredTaskDisplayArea); assertEquals(TEST_WINDOWING_MODE, mResult.mWindowingMode); assertEquals(TEST_BOUNDS, mResult.mBounds); } @@ -282,7 +282,7 @@ public class LaunchParamsPersisterTests extends ActivityTestsBase { target.getLaunchParams(mTestTask, null, mResult); - assertEquals(mTestDisplay.mDisplayId, mResult.mPreferredDisplayId); + assertEquals(mTestDisplay.getDefaultTaskDisplayArea(), mResult.mPreferredTaskDisplayArea); assertEquals(TEST_WINDOWING_MODE, mResult.mWindowingMode); assertEquals(TEST_BOUNDS, mResult.mBounds); } @@ -301,7 +301,7 @@ public class LaunchParamsPersisterTests extends ActivityTestsBase { mTaskWithDifferentComponent.mWindowLayoutAffinity = TEST_WINDOW_LAYOUT_AFFINITY; target.getLaunchParams(mTaskWithDifferentComponent, null, mResult); - assertEquals(mTestDisplay.mDisplayId, mResult.mPreferredDisplayId); + assertEquals(mTestDisplay.getDefaultTaskDisplayArea(), mResult.mPreferredTaskDisplayArea); assertEquals(TEST_WINDOWING_MODE, mResult.mWindowingMode); assertEquals(TEST_BOUNDS, mResult.mBounds); } @@ -328,7 +328,7 @@ public class LaunchParamsPersisterTests extends ActivityTestsBase { target.getLaunchParams(mTaskWithDifferentComponent, null, mResult); - assertEquals(mTestDisplay.mDisplayId, mResult.mPreferredDisplayId); + assertEquals(mTestDisplay.getDefaultTaskDisplayArea(), mResult.mPreferredTaskDisplayArea); assertEquals(TEST_WINDOWING_MODE, mResult.mWindowingMode); assertEquals(TEST_BOUNDS, mResult.mBounds); } diff --git a/services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java b/services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java index 3c9051547eed..5dba00455913 100644 --- a/services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java @@ -537,8 +537,8 @@ public class RootActivityContainerTests extends ActivityTestsBase { doReturn(true).when(mRootWindowContainer) .ensureVisibilityAndConfig(any(), anyInt(), anyBoolean(), anyBoolean()); - doReturn(true).when(mRootWindowContainer).canStartHomeOnDisplay( - any(), anyInt(), anyBoolean()); + doReturn(true).when(mRootWindowContainer).canStartHomeOnDisplayArea(any(), any(), + anyBoolean()); mRootWindowContainer.startHomeOnAllDisplays(0, "testStartHome"); @@ -578,17 +578,19 @@ public class RootActivityContainerTests extends ActivityTestsBase { // Can not start home if we don't want to start home while home is being instrumented. doReturn(true).when(app).isInstrumenting(); - assertFalse(mRootWindowContainer.canStartHomeOnDisplay(info, DEFAULT_DISPLAY, + final TaskDisplayArea defaultTaskDisplayArea = mRootWindowContainer + .getDefaultTaskDisplayArea(); + assertFalse(mRootWindowContainer.canStartHomeOnDisplayArea(info, defaultTaskDisplayArea, false /* allowInstrumenting*/)); // Can start home for other cases. - assertTrue(mRootWindowContainer.canStartHomeOnDisplay(info, DEFAULT_DISPLAY, + assertTrue(mRootWindowContainer.canStartHomeOnDisplayArea(info, defaultTaskDisplayArea, true /* allowInstrumenting*/)); doReturn(false).when(app).isInstrumenting(); - assertTrue(mRootWindowContainer.canStartHomeOnDisplay(info, DEFAULT_DISPLAY, + assertTrue(mRootWindowContainer.canStartHomeOnDisplayArea(info, defaultTaskDisplayArea, false /* allowInstrumenting*/)); - assertTrue(mRootWindowContainer.canStartHomeOnDisplay(info, DEFAULT_DISPLAY, + assertTrue(mRootWindowContainer.canStartHomeOnDisplayArea(info, defaultTaskDisplayArea, true /* allowInstrumenting*/)); } @@ -694,8 +696,8 @@ public class RootActivityContainerTests extends ActivityTestsBase { resolutions.add(resolveInfo); doReturn(resolutions).when(mRootWindowContainer).resolveActivities(anyInt(), refEq(secondaryHomeIntent)); - doReturn(true).when(mRootWindowContainer).canStartHomeOnDisplay( - any(), anyInt(), anyBoolean()); + doReturn(true).when(mRootWindowContainer).canStartHomeOnDisplayArea(any(), any(), + anyBoolean()); // Run the test. final Pair<ActivityInfo, Intent> resolvedInfo = mRootWindowContainer @@ -747,8 +749,8 @@ public class RootActivityContainerTests extends ActivityTestsBase { resolutions.add(infoFake2); doReturn(resolutions).when(mRootWindowContainer).resolveActivities(anyInt(), any()); - doReturn(true).when(mRootWindowContainer).canStartHomeOnDisplay( - any(), anyInt(), anyBoolean()); + doReturn(true).when(mRootWindowContainer).canStartHomeOnDisplayArea(any(), any(), + anyBoolean()); // Run the test. final Pair<ActivityInfo, Intent> resolvedInfo = mRootWindowContainer @@ -781,8 +783,8 @@ public class RootActivityContainerTests extends ActivityTestsBase { resolutions.add(infoFake2); doReturn(resolutions).when(mRootWindowContainer).resolveActivities(anyInt(), any()); - doReturn(true).when(mRootWindowContainer).canStartHomeOnDisplay( - any(), anyInt(), anyBoolean()); + doReturn(true).when(mRootWindowContainer).canStartHomeOnDisplayArea(any(), any(), + anyBoolean()); // Use the first one of matched activities in the same package as selected primary home. final Pair<ActivityInfo, Intent> resolvedInfo = mRootWindowContainer @@ -836,8 +838,9 @@ public class RootActivityContainerTests extends ActivityTestsBase { .setTask(task).build(); // Make sure the root task is valid and can be reused on default display. - final ActivityStack stack = mRootWindowContainer.getValidLaunchStackOnDisplay( - DEFAULT_DISPLAY, activity, task, null, null); + final ActivityStack stack = mRootWindowContainer.getValidLaunchStackInTaskDisplayArea( + mRootWindowContainer.getDefaultTaskDisplayArea(), activity, task, null, + null); assertEquals(task, stack); } diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java b/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java index 1a38ff283477..a69231b9e03a 100644 --- a/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java @@ -30,6 +30,7 @@ import static android.util.DisplayMetrics.DENSITY_DEFAULT; import static android.view.Display.DEFAULT_DISPLAY; import static com.android.dx.mockito.inline.extended.ExtendedMockito.doNothing; +import static com.android.dx.mockito.inline.extended.ExtendedMockito.mock; import static com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn; import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.RESULT_CONTINUE; import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.RESULT_SKIP; @@ -44,7 +45,6 @@ import android.content.res.Configuration; import android.graphics.Rect; import android.os.Build; import android.platform.test.annotations.Presubmit; -import android.view.Display; import android.view.Gravity; import androidx.test.filters.SmallTest; @@ -106,53 +106,45 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { // Display ID Related Tests // ============================= @Test - public void testDefaultToPrimaryDisplay() { + public void testDefaultToPrimaryDisplayArea() { createNewDisplayContent(WINDOWING_MODE_FREEFORM); assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, mActivity, /* source */ null, /* options */ null, mCurrent, mResult)); - assertEquals(DEFAULT_DISPLAY, mResult.mPreferredDisplayId); + assertEquals(mRootWindowContainer.getDefaultTaskDisplayArea(), + mResult.mPreferredTaskDisplayArea); } @Test - public void testUsesDefaultDisplayIfPreviousDisplayNotExists() { - mCurrent.mPreferredDisplayId = 19; - - assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, - mActivity, /* source */ null, /* options */ null, mCurrent, mResult)); - - assertEquals(DEFAULT_DISPLAY, mResult.mPreferredDisplayId); - } - - @Test - public void testUsesPreviousDisplayIdIfSet() { + public void testUsesPreviousDisplayAreaIfSet() { createNewDisplayContent(WINDOWING_MODE_FREEFORM); final TestDisplayContent display = createNewDisplayContent(WINDOWING_MODE_FULLSCREEN); - mCurrent.mPreferredDisplayId = display.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = display.getDefaultTaskDisplayArea(); assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, mActivity, /* source */ null, /* options */ null, mCurrent, mResult)); - assertEquals(display.mDisplayId, mResult.mPreferredDisplayId); + assertEquals(display.getDefaultTaskDisplayArea(), mResult.mPreferredTaskDisplayArea); } @Test - public void testUsesSourcesDisplayIdIfSet() { + public void testUsesSourcesDisplayAreaIfSet() { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); final TestDisplayContent fullscreenDisplay = createNewDisplayContent( WINDOWING_MODE_FULLSCREEN); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); ActivityRecord source = createSourceActivity(fullscreenDisplay); assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, mActivity, source, /* options */ null, mCurrent, mResult)); - assertEquals(fullscreenDisplay.mDisplayId, mResult.mPreferredDisplayId); + assertEquals(fullscreenDisplay.getDefaultTaskDisplayArea(), + mResult.mPreferredTaskDisplayArea); } @Test @@ -162,7 +154,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent fullscreenDisplay = createNewDisplayContent( WINDOWING_MODE_FULLSCREEN); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); ActivityRecord source = createSourceActivity(freeformDisplay); ActivityOptions options = ActivityOptions.makeBasic(); @@ -171,28 +163,51 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, mActivity, source, options, mCurrent, mResult)); - assertEquals(fullscreenDisplay.mDisplayId, mResult.mPreferredDisplayId); + assertEquals(fullscreenDisplay.getDefaultTaskDisplayArea(), + mResult.mPreferredTaskDisplayArea); } @Test - public void testUsesTasksDisplayIdPriorToSourceIfSet() { + public void testUsesOptionsDisplayAreaTokenIfSet() { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); final TestDisplayContent fullscreenDisplay = createNewDisplayContent( WINDOWING_MODE_FULLSCREEN); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); + ActivityRecord source = createSourceActivity(freeformDisplay); + + ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchTaskDisplayArea(fullscreenDisplay.getDefaultTaskDisplayArea() + .mRemoteToken.toWindowContainerToken()); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, source, options, mCurrent, mResult)); + + assertEquals(fullscreenDisplay.getDefaultTaskDisplayArea(), + mResult.mPreferredTaskDisplayArea); + } + + @Test + public void testUsesTasksDisplayAreaIdPriorToSourceIfSet() { + final TestDisplayContent freeformDisplay = createNewDisplayContent( + WINDOWING_MODE_FREEFORM); + final TestDisplayContent fullscreenDisplay = createNewDisplayContent( + WINDOWING_MODE_FULLSCREEN); + + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); ActivityRecord reusableActivity = createSourceActivity(fullscreenDisplay); ActivityRecord source = createSourceActivity(freeformDisplay); assertEquals(RESULT_CONTINUE, mTarget.onCalculate(reusableActivity.getTask(), /* layout */ null, mActivity, source, /* options */ null, mCurrent, mResult)); - assertEquals(fullscreenDisplay.mDisplayId, mResult.mPreferredDisplayId); + assertEquals(fullscreenDisplay.getDefaultTaskDisplayArea(), + mResult.mPreferredTaskDisplayArea); } @Test - public void testUsesTaskDisplayIdIfSet() { + public void testUsesTaskDisplayAreaIdIfSet() { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); ActivityRecord source = createSourceActivity(freeformDisplay); @@ -200,7 +215,8 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { assertEquals(RESULT_CONTINUE, mTarget.onCalculate(source.getTask(), null /* layout */, null /* activity */, null /* source */, null /* options */, mCurrent, mResult)); - assertEquals(freeformDisplay.mDisplayId, mResult.mPreferredDisplayId); + assertEquals(freeformDisplay.getDefaultTaskDisplayArea(), + mResult.mPreferredTaskDisplayArea); } @Test @@ -210,7 +226,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent fullscreenDisplay = createNewDisplayContent( WINDOWING_MODE_FULLSCREEN); - mCurrent.mPreferredDisplayId = fullscreenDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = fullscreenDisplay.getDefaultTaskDisplayArea(); ActivityRecord reusableActivity = createSourceActivity(fullscreenDisplay); ActivityRecord source = createSourceActivity(freeformDisplay); source.mHandoverLaunchDisplayId = freeformDisplay.mDisplayId; @@ -219,7 +235,28 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { assertEquals(RESULT_CONTINUE, mTarget.onCalculate(reusableActivity.getTask(), null /* layout */, mActivity, source, null /* options */, mCurrent, mResult)); - assertEquals(freeformDisplay.mDisplayId, mResult.mPreferredDisplayId); + assertEquals(freeformDisplay.getDefaultTaskDisplayArea(), + mResult.mPreferredTaskDisplayArea); + } + + @Test + public void testUsesNoDisplaySourceHandoverDisplayAreaIdIfSet() { + final TestDisplayContent freeformDisplay = createNewDisplayContent( + WINDOWING_MODE_FREEFORM); + final TestDisplayContent fullscreenDisplay = createNewDisplayContent( + WINDOWING_MODE_FULLSCREEN); + + mCurrent.mPreferredTaskDisplayArea = fullscreenDisplay.getDefaultTaskDisplayArea(); + ActivityRecord reusableActivity = createSourceActivity(fullscreenDisplay); + ActivityRecord source = createSourceActivity(freeformDisplay); + source.mHandoverTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); + source.noDisplay = true; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(reusableActivity.getTask(), + null /* layout */, mActivity, source, null /* options */, mCurrent, mResult)); + + assertEquals(freeformDisplay.getDefaultTaskDisplayArea(), + mResult.mPreferredTaskDisplayArea); } // ===================================== @@ -233,7 +270,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final ActivityOptions options = ActivityOptions.makeBasic(); options.setLaunchBounds(new Rect(0, 0, 100, 100)); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, mActivity, /* source */ null, options, mCurrent, mResult)); @@ -247,7 +284,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final ActivityOptions options = ActivityOptions.makeBasic(); options.setLaunchBounds(new Rect(0, 0, 100, 100)); - mCurrent.mPreferredDisplayId = DEFAULT_DISPLAY; + mCurrent.mPreferredTaskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, mActivity, /* source */ null, options, mCurrent, mResult)); @@ -278,7 +315,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final ActivityOptions options = ActivityOptions.makeBasic(); options.setLaunchWindowingMode(WINDOWING_MODE_PINNED); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, mActivity, /* source */ null, options, mCurrent, mResult)); @@ -296,7 +333,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { options.setLaunchWindowingMode(WINDOWING_MODE_PINNED); options.setLaunchBounds(new Rect(0, 0, 100, 100)); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, mActivity, /* source */ null, options, mCurrent, mResult)); @@ -310,7 +347,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final ActivityOptions options = ActivityOptions.makeBasic(); options.setLaunchWindowingMode(WINDOWING_MODE_FULLSCREEN); - mCurrent.mPreferredDisplayId = DEFAULT_DISPLAY; + mCurrent.mPreferredTaskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, mActivity, /* source */ null, options, mCurrent, mResult)); @@ -324,7 +361,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setWidth(120).setHeight(80).build(); @@ -341,7 +378,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setGravity(Gravity.LEFT).build(); @@ -358,7 +395,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setWidth(120).setHeight(80).build(); - mCurrent.mPreferredDisplayId = DEFAULT_DISPLAY; + mCurrent.mPreferredTaskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, /* source */ null, /* options */ null, mCurrent, mResult)); @@ -369,7 +406,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { @Test public void testLaunchesFullscreenOnFullscreenDisplayWithFreeformHistory() { - mCurrent.mPreferredDisplayId = Display.INVALID_DISPLAY; + mCurrent.mPreferredTaskDisplayArea = null; mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; mCurrent.mBounds.set(0, 0, 200, 100); @@ -385,7 +422,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); mCurrent.mWindowingMode = WINDOWING_MODE_FULLSCREEN; assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, @@ -400,7 +437,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; mCurrent.mBounds.set(0, 0, 200, 100); @@ -421,7 +458,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { options.setLaunchWindowingMode(WINDOWING_MODE_FREEFORM); options.setLaunchBounds(new Rect(0, 0, 200, 100)); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; mCurrent.mBounds.set(0, 0, 200, 100); @@ -446,7 +483,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { options.setLaunchWindowingMode(WINDOWING_MODE_FREEFORM); options.setLaunchBounds(expectedLaunchBounds); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; mCurrent.mBounds.set(expectedLaunchBounds); @@ -467,7 +504,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { options.setLaunchWindowingMode(WINDOWING_MODE_FREEFORM); options.setLaunchBounds(new Rect(0, 0, 200, 100)); - mCurrent.mPreferredDisplayId = DEFAULT_DISPLAY; + mCurrent.mPreferredTaskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; mCurrent.mBounds.set(0, 0, 200, 100); @@ -568,7 +605,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final Rect expected = new Rect(0, 0, 100, 100); options.setLaunchBounds(expected); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, mActivity, /* source */ null, options, mCurrent, mResult)); @@ -598,7 +635,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setGravity(Gravity.LEFT).build(); @@ -614,7 +651,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setGravity(Gravity.TOP).build(); @@ -630,7 +667,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setGravity(Gravity.TOP | Gravity.LEFT).build(); @@ -647,7 +684,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setGravity(Gravity.RIGHT).build(); @@ -663,7 +700,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setGravity(Gravity.BOTTOM).build(); @@ -679,7 +716,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setGravity(Gravity.BOTTOM | Gravity.RIGHT).build(); @@ -696,7 +733,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setWidth(120).setHeight(80).build(); @@ -712,7 +749,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setWidth(120).setHeight(80).setGravity(Gravity.LEFT).build(); @@ -728,7 +765,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setWidth(120).setHeight(80).setGravity(Gravity.TOP).build(); @@ -744,7 +781,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setWidth(120).setHeight(80).setGravity(Gravity.TOP | Gravity.LEFT).build(); @@ -760,7 +797,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setWidth(120).setHeight(80).setGravity(Gravity.RIGHT).build(); @@ -776,7 +813,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setWidth(120).setHeight(80).setGravity(Gravity.BOTTOM).build(); @@ -792,7 +829,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setWidth(120).setHeight(80).setGravity(Gravity.BOTTOM | Gravity.RIGHT).build(); @@ -808,7 +845,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() .setWidthFraction(0.125f).setHeightFraction(0.1f).build(); @@ -824,7 +861,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; mCurrent.mBounds.set(0, 0, 200, 100); @@ -839,7 +876,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); mCurrent.mWindowingMode = WINDOWING_MODE_FULLSCREEN; mCurrent.mBounds.set(0, 0, 200, 100); @@ -1217,7 +1254,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { @Test public void returnsNonFullscreenBoundsOnFullscreenDisplayWithFreeformHistory() { - mCurrent.mPreferredDisplayId = Display.INVALID_DISPLAY; + mCurrent.mPreferredTaskDisplayArea = null; mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; mCurrent.mBounds.set(0, 0, 200, 100); @@ -1233,7 +1270,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); - mCurrent.mPreferredDisplayId = Display.INVALID_DISPLAY; + mCurrent.mPreferredTaskDisplayArea = null; mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; mCurrent.mBounds.set(-100, -200, 200, 100); @@ -1253,7 +1290,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { addFreeformTaskTo(freeformDisplay, new Rect(0, 0, 200, 100)); - mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea(); mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; mCurrent.mBounds.set(0, 0, 200, 100); @@ -1284,13 +1321,14 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { public void testNoMultiDisplaySupports() { final boolean orgValue = mService.mSupportsMultiDisplay; final TestDisplayContent display = createNewDisplayContent(WINDOWING_MODE_FULLSCREEN); - mCurrent.mPreferredDisplayId = display.mDisplayId; + mCurrent.mPreferredTaskDisplayArea = display.getDefaultTaskDisplayArea(); try { mService.mSupportsMultiDisplay = false; assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, mActivity, /* source */ null, /* options */ null, mCurrent, mResult)); - assertEquals(DEFAULT_DISPLAY, mResult.mPreferredDisplayId); + assertEquals(mRootWindowContainer.getDefaultTaskDisplayArea(), + mResult.mPreferredTaskDisplayArea); } finally { mService.mSupportsMultiDisplay = orgValue; } |