diff options
273 files changed, 9568 insertions, 2867 deletions
diff --git a/AconfigFlags.bp b/AconfigFlags.bp index 1fb5f34650cb..20f879c7fc2c 100644 --- a/AconfigFlags.bp +++ b/AconfigFlags.bp @@ -428,7 +428,10 @@ java_aconfig_library { aconfig_declarations { name: "com.android.media.flags.bettertogether-aconfig", package: "com.android.media.flags", - srcs: ["media/java/android/media/flags/media_better_together.aconfig"], + srcs: [ + "media/java/android/media/flags/media_better_together.aconfig", + "media/java/android/media/flags/fade_manager_configuration.aconfig", + ], } java_aconfig_library { diff --git a/Android.bp b/Android.bp index c1fb41f845e3..fa7c97d3d21a 100644 --- a/Android.bp +++ b/Android.bp @@ -95,7 +95,7 @@ filegroup { ":platform-compat-native-aidl", // AIDL sources from external directories - ":android.hardware.biometrics.common-V3-java-source", + ":android.hardware.biometrics.common-V4-java-source", ":android.hardware.biometrics.fingerprint-V3-java-source", ":android.hardware.gnss-V2-java-source", ":android.hardware.graphics.common-V3-java-source", @@ -379,6 +379,7 @@ java_defaults { // system propagates "required" properly. "gps_debug.conf", "protolog.conf.json.gz", + "framework-res", // any install dependencies should go into framework-minus-apex-install-dependencies // rather than here to avoid bloating incremental build time ], diff --git a/apex/jobscheduler/framework/aconfig/job.aconfig b/apex/jobscheduler/framework/aconfig/job.aconfig index f5e33a80211b..e73b434042af 100644 --- a/apex/jobscheduler/framework/aconfig/job.aconfig +++ b/apex/jobscheduler/framework/aconfig/job.aconfig @@ -1,6 +1,13 @@ package: "android.app.job" flag { + name: "enforce_minimum_time_windows" + namespace: "backstage_power" + description: "Enforce a minimum time window for job latencies & deadlines" + bug: "311402873" +} + +flag { name: "job_debug_info_apis" namespace: "backstage_power" description: "Add APIs to let apps attach debug information to jobs" diff --git a/apex/jobscheduler/framework/java/android/app/job/JobInfo.java b/apex/jobscheduler/framework/java/android/app/job/JobInfo.java index 742ed5f2eeb7..4bc73130db29 100644 --- a/apex/jobscheduler/framework/java/android/app/job/JobInfo.java +++ b/apex/jobscheduler/framework/java/android/app/job/JobInfo.java @@ -23,6 +23,7 @@ import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING; import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VPN; import static android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED; import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR; +import static android.text.format.DateUtils.HOUR_IN_MILLIS; import static android.util.TimeUtils.formatDuration; import android.annotation.BytesLong; @@ -36,6 +37,7 @@ import android.compat.Compatibility; import android.compat.annotation.ChangeId; import android.compat.annotation.EnabledAfter; import android.compat.annotation.EnabledSince; +import android.compat.annotation.Overridable; import android.compat.annotation.UnsupportedAppUsage; import android.content.ClipData; import android.content.ComponentName; @@ -48,7 +50,9 @@ import android.os.Bundle; import android.os.Parcel; import android.os.Parcelable; import android.os.PersistableBundle; +import android.os.Process; import android.os.Trace; +import android.os.UserHandle; import android.util.ArraySet; import android.util.Log; @@ -113,6 +117,16 @@ public class JobInfo implements Parcelable { @EnabledAfter(targetSdkVersion = Build.VERSION_CODES.TIRAMISU) public static final long REJECT_NEGATIVE_NETWORK_ESTIMATES = 253665015L; + /** + * Enforce a minimum time window between job latencies and deadlines. + * + * @hide + */ + @ChangeId + @EnabledAfter(targetSdkVersion = Build.VERSION_CODES.UPSIDE_DOWN_CAKE) + @Overridable // Aid in testing + public static final long ENFORCE_MINIMUM_TIME_WINDOWS = 311402873L; + /** @hide */ @IntDef(prefix = { "NETWORK_TYPE_" }, value = { NETWORK_TYPE_NONE, @@ -1866,10 +1880,40 @@ public class JobInfo implements Parcelable { * Set deadline which is the maximum scheduling latency. The job will be run by this * deadline even if other requirements (including a delay set through * {@link #setMinimumLatency(long)}) are not met. + * {@link JobParameters#isOverrideDeadlineExpired()} will return {@code true} if the job's + * deadline has passed. + * * <p> * Because it doesn't make sense setting this property on a periodic job, doing so will * throw an {@link java.lang.IllegalArgumentException} when * {@link android.app.job.JobInfo.Builder#build()} is called. + * + * <p class="note"> + * Since a job will run once the deadline has passed regardless of the status of other + * constraints, setting a deadline of 0 with other constraints makes those constraints + * meaningless when it comes to execution decisions. Avoid doing this. + * </p> + * + * <p> + * Short deadlines hinder the system's ability to optimize scheduling behavior and may + * result in running jobs at inopportune times. Therefore, starting in Android version + * {@link android.os.Build.VERSION_CODES#VANILLA_ICE_CREAM}, minimum time windows will be + * enforced to help make it easier to better optimize job execution. Time windows are + * defined as the time between a job's {@link #setMinimumLatency(long) minimum latency} + * and its deadline. If the minimum latency is not set, it is assumed to be 0. + * The following minimums will be enforced: + * <ul> + * <li> + * Jobs with {@link #PRIORITY_DEFAULT} or higher priorities have a minimum time + * window of one hour. + * </li> + * <li>Jobs with {@link #PRIORITY_LOW} have a minimum time window of 6 hours.</li> + * <li>Jobs with {@link #PRIORITY_MIN} have a minimum time window of 12 hours.</li> + * </ul> + * + * Work that must happen immediately should use {@link #setExpedited(boolean)} or + * {@link #setUserInitiated(boolean)} in the appropriate manner. + * * @see JobInfo#getMaxExecutionDelayMillis() */ public Builder setOverrideDeadline(long maxExecutionDelayMillis) { @@ -2143,12 +2187,14 @@ public class JobInfo implements Parcelable { */ public JobInfo build() { return build(Compatibility.isChangeEnabled(DISALLOW_DEADLINES_FOR_PREFETCH_JOBS), - Compatibility.isChangeEnabled(REJECT_NEGATIVE_NETWORK_ESTIMATES)); + Compatibility.isChangeEnabled(REJECT_NEGATIVE_NETWORK_ESTIMATES), + Compatibility.isChangeEnabled(ENFORCE_MINIMUM_TIME_WINDOWS)); } /** @hide */ public JobInfo build(boolean disallowPrefetchDeadlines, - boolean rejectNegativeNetworkEstimates) { + boolean rejectNegativeNetworkEstimates, + boolean enforceMinimumTimeWindows) { // This check doesn't need to be inside enforceValidity. It's an unnecessary legacy // check that would ideally be phased out instead. if (mBackoffPolicySet && (mConstraintFlags & CONSTRAINT_FLAG_DEVICE_IDLE) != 0) { @@ -2157,7 +2203,8 @@ public class JobInfo implements Parcelable { " setRequiresDeviceIdle is an error."); } JobInfo jobInfo = new JobInfo(this); - jobInfo.enforceValidity(disallowPrefetchDeadlines, rejectNegativeNetworkEstimates); + jobInfo.enforceValidity(disallowPrefetchDeadlines, rejectNegativeNetworkEstimates, + enforceMinimumTimeWindows); return jobInfo; } @@ -2176,7 +2223,8 @@ public class JobInfo implements Parcelable { * @hide */ public final void enforceValidity(boolean disallowPrefetchDeadlines, - boolean rejectNegativeNetworkEstimates) { + boolean rejectNegativeNetworkEstimates, + boolean enforceMinimumTimeWindows) { // Check that network estimates require network type and are reasonable values. if ((networkDownloadBytes > 0 || networkUploadBytes > 0 || minimumNetworkChunkBytes > 0) && networkRequest == null) { @@ -2291,6 +2339,39 @@ public class JobInfo implements Parcelable { throw new IllegalArgumentException("Invalid priority level provided: " + mPriority); } + if (enforceMinimumTimeWindows + && Flags.enforceMinimumTimeWindows() + // TODO(312197030): remove exemption for the system + && !UserHandle.isCore(Process.myUid()) + && hasLateConstraint && !isPeriodic) { + final long windowStart = hasEarlyConstraint ? minLatencyMillis : 0; + if (mPriority >= PRIORITY_DEFAULT) { + if (maxExecutionDelayMillis - windowStart < HOUR_IN_MILLIS) { + throw new IllegalArgumentException( + getPriorityString(mPriority) + + " cannot have a time window less than 1 hour." + + " Delay=" + windowStart + + ", deadline=" + maxExecutionDelayMillis); + } + } else if (mPriority >= PRIORITY_LOW) { + if (maxExecutionDelayMillis - windowStart < 6 * HOUR_IN_MILLIS) { + throw new IllegalArgumentException( + getPriorityString(mPriority) + + " cannot have a time window less than 6 hours." + + " Delay=" + windowStart + + ", deadline=" + maxExecutionDelayMillis); + } + } else { + if (maxExecutionDelayMillis - windowStart < 12 * HOUR_IN_MILLIS) { + throw new IllegalArgumentException( + getPriorityString(mPriority) + + " cannot have a time window less than 12 hours." + + " Delay=" + windowStart + + ", deadline=" + maxExecutionDelayMillis); + } + } + } + if (isExpedited) { if (hasEarlyConstraint) { throw new IllegalArgumentException("An expedited job cannot have a time delay"); diff --git a/apex/jobscheduler/service/java/com/android/server/job/JobSchedulerService.java b/apex/jobscheduler/service/java/com/android/server/job/JobSchedulerService.java index fecd2fd60b1d..f97100bf2e9b 100644 --- a/apex/jobscheduler/service/java/com/android/server/job/JobSchedulerService.java +++ b/apex/jobscheduler/service/java/com/android/server/job/JobSchedulerService.java @@ -4388,7 +4388,7 @@ public class JobSchedulerService extends com.android.server.SystemService Slog.w(TAG, "Uid " + uid + " set bias on its job"); return new JobInfo.Builder(job) .setBias(JobInfo.BIAS_DEFAULT) - .build(false, false); + .build(false, false, false); } } @@ -4410,7 +4410,9 @@ public class JobSchedulerService extends com.android.server.SystemService job.enforceValidity( CompatChanges.isChangeEnabled( JobInfo.DISALLOW_DEADLINES_FOR_PREFETCH_JOBS, callingUid), - rejectNegativeNetworkEstimates); + rejectNegativeNetworkEstimates, + CompatChanges.isChangeEnabled( + JobInfo.ENFORCE_MINIMUM_TIME_WINDOWS, callingUid)); if ((job.getFlags() & JobInfo.FLAG_WILL_BE_FOREGROUND) != 0) { getContext().enforceCallingOrSelfPermission( android.Manifest.permission.CONNECTIVITY_INTERNAL, TAG); diff --git a/apex/jobscheduler/service/java/com/android/server/job/JobStore.java b/apex/jobscheduler/service/java/com/android/server/job/JobStore.java index afcbddad611e..53b14d616ecc 100644 --- a/apex/jobscheduler/service/java/com/android/server/job/JobStore.java +++ b/apex/jobscheduler/service/java/com/android/server/job/JobStore.java @@ -1495,7 +1495,7 @@ public final class JobStore { // return value), the deadline is dropped. Periodic jobs require all constraints // to be met, so there's no issue with their deadlines. // The same logic applies for other target SDK-based validation checks. - builtJob = jobBuilder.build(false, false); + builtJob = jobBuilder.build(false, false, false); } catch (Exception e) { Slog.w(TAG, "Unable to build job from XML, ignoring: " + jobBuilder.summarize(), e); return null; diff --git a/apex/jobscheduler/service/java/com/android/server/job/controllers/JobStatus.java b/apex/jobscheduler/service/java/com/android/server/job/controllers/JobStatus.java index 13bea6bd1dd1..b74806494a60 100644 --- a/apex/jobscheduler/service/java/com/android/server/job/controllers/JobStatus.java +++ b/apex/jobscheduler/service/java/com/android/server/job/controllers/JobStatus.java @@ -636,7 +636,7 @@ public final class JobStatus { .build()); // Don't perform validation checks at this point since we've already passed the // initial validation check. - job = builder.build(false, false); + job = builder.build(false, false, false); } this.job = job; diff --git a/core/api/current.txt b/core/api/current.txt index 095da8871dc8..119a3de6835e 100644 --- a/core/api/current.txt +++ b/core/api/current.txt @@ -12428,7 +12428,7 @@ package android.content.pm { method public void registerSessionCallback(@NonNull android.content.pm.PackageInstaller.SessionCallback); method public void registerSessionCallback(@NonNull android.content.pm.PackageInstaller.SessionCallback, @NonNull android.os.Handler); method @FlaggedApi("android.content.pm.archiving") @RequiresPermission(anyOf={android.Manifest.permission.INSTALL_PACKAGES, android.Manifest.permission.REQUEST_INSTALL_PACKAGES}) public void reportUnarchivalStatus(int, int, long, @Nullable android.app.PendingIntent) throws android.content.pm.PackageManager.NameNotFoundException; - method @FlaggedApi("android.content.pm.archiving") @RequiresPermission(anyOf={android.Manifest.permission.DELETE_PACKAGES, android.Manifest.permission.REQUEST_DELETE_PACKAGES}) public void requestArchive(@NonNull String, @NonNull android.content.IntentSender) throws android.content.pm.PackageManager.NameNotFoundException; + method @FlaggedApi("android.content.pm.archiving") @RequiresPermission(anyOf={android.Manifest.permission.DELETE_PACKAGES, android.Manifest.permission.REQUEST_DELETE_PACKAGES}) public void requestArchive(@NonNull String, @NonNull android.content.IntentSender, int) throws android.content.pm.PackageManager.NameNotFoundException; method @FlaggedApi("android.content.pm.archiving") @RequiresPermission(anyOf={android.Manifest.permission.INSTALL_PACKAGES, android.Manifest.permission.REQUEST_INSTALL_PACKAGES}) public void requestUnarchive(@NonNull String, @NonNull android.content.IntentSender) throws java.io.IOException, android.content.pm.PackageManager.NameNotFoundException; method @RequiresPermission(anyOf={android.Manifest.permission.DELETE_PACKAGES, android.Manifest.permission.REQUEST_DELETE_PACKAGES}) public void uninstall(@NonNull String, @NonNull android.content.IntentSender); method @RequiresPermission(anyOf={android.Manifest.permission.DELETE_PACKAGES, android.Manifest.permission.REQUEST_DELETE_PACKAGES}) public void uninstall(@NonNull android.content.pm.VersionedPackage, @NonNull android.content.IntentSender); @@ -12853,6 +12853,8 @@ package android.content.pm { field public static final int COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED = 4; // 0x4 field public static final int COMPONENT_ENABLED_STATE_DISABLED_USER = 3; // 0x3 field public static final int COMPONENT_ENABLED_STATE_ENABLED = 1; // 0x1 + field @FlaggedApi("android.content.pm.archiving") public static final int DELETE_ARCHIVE = 16; // 0x10 + field @FlaggedApi("android.content.pm.archiving") public static final int DELETE_SHOW_DIALOG = 32; // 0x20 field public static final int DONT_KILL_APP = 1; // 0x1 field public static final String EXTRA_VERIFICATION_ID = "android.content.pm.extra.VERIFICATION_ID"; field public static final String EXTRA_VERIFICATION_RESULT = "android.content.pm.extra.VERIFICATION_RESULT"; @@ -19508,6 +19510,7 @@ package android.hardware.camera2 { field @Deprecated @NonNull public static final android.hardware.camera2.CaptureResult.Key<float[]> LENS_RADIAL_DISTORTION; field @NonNull public static final android.hardware.camera2.CaptureResult.Key<java.lang.Integer> LENS_STATE; field @NonNull public static final android.hardware.camera2.CaptureResult.Key<java.lang.String> LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID; + field @FlaggedApi("com.android.internal.camera.flags.concert_mode") @NonNull public static final android.hardware.camera2.CaptureResult.Key<android.graphics.Rect> LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_SENSOR_CROP_REGION; field @NonNull public static final android.hardware.camera2.CaptureResult.Key<java.lang.Integer> NOISE_REDUCTION_MODE; field @NonNull public static final android.hardware.camera2.CaptureResult.Key<java.lang.Float> REPROCESS_EFFECTIVE_EXPOSURE_FACTOR; field @NonNull public static final android.hardware.camera2.CaptureResult.Key<java.lang.Byte> REQUEST_PIPELINE_DEPTH; @@ -19533,6 +19536,7 @@ package android.hardware.camera2 { field @NonNull public static final android.hardware.camera2.CaptureResult.Key<java.lang.Integer> STATISTICS_FACE_DETECT_MODE; field @NonNull public static final android.hardware.camera2.CaptureResult.Key<android.graphics.Point[]> STATISTICS_HOT_PIXEL_MAP; field @NonNull public static final android.hardware.camera2.CaptureResult.Key<java.lang.Boolean> STATISTICS_HOT_PIXEL_MAP_MODE; + field @FlaggedApi("com.android.internal.camera.flags.concert_mode") @NonNull public static final android.hardware.camera2.CaptureResult.Key<android.hardware.camera2.params.LensIntrinsicsSample[]> STATISTICS_LENS_INTRINSICS_SAMPLES; field @NonNull public static final android.hardware.camera2.CaptureResult.Key<android.hardware.camera2.params.LensShadingMap> STATISTICS_LENS_SHADING_CORRECTION_MAP; field @NonNull public static final android.hardware.camera2.CaptureResult.Key<java.lang.Integer> STATISTICS_LENS_SHADING_MAP_MODE; field @NonNull public static final android.hardware.camera2.CaptureResult.Key<java.lang.Integer> STATISTICS_OIS_DATA_MODE; @@ -19689,6 +19693,12 @@ package android.hardware.camera2.params { method public boolean isMultiResolution(); } + @FlaggedApi("com.android.internal.camera.flags.concert_mode") public final class LensIntrinsicsSample { + ctor @FlaggedApi("com.android.internal.camera.flags.concert_mode") public LensIntrinsicsSample(long, @NonNull float[]); + method @FlaggedApi("com.android.internal.camera.flags.concert_mode") @NonNull public float[] getLensIntrinsics(); + method @FlaggedApi("com.android.internal.camera.flags.concert_mode") public long getTimestamp(); + } + public final class LensShadingMap { method public void copyGainFactors(float[], int); method public int getColumnCount(); diff --git a/core/api/system-current.txt b/core/api/system-current.txt index 742b903a49a1..30d57bb190be 100644 --- a/core/api/system-current.txt +++ b/core/api/system-current.txt @@ -3873,6 +3873,7 @@ package android.content.pm { field public static final int DATA_LOADER_TYPE_STREAMING = 1; // 0x1 field public static final String EXTRA_CALLBACK = "android.content.pm.extra.CALLBACK"; field public static final String EXTRA_DATA_LOADER_TYPE = "android.content.pm.extra.DATA_LOADER_TYPE"; + field @FlaggedApi("android.content.pm.archiving") public static final String EXTRA_DELETE_FLAGS = "android.content.pm.extra.DELETE_FLAGS"; field public static final String EXTRA_LEGACY_STATUS = "android.content.pm.extra.LEGACY_STATUS"; field @Deprecated public static final String EXTRA_RESOLVED_BASE_PATH = "android.content.pm.extra.RESOLVED_BASE_PATH"; field public static final int LOCATION_DATA_APP = 0; // 0x0 diff --git a/core/java/android/app/Activity.java b/core/java/android/app/Activity.java index 00432dcf152c..c52d27ea6608 100644 --- a/core/java/android/app/Activity.java +++ b/core/java/android/app/Activity.java @@ -971,6 +971,7 @@ public class Activity extends ContextThemeWrapper private final ActivityManager.TaskDescription mTaskDescription = new ActivityManager.TaskDescription(); + private int mLastTaskDescriptionHashCode; protected static final int[] FOCUSED_STATE_SET = {com.android.internal.R.attr.state_focused}; @@ -7612,6 +7613,13 @@ public class Activity extends ContextThemeWrapper mTaskDescription.setIcon(Icon.createWithBitmap(icon)); } } + if (mLastTaskDescriptionHashCode == mTaskDescription.hashCode()) { + // Early return if the hashCode is the same. + // Note that we do not use #equals() to perform the check because there are several + // places in this class that directly sets the value to mTaskDescription. + return; + } + mLastTaskDescriptionHashCode = mTaskDescription.hashCode(); ActivityClient.getInstance().setTaskDescription(mToken, mTaskDescription); } diff --git a/core/java/android/app/ActivityManager.java b/core/java/android/app/ActivityManager.java index 854e12177fb5..6b7f4880e2f0 100644 --- a/core/java/android/app/ActivityManager.java +++ b/core/java/android/app/ActivityManager.java @@ -2309,6 +2309,32 @@ public class ActivityManager { } @Override + public int hashCode() { + int result = 17; + if (mLabel != null) { + result = result * 31 + mLabel.hashCode(); + } + if (mIcon != null) { + result = result * 31 + mIcon.hashCode(); + } + if (mIconFilename != null) { + result = result * 31 + mIconFilename.hashCode(); + } + result = result * 31 + mColorPrimary; + result = result * 31 + mColorBackground; + result = result * 31 + mColorBackgroundFloating; + result = result * 31 + mStatusBarColor; + result = result * 31 + mNavigationBarColor; + result = result * 31 + mStatusBarAppearance; + result = result * 31 + (mEnsureStatusBarContrastWhenTransparent ? 1 : 0); + result = result * 31 + (mEnsureNavigationBarContrastWhenTransparent ? 1 : 0); + result = result * 31 + mResizeMode; + result = result * 31 + mMinWidth; + result = result * 31 + mMinHeight; + return result; + } + + @Override public boolean equals(@Nullable Object obj) { if (!(obj instanceof TaskDescription)) { return false; diff --git a/core/java/android/app/Person.java b/core/java/android/app/Person.java index 18fc0ce6af15..04186600125f 100644 --- a/core/java/android/app/Person.java +++ b/core/java/android/app/Person.java @@ -189,6 +189,11 @@ public final class Person implements Parcelable { */ public void visitUris(@NonNull Consumer<Uri> visitor) { visitor.accept(getIconUri()); + if (Flags.visitRiskyUris()) { + if (mUri != null && !mUri.isEmpty()) { + visitor.accept(Uri.parse(mUri)); + } + } } /** Builder for the immutable {@link Person} class. */ diff --git a/core/java/android/content/pm/IPackageInstaller.aidl b/core/java/android/content/pm/IPackageInstaller.aidl index 1f25fd039dd8..32ecb58ce241 100644 --- a/core/java/android/content/pm/IPackageInstaller.aidl +++ b/core/java/android/content/pm/IPackageInstaller.aidl @@ -80,7 +80,7 @@ interface IPackageInstaller { long timeout); @JavaPassthrough(annotation="@android.annotation.RequiresPermission(anyOf={android.Manifest.permission.DELETE_PACKAGES,android.Manifest.permission.REQUEST_DELETE_PACKAGES})") - void requestArchive(String packageName, String callerPackageName, in IntentSender statusReceiver, in UserHandle userHandle); + void requestArchive(String packageName, String callerPackageName, in IntentSender statusReceiver, in UserHandle userHandle, int flags); @JavaPassthrough(annotation="@android.annotation.RequiresPermission(anyOf={android.Manifest.permission.INSTALL_PACKAGES,android.Manifest.permission.REQUEST_INSTALL_PACKAGES})") void requestUnarchive(String packageName, String callerPackageName, in IntentSender statusReceiver, in UserHandle userHandle); diff --git a/core/java/android/content/pm/PackageInstaller.java b/core/java/android/content/pm/PackageInstaller.java index d35c3922e9b7..457fd63fa3d8 100644 --- a/core/java/android/content/pm/PackageInstaller.java +++ b/core/java/android/content/pm/PackageInstaller.java @@ -323,6 +323,14 @@ public class PackageInstaller { */ @SystemApi public static final String EXTRA_CALLBACK = "android.content.pm.extra.CALLBACK"; + /** + * Key for passing extra delete flags during archiving. + * + * @hide + */ + @SystemApi + @FlaggedApi(android.content.pm.Flags.FLAG_ARCHIVING) + public static final String EXTRA_DELETE_FLAGS = "android.content.pm.extra.DELETE_FLAGS"; /** * Type of DataLoader for this session. Will be one of @@ -2330,6 +2338,7 @@ public class PackageInstaller { * communicated. * * @param statusReceiver Callback used to notify when the operation is completed. + * @param flags Flags for archiving. Can be 0 or {@link PackageManager#DELETE_SHOW_DIALOG}. * @throws PackageManager.NameNotFoundException If {@code packageName} isn't found or not * available to the caller or isn't archived. */ @@ -2337,11 +2346,12 @@ public class PackageInstaller { Manifest.permission.DELETE_PACKAGES, Manifest.permission.REQUEST_DELETE_PACKAGES}) @FlaggedApi(Flags.FLAG_ARCHIVING) - public void requestArchive(@NonNull String packageName, @NonNull IntentSender statusReceiver) + public void requestArchive(@NonNull String packageName, @NonNull IntentSender statusReceiver, + @DeleteFlags int flags) throws PackageManager.NameNotFoundException { try { mInstaller.requestArchive(packageName, mInstallerPackageName, statusReceiver, - new UserHandle(mUserId)); + new UserHandle(mUserId), flags); } catch (ParcelableException e) { e.maybeRethrow(PackageManager.NameNotFoundException.class); } catch (RemoteException e) { diff --git a/core/java/android/content/pm/PackageManager.java b/core/java/android/content/pm/PackageManager.java index a22fe3f1452b..7bb673ac998d 100644 --- a/core/java/android/content/pm/PackageManager.java +++ b/core/java/android/content/pm/PackageManager.java @@ -2552,6 +2552,7 @@ public abstract class PackageManager { DELETE_SYSTEM_APP, DELETE_DONT_KILL_APP, DELETE_CHATTY, + DELETE_SHOW_DIALOG, }) @Retention(RetentionPolicy.SOURCE) public @interface DeleteFlags {} @@ -2595,15 +2596,21 @@ public abstract class PackageManager { public static final int DELETE_DONT_KILL_APP = 0x00000008; /** - * Flag parameter for {@link #deletePackage} to indicate that the deletion is an archival. This + * Flag parameter for {@link PackageInstaller#uninstall(VersionedPackage, int, IntentSender)} to + * indicate that the deletion is an archival. This * flag is only for internal usage as part of - * {@link PackageInstaller#requestArchive(String, IntentSender)}. - * - * @hide + * {@link PackageInstaller#requestArchive}. */ + @FlaggedApi(android.content.pm.Flags.FLAG_ARCHIVING) public static final int DELETE_ARCHIVE = 0x00000010; /** + * Show a confirmation dialog to the user when app is being deleted. + */ + @FlaggedApi(android.content.pm.Flags.FLAG_ARCHIVING) + public static final int DELETE_SHOW_DIALOG = 0x00000020; + + /** * Flag parameter for {@link #deletePackage} to indicate that package deletion * should be chatty. * @@ -8964,7 +8971,7 @@ public abstract class PackageManager { * Returns true if an app is archivable. * * @throws NameNotFoundException if the given package name is not available to the caller. - * @see PackageInstaller#requestArchive(String, IntentSender) + * @see PackageInstaller#requestArchive */ @FlaggedApi(android.content.pm.Flags.FLAG_ARCHIVING) public boolean isAppArchivable(@NonNull String packageName) throws NameNotFoundException { diff --git a/core/java/android/hardware/camera2/CaptureResult.java b/core/java/android/hardware/camera2/CaptureResult.java index 12ab0f6e50e1..35f295a36d87 100644 --- a/core/java/android/hardware/camera2/CaptureResult.java +++ b/core/java/android/hardware/camera2/CaptureResult.java @@ -5226,6 +5226,60 @@ public class CaptureResult extends CameraMetadata<CaptureResult.Key<?>> { new Key<android.hardware.camera2.params.OisSample[]>("android.statistics.oisSamples", android.hardware.camera2.params.OisSample[].class); /** + * <p>An array of intra-frame lens intrinsic samples.</p> + * <p>Contains an array of intra-frame {@link CameraCharacteristics#LENS_INTRINSIC_CALIBRATION android.lens.intrinsicCalibration} updates. This must + * not be confused or compared to {@link CaptureResult#STATISTICS_OIS_SAMPLES android.statistics.oisSamples}. Although OIS could be the + * main driver, all relevant factors such as focus distance and optical zoom must also + * be included. Do note that OIS samples must not be applied on top of the lens intrinsic + * samples. + * Support for this capture result can be queried via + * {@link android.hardware.camera2.CameraCharacteristics#getAvailableCaptureResultKeys }. + * If available, clients can expect multiple samples per capture result. The specific + * amount will depend on current frame duration and sampling rate. Generally a sampling rate + * greater than or equal to 200Hz is considered sufficient for high quality results.</p> + * <p><b>Optional</b> - The value for this key may be {@code null} on some devices.</p> + * + * @see CameraCharacteristics#LENS_INTRINSIC_CALIBRATION + * @see CaptureResult#STATISTICS_OIS_SAMPLES + */ + @PublicKey + @NonNull + @SyntheticKey + @FlaggedApi(Flags.FLAG_CONCERT_MODE) + public static final Key<android.hardware.camera2.params.LensIntrinsicsSample[]> STATISTICS_LENS_INTRINSICS_SAMPLES = + new Key<android.hardware.camera2.params.LensIntrinsicsSample[]>("android.statistics.lensIntrinsicsSamples", android.hardware.camera2.params.LensIntrinsicsSample[].class); + + /** + * <p>An array of timestamps of lens intrinsics samples, in nanoseconds.</p> + * <p>The array contains the timestamps of lens intrinsics samples. The timestamps are in the + * same timebase as and comparable to {@link CaptureResult#SENSOR_TIMESTAMP android.sensor.timestamp}.</p> + * <p><b>Units</b>: nanoseconds</p> + * <p><b>Optional</b> - The value for this key may be {@code null} on some devices.</p> + * + * @see CaptureResult#SENSOR_TIMESTAMP + * @hide + */ + @FlaggedApi(Flags.FLAG_CONCERT_MODE) + public static final Key<long[]> STATISTICS_LENS_INTRINSIC_TIMESTAMPS = + new Key<long[]>("android.statistics.lensIntrinsicTimestamps", long[].class); + + /** + * <p>An array of intra-frame lens intrinsics.</p> + * <p>The data layout and contents of individual array entries matches with + * {@link CameraCharacteristics#LENS_INTRINSIC_CALIBRATION android.lens.intrinsicCalibration}.</p> + * <p><b>Units</b>: + * Pixels in the {@link CameraCharacteristics#SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE android.sensor.info.preCorrectionActiveArraySize} coordinate system.</p> + * <p><b>Optional</b> - The value for this key may be {@code null} on some devices.</p> + * + * @see CameraCharacteristics#LENS_INTRINSIC_CALIBRATION + * @see CameraCharacteristics#SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE + * @hide + */ + @FlaggedApi(Flags.FLAG_CONCERT_MODE) + public static final Key<float[]> STATISTICS_LENS_INTRINSIC_SAMPLES = + new Key<float[]>("android.statistics.lensIntrinsicSamples", float[].class); + + /** * <p>Tonemapping / contrast / gamma curve for the blue * channel, to use when {@link CaptureRequest#TONEMAP_MODE android.tonemap.mode} is * CONTRAST_CURVE.</p> @@ -5668,6 +5722,55 @@ public class CaptureResult extends CameraMetadata<CaptureResult.Key<?>> { new Key<String>("android.logicalMultiCamera.activePhysicalId", String.class); /** + * <p>The current region of the active physical sensor that will be read out for this + * capture.</p> + * <p>This capture result matches with {@link CaptureRequest#SCALER_CROP_REGION android.scaler.cropRegion} on non-logical single + * camera sensor devices. In case of logical cameras that can switch between several + * physical devices in response to {@link CaptureRequest#CONTROL_ZOOM_RATIO android.control.zoomRatio}, this capture result will + * not behave like {@link CaptureRequest#SCALER_CROP_REGION android.scaler.cropRegion} and {@link CaptureRequest#CONTROL_ZOOM_RATIO android.control.zoomRatio}, where the + * combination of both reflects the effective zoom and crop of the logical camera output. + * Instead, this capture result value will describe the zoom and crop of the active physical + * device. Some examples of when the value of this capture result will change include + * switches between different physical lenses, switches between regular and maximum + * resolution pixel mode and going through the device digital or optical range. + * This capture result is similar to {@link CaptureRequest#SCALER_CROP_REGION android.scaler.cropRegion} with respect to distortion + * correction. When the distortion correction mode is OFF, the coordinate system follows + * {@link CameraCharacteristics#SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE android.sensor.info.preCorrectionActiveArraySize}, with (0, 0) being the top-left pixel + * of the pre-correction active array. When the distortion correction mode is not OFF, + * the coordinate system follows {@link CameraCharacteristics#SENSOR_INFO_ACTIVE_ARRAY_SIZE android.sensor.info.activeArraySize}, with (0, 0) being + * the top-left pixel of the active array.</p> + * <p>For camera devices with the + * {@link android.hardware.camera2.CameraMetadata#REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR } + * capability or devices where {@link CameraCharacteristics#getAvailableCaptureRequestKeys } + * lists {@link CaptureRequest#SENSOR_PIXEL_MODE {@link CaptureRequest#SENSOR_PIXEL_MODE android.sensor.pixelMode}} + * , the current active physical device + * {@link CameraCharacteristics#SENSOR_INFO_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION android.sensor.info.activeArraySizeMaximumResolution} / + * {@link CameraCharacteristics#SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION android.sensor.info.preCorrectionActiveArraySizeMaximumResolution} must be used as the + * coordinate system for requests where {@link CaptureRequest#SENSOR_PIXEL_MODE android.sensor.pixelMode} is set to + * {@link android.hardware.camera2.CameraMetadata#SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION }.</p> + * <p><b>Units</b>: Pixel coordinates relative to + * {@link CameraCharacteristics#SENSOR_INFO_ACTIVE_ARRAY_SIZE android.sensor.info.activeArraySize} or + * {@link CameraCharacteristics#SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE android.sensor.info.preCorrectionActiveArraySize} of the currently + * {@link CaptureResult#LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID android.logicalMultiCamera.activePhysicalId} depending on distortion correction capability + * and mode</p> + * <p><b>Optional</b> - The value for this key may be {@code null} on some devices.</p> + * + * @see CaptureRequest#CONTROL_ZOOM_RATIO + * @see CaptureResult#LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID + * @see CaptureRequest#SCALER_CROP_REGION + * @see CameraCharacteristics#SENSOR_INFO_ACTIVE_ARRAY_SIZE + * @see CameraCharacteristics#SENSOR_INFO_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION + * @see CameraCharacteristics#SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE + * @see CameraCharacteristics#SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION + * @see CaptureRequest#SENSOR_PIXEL_MODE + */ + @PublicKey + @NonNull + @FlaggedApi(Flags.FLAG_CONCERT_MODE) + public static final Key<android.graphics.Rect> LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_SENSOR_CROP_REGION = + new Key<android.graphics.Rect>("android.logicalMultiCamera.activePhysicalSensorCropRegion", android.graphics.Rect.class); + + /** * <p>Mode of operation for the lens distortion correction block.</p> * <p>The lens distortion correction block attempts to improve image quality by fixing * radial, tangential, or other geometric aberrations in the camera device's optics. If diff --git a/core/java/android/hardware/camera2/impl/CameraMetadataNative.java b/core/java/android/hardware/camera2/impl/CameraMetadataNative.java index 9743c1f80f9d..3affb73d1075 100644 --- a/core/java/android/hardware/camera2/impl/CameraMetadataNative.java +++ b/core/java/android/hardware/camera2/impl/CameraMetadataNative.java @@ -55,6 +55,7 @@ import android.hardware.camera2.params.DeviceStateSensorOrientationMap; import android.hardware.camera2.params.DynamicRangeProfiles; import android.hardware.camera2.params.Face; import android.hardware.camera2.params.HighSpeedVideoConfiguration; +import android.hardware.camera2.params.LensIntrinsicsSample; import android.hardware.camera2.params.LensShadingMap; import android.hardware.camera2.params.MandatoryStreamCombination; import android.hardware.camera2.params.MultiResolutionStreamConfigurationMap; @@ -849,6 +850,15 @@ public class CameraMetadataNative implements Parcelable { return (T) metadata.getMultiResolutionStreamConfigurationMap(); } }); + sGetCommandMap.put( + CaptureResult.STATISTICS_LENS_INTRINSICS_SAMPLES.getNativeKey(), + new GetCommand() { + @Override + @SuppressWarnings("unchecked") + public <T> T getValue(CameraMetadataNative metadata, Key<T> key) { + return (T) metadata.getLensIntrinsicSamples(); + } + }); } private int[] getAvailableFormats() { @@ -1780,6 +1790,56 @@ public class CameraMetadataNative implements Parcelable { return samples; } + private boolean setLensIntrinsicsSamples(LensIntrinsicsSample[] samples) { + if (samples == null) { + return false; + } + + long[] tsArray = new long[samples.length]; + float[] intrinsicsArray = new float[samples.length * 5]; + for (int i = 0; i < samples.length; i++) { + tsArray[i] = samples[i].getTimestamp(); + System.arraycopy(samples[i].getLensIntrinsics(), 0, intrinsicsArray, 5*i, 5); + + } + setBase(CaptureResult.STATISTICS_LENS_INTRINSIC_SAMPLES, intrinsicsArray); + setBase(CaptureResult.STATISTICS_LENS_INTRINSIC_TIMESTAMPS, tsArray); + + return true; + } + + private LensIntrinsicsSample[] getLensIntrinsicSamples() { + long[] timestamps = getBase(CaptureResult.STATISTICS_LENS_INTRINSIC_TIMESTAMPS); + float[] intrinsics = getBase(CaptureResult.STATISTICS_LENS_INTRINSIC_SAMPLES); + + if (timestamps == null) { + if (intrinsics != null) { + throw new AssertionError("timestamps is null but intrinsics is not"); + } + + return null; + } + + if (intrinsics == null) { + throw new AssertionError("timestamps is not null but intrinsics is"); + } else if((intrinsics.length % 5) != 0) { + throw new AssertionError("intrinsics are not multiple of 5"); + } + + if ((intrinsics.length / 5) != timestamps.length) { + throw new AssertionError(String.format( + "timestamps has %d entries but intrinsics has %d", timestamps.length, + intrinsics.length / 5)); + } + + LensIntrinsicsSample[] samples = new LensIntrinsicsSample[timestamps.length]; + for (int i = 0; i < timestamps.length; i++) { + float[] currentIntrinsic = Arrays.copyOfRange(intrinsics, 5*i, 5*i + 5); + samples[i] = new LensIntrinsicsSample(timestamps[i], currentIntrinsic); + } + return samples; + } + private Capability[] getExtendedSceneModeCapabilities() { int[] maxSizes = getBase(CameraCharacteristics.CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_MAX_SIZES); @@ -1947,6 +2007,15 @@ public class CameraMetadataNative implements Parcelable { metadata.setLensShadingMap((LensShadingMap) value); } }); + sSetCommandMap.put( + CaptureResult.STATISTICS_LENS_INTRINSICS_SAMPLES.getNativeKey(), + new SetCommand() { + @Override + @SuppressWarnings("unchecked") + public <T> void setValue(CameraMetadataNative metadata, T value) { + metadata.setLensIntrinsicsSamples((LensIntrinsicsSample []) value); + } + }); } private boolean setAvailableFormats(int[] value) { diff --git a/core/java/android/hardware/camera2/params/LensIntrinsicsSample.java b/core/java/android/hardware/camera2/params/LensIntrinsicsSample.java new file mode 100644 index 000000000000..575cbfae34e3 --- /dev/null +++ b/core/java/android/hardware/camera2/params/LensIntrinsicsSample.java @@ -0,0 +1,125 @@ +/* + * Copyright (C) 2023 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 android.hardware.camera2.params; + +import android.annotation.FlaggedApi; +import android.annotation.NonNull; +import android.hardware.camera2.CaptureResult; +import android.hardware.camera2.utils.HashCodeHelpers; +import android.text.TextUtils; + +import com.android.internal.camera.flags.Flags; +import com.android.internal.util.Preconditions; + +import java.util.Arrays; + +/** + * Immutable class to store an + * {@link CaptureResult#STATISTICS_LENS_INTRINSICS_SAMPLES lens intrinsics intra-frame sample}. + */ +@FlaggedApi(Flags.FLAG_CONCERT_MODE) +public final class LensIntrinsicsSample { + /** + * Create a new {@link LensIntrinsicsSample}. + * + * <p>{@link LensIntrinsicsSample} contains the timestamp and the + * {@link CaptureResult#LENS_INTRINSIC_CALIBRATION} sample. + * + * @param timestamp timestamp of the lens intrinsics sample. + * @param lensIntrinsics the lens intrinsic calibration for the sample. + * + * @throws IllegalArgumentException if lensIntrinsics length is different from 5 + */ + @FlaggedApi(Flags.FLAG_CONCERT_MODE) + public LensIntrinsicsSample(final long timestamp, @NonNull final float[] lensIntrinsics) { + mTimestampNs = timestamp; + Preconditions.checkArgument(lensIntrinsics.length == 5); + mLensIntrinsics = lensIntrinsics; + } + + /** + * Get the timestamp in nanoseconds. + * + *<p>The timestamps are in the same timebase as and comparable to + *{@link CaptureResult#SENSOR_TIMESTAMP android.sensor.timestamp}.</p> + * + * @return a long value (guaranteed to be finite) + */ + @FlaggedApi(Flags.FLAG_CONCERT_MODE) + public long getTimestamp() { + return mTimestampNs; + } + + /** + * Get the lens intrinsics calibration + * + * @return a floating point value (guaranteed to be finite) + * @see CaptureResult#LENS_INTRINSIC_CALIBRATION + */ + @FlaggedApi(Flags.FLAG_CONCERT_MODE) + @NonNull + public float[] getLensIntrinsics() { + return mLensIntrinsics; + } + + /** + * Check if this {@link LensIntrinsicsSample} is equal to another {@link LensIntrinsicsSample}. + * + * <p>Two samples are only equal if and only if each of the lens intrinsics are equal.</p> + * + * @return {@code true} if the objects were equal, {@code false} otherwise + */ + @Override + public boolean equals(final Object obj) { + if (obj == null) { + return false; + } else if (this == obj) { + return true; + } else if (obj instanceof LensIntrinsicsSample) { + final LensIntrinsicsSample other = (LensIntrinsicsSample) obj; + return mTimestampNs == other.mTimestampNs + && Arrays.equals(mLensIntrinsics, other.getLensIntrinsics()); + } + return false; + } + + /** + * {@inheritDoc} + */ + @Override + public int hashCode() { + int timestampHash = HashCodeHelpers.hashCode(((float)mTimestampNs)); + return HashCodeHelpers.hashCode(Arrays.hashCode(mLensIntrinsics), timestampHash); + } + + /** + * Return the LensIntrinsicsSample as a string representation. + * + * <p> {@code "LensIntrinsicsSample{timestamp:%l, sample:%s}"} represents the LensIntrinsics + * sample's timestamp, and calibration data.</p> + * + * @return string representation of {@link LensIntrinsicsSample} + */ + @Override + public String toString() { + return TextUtils.formatSimple("LensIntrinsicsSample{timestamp:%d, sample:%s}", mTimestampNs, + Arrays.toString(mLensIntrinsics)); + } + + private final long mTimestampNs; + private final float [] mLensIntrinsics; +} diff --git a/core/java/android/service/notification/ZenPolicy.java b/core/java/android/service/notification/ZenPolicy.java index 3a4a0c5dcd30..b1680abfadeb 100644 --- a/core/java/android/service/notification/ZenPolicy.java +++ b/core/java/android/service/notification/ZenPolicy.java @@ -1241,7 +1241,7 @@ public final class ZenPolicy implements Parcelable { * @hide */ public byte[] toProto() { - // TODO: b/308672510 - log new ZenPolicy fields to DNDPolicyProto. + // TODO: b/308672510 - log user-customized ZenPolicy fields to DNDPolicyProto. ByteArrayOutputStream bytes = new ByteArrayOutputStream(); ProtoOutputStream proto = new ProtoOutputStream(bytes); @@ -1267,6 +1267,10 @@ public final class ZenPolicy implements Parcelable { proto.write(DNDPolicyProto.ALLOW_MESSAGES_FROM, getPriorityMessageSenders()); proto.write(DNDPolicyProto.ALLOW_CONVERSATIONS_FROM, getPriorityConversationSenders()); + if (Flags.modesApi()) { + proto.write(DNDPolicyProto.ALLOW_CHANNELS, getAllowedChannels()); + } + proto.flush(); return bytes.toByteArray(); } diff --git a/core/java/android/tracing/OWNERS b/core/java/android/tracing/OWNERS index 079d4c545f25..2ebe2e9e2761 100644 --- a/core/java/android/tracing/OWNERS +++ b/core/java/android/tracing/OWNERS @@ -1,3 +1,6 @@ carmenjackson@google.com kevinjeon@google.com +pablogamito@google.com +natanieljr@google.com +keanmariotti@google.com include platform/external/perfetto:/OWNERS diff --git a/core/java/android/tracing/flags.aconfig b/core/java/android/tracing/flags.aconfig index 4b4f6d661e31..c6e8844bc47a 100644 --- a/core/java/android/tracing/flags.aconfig +++ b/core/java/android/tracing/flags.aconfig @@ -5,4 +5,11 @@ flag { namespace: "windowing_tools" description: "Move transition tracing to Perfetto" bug: "309630341" -}
\ No newline at end of file +} + +flag { + name: "perfetto_protolog" + namespace: "windowing_tools" + description: "Migrate protolog to Perfetto" + bug: "276432490" +} diff --git a/core/java/android/view/AttachedSurfaceControl.java b/core/java/android/view/AttachedSurfaceControl.java index fd5517d29d74..f28574ecb3b2 100644 --- a/core/java/android/view/AttachedSurfaceControl.java +++ b/core/java/android/view/AttachedSurfaceControl.java @@ -27,9 +27,6 @@ import android.window.SurfaceSyncGroup; import com.android.window.flags.Flags; -import java.util.concurrent.Executor; -import java.util.function.Consumer; - /** * Provides an interface to the root-Surface of a View Hierarchy or Window. This * is used in combination with the {@link android.view.SurfaceControl} API to enable @@ -197,42 +194,6 @@ public interface AttachedSurfaceControl { } /** - * Add a trusted presentation listener on the SurfaceControl associated with this window. - * - * @param t Transaction that the trusted presentation listener is added on. This should - * be applied by the caller. - * @param thresholds The {@link SurfaceControl.TrustedPresentationThresholds} that will specify - * when the to invoke the callback. - * @param executor The {@link Executor} where the callback will be invoked on. - * @param listener The {@link Consumer} that will receive the callbacks when entered or - * exited the threshold. - * - * @see SurfaceControl.Transaction#setTrustedPresentationCallback(SurfaceControl, - * SurfaceControl.TrustedPresentationThresholds, Executor, Consumer) - * - * @hide b/287076178 un-hide with API bump - */ - default void addTrustedPresentationCallback(@NonNull SurfaceControl.Transaction t, - @NonNull SurfaceControl.TrustedPresentationThresholds thresholds, - @NonNull Executor executor, @NonNull Consumer<Boolean> listener) { - } - - /** - * Remove a trusted presentation listener on the SurfaceControl associated with this window. - * - * @param t Transaction that the trusted presentation listener removed on. This should - * be applied by the caller. - * @param listener The {@link Consumer} that was previously registered with - * addTrustedPresentationCallback that should be removed. - * - * @see SurfaceControl.Transaction#clearTrustedPresentationCallback(SurfaceControl) - * @hide b/287076178 un-hide with API bump - */ - default void removeTrustedPresentationCallback(@NonNull SurfaceControl.Transaction t, - @NonNull Consumer<Boolean> listener) { - } - - /** * Transfer the currently in progress touch gesture from the host to the requested * {@link SurfaceControlViewHost.SurfacePackage}. This requires that the * SurfaceControlViewHost was created with the current host's inputToken. diff --git a/core/java/android/view/IWindowManager.aidl b/core/java/android/view/IWindowManager.aidl index 17bbee6d020f..36b74e39072a 100644 --- a/core/java/android/view/IWindowManager.aidl +++ b/core/java/android/view/IWindowManager.aidl @@ -73,6 +73,8 @@ import android.window.ISurfaceSyncGroupCompletedListener; import android.window.ITaskFpsCallback; import android.window.ScreenCapture; import android.window.WindowContextInfo; +import android.window.ITrustedPresentationListener; +import android.window.TrustedPresentationThresholds; /** * System private interface to the window manager. @@ -1075,4 +1077,10 @@ interface IWindowManager @JavaPassthrough(annotation = "@android.annotation.RequiresPermission(android.Manifest" + ".permission.MONITOR_INPUT)") void unregisterDecorViewGestureListener(IDecorViewGestureListener listener, int displayId); + + void registerTrustedPresentationListener(in IBinder window, in ITrustedPresentationListener listener, + in TrustedPresentationThresholds thresholds, int id); + + + void unregisterTrustedPresentationListener(in ITrustedPresentationListener listener, int id); } diff --git a/core/java/android/view/ViewRootImpl.java b/core/java/android/view/ViewRootImpl.java index 9d2ab1fe2085..d27f787072e2 100644 --- a/core/java/android/view/ViewRootImpl.java +++ b/core/java/android/view/ViewRootImpl.java @@ -123,6 +123,7 @@ import android.content.res.CompatibilityInfo; import android.content.res.Configuration; import android.content.res.Resources; import android.content.res.TypedArray; +import android.database.ContentObserver; import android.graphics.BLASTBufferQueue; import android.graphics.Canvas; import android.graphics.Color; @@ -392,6 +393,9 @@ public final class ViewRootImpl implements ViewParent, */ private CompatOnBackInvokedCallback mCompatOnBackInvokedCallback; + @Nullable + private ContentObserver mForceInvertObserver; + /** * Callback for notifying about global configuration changes. */ @@ -1597,6 +1601,24 @@ public final class ViewRootImpl implements ViewParent, | DisplayManager.EVENT_FLAG_DISPLAY_CHANGED | DisplayManager.EVENT_FLAG_DISPLAY_REMOVED, mBasePackageName); + + if (forceInvertColor()) { + if (mForceInvertObserver == null) { + mForceInvertObserver = new ContentObserver(mHandler) { + @Override + public void onChange(boolean selfChange) { + updateForceDarkMode(); + } + }; + mContext.getContentResolver().registerContentObserver( + Settings.Secure.getUriFor( + Settings.Secure.ACCESSIBILITY_FORCE_INVERT_COLOR_ENABLED + ), + false, + mForceInvertObserver, + UserHandle.myUserId()); + } + } } /** @@ -1610,6 +1632,14 @@ public final class ViewRootImpl implements ViewParent, DisplayManagerGlobal .getInstance() .unregisterDisplayListener(mDisplayListener); + + if (forceInvertColor()) { + if (mForceInvertObserver != null) { + mContext.getContentResolver().unregisterContentObserver(mForceInvertObserver); + mForceInvertObserver = null; + } + } + if (mExtraDisplayListenerLogging) { Slog.w(mTag, "Unregister listeners: " + mBasePackageName, new Throwable()); } @@ -2182,8 +2212,14 @@ public final class ViewRootImpl implements ViewParent, } } - void notifyInsetsAnimationRunningStateChanged(boolean running) { - mInsetsAnimationRunning = running; + /** + * Notify the when the running state of a insets animation changed. + */ + @VisibleForTesting + public void notifyInsetsAnimationRunningStateChanged(boolean running) { + if (sToolkitSetFrameRateReadOnlyFlagValue) { + mInsetsAnimationRunning = running; + } } @Override @@ -2443,6 +2479,19 @@ public final class ViewRootImpl implements ViewParent, if (updateBoundsLayer(t)) { applyTransactionOnDraw(t); } + + // Set the frame rate selection strategy to FRAME_RATE_SELECTION_STRATEGY_SELF + // This strategy ensures that the frame rate specifications do not cascade down to + // the descendant layers. This is particularly important for applications like Chrome, + // where child surfaces should adhere to default behavior instead of no preference + if (sToolkitSetFrameRateReadOnlyFlagValue) { + try { + mFrameRateTransaction.setFrameRateSelectionStrategy(sc, + sc.FRAME_RATE_SELECTION_STRATEGY_SELF).applyAsyncUnsafe(); + } catch (Exception e) { + Log.e(mTag, "Unable to set frame rate selection strategy ", e); + } + } } private void destroySurface() { @@ -11924,18 +11973,6 @@ public final class ViewRootImpl implements ViewParent, scheduleTraversals(); } - @Override - public void addTrustedPresentationCallback(@NonNull SurfaceControl.Transaction t, - @NonNull SurfaceControl.TrustedPresentationThresholds thresholds, - @NonNull Executor executor, @NonNull Consumer<Boolean> listener) { - t.setTrustedPresentationCallback(getSurfaceControl(), thresholds, executor, listener); - } - - @Override - public void removeTrustedPresentationCallback(@NonNull SurfaceControl.Transaction t, - @NonNull Consumer<Boolean> listener) { - t.clearTrustedPresentationCallback(getSurfaceControl()); - } private void logAndTrace(String msg) { if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) { @@ -11949,7 +11986,7 @@ public final class ViewRootImpl implements ViewParent, return; } - int frameRateCategory = mIsFrameRateBoosting + int frameRateCategory = mIsFrameRateBoosting || mInsetsAnimationRunning ? FRAME_RATE_CATEGORY_HIGH : preferredFrameRateCategory; try { @@ -12063,6 +12100,14 @@ public final class ViewRootImpl implements ViewParent, } /** + * Get the value of mLastPreferredFrameRateCategory + */ + @VisibleForTesting + public int getLastPreferredFrameRateCategory() { + return mLastPreferredFrameRateCategory; + } + + /** * Get the value of mPreferredFrameRate */ @VisibleForTesting diff --git a/core/java/android/view/WindowManager.java b/core/java/android/view/WindowManager.java index 046ea77f196d..f668088e6b44 100644 --- a/core/java/android/view/WindowManager.java +++ b/core/java/android/view/WindowManager.java @@ -122,7 +122,9 @@ import android.view.WindowInsets.Side.InsetsSide; import android.view.WindowInsets.Type; import android.view.WindowInsets.Type.InsetsType; import android.view.accessibility.AccessibilityNodeInfo; +import android.window.ITrustedPresentationListener; import android.window.TaskFpsCallback; +import android.window.TrustedPresentationThresholds; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; @@ -5884,4 +5886,35 @@ public interface WindowManager extends ViewManager { default boolean replaceContentOnDisplayWithSc(int displayId, @NonNull SurfaceControl sc) { throw new UnsupportedOperationException(); } + + /** + * Add a trusted presentation listener associated with a window. If the listener has already + * been registered, an AndroidRuntimeException will be thrown. + * + * @param window The Window to add the trusted presentation listener for + * @param thresholds The {@link TrustedPresentationThresholds} that will specify + * when the to invoke the callback. + * @param executor The {@link Executor} where the callback will be invoked on. + * @param listener The {@link ITrustedPresentationListener} that will receive the callbacks + * when entered or exited trusted presentation per the thresholds. + * + * @hide b/287076178 un-hide with API bump + */ + default void registerTrustedPresentationListener(@NonNull IBinder window, + @NonNull TrustedPresentationThresholds thresholds, @NonNull Executor executor, + @NonNull Consumer<Boolean> listener) { + throw new UnsupportedOperationException(); + } + + /** + * Removes a presentation listener associated with a window. If the listener was not previously + * registered, the call will be a noop. + * + * @hide + * @see #registerTrustedPresentationListener(IBinder, + * TrustedPresentationThresholds, Executor, Consumer) + */ + default void unregisterTrustedPresentationListener(@NonNull Consumer<Boolean> listener) { + throw new UnsupportedOperationException(); + } } diff --git a/core/java/android/view/WindowManagerGlobal.java b/core/java/android/view/WindowManagerGlobal.java index 214f1ec3d1ec..a7d814e9ab8c 100644 --- a/core/java/android/view/WindowManagerGlobal.java +++ b/core/java/android/view/WindowManagerGlobal.java @@ -30,9 +30,13 @@ import android.os.RemoteException; import android.os.ServiceManager; import android.os.SystemProperties; import android.util.AndroidRuntimeException; +import android.util.ArrayMap; import android.util.ArraySet; import android.util.Log; +import android.util.Pair; import android.view.inputmethod.InputMethodManager; +import android.window.ITrustedPresentationListener; +import android.window.TrustedPresentationThresholds; import com.android.internal.util.FastPrintWriter; @@ -43,6 +47,7 @@ import java.lang.ref.WeakReference; import java.util.ArrayList; import java.util.WeakHashMap; import java.util.concurrent.Executor; +import java.util.function.Consumer; import java.util.function.IntConsumer; /** @@ -143,6 +148,9 @@ public final class WindowManagerGlobal { private Runnable mSystemPropertyUpdater; + private final TrustedPresentationListener mTrustedPresentationListener = + new TrustedPresentationListener(); + private WindowManagerGlobal() { } @@ -324,7 +332,7 @@ public final class WindowManagerGlobal { final Context context = view.getContext(); if (context != null && (context.getApplicationInfo().flags - & ApplicationInfo.FLAG_HARDWARE_ACCELERATED) != 0) { + & ApplicationInfo.FLAG_HARDWARE_ACCELERATED) != 0) { wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED; } } @@ -482,7 +490,7 @@ public final class WindowManagerGlobal { if (who != null) { WindowLeaked leak = new WindowLeaked( what + " " + who + " has leaked window " - + root.getView() + " that was originally added here"); + + root.getView() + " that was originally added here"); leak.setStackTrace(root.getLocation().getStackTrace()); Log.e(TAG, "", leak); } @@ -790,6 +798,86 @@ public final class WindowManagerGlobal { } } + public void registerTrustedPresentationListener(@NonNull IBinder window, + @NonNull TrustedPresentationThresholds thresholds, Executor executor, + @NonNull Consumer<Boolean> listener) { + mTrustedPresentationListener.addListener(window, thresholds, listener, executor); + } + + public void unregisterTrustedPresentationListener(@NonNull Consumer<Boolean> listener) { + mTrustedPresentationListener.removeListener(listener); + } + + private final class TrustedPresentationListener extends + ITrustedPresentationListener.Stub { + private static int sId = 0; + private final ArrayMap<Consumer<Boolean>, Pair<Integer, Executor>> mListeners = + new ArrayMap<>(); + + private final Object mTplLock = new Object(); + + private void addListener(IBinder window, TrustedPresentationThresholds thresholds, + Consumer<Boolean> listener, Executor executor) { + synchronized (mTplLock) { + if (mListeners.containsKey(listener)) { + throw new AndroidRuntimeException("Trying to add duplicate listener"); + } + int id = sId++; + mListeners.put(listener, new Pair<>(id, executor)); + try { + WindowManagerGlobal.getWindowManagerService() + .registerTrustedPresentationListener(window, this, thresholds, id); + } catch (RemoteException e) { + e.rethrowAsRuntimeException(); + } + } + } + + private void removeListener(Consumer<Boolean> listener) { + synchronized (mTplLock) { + var removedListener = mListeners.remove(listener); + if (removedListener == null) { + Log.i(TAG, "listener " + listener + " does not exist."); + return; + } + + try { + WindowManagerGlobal.getWindowManagerService() + .unregisterTrustedPresentationListener(this, removedListener.first); + } catch (RemoteException e) { + e.rethrowAsRuntimeException(); + } + } + } + + @Override + public void onTrustedPresentationChanged(int[] inTrustedStateListenerIds, + int[] outOfTrustedStateListenerIds) { + ArrayList<Runnable> firedListeners = new ArrayList<>(); + synchronized (mTplLock) { + mListeners.forEach((listener, idExecutorPair) -> { + final var listenerId = idExecutorPair.first; + final var executor = idExecutorPair.second; + for (int id : inTrustedStateListenerIds) { + if (listenerId == id) { + firedListeners.add(() -> executor.execute( + () -> listener.accept(/*presentationState*/true))); + } + } + for (int id : outOfTrustedStateListenerIds) { + if (listenerId == id) { + firedListeners.add(() -> executor.execute( + () -> listener.accept(/*presentationState*/false))); + } + } + }); + } + for (int i = 0; i < firedListeners.size(); i++) { + firedListeners.get(i).run(); + } + } + } + /** @hide */ public void addWindowlessRoot(ViewRootImpl impl) { synchronized (mLock) { @@ -801,7 +889,7 @@ public final class WindowManagerGlobal { public void removeWindowlessRoot(ViewRootImpl impl) { synchronized (mLock) { mWindowlessRoots.remove(impl); - } + } } public void setRecentsAppBehindSystemBars(boolean behindSystemBars) { diff --git a/core/java/android/view/WindowManagerImpl.java b/core/java/android/view/WindowManagerImpl.java index d7b74b3bcfe2..b4b1fde89a46 100644 --- a/core/java/android/view/WindowManagerImpl.java +++ b/core/java/android/view/WindowManagerImpl.java @@ -37,6 +37,7 @@ import android.os.StrictMode; import android.util.Log; import android.window.ITaskFpsCallback; import android.window.TaskFpsCallback; +import android.window.TrustedPresentationThresholds; import android.window.WindowContext; import android.window.WindowMetricsController; import android.window.WindowProvider; @@ -508,4 +509,17 @@ public final class WindowManagerImpl implements WindowManager { } return false; } + + @Override + public void registerTrustedPresentationListener(@NonNull IBinder window, + @NonNull TrustedPresentationThresholds thresholds, @NonNull Executor executor, + @NonNull Consumer<Boolean> listener) { + mGlobal.registerTrustedPresentationListener(window, thresholds, executor, listener); + } + + @Override + public void unregisterTrustedPresentationListener(@NonNull Consumer<Boolean> listener) { + mGlobal.unregisterTrustedPresentationListener(listener); + + } } diff --git a/core/java/android/widget/ToastPresenter.java b/core/java/android/widget/ToastPresenter.java index 6884e639f9c7..6963237fc19b 100644 --- a/core/java/android/widget/ToastPresenter.java +++ b/core/java/android/widget/ToastPresenter.java @@ -91,7 +91,6 @@ public class ToastPresenter { private final WeakReference<Context> mContext; private final Resources mResources; - private final WeakReference<WindowManager> mWindowManager; private final IAccessibilityManager mAccessibilityManagerService; private final INotificationManager mNotificationManager; private final String mPackageName; @@ -104,7 +103,6 @@ public class ToastPresenter { INotificationManager notificationManager, String packageName) { mContext = new WeakReference<>(context); mResources = context.getResources(); - mWindowManager = new WeakReference<>(context.getSystemService(WindowManager.class)); mNotificationManager = notificationManager; mPackageName = packageName; mContextPackageName = context.getPackageName(); @@ -274,7 +272,7 @@ public class ToastPresenter { public void hide(@Nullable ITransientNotificationCallback callback) { checkState(mView != null, "No toast to hide."); - final WindowManager windowManager = mWindowManager.get(); + final WindowManager windowManager = getWindowManager(mView); if (mView.getParent() != null && windowManager != null) { windowManager.removeViewImmediate(mView); } @@ -295,6 +293,17 @@ public class ToastPresenter { mToken = null; } + private WindowManager getWindowManager(View view) { + Context context = mContext.get(); + if (context == null && view != null) { + context = view.getContext(); + } + if (context != null) { + return context.getSystemService(WindowManager.class); + } + return null; + } + /** * Sends {@link AccessibilityEvent#TYPE_NOTIFICATION_STATE_CHANGED} event if accessibility is * enabled. @@ -331,7 +340,7 @@ public class ToastPresenter { } private void addToastView() { - final WindowManager windowManager = mWindowManager.get(); + final WindowManager windowManager = getWindowManager(mView); if (windowManager == null) { return; } diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/shared/model/KeyguardRootViewVisibilityState.kt b/core/java/android/window/ITrustedPresentationListener.aidl index 9a57aefba329..b33128abb7e5 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/shared/model/KeyguardRootViewVisibilityState.kt +++ b/core/java/android/window/ITrustedPresentationListener.aidl @@ -12,20 +12,13 @@ * 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.systemui.keyguard.shared.model +package android.window; /** - * Provides a stateful representation of the visibility of the KeyguardRootView - * - * @param statusBarState State of the status bar represented by [StatusBarState] - * @param goingToFullShade Whether status bar is going to full shade - * @param occlusionTransitionRunning Whether the occlusion transition is running in this instant + * @hide */ -data class KeyguardRootViewVisibilityState( - val statusBarState: Int, - val goingToFullShade: Boolean, - val occlusionTransitionRunning: Boolean, -) +oneway interface ITrustedPresentationListener { + void onTrustedPresentationChanged(in int[] enteredTrustedStateIds, in int[] exitedTrustedStateIds); +}
\ No newline at end of file diff --git a/core/java/android/window/TrustedPresentationListener.java b/core/java/android/window/TrustedPresentationListener.java new file mode 100644 index 000000000000..02fd6d98fb0d --- /dev/null +++ b/core/java/android/window/TrustedPresentationListener.java @@ -0,0 +1,26 @@ +/* + * Copyright 2023 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 android.window; + +/** + * @hide + */ +public interface TrustedPresentationListener { + + void onTrustedPresentationChanged(boolean inTrustedPresentationState); + +} diff --git a/core/java/android/window/TrustedPresentationThresholds.aidl b/core/java/android/window/TrustedPresentationThresholds.aidl new file mode 100644 index 000000000000..d7088bf0fddc --- /dev/null +++ b/core/java/android/window/TrustedPresentationThresholds.aidl @@ -0,0 +1,3 @@ +package android.window; + +parcelable TrustedPresentationThresholds; diff --git a/core/java/android/window/TrustedPresentationThresholds.java b/core/java/android/window/TrustedPresentationThresholds.java new file mode 100644 index 000000000000..801d35c49228 --- /dev/null +++ b/core/java/android/window/TrustedPresentationThresholds.java @@ -0,0 +1,127 @@ +/* + * Copyright 2023 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 android.window; + +import android.annotation.FloatRange; +import android.annotation.IntRange; +import android.os.Parcel; +import android.os.Parcelable; +import android.view.SurfaceControl; + +import androidx.annotation.NonNull; + +/** + * @hide + */ +public final class TrustedPresentationThresholds implements Parcelable { + /** + * The min alpha the {@link SurfaceControl} is required to have to be considered inside the + * threshold. + */ + @FloatRange(from = 0f, fromInclusive = false, to = 1f) + public final float mMinAlpha; + + /** + * The min fraction of the SurfaceControl that was presented to the user to be considered + * inside the threshold. + */ + @FloatRange(from = 0f, fromInclusive = false, to = 1f) + public final float mMinFractionRendered; + + /** + * The time in milliseconds required for the {@link SurfaceControl} to be in the threshold. + */ + @IntRange(from = 1) + public final int mStabilityRequirementMs; + + private void checkValid() { + if (mMinAlpha <= 0 || mMinFractionRendered <= 0 || mStabilityRequirementMs < 1) { + throw new IllegalArgumentException( + "TrustedPresentationThresholds values are invalid"); + } + } + + /** + * Creates a new TrustedPresentationThresholds. + * + * @param minAlpha The min alpha the {@link SurfaceControl} is required to + * have to be considered inside the + * threshold. + * @param minFractionRendered The min fraction of the SurfaceControl that was presented + * to the user to be considered + * inside the threshold. + * @param stabilityRequirementMs The time in milliseconds required for the + * {@link SurfaceControl} to be in the threshold. + */ + public TrustedPresentationThresholds( + @FloatRange(from = 0f, fromInclusive = false, to = 1f) float minAlpha, + @FloatRange(from = 0f, fromInclusive = false, to = 1f) float minFractionRendered, + @IntRange(from = 1) int stabilityRequirementMs) { + this.mMinAlpha = minAlpha; + this.mMinFractionRendered = minFractionRendered; + this.mStabilityRequirementMs = stabilityRequirementMs; + checkValid(); + } + + @Override + public String toString() { + return "TrustedPresentationThresholds { " + + "minAlpha = " + mMinAlpha + ", " + + "minFractionRendered = " + mMinFractionRendered + ", " + + "stabilityRequirementMs = " + mStabilityRequirementMs + + " }"; + } + + @Override + public void writeToParcel(@NonNull Parcel dest, int flags) { + dest.writeFloat(mMinAlpha); + dest.writeFloat(mMinFractionRendered); + dest.writeInt(mStabilityRequirementMs); + } + + @Override + public int describeContents() { + return 0; + } + + /** + * @hide + */ + TrustedPresentationThresholds(@NonNull Parcel in) { + mMinAlpha = in.readFloat(); + mMinFractionRendered = in.readFloat(); + mStabilityRequirementMs = in.readInt(); + + checkValid(); + } + + /** + * @hide + */ + public static final @NonNull Creator<TrustedPresentationThresholds> CREATOR = + new Creator<TrustedPresentationThresholds>() { + @Override + public TrustedPresentationThresholds[] newArray(int size) { + return new TrustedPresentationThresholds[size]; + } + + @Override + public TrustedPresentationThresholds createFromParcel(@NonNull Parcel in) { + return new TrustedPresentationThresholds(in); + } + }; +} diff --git a/core/java/android/window/flags/large_screen_experiences_app_compat.aconfig b/core/java/android/window/flags/large_screen_experiences_app_compat.aconfig index 9fe30df13036..727bff44017e 100644 --- a/core/java/android/window/flags/large_screen_experiences_app_compat.aconfig +++ b/core/java/android/window/flags/large_screen_experiences_app_compat.aconfig @@ -14,4 +14,12 @@ flag { description: "Make it possible to move cutout across edges through device config" bug: "302387383" is_fixed_read_only: true -}
\ No newline at end of file +} + +flag { + name: "density_390_api" + namespace: "large_screen_experiences_app_compat" + description: "Whether the API DisplayMetrics.DENSITY_390 is available" + bug: "297550533" + is_fixed_read_only: true +} diff --git a/core/java/com/android/internal/protolog/ProtoLogGroup.java b/core/java/com/android/internal/protolog/ProtoLogGroup.java index 4bb7c33b41e2..8c2a52560050 100644 --- a/core/java/com/android/internal/protolog/ProtoLogGroup.java +++ b/core/java/com/android/internal/protolog/ProtoLogGroup.java @@ -93,6 +93,7 @@ public enum ProtoLogGroup implements IProtoLogGroup { WM_DEBUG_DREAM(Consts.ENABLE_DEBUG, Consts.ENABLE_LOG_TO_PROTO_DEBUG, true, Consts.TAG_WM), WM_DEBUG_DIMMER(Consts.ENABLE_DEBUG, Consts.ENABLE_LOG_TO_PROTO_DEBUG, false, Consts.TAG_WM), + WM_DEBUG_TPL(Consts.ENABLE_DEBUG, Consts.ENABLE_LOG_TO_PROTO_DEBUG, false, Consts.TAG_WM), TEST_GROUP(true, true, false, "WindowManagerProtoLogTest"); private final boolean mEnabled; diff --git a/core/proto/android/service/notification.proto b/core/proto/android/service/notification.proto index 17ca7c80707c..a2978bec16b5 100644 --- a/core/proto/android/service/notification.proto +++ b/core/proto/android/service/notification.proto @@ -359,6 +359,8 @@ message DNDPolicyProto { optional PeopleType allow_messages_from = 18; optional ConversationType allow_conversations_from = 19; + + optional ChannelType allow_channels = 20; } // Enum identifying the type of rule that changed; values set to match ones used in the @@ -368,3 +370,11 @@ enum RuleType { RULE_TYPE_MANUAL = 1; RULE_TYPE_AUTOMATIC = 2; } + +// Enum used in DNDPolicyProto to indicate the type of channels permitted to +// break through DND. Mirrors values in ZenPolicy. +enum ChannelType { + CHANNEL_TYPE_UNSET = 0; + CHANNEL_TYPE_PRIORITY = 1; + CHANNEL_TYPE_NONE = 2; +} diff --git a/core/tests/coretests/src/android/view/ViewRootImplTest.java b/core/tests/coretests/src/android/view/ViewRootImplTest.java index e0e3a3542cb0..617262203c6b 100644 --- a/core/tests/coretests/src/android/view/ViewRootImplTest.java +++ b/core/tests/coretests/src/android/view/ViewRootImplTest.java @@ -628,6 +628,42 @@ public class ViewRootImplTest { }); } + /** + * We should boost the frame rate if the value of mInsetsAnimationRunning is true. + */ + @Test + @RequiresFlagsEnabled(FLAG_TOOLKIT_SET_FRAME_RATE_READ_ONLY) + public void votePreferredFrameRate_insetsAnimation() { + View view = new View(sContext); + WindowManager.LayoutParams wmlp = new WindowManager.LayoutParams(TYPE_APPLICATION_OVERLAY); + wmlp.token = new Binder(); // Set a fake token to bypass 'is your activity running' check + + sInstrumentation.runOnMainSync(() -> { + WindowManager wm = sContext.getSystemService(WindowManager.class); + Display display = wm.getDefaultDisplay(); + DisplayMetrics metrics = new DisplayMetrics(); + display.getMetrics(metrics); + wmlp.width = (int) (metrics.widthPixels * 0.9); + wmlp.height = (int) (metrics.heightPixels * 0.9); + wm.addView(view, wmlp); + }); + sInstrumentation.waitForIdleSync(); + + ViewRootImpl viewRootImpl = view.getViewRootImpl(); + sInstrumentation.runOnMainSync(() -> { + view.invalidate(); + assertEquals(viewRootImpl.getLastPreferredFrameRateCategory(), + FRAME_RATE_CATEGORY_NORMAL); + viewRootImpl.notifyInsetsAnimationRunningStateChanged(true); + view.invalidate(); + }); + sInstrumentation.waitForIdleSync(); + + sInstrumentation.runOnMainSync(() -> { + assertEquals(viewRootImpl.getLastPreferredFrameRateCategory(), + FRAME_RATE_CATEGORY_HIGH); + }); + } @Test public void forceInvertOffDarkThemeOff_forceDarkModeDisabled() { diff --git a/data/etc/services.core.protolog.json b/data/etc/services.core.protolog.json index 2237ba1924db..19128212094d 100644 --- a/data/etc/services.core.protolog.json +++ b/data/etc/services.core.protolog.json @@ -595,6 +595,12 @@ "group": "WM_ERROR", "at": "com\/android\/server\/wm\/WindowManagerService.java" }, + "-1518132958": { + "message": "fractionRendered boundsOverSource=%f", + "level": "VERBOSE", + "group": "WM_DEBUG_TPL", + "at": "com\/android\/server\/wm\/TrustedPresentationListenerController.java" + }, "-1517908912": { "message": "requestScrollCapture: caught exception dispatching to window.token=%s", "level": "WARN", @@ -961,6 +967,12 @@ "group": "WM_DEBUG_CONTENT_RECORDING", "at": "com\/android\/server\/wm\/ContentRecorder.java" }, + "-1209762265": { + "message": "Registering listener=%s with id=%d for window=%s with %s", + "level": "DEBUG", + "group": "WM_DEBUG_TPL", + "at": "com\/android\/server\/wm\/TrustedPresentationListenerController.java" + }, "-1209252064": { "message": "Clear animatingExit: reason=clearAnimatingFlags win=%s", "level": "DEBUG", @@ -1333,6 +1345,12 @@ "group": "WM_DEBUG_WINDOW_TRANSITIONS", "at": "com\/android\/server\/wm\/Transition.java" }, + "-888703350": { + "message": "Skipping %s", + "level": "VERBOSE", + "group": "WM_DEBUG_TPL", + "at": "com\/android\/server\/wm\/TrustedPresentationListenerController.java" + }, "-883738232": { "message": "Adding more than one toast window for UID at a time.", "level": "WARN", @@ -2803,6 +2821,12 @@ "group": "WM_DEBUG_ORIENTATION", "at": "com\/android\/server\/wm\/WindowManagerService.java" }, + "360319850": { + "message": "fractionRendered scale=%f", + "level": "VERBOSE", + "group": "WM_DEBUG_TPL", + "at": "com\/android\/server\/wm\/TrustedPresentationListenerController.java" + }, "364992694": { "message": "freezeDisplayRotation: current rotation=%d, new rotation=%d, caller=%s", "level": "VERBOSE", @@ -2983,6 +3007,12 @@ "group": "WM_DEBUG_BACK_PREVIEW", "at": "com\/android\/server\/wm\/BackNavigationController.java" }, + "532771960": { + "message": "Adding untrusted state listener=%s with id=%d", + "level": "DEBUG", + "group": "WM_DEBUG_TPL", + "at": "com\/android\/server\/wm\/TrustedPresentationListenerController.java" + }, "535103992": { "message": "Wallpaper may change! Adjusting", "level": "VERBOSE", @@ -3061,6 +3091,12 @@ "group": "WM_DEBUG_DREAM", "at": "com\/android\/server\/wm\/ActivityTaskManagerService.java" }, + "605179032": { + "message": "checkIfInThreshold fractionRendered=%f alpha=%f currTimeMs=%d", + "level": "VERBOSE", + "group": "WM_DEBUG_TPL", + "at": "com\/android\/server\/wm\/TrustedPresentationListenerController.java" + }, "608694300": { "message": " NEW SURFACE SESSION %s", "level": "INFO", @@ -3289,6 +3325,12 @@ "group": "WM_SHOW_TRANSACTIONS", "at": "com\/android\/server\/wm\/WindowState.java" }, + "824532141": { + "message": "lastState=%s newState=%s alpha=%f minAlpha=%f fractionRendered=%f minFractionRendered=%f", + "level": "VERBOSE", + "group": "WM_DEBUG_TPL", + "at": "com\/android\/server\/wm\/TrustedPresentationListenerController.java" + }, "829434921": { "message": "Draw state now committed in %s", "level": "VERBOSE", @@ -3583,6 +3625,12 @@ "group": "WM_SHOW_SURFACE_ALLOC", "at": "com\/android\/server\/wm\/ScreenRotationAnimation.java" }, + "1090378847": { + "message": "Checking %d windows", + "level": "VERBOSE", + "group": "WM_DEBUG_TPL", + "at": "com\/android\/server\/wm\/TrustedPresentationListenerController.java" + }, "1100065297": { "message": "Attempted to get IME policy of a display that does not exist: %d", "level": "WARN", @@ -3715,6 +3763,12 @@ "group": "WM_DEBUG_FOCUS", "at": "com\/android\/server\/wm\/ActivityRecord.java" }, + "1251721200": { + "message": "unregister failed, couldn't find deathRecipient for %s with id=%d", + "level": "ERROR", + "group": "WM_DEBUG_TPL", + "at": "com\/android\/server\/wm\/TrustedPresentationListenerController.java" + }, "1252594551": { "message": "Window types in WindowContext and LayoutParams.type should match! Type from LayoutParams is %d, but type from WindowContext is %d", "level": "WARN", @@ -3853,6 +3907,12 @@ "group": "WM_DEBUG_ORIENTATION", "at": "com\/android\/server\/wm\/TaskDisplayArea.java" }, + "1382634842": { + "message": "Unregistering listener=%s with id=%d", + "level": "DEBUG", + "group": "WM_DEBUG_TPL", + "at": "com\/android\/server\/wm\/TrustedPresentationListenerController.java" + }, "1393721079": { "message": "Starting remote display change: from [rot = %d], to [%dx%d, rot = %d]", "level": "VERBOSE", @@ -3901,6 +3961,12 @@ "group": "WM_ERROR", "at": "com\/android\/server\/wm\/WindowManagerService.java" }, + "1445704347": { + "message": "coveredRegionsAbove updated with %s frame:%s region:%s", + "level": "VERBOSE", + "group": "WM_DEBUG_TPL", + "at": "com\/android\/server\/wm\/TrustedPresentationListenerController.java" + }, "1448683958": { "message": "Override pending remote transitionSet=%b adapter=%s", "level": "INFO", @@ -4201,6 +4267,12 @@ "group": "WM_DEBUG_RECENTS_ANIMATIONS", "at": "com\/android\/server\/wm\/RecentsAnimation.java" }, + "1786463281": { + "message": "Adding trusted state listener=%s with id=%d", + "level": "DEBUG", + "group": "WM_DEBUG_TPL", + "at": "com\/android\/server\/wm\/TrustedPresentationListenerController.java" + }, "1789321832": { "message": "Then token:%s is invalid. It might be removed", "level": "WARN", @@ -4375,6 +4447,12 @@ "group": "WM_DEBUG_TASKS", "at": "com\/android\/server\/wm\/RootWindowContainer.java" }, + "1955470028": { + "message": "computeFractionRendered: visibleRegion=%s screenBounds=%s contentSize=%s scale=%f,%f", + "level": "VERBOSE", + "group": "WM_DEBUG_TPL", + "at": "com\/android\/server\/wm\/TrustedPresentationListenerController.java" + }, "1964565370": { "message": "Starting remote animation", "level": "INFO", @@ -4659,6 +4737,9 @@ "WM_DEBUG_TASKS": { "tag": "WindowManager" }, + "WM_DEBUG_TPL": { + "tag": "WindowManager" + }, "WM_DEBUG_WALLPAPER": { "tag": "WindowManager" }, diff --git a/libs/WindowManager/Shell/src/com/android/wm/shell/bubbles/BubblePositioner.java b/libs/WindowManager/Shell/src/com/android/wm/shell/bubbles/BubblePositioner.java index baa52a0b5626..5d161962be4a 100644 --- a/libs/WindowManager/Shell/src/com/android/wm/shell/bubbles/BubblePositioner.java +++ b/libs/WindowManager/Shell/src/com/android/wm/shell/bubbles/BubblePositioner.java @@ -397,6 +397,9 @@ public class BubblePositioner { * the screen and the size of the elements around it (e.g. padding, pointer, manage button). */ public int getMaxExpandedViewHeight(boolean isOverflow) { + if (mDeviceConfig.isLargeScreen() && !mDeviceConfig.isSmallTablet() && !isOverflow) { + return getExpandedViewHeightForLargeScreen(); + } // Subtract top insets because availableRect.height would account for that int expandedContainerY = (int) getExpandedViewYTopAligned() - getInsets().top; int paddingTop = showBubblesVertically() @@ -414,6 +417,16 @@ public class BubblePositioner { - bottomPadding; } + private int getExpandedViewHeightForLargeScreen() { + // the expanded view height on large tablets is calculated based on the shortest screen + // size and is the same in both portrait and landscape + int maxVerticalInset = Math.max(mInsets.top, mInsets.bottom); + int shortestScreenSide = Math.min(getScreenRect().height(), getScreenRect().width()); + // Subtract pointer size because it's laid out in LinearLayout with the expanded view. + return shortestScreenSide - maxVerticalInset * 2 + - mManageButtonHeight - mPointerWidth - mExpandedViewPadding * 2; + } + /** * Determines the height for the bubble, ensuring a minimum height. If the height should be as * big as available, returns {@link #MAX_HEIGHT}. @@ -424,15 +437,6 @@ public class BubblePositioner { // overflow in landscape on phone is max return MAX_HEIGHT; } - - if (mDeviceConfig.isLargeScreen() && !mDeviceConfig.isSmallTablet() && !isOverflow) { - // the expanded view height on large tablets is calculated based on the shortest screen - // size and is the same in both portrait and landscape - int maxVerticalInset = Math.max(mInsets.top, mInsets.bottom); - int shortestScreenSide = Math.min(mScreenRect.height(), mScreenRect.width()); - return shortestScreenSide - 2 * maxVerticalInset - mManageButtonHeight; - } - float desiredHeight = isOverflow ? mOverflowHeight : ((Bubble) bubble).getDesiredHeight(mContext); diff --git a/libs/WindowManager/Shell/src/com/android/wm/shell/pip/PipTaskOrganizer.java b/libs/WindowManager/Shell/src/com/android/wm/shell/pip/PipTaskOrganizer.java index fdd30448995f..c1164fca22f2 100644 --- a/libs/WindowManager/Shell/src/com/android/wm/shell/pip/PipTaskOrganizer.java +++ b/libs/WindowManager/Shell/src/com/android/wm/shell/pip/PipTaskOrganizer.java @@ -123,7 +123,7 @@ public class PipTaskOrganizer implements ShellTaskOrganizer.TaskListener, private static final int EXTRA_CONTENT_OVERLAY_FADE_OUT_DELAY_MS = SystemProperties.getInt( - "persist.wm.debug.extra_content_overlay_fade_out_delay_ms", 450); + "persist.wm.debug.extra_content_overlay_fade_out_delay_ms", 400); private final Context mContext; private final SyncTransactionQueue mSyncTransactionQueue; diff --git a/libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/bubbles/BubblePositionerTest.java b/libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/bubbles/BubblePositionerTest.java index 835ebe2206ad..e5ae6e515566 100644 --- a/libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/bubbles/BubblePositionerTest.java +++ b/libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/bubbles/BubblePositionerTest.java @@ -16,10 +16,15 @@ package com.android.wm.shell.bubbles; +import static com.android.wm.shell.bubbles.BubblePositioner.MAX_HEIGHT; + import static com.google.common.truth.Truth.assertThat; import static com.google.common.util.concurrent.MoreExecutors.directExecutor; +import static org.mockito.Mockito.mock; + import android.content.Intent; +import android.content.pm.ShortcutInfo; import android.graphics.Insets; import android.graphics.PointF; import android.graphics.Rect; @@ -226,7 +231,7 @@ public class BubblePositionerTest extends ShellTestCase { } @Test - public void testExpandedViewHeight_onLargeTablet() { + public void testGetExpandedViewHeight_max() { Insets insets = Insets.of(10, 20, 5, 15); Rect screenBounds = new Rect(0, 0, 1800, 2600); @@ -240,10 +245,91 @@ public class BubblePositionerTest extends ShellTestCase { Intent intent = new Intent(Intent.ACTION_VIEW).setPackage(mContext.getPackageName()); Bubble bubble = Bubble.createAppBubble(intent, new UserHandle(1), null, directExecutor()); + assertThat(mPositioner.getExpandedViewHeight(bubble)).isEqualTo(MAX_HEIGHT); + } + + @Test + public void testGetExpandedViewHeight_customHeight_valid() { + Insets insets = Insets.of(10, 20, 5, 15); + Rect screenBounds = new Rect(0, 0, 1800, 2600); + + DeviceConfig deviceConfig = new ConfigBuilder() + .setLargeScreen() + .setInsets(insets) + .setScreenBounds(screenBounds) + .build(); + mPositioner.update(deviceConfig); + + final int minHeight = mContext.getResources().getDimensionPixelSize( + R.dimen.bubble_expanded_default_height); + Bubble bubble = new Bubble("key", + mock(ShortcutInfo.class), + minHeight + 100 /* desiredHeight */, + 0 /* desiredHeightResId */, + "title", + 0 /* taskId */, + null /* locus */, + true /* isDismissable */, + directExecutor(), + mock(Bubbles.BubbleMetadataFlagListener.class)); + + // Ensure the height is the same as the desired value + assertThat(mPositioner.getExpandedViewHeight(bubble)).isEqualTo( + bubble.getDesiredHeight(mContext)); + } + + + @Test + public void testGetExpandedViewHeight_customHeight_tooSmall() { + Insets insets = Insets.of(10, 20, 5, 15); + Rect screenBounds = new Rect(0, 0, 1800, 2600); + + DeviceConfig deviceConfig = new ConfigBuilder() + .setLargeScreen() + .setInsets(insets) + .setScreenBounds(screenBounds) + .build(); + mPositioner.update(deviceConfig); + + Bubble bubble = new Bubble("key", + mock(ShortcutInfo.class), + 10 /* desiredHeight */, + 0 /* desiredHeightResId */, + "title", + 0 /* taskId */, + null /* locus */, + true /* isDismissable */, + directExecutor(), + mock(Bubbles.BubbleMetadataFlagListener.class)); + + // Ensure the height is the same as the minimum value + final int minHeight = mContext.getResources().getDimensionPixelSize( + R.dimen.bubble_expanded_default_height); + assertThat(mPositioner.getExpandedViewHeight(bubble)).isEqualTo(minHeight); + } + + @Test + public void testGetMaxExpandedViewHeight_onLargeTablet() { + Insets insets = Insets.of(10, 20, 5, 15); + Rect screenBounds = new Rect(0, 0, 1800, 2600); + + DeviceConfig deviceConfig = new ConfigBuilder() + .setLargeScreen() + .setInsets(insets) + .setScreenBounds(screenBounds) + .build(); + mPositioner.update(deviceConfig); + int manageButtonHeight = mContext.getResources().getDimensionPixelSize(R.dimen.bubble_manage_button_height); - float expectedHeight = 1800 - 2 * 20 - manageButtonHeight; - assertThat(mPositioner.getExpandedViewHeight(bubble)).isWithin(0.1f).of(expectedHeight); + int pointerWidth = mContext.getResources().getDimensionPixelSize( + R.dimen.bubble_pointer_width); + int expandedViewPadding = mContext.getResources().getDimensionPixelSize(R + .dimen.bubble_expanded_view_padding); + float expectedHeight = 1800 - 2 * 20 - manageButtonHeight - pointerWidth + - expandedViewPadding * 2; + assertThat(((float) mPositioner.getMaxExpandedViewHeight(false /* isOverflow */))) + .isWithin(0.1f).of(expectedHeight); } /** diff --git a/media/java/android/media/AudioAttributes.java b/media/java/android/media/AudioAttributes.java index bf9419fe6603..4be282b5de87 100644 --- a/media/java/android/media/AudioAttributes.java +++ b/media/java/android/media/AudioAttributes.java @@ -29,6 +29,7 @@ import android.os.Bundle; import android.os.Parcel; import android.os.Parcelable; import android.text.TextUtils; +import android.util.IntArray; import android.util.Log; import android.util.SparseIntArray; import android.util.proto.ProtoOutputStream; @@ -330,7 +331,7 @@ public final class AudioAttributes implements Parcelable { * @hide * Array of all usage types exposed in the SDK that applications can use. */ - public final static int[] SDK_USAGES = { + public static final IntArray SDK_USAGES = IntArray.wrap(new int[] { USAGE_UNKNOWN, USAGE_MEDIA, USAGE_VOICE_COMMUNICATION, @@ -347,14 +348,14 @@ public final class AudioAttributes implements Parcelable { USAGE_ASSISTANCE_SONIFICATION, USAGE_GAME, USAGE_ASSISTANT, - }; + }); /** * @hide */ @TestApi public static int[] getSdkUsages() { - return SDK_USAGES; + return SDK_USAGES.toArray(); } /** @@ -567,6 +568,15 @@ public final class AudioAttributes implements Parcelable { private String mFormattedTags; private Bundle mBundle; // lazy-initialized, may be null + /** Array of all content types exposed in the SDK that applications can use */ + private static final IntArray CONTENT_TYPES = IntArray.wrap(new int[]{ + CONTENT_TYPE_UNKNOWN, + CONTENT_TYPE_SPEECH, + CONTENT_TYPE_MUSIC, + CONTENT_TYPE_MOVIE, + CONTENT_TYPE_SONIFICATION, + }); + private AudioAttributes() { } @@ -1669,6 +1679,27 @@ public final class AudioAttributes implements Parcelable { } /** + * Query if the usage is a valid sdk usage + * + * @param usage one of {@link AttributeSdkUsage} + * @return {@code true} if the usage is valid for sdk or {@code false} otherwise + * @hide + */ + public static boolean isSdkUsage(@AttributeSdkUsage int usage) { + return SDK_USAGES.contains(usage); + } + + /** + * Query if the content type is a valid sdk content type + * @param contentType one of {@link AttributeContentType} + * @return {@code true} if the content type is valid for sdk or {@code false} otherwise + * @hide + */ + public static boolean isSdkContentType(@AttributeContentType int contentType) { + return CONTENT_TYPES.contains(contentType); + } + + /** * Returns the stream type matching this {@code AudioAttributes} instance for volume control. * Use this method to derive the stream type needed to configure the volume * control slider in an {@link android.app.Activity} with diff --git a/media/java/android/media/AudioSystem.java b/media/java/android/media/AudioSystem.java index 367b38a152fc..9ffd644493db 100644 --- a/media/java/android/media/AudioSystem.java +++ b/media/java/android/media/AudioSystem.java @@ -318,11 +318,12 @@ public class AudioSystem /** * @hide - * Convert a Bluetooth codec to an audio format enum + * Convert an A2DP Bluetooth codec to an audio format enum * @param btCodec the codec to convert. * @return the audio format, or {@link #AUDIO_FORMAT_DEFAULT} if unknown */ - public static @AudioFormatNativeEnumForBtCodec int bluetoothCodecToAudioFormat(int btCodec) { + public static @AudioFormatNativeEnumForBtCodec int bluetoothA2dpCodecToAudioFormat( + int btCodec) { switch (btCodec) { case BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC: return AudioSystem.AUDIO_FORMAT_SBC; @@ -339,7 +340,25 @@ public class AudioSystem case BluetoothCodecConfig.SOURCE_CODEC_TYPE_OPUS: return AudioSystem.AUDIO_FORMAT_OPUS; default: - Log.e(TAG, "Unknown BT codec 0x" + Integer.toHexString(btCodec) + Log.e(TAG, "Unknown A2DP BT codec 0x" + Integer.toHexString(btCodec) + + " for conversion to audio format"); + // TODO returning DEFAULT is the current behavior, should this return INVALID? + return AudioSystem.AUDIO_FORMAT_DEFAULT; + } + } + + /** + * @hide + * Convert a LE Audio Bluetooth codec to an audio format enum + * @param btCodec the codec to convert. + * @return the audio format, or {@link #AUDIO_FORMAT_DEFAULT} if unknown + */ + public static @AudioFormatNativeEnumForBtCodec int bluetoothLeCodecToAudioFormat(int btCodec) { + switch (btCodec) { + case BluetoothLeAudioCodecConfig.SOURCE_CODEC_TYPE_LC3: + return AudioSystem.AUDIO_FORMAT_LC3; + default: + Log.e(TAG, "Unknown LE Audio BT codec 0x" + Integer.toHexString(btCodec) + " for conversion to audio format"); // TODO returning DEFAULT is the current behavior, should this return INVALID? return AudioSystem.AUDIO_FORMAT_DEFAULT; diff --git a/media/java/android/media/FadeManagerConfiguration.aidl b/media/java/android/media/FadeManagerConfiguration.aidl new file mode 100644 index 000000000000..ceb4ded76dcf --- /dev/null +++ b/media/java/android/media/FadeManagerConfiguration.aidl @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2023 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 android.media; + +/** + * Class to encapsulate fade configurations. + * @hide + */ +parcelable FadeManagerConfiguration; diff --git a/media/java/android/media/FadeManagerConfiguration.java b/media/java/android/media/FadeManagerConfiguration.java new file mode 100644 index 000000000000..337d4b0a916c --- /dev/null +++ b/media/java/android/media/FadeManagerConfiguration.java @@ -0,0 +1,1684 @@ +/* + * Copyright (C) 2023 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 android.media; + +import static com.android.media.flags.Flags.FLAG_ENABLE_FADE_MANAGER_CONFIGURATION; + +import android.annotation.FlaggedApi; +import android.annotation.IntDef; +import android.annotation.NonNull; +import android.annotation.Nullable; +import android.os.Parcel; +import android.os.Parcelable; +import android.util.ArrayMap; +import android.util.IntArray; +import android.util.SparseArray; + +import com.android.internal.annotations.VisibleForTesting; +import com.android.internal.util.Preconditions; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Objects; + +/** + * Class to encapsulate fade configurations. + * + * <p>Configurations are provided through: + * <ul> + * <li>Fadeable list: a positive list of fadeable type - usage</li> + * <li>Unfadeable lists: negative list of unfadeable types - content type, uid, audio attributes + * </li> + * <li>Volume shaper configs: fade in and fade out configs per usage or audio attributes + * </li> + * </ul> + * + * <p>Fade manager configuration can be created in one of the following ways: + * <ul> + * <li>Disabled fades: + * <pre class="prettyprint"> + * new FadeManagerConfiguration.Builder() + * .setFadeState(FADE_STATE_DISABLED).build() + * </pre> + * Can be used to disable fading</li> + * <li>Default configurations including default fade duration: + * <pre class="prettyprint"> + * new FadeManagerConfiguration.Builder() + * .setFadeState(FADE_STATE_ENABLED_DEFAULT).build() + * </pre> + * Can be used to enable default fading configurations</li> + * <li>Default configurations with custom fade duration: + * <pre class="prettyprint"> + * new FadeManagerConfiguration.Builder(fade out duration, fade in duration) + * .setFadeState(FADE_STATE_ENABLED_DEFAULT).build() + * </pre> + * Can be used to enable default fadeability lists with configurable fade in and out duration + * </li> + * <li>Custom configurations and fade volume shapers: + * <pre class="prettyprint"> + * new FadeManagerConfiguration.Builder(fade out duration, fade in duration) + * .setFadeState(FADE_STATE_ENABLED_DEFAULT) + * .setFadeableUsages(list of usages) + * .setUnfadeableContentTypes(list of content types) + * .setUnfadeableUids(list of uids) + * .setUnfadeableAudioAttributes(list of audio attributes) + * .setFadeOutVolumeShaperConfigForAudioAttributes(attributes, volume shaper config) + * .setFadeInDurationForUsaeg(usage, duration) + * .... + * .build() </pre> + * Achieves full customization of fadeability lists and configurations</li> + * <li>Also provides a copy constructor from another instance of fade manager configuration + * <pre class="prettyprint"> + * new FadeManagerConfiguration.Builder(fadeManagerConfiguration) + * .addFadeableUsage(new usage) + * .... + * .build()</pre> + * Helps with recreating a new instance from another to simply change/add on top of the + * existing ones</li> + * </ul> + * TODO(b/304835727): Convert into system API so that it can be set through AudioPolicy + * + * @hide + */ + +@FlaggedApi(FLAG_ENABLE_FADE_MANAGER_CONFIGURATION) +public final class FadeManagerConfiguration implements Parcelable { + + public static final String TAG = "FadeManagerConfiguration"; + + /** + * Defines the disabled fade state. No player will be faded in this state. + */ + public static final int FADE_STATE_DISABLED = 0; + + /** + * Defines the enabled fade state with default configurations + */ + public static final int FADE_STATE_ENABLED_DEFAULT = 1; + + /** + * Defines the enabled state with Automotive specific configurations + */ + public static final int FADE_STATE_ENABLED_AUTO = 2; + + /** @hide */ + @Retention(RetentionPolicy.SOURCE) + @IntDef(flag = false, prefix = "FADE_STATE", value = { + FADE_STATE_DISABLED, + FADE_STATE_ENABLED_DEFAULT, + FADE_STATE_ENABLED_AUTO, + }) + public @interface FadeStateEnum {} + + /** + * Defines ID to be used in volume shaper for fading + */ + public static final int VOLUME_SHAPER_SYSTEM_FADE_ID = 2; + + /** + * Used to reset duration or return duration when not set + * + * @see Builder#setFadeOutDurationForUsage(int, long) + * @see Builder#setFadeInDurationForUsage(int, long) + * @see Builder#setFadeOutDurationForAudioAttributes(AudioAttributes, long) + * @see Builder#setFadeInDurationForAudioAttributes(AudioAttributes, long) + * @see #getFadeOutDurationForUsage(int) + * @see #getFadeInDurationForUsage(int) + * @see #getFadeOutDurationForAudioAttributes(AudioAttributes) + * @see #getFadeInDurationForAudioAttributes(AudioAttributes) + */ + public static final long DURATION_NOT_SET = 0; + /** Map of Usage to Fade volume shaper configs wrapper */ + private final SparseArray<FadeVolumeShaperConfigsWrapper> mUsageToFadeWrapperMap; + /** Map of AudioAttributes to Fade volume shaper configs wrapper */ + private final ArrayMap<AudioAttributes, FadeVolumeShaperConfigsWrapper> mAttrToFadeWrapperMap; + /** list of fadeable usages */ + private final @NonNull IntArray mFadeableUsages; + /** list of unfadeable content types */ + private final @NonNull IntArray mUnfadeableContentTypes; + /** list of unfadeable player types */ + private final @NonNull IntArray mUnfadeablePlayerTypes; + /** list of unfadeable uid(s) */ + private final @NonNull IntArray mUnfadeableUids; + /** list of unfadeable AudioAttributes */ + private final @NonNull List<AudioAttributes> mUnfadeableAudioAttributes; + /** fade state */ + private final @FadeStateEnum int mFadeState; + /** fade out duration from builder - used for creating default fade out volume shaper */ + private final long mFadeOutDurationMillis; + /** fade in duration from builder - used for creating default fade in volume shaper */ + private final long mFadeInDurationMillis; + /** delay after which the offending players are faded back in */ + private final long mFadeInDelayForOffendersMillis; + + private FadeManagerConfiguration(int fadeState, long fadeOutDurationMillis, + long fadeInDurationMillis, long offendersFadeInDelayMillis, + @NonNull SparseArray<FadeVolumeShaperConfigsWrapper> usageToFadeWrapperMap, + @NonNull ArrayMap<AudioAttributes, FadeVolumeShaperConfigsWrapper> attrToFadeWrapperMap, + @NonNull IntArray fadeableUsages, @NonNull IntArray unfadeableContentTypes, + @NonNull IntArray unfadeablePlayerTypes, @NonNull IntArray unfadeableUids, + @NonNull List<AudioAttributes> unfadeableAudioAttributes) { + mFadeState = fadeState; + mFadeOutDurationMillis = fadeOutDurationMillis; + mFadeInDurationMillis = fadeInDurationMillis; + mFadeInDelayForOffendersMillis = offendersFadeInDelayMillis; + mUsageToFadeWrapperMap = Objects.requireNonNull(usageToFadeWrapperMap, + "Usage to fade wrapper map cannot be null"); + mAttrToFadeWrapperMap = Objects.requireNonNull(attrToFadeWrapperMap, + "Attribute to fade wrapper map cannot be null"); + mFadeableUsages = Objects.requireNonNull(fadeableUsages, + "List of fadeable usages cannot be null"); + mUnfadeableContentTypes = Objects.requireNonNull(unfadeableContentTypes, + "List of unfadeable content types cannot be null"); + mUnfadeablePlayerTypes = Objects.requireNonNull(unfadeablePlayerTypes, + "List of unfadeable player types cannot be null"); + mUnfadeableUids = Objects.requireNonNull(unfadeableUids, + "List of unfadeable uids cannot be null"); + mUnfadeableAudioAttributes = Objects.requireNonNull(unfadeableAudioAttributes, + "List of unfadeable audio attributes cannot be null"); + } + + /** + * Get the fade state + * + * @return one of the {@link FadeStateEnum} state + */ + @FadeStateEnum + public int getFadeState() { + return mFadeState; + } + + /** + * Get the list of usages that can be faded + * + * @return list of {@link android.media.AudioAttributes.AttributeUsage} that shall be faded + * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED} + */ + @NonNull + public List<Integer> getFadeableUsages() { + ensureFadingIsEnabled(); + return convertIntArrayToIntegerList(mFadeableUsages); + } + + /** + * Get the list of {@link android.media.AudioPlaybackConfiguration.PlayerType player types} + * that cannot be faded + * + * @return list of {@link android.media.AudioPlaybackConfiguration.PlayerType} + * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED} + */ + @NonNull + public List<Integer> getUnfadeablePlayerTypes() { + ensureFadingIsEnabled(); + return convertIntArrayToIntegerList(mUnfadeablePlayerTypes); + } + + /** + * Get the list of {@link android.media.AudioAttributes.AttributeContentType content types} + * that cannot be faded + * + * @return list of {@link android.media.AudioAttributes.AttributeContentType} + * @throws IllegalStateExceptionif if the fade state is set to {@link #FADE_STATE_DISABLED} + */ + @NonNull + public List<Integer> getUnfadeableContentTypes() { + ensureFadingIsEnabled(); + return convertIntArrayToIntegerList(mUnfadeableContentTypes); + } + + /** + * Get the list of uids that cannot be faded + * + * @return list of uids that shall not be faded + * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED} + */ + @NonNull + public List<Integer> getUnfadeableUids() { + ensureFadingIsEnabled(); + return convertIntArrayToIntegerList(mUnfadeableUids); + } + + /** + * Get the list of {@link android.media.AudioAttributes} that cannot be faded + * + * @return list of {@link android.media.AudioAttributes} that shall not be faded + * @throws IllegalStateException if fade state is set to {@link #FADE_STATE_DISABLED} + */ + @NonNull + public List<AudioAttributes> getUnfadeableAudioAttributes() { + ensureFadingIsEnabled(); + return mUnfadeableAudioAttributes; + } + + /** + * Get the duration used to fade out players with + * {@link android.media.AudioAttributes.AttributeUsage} + * + * @param usage the {@link android.media.AudioAttributes.AttributeUsage} + * @return duration in milliseconds if set for the usage or {@link #DURATION_NOT_SET} otherwise + * @throws IllegalArgumentException if the usage is invalid + * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED} + */ + public long getFadeOutDurationForUsage(int usage) { + ensureFadingIsEnabled(); + validateUsage(usage); + return getDurationForVolumeShaperConfig(getVolumeShaperConfigFromWrapper( + mUsageToFadeWrapperMap.get(usage), /* isFadeIn= */ false)); + } + + /** + * Get the duration used to fade in players with + * {@link android.media.AudioAttributes.AttributeUsage} + * + * @param usage the {@link android.media.AudioAttributes.AttributeUsage} + * @return duration in milliseconds if set for the usage or {@link #DURATION_NOT_SET} otherwise + * @throws IllegalArgumentException if the usage is invalid + * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED} + */ + public long getFadeInDurationForUsage(int usage) { + ensureFadingIsEnabled(); + validateUsage(usage); + return getDurationForVolumeShaperConfig(getVolumeShaperConfigFromWrapper( + mUsageToFadeWrapperMap.get(usage), /* isFadeIn= */ true)); + } + + /** + * Get the {@link android.media.VolumeShaper.Configuration} used to fade out players with + * {@link android.media.AudioAttributes.AttributeUsage} + * + * @param usage the {@link android.media.AudioAttributes.AttributeUsage} + * @return {@link android.media.VolumeShaper.Configuration} if set for the usage or + * {@code null} otherwise + * @throws IllegalArgumentException if the usage is invalid + * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED} + */ + @Nullable + public VolumeShaper.Configuration getFadeOutVolumeShaperConfigForUsage(int usage) { + ensureFadingIsEnabled(); + validateUsage(usage); + return getVolumeShaperConfigFromWrapper(mUsageToFadeWrapperMap.get(usage), + /* isFadeIn= */ false); + } + + /** + * Get the {@link android.media.VolumeShaper.Configuration} used to fade in players with + * {@link android.media.AudioAttributes.AttributeUsage} + * + * @param usage the {@link android.media.AudioAttributes.AttributeUsage} of player + * @return {@link android.media.VolumeShaper.Configuration} if set for the usage or + * {@code null} otherwise + * @throws IllegalArgumentException if the usage is invalid + * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED} + */ + @Nullable + public VolumeShaper.Configuration getFadeInVolumeShaperConfigForUsage(int usage) { + ensureFadingIsEnabled(); + validateUsage(usage); + return getVolumeShaperConfigFromWrapper(mUsageToFadeWrapperMap.get(usage), + /* isFadeIn= */ true); + } + + /** + * Get the duration used to fade out players with {@link android.media.AudioAttributes} + * + * @param audioAttributes {@link android.media.AudioAttributes} + * @return duration in milliseconds if set for the audio attributes or + * {@link #DURATION_NOT_SET} otherwise + * @throws NullPointerException if the audio attributes is {@code null} + * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED} + */ + public long getFadeOutDurationForAudioAttributes(@NonNull AudioAttributes audioAttributes) { + ensureFadingIsEnabled(); + return getDurationForVolumeShaperConfig(getVolumeShaperConfigFromWrapper( + mAttrToFadeWrapperMap.get(audioAttributes), /* isFadeIn= */ false)); + } + + /** + * Get the duration used to fade-in players with {@link android.media.AudioAttributes} + * + * @param audioAttributes {@link android.media.AudioAttributes} + * @return duration in milliseconds if set for the audio attributes or + * {@link #DURATION_NOT_SET} otherwise + * @throws NullPointerException if the audio attributes is {@code null} + * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED} + */ + public long getFadeInDurationForAudioAttributes(@NonNull AudioAttributes audioAttributes) { + ensureFadingIsEnabled(); + return getDurationForVolumeShaperConfig(getVolumeShaperConfigFromWrapper( + mAttrToFadeWrapperMap.get(audioAttributes), /* isFadeIn= */ true)); + } + + /** + * Get the {@link android.media.VolumeShaper.Configuration} used to fade out players with + * {@link android.media.AudioAttributes} + * + * @param audioAttributes {@link android.media.AudioAttributes} + * @return {@link android.media.VolumeShaper.Configuration} if set for the audio attribute or + * {@code null} otherwise + * @throws NullPointerException if the audio attributes is {@code null} + * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED} + */ + @Nullable + public VolumeShaper.Configuration getFadeOutVolumeShaperConfigForAudioAttributes( + @NonNull AudioAttributes audioAttributes) { + Objects.requireNonNull(audioAttributes, "Audio attributes cannot be null"); + ensureFadingIsEnabled(); + return getVolumeShaperConfigFromWrapper(mAttrToFadeWrapperMap.get(audioAttributes), + /* isFadeIn= */ false); + } + + /** + * Get the {@link android.media.VolumeShaper.Configuration} used to fade out players with + * {@link android.media.AudioAttributes} + * + * @param audioAttributes {@link android.media.AudioAttributes} + * @return {@link android.media.VolumeShaper.Configuration} used for fading in if set for the + * audio attribute or {@code null} otherwise + * @throws NullPointerException if the audio attributes is {@code null} + * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED} + */ + @Nullable + public VolumeShaper.Configuration getFadeInVolumeShaperConfigForAudioAttributes( + @NonNull AudioAttributes audioAttributes) { + Objects.requireNonNull(audioAttributes, "Audio attributes cannot be null"); + ensureFadingIsEnabled(); + return getVolumeShaperConfigFromWrapper(mAttrToFadeWrapperMap.get(audioAttributes), + /* isFadeIn= */ true); + } + + /** + * Get the list of {@link android.media.AudioAttributes} for whome the volume shaper + * configurations are defined + * + * @return list of {@link android.media.AudioAttributes} with valid volume shaper configs or + * empty list if none set. + */ + @NonNull + public List<AudioAttributes> getAudioAttributesWithVolumeShaperConfigs() { + return getAudioAttributesInternal(); + } + + /** + * Get the delay after which the offending players are faded back in + * + * @return delay in milliseconds + */ + public long getFadeInDelayForOffenders() { + return mFadeInDelayForOffendersMillis; + } + + /** + * Query if fade is enabled + * + * @return {@code true} if fading is enabled, {@code false} otherwise + */ + public boolean isFadeEnabled() { + return mFadeState != FADE_STATE_DISABLED; + } + + /** + * Query if the usage is fadeable + * + * @param usage the {@link android.media.AudioAttributes.AttributeUsage} + * @return {@code true} if usage is fadeable, {@code false} otherwise + */ + public boolean isUsageFadeable(@AudioAttributes.AttributeUsage int usage) { + if (!isFadeEnabled()) { + return false; + } + return mFadeableUsages.contains(usage); + } + + /** + * Query if the content type is unfadeable + * + * @param contentType the {@link android.media.AudioAttributes.AttributeContentType} + * @return {@code true} if content type is unfadeable or if fade state is set to + * {@link #FADE_STATE_DISABLED}, {@code false} otherwise + */ + public boolean isContentTypeUnfadeable(@AudioAttributes.AttributeContentType int contentType) { + if (!isFadeEnabled()) { + return true; + } + return mUnfadeableContentTypes.contains(contentType); + } + + /** + * Query if the player type is unfadeable + * + * @param playerType the {@link android.media.AudioPlaybackConfiguration} player type + * @return {@code true} if player type is unfadeable or if fade state is set to + * {@link #FADE_STATE_DISABLED}, {@code false} otherwise + */ + public boolean isPlayerTypeUnfadeable(int playerType) { + if (!isFadeEnabled()) { + return true; + } + return mUnfadeablePlayerTypes.contains(playerType); + } + + /** + * Query if the audio attributes is unfadeable + * + * @param audioAttributes the {@link android.media.AudioAttributes} + * @return {@code true} if audio attributes is unfadeable or if fade state is set to + * {@link #FADE_STATE_DISABLED}, {@code false} otherwise + * @throws NullPointerException if the audio attributes is {@code null} + */ + public boolean isAudioAttributesUnfadeable(@NonNull AudioAttributes audioAttributes) { + Objects.requireNonNull(audioAttributes, "Audio attributes cannot be null"); + if (!isFadeEnabled()) { + return true; + } + return mUnfadeableAudioAttributes.contains(audioAttributes); + } + + /** + * Query if the uid is unfadeable + * + * @param uid the uid of application + * @return {@code true} if uid is unfadeable or if fade state is set to + * {@link #FADE_STATE_DISABLED}, {@code false} otherwise + */ + public boolean isUidUnfadeable(int uid) { + if (!isFadeEnabled()) { + return true; + } + return mUnfadeableUids.contains(uid); + } + + @Override + public String toString() { + return "FadeManagerConfiguration { fade state = " + fadeStateToString(mFadeState) + + ", fade out duration = " + mFadeOutDurationMillis + + ", fade in duration = " + mFadeInDurationMillis + + ", offenders fade in delay = " + mFadeInDelayForOffendersMillis + + ", fade volume shapers for audio attributes = " + mAttrToFadeWrapperMap + + ", fadeable usages = " + mFadeableUsages.toString() + + ", unfadeable content types = " + mUnfadeableContentTypes.toString() + + ", unfadeable player types = " + mUnfadeablePlayerTypes.toString() + + ", unfadeable uids = " + mUnfadeableUids.toString() + + ", unfadeable audio attributes = " + mUnfadeableAudioAttributes + "}"; + } + + /** + * Convert fade state into a human-readable string + * + * @param fadeState one of the fade state in {@link FadeStateEnum} + * @return human-readable string + */ + @NonNull + public static String fadeStateToString(@FadeStateEnum int fadeState) { + switch (fadeState) { + case FADE_STATE_DISABLED: + return "FADE_STATE_DISABLED"; + case FADE_STATE_ENABLED_DEFAULT: + return "FADE_STATE_ENABLED_DEFAULT"; + case FADE_STATE_ENABLED_AUTO: + return "FADE_STATE_ENABLED_AUTO"; + default: + return "unknown fade state: " + fadeState; + } + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + + if (!(o instanceof FadeManagerConfiguration)) { + return false; + } + + FadeManagerConfiguration rhs = (FadeManagerConfiguration) o; + + return mUsageToFadeWrapperMap.contentEquals(rhs.mUsageToFadeWrapperMap) + && mAttrToFadeWrapperMap.equals(rhs.mAttrToFadeWrapperMap) + && Arrays.equals(mFadeableUsages.toArray(), rhs.mFadeableUsages.toArray()) + && Arrays.equals(mUnfadeableContentTypes.toArray(), + rhs.mUnfadeableContentTypes.toArray()) + && Arrays.equals(mUnfadeablePlayerTypes.toArray(), + rhs.mUnfadeablePlayerTypes.toArray()) + && Arrays.equals(mUnfadeableUids.toArray(), rhs.mUnfadeableUids.toArray()) + && mUnfadeableAudioAttributes.equals(rhs.mUnfadeableAudioAttributes) + && mFadeState == rhs.mFadeState + && mFadeOutDurationMillis == rhs.mFadeOutDurationMillis + && mFadeInDurationMillis == rhs.mFadeInDurationMillis + && mFadeInDelayForOffendersMillis == rhs.mFadeInDelayForOffendersMillis; + } + + @Override + public int hashCode() { + return Objects.hash(mUsageToFadeWrapperMap, mAttrToFadeWrapperMap, mFadeableUsages, + mUnfadeableContentTypes, mUnfadeablePlayerTypes, mUnfadeableAudioAttributes, + mUnfadeableUids, mFadeState, mFadeOutDurationMillis, mFadeInDurationMillis, + mFadeInDelayForOffendersMillis); + } + + @Override + public void writeToParcel(@NonNull Parcel dest, int flags) { + dest.writeInt(mFadeState); + dest.writeLong(mFadeOutDurationMillis); + dest.writeLong(mFadeInDurationMillis); + dest.writeLong(mFadeInDelayForOffendersMillis); + dest.writeTypedSparseArray(mUsageToFadeWrapperMap, flags); + dest.writeMap(mAttrToFadeWrapperMap); + dest.writeIntArray(mFadeableUsages.toArray()); + dest.writeIntArray(mUnfadeableContentTypes.toArray()); + dest.writeIntArray(mUnfadeablePlayerTypes.toArray()); + dest.writeIntArray(mUnfadeableUids.toArray()); + dest.writeTypedList(mUnfadeableAudioAttributes, flags); + } + + /** + * Creates fade manage configuration from parcel + * + * @hide + */ + @VisibleForTesting() + FadeManagerConfiguration(Parcel in) { + int fadeState = in.readInt(); + long fadeOutDurationMillis = in.readLong(); + long fadeInDurationMillis = in.readLong(); + long fadeInDelayForOffenders = in.readLong(); + SparseArray<FadeVolumeShaperConfigsWrapper> usageToWrapperMap = + in.createTypedSparseArray(FadeVolumeShaperConfigsWrapper.CREATOR); + ArrayMap<AudioAttributes, FadeVolumeShaperConfigsWrapper> attrToFadeWrapperMap = + new ArrayMap<>(); + in.readMap(attrToFadeWrapperMap, getClass().getClassLoader(), AudioAttributes.class, + FadeVolumeShaperConfigsWrapper.class); + int[] fadeableUsages = in.createIntArray(); + int[] unfadeableContentTypes = in.createIntArray(); + int[] unfadeablePlayerTypes = in.createIntArray(); + int[] unfadeableUids = in.createIntArray(); + List<AudioAttributes> unfadeableAudioAttributes = new ArrayList<>(); + in.readTypedList(unfadeableAudioAttributes, AudioAttributes.CREATOR); + + this.mFadeState = fadeState; + this.mFadeOutDurationMillis = fadeOutDurationMillis; + this.mFadeInDurationMillis = fadeInDurationMillis; + this.mFadeInDelayForOffendersMillis = fadeInDelayForOffenders; + this.mUsageToFadeWrapperMap = usageToWrapperMap; + this.mAttrToFadeWrapperMap = attrToFadeWrapperMap; + this.mFadeableUsages = IntArray.wrap(fadeableUsages); + this.mUnfadeableContentTypes = IntArray.wrap(unfadeableContentTypes); + this.mUnfadeablePlayerTypes = IntArray.wrap(unfadeablePlayerTypes); + this.mUnfadeableUids = IntArray.wrap(unfadeableUids); + this.mUnfadeableAudioAttributes = unfadeableAudioAttributes; + } + + @NonNull + public static final Creator<FadeManagerConfiguration> CREATOR = new Creator<>() { + @Override + @NonNull + public FadeManagerConfiguration createFromParcel(@NonNull Parcel in) { + return new FadeManagerConfiguration(in); + } + + @Override + @NonNull + public FadeManagerConfiguration[] newArray(int size) { + return new FadeManagerConfiguration[size]; + } + }; + + private long getDurationForVolumeShaperConfig(VolumeShaper.Configuration config) { + return config != null ? config.getDuration() : DURATION_NOT_SET; + } + + private VolumeShaper.Configuration getVolumeShaperConfigFromWrapper( + FadeVolumeShaperConfigsWrapper wrapper, boolean isFadeIn) { + // if no volume shaper config is available, return null + if (wrapper == null) { + return null; + } + if (isFadeIn) { + return wrapper.getFadeInVolShaperConfig(); + } + return wrapper.getFadeOutVolShaperConfig(); + } + + private List<AudioAttributes> getAudioAttributesInternal() { + List<AudioAttributes> attrs = new ArrayList<>(mAttrToFadeWrapperMap.size()); + for (int index = 0; index < mAttrToFadeWrapperMap.size(); index++) { + attrs.add(mAttrToFadeWrapperMap.keyAt(index)); + } + return attrs; + } + + private static boolean isUsageValid(int usage) { + return AudioAttributes.isSdkUsage(usage) || AudioAttributes.isSystemUsage(usage); + } + + private void ensureFadingIsEnabled() { + if (!isFadeEnabled()) { + throw new IllegalStateException("Method call not allowed when fade is disabled"); + } + } + + private static void validateUsage(int usage) { + Preconditions.checkArgument(isUsageValid(usage), "Invalid usage: %s", usage); + } + + private static IntArray convertIntegerListToIntArray(List<Integer> integerList) { + if (integerList == null) { + return new IntArray(); + } + + IntArray intArray = new IntArray(integerList.size()); + for (int index = 0; index < integerList.size(); index++) { + intArray.add(integerList.get(index)); + } + return intArray; + } + + private static List<Integer> convertIntArrayToIntegerList(IntArray intArray) { + if (intArray == null) { + return new ArrayList<>(); + } + + ArrayList<Integer> integerArrayList = new ArrayList<>(intArray.size()); + for (int index = 0; index < intArray.size(); index++) { + integerArrayList.add(intArray.get(index)); + } + return integerArrayList; + } + + /** + * Builder class for {@link FadeManagerConfiguration} objects. + * + * <p><b>Notes:</b> + * <ul> + * <li>When fade state is set to enabled, the builder expects at least one valid usage to be + * set/added. Failure to do so will result in an exception during {@link #build()}</li> + * <li>Every usage added to the fadeable list should have corresponding volume shaper + * configs defined. This can be achieved by setting either the duration or volume shaper + * config through {@link #setFadeOutDurationForUsage(int, long)} or + * {@link #setFadeOutVolumeShaperConfigForUsage(int, VolumeShaper.Configuration)}</li> + * <li> It is recommended to set volume shaper configurations individually for fade out and + * fade in</li> + * <li>For any incomplete volume shaper configs a volume shaper configuration will be + * created using either the default fade durations or the ones provided as part of the + * {@link #Builder(long, long)}</li> + * <li>Additional volume shaper configs can also configured for a given usage + * with additional attributes like content-type in order to achieve finer fade controls. + * See: + * {@link #setFadeOutVolumeShaperConfigForAudioAttributes(AudioAttributes, + * VolumeShaper.Configuration)} and + * {@link #setFadeInVolumeShaperConfigForAudioAttributes(AudioAttributes, + * VolumeShaper.Configuration)} </li> + * </ul> + * + */ + @SuppressWarnings("WeakerAccess") + public static final class Builder { + private static final int INVALID_INDEX = -1; + private static final long IS_BUILDER_USED_FIELD_SET = 1 << 0; + private static final long IS_FADEABLE_USAGES_FIELD_SET = 1 << 1; + private static final long IS_UNFADEABLE_CONTENT_TYPE_FIELD_SET = 1 << 2; + + /** duration of the fade out curve */ + private static final long DEFAULT_FADE_OUT_DURATION_MS = 2_000; + /** duration of the fade in curve */ + private static final long DEFAULT_FADE_IN_DURATION_MS = 1_000; + + /** + * delay after which a faded out player will be faded back in. This will be heard by the + * user only in the case of unmuting players that didn't respect audio focus and didn't + * stop/pause when their app lost focus. + * This is the amount of time between the app being notified of the focus loss + * (when its muted by the fade out), and the time fade in (to unmute) starts + */ + private static final long DEFAULT_DELAY_FADE_IN_OFFENDERS_MS = 2_000; + + + private static final IntArray DEFAULT_UNFADEABLE_PLAYER_TYPES = IntArray.wrap(new int[]{ + AudioPlaybackConfiguration.PLAYER_TYPE_AAUDIO, + AudioPlaybackConfiguration.PLAYER_TYPE_JAM_SOUNDPOOL + }); + + private static final IntArray DEFAULT_UNFADEABLE_CONTENT_TYPES = IntArray.wrap(new int[]{ + AudioAttributes.CONTENT_TYPE_SPEECH + }); + + private static final IntArray DEFAULT_FADEABLE_USAGES = IntArray.wrap(new int[]{ + AudioAttributes.USAGE_GAME, + AudioAttributes.USAGE_MEDIA + }); + + private int mFadeState = FADE_STATE_ENABLED_DEFAULT; + private long mFadeInDelayForOffendersMillis = DEFAULT_DELAY_FADE_IN_OFFENDERS_MS; + private long mFadeOutDurationMillis; + private long mFadeInDurationMillis; + private long mBuilderFieldsSet; + private SparseArray<FadeVolumeShaperConfigsWrapper> mUsageToFadeWrapperMap = + new SparseArray<>(); + private ArrayMap<AudioAttributes, FadeVolumeShaperConfigsWrapper> mAttrToFadeWrapperMap = + new ArrayMap<>(); + private IntArray mFadeableUsages = new IntArray(); + private IntArray mUnfadeableContentTypes = new IntArray(); + // Player types are not yet configurable + private IntArray mUnfadeablePlayerTypes = DEFAULT_UNFADEABLE_PLAYER_TYPES; + private IntArray mUnfadeableUids = new IntArray(); + private List<AudioAttributes> mUnfadeableAudioAttributes = new ArrayList<>(); + + /** + * Constructs a new Builder with default fade out and fade in durations + */ + public Builder() { + mFadeOutDurationMillis = DEFAULT_FADE_OUT_DURATION_MS; + mFadeInDurationMillis = DEFAULT_FADE_IN_DURATION_MS; + } + + /** + * Constructs a new Builder with the provided fade out and fade in durations + * + * @param fadeOutDurationMillis duration in milliseconds used for fading out + * @param fadeInDurationMills duration in milliseconds used for fading in + */ + public Builder(long fadeOutDurationMillis, long fadeInDurationMills) { + mFadeOutDurationMillis = fadeOutDurationMillis; + mFadeInDurationMillis = fadeInDurationMills; + } + + /** + * Constructs a new Builder from the given {@link FadeManagerConfiguration} + * + * @param fmc the {@link FadeManagerConfiguration} object whose data will be reused in the + * new builder + */ + public Builder(@NonNull FadeManagerConfiguration fmc) { + mFadeState = fmc.mFadeState; + mUsageToFadeWrapperMap = fmc.mUsageToFadeWrapperMap.clone(); + mAttrToFadeWrapperMap = new ArrayMap<AudioAttributes, FadeVolumeShaperConfigsWrapper>( + fmc.mAttrToFadeWrapperMap); + mFadeableUsages = fmc.mFadeableUsages.clone(); + setFlag(IS_FADEABLE_USAGES_FIELD_SET); + mUnfadeableContentTypes = fmc.mUnfadeableContentTypes.clone(); + setFlag(IS_UNFADEABLE_CONTENT_TYPE_FIELD_SET); + mUnfadeablePlayerTypes = fmc.mUnfadeablePlayerTypes.clone(); + mUnfadeableUids = fmc.mUnfadeableUids.clone(); + mUnfadeableAudioAttributes = new ArrayList<>(fmc.mUnfadeableAudioAttributes); + mFadeOutDurationMillis = fmc.mFadeOutDurationMillis; + mFadeInDurationMillis = fmc.mFadeInDurationMillis; + } + + /** + * Set the overall fade state + * + * @param state one of the {@link FadeStateEnum} states + * @return the same Builder instance + * @throws IllegalArgumentException if the fade state is invalid + * @see #getFadeState() + */ + @NonNull + public Builder setFadeState(@FadeStateEnum int state) { + validateFadeState(state); + mFadeState = state; + return this; + } + + /** + * Set the {@link android.media.VolumeShaper.Configuration} used to fade out players with + * {@link android.media.AudioAttributes.AttributeUsage} + * <p> + * This method accepts {@code null} for volume shaper config to clear a previously set + * configuration (example, if set through + * {@link #Builder(android.media.FadeManagerConfiguration)}) + * + * @param usage the {@link android.media.AudioAttributes.AttributeUsage} of target player + * @param fadeOutVShaperConfig the {@link android.media.VolumeShaper.Configuration} used + * to fade out players with usage + * @return the same Builder instance + * @throws IllegalArgumentException if the usage is invalid + * @see #getFadeOutVolumeShaperConfigForUsage(int) + */ + @NonNull + public Builder setFadeOutVolumeShaperConfigForUsage(int usage, + @Nullable VolumeShaper.Configuration fadeOutVShaperConfig) { + validateUsage(usage); + getFadeVolShaperConfigWrapperForUsage(usage) + .setFadeOutVolShaperConfig(fadeOutVShaperConfig); + cleanupInactiveWrapperEntries(usage); + return this; + } + + /** + * Set the {@link android.media.VolumeShaper.Configuration} used to fade in players with + * {@link android.media.AudioAttributes.AttributeUsage} + * <p> + * This method accepts {@code null} for volume shaper config to clear a previously set + * configuration (example, if set through + * {@link #Builder(android.media.FadeManagerConfiguration)}) + * + * @param usage the {@link android.media.AudioAttributes.AttributeUsage} + * @param fadeInVShaperConfig the {@link android.media.VolumeShaper.Configuration} used + * to fade in players with usage + * @return the same Builder instance + * @throws IllegalArgumentException if the usage is invalid + * @see #getFadeInVolumeShaperConfigForUsage(int) + */ + @NonNull + public Builder setFadeInVolumeShaperConfigForUsage(int usage, + @Nullable VolumeShaper.Configuration fadeInVShaperConfig) { + validateUsage(usage); + getFadeVolShaperConfigWrapperForUsage(usage) + .setFadeInVolShaperConfig(fadeInVShaperConfig); + cleanupInactiveWrapperEntries(usage); + return this; + } + + /** + * Set the duration used for fading out players with + * {@link android.media.AudioAttributes.AttributeUsage} + * <p> + * A Volume shaper configuration is generated with the provided duration and default + * volume curve definitions. This config is then used to fade out players with given usage. + * <p> + * In order to clear previously set duration (example, if set through + * {@link #Builder(android.media.FadeManagerConfiguration)}), this method accepts + * {@link #DURATION_NOT_SET} and sets the corresponding fade out volume shaper config to + * {@code null} + * + * @param usage the {@link android.media.AudioAttributes.AttributeUsage} of target player + * @param fadeOutDurationMillis positive duration in milliseconds or + * {@link #DURATION_NOT_SET} + * @return the same Builder instance + * @throws IllegalArgumentException if the fade out duration is non-positive with the + * exception of {@link #DURATION_NOT_SET} + * @see #setFadeOutVolumeShaperConfigForUsage(int, VolumeShaper.Configuration) + * @see #getFadeOutDurationForUsage(int) + */ + @NonNull + public Builder setFadeOutDurationForUsage(int usage, long fadeOutDurationMillis) { + validateUsage(usage); + VolumeShaper.Configuration fadeOutVShaperConfig = + createVolShaperConfigForDuration(fadeOutDurationMillis, /* isFadeIn= */ false); + setFadeOutVolumeShaperConfigForUsage(usage, fadeOutVShaperConfig); + return this; + } + + /** + * Set the duration used for fading in players with + * {@link android.media.AudioAttributes.AttributeUsage} + * <p> + * A Volume shaper configuration is generated with the provided duration and default + * volume curve definitions. This config is then used to fade in players with given usage. + * <p> + * <b>Note: </b>In order to clear previously set duration (example, if set through + * {@link #Builder(android.media.FadeManagerConfiguration)}), this method accepts + * {@link #DURATION_NOT_SET} and sets the corresponding fade in volume shaper config to + * {@code null} + * + * @param usage the {@link android.media.AudioAttributes.AttributeUsage} of target player + * @param fadeInDurationMillis positive duration in milliseconds or + * {@link #DURATION_NOT_SET} + * @return the same Builder instance + * @throws IllegalArgumentException if the fade in duration is non-positive with the + * exception of {@link #DURATION_NOT_SET} + * @see #setFadeInVolumeShaperConfigForUsage(int, VolumeShaper.Configuration) + * @see #getFadeInDurationForUsage(int) + */ + @NonNull + public Builder setFadeInDurationForUsage(int usage, long fadeInDurationMillis) { + validateUsage(usage); + VolumeShaper.Configuration fadeInVShaperConfig = + createVolShaperConfigForDuration(fadeInDurationMillis, /* isFadeIn= */ true); + setFadeInVolumeShaperConfigForUsage(usage, fadeInVShaperConfig); + return this; + } + + /** + * Set the {@link android.media.VolumeShaper.Configuration} used to fade out players with + * {@link android.media.AudioAttributes} + * <p> + * This method accepts {@code null} for volume shaper config to clear a previously set + * configuration (example, set through + * {@link #Builder(android.media.FadeManagerConfiguration)}) + * + * @param audioAttributes the {@link android.media.AudioAttributes} + * @param fadeOutVShaperConfig the {@link android.media.VolumeShaper.Configuration} used to + * fade out players with audio attribute + * @return the same Builder instance + * @throws NullPointerException if the audio attributes is {@code null} + * @see #getFadeOutVolumeShaperConfigForAudioAttributes(AudioAttributes) + */ + @NonNull + public Builder setFadeOutVolumeShaperConfigForAudioAttributes( + @NonNull AudioAttributes audioAttributes, + @Nullable VolumeShaper.Configuration fadeOutVShaperConfig) { + Objects.requireNonNull(audioAttributes, "Audio attribute cannot be null"); + getFadeVolShaperConfigWrapperForAttr(audioAttributes) + .setFadeOutVolShaperConfig(fadeOutVShaperConfig); + cleanupInactiveWrapperEntries(audioAttributes); + return this; + } + + /** + * Set the {@link android.media.VolumeShaper.Configuration} used to fade in players with + * {@link android.media.AudioAttributes} + * + * <p>This method accepts {@code null} for volume shaper config to clear a previously set + * configuration (example, set through + * {@link #Builder(android.media.FadeManagerConfiguration)}) + * + * @param audioAttributes the {@link android.media.AudioAttributes} + * @param fadeInVShaperConfig the {@link android.media.VolumeShaper.Configuration} used to + * fade in players with audio attribute + * @return the same Builder instance + * @throws NullPointerException if the audio attributes is {@code null} + * @see #getFadeInVolumeShaperConfigForAudioAttributes(AudioAttributes) + */ + @NonNull + public Builder setFadeInVolumeShaperConfigForAudioAttributes( + @NonNull AudioAttributes audioAttributes, + @Nullable VolumeShaper.Configuration fadeInVShaperConfig) { + Objects.requireNonNull(audioAttributes, "Audio attribute cannot be null"); + getFadeVolShaperConfigWrapperForAttr(audioAttributes) + .setFadeInVolShaperConfig(fadeInVShaperConfig); + cleanupInactiveWrapperEntries(audioAttributes); + return this; + } + + /** + * Set the duration used for fading out players of type + * {@link android.media.AudioAttributes}. + * <p> + * A Volume shaper configuration is generated with the provided duration and default + * volume curve definitions. This config is then used to fade out players with given usage. + * <p> + * <b>Note: </b>In order to clear previously set duration (example, if set through + * {@link #Builder(android.media.FadeManagerConfiguration)}), this method accepts + * {@link #DURATION_NOT_SET} and sets the corresponding fade out volume shaper config to + * {@code null} + * + * @param audioAttributes the {@link android.media.AudioAttributes} for which the fade out + * duration will be set/updated/reset + * @param fadeOutDurationMillis positive duration in milliseconds or + * {@link #DURATION_NOT_SET} + * @return the same Builder instance + * @throws IllegalArgumentException if the fade out duration is non-positive with the + * exception of {@link #DURATION_NOT_SET} + * @see #getFadeOutDurationForAudioAttributes(AudioAttributes) + * @see #setFadeOutVolumeShaperConfigForAudioAttributes(AudioAttributes, + * VolumeShaper.Configuration) + */ + @NonNull + public Builder setFadeOutDurationForAudioAttributes( + @NonNull AudioAttributes audioAttributes, + long fadeOutDurationMillis) { + Objects.requireNonNull(audioAttributes, "Audio attribute cannot be null"); + VolumeShaper.Configuration fadeOutVShaperConfig = + createVolShaperConfigForDuration(fadeOutDurationMillis, /* isFadeIn= */ false); + setFadeOutVolumeShaperConfigForAudioAttributes(audioAttributes, fadeOutVShaperConfig); + return this; + } + + /** + * Set the duration used for fading in players of type + * {@link android.media.AudioAttributes}. + * <p> + * A Volume shaper configuration is generated with the provided duration and default + * volume curve definitions. This config is then used to fade in players with given usage. + * <p> + * <b>Note: </b>In order to clear previously set duration (example, if set through + * {@link #Builder(android.media.FadeManagerConfiguration)}), this method accepts + * {@link #DURATION_NOT_SET} and sets the corresponding fade in volume shaper config to + * {@code null} + * + * @param audioAttributes the {@link android.media.AudioAttributes} for which the fade in + * duration will be set/updated/reset + * @param fadeInDurationMillis positive duration in milliseconds or + * {@link #DURATION_NOT_SET} + * @return the same Builder instance + * @throws IllegalArgumentException if the fade in duration is non-positive with the + * exception of {@link #DURATION_NOT_SET} + * @see #getFadeInDurationForAudioAttributes(AudioAttributes) + * @see #setFadeInVolumeShaperConfigForAudioAttributes(AudioAttributes, + * VolumeShaper.Configuration) + */ + @NonNull + public Builder setFadeInDurationForAudioAttributes(@NonNull AudioAttributes audioAttributes, + long fadeInDurationMillis) { + Objects.requireNonNull(audioAttributes, "Audio attribute cannot be null"); + VolumeShaper.Configuration fadeInVShaperConfig = + createVolShaperConfigForDuration(fadeInDurationMillis, /* isFadeIn= */ true); + setFadeInVolumeShaperConfigForAudioAttributes(audioAttributes, fadeInVShaperConfig); + return this; + } + + /** + * Set the list of {@link android.media.AudioAttributes.AttributeUsage} that can be faded + * + * <p>This is a positive list. Players with matching usage will be considered for fading. + * Usages that are not part of this list will not be faded + * + * <p>Passing an empty list as input clears the existing list. This can be used to + * reset the list when using a copy constructor + * + * <p><b>Warning:</b> When fade state is set to enabled, the builder expects at least one + * usage to be set/added. Failure to do so will result in an exception during + * {@link #build()} + * + * @param usages List of the {@link android.media.AudioAttributes.AttributeUsage} + * @return the same Builder instance + * @throws IllegalArgumentException if the usages are invalid + * @throws NullPointerException if the usage list is {@code null} + * @see #getFadeableUsages() + */ + @NonNull + public Builder setFadeableUsages(@NonNull List<Integer> usages) { + Objects.requireNonNull(usages, "List of usages cannot be null"); + validateUsages(usages); + setFlag(IS_FADEABLE_USAGES_FIELD_SET); + mFadeableUsages.clear(); + mFadeableUsages.addAll(convertIntegerListToIntArray(usages)); + return this; + } + + /** + * Add the {@link android.media.AudioAttributes.AttributeUsage} to the fadeable list + * + * @param usage the {@link android.media.AudioAttributes.AttributeUsage} + * @return the same Builder instance + * @throws IllegalArgumentException if the usage is invalid + * @see #getFadeableUsages() + * @see #setFadeableUsages(List) + */ + @NonNull + public Builder addFadeableUsage(@AudioAttributes.AttributeUsage int usage) { + validateUsage(usage); + setFlag(IS_FADEABLE_USAGES_FIELD_SET); + if (!mFadeableUsages.contains(usage)) { + mFadeableUsages.add(usage); + } + return this; + } + + /** + * Remove the {@link android.media.AudioAttributes.AttributeUsage} from the fadeable list + * <p> + * Players of this usage type will not be faded. + * + * @param usage the {@link android.media.AudioAttributes.AttributeUsage} + * @return the same Builder instance + * @throws IllegalArgumentException if the usage is invalid + * @see #getFadeableUsages() + * @see #setFadeableUsages(List) + */ + @NonNull + public Builder clearFadeableUsage(@AudioAttributes.AttributeUsage int usage) { + validateUsage(usage); + setFlag(IS_FADEABLE_USAGES_FIELD_SET); + int index = mFadeableUsages.indexOf(usage); + if (index != INVALID_INDEX) { + mFadeableUsages.remove(index); + } + return this; + } + + /** + * Set the list of {@link android.media.AudioAttributes.AttributeContentType} that can not + * be faded + * + * <p>This is a negative list. Players with matching content type of this list will not be + * faded. Content types that are not part of this list will be considered for fading. + * + * <p>Passing an empty list as input clears the existing list. This can be used to + * reset the list when using a copy constructor + * + * @param contentTypes list of {@link android.media.AudioAttributes.AttributeContentType} + * @return the same Builder instance + * @throws IllegalArgumentException if the content types are invalid + * @throws NullPointerException if the content type list is {@code null} + * @see #getUnfadeableContentTypes() + */ + @NonNull + public Builder setUnfadeableContentTypes(@NonNull List<Integer> contentTypes) { + Objects.requireNonNull(contentTypes, "List of content types cannot be null"); + validateContentTypes(contentTypes); + setFlag(IS_UNFADEABLE_CONTENT_TYPE_FIELD_SET); + mUnfadeableContentTypes.clear(); + mUnfadeableContentTypes.addAll(convertIntegerListToIntArray(contentTypes)); + return this; + } + + /** + * Add the {@link android.media.AudioAttributes.AttributeContentType} to unfadeable list + * + * @param contentType the {@link android.media.AudioAttributes.AttributeContentType} + * @return the same Builder instance + * @throws IllegalArgumentException if the content type is invalid + * @see #setUnfadeableContentTypes(List) + * @see #getUnfadeableContentTypes() + */ + @NonNull + public Builder addUnfadeableContentType( + @AudioAttributes.AttributeContentType int contentType) { + validateContentType(contentType); + setFlag(IS_UNFADEABLE_CONTENT_TYPE_FIELD_SET); + if (!mUnfadeableContentTypes.contains(contentType)) { + mUnfadeableContentTypes.add(contentType); + } + return this; + } + + /** + * Remove the {@link android.media.AudioAttributes.AttributeContentType} from the + * unfadeable list + * + * @param contentType the {@link android.media.AudioAttributes.AttributeContentType} + * @return the same Builder instance + * @throws IllegalArgumentException if the content type is invalid + * @see #setUnfadeableContentTypes(List) + * @see #getUnfadeableContentTypes() + */ + @NonNull + public Builder clearUnfadeableContentType( + @AudioAttributes.AttributeContentType int contentType) { + validateContentType(contentType); + setFlag(IS_UNFADEABLE_CONTENT_TYPE_FIELD_SET); + int index = mUnfadeableContentTypes.indexOf(contentType); + if (index != INVALID_INDEX) { + mUnfadeableContentTypes.remove(index); + } + return this; + } + + /** + * Set the uids that cannot be faded + * + * <p>This is a negative list. Players with matching uid of this list will not be faded. + * Uids that are not part of this list shall be considered for fading + * + * <p>Passing an empty list as input clears the existing list. This can be used to + * reset the list when using a copy constructor + * + * @param uids list of uids + * @return the same Builder instance + * @throws NullPointerException if the uid list is {@code null} + * @see #getUnfadeableUids() + */ + @NonNull + public Builder setUnfadeableUids(@NonNull List<Integer> uids) { + Objects.requireNonNull(uids, "List of uids cannot be null"); + mUnfadeableUids.clear(); + mUnfadeableUids.addAll(convertIntegerListToIntArray(uids)); + return this; + } + + /** + * Add uid to unfadeable list + * + * @param uid client uid + * @return the same Builder instance + * @see #setUnfadeableUids(List) + * @see #getUnfadeableUids() + */ + @NonNull + public Builder addUnfadeableUid(int uid) { + if (!mUnfadeableUids.contains(uid)) { + mUnfadeableUids.add(uid); + } + return this; + } + + /** + * Remove the uid from unfadeable list + * + * @param uid client uid + * @return the same Builder instance + * @see #setUnfadeableUids(List) + * @see #getUnfadeableUids() + */ + @NonNull + public Builder clearUnfadeableUid(int uid) { + int index = mUnfadeableUids.indexOf(uid); + if (index != INVALID_INDEX) { + mUnfadeableUids.remove(index); + } + return this; + } + + /** + * Set the list of {@link android.media.AudioAttributes} that can not be faded + * + * <p>This is a negative list. Players with matching audio attributes of this list will not + * be faded. Audio attributes that are not part of this list shall be considered for fading. + * + * <p>Passing an empty list as input clears any existing list. This can be used to + * reset the list when using a copy constructor + * + * <p><b>Note:</b> Be cautious when adding generic audio attributes into this list as it can + * negatively impact fadeability decision if such an audio attribute and corresponding + * usage fall into opposing lists. + * For example: + * <pre class=prettyprint> + * AudioAttributes.Builder().setUsage(AudioAttributes.USAGE_MEDIA).build() </pre> + * is a generic audio attribute for {@link android.media.AudioAttributes.USAGE_MEDIA}. + * It is an undefined behavior to have an + * {@link android.media.AudioAttributes.AttributeUsage} in the fadeable usage list and the + * corresponding generic {@link android.media.AudioAttributes} in the unfadeable list. Such + * cases will result in an exception during {@link #build()} + * + * @param attrs list of {@link android.media.AudioAttributes} + * @return the same Builder instance + * @throws NullPointerException if the audio attributes list is {@code null} + * @see #getUnfadeableAudioAttributes() + */ + @NonNull + public Builder setUnfadeableAudioAttributes(@NonNull List<AudioAttributes> attrs) { + Objects.requireNonNull(attrs, "List of audio attributes cannot be null"); + mUnfadeableAudioAttributes.clear(); + mUnfadeableAudioAttributes.addAll(attrs); + return this; + } + + /** + * Add the {@link android.media.AudioAttributes} to the unfadeable list + * + * @param audioAttributes the {@link android.media.AudioAttributes} + * @return the same Builder instance + * @throws NullPointerException if the audio attributes is {@code null} + * @see #setUnfadeableAudioAttributes(List) + * @see #getUnfadeableAudioAttributes() + */ + @NonNull + public Builder addUnfadeableAudioAttributes(@NonNull AudioAttributes audioAttributes) { + Objects.requireNonNull(audioAttributes, "Audio attributes cannot be null"); + if (!mUnfadeableAudioAttributes.contains(audioAttributes)) { + mUnfadeableAudioAttributes.add(audioAttributes); + } + return this; + } + + /** + * Remove the {@link android.media.AudioAttributes} from the unfadeable list. + * + * @param audioAttributes the {@link android.media.AudioAttributes} + * @return the same Builder instance + * @throws NullPointerException if the audio attributes is {@code null} + * @see #getUnfadeableAudioAttributes() + */ + @NonNull + public Builder clearUnfadeableAudioAttributes(@NonNull AudioAttributes audioAttributes) { + Objects.requireNonNull(audioAttributes, "Audio attributes cannot be null"); + if (mUnfadeableAudioAttributes.contains(audioAttributes)) { + mUnfadeableAudioAttributes.remove(audioAttributes); + } + return this; + } + + /** + * Set the delay after which the offending faded out player will be faded in. + * + * <p>This is the amount of time between the app being notified of the focus loss (when its + * muted by the fade out), and the time fade in (to unmute) starts + * + * @param delayMillis delay in milliseconds + * @return the same Builder instance + * @throws IllegalArgumentException if the delay is negative + * @see #getFadeInDelayForOffenders() + */ + @NonNull + public Builder setFadeInDelayForOffenders(long delayMillis) { + Preconditions.checkArgument(delayMillis >= 0, "Delay cannot be negative"); + mFadeInDelayForOffendersMillis = delayMillis; + return this; + } + + /** + * Builds the {@link FadeManagerConfiguration} with all of the fade configurations that + * have been set. + * + * @return a new {@link FadeManagerConfiguration} object + */ + @NonNull + public FadeManagerConfiguration build() { + if (!checkNotSet(IS_BUILDER_USED_FIELD_SET)) { + throw new IllegalStateException( + "This Builder should not be reused. Use a new Builder instance instead"); + } + + setFlag(IS_BUILDER_USED_FIELD_SET); + + if (checkNotSet(IS_FADEABLE_USAGES_FIELD_SET)) { + mFadeableUsages = DEFAULT_FADEABLE_USAGES; + setVolShaperConfigsForUsages(mFadeableUsages); + } + + if (checkNotSet(IS_UNFADEABLE_CONTENT_TYPE_FIELD_SET)) { + mUnfadeableContentTypes = DEFAULT_UNFADEABLE_CONTENT_TYPES; + } + + validateFadeConfigurations(); + + return new FadeManagerConfiguration(mFadeState, mFadeOutDurationMillis, + mFadeInDurationMillis, mFadeInDelayForOffendersMillis, mUsageToFadeWrapperMap, + mAttrToFadeWrapperMap, mFadeableUsages, mUnfadeableContentTypes, + mUnfadeablePlayerTypes, mUnfadeableUids, mUnfadeableAudioAttributes); + } + + private void setFlag(long flag) { + mBuilderFieldsSet |= flag; + } + + private boolean checkNotSet(long flag) { + return (mBuilderFieldsSet & flag) == 0; + } + + private FadeVolumeShaperConfigsWrapper getFadeVolShaperConfigWrapperForUsage(int usage) { + if (!mUsageToFadeWrapperMap.contains(usage)) { + mUsageToFadeWrapperMap.put(usage, new FadeVolumeShaperConfigsWrapper()); + } + return mUsageToFadeWrapperMap.get(usage); + } + + private FadeVolumeShaperConfigsWrapper getFadeVolShaperConfigWrapperForAttr( + AudioAttributes attr) { + // if no entry, create a new one for setting/clearing + if (!mAttrToFadeWrapperMap.containsKey(attr)) { + mAttrToFadeWrapperMap.put(attr, new FadeVolumeShaperConfigsWrapper()); + } + return mAttrToFadeWrapperMap.get(attr); + } + + private VolumeShaper.Configuration createVolShaperConfigForDuration(long duration, + boolean isFadeIn) { + // used to reset the volume shaper config setting + if (duration == DURATION_NOT_SET) { + return null; + } + + VolumeShaper.Configuration.Builder builder = new VolumeShaper.Configuration.Builder() + .setId(VOLUME_SHAPER_SYSTEM_FADE_ID) + .setOptionFlags(VolumeShaper.Configuration.OPTION_FLAG_CLOCK_TIME) + .setDuration(duration); + + if (isFadeIn) { + builder.setCurve(/* times= */ new float[]{0.f, 0.50f, 1.0f}, + /* volumes= */ new float[]{0.f, 0.30f, 1.0f}); + } else { + builder.setCurve(/* times= */ new float[]{0.f, 0.25f, 1.0f}, + /* volumes= */ new float[]{1.f, 0.65f, 0.0f}); + } + + return builder.build(); + } + + private void cleanupInactiveWrapperEntries(int usage) { + FadeVolumeShaperConfigsWrapper fmcw = mUsageToFadeWrapperMap.get(usage); + // cleanup map entry if FadeVolumeShaperConfigWrapper is inactive + if (fmcw != null && fmcw.isInactive()) { + mUsageToFadeWrapperMap.remove(usage); + } + } + + private void cleanupInactiveWrapperEntries(AudioAttributes attr) { + FadeVolumeShaperConfigsWrapper fmcw = mAttrToFadeWrapperMap.get(attr); + // cleanup map entry if FadeVolumeShaperConfigWrapper is inactive + if (fmcw != null && fmcw.isInactive()) { + mAttrToFadeWrapperMap.remove(attr); + } + } + + private void setVolShaperConfigsForUsages(IntArray usages) { + // set default volume shaper configs for fadeable usages + for (int index = 0; index < usages.size(); index++) { + setMissingVolShaperConfigsForWrapper( + getFadeVolShaperConfigWrapperForUsage(usages.get(index))); + } + } + + private void setMissingVolShaperConfigsForWrapper(FadeVolumeShaperConfigsWrapper wrapper) { + if (!wrapper.isFadeOutConfigActive()) { + wrapper.setFadeOutVolShaperConfig(createVolShaperConfigForDuration( + mFadeOutDurationMillis, /* isFadeIn= */ false)); + } + if (!wrapper.isFadeInConfigActive()) { + wrapper.setFadeInVolShaperConfig(createVolShaperConfigForDuration( + mFadeInDurationMillis, /* isFadeIn= */ true)); + } + } + + private void validateFadeState(int state) { + switch(state) { + case FADE_STATE_DISABLED: + case FADE_STATE_ENABLED_DEFAULT: + case FADE_STATE_ENABLED_AUTO: + break; + default: + throw new IllegalArgumentException("Unknown fade state: " + state); + } + } + + private void validateUsages(List<Integer> usages) { + for (int index = 0; index < usages.size(); index++) { + validateUsage(usages.get(index)); + } + } + + private void validateContentTypes(List<Integer> contentTypes) { + for (int index = 0; index < contentTypes.size(); index++) { + validateContentType(contentTypes.get(index)); + } + } + + private void validateContentType(int contentType) { + Preconditions.checkArgument(AudioAttributes.isSdkContentType(contentType), + "Invalid content type: ", contentType); + } + + private void validateFadeConfigurations() { + validateFadeableUsages(); + validateFadeVolumeShaperConfigsWrappers(); + validateUnfadeableAudioAttributes(); + } + + /** Ensure fadeable usage list meets config requirements */ + private void validateFadeableUsages() { + // ensure at least one fadeable usage + Preconditions.checkArgumentPositive(mFadeableUsages.size(), + "Fadeable usage list cannot be empty when state set to enabled"); + // ensure all fadeable usages have volume shaper configs - both fade in and out + for (int index = 0; index < mFadeableUsages.size(); index++) { + setMissingVolShaperConfigsForWrapper( + getFadeVolShaperConfigWrapperForUsage(mFadeableUsages.get(index))); + } + } + + /** Ensure Fade volume shaper config wrappers meet requirements */ + private void validateFadeVolumeShaperConfigsWrappers() { + // ensure both fade in & out volume shaper configs are defined for all wrappers + // for usages - + for (int index = 0; index < mUsageToFadeWrapperMap.size(); index++) { + setMissingVolShaperConfigsForWrapper( + getFadeVolShaperConfigWrapperForUsage(mUsageToFadeWrapperMap.keyAt(index))); + } + + // for additional audio attributes - + for (int index = 0; index < mAttrToFadeWrapperMap.size(); index++) { + setMissingVolShaperConfigsForWrapper( + getFadeVolShaperConfigWrapperForAttr(mAttrToFadeWrapperMap.keyAt(index))); + } + } + + /** Ensure Unfadeable attributes meet configuration requirements */ + private void validateUnfadeableAudioAttributes() { + // ensure no generic AudioAttributes in unfadeable list with matching usage in fadeable + // list. failure results in an undefined behavior as the audio attributes + // shall be both fadeable (because of the usage) and unfadeable at the same time. + for (int index = 0; index < mUnfadeableAudioAttributes.size(); index++) { + AudioAttributes targetAttr = mUnfadeableAudioAttributes.get(index); + int usage = targetAttr.getSystemUsage(); + boolean isFadeableUsage = mFadeableUsages.contains(usage); + // cannot have a generic audio attribute that also is a fadeable usage + Preconditions.checkArgument( + !isFadeableUsage || (isFadeableUsage && !isGeneric(targetAttr)), + "Unfadeable audio attributes cannot be generic of the fadeable usage"); + } + } + + private static boolean isGeneric(AudioAttributes attr) { + return (attr.getContentType() == AudioAttributes.CONTENT_TYPE_UNKNOWN + && attr.getFlags() == 0x0 + && attr.getBundle() == null + && attr.getTags().isEmpty()); + } + } + + private static final class FadeVolumeShaperConfigsWrapper implements Parcelable { + // null volume shaper config refers to either init state or if its cleared/reset + private @Nullable VolumeShaper.Configuration mFadeOutVolShaperConfig; + private @Nullable VolumeShaper.Configuration mFadeInVolShaperConfig; + + FadeVolumeShaperConfigsWrapper() {} + + public void setFadeOutVolShaperConfig(@Nullable VolumeShaper.Configuration fadeOutConfig) { + mFadeOutVolShaperConfig = fadeOutConfig; + } + + public void setFadeInVolShaperConfig(@Nullable VolumeShaper.Configuration fadeInConfig) { + mFadeInVolShaperConfig = fadeInConfig; + } + + /** + * Query fade out volume shaper config + * + * @return configured fade out volume shaper config or {@code null} when initialized/reset + */ + @Nullable + public VolumeShaper.Configuration getFadeOutVolShaperConfig() { + return mFadeOutVolShaperConfig; + } + + /** + * Query fade in volume shaper config + * + * @return configured fade in volume shaper config or {@code null} when initialized/reset + */ + @Nullable + public VolumeShaper.Configuration getFadeInVolShaperConfig() { + return mFadeInVolShaperConfig; + } + + /** + * Wrapper is inactive if both fade out and in configs are cleared. + * + * @return {@code true} if configs are cleared. {@code false} if either of the configs is + * set + */ + public boolean isInactive() { + return !isFadeOutConfigActive() && !isFadeInConfigActive(); + } + + boolean isFadeOutConfigActive() { + return mFadeOutVolShaperConfig != null; + } + + boolean isFadeInConfigActive() { + return mFadeInVolShaperConfig != null; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + + if (!(o instanceof FadeVolumeShaperConfigsWrapper)) { + return false; + } + + FadeVolumeShaperConfigsWrapper rhs = (FadeVolumeShaperConfigsWrapper) o; + + if (mFadeInVolShaperConfig == null && rhs.mFadeInVolShaperConfig == null + && mFadeOutVolShaperConfig == null && rhs.mFadeOutVolShaperConfig == null) { + return true; + } + + boolean isEqual; + if (mFadeOutVolShaperConfig != null) { + isEqual = mFadeOutVolShaperConfig.equals(rhs.mFadeOutVolShaperConfig); + } else if (rhs.mFadeOutVolShaperConfig != null) { + return false; + } else { + isEqual = true; + } + + if (mFadeInVolShaperConfig != null) { + isEqual = isEqual && mFadeInVolShaperConfig.equals(rhs.mFadeInVolShaperConfig); + } else if (rhs.mFadeInVolShaperConfig != null) { + return false; + } + + return isEqual; + } + + @Override + public int hashCode() { + return Objects.hash(mFadeOutVolShaperConfig, mFadeInVolShaperConfig); + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(@NonNull Parcel dest, int flags) { + mFadeOutVolShaperConfig.writeToParcel(dest, flags); + mFadeInVolShaperConfig.writeToParcel(dest, flags); + } + + /** + * Creates fade volume shaper config wrapper from parcel + * + * @hide + */ + @VisibleForTesting() + FadeVolumeShaperConfigsWrapper(Parcel in) { + mFadeOutVolShaperConfig = VolumeShaper.Configuration.CREATOR.createFromParcel(in); + mFadeInVolShaperConfig = VolumeShaper.Configuration.CREATOR.createFromParcel(in); + } + + @NonNull + public static final Creator<FadeVolumeShaperConfigsWrapper> CREATOR = new Creator<>() { + @Override + @NonNull + public FadeVolumeShaperConfigsWrapper createFromParcel(@NonNull Parcel in) { + return new FadeVolumeShaperConfigsWrapper(in); + } + + @Override + @NonNull + public FadeVolumeShaperConfigsWrapper[] newArray(int size) { + return new FadeVolumeShaperConfigsWrapper[size]; + } + }; + } +} + diff --git a/media/java/android/media/flags/fade_manager_configuration.aconfig b/media/java/android/media/flags/fade_manager_configuration.aconfig new file mode 100644 index 000000000000..100e2235a7a8 --- /dev/null +++ b/media/java/android/media/flags/fade_manager_configuration.aconfig @@ -0,0 +1,8 @@ +package: "com.android.media.flags" + +flag { + namespace: "media_solutions" + name: "enable_fade_manager_configuration" + description: "Enable Fade Manager Configuration support to determine fade properties" + bug: "307354764" +}
\ No newline at end of file diff --git a/media/tests/AudioPolicyTest/Android.bp b/media/tests/AudioPolicyTest/Android.bp index 4624dfe70756..3dc2a0a9fd7c 100644 --- a/media/tests/AudioPolicyTest/Android.bp +++ b/media/tests/AudioPolicyTest/Android.bp @@ -17,6 +17,7 @@ android_test { "guava-android-testlib", "hamcrest-library", "platform-test-annotations", + "truth", ], platform_apis: true, certificate: "platform", diff --git a/media/tests/AudioPolicyTest/src/com/android/audiopolicytest/AudioManagerTest.java b/media/tests/AudioPolicyTest/src/com/android/audiopolicytest/AudioManagerTest.java index 94df40da16c1..e9a0d3eceba3 100644 --- a/media/tests/AudioPolicyTest/src/com/android/audiopolicytest/AudioManagerTest.java +++ b/media/tests/AudioPolicyTest/src/com/android/audiopolicytest/AudioManagerTest.java @@ -229,7 +229,7 @@ public class AudioManagerTest { @Test public void testSetGetVolumePerAttributes() { - for (int usage : AudioAttributes.SDK_USAGES) { + for (int usage : AudioAttributes.getSdkUsages()) { if (usage == AudioAttributes.USAGE_UNKNOWN) { continue; } diff --git a/media/tests/AudioPolicyTest/src/com/android/audiopolicytest/AudioProductStrategyTest.java b/media/tests/AudioPolicyTest/src/com/android/audiopolicytest/AudioProductStrategyTest.java index 266faae489dd..18e8608d3b4d 100644 --- a/media/tests/AudioPolicyTest/src/com/android/audiopolicytest/AudioProductStrategyTest.java +++ b/media/tests/AudioPolicyTest/src/com/android/audiopolicytest/AudioProductStrategyTest.java @@ -169,7 +169,7 @@ public class AudioProductStrategyTest { assertNotNull(audioProductStrategies); assertTrue(audioProductStrategies.size() > 0); - for (int usage : AudioAttributes.SDK_USAGES) { + for (int usage : AudioAttributes.getSdkUsages()) { AudioAttributes aaForUsage = new AudioAttributes.Builder().setUsage(usage).build(); int streamTypeFromUsage = diff --git a/media/tests/AudioPolicyTest/src/com/android/audiopolicytest/FadeManagerConfigurationUnitTest.java b/media/tests/AudioPolicyTest/src/com/android/audiopolicytest/FadeManagerConfigurationUnitTest.java new file mode 100644 index 000000000000..fb6bd489d5d0 --- /dev/null +++ b/media/tests/AudioPolicyTest/src/com/android/audiopolicytest/FadeManagerConfigurationUnitTest.java @@ -0,0 +1,795 @@ +/* + * Copyright (C) 2023 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.audiopolicytest; + +import static com.android.media.flags.Flags.FLAG_ENABLE_FADE_MANAGER_CONFIGURATION; + +import static org.junit.Assert.assertThrows; + +import android.media.AudioAttributes; +import android.media.AudioPlaybackConfiguration; +import android.media.FadeManagerConfiguration; +import android.media.VolumeShaper; +import android.os.Parcel; +import android.platform.test.annotations.Presubmit; +import android.platform.test.annotations.RequiresFlagsEnabled; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.google.common.truth.Expect; + +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +@Presubmit +@RunWith(AndroidJUnit4.class) +@RequiresFlagsEnabled(FLAG_ENABLE_FADE_MANAGER_CONFIGURATION) +public final class FadeManagerConfigurationUnitTest { + private static final long DEFAULT_FADE_OUT_DURATION_MS = 2_000; + private static final long DEFAULT_FADE_IN_DURATION_MS = 1_000; + private static final long TEST_FADE_OUT_DURATION_MS = 1_500; + private static final long TEST_FADE_IN_DURATION_MS = 750; + private static final int TEST_INVALID_USAGE = -10; + private static final int TEST_INVALID_CONTENT_TYPE = 100; + private static final int TEST_INVALID_FADE_STATE = 100; + private static final long TEST_INVALID_DURATION = -10; + private static final int TEST_UID_1 = 1010001; + private static final int TEST_UID_2 = 1000; + private static final int TEST_PARCEL_FLAGS = 0; + private static final AudioAttributes TEST_MEDIA_AUDIO_ATTRIBUTE = + createAudioAttributesForUsage(AudioAttributes.USAGE_MEDIA); + private static final AudioAttributes TEST_GAME_AUDIO_ATTRIBUTE = + createAudioAttributesForUsage(AudioAttributes.USAGE_GAME); + private static final AudioAttributes TEST_NAVIGATION_AUDIO_ATTRIBUTE = + new AudioAttributes.Builder().setUsage( + AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE) + .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION) + .build(); + private static final AudioAttributes TEST_ASSISTANT_AUDIO_ATTRIBUTE = + new AudioAttributes.Builder().setUsage(AudioAttributes.USAGE_ASSISTANT) + .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION).build(); + private static final List<Integer> TEST_FADEABLE_USAGES = Arrays.asList( + AudioAttributes.USAGE_MEDIA, + AudioAttributes.USAGE_GAME + ); + private static final List<Integer> TEST_UNFADEABLE_CONTENT_TYPES = Arrays.asList( + AudioAttributes.CONTENT_TYPE_SPEECH + ); + + private static final List<Integer> TEST_UNFADEABLE_PLAYER_TYPES = Arrays.asList( + AudioPlaybackConfiguration.PLAYER_TYPE_AAUDIO, + AudioPlaybackConfiguration.PLAYER_TYPE_JAM_SOUNDPOOL + ); + private static final VolumeShaper.Configuration TEST_DEFAULT_FADE_OUT_VOLUME_SHAPER_CONFIG = + new VolumeShaper.Configuration.Builder() + .setId(FadeManagerConfiguration.VOLUME_SHAPER_SYSTEM_FADE_ID) + .setCurve(/* times= */new float[]{0.f, 0.25f, 1.0f}, + /* volumes= */new float[]{1.f, 0.65f, 0.0f}) + .setOptionFlags(VolumeShaper.Configuration.OPTION_FLAG_CLOCK_TIME) + .setDuration(DEFAULT_FADE_OUT_DURATION_MS) + .build(); + private static final VolumeShaper.Configuration TEST_DEFAULT_FADE_IN_VOLUME_SHAPER_CONFIG = + new VolumeShaper.Configuration.Builder() + .setId(FadeManagerConfiguration.VOLUME_SHAPER_SYSTEM_FADE_ID) + .setCurve(/* times= */new float[]{0.f, 0.50f, 1.0f}, + /* volumes= */new float[]{0.f, 0.30f, 1.0f}) + .setOptionFlags(VolumeShaper.Configuration.OPTION_FLAG_CLOCK_TIME) + .setDuration(DEFAULT_FADE_IN_DURATION_MS) + .build(); + private static final VolumeShaper.Configuration TEST_FADE_OUT_VOLUME_SHAPER_CONFIG = + new VolumeShaper.Configuration.Builder() + .setId(FadeManagerConfiguration.VOLUME_SHAPER_SYSTEM_FADE_ID) + .setCurve(/* times= */new float[]{0.f, 0.25f, 1.0f}, + /* volumes= */new float[]{1.f, 0.65f, 0.0f}) + .setOptionFlags(VolumeShaper.Configuration.OPTION_FLAG_CLOCK_TIME) + .setDuration(TEST_FADE_OUT_DURATION_MS) + .build(); + private static final VolumeShaper.Configuration TEST_FADE_IN_VOLUME_SHAPER_CONFIG = + new VolumeShaper.Configuration.Builder() + .setId(FadeManagerConfiguration.VOLUME_SHAPER_SYSTEM_FADE_ID) + .setCurve(/* times= */new float[]{0.f, 0.50f, 1.0f}, + /* volumes= */new float[]{0.f, 0.30f, 1.0f}) + .setOptionFlags(VolumeShaper.Configuration.OPTION_FLAG_CLOCK_TIME) + .setDuration(TEST_FADE_IN_DURATION_MS) + .build(); + + private FadeManagerConfiguration mFmc; + + @Rule + public final Expect expect = Expect.create(); + + @Before + public void setUp() { + mFmc = new FadeManagerConfiguration.Builder().build(); + } + + + @Test + public void build() { + expect.withMessage("Fade state for default builder") + .that(mFmc.getFadeState()) + .isEqualTo(FadeManagerConfiguration.FADE_STATE_ENABLED_DEFAULT); + expect.withMessage("Fadeable usages for default builder") + .that(mFmc.getFadeableUsages()) + .containsExactlyElementsIn(TEST_FADEABLE_USAGES); + expect.withMessage("Unfadeable content types usages for default builder") + .that(mFmc.getUnfadeableContentTypes()) + .containsExactlyElementsIn(TEST_UNFADEABLE_CONTENT_TYPES); + expect.withMessage("Unfadeable player types for default builder") + .that(mFmc.getUnfadeablePlayerTypes()) + .containsExactlyElementsIn(TEST_UNFADEABLE_PLAYER_TYPES); + expect.withMessage("Unfadeable uids for default builder") + .that(mFmc.getUnfadeableUids()).isEmpty(); + expect.withMessage("Unfadeable audio attributes for default builder") + .that(mFmc.getUnfadeableAudioAttributes()).isEmpty(); + expect.withMessage("Fade out volume shaper config for media usage") + .that(mFmc.getFadeOutVolumeShaperConfigForUsage(AudioAttributes.USAGE_MEDIA)) + .isEqualTo(TEST_DEFAULT_FADE_OUT_VOLUME_SHAPER_CONFIG); + expect.withMessage("Fade out duration for game usage") + .that(mFmc.getFadeOutDurationForUsage(AudioAttributes.USAGE_GAME)) + .isEqualTo(DEFAULT_FADE_OUT_DURATION_MS); + expect.withMessage("Fade in volume shaper config for media uasge") + .that(mFmc.getFadeInVolumeShaperConfigForUsage(AudioAttributes.USAGE_MEDIA)) + .isEqualTo(TEST_DEFAULT_FADE_IN_VOLUME_SHAPER_CONFIG); + expect.withMessage("Fade in duration for game audio usage") + .that(mFmc.getFadeInDurationForUsage(AudioAttributes.USAGE_GAME)) + .isEqualTo(DEFAULT_FADE_IN_DURATION_MS); + } + + @Test + public void build_withFadeDurations_succeeds() { + FadeManagerConfiguration fmc = new FadeManagerConfiguration + .Builder(TEST_FADE_OUT_DURATION_MS, TEST_FADE_IN_DURATION_MS).build(); + + expect.withMessage("Fade state for builder with duration").that(fmc.getFadeState()) + .isEqualTo(FadeManagerConfiguration.FADE_STATE_ENABLED_DEFAULT); + expect.withMessage("Fadeable usages for builder with duration") + .that(fmc.getFadeableUsages()) + .containsExactlyElementsIn(TEST_FADEABLE_USAGES); + expect.withMessage("Unfadeable content types usages for builder with duration") + .that(fmc.getUnfadeableContentTypes()) + .containsExactlyElementsIn(TEST_UNFADEABLE_CONTENT_TYPES); + expect.withMessage("Unfadeable player types for builder with duration") + .that(fmc.getUnfadeablePlayerTypes()) + .containsExactlyElementsIn(TEST_UNFADEABLE_PLAYER_TYPES); + expect.withMessage("Unfadeable uids for builder with duration") + .that(fmc.getUnfadeableUids()).isEmpty(); + expect.withMessage("Unfadeable audio attributes for builder with duration") + .that(fmc.getUnfadeableAudioAttributes()).isEmpty(); + expect.withMessage("Fade out volume shaper config for media usage") + .that(fmc.getFadeOutVolumeShaperConfigForUsage(AudioAttributes.USAGE_MEDIA)) + .isEqualTo(TEST_FADE_OUT_VOLUME_SHAPER_CONFIG); + expect.withMessage("Fade out duration for game usage") + .that(fmc.getFadeOutDurationForUsage(AudioAttributes.USAGE_GAME)) + .isEqualTo(TEST_FADE_OUT_DURATION_MS); + expect.withMessage("Fade in volume shaper config for media audio attributes") + .that(fmc.getFadeInVolumeShaperConfigForUsage(AudioAttributes.USAGE_MEDIA)) + .isEqualTo(TEST_FADE_IN_VOLUME_SHAPER_CONFIG); + expect.withMessage("Fade in duration for game audio attributes") + .that(fmc.getFadeInDurationForUsage(AudioAttributes.USAGE_GAME)) + .isEqualTo(TEST_FADE_IN_DURATION_MS); + + } + + @Test + public void build_withFadeManagerConfiguration_succeeds() { + FadeManagerConfiguration fmcObj = new FadeManagerConfiguration + .Builder(TEST_FADE_OUT_DURATION_MS, TEST_FADE_IN_DURATION_MS).build(); + + FadeManagerConfiguration fmc = new FadeManagerConfiguration + .Builder(fmcObj).build(); + + expect.withMessage("Fade state for copy builder").that(fmc.getFadeState()) + .isEqualTo(fmcObj.getFadeState()); + expect.withMessage("Fadeable usages for copy builder") + .that(fmc.getFadeableUsages()) + .containsExactlyElementsIn(fmcObj.getFadeableUsages()); + expect.withMessage("Unfadeable content types usages for copy builder") + .that(fmc.getUnfadeableContentTypes()) + .containsExactlyElementsIn(fmcObj.getUnfadeableContentTypes()); + expect.withMessage("Unfadeable player types for copy builder") + .that(fmc.getUnfadeablePlayerTypes()) + .containsExactlyElementsIn(fmcObj.getUnfadeablePlayerTypes()); + expect.withMessage("Unfadeable uids for copy builder") + .that(fmc.getUnfadeableUids()).isEqualTo(fmcObj.getUnfadeableUids()); + expect.withMessage("Unfadeable audio attributes for copy builder") + .that(fmc.getUnfadeableAudioAttributes()) + .isEqualTo(fmcObj.getUnfadeableAudioAttributes()); + expect.withMessage("Fade out volume shaper config for media usage") + .that(fmc.getFadeOutVolumeShaperConfigForUsage(AudioAttributes.USAGE_MEDIA)) + .isEqualTo(fmcObj.getFadeOutVolumeShaperConfigForUsage( + AudioAttributes.USAGE_MEDIA)); + expect.withMessage("Fade out volume shaper config for game usage") + .that(fmc.getFadeOutVolumeShaperConfigForUsage(AudioAttributes.USAGE_GAME)) + .isEqualTo(fmcObj.getFadeOutVolumeShaperConfigForUsage( + AudioAttributes.USAGE_GAME)); + expect.withMessage("Fade in volume shaper config for media usage") + .that(fmc.getFadeInVolumeShaperConfigForUsage(AudioAttributes.USAGE_MEDIA)) + .isEqualTo(fmcObj.getFadeInVolumeShaperConfigForUsage( + AudioAttributes.USAGE_MEDIA)); + expect.withMessage("Fade in volume shaper config for game usage") + .that(fmc.getFadeInVolumeShaperConfigForUsage(AudioAttributes.USAGE_GAME)) + .isEqualTo(fmcObj.getFadeInVolumeShaperConfigForUsage( + AudioAttributes.USAGE_GAME)); + expect.withMessage("Fade out volume shaper config for media audio attributes") + .that(fmc.getFadeOutVolumeShaperConfigForAudioAttributes( + TEST_MEDIA_AUDIO_ATTRIBUTE)) + .isEqualTo(fmcObj.getFadeOutVolumeShaperConfigForAudioAttributes( + TEST_MEDIA_AUDIO_ATTRIBUTE)); + expect.withMessage("Fade out duration for game audio attributes") + .that(fmc.getFadeOutDurationForAudioAttributes(TEST_GAME_AUDIO_ATTRIBUTE)) + .isEqualTo(fmcObj.getFadeOutDurationForAudioAttributes(TEST_GAME_AUDIO_ATTRIBUTE)); + expect.withMessage("Fade in volume shaper config for media audio attributes") + .that(fmc.getFadeInVolumeShaperConfigForAudioAttributes(TEST_MEDIA_AUDIO_ATTRIBUTE)) + .isEqualTo(fmcObj.getFadeInVolumeShaperConfigForAudioAttributes( + TEST_MEDIA_AUDIO_ATTRIBUTE)); + expect.withMessage("Fade in duration for game audio attributes") + .that(fmc.getFadeInDurationForAudioAttributes(TEST_GAME_AUDIO_ATTRIBUTE)) + .isEqualTo(fmcObj.getFadeInDurationForAudioAttributes(TEST_GAME_AUDIO_ATTRIBUTE)); + } + + @Test + public void testSetFadeState_toDisable() { + final int fadeState = FadeManagerConfiguration.FADE_STATE_DISABLED; + FadeManagerConfiguration fmc = new FadeManagerConfiguration.Builder() + .setFadeState(fadeState).build(); + + expect.withMessage("Fade state when disabled").that(fmc.getFadeState()) + .isEqualTo(fadeState); + } + + @Test + public void testSetFadeState_toEnableAuto() { + final int fadeStateAuto = FadeManagerConfiguration.FADE_STATE_ENABLED_AUTO; + FadeManagerConfiguration fmc = new FadeManagerConfiguration.Builder() + .setFadeState(fadeStateAuto).build(); + + expect.withMessage("Fade state when enabled for audio").that(fmc.getFadeState()) + .isEqualTo(fadeStateAuto); + } + + @Test + public void testSetFadeState_toInvalid_fails() { + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> + new FadeManagerConfiguration.Builder() + .setFadeState(TEST_INVALID_FADE_STATE).build() + ); + + expect.withMessage("Invalid fade state exception").that(thrown) + .hasMessageThat().contains("Unknown fade state"); + } + + @Test + public void testSetFadeVolShaperConfig() { + FadeManagerConfiguration fmc = new FadeManagerConfiguration.Builder() + .setFadeOutVolumeShaperConfigForAudioAttributes(TEST_ASSISTANT_AUDIO_ATTRIBUTE, + TEST_FADE_OUT_VOLUME_SHAPER_CONFIG) + .setFadeInVolumeShaperConfigForAudioAttributes(TEST_ASSISTANT_AUDIO_ATTRIBUTE, + TEST_FADE_IN_VOLUME_SHAPER_CONFIG).build(); + + expect.withMessage("Fade out volume shaper config set for assistant audio attributes") + .that(fmc.getFadeOutVolumeShaperConfigForAudioAttributes( + TEST_ASSISTANT_AUDIO_ATTRIBUTE)) + .isEqualTo(TEST_FADE_OUT_VOLUME_SHAPER_CONFIG); + expect.withMessage("Fade in volume shaper config set for assistant audio attributes") + .that(fmc.getFadeInVolumeShaperConfigForAudioAttributes( + TEST_ASSISTANT_AUDIO_ATTRIBUTE)) + .isEqualTo(TEST_FADE_IN_VOLUME_SHAPER_CONFIG); + } + + @Test + public void testSetFadeOutVolShaperConfig_withNullAudioAttributes_fails() { + NullPointerException thrown = assertThrows(NullPointerException.class, () -> + new FadeManagerConfiguration.Builder() + .setFadeOutVolumeShaperConfigForAudioAttributes(/* audioAttributes= */ null, + TEST_FADE_OUT_VOLUME_SHAPER_CONFIG).build() + ); + + expect.withMessage("Null audio attributes for fade out exception") + .that(thrown).hasMessageThat().contains("cannot be null"); + } + + @Test + public void testSetFadeVolShaperConfig_withNullVolumeShaper_getsNull() { + FadeManagerConfiguration fmc = new FadeManagerConfiguration.Builder(mFmc) + .setFadeOutVolumeShaperConfigForAudioAttributes(TEST_MEDIA_AUDIO_ATTRIBUTE, + /* VolumeShaper.Configuration= */ null) + .setFadeInVolumeShaperConfigForAudioAttributes(TEST_MEDIA_AUDIO_ATTRIBUTE, + /* VolumeShaper.Configuration= */ null) + .clearFadeableUsage(AudioAttributes.USAGE_MEDIA).build(); + + expect.withMessage("Fade out volume shaper config set with null value") + .that(fmc.getFadeOutVolumeShaperConfigForAudioAttributes( + TEST_MEDIA_AUDIO_ATTRIBUTE)).isNull(); + } + + @Test + public void testSetFadeInVolShaperConfig_withNullAudioAttributes_fails() { + NullPointerException thrown = assertThrows(NullPointerException.class, () -> + new FadeManagerConfiguration.Builder() + .setFadeInVolumeShaperConfigForAudioAttributes(/* audioAttributes= */ null, + TEST_FADE_IN_VOLUME_SHAPER_CONFIG).build() + ); + + expect.withMessage("Null audio attributes for fade in exception") + .that(thrown).hasMessageThat().contains("cannot be null"); + } + + @Test + public void testSetFadeDuration() { + FadeManagerConfiguration fmc = new FadeManagerConfiguration.Builder() + .setFadeOutDurationForAudioAttributes(TEST_GAME_AUDIO_ATTRIBUTE, + TEST_FADE_OUT_DURATION_MS) + .setFadeInDurationForAudioAttributes(TEST_GAME_AUDIO_ATTRIBUTE, + TEST_FADE_IN_DURATION_MS).build(); + + expect.withMessage("Fade out duration set for audio attributes") + .that(fmc.getFadeOutDurationForAudioAttributes(TEST_GAME_AUDIO_ATTRIBUTE)) + .isEqualTo(TEST_FADE_OUT_DURATION_MS); + expect.withMessage("Fade in duration set for audio attributes") + .that(fmc.getFadeInDurationForAudioAttributes(TEST_GAME_AUDIO_ATTRIBUTE)) + .isEqualTo(TEST_FADE_IN_DURATION_MS); + } + + @Test + public void testSetFadeOutDuration_withNullAudioAttributes_fails() { + NullPointerException thrown = assertThrows(NullPointerException.class, () -> + new FadeManagerConfiguration.Builder().setFadeOutDurationForAudioAttributes( + /* audioAttributes= */ null, TEST_FADE_OUT_DURATION_MS).build() + ); + + expect.withMessage("Null audio attributes for fade out duration exception").that(thrown) + .hasMessageThat().contains("cannot be null"); + } + + @Test + public void testSetFadeOutDuration_withInvalidDuration_fails() { + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> + new FadeManagerConfiguration.Builder().setFadeOutDurationForAudioAttributes( + TEST_NAVIGATION_AUDIO_ATTRIBUTE, TEST_INVALID_DURATION).build() + ); + + expect.withMessage("Invalid duration for fade out exception").that(thrown) + .hasMessageThat().contains("not positive"); + } + + @Test + public void testSetFadeInDuration_withNullAudioAttributes_fails() { + NullPointerException thrown = assertThrows(NullPointerException.class, () -> + new FadeManagerConfiguration.Builder().setFadeInDurationForAudioAttributes( + /* audioAttributes= */ null, TEST_FADE_IN_DURATION_MS).build() + ); + + expect.withMessage("Null audio attributes for fade in duration exception").that(thrown) + .hasMessageThat().contains("cannot be null"); + } + + @Test + public void testSetFadeInDuration_withInvalidDuration_fails() { + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> + new FadeManagerConfiguration.Builder().setFadeInDurationForAudioAttributes( + TEST_NAVIGATION_AUDIO_ATTRIBUTE, TEST_INVALID_DURATION).build() + ); + + expect.withMessage("Invalid duration for fade in exception").that(thrown) + .hasMessageThat().contains("not positive"); + } + + @Test + public void testSetFadeableUsages() { + final List<Integer> fadeableUsages = List.of( + AudioAttributes.USAGE_VOICE_COMMUNICATION, + AudioAttributes.USAGE_ALARM, + AudioAttributes.USAGE_ASSISTANT + ); + AudioAttributes aaForVoiceComm = createAudioAttributesForUsage( + AudioAttributes.USAGE_VOICE_COMMUNICATION); + AudioAttributes aaForAlarm = createAudioAttributesForUsage(AudioAttributes.USAGE_ALARM); + AudioAttributes aaForAssistant = createAudioAttributesForUsage( + AudioAttributes.USAGE_ASSISTANT); + + + FadeManagerConfiguration fmc = new FadeManagerConfiguration.Builder() + .setFadeableUsages(fadeableUsages) + .setFadeOutVolumeShaperConfigForAudioAttributes(aaForVoiceComm, + TEST_FADE_OUT_VOLUME_SHAPER_CONFIG) + .setFadeInVolumeShaperConfigForAudioAttributes(aaForVoiceComm, + TEST_FADE_IN_VOLUME_SHAPER_CONFIG) + .setFadeOutVolumeShaperConfigForAudioAttributes(aaForAlarm, + TEST_FADE_OUT_VOLUME_SHAPER_CONFIG) + .setFadeInVolumeShaperConfigForAudioAttributes(aaForAlarm, + TEST_FADE_IN_VOLUME_SHAPER_CONFIG) + .setFadeOutVolumeShaperConfigForAudioAttributes(aaForAssistant, + TEST_FADE_OUT_VOLUME_SHAPER_CONFIG) + .setFadeInVolumeShaperConfigForAudioAttributes(aaForAssistant, + TEST_FADE_IN_VOLUME_SHAPER_CONFIG).build(); + + expect.withMessage("Fadeable usages") + .that(fmc.getFadeableUsages()).isEqualTo(fadeableUsages); + } + + @Test + public void testSetFadeableUsages_withInvalidUsage_fails() { + final List<Integer> fadeableUsages = List.of( + AudioAttributes.USAGE_VOICE_COMMUNICATION, + TEST_INVALID_USAGE, + AudioAttributes.USAGE_ANNOUNCEMENT + ); + + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> + new FadeManagerConfiguration.Builder().setFadeableUsages(fadeableUsages).build() + ); + + expect.withMessage("Fadeable usages set to invalid usage").that(thrown).hasMessageThat() + .contains("Invalid usage"); + } + + @Test + public void testSetFadeableUsages_withNullUsages_fails() { + NullPointerException thrown = assertThrows(NullPointerException.class, () -> + new FadeManagerConfiguration.Builder().setFadeableUsages(/* usages= */ null) + .build() + ); + + expect.withMessage("Fadeable usages set to null list").that(thrown).hasMessageThat() + .contains("cannot be null"); + } + + @Test + public void testSetFadeableUsages_withEmptyListClears_addsNewUsage() { + final List<Integer> fadeableUsages = List.of( + AudioAttributes.USAGE_VOICE_COMMUNICATION, + AudioAttributes.USAGE_ALARM, + AudioAttributes.USAGE_ASSISTANT + ); + FadeManagerConfiguration.Builder fmcBuilder = new FadeManagerConfiguration.Builder() + .setFadeableUsages(fadeableUsages); + + fmcBuilder.setFadeableUsages(List.of()); + + FadeManagerConfiguration fmc = fmcBuilder + .addFadeableUsage(AudioAttributes.USAGE_MEDIA) + .setFadeOutVolumeShaperConfigForAudioAttributes(TEST_MEDIA_AUDIO_ATTRIBUTE, + TEST_FADE_OUT_VOLUME_SHAPER_CONFIG) + .setFadeInVolumeShaperConfigForAudioAttributes(TEST_MEDIA_AUDIO_ATTRIBUTE, + TEST_FADE_IN_VOLUME_SHAPER_CONFIG).build(); + expect.withMessage("Fadeable usages set to empty list") + .that(fmc.getFadeableUsages()).isEqualTo(List.of(AudioAttributes.USAGE_MEDIA)); + } + + + @Test + public void testAddFadeableUsage() { + final int usageToAdd = AudioAttributes.USAGE_ASSISTANT; + AudioAttributes aaToAdd = createAudioAttributesForUsage(usageToAdd); + List<Integer> updatedUsages = new ArrayList<>(mFmc.getFadeableUsages()); + updatedUsages.add(usageToAdd); + + FadeManagerConfiguration updatedFmc = new FadeManagerConfiguration + .Builder(mFmc).addFadeableUsage(usageToAdd) + .setFadeOutVolumeShaperConfigForAudioAttributes(aaToAdd, + TEST_FADE_OUT_VOLUME_SHAPER_CONFIG) + .setFadeInVolumeShaperConfigForAudioAttributes(aaToAdd, + TEST_FADE_IN_VOLUME_SHAPER_CONFIG) + .build(); + + expect.withMessage("Fadeable usages").that(updatedFmc.getFadeableUsages()) + .containsExactlyElementsIn(updatedUsages); + } + + @Test + public void testAddFadeableUsage_withoutSetFadeableUsages() { + final int newUsage = AudioAttributes.USAGE_ASSISTANT; + AudioAttributes aaToAdd = createAudioAttributesForUsage(newUsage); + + FadeManagerConfiguration fmc = new FadeManagerConfiguration.Builder() + .addFadeableUsage(newUsage) + .setFadeOutVolumeShaperConfigForAudioAttributes(aaToAdd, + TEST_FADE_OUT_VOLUME_SHAPER_CONFIG) + .setFadeInVolumeShaperConfigForAudioAttributes(aaToAdd, + TEST_FADE_IN_VOLUME_SHAPER_CONFIG) + .build(); + + expect.withMessage("Fadeable usages").that(fmc.getFadeableUsages()) + .containsExactlyElementsIn(List.of(newUsage)); + } + + @Test + public void testAddFadeableUsage_withInvalidUsage_fails() { + List<Integer> setUsages = Arrays.asList( + AudioAttributes.USAGE_VOICE_COMMUNICATION, + AudioAttributes.USAGE_ASSISTANT + ); + AudioAttributes aaForVoiceComm = createAudioAttributesForUsage( + AudioAttributes.USAGE_VOICE_COMMUNICATION); + AudioAttributes aaForAssistant = createAudioAttributesForUsage( + AudioAttributes.USAGE_ASSISTANT); + FadeManagerConfiguration.Builder fmcBuilder = new FadeManagerConfiguration.Builder() + .setFadeableUsages(setUsages) + .setFadeOutVolumeShaperConfigForAudioAttributes(aaForVoiceComm, + TEST_FADE_OUT_VOLUME_SHAPER_CONFIG) + .setFadeInVolumeShaperConfigForAudioAttributes(aaForVoiceComm, + TEST_FADE_IN_VOLUME_SHAPER_CONFIG) + .setFadeOutVolumeShaperConfigForAudioAttributes(aaForAssistant, + TEST_FADE_OUT_VOLUME_SHAPER_CONFIG) + .setFadeInVolumeShaperConfigForAudioAttributes(aaForAssistant, + TEST_FADE_IN_VOLUME_SHAPER_CONFIG); + + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> + fmcBuilder.addFadeableUsage(TEST_INVALID_USAGE) + ); + + FadeManagerConfiguration fmc = fmcBuilder.build(); + expect.withMessage("Fadeable usages ").that(thrown).hasMessageThat() + .contains("Invalid usage"); + expect.withMessage("Fadeable usages").that(fmc.getFadeableUsages()) + .containsExactlyElementsIn(setUsages); + } + + @Test + public void testClearFadeableUsage() { + final int usageToClear = AudioAttributes.USAGE_MEDIA; + List<Integer> updatedUsages = new ArrayList<>(mFmc.getFadeableUsages()); + updatedUsages.remove((Integer) usageToClear); + + FadeManagerConfiguration updatedFmc = new FadeManagerConfiguration + .Builder(mFmc).clearFadeableUsage(usageToClear).build(); + + expect.withMessage("Clear fadeable usage").that(updatedFmc.getFadeableUsages()) + .containsExactlyElementsIn(updatedUsages); + } + + @Test + public void testClearFadeableUsage_withInvalidUsage_fails() { + FadeManagerConfiguration.Builder fmcBuilder = new FadeManagerConfiguration.Builder(mFmc); + + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> + fmcBuilder.clearFadeableUsage(TEST_INVALID_USAGE) + ); + + FadeManagerConfiguration fmc = fmcBuilder.build(); + expect.withMessage("Clear invalid usage").that(thrown).hasMessageThat() + .contains("Invalid usage"); + expect.withMessage("Fadeable usages").that(fmc.getFadeableUsages()) + .containsExactlyElementsIn(mFmc.getFadeableUsages()); + } + + @Test + public void testSetUnfadeableContentTypes() { + final List<Integer> unfadeableContentTypes = List.of( + AudioAttributes.CONTENT_TYPE_MOVIE, + AudioAttributes.CONTENT_TYPE_SONIFICATION + ); + FadeManagerConfiguration fmc = new FadeManagerConfiguration.Builder() + .setUnfadeableContentTypes(unfadeableContentTypes).build(); + + expect.withMessage("Unfadeable content types set") + .that(fmc.getUnfadeableContentTypes()).isEqualTo(unfadeableContentTypes); + } + + @Test + public void testSetUnfadeableContentTypes_withInvalidContentType_fails() { + final List<Integer> invalidUnfadeableContentTypes = List.of( + AudioAttributes.CONTENT_TYPE_MOVIE, + TEST_INVALID_CONTENT_TYPE, + AudioAttributes.CONTENT_TYPE_SONIFICATION + ); + + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> + new FadeManagerConfiguration.Builder() + .setUnfadeableContentTypes(invalidUnfadeableContentTypes).build() + ); + + expect.withMessage("Invalid content type set exception").that(thrown).hasMessageThat() + .contains("Invalid content type"); + } + + @Test + public void testSetUnfadeableContentTypes_withNullContentType_fails() { + NullPointerException thrown = assertThrows(NullPointerException.class, () -> + new FadeManagerConfiguration.Builder() + .setUnfadeableContentTypes(/* contentType= */ null).build() + ); + + expect.withMessage("Null content type set exception").that(thrown).hasMessageThat() + .contains("cannot be null"); + } + + @Test + public void testSetUnfadeableContentTypes_withEmptyList_clearsExistingList() { + final List<Integer> unfadeableContentTypes = List.of( + AudioAttributes.CONTENT_TYPE_MOVIE, + AudioAttributes.CONTENT_TYPE_SONIFICATION + ); + FadeManagerConfiguration fmc = new FadeManagerConfiguration.Builder() + .setUnfadeableContentTypes(unfadeableContentTypes).build(); + + FadeManagerConfiguration fmcWithEmptyLsit = new FadeManagerConfiguration.Builder(fmc) + .setUnfadeableContentTypes(List.of()).build(); + + expect.withMessage("Unfadeable content types for empty list") + .that(fmcWithEmptyLsit.getUnfadeableContentTypes()).isEmpty(); + } + + @Test + public void testAddUnfadeableContentType() { + final int contentTypeToAdd = AudioAttributes.CONTENT_TYPE_MOVIE; + List<Integer> upatdedContentTypes = new ArrayList<>(mFmc.getUnfadeableContentTypes()); + upatdedContentTypes.add(contentTypeToAdd); + + FadeManagerConfiguration updatedFmc = new FadeManagerConfiguration + .Builder(mFmc).addUnfadeableContentType(contentTypeToAdd).build(); + + expect.withMessage("Unfadeable content types").that(updatedFmc.getUnfadeableContentTypes()) + .containsExactlyElementsIn(upatdedContentTypes); + } + + @Test + public void testAddUnfadeableContentTypes_withoutSetUnfadeableContentTypes() { + final int newContentType = AudioAttributes.CONTENT_TYPE_MOVIE; + + FadeManagerConfiguration fmc = new FadeManagerConfiguration.Builder() + .addUnfadeableContentType(newContentType).build(); + + expect.withMessage("Unfadeable content types").that(fmc.getUnfadeableContentTypes()) + .containsExactlyElementsIn(List.of(newContentType)); + } + + @Test + public void testAddunfadeableContentTypes_withInvalidContentType_fails() { + final List<Integer> unfadeableContentTypes = List.of( + AudioAttributes.CONTENT_TYPE_MOVIE, + AudioAttributes.CONTENT_TYPE_SONIFICATION + ); + FadeManagerConfiguration.Builder fmcBuilder = new FadeManagerConfiguration.Builder() + .setUnfadeableContentTypes(unfadeableContentTypes); + + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> + fmcBuilder.addUnfadeableContentType(TEST_INVALID_CONTENT_TYPE).build() + ); + + expect.withMessage("Invalid content types exception").that(thrown).hasMessageThat() + .contains("Invalid content type"); + } + + @Test + public void testClearUnfadeableContentType() { + List<Integer> unfadeableContentTypes = new ArrayList<>(Arrays.asList( + AudioAttributes.CONTENT_TYPE_MOVIE, + AudioAttributes.CONTENT_TYPE_SONIFICATION + )); + final int contentTypeToClear = AudioAttributes.CONTENT_TYPE_MOVIE; + + FadeManagerConfiguration updatedFmc = new FadeManagerConfiguration.Builder() + .setUnfadeableContentTypes(unfadeableContentTypes) + .clearUnfadeableContentType(contentTypeToClear).build(); + + unfadeableContentTypes.remove((Integer) contentTypeToClear); + expect.withMessage("Unfadeable content types").that(updatedFmc.getUnfadeableContentTypes()) + .containsExactlyElementsIn(unfadeableContentTypes); + } + + @Test + public void testClearUnfadeableContentType_withInvalidContentType_fails() { + FadeManagerConfiguration.Builder fmcBuilder = new FadeManagerConfiguration.Builder(mFmc); + + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> + fmcBuilder.clearUnfadeableContentType(TEST_INVALID_CONTENT_TYPE).build() + ); + + expect.withMessage("Invalid content type exception").that(thrown).hasMessageThat() + .contains("Invalid content type"); + } + + @Test + public void testSetUnfadeableUids() { + final List<Integer> unfadeableUids = List.of( + TEST_UID_1, + TEST_UID_2 + ); + FadeManagerConfiguration fmc = new FadeManagerConfiguration.Builder() + .setUnfadeableUids(unfadeableUids).build(); + + expect.withMessage("Unfadeable uids set") + .that(fmc.getUnfadeableUids()).isEqualTo(unfadeableUids); + } + + @Test + public void testSetUnfadeableUids_withNullUids_fails() { + NullPointerException thrown = assertThrows(NullPointerException.class, () -> + new FadeManagerConfiguration.Builder() + .setUnfadeableUids(/* uids= */ null).build() + ); + + expect.withMessage("Null unfadeable uids").that(thrown).hasMessageThat() + .contains("cannot be null"); + } + + @Test + public void testAddUnfadeableUid() { + FadeManagerConfiguration fmc = new FadeManagerConfiguration.Builder() + .addUnfadeableUid(TEST_UID_1).build(); + + expect.withMessage("Unfadeable uids") + .that(fmc.getUnfadeableUids()).isEqualTo(List.of(TEST_UID_1)); + } + + @Test + public void testClearUnfadebaleUid() { + final List<Integer> unfadeableUids = List.of( + TEST_UID_1, + TEST_UID_2 + ); + FadeManagerConfiguration fmc = new FadeManagerConfiguration.Builder() + .setUnfadeableUids(unfadeableUids).build(); + + FadeManagerConfiguration updatedFmc = new FadeManagerConfiguration.Builder(fmc) + .clearUnfadeableUid(TEST_UID_1).build(); + + expect.withMessage("Unfadeable uids").that(updatedFmc.getUnfadeableUids()) + .isEqualTo(List.of(TEST_UID_2)); + } + + @Test + public void testSetUnfadeableAudioAttributes() { + final List<AudioAttributes> unfadeableAttrs = List.of( + TEST_ASSISTANT_AUDIO_ATTRIBUTE, + TEST_NAVIGATION_AUDIO_ATTRIBUTE + ); + + FadeManagerConfiguration fmc = new FadeManagerConfiguration.Builder() + .setUnfadeableAudioAttributes(unfadeableAttrs).build(); + + expect.withMessage("Unfadeable audio attributes") + .that(fmc.getUnfadeableAudioAttributes()).isEqualTo(unfadeableAttrs); + } + + @Test + public void testSetUnfadeableAudioAttributes_withNullAttributes_fails() { + NullPointerException thrown = assertThrows(NullPointerException.class, () -> + new FadeManagerConfiguration.Builder() + .setUnfadeableAudioAttributes(/* attrs= */ null).build() + ); + + expect.withMessage("Null audio attributes exception").that(thrown).hasMessageThat() + .contains("cannot be null"); + } + + @Test + public void testWriteToParcel_andCreateFromParcel() { + Parcel parcel = Parcel.obtain(); + + mFmc.writeToParcel(parcel, TEST_PARCEL_FLAGS); + parcel.setDataPosition(/* position= */ 0); + expect.withMessage("Fade manager configuration write to and create from parcel") + .that(mFmc) + .isEqualTo(FadeManagerConfiguration.CREATOR.createFromParcel(parcel)); + } + + private static AudioAttributes createAudioAttributesForUsage(int usage) { + if (AudioAttributes.isSystemUsage(usage)) { + return new AudioAttributes.Builder().setSystemUsage(usage).build(); + } + return new AudioAttributes.Builder().setUsage(usage).build(); + } +} diff --git a/packages/InputDevices/res/raw/keyboard_layout_ukrainian.kcm b/packages/InputDevices/res/raw/keyboard_layout_ukrainian.kcm index 90041da529c0..24b4d2fd6487 100644 --- a/packages/InputDevices/res/raw/keyboard_layout_ukrainian.kcm +++ b/packages/InputDevices/res/raw/keyboard_layout_ukrainian.kcm @@ -14,8 +14,8 @@ # # Ukrainian keyboard layout. -# This is a typical Ukrainian PC keyboard layout. -# As an added convenience, English characters are accessible using ralt (Alt Gr). +# Based on PC enhanced Ukrainian layout with added Unicode keys based on +# the Linux one. # type OVERLAY @@ -25,32 +25,34 @@ map key 86 PLUS ### ROW 1 key GRAVE { - label: '\u0401' - base: '\u0451' - shift, capslock: '\u0401' - shift+capslock: '\u0451' - ralt: '`' + label: '\'' + base: '\'' + shift: '\u02bc' + ralt: '\u0301' ralt+shift: '~' } key 1 { label: '1' base: '1' - shift, ralt: '!' + shift: '!' + ralt: '\u00b9' } key 2 { label: '2' base: '2' shift: '"' - ralt: '@' + ralt: '\u00b2' + ralt+shift: '\u2019' } key 3 { label: '3' base: '3' shift: '\u2116' - ralt: '#' + ralt: '\u00a7' + ralt+shift: '\u20b4' } key 4 { @@ -58,60 +60,67 @@ key 4 { base: '4' shift: ';' ralt: '$' + ralt+shift: '\u20ac' } key 5 { label: '5' base: '5' - shift, ralt: '%' + shift: '%' + ralt: '\u00b0' } key 6 { label: '6' base: '6' shift: ':' - ralt: '^' + ralt: '<' } key 7 { label: '7' base: '7' shift: '?' - ralt: '&' + ralt: '>' } key 8 { label: '8' base: '8' - shift, ralt: '*' + shift: '*' + ralt: '\u2022' } key 9 { label: '9' base: '9' - shift, ralt: '(' + shift: '(' + ralt: '[' + ralt+shift: '{' } key 0 { label: '0' base: '0' - shift, ralt: ')' + shift: ')' + ralt: ']' + ralt+shift: '}' } key MINUS { label: '-' base: '-' shift: '_' - ralt: '-' - shift+ralt: '_' + ralt: '\u2014' + shift+ralt: '\u2013' } key EQUALS { label: '=' base: '=' shift: '+' - ralt: '=' - shift+ralt: '+' + ralt: '\u2260' + shift+ralt: '\u00b1' } ### ROW 2 @@ -121,6 +130,9 @@ key Q { base: '\u0439' shift, capslock: '\u0419' shift+capslock: '\u0439' + ralt: '\u0458' + ralt+shift, ralt+capslock: '\u0408' + ralt+shift+capslock: '\u0458' } key W { @@ -128,6 +140,9 @@ key W { base: '\u0446' shift, capslock: '\u0426' shift+capslock: '\u0446' + ralt: '\u045f' + ralt+shift, ralt+capslock: '\u040f' + ralt+shift+capslock: '\u045f' } key E { @@ -135,6 +150,9 @@ key E { base: '\u0443' shift, capslock: '\u0423' shift+capslock: '\u0443' + ralt: '\u045e' + ralt+shift, ralt+capslock: '\u040e' + ralt+shift+capslock: '\u045e' } key R { @@ -142,6 +160,7 @@ key R { base: '\u043a' shift, capslock: '\u041a' shift+capslock: '\u043a' + ralt: '\u00ae' } key T { @@ -149,6 +168,9 @@ key T { base: '\u0435' shift, capslock: '\u0415' shift+capslock: '\u0435' + ralt: '\u0451' + ralt+shift, ralt+capslock: '\u0401' + ralt+shift+capslock: '\u0451' } key Y { @@ -156,6 +178,9 @@ key Y { base: '\u043d' shift, capslock: '\u041d' shift+capslock: '\u043d' + ralt: '\u045a' + ralt+shift, ralt+capslock: '\u040a' + ralt+shift+capslock: '\u045a' } key U { @@ -164,8 +189,8 @@ key U { shift, capslock: '\u0413' shift+capslock: '\u0433' ralt: '\u0491' - shift+ralt, capslock+ralt: '\u0490' - shift+capslock+ralt: '\u0491' + ralt+shift, ralt+capslock: '\u0490' + ralt+shift+capslock: '\u0491' } key I { @@ -201,6 +226,9 @@ key RIGHT_BRACKET { base: '\u0457' shift, capslock: '\u0407' shift+capslock: '\u0457' + ralt: '\u044a' + ralt+shift, ralt+capslock: '\u042a' + ralt+shift+capslock: '\u044a' } ### ROW 3 @@ -217,6 +245,9 @@ key S { base: '\u0456' shift, capslock: '\u0406' shift+capslock: '\u0456' + ralt: '\u044b' + ralt+shift, ralt+capslock: '\u042b' + ralt+shift+capslock: '\u044b' } key D { @@ -259,6 +290,9 @@ key K { base: '\u043b' shift, capslock: '\u041b' shift+capslock: '\u043b' + ralt: '\u0459' + ralt+shift, ralt+capslock: '\u0409' + ralt+shift+capslock: '\u0459' } key L { @@ -266,6 +300,9 @@ key L { base: '\u0434' shift, capslock: '\u0414' shift+capslock: '\u0434' + ralt: '\u0452' + ralt+shift, ralt+capslock: '\u0402' + ralt+shift+capslock: '\u0452' } key SEMICOLON { @@ -282,15 +319,18 @@ key APOSTROPHE { base: '\u0454' shift, capslock: '\u0404' shift+capslock: '\u0454' - ralt: '\'' - ralt+shift: '"' + ralt: '\u044d' + ralt+shift, ralt+capslock: '\u042d' + ralt+shift+capslock: '\u044d' } key BACKSLASH { label: '\\' base: '\\' shift: '/' - ralt: '|' + ralt: '\u0491' + ralt+shift, ralt+capslock: '\u0490' + ralt+shift+capslock: '\u0491' } ### ROW 4 @@ -316,6 +356,9 @@ key X { base: '\u0447' shift, capslock: '\u0427' shift+capslock: '\u0447' + ralt: '\u045b' + ralt+shift, ralt+capslock: '\u040b' + ralt+shift+capslock: '\u045b' } key C { @@ -323,6 +366,7 @@ key C { base: '\u0441' shift, capslock: '\u0421' shift+capslock: '\u0441' + ralt: '\u00a9' } key V { @@ -344,6 +388,7 @@ key N { base: '\u0442' shift, capslock: '\u0422' shift+capslock: '\u0442' + ralt: '\u2122' } key M { @@ -358,8 +403,8 @@ key COMMA { base: '\u0431' shift, capslock: '\u0411' shift+capslock: '\u0431' - ralt: ',' - ralt+shift: '<' + ralt: '\u00ab' + ralt+shift: '\u201e' } key PERIOD { @@ -367,8 +412,8 @@ key PERIOD { base: '\u044e' shift, capslock: '\u042e' shift+capslock: '\u044e' - ralt: '.' - ralt+shift: '>' + ralt: '\u00bb' + ralt+shift: '\u201c' } key SLASH { @@ -376,5 +421,5 @@ key SLASH { base: '.' shift: ',' ralt: '/' - ralt+shift: '?' + ralt+shift: '\u2026' } diff --git a/packages/PackageInstaller/src/com/android/packageinstaller/UninstallUninstalling.java b/packages/PackageInstaller/src/com/android/packageinstaller/UninstallUninstalling.java index 4e28d77aed08..09be76814d92 100644 --- a/packages/PackageInstaller/src/com/android/packageinstaller/UninstallUninstalling.java +++ b/packages/PackageInstaller/src/com/android/packageinstaller/UninstallUninstalling.java @@ -116,6 +116,7 @@ public class UninstallUninstalling extends Activity implements int flags = allUsers ? PackageManager.DELETE_ALL_USERS : 0; flags |= keepData ? PackageManager.DELETE_KEEP_DATA : 0; + flags |= getIntent().getIntExtra(PackageInstaller.EXTRA_DELETE_FLAGS, 0); createContextAsUser(user, 0).getPackageManager().getPackageInstaller().uninstall( new VersionedPackage(mAppInfo.packageName, diff --git a/packages/PackageInstaller/src/com/android/packageinstaller/UninstallerActivity.java b/packages/PackageInstaller/src/com/android/packageinstaller/UninstallerActivity.java index ba627e9e9202..5c9b728a0f9d 100644 --- a/packages/PackageInstaller/src/com/android/packageinstaller/UninstallerActivity.java +++ b/packages/PackageInstaller/src/com/android/packageinstaller/UninstallerActivity.java @@ -19,6 +19,7 @@ package com.android.packageinstaller; import static android.app.AppOpsManager.MODE_ALLOWED; import static android.content.pm.Flags.usePiaV2; import static android.view.WindowManager.LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; + import static com.android.packageinstaller.PackageUtil.getMaxTargetSdkVersionForUid; import android.Manifest; @@ -55,8 +56,8 @@ import com.android.packageinstaller.handheld.UninstallAlertDialogFragment; import com.android.packageinstaller.television.ErrorFragment; import com.android.packageinstaller.television.UninstallAlertFragment; import com.android.packageinstaller.television.UninstallAppProgress; - import com.android.packageinstaller.v2.ui.UninstallLaunch; + import java.util.List; /* @@ -76,6 +77,7 @@ public class UninstallerActivity extends Activity { public boolean allUsers; public UserHandle user; public PackageManager.UninstallCompleteCallback callback; + public int deleteFlags; } private String mPackageName; @@ -226,10 +228,26 @@ public class UninstallerActivity extends Activity { // Continue as the ActivityInfo isn't critical. } } + parseDeleteFlags(intent); showConfirmationDialog(); } + /** + * Parses specific {@link android.content.pm.PackageManager.DeleteFlags} from {@link Intent} + * to archive an app if requested. + * + * Do not parse any flags because developers might pass here any flags which might cause + * unintended behaviour. + * For more context {@link com.android.server.pm.PackageArchiver#requestArchive}. + */ + private void parseDeleteFlags(Intent intent) { + int deleteFlags = intent.getIntExtra(PackageInstaller.EXTRA_DELETE_FLAGS, 0); + int archive = deleteFlags & PackageManager.DELETE_ARCHIVE; + int keepData = deleteFlags & PackageManager.DELETE_KEEP_DATA; + mDialogInfo.deleteFlags = archive | keepData; + } + public DialogInfo getDialogInfo() { return mDialogInfo; } @@ -347,7 +365,10 @@ public class UninstallerActivity extends Activity { if (returnResult || getCallingActivity() != null) { newIntent.addFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT); } - + if (mDialogInfo.deleteFlags != 0) { + newIntent.putExtra(PackageInstaller.EXTRA_DELETE_FLAGS, + mDialogInfo.deleteFlags); + } startActivity(newIntent); } else { int uninstallId; @@ -393,6 +414,7 @@ public class UninstallerActivity extends Activity { int flags = mDialogInfo.allUsers ? PackageManager.DELETE_ALL_USERS : 0; flags |= keepData ? PackageManager.DELETE_KEEP_DATA : 0; + flags |= mDialogInfo.deleteFlags; createContextAsUser(mDialogInfo.user, 0).getPackageManager().getPackageInstaller() .uninstall(new VersionedPackage(mDialogInfo.appInfo.packageName, diff --git a/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/app/AppInfo.kt b/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/app/AppInfo.kt index 45295b013cf9..f306918ec72f 100644 --- a/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/app/AppInfo.kt +++ b/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/app/AppInfo.kt @@ -89,7 +89,7 @@ class AppInfoProvider(private val packageInfo: PackageInfo) { @Composable fun FooterAppVersion(showPackageName: Boolean = rememberIsDevelopmentSettingsEnabled()) { val context = LocalContext.current - val footer = remember(showPackageName) { + val footer = remember(packageInfo, showPackageName) { val list = mutableListOf<String>() packageInfo.versionNameBidiWrapped?.let { list += context.getString(R.string.version_text, it) diff --git a/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/app/AppStorageSize.kt b/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/app/AppStorageSize.kt index 626c913ac9e6..7a4f81cc1321 100644 --- a/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/app/AppStorageSize.kt +++ b/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/app/AppStorageSize.kt @@ -37,7 +37,7 @@ private const val TAG = "AppStorageSize" @Composable fun ApplicationInfo.getStorageSize(): State<String> { val context = LocalContext.current - return remember { + return remember(this) { flow { val sizeBytes = calculateSizeBytes(context) this.emit(if (sizeBytes != null) Formatter.formatFileSize(context, sizeBytes) else "") diff --git a/packages/SettingsLib/SpaPrivileged/tests/src/com/android/settingslib/spaprivileged/model/app/AppListRepositoryTest.kt b/packages/SettingsLib/SpaPrivileged/tests/src/com/android/settingslib/spaprivileged/model/app/AppListRepositoryTest.kt index 44973a743c76..f2922316dbde 100644 --- a/packages/SettingsLib/SpaPrivileged/tests/src/com/android/settingslib/spaprivileged/model/app/AppListRepositoryTest.kt +++ b/packages/SettingsLib/SpaPrivileged/tests/src/com/android/settingslib/spaprivileged/model/app/AppListRepositoryTest.kt @@ -126,10 +126,7 @@ class AppListRepositoryTest { val flags = argumentCaptor<ApplicationInfoFlags> { verify(packageManager).getInstalledApplicationsAsUser(capture(), eq(ADMIN_USER_ID)) }.firstValue - assertThat(flags.value).isEqualTo( - PackageManager.MATCH_DISABLED_COMPONENTS or - PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS - ) + assertThat(flags.value and PackageManager.MATCH_ANY_USER.toLong()).isEqualTo(0L) } @Test @@ -276,21 +273,6 @@ class AppListRepositoryTest { } @Test - fun loadApps_archivedAppsDisabled() = runTest { - mockInstalledApplications(listOf(NORMAL_APP), ADMIN_USER_ID) - val appList = repository.loadApps(userId = ADMIN_USER_ID) - - assertThat(appList).containsExactly(NORMAL_APP) - val flags = argumentCaptor<ApplicationInfoFlags> { - verify(packageManager).getInstalledApplicationsAsUser(capture(), eq(ADMIN_USER_ID)) - }.firstValue - assertThat(flags.value).isEqualTo( - PackageManager.MATCH_DISABLED_COMPONENTS or - PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS - ) - } - - @Test fun showSystemPredicate_showSystem() = runTest { val app = SYSTEM_APP diff --git a/packages/SettingsLib/aconfig/settingslib_media_flag_declarations.aconfig b/packages/SettingsLib/aconfig/settingslib_media_flag_declarations.aconfig index 4936f882f91e..f3e537b33230 100644 --- a/packages/SettingsLib/aconfig/settingslib_media_flag_declarations.aconfig +++ b/packages/SettingsLib/aconfig/settingslib_media_flag_declarations.aconfig @@ -12,4 +12,11 @@ flag { namespace: "tv_system_ui" description: "Gates all the changes for the tv specific media output dialog" bug: "303205631" -}
\ No newline at end of file +} + +flag { + name: "enable_output_switcher_for_system_routing" + namespace: "media_solutions" + description: "Enable Output Switcher when no media is playing." + bug: "284227163" +} diff --git a/packages/SettingsProvider/src/com/android/providers/settings/DatabaseHelper.java b/packages/SettingsProvider/src/com/android/providers/settings/DatabaseHelper.java index ed5654d4f259..ec50323dd91d 100644 --- a/packages/SettingsProvider/src/com/android/providers/settings/DatabaseHelper.java +++ b/packages/SettingsProvider/src/com/android/providers/settings/DatabaseHelper.java @@ -2432,9 +2432,7 @@ class DatabaseHelper extends SQLiteOpenHelper { R.bool.def_auto_time_zone); // Sync timezone to NITZ loadSetting(stmt, Settings.Global.STAY_ON_WHILE_PLUGGED_IN, - ("1".equals(SystemProperties.get("ro.boot.qemu")) - || res.getBoolean(R.bool.def_stay_on_while_plugged_in)) - ? 1 : 0); + res.getBoolean(R.bool.def_stay_on_while_plugged_in) ? 1 : 0); loadIntegerSetting(stmt, Settings.Global.WIFI_SLEEP_POLICY, R.integer.def_wifi_sleep_policy); diff --git a/packages/SystemUI/docs/qs-tiles.md b/packages/SystemUI/docs/qs-tiles.md index bd0b4abbeb34..ee388ec8e5c5 100644 --- a/packages/SystemUI/docs/qs-tiles.md +++ b/packages/SystemUI/docs/qs-tiles.md @@ -4,25 +4,37 @@ ## About this document -This document is a more or less comprehensive summary of the state and infrastructure used by Quick Settings tiles. It provides descriptions about the lifecycle of a tile, how to create new tiles and how SystemUI manages and displays tiles, among other topics. +This document is a more or less comprehensive summary of the state and infrastructure used by Quick +Settings tiles. It provides descriptions about the lifecycle of a tile, how to create new tiles and +how SystemUI manages and displays tiles, among other topics. ## What are Quick Settings Tiles? -Quick Settings (from now on, QS) is the expanded panel that contains shortcuts for the user to toggle many settings. This is opened by expanding the notification drawer twice (or once when phone is locked). Quick Quick Settings (QQS) is the smaller panel that appears on top of the notifications before expanding twice and contains some of the toggles with no secondary line. +Quick Settings (from now on, QS) is the expanded panel that contains shortcuts for the user to +toggle many settings. This is opened by expanding the notification drawer twice (or once when phone +is locked). Quick Quick Settings (QQS) is the smaller panel that appears on top of the notifications +before expanding twice and contains some of the toggles with no secondary line. -Each of these toggles that appear either in QS or QQS are called Quick Settings Tiles (or tiles for short). They allow the user to enable or disable settings quickly and sometimes provides access to more comprehensive settings pages. +Each of these toggles that appear either in QS or QQS are called Quick Settings Tiles (or tiles for +short). They allow the user to enable or disable settings quickly and sometimes provides access to +more comprehensive settings pages. The following image shows QQS on the left and QS on the right, with the tiles highlighted.  -QS Tiles usually depend on one or more Controllers that bind the tile with the necessary service. Controllers are obtained by the backend and used for communication between the user and the device. +QS Tiles usually depend on one or more Controllers that bind the tile with the necessary service. +Controllers are obtained by the backend and used for communication between the user and the device. ### A note on multi-user support -All the classes described in this document that live inside SystemUI are only instantiated in the process of user 0. The different controllers that back the QS Tiles (also instantiated just in user 0) are user aware and provide an illusion of different instances for different users. +All the classes described in this document that live inside SystemUI are only instantiated in the +process of user 0. The different controllers that back the QS Tiles (also instantiated just in user +0) are user aware and provide an illusion of different instances for different users. -For an example on this, see [`RotationLockController`](/packages/SystemUI/src/com/android/systemui/statusbar/policy/RotationLockControllerImpl.java). This controller for the `RotationLockTile` listens to changes in all users. +For an example on this, +see [`RotationLockController`](/packages/SystemUI/src/com/android/systemui/statusbar/policy/RotationLockControllerImpl.java). +This controller for the `RotationLockTile` listens to changes in all users. ## What are tiles made of? @@ -30,104 +42,161 @@ For an example on this, see [`RotationLockController`](/packages/SystemUI/src/co QS Tiles are composed of the following backend classes. -* [`QSTile`](/packages/SystemUI/plugin/src/com/android/systemui/plugins/qs/QSTile.java): Interface providing common behavior for all Tiles. This class also contains some useful utility classes needed for the tiles. - * `Icon`: Defines the basic interface for an icon as used by the tiles. - * `State`: Encapsulates the state of the Tile in order to communicate between the backend and the UI. -* [`QSTileImpl`](/packages/SystemUI/src/com/android/systemui/qs/tileimpl/QSTileImpl.java): Abstract implementation of `QSTile`, providing basic common behavior for all tiles. Also implements extensions for different types of `Icon`. All tiles currently defined in SystemUI subclass from this implementation. -* [`SystemUI/src/com/android/systemui/qs/tiles`](/packages/SystemUI/src/com/android/systemui/qs/tiles): Each tile from SystemUI is defined here by a class that extends `QSTileImpl`. These implementations connect to corresponding controllers. The controllers serve two purposes: - * track the state of the device and notify the tile when a change has occurred (for example, bluetooth connected to a device) - * accept actions from the tiles to modify the state of the phone (for example, enablind and disabling wifi). -* [`CustomTile`](/packages/SystemUI/src/com/android/systemui/qs/external/CustomTile.java): Equivalent to the tiles in the previous item, but used for 3rd party tiles. In depth information to be found in [`CustomTile`](#customtile) - -All the elements in SystemUI that work with tiles operate on `QSTile` or the interfaces defined in it. However, all the current implementations of tiles in SystemUI subclass from `QSTileImpl`, as it takes care of many common situations. Throughout this document, we will focus on `QSTileImpl` as examples of tiles. - -The interfaces in `QSTile` as well as other interfaces described in this document can be used to implement plugins to add additional tiles or different behavior. For more information, see [plugins.md](plugins.md) +* [`QSTile`](/packages/SystemUI/plugin/src/com/android/systemui/plugins/qs/QSTile.java): Interface + providing common behavior for all Tiles. This class also contains some useful utility classes + needed for the tiles. + * `Icon`: Defines the basic interface for an icon as used by the tiles. + * `State`: Encapsulates the state of the Tile in order to communicate between the backend and + the UI. +* [`QSTileImpl`](/packages/SystemUI/src/com/android/systemui/qs/tileimpl/QSTileImpl.java): Abstract + implementation of `QSTile`, providing basic common behavior for all tiles. Also implements + extensions for different types of `Icon`. All tiles currently defined in SystemUI subclass from + this implementation. +* [`SystemUI/src/com/android/systemui/qs/tiles`](/packages/SystemUI/src/com/android/systemui/qs/tiles): + Each tile from SystemUI is defined here by a class that extends `QSTileImpl`. These + implementations connect to corresponding controllers. The controllers serve two purposes: + * track the state of the device and notify the tile when a change has occurred (for example, + bluetooth connected to a device) + * accept actions from the tiles to modify the state of the phone (for example, enablind and + disabling wifi). +* [`CustomTile`](/packages/SystemUI/src/com/android/systemui/qs/external/CustomTile.java): + Equivalent to the tiles in the previous item, but used for 3rd party tiles. In depth information + to be found in [`CustomTile`](#customtile) + +All the elements in SystemUI that work with tiles operate on `QSTile` or the interfaces defined in +it. However, all the current implementations of tiles in SystemUI subclass from `QSTileImpl`, as it +takes care of many common situations. Throughout this document, we will focus on `QSTileImpl` as +examples of tiles. + +The interfaces in `QSTile` as well as other interfaces described in this document can be used to +implement plugins to add additional tiles or different behavior. For more information, +see [plugins.md](plugins.md) #### Tile State -Each tile has an associated `State` object that is used to communicate information to the corresponding view. The base class `State` has (among others) the following fields: +Each tile has an associated `State` object that is used to communicate information to the +corresponding view. The base class `State` has (among others) the following fields: * **`state`**: one of `Tile#STATE_UNAVAILABLE`, `Tile#STATE_ACTIVE`, `Tile#STATE_INACTIVE`. * **`icon`**; icon to display. It may depend on the current state. * **`label`**: usually the name of the tile. * **`secondaryLabel`**: text to display in a second line. Usually extra state information. * **`contentDescription`** -* **`expandedAccessibilityClassName`**: usually `Switch.class.getName()` for boolean Tiles. This will make screen readers read the current state of the tile as well as the new state when it's toggled. For this, the Tile has to use `BooleanState`. -* **`handlesLongClick`**: whether the Tile will handle long click. If it won't, it should be set to `false` so it will not be announced for accessibility. +* **`expandedAccessibilityClassName`**: usually `Switch.class.getName()` for boolean Tiles. This + will make screen readers read the current state of the tile as well as the new state when it's + toggled. For this, the Tile has to use `BooleanState`. +* **`handlesLongClick`**: whether the Tile will handle long click. If it won't, it should be set + to `false` so it will not be announced for accessibility. Setting any of these fields during `QSTileImpl#handleUpdateState` will update the UI after it. -Additionally. `BooleanState` has a `value` boolean field that usually would be set to `state == Tile#STATE_ACTIVE`. This is used by accessibility services along with `expandedAccessibilityClassName`. +Additionally. `BooleanState` has a `value` boolean field that usually would be set +to `state == Tile#STATE_ACTIVE`. This is used by accessibility services along +with `expandedAccessibilityClassName`. #### SystemUI tiles -Each tile defined in SystemUI extends `QSTileImpl`. This abstract class implements some common functions and leaves others to be implemented by each tile, in particular those that determine how to handle different events (refresh, click, etc.). +Each tile defined in SystemUI extends `QSTileImpl`. This abstract class implements some common +functions and leaves others to be implemented by each tile, in particular those that determine how +to handle different events (refresh, click, etc.). -For more information on how to implement a tile in SystemUI, see [Implementing a SystemUI tile](#implementing-a-systemui-tile). +For more information on how to implement a tile in SystemUI, +see [Implementing a SystemUI tile](#implementing-a-systemui-tile). ### Tile views -Each Tile has a couple of associated views for displaying it in QS and QQS. These views are updated after the backend updates the `State` using `QSTileImpl#handleUpdateState`. - -* **[`QSTileView`](/packages/SystemUI/plugin/src/com/android/systemui/plugins/qs/QSTileView.java)**: Abstract class that provides basic Tile functionality. These allows external [Factories](#qsfactory) to create Tiles. -* **[`QSTileViewImpl`](/packages/SystemUI/src/com/android/systemui/qs/tileimpl/QSTileViewImpl.java)**: Implementation of `QSTileView`. It takes care of the following: - * Holding the icon - * Background color and shape - * Ripple - * Click listening - * Labels +Each Tile has a couple of associated views for displaying it in QS and QQS. These views are updated +after the backend updates the `State` using `QSTileImpl#handleUpdateState`. + +* **[`QSTileView`](/packages/SystemUI/plugin/src/com/android/systemui/plugins/qs/QSTileView.java)**: + Abstract class that provides basic Tile functionality. These allows + external [Factories](#qsfactory) to create Tiles. +* **[`QSTileViewImpl`](/packages/SystemUI/src/com/android/systemui/qs/tileimpl/QSTileViewImpl.java)**: + Implementation of `QSTileView`. It takes care of the following: + * Holding the icon + * Background color and shape + * Ripple + * Click listening + * Labels * **[`QSIconView`](/packages/SystemUI/plugin/src/com/android/systemui/plugins/qs/QSIconView.java)** * **[`QSIconViewImpl`](/packages/SystemUI/src/com/android/systemui/qs/tileimpl/QSIconViewImpl.java)** #### QSIconView and QSIconViewImpl -`QSIconView` is an interface that define the basic actions that icons have to respond to. Its base implementation in SystemUI is `QSIconViewImpl` and it and its subclasses are used by all QS tiles. +`QSIconView` is an interface that define the basic actions that icons have to respond to. Its base +implementation in SystemUI is `QSIconViewImpl` and it and its subclasses are used by all QS tiles. -This `ViewGroup` is a container for the icon used in each tile. It has methods to apply the current `State` of the tile, modifying the icon (color and animations). Classes that inherit from this can add other details that are modified when the `State` changes. +This `ViewGroup` is a container for the icon used in each tile. It has methods to apply the +current `State` of the tile, modifying the icon (color and animations). Classes that inherit from +this can add other details that are modified when the `State` changes. -Each `QSTileImpl` can specify that they use a particular implementation of this class when creating an icon. +Each `QSTileImpl` can specify that they use a particular implementation of this class when creating +an icon. ### How are the backend and the views related? -The backend of the tiles (all the implementations of `QSTileImpl`) communicate with the views by using a `State`. The backend populates the state, and then the view maps the state to a visual representation. +The backend of the tiles (all the implementations of `QSTileImpl`) communicate with the views by +using a `State`. The backend populates the state, and then the view maps the state to a visual +representation. -It's important to notice that the state of the tile (internal or visual) is not directly modified by a user action like clicking on the tile. Instead, acting on a tile produces internal state changes on the device, and those trigger the changes on the tile state and UI. +It's important to notice that the state of the tile (internal or visual) is not directly modified by +a user action like clicking on the tile. Instead, acting on a tile produces internal state changes +on the device, and those trigger the changes on the tile state and UI. -When a container for tiles (`QuickQSPanel` or `QSPanel`) has to display tiles, they create a [`TileRecord`](/packages/SystemUI/src/com/android/systemui/qs/QSPanel.java). This associates the corresponding `QSTile` with its `QSTileView`, doing the following: +When a container for tiles (`QuickQSPanel` or `QSPanel`) has to display tiles, they create +a [`TileRecord`](/packages/SystemUI/src/com/android/systemui/qs/QSPanel.java). This associates the +corresponding `QSTile` with its `QSTileView`, doing the following: * Create the corresponding `QSTileView` to display in that container. -* Create a callback for `QSTile` to call when its state changes. Note that a single tile will normally have up to two callbacks: one for QS and one for QQS. +* Create a callback for `QSTile` to call when its state changes. Note that a single tile will + normally have up to two callbacks: one for QS and one for QQS. #### Life of a tile click -This is a brief run-down of what happens when a user clicks on a tile. Internal changes on the device (for example, changes from Settings) will trigger this process starting in step 3. Throughout this section, we assume that we are dealing with a `QSTileImpl`. +This is a brief run-down of what happens when a user clicks on a tile. Internal changes on the +device (for example, changes from Settings) will trigger this process starting in step 3. Throughout +this section, we assume that we are dealing with a `QSTileImpl`. 1. User clicks on tile. The following calls happen in sequence: - 1. `QSTileViewImpl#onClickListener`. - 2. `QSTile#click`. - 3. `QSTileImpl#handleClick`. This last call sets the new state for the device by using the associated controller. + 1. `QSTileViewImpl#onClickListener`. + 2. `QSTile#click`. + 3. `QSTileImpl#handleClick`. This last call sets the new state for the device by using the + associated controller. 2. State in the device changes. This is normally outside of SystemUI's control. -3. Controller receives a callback (or `Intent`) indicating the change in the device. The following calls happen: - 1. `QSTileImpl#refreshState`, maybe passing an object with necessary information regarding the new state. - 2. `QSTileImpl#handleRefreshState` -4. `QSTileImpl#handleUpdateState` is called to update the state with the new information. This information can be obtained both from the `Object` passed to `refreshState` as well as from the controller. -5. If the state has changed (in at least one element), `QSTileImpl#handleStateChanged` is called. This will trigger a call to all the associated `QSTile.Callback#onStateChanged`, passing the new `State`. -6. `QSTileView#onStateChanged` is called and this calls `QSTileView#handleStateChanged`. This method maps the state into the view: - * The tile colors change to match the new state. - * `QSIconView.setIcon` is called to apply the correct state to the icon and the correct icon to the view. - * The tile labels change to match the new state. +3. Controller receives a callback (or `Intent`) indicating the change in the device. The following + calls happen: + 1. `QSTileImpl#refreshState`, maybe passing an object with necessary information regarding the + new state. + 2. `QSTileImpl#handleRefreshState` +4. `QSTileImpl#handleUpdateState` is called to update the state with the new information. This + information can be obtained both from the `Object` passed to `refreshState` as well as from the + controller. +5. If the state has changed (in at least one element), `QSTileImpl#handleStateChanged` is called. + This will trigger a call to all the associated `QSTile.Callback#onStateChanged`, passing the + new `State`. +6. `QSTileView#onStateChanged` is called and this calls `QSTileView#handleStateChanged`. This method + maps the state into the view: + * The tile colors change to match the new state. + * `QSIconView.setIcon` is called to apply the correct state to the icon and the correct icon to + the view. + * The tile labels change to match the new state. ## Third party tiles (TileService) -A third party tile is any Quick Settings tile that is provided by an app (that's not SystemUI). This is implemented by developers subclassing [`TileService`](/core/java/android/service/quicksettings/TileService.java) and interacting with its API. +A third party tile is any Quick Settings tile that is provided by an app (that's not SystemUI). This +is implemented by developers +subclassing [`TileService`](/core/java/android/service/quicksettings/TileService.java) and +interacting with its API. ### API classes -The classes that define the public API are in [core/java/android/service/quicksettings](/core/java/android/service/quicksettings). +The classes that define the public API are +in [core/java/android/service/quicksettings](/core/java/android/service/quicksettings). #### Tile -Parcelable class used to communicate information about the state between the external app and SystemUI. The class supports the following fields: +Parcelable class used to communicate information about the state between the external app and +SystemUI. The class supports the following fields: * Label * Subtitle @@ -135,18 +204,25 @@ Parcelable class used to communicate information about the state between the ext * State (`Tile#STATE_ACTIVE`, `Tile#STATE_INACTIVE`, `Tile#STATE_UNAVAILABLE`) * Content description -Additionally, it provides a method to notify SystemUI that the information may have changed and the tile should be refreshed. +Additionally, it provides a method to notify SystemUI that the information may have changed and the +tile should be refreshed. #### TileService -This is an abstract Service that needs to be implemented by the developer. The Service manifest must have the permission `android.permission.BIND_QUICK_SETTINGS_TILE` and must respond to the action `android.service.quicksettings.action.QS_TILE`. This will allow SystemUI to find the available tiles and display them to the user. +This is an abstract Service that needs to be implemented by the developer. The Service manifest must +have the permission `android.permission.BIND_QUICK_SETTINGS_TILE` and must respond to the +action `android.service.quicksettings.action.QS_TILE`. This will allow SystemUI to find the +available tiles and display them to the user. -The implementer is responsible for creating the methods that will respond to the following calls from SystemUI: +The implementer is responsible for creating the methods that will respond to the following calls +from SystemUI: * **`onTileAdded`**: called when the tile is added to QS. * **`onTileRemoved`**: called when the tile is removed from QS. -* **`onStartListening`**: called when QS is opened and the tile is showing. This marks the start of the window when calling `getQSTile` is safe and will provide the correct object. -* **`onStopListening`**: called when QS is closed or the tile is no longer visible by the user. This marks the end of the window described in `onStartListening`. +* **`onStartListening`**: called when QS is opened and the tile is showing. This marks the start of + the window when calling `getQSTile` is safe and will provide the correct object. +* **`onStopListening`**: called when QS is closed or the tile is no longer visible by the user. This + marks the end of the window described in `onStartListening`. * **`onClick`**: called when the user clicks on the tile. Additionally, the following final methods are provided: @@ -155,7 +231,8 @@ Additionally, the following final methods are provided: public final Tile getQsTile() ``` - Provides the tile object that can be modified. This should only be called in the window between `onStartListening` and `onStopListening`. + Provides the tile object that can be modified. This should only be called in the window + between `onStartListening` and `onStopListening`. * ```java public final boolean isLocked() @@ -163,13 +240,15 @@ Additionally, the following final methods are provided: public final boolean isSecure() ``` - Provide information about the secure state of the device. This can be used by the tile to accept or reject actions on the tile. + Provide information about the secure state of the device. This can be used by the tile to accept + or reject actions on the tile. * ```java public final void unlockAndRun(Runnable) ``` - May prompt the user to unlock the device if locked. Once the device is unlocked, it runs the given `Runnable`. + May prompt the user to unlock the device if locked. Once the device is unlocked, it runs the + given `Runnable`. * ```java public final void showDialog(Dialog) @@ -179,162 +258,272 @@ Additionally, the following final methods are provided: ##### Binding -When the Service is bound, a callback Binder is provided by SystemUI for all the callbacks, as well as an identifier token (`Binder`). This token is used in the callbacks to identify this `TileService` and match it to the corresponding tile. +When the Service is bound, a callback Binder is provided by SystemUI for all the callbacks, as well +as an identifier token (`Binder`). This token is used in the callbacks to identify +this `TileService` and match it to the corresponding tile. -The tiles are bound once immediately on creation. After that, the tile is bound whenever it should start listening. When the panels are closed, and the tile is set to stop listening, it will be unbound after a delay of `TileServiceManager#UNBIND_DELAY` (30s), if it's not set to listening again. +The tiles are bound once immediately on creation. After that, the tile is bound whenever it should +start listening. When the panels are closed, and the tile is set to stop listening, it will be +unbound after a delay of `TileServiceManager#UNBIND_DELAY` (30s), if it's not set to listening +again. ##### Active tile -A `TileService` can be declared as an active tile by adding specific meta-data to its manifest (see [TileService#META_DATA_ACTIVE_TILE](https://developer.android.com/reference/android/service/quicksettings/TileService#META_DATA_ACTIVE_TILE)). In this case, it won't receive a call of `onStartListening` when QS is opened. Instead, the tile must request listening status by making a call to `TileService#requestListeningState` with its component name. This will initiate a window that will last until the tile is updated. +A `TileService` can be declared as an active tile by adding specific meta-data to its manifest ( +see [TileService#META_DATA_ACTIVE_TILE](https://developer.android.com/reference/android/service/quicksettings/TileService#META_DATA_ACTIVE_TILE)). +In this case, it won't receive a call of `onStartListening` when QS is opened. Instead, the tile +must request listening status by making a call to `TileService#requestListeningState` with its +component name. This will initiate a window that will last until the tile is updated. The tile will also be granted listening status if it's clicked by the user. ### SystemUI classes -The following sections describe the classes that live in SystemUI to support third party tiles. These classes live in [SystemUI/src/com/android/systemui/qs/external](/packages/SystemUI/src/com/android/systemui/qs/external/) +The following sections describe the classes that live in SystemUI to support third party tiles. +These classes live +in [SystemUI/src/com/android/systemui/qs/external](/packages/SystemUI/src/com/android/systemui/qs/external/) #### CustomTile -This class is an subclass of `QSTileImpl` to be used with third party tiles. It provides similar behavior to SystemUI tiles as well as handling exclusive behavior like lifting default icons and labels from the application manifest. +This class is an subclass of `QSTileImpl` to be used with third party tiles. It provides similar +behavior to SystemUI tiles as well as handling exclusive behavior like lifting default icons and +labels from the application manifest. #### TileServices -This class is the central controller for all tile services that are currently in Quick Settings as well as provides the support for starting new ones. It is also an implementation of the `Binder` that receives all calls from current `TileService` components and dispatches them to SystemUI or the corresponding `CustomTile`. +This class is the central controller for all tile services that are currently in Quick Settings as +well as provides the support for starting new ones. It is also an implementation of the `Binder` +that receives all calls from current `TileService` components and dispatches them to SystemUI or the +corresponding `CustomTile`. -Whenever a binder call is made to this class, it matches the corresponding token assigned to the `TileService` with the `ComponentName` and verifies that the call comes from the right UID to prevent spoofing. +Whenever a binder call is made to this class, it matches the corresponding token assigned to +the `TileService` with the `ComponentName` and verifies that the call comes from the right UID to +prevent spoofing. -As this class is the only one that's aware of every `TileService` that's currently bound, it is also in charge of requesting some to be unbound whenever there is a low memory situation. +As this class is the only one that's aware of every `TileService` that's currently bound, it is also +in charge of requesting some to be unbound whenever there is a low memory situation. #### TileLifecycleManager -This class is in charge of binding and unbinding to a particular `TileService` when necessary, as well as sending the corresponding binder calls. It does not decide whether the tile should be bound or unbound, unless it's requested to process a message. It additionally handles errors in the `Binder` as well as changes in the corresponding component (like updates and enable/disable). +This class is in charge of binding and unbinding to a particular `TileService` when necessary, as +well as sending the corresponding binder calls. It does not decide whether the tile should be bound +or unbound, unless it's requested to process a message. It additionally handles errors in +the `Binder` as well as changes in the corresponding component (like updates and enable/disable). -The class has a queue that stores requests while the service is not bound, to be processed as soon as the service is bound. +The class has a queue that stores requests while the service is not bound, to be processed as soon +as the service is bound. -Each `TileService` gets assigned an exclusive `TileLifecycleManager` when its corresponding tile is added to the set of current ones and kept as long as the tile is available to the user. +Each `TileService` gets assigned an exclusive `TileLifecycleManager` when its corresponding tile is +added to the set of current ones and kept as long as the tile is available to the user. #### TileServiceManager -Each instance of this class is an intermediary between the `TileServices` controller and a `TileLifecycleManager` corresponding to a particular `TileService`. +Each instance of this class is an intermediary between the `TileServices` controller and +a `TileLifecycleManager` corresponding to a particular `TileService`. This class handles management of the service, including: * Deciding when to bind and unbind, requesting it to the `TileLifecycleManager`. * Relaying messages to the `TileService` through the `TileLifecycleManager`. * Determining the service's bind priority (to deal with OOM situations). -* Detecting when the package/component has been removed in order to remove the tile and references to it. +* Detecting when the package/component has been removed in order to remove the tile and references + to it. ## How are tiles created/instantiated? -This section describes the classes that aid in the creation of each tile as well as the complete lifecycle of a tile. First we describe two important interfaces/classes. +This section describes the classes that aid in the creation of each tile as well as the complete +lifecycle of a tile. The current system makes use of flows to propagate information downstream. + +First we describe three important interfaces/classes. + +### TileSpecRepository (and UserTileSpecRepository) -### QSTileHost +These classes keep track of the current tiles for each user, as a list of Tile specs. While the +device is running, this is the source of truth of tiles for that user. -This class keeps track of the tiles selected by the current user (backed in the Secure Setting `sysui_qs_tiles`) to be displayed in Quick Settings. Whenever the value of this setting changes (or on device start), the whole list of tiles is read. This is compared with the current tiles, destroying unnecessary ones and creating needed ones. +The list is persisted to `Settings.Secure` every time it changes so it will be available upon +restart or backup. In particular, any changes in the secure setting while this repository is +tracking the list of tiles will be reverted. -It additionally provides a point of communication between the tiles and the StatusBar, for example to open it and collapse it. And a way for the StatusBar service to add tiles (only works for `CustomTile`). +The class provides a `Flow<List<TileSpec>>` for each user that can be collected to keep track of the +current list of tiles. #### Tile specs -Each single tile is identified by a spec, which is a unique String for that type of tile. The current tiles are stored as a Setting string of comma separated values of these specs. Additionally, the default tiles (that appear on a fresh system) configuration value is stored likewise. +Each single tile is identified by a spec, which is a unique String for that type of tile. The +current tiles are stored as a Setting string of comma separated values of these specs. Additionally, +the default tiles (that appear on a fresh system) configuration value is stored likewise. + +SystemUI tile specs are usually a single simple word identifying the tile (like `wifi` +or `battery`). Custom tile specs are always a string of the form `custom(...)` where the ellipsis is +a flattened String representing the `ComponentName` for the corresponding `TileService`. + +We represent these internally using a `TileSpec` class that can distinguish between platform tiles +and custom tiles. + +### CurrentTilesInteractor + +This class consumes the lists of specs provided by `TileSpecRepository` and produces a +`Flow<List<Pair<TileSpec, QSTile>>>` with the current tiles for the current user. + +Internally, whenever the list of tiles changes, the following operation is performed: +* Properly dispose of tiles that are no longer in the current list. +* Properly dispose of tiles that are no longer available. +* If the user has changed, relay the new user to the platform tiles and destroy any custom tiles. +* Create new tiles as needed, disposing those that are not available or when the corresponding + service does not exist. +* Reorder the tiles. -SystemUI tile specs are usually a single simple word identifying the tile (like `wifi` or `battery`). Custom tile specs are always a string of the form `custom(...)` where the ellipsis is a flattened String representing the `ComponentName` for the corresponding `TileService`. +Also, when this is completed, we pass the final list back to the repository so it matches the +correct list of tiles. ### QSFactory -This interface provides a way of creating tiles and views from a spec. It can be used in plugins to provide different definitions for tiles. +This interface provides a way of creating tiles and views from a spec. It can be used in plugins to +provide different definitions for tiles. -In SystemUI there is only one implementation of this factory and that is the default factory (`QSFactoryImpl`) in `QSTileHost`. +In SystemUI there is only one implementation of this factory and that is the default +factory (`QSFactoryImpl`) in `CurrentTilesInteractorImpl`. #### QSFactoryImpl -This class implements two methods as specified in the `QSFactory` interface: +This class implements the following method as specified in the `QSFactory` interface: * ```java public QSTile createTile(String) ``` - Creates a tile (backend) from a given spec. The factory has providers for all of the SystemUI tiles, returning one when the correct spec is used. + Creates a tile (backend) from a given spec. The factory has a map with providers for all of the + SystemUI tiles, returning one when the correct spec is used. - If the spec is not recognized but it has the `custom(` prefix, the factory tries to create a `CustomTile` for the component in the spec. This could fail (the component is not a valid `TileService` or is not enabled) and will be detected later when the tile is polled to determine if it's available. + If the spec is not recognized but it has the `custom(` prefix, the factory tries to create + a `CustomTile` for the component in the spec. -* ```java - public QSTileView createTileView(QSTile, boolean) - ``` - - Creates a view for the corresponding `QSTile`. The second parameter determines if the view that is created should be a collapsed one (for using in QQS) or not (for using in QS). + As part of filtering not valid tiles, custom tiles that don't have a corresponding valid service + component are never instantiated. ### Lifecycle of a Tile -We describe first the parts of the lifecycle that are common to SystemUI tiles and third party tiles. Following that, there will be a section with the steps that are exclusive to third party tiles. - -1. The tile is added through the QS customizer by the user. This will immediately save the new list of tile specs to the Secure Setting `sysui_qs_tiles`. This step could also happend if `StatusBar` adds tiles (either through adb, or through its service interface as with the `DevelopmentTiles`). -2. This triggers a "setting changed" that is caught by `QSTileHost`. This class processes the new value of the setting and finds out that there is a new spec in the list. Alternatively, when the device is booted, all tiles in the setting are considered as "new". -3. `QSTileHost` calls all the available `QSFactory` classes that it has registered in order to find the first one that will be able to create a tile with that spec. Assume that `QSFactoryImpl` managed to create the tile, which is some implementation of `QSTile` (either a SystemUI subclass of `QSTileImpl` or a `CustomTile`). If the tile is available, it's stored in a map and things proceed forward. -4. `QSTileHost` calls its callbacks indicating that the tiles have changed. In particular, `QSPanel` and `QuickQSPanel` receive this call with the full list of tiles. We will focus on these two classes. -5. For each tile in this list, a `QSTileView` is created (collapsed or expanded) and attached to a `TileRecord` containing the tile backend and the view. Additionally: - * a callback is attached to the tile to communicate between the backend and the view or the panel. +We describe first the parts of the lifecycle that are common to SystemUI tiles and third party +tiles. Following that, there will be a section with the steps that are exclusive to third party +tiles. + +1. The tile is added through the QS customizer by the user. This will send the new list of tiles to + `TileSpecRepository` which will update its internal state and also store the new value in the + secure setting `sysui_qs_tiles`. This step could also happen if `StatusBar` adds tiles (either + through adb, or through its service interface as with the `DevelopmentTiles`). +2. This updates the flow that `CurrentTilesInteractor` is collecting from, triggering the process + described above. +3. `CurrentTilesInteractor` calls the available `QSFactory` classes in order to find one that will + be able to create a tile with that spec. Assuming that `QSFactoryImpl` managed to create the + tile, which is some implementation of `QSTile` (either a SystemUI subclass + of `QSTileImpl` or a `CustomTile`) it will be added to the current list. + If the tile is available, it's stored in a map and things proceed forward. +4. `CurrentTilesInteractor` updates its flow and classes collecting from it will be notified of the + change. In particular, `QSPanel` and `QuickQSPanel` receive this call with the full list of + tiles. We will focus on these two classes. +5. For each tile in this list, a `QSTileView` is created (collapsed or expanded) and attached to + a `TileRecord` containing the tile backend and the view. Additionally: + * a callback is attached to the tile to communicate between the backend and the view or the + panel. * the click listeners in the tile are attached to those of the view. 6. The tile view is added to the corresponding layout. -When the tile is removed from the list of current tiles, all these classes are properly disposed including removing the callbacks and making sure that the backends remove themselves from the controllers they were listening to. +When the tile is removed from the list of current tiles, all these classes are properly disposed +including removing the callbacks and making sure that the backends remove themselves from the +controllers they were listening to. #### Lifecycle of a CustomTile -In step 3 of the previous process, when a `CustomTile` is created, additional steps are taken to ensure the proper binding to the service as described in [Third party tiles (TileService)](#third-party-tiles-tileservice). +In step 3 of the previous process, when a `CustomTile` is created, additional steps are taken to +ensure the proper binding to the service as described +in [Third party tiles (TileService)](#third-party-tiles-tileservice). -1. The `CustomTile` obtains the `TileServices` class from the `QSTileHost` and request the creation of a `TileServiceManager` with its token. As the spec for the `CustomTile` contains the `ComponentName` of the associated service, this can be used to bind to it. -2. The `TileServiceManager` creates its own `TileLifecycleManager` to take care of binding to the service. -3. `TileServices` creates maps between the token, the `CustomTile`, the `TileServiceManager`, the token and the `ComponentName`. +1. The `CustomTile` obtains the `TileServices` class from the `QSTileHost` and request the creation + of a `TileServiceManager` with its token. As the spec for the `CustomTile` contains + the `ComponentName` of the associated service, this can be used to bind to it. +2. The `TileServiceManager` creates its own `TileLifecycleManager` to take care of binding to the + service. +3. `TileServices` creates maps between the token, the `CustomTile`, the `TileServiceManager`, the + token and the `ComponentName`. ## Implementing a tile -This section describes necessary and recommended steps when implementing a Quick Settings tile. Some of them are optional and depend on the requirements of the tile. +This section describes necessary and recommended steps when implementing a Quick Settings tile. Some +of them are optional and depend on the requirements of the tile. ### Implementing a SystemUI tile -1. Create a class (preferably in [`SystemUI/src/com/android/systemui/qs/tiles`](/packages/SystemUI/src/com/android/systemui/qs/tiles)) implementing `QSTileImpl` with a particular type of `State` as a parameter. -2. Create an injectable constructor taking a `QSHost` and whichever classes are needed for the tile's operation. Normally this would be other SystemUI controllers. -3. Implement the methods described in [Abstract methods in QSTileImpl](#abstract-methods-in-qstileimpl). Look at other tiles for help. Some considerations to have in mind: - * If the tile will not support long click (like the `FlashlightTile`), set `state.handlesLongClick` to `false` (maybe in `newTileState`). +1. Create a class (preferably + in [`SystemUI/src/com/android/systemui/qs/tiles`](/packages/SystemUI/src/com/android/systemui/qs/tiles)) + implementing `QSTileImpl` with a particular type of `State` as a parameter. +2. Create an injectable constructor taking a `QSHost` and whichever classes are needed for the + tile's operation. Normally this would be other SystemUI controllers. +3. Implement the methods described + in [Abstract methods in QSTileImpl](#abstract-methods-in-qstileimpl). Look at other tiles for + help. Some considerations to have in mind: + * If the tile will not support long click (like the `FlashlightTile`), + set `state.handlesLongClick` to `false` (maybe in `newTileState`). * Changes to the tile state (either from controllers or from clicks) should call `refreshState`. - * Use only `handleUpdateState` to modify the values of the state to the new ones. This can be done by polling controllers or through the `arg` parameter. - * If the controller is not a `CallbackController`, respond to `handleSetListening` by attaching/dettaching from controllers. + * Use only `handleUpdateState` to modify the values of the state to the new ones. This can be + done by polling controllers or through the `arg` parameter. + * If the controller is not a `CallbackController`, respond to `handleSetListening` by + attaching/dettaching from controllers. * Implement `isAvailable` so the tile will not be created when it's not necessary. -4. Either create a new feature module or find an existing related feature module and add the following binding method: +4. Either create a new feature module or find an existing related feature module and add the + following binding method: * ```kotlin @Binds @IntoMap @StringKey(YourNewTile.TILE_SPEC) // A unique word that will map to YourNewTile fun bindYourNewTile(yourNewTile: YourNewTile): QSTileImpl<*> ``` -5. In [SystemUI/res/values/config.xml](/packages/SystemUI/res/values/config.xml), modify `quick_settings_tiles_stock` and add the spec defined in the previous step. If necessary, add it also to `quick_settings_tiles_default`. The first one contains a list of all the tiles that SystemUI knows how to create (to show to the user in the customization screen). The second one contains only the default tiles that the user will experience on a fresh boot or after they reset their tiles. -6. In [SystemUI/res/values/tiles_states_strings.xml](/packages/SystemUI/res/values/tiles_states_strings.xml), add a new array for your tile. The name has to be `tile_states_<spec>`. Use a good description to help the translators. -7. In [`SystemUI/src/com/android/systemui/qs/tileimpl/QSTileViewImpl.kt`](/packages/SystemUI/src/com/android/systemui/qs/tileimpl/QSTileViewImpl.kt), add a new element to the map in `SubtitleArrayMapping` corresponding to the resource created in the previous step. +5. In [SystemUI/res/values/config.xml](/packages/SystemUI/res/values/config.xml), + modify `quick_settings_tiles_stock` and add the spec defined in the previous step. If necessary, + add it also to `quick_settings_tiles_default`. The first one contains a list of all the tiles + that SystemUI knows how to create (to show to the user in the customization screen). The second + one contains only the default tiles that the user will experience on a fresh boot or after they + reset their tiles. +6. In [SystemUI/res/values/tiles_states_strings.xml](/packages/SystemUI/res/values/tiles_states_strings.xml), +add a new array for your tile. The name has to be `tile_states_<spec>`. Use a good description to +help the translators. +7. In [`SystemUI/src/com/android/systemui/qs/tileimpl/QSTileViewImpl.kt`](/packages/SystemUI/src/com/android/systemui/qs/tileimpl/QSTileViewImpl.kt), +add a new element to the map in `SubtitleArrayMapping` corresponding to the resource created in the +previous step. #### Abstract methods in QSTileImpl -Following are methods that need to be implemented when creating a new SystemUI tile. `TState` is a type variable of type `State`. +Following are methods that need to be implemented when creating a new SystemUI tile. `TState` is a +type variable of type `State`. * ```java public TState newTileState() ``` - Creates a new `State` for this tile to use. Each time the state changes, it is copied into a new one and the corresponding fields are modified. The framework provides `State`, `BooleanState` (has an on and off state and provides this as a content description), `SignalState` (`BooleanState` with `activityIn` and `activityOut`), and `SlashState` (can be rotated or slashed through). + Creates a new `State` for this tile to use. Each time the state changes, it is copied into a new + one and the corresponding fields are modified. The framework provides `State`, `BooleanState` (has + an on and off state and provides this as a content description), `SignalState` (`BooleanState` + with `activityIn` and `activityOut`), and `SlashState` (can be rotated or slashed through). - If a tile has special behavior (no long click, no ripple), it can be set in its state here. + If a tile has special behavior (no long click, no ripple), it can be set in its state here. * ```java public void handleSetListening(boolean) ``` - Initiates or terminates listening behavior, like listening to Callbacks from controllers. This gets triggered when QS is expanded or collapsed (i.e., when the tile is visible and actionable). Most tiles (like `WifiTile`) do not implement this. Instead, Tiles are LifecycleOwner and are marked as `RESUMED` or `DESTROYED` in `QSTileImpl#handleListening` and handled as part of the lifecycle of [CallbackController](/packages/SystemUI/src/com/android/systemui/statusbar/policy/CallbackController.java) + Initiates or terminates listening behavior, like listening to Callbacks from controllers. This + gets triggered when QS is expanded or collapsed (i.e., when the tile is visible and actionable). + Most tiles (like `WifiTile`) do not implement this. Instead, Tiles are LifecycleOwner and are + marked as `RESUMED` or `DESTROYED` in `QSTileImpl#handleListening` and handled as part of the + lifecycle + of [CallbackController](/packages/SystemUI/src/com/android/systemui/statusbar/policy/CallbackController.java) * ```java public QSIconView createTileView(Context) ``` - Allows a Tile to use a `QSIconView` different from `QSIconViewImpl` (see [Tile views](#tile-views)), which is the default defined in `QSTileImpl` + Allows a Tile to use a `QSIconView` different from `QSIconViewImpl` ( + see [Tile views](#tile-views)), which is the default defined in `QSTileImpl` * ```java public Intent getLongClickIntent() @@ -350,36 +539,137 @@ Following are methods that need to be implemented when creating a new SystemUI t protected void handleLongClick() ``` - Handles what to do when the Tile is clicked. In general, a Tile will make calls to its controller here and maybe update its state immediately (by calling `QSTileImpl#refreshState`). A Tile can also decide to ignore the click here, if it's `Tile#STATE_UNAVAILABLE`. + Handles what to do when the Tile is clicked. In general, a Tile will make calls to its controller + here and maybe update its state immediately (by calling `QSTileImpl#refreshState`). A Tile can + also decide to ignore the click here, if it's `Tile#STATE_UNAVAILABLE`. - By default long click redirects to click and long click launches the intent defined in `getLongClickIntent`. + By default long click redirects to click and long click launches the intent defined + in `getLongClickIntent`. * ```java protected void handleUpdateState(TState, Object) ``` - Updates the `State` of the Tile based on the state of the device as provided by the respective controller. It will be called every time the Tile becomes visible, is interacted with or `QSTileImpl#refreshState` is called. After this is done, the updated state will be reflected in the UI. + Updates the `State` of the Tile based on the state of the device as provided by the respective + controller. It will be called every time the Tile becomes visible, is interacted with + or `QSTileImpl#refreshState` is called. After this is done, the updated state will be reflected in + the UI. * ```java @Deprecated public int getMetricsCategory() ``` - ~~Identifier for this Tile, as defined in [proto/src/metrics_constants/metrics_constants.proto](/proto/src/metrics_constants/metrics_constants.proto). This is used to log events related to this Tile.~~ + ~~Identifier for this Tile, as defined + in [proto/src/metrics_constants/metrics_constants.proto](/proto/src/metrics_constants/metrics_constants.proto). + This is used to log events related to this Tile.~~ This is now deprecated in favor of `UiEvent` that use the tile spec. * ```java public boolean isAvailable() ``` - Determines if a Tile is available to be used (for example, disable `WifiTile` in devices with no Wifi support). If this is false, the Tile will be destroyed upon creation. + Determines if a Tile is available to be used (for example, disable `WifiTile` in devices with no + Wifi support). If this is false, the Tile will be destroyed upon creation. * ```java public CharSequence getTileLabel() ``` - Provides a default label for this Tile. Used by the QS Panel customizer to show a name next to each available tile. + Provides a default label for this Tile. Used by the QS Panel customizer to show a name next to + each available tile. ### Implementing a third party tile -For information about this, use the Android Developer documentation for [TileService](https://developer.android.com/reference/android/service/quicksettings/TileService).
\ No newline at end of file +For information about this, use the Android Developer documentation +for [TileService](https://developer.android.com/reference/android/service/quicksettings/TileService). + +## AutoAddable tiles + +AutoAddable tiles are tiles that are not part of the default set, but will be automatically added +for the user, when the user enabled a feature for the first time. For example: +* When the user creates a work profile, the work profile tile is automatically added. +* When the user sets up a hotspot for the first time, the hotspot tile is automatically added. + +In order to declare a tile as auto-addable, there are two ways: + +* If the tile can be tied to a secure setting such that the tile should be auto added after that + setting has changed to a non-zero value for the first time, a new line can be added to the + string-array `config_quickSettingsAutoAdd` in [config.xml](/packages/SystemUI/res/values/config.xml). +* If more specific behavior is needed, a new + [AutoAddable](/packages/SystemUI/src/com/android/systemui/qs/pipeline/domain/model/AutoAddable.kt) + can be added in the `autoaddables` package. This can have custom logic that produces a flow of + signals on when the tile should be auto-added (or auto-removed in special cases). + + *Special case: If the data comes from a `CallbackController`, a special + `CallbackControllerAutoAddable` can be created instead that handles a lot of the common code.* + +### AutoAddRepository (and UserAutoAddRepository) + +These classes keep track of tiles that have been auto-added for each user, as a list of Tile specs. +While the device is running, this is the source of truth of already auto-added tiles for that user. + +The list is persisted to `Settings.Secure` every time it changes so it will be available upon +restart or backup. In particular, any changes in the secure setting while this repository is +tracking the list of tiles will be reverted. + +The class provides a `Flow<Set<TileSpec>>` for each user that can be collected to keep track of the +set of already auto added tiles. + +### AutoAddInteractor + +This class collects all registered (through Dagger) `AutoAddables` and merges all the signals for +the current user. It will add/remove tiles as necessary and mark them as such in the +`AutoAddRepository`. + +## Backup and restore + +It's important to point out that B&R of Quick Settings tiles only concerns itself with restoring, +for each user, the list of current tiles and their order. The state of the tiles (or other things +that can be accessed from them like list of WiFi networks) is the concern of each feature team and +out of the scope of Quick Settings. + +In order to provide better support to restoring Quick Settings tiles and prevent overwritten or +inconsistent data, the system has the following steps: + +1. When `Settings.Secure.SYSUI_QS_TILES` and `Settings.Secure.QS_AUTO_TILES` are restored, a + broadcast is sent to SystemUI. This is handled by + [SettingsHelper](/packages/SettingsProvider/src/com/android/providers/settings/SettingsHelper.java). + The broadcasts are received by [QSSettingsRestoredRepository](/packages/SystemUI/src/com/android/systemui/qs/pipeline/data/repository/QSSettingsRestoredRepository.kt) + and grouped by user into a data object. As described above, the change performed by the restore in + settings is overriden by the corresponding repositories. +2. Once both settings have been restored, the data is reconciled with the current data, to account + for tiles that may have been auto-added between the start of SystemUI and the time the restore + happened. The guiding principles for the reconciliation are as follows: + * We assume that the user expects the restored tiles to be the ones to be present after restore, + so those are taken as the basis for the reconciliation. + * Any tile that was auto-added before the restore, but had not been auto-added in the source + device, is auto-added again (preferably in a similar position). + * Any tile that was auto-added before the restore, and it was also auto-added in the source + device, but not present in the restored tiles, is considered removed by the user and therefore + not restored. + * Every tile that was marked as auto-added (all tiles in source + tiles added before restore) + are set as auto-added. + +## Logs for debugging + +The following log buffers are used for Quick Settings debugging purposes: + +### QSLog + +Logs events in the individual tiles, like listening state, clicks, and status updates. + +### QSTileListLog + +Logs changes in the current set of tiles for each user, including when tiles are created or +destroyed, and the reason for that. It also logs what operation caused the tiles to change +(add, remove, change, restore). + +### QSAutoAddLog + +Logs operations of auto-add (or auto-remove) of tiles. + +### QSRestoreLog + +Logs the data obtained after a successful restore of the settings. This is the data that will be +used for reconciliation.
\ No newline at end of file diff --git a/packages/SystemUI/multivalentTests/src/com/android/systemui/biometrics/AuthControllerTest.java b/packages/SystemUI/multivalentTests/src/com/android/systemui/biometrics/AuthControllerTest.java index 602f3dc29491..da97a1283261 100644 --- a/packages/SystemUI/multivalentTests/src/com/android/systemui/biometrics/AuthControllerTest.java +++ b/packages/SystemUI/multivalentTests/src/com/android/systemui/biometrics/AuthControllerTest.java @@ -1041,8 +1041,9 @@ public class AuthControllerTest extends SysuiTestCase { mExecution, mCommandQueue, mActivityTaskManager, mWindowManager, mFingerprintManager, mFaceManager, () -> mUdfpsController, () -> mSideFpsController, mDisplayManager, mWakefulnessLifecycle, - mPanelInteractionDetector, mUserManager, mLockPatternUtils, mUdfpsLogger, - mLogContextInteractor, () -> mBiometricPromptCredentialInteractor, + mPanelInteractionDetector, mUserManager, mLockPatternUtils, () -> mUdfpsLogger, + () -> mLogContextInteractor, + () -> mBiometricPromptCredentialInteractor, () -> mPromptSelectionInteractor, () -> mCredentialViewModel, () -> mPromptViewModel, mInteractionJankMonitor, mHandler, mBackgroundExecutor, mUdfpsUtils, mVibratorHelper); diff --git a/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractorTest.kt b/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractorTest.kt index 706f94e412ac..11939c1120d9 100644 --- a/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractorTest.kt +++ b/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractorTest.kt @@ -23,6 +23,7 @@ import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase import com.android.systemui.bouncer.data.repository.FakeKeyguardBouncerRepository import com.android.systemui.common.ui.data.repository.FakeConfigurationRepository +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor import com.android.systemui.coroutines.collectLastValue import com.android.systemui.keyguard.data.repository.FakeCommandQueue import com.android.systemui.keyguard.shared.model.CameraLaunchSourceModel @@ -53,7 +54,6 @@ class KeyguardInteractorTest : SysuiTestCase() { private val sceneInteractor = testUtils.sceneInteractor() private val commandQueue = FakeCommandQueue() private val bouncerRepository = FakeKeyguardBouncerRepository() - private val configurationRepository = FakeConfigurationRepository() private val shadeRepository = FakeShadeRepository() private val transitionState: MutableStateFlow<ObservableTransitionState> = MutableStateFlow(ObservableTransitionState.Idle(SceneKey.Gone)) @@ -65,7 +65,7 @@ class KeyguardInteractorTest : SysuiTestCase() { powerInteractor = PowerInteractorFactory.create().powerInteractor, sceneContainerFlags = testUtils.sceneContainerFlags, bouncerRepository = bouncerRepository, - configurationRepository = configurationRepository, + configurationInteractor = ConfigurationInteractor(FakeConfigurationRepository()), shadeRepository = shadeRepository, sceneInteractorProvider = { sceneInteractor }, ) diff --git a/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/DreamingToLockscreenTransitionViewModelTest.kt b/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/DreamingToLockscreenTransitionViewModelTest.kt index fd125e099f1b..53bca483f73f 100644 --- a/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/DreamingToLockscreenTransitionViewModelTest.kt +++ b/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/DreamingToLockscreenTransitionViewModelTest.kt @@ -19,14 +19,11 @@ package com.android.systemui.keyguard.ui.viewmodel import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase -import com.android.systemui.biometrics.data.repository.FakeFingerprintPropertyRepository +import com.android.systemui.biometrics.data.repository.fingerprintPropertyRepository import com.android.systemui.biometrics.shared.model.FingerprintSensorType import com.android.systemui.biometrics.shared.model.SensorStrength -import com.android.systemui.deviceentry.domain.interactor.DeviceEntryUdfpsInteractor -import com.android.systemui.keyguard.data.repository.FakeBiometricSettingsRepository -import com.android.systemui.keyguard.data.repository.FakeDeviceEntryFingerprintAuthRepository -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractorFactory +import com.android.systemui.coroutines.collectValues +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState.AOD import com.android.systemui.keyguard.shared.model.KeyguardState.DOZING import com.android.systemui.keyguard.shared.model.KeyguardState.DREAMING @@ -38,16 +35,12 @@ import com.android.systemui.keyguard.shared.model.TransitionState.FINISHED import com.android.systemui.keyguard.shared.model.TransitionState.RUNNING import com.android.systemui.keyguard.shared.model.TransitionState.STARTED import com.android.systemui.keyguard.shared.model.TransitionStep -import com.android.systemui.util.mockito.mock +import com.android.systemui.kosmos.testScope +import com.android.systemui.testKosmos import com.google.common.collect.Range import com.google.common.truth.Truth.assertThat import kotlinx.coroutines.ExperimentalCoroutinesApi -import kotlinx.coroutines.flow.launchIn -import kotlinx.coroutines.flow.onEach -import kotlinx.coroutines.test.TestScope -import kotlinx.coroutines.test.UnconfinedTestDispatcher import kotlinx.coroutines.test.runTest -import org.junit.Before import org.junit.Test import org.junit.runner.RunWith @@ -55,223 +48,201 @@ import org.junit.runner.RunWith @SmallTest @RunWith(AndroidJUnit4::class) class DreamingToLockscreenTransitionViewModelTest : SysuiTestCase() { - private lateinit var underTest: DreamingToLockscreenTransitionViewModel - private lateinit var repository: FakeKeyguardTransitionRepository - private lateinit var fingerprintPropertyRepository: FakeFingerprintPropertyRepository - - @Before - fun setUp() { - repository = FakeKeyguardTransitionRepository() - fingerprintPropertyRepository = FakeFingerprintPropertyRepository() - val interactor = - KeyguardTransitionInteractorFactory.create( - scope = TestScope().backgroundScope, - repository = repository, - ) - .keyguardTransitionInteractor - underTest = - DreamingToLockscreenTransitionViewModel( - interactor, - mock(), - DeviceEntryUdfpsInteractor( - fingerprintPropertyRepository = fingerprintPropertyRepository, - fingerprintAuthRepository = FakeDeviceEntryFingerprintAuthRepository(), - biometricSettingsRepository = FakeBiometricSettingsRepository(), - ), - ) - } + private val kosmos = testKosmos() + private val testScope = kosmos.testScope + private val keyguardTransitionRepository = kosmos.fakeKeyguardTransitionRepository + private val fingerprintPropertyRepository = kosmos.fingerprintPropertyRepository + private val underTest = kosmos.dreamingToLockscreenTransitionViewModel @Test fun dreamOverlayTranslationY() = - runTest(UnconfinedTestDispatcher()) { - val values = mutableListOf<Float>() - + testScope.runTest { val pixels = 100 - val job = - underTest.dreamOverlayTranslationY(pixels).onEach { values.add(it) }.launchIn(this) - - repository.sendTransitionStep(step(0f, STARTED)) - repository.sendTransitionStep(step(0f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.5f)) - repository.sendTransitionStep(step(0.6f)) - repository.sendTransitionStep(step(0.8f)) - repository.sendTransitionStep(step(1f)) + val values by collectValues(underTest.dreamOverlayTranslationY(pixels)) + + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0f), + step(0.3f), + step(0.5f), + step(0.6f), + step(0.8f), + step(1f), + ), + testScope, + ) assertThat(values.size).isEqualTo(7) values.forEach { assertThat(it).isIn(Range.closed(0f, 100f)) } - - job.cancel() } @Test fun dreamOverlayFadeOut() = - runTest(UnconfinedTestDispatcher()) { - val values = mutableListOf<Float>() - - val job = underTest.dreamOverlayAlpha.onEach { values.add(it) }.launchIn(this) - - // Should start running here... - repository.sendTransitionStep(step(0f, STARTED)) - repository.sendTransitionStep(step(0f)) - repository.sendTransitionStep(step(0.1f)) - repository.sendTransitionStep(step(0.5f)) - // ...up to here - repository.sendTransitionStep(step(1f)) + testScope.runTest { + val values by collectValues(underTest.dreamOverlayAlpha) + + keyguardTransitionRepository.sendTransitionSteps( + listOf( + // Should start running here... + step(0f, TransitionState.STARTED), + step(0f), + step(0.1f), + step(0.5f), + // ...up to here + step(1f), + ), + testScope, + ) - // Only two values should be present, since the dream overlay runs for a small fraction - // of the overall animation time assertThat(values.size).isEqualTo(4) values.forEach { assertThat(it).isIn(Range.closed(0f, 1f)) } - - job.cancel() } @Test fun lockscreenFadeIn() = - runTest(UnconfinedTestDispatcher()) { - val values = mutableListOf<Float>() - - val job = underTest.lockscreenAlpha.onEach { values.add(it) }.launchIn(this) - - repository.sendTransitionStep(step(0f, STARTED)) - repository.sendTransitionStep(step(0f)) - repository.sendTransitionStep(step(0.1f)) - repository.sendTransitionStep(step(0.2f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(1f)) + testScope.runTest { + val values by collectValues(underTest.lockscreenAlpha) + + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0f), + step(0.1f), + step(0.2f), + step(0.3f), + step(1f), + ), + testScope, + ) assertThat(values.size).isEqualTo(4) values.forEach { assertThat(it).isIn(Range.closed(0f, 1f)) } - - job.cancel() } @Test fun deviceEntryParentViewFadeIn() = - runTest(UnconfinedTestDispatcher()) { - val values = mutableListOf<Float>() - - val job = underTest.deviceEntryParentViewAlpha.onEach { values.add(it) }.launchIn(this) - - repository.sendTransitionStep(step(0f, STARTED)) - repository.sendTransitionStep(step(0f)) - repository.sendTransitionStep(step(0.1f)) - repository.sendTransitionStep(step(0.2f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(1f)) + testScope.runTest { + val values by collectValues(underTest.deviceEntryParentViewAlpha) + + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0f), + step(0.1f), + step(0.2f), + step(0.3f), + step(1f), + ), + testScope, + ) assertThat(values.size).isEqualTo(4) values.forEach { assertThat(it).isIn(Range.closed(0f, 1f)) } - - job.cancel() } @Test fun deviceEntryBackgroundViewAppear() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { fingerprintPropertyRepository.setProperties( sensorId = 0, strength = SensorStrength.STRONG, sensorType = FingerprintSensorType.UDFPS_OPTICAL, sensorLocations = emptyMap(), ) - val values = mutableListOf<Float>() - - val job = - underTest.deviceEntryBackgroundViewAlpha.onEach { values.add(it) }.launchIn(this) - - repository.sendTransitionStep(step(0f, STARTED)) - repository.sendTransitionStep(step(0f)) - repository.sendTransitionStep(step(0.1f)) - repository.sendTransitionStep(step(0.2f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(1f)) + val values by collectValues(underTest.deviceEntryBackgroundViewAlpha) + + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0f), + step(0.1f), + step(0.2f), + step(0.3f), + step(1f), + ), + testScope, + ) values.forEach { assertThat(it).isEqualTo(1f) } - - job.cancel() } @Test fun deviceEntryBackground_noUdfps_noUpdates() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { fingerprintPropertyRepository.setProperties( sensorId = 0, strength = SensorStrength.STRONG, sensorType = FingerprintSensorType.REAR, sensorLocations = emptyMap(), ) - val values = mutableListOf<Float>() - - val job = - underTest.deviceEntryBackgroundViewAlpha.onEach { values.add(it) }.launchIn(this) - - repository.sendTransitionStep(step(0f, STARTED)) - repository.sendTransitionStep(step(0f)) - repository.sendTransitionStep(step(0.1f)) - repository.sendTransitionStep(step(0.2f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(1f)) + val values by collectValues(underTest.deviceEntryBackgroundViewAlpha) + + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0f), + step(0.1f), + step(0.2f), + step(0.3f), + step(1f), + ), + testScope, + ) assertThat(values.size).isEqualTo(0) // no updates - - job.cancel() } @Test fun lockscreenTranslationY() = - runTest(UnconfinedTestDispatcher()) { - val values = mutableListOf<Float>() - + testScope.runTest { val pixels = 100 - val job = - underTest.lockscreenTranslationY(pixels).onEach { values.add(it) }.launchIn(this) - - repository.sendTransitionStep(step(0f, STARTED)) - repository.sendTransitionStep(step(0f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.5f)) - repository.sendTransitionStep(step(1f)) + val values by collectValues(underTest.lockscreenTranslationY(pixels)) + + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0f), + step(0.3f), + step(0.5f), + step(1f), + ), + testScope, + ) assertThat(values.size).isEqualTo(5) values.forEach { assertThat(it).isIn(Range.closed(-100f, 0f)) } - - job.cancel() } @Test fun transitionEnded() = - runTest(UnconfinedTestDispatcher()) { - val values = mutableListOf<TransitionStep>() - - val job = underTest.transitionEnded.onEach { values.add(it) }.launchIn(this) - - repository.sendTransitionStep(TransitionStep(DOZING, DREAMING, 0.0f, STARTED)) - repository.sendTransitionStep(TransitionStep(DOZING, DREAMING, 1.0f, FINISHED)) - - repository.sendTransitionStep(TransitionStep(DREAMING, LOCKSCREEN, 0.0f, STARTED)) - repository.sendTransitionStep(TransitionStep(DREAMING, LOCKSCREEN, 0.1f, RUNNING)) - repository.sendTransitionStep(TransitionStep(DREAMING, LOCKSCREEN, 1.0f, FINISHED)) - - repository.sendTransitionStep(TransitionStep(LOCKSCREEN, DREAMING, 0.0f, STARTED)) - repository.sendTransitionStep(TransitionStep(LOCKSCREEN, DREAMING, 0.5f, RUNNING)) - repository.sendTransitionStep(TransitionStep(LOCKSCREEN, DREAMING, 1.0f, FINISHED)) - - repository.sendTransitionStep(TransitionStep(DREAMING, GONE, 0.0f, STARTED)) - repository.sendTransitionStep(TransitionStep(DREAMING, GONE, 0.5f, RUNNING)) - repository.sendTransitionStep(TransitionStep(DREAMING, GONE, 1.0f, CANCELED)) - - repository.sendTransitionStep(TransitionStep(DREAMING, AOD, 0.0f, STARTED)) - repository.sendTransitionStep(TransitionStep(DREAMING, AOD, 1.0f, FINISHED)) + testScope.runTest { + val values by collectValues(underTest.transitionEnded) + + keyguardTransitionRepository.sendTransitionSteps( + listOf( + TransitionStep(DOZING, DREAMING, 0.0f, STARTED), + TransitionStep(DOZING, DREAMING, 1.0f, FINISHED), + TransitionStep(DREAMING, LOCKSCREEN, 0.0f, STARTED), + TransitionStep(DREAMING, LOCKSCREEN, 0.1f, RUNNING), + TransitionStep(DREAMING, LOCKSCREEN, 1.0f, FINISHED), + TransitionStep(LOCKSCREEN, DREAMING, 0.0f, STARTED), + TransitionStep(LOCKSCREEN, DREAMING, 0.5f, RUNNING), + TransitionStep(LOCKSCREEN, DREAMING, 1.0f, FINISHED), + TransitionStep(DREAMING, GONE, 0.0f, STARTED), + TransitionStep(DREAMING, GONE, 0.5f, RUNNING), + TransitionStep(DREAMING, GONE, 1.0f, CANCELED), + TransitionStep(DREAMING, AOD, 0.0f, STARTED), + TransitionStep(DREAMING, AOD, 1.0f, FINISHED), + ), + testScope, + ) assertThat(values.size).isEqualTo(3) values.forEach { assertThat(it.transitionState == FINISHED || it.transitionState == CANCELED) .isTrue() } - - job.cancel() } private fun step(value: Float, state: TransitionState = RUNNING): TransitionStep { diff --git a/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingTransitionViewModelTest.kt b/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingTransitionViewModelTest.kt index cf2012989624..3c07034f0e12 100644 --- a/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingTransitionViewModelTest.kt +++ b/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingTransitionViewModelTest.kt @@ -19,85 +19,73 @@ package com.android.systemui.keyguard.ui.viewmodel import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractorFactory +import com.android.systemui.coroutines.collectValues +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.kosmos.testScope +import com.android.systemui.testKosmos import com.google.common.collect.Range import com.google.common.truth.Truth.assertThat -import kotlinx.coroutines.flow.launchIn -import kotlinx.coroutines.flow.onEach -import kotlinx.coroutines.test.TestScope -import kotlinx.coroutines.test.UnconfinedTestDispatcher import kotlinx.coroutines.test.runTest -import org.junit.Before import org.junit.Test import org.junit.runner.RunWith @SmallTest @RunWith(AndroidJUnit4::class) class GoneToDreamingTransitionViewModelTest : SysuiTestCase() { - private lateinit var underTest: GoneToDreamingTransitionViewModel - private lateinit var repository: FakeKeyguardTransitionRepository - - @Before - fun setUp() { - repository = FakeKeyguardTransitionRepository() - val interactor = - KeyguardTransitionInteractorFactory.create( - scope = TestScope().backgroundScope, - repository = repository, - ) - .keyguardTransitionInteractor - underTest = GoneToDreamingTransitionViewModel(interactor) - } + private val kosmos = testKosmos() + private val testScope = kosmos.testScope + private val repository = kosmos.fakeKeyguardTransitionRepository + private val underTest = kosmos.goneToDreamingTransitionViewModel @Test - fun lockscreenFadeOut() = - runTest(UnconfinedTestDispatcher()) { - val values = mutableListOf<Float>() - - val job = underTest.lockscreenAlpha.onEach { values.add(it) }.launchIn(this) + fun runTest() = + testScope.runTest { + val values by collectValues(underTest.lockscreenAlpha) - // Should start running here... - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0f)) - repository.sendTransitionStep(step(0.1f)) - repository.sendTransitionStep(step(0.2f)) - repository.sendTransitionStep(step(0.3f)) - // ...up to here - repository.sendTransitionStep(step(1f)) + repository.sendTransitionSteps( + listOf( + // Should start running here... + step(0f, TransitionState.STARTED), + step(0f), + step(0.1f), + step(0.2f), + step(0.3f), + // ...up to here + step(1f), + ), + testScope, + ) // Only three values should be present, since the dream overlay runs for a small // fraction of the overall animation time assertThat(values.size).isEqualTo(5) values.forEach { assertThat(it).isIn(Range.closed(0f, 1f)) } - - job.cancel() } @Test fun lockscreenTranslationY() = - runTest(UnconfinedTestDispatcher()) { - val values = mutableListOf<Float>() - + testScope.runTest { val pixels = 100 - val job = - underTest.lockscreenTranslationY(pixels).onEach { values.add(it) }.launchIn(this) + val values by collectValues(underTest.lockscreenTranslationY(pixels)) - // Should start running here... - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.5f)) - // And a final reset event on CANCEL - repository.sendTransitionStep(step(0.8f, TransitionState.CANCELED)) + repository.sendTransitionSteps( + listOf( + // Should start running here... + step(0f, TransitionState.STARTED), + step(0f), + step(0.3f), + step(0.5f), + // And a final reset event on CANCEL + step(0.8f, TransitionState.CANCELED) + ), + testScope, + ) assertThat(values.size).isEqualTo(5) values.forEach { assertThat(it).isIn(Range.closed(0f, 100f)) } - - job.cancel() } private fun step( diff --git a/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingTransitionViewModelTest.kt b/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingTransitionViewModelTest.kt index ba72b4c95a44..9226c0d61a3c 100644 --- a/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingTransitionViewModelTest.kt +++ b/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingTransitionViewModelTest.kt @@ -27,7 +27,6 @@ import com.android.systemui.flags.Flags import com.android.systemui.flags.featureFlagsClassic import com.android.systemui.keyguard.data.repository.fakeKeyguardRepository import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.StatusBarState import com.android.systemui.keyguard.shared.model.TransitionState @@ -55,11 +54,7 @@ class LockscreenToDreamingTransitionViewModelTest : SysuiTestCase() { private val repository = kosmos.fakeKeyguardTransitionRepository private val shadeRepository = kosmos.shadeRepository private val keyguardRepository = kosmos.fakeKeyguardRepository - private val underTest = - LockscreenToDreamingTransitionViewModel( - interactor = kosmos.keyguardTransitionInteractor, - shadeDependentFlows = kosmos.shadeDependentFlows, - ) + private val underTest = kosmos.lockscreenToDreamingTransitionViewModel @Test fun lockscreenFadeOut() = diff --git a/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToOccludedTransitionViewModelTest.kt b/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToOccludedTransitionViewModelTest.kt index 3536d5c77c93..bcad72bef1e6 100644 --- a/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToOccludedTransitionViewModelTest.kt +++ b/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToOccludedTransitionViewModelTest.kt @@ -21,18 +21,19 @@ package com.android.systemui.keyguard.ui.viewmodel import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase +import com.android.systemui.common.ui.data.repository.fakeConfigurationRepository import com.android.systemui.coroutines.collectLastValue import com.android.systemui.coroutines.collectValues import com.android.systemui.flags.Flags import com.android.systemui.flags.featureFlagsClassic import com.android.systemui.keyguard.data.repository.fakeKeyguardRepository import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.StatusBarState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep import com.android.systemui.kosmos.testScope +import com.android.systemui.res.R import com.android.systemui.shade.data.repository.shadeRepository import com.android.systemui.testKosmos import com.google.common.collect.Range @@ -46,7 +47,6 @@ import org.junit.runner.RunWith @SmallTest @RunWith(AndroidJUnit4::class) class LockscreenToOccludedTransitionViewModelTest : SysuiTestCase() { - private val kosmos = testKosmos().apply { featureFlagsClassic.apply { set(Flags.FULL_SCREEN_USER_SWITCHER, false) } @@ -55,11 +55,8 @@ class LockscreenToOccludedTransitionViewModelTest : SysuiTestCase() { private val repository = kosmos.fakeKeyguardTransitionRepository private val shadeRepository = kosmos.shadeRepository private val keyguardRepository = kosmos.fakeKeyguardRepository - private val underTest = - LockscreenToOccludedTransitionViewModel( - interactor = kosmos.keyguardTransitionInteractor, - shadeDependentFlows = kosmos.shadeDependentFlows, - ) + private val configurationRepository = kosmos.fakeConfigurationRepository + private val underTest = kosmos.lockscreenToOccludedTransitionViewModel @Test fun lockscreenFadeOut() = @@ -86,8 +83,11 @@ class LockscreenToOccludedTransitionViewModelTest : SysuiTestCase() { @Test fun lockscreenTranslationY() = testScope.runTest { - val pixels = 100 - val values by collectValues(underTest.lockscreenTranslationY(pixels)) + configurationRepository.setDimensionPixelSize( + R.dimen.lockscreen_to_occluded_transition_lockscreen_translation_y, + 100 + ) + val values by collectValues(underTest.lockscreenTranslationY) repository.sendTransitionSteps( steps = listOf( @@ -106,8 +106,11 @@ class LockscreenToOccludedTransitionViewModelTest : SysuiTestCase() { @Test fun lockscreenTranslationYIsCanceled() = testScope.runTest { - val pixels = 100 - val values by collectValues(underTest.lockscreenTranslationY(pixels)) + configurationRepository.setDimensionPixelSize( + R.dimen.lockscreen_to_occluded_transition_lockscreen_translation_y, + 100 + ) + val values by collectValues(underTest.lockscreenTranslationY) repository.sendTransitionSteps( steps = listOf( diff --git a/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToLockscreenTransitionViewModelTest.kt b/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToLockscreenTransitionViewModelTest.kt index d0772270ed5e..d419d4a2534c 100644 --- a/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToLockscreenTransitionViewModelTest.kt +++ b/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToLockscreenTransitionViewModelTest.kt @@ -19,24 +19,21 @@ package com.android.systemui.keyguard.ui.viewmodel import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase -import com.android.systemui.biometrics.data.repository.FakeFingerprintPropertyRepository -import com.android.systemui.deviceentry.domain.interactor.DeviceEntryUdfpsInteractor -import com.android.systemui.keyguard.data.repository.FakeBiometricSettingsRepository -import com.android.systemui.keyguard.data.repository.FakeDeviceEntryFingerprintAuthRepository -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractorFactory +import com.android.systemui.biometrics.data.repository.fingerprintPropertyRepository +import com.android.systemui.common.ui.data.repository.fakeConfigurationRepository +import com.android.systemui.coroutines.collectValues +import com.android.systemui.keyguard.data.repository.biometricSettingsRepository +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.kosmos.testScope +import com.android.systemui.res.R +import com.android.systemui.testKosmos import com.google.common.collect.Range import com.google.common.truth.Truth.assertThat import kotlinx.coroutines.ExperimentalCoroutinesApi -import kotlinx.coroutines.flow.launchIn -import kotlinx.coroutines.flow.onEach -import kotlinx.coroutines.test.TestScope -import kotlinx.coroutines.test.UnconfinedTestDispatcher import kotlinx.coroutines.test.runTest -import org.junit.Before import org.junit.Test import org.junit.runner.RunWith @@ -44,163 +41,139 @@ import org.junit.runner.RunWith @SmallTest @RunWith(AndroidJUnit4::class) class OccludedToLockscreenTransitionViewModelTest : SysuiTestCase() { - private lateinit var underTest: OccludedToLockscreenTransitionViewModel - private lateinit var repository: FakeKeyguardTransitionRepository - private lateinit var fingerprintPropertyRepository: FakeFingerprintPropertyRepository - private lateinit var biometricSettingsRepository: FakeBiometricSettingsRepository - - @Before - fun setUp() { - repository = FakeKeyguardTransitionRepository() - fingerprintPropertyRepository = FakeFingerprintPropertyRepository() - biometricSettingsRepository = FakeBiometricSettingsRepository() - underTest = - OccludedToLockscreenTransitionViewModel( - interactor = - KeyguardTransitionInteractorFactory.create( - scope = TestScope().backgroundScope, - repository = repository, - ) - .keyguardTransitionInteractor, - deviceEntryUdfpsInteractor = - DeviceEntryUdfpsInteractor( - fingerprintPropertyRepository = fingerprintPropertyRepository, - fingerprintAuthRepository = FakeDeviceEntryFingerprintAuthRepository(), - biometricSettingsRepository = biometricSettingsRepository, - ), - ) - } + val kosmos = testKosmos() + val testScope = kosmos.testScope + + val biometricSettingsRepository = kosmos.biometricSettingsRepository + val keyguardTransitionRepository = kosmos.fakeKeyguardTransitionRepository + val fingerprintPropertyRepository = kosmos.fingerprintPropertyRepository + val configurationRepository = kosmos.fakeConfigurationRepository + val underTest = kosmos.occludedToLockscreenTransitionViewModel @Test fun lockscreenFadeIn() = - runTest(UnconfinedTestDispatcher()) { - val values = mutableListOf<Float>() - - val job = underTest.lockscreenAlpha.onEach { values.add(it) }.launchIn(this) - - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.1f)) - // Should start running here... - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.4f)) - repository.sendTransitionStep(step(0.5f)) - repository.sendTransitionStep(step(0.6f)) - // ...up to here - repository.sendTransitionStep(step(0.8f)) - repository.sendTransitionStep(step(1f)) + testScope.runTest { + val values by collectValues(underTest.lockscreenAlpha) + + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0.1f), + // Should start running here... + step(0.3f), + step(0.4f), + step(0.5f), + step(0.6f), + // ...up to here + step(0.8f), + step(1f), + ), + testScope, + ) assertThat(values.size).isEqualTo(5) values.forEach { assertThat(it).isIn(Range.closed(0f, 1f)) } - - job.cancel() } @Test fun lockscreenTranslationY() = - runTest(UnconfinedTestDispatcher()) { - val values = mutableListOf<Float>() - - val pixels = 100 - val job = - underTest.lockscreenTranslationY(pixels).onEach { values.add(it) }.launchIn(this) - - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.5f)) - repository.sendTransitionStep(step(1f)) + testScope.runTest { + configurationRepository.setDimensionPixelSize( + R.dimen.occluded_to_lockscreen_transition_lockscreen_translation_y, + 100 + ) + val values by collectValues(underTest.lockscreenTranslationY) + + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0f), + step(0.3f), + step(0.5f), + step(1f), + ), + testScope, + ) assertThat(values.size).isEqualTo(5) values.forEach { assertThat(it).isIn(Range.closed(-100f, 0f)) } - - job.cancel() } @Test fun lockscreenTranslationYResettedAfterJobCancelled() = - runTest(UnconfinedTestDispatcher()) { - val values = mutableListOf<Float>() + testScope.runTest { + configurationRepository.setDimensionPixelSize( + R.dimen.occluded_to_lockscreen_transition_lockscreen_translation_y, + 100 + ) + val values by collectValues(underTest.lockscreenTranslationY) - val pixels = 100 - val job = - underTest.lockscreenTranslationY(pixels).onEach { values.add(it) }.launchIn(this) - repository.sendTransitionStep(step(0.5f, TransitionState.CANCELED)) + keyguardTransitionRepository.sendTransitionStep(step(0.5f, TransitionState.CANCELED)) assertThat(values.last()).isEqualTo(0f) - - job.cancel() } @Test fun deviceEntryParentViewFadeIn() = - runTest(UnconfinedTestDispatcher()) { - val values = mutableListOf<Float>() - - val job = underTest.deviceEntryParentViewAlpha.onEach { values.add(it) }.launchIn(this) - - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.1f)) - // Should start running here... - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.4f)) - repository.sendTransitionStep(step(0.5f)) - repository.sendTransitionStep(step(0.6f)) - // ...up to here - repository.sendTransitionStep(step(0.8f)) - repository.sendTransitionStep(step(1f)) + testScope.runTest { + val values by collectValues(underTest.deviceEntryParentViewAlpha) + + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0.1f), + // Should start running here... + step(0.3f), + step(0.4f), + step(0.5f), + step(0.6f), + // ...up to here + step(0.8f), + step(1f), + ), + testScope, + ) assertThat(values.size).isEqualTo(5) values.forEach { assertThat(it).isIn(Range.closed(0f, 1f)) } - - job.cancel() } @Test fun deviceEntryBackgroundViewShows() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { fingerprintPropertyRepository.supportsUdfps() biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(true) - val values = mutableListOf<Float>() + val values by collectValues(underTest.deviceEntryBackgroundViewAlpha) - val job = - underTest.deviceEntryBackgroundViewAlpha.onEach { values.add(it) }.launchIn(this) - - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.1f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.4f)) - repository.sendTransitionStep(step(0.5f)) - repository.sendTransitionStep(step(0.6f)) - repository.sendTransitionStep(step(0.8f)) - repository.sendTransitionStep(step(1f)) + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + keyguardTransitionRepository.sendTransitionStep(step(0.1f)) + keyguardTransitionRepository.sendTransitionStep(step(0.3f)) + keyguardTransitionRepository.sendTransitionStep(step(0.4f)) + keyguardTransitionRepository.sendTransitionStep(step(0.5f)) + keyguardTransitionRepository.sendTransitionStep(step(0.6f)) + keyguardTransitionRepository.sendTransitionStep(step(0.8f)) + keyguardTransitionRepository.sendTransitionStep(step(1f)) values.forEach { assertThat(it).isEqualTo(1f) } - - job.cancel() } @Test fun deviceEntryBackgroundView_noUdfpsEnrolled_noUpdates() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { fingerprintPropertyRepository.supportsRearFps() biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(true) - val values = mutableListOf<Float>() + val values by collectValues(underTest.deviceEntryBackgroundViewAlpha) - val job = - underTest.deviceEntryBackgroundViewAlpha.onEach { values.add(it) }.launchIn(this) - - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.1f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.4f)) - repository.sendTransitionStep(step(0.5f)) - repository.sendTransitionStep(step(0.6f)) - repository.sendTransitionStep(step(0.8f)) - repository.sendTransitionStep(step(1f)) + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + keyguardTransitionRepository.sendTransitionStep(step(0.1f)) + keyguardTransitionRepository.sendTransitionStep(step(0.3f)) + keyguardTransitionRepository.sendTransitionStep(step(0.4f)) + keyguardTransitionRepository.sendTransitionStep(step(0.5f)) + keyguardTransitionRepository.sendTransitionStep(step(0.6f)) + keyguardTransitionRepository.sendTransitionStep(step(0.8f)) + keyguardTransitionRepository.sendTransitionStep(step(1f)) assertThat(values).isEmpty() // no updates - - job.cancel() } private fun step( diff --git a/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToGoneTransitionViewModelTest.kt b/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToGoneTransitionViewModelTest.kt index 6cab023d59b0..78d87a680c5b 100644 --- a/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToGoneTransitionViewModelTest.kt +++ b/packages/SystemUI/multivalentTests/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToGoneTransitionViewModelTest.kt @@ -19,80 +19,61 @@ package com.android.systemui.keyguard.ui.viewmodel import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase -import com.android.systemui.bouncer.domain.interactor.PrimaryBouncerInteractor +import com.android.systemui.bouncer.domain.interactor.primaryBouncerInteractor import com.android.systemui.coroutines.collectValues -import com.android.systemui.flags.FakeFeatureFlags import com.android.systemui.flags.Flags -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.KeyguardDismissActionInteractor -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractorFactory +import com.android.systemui.flags.featureFlagsClassic +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep -import com.android.systemui.statusbar.SysuiStatusBarStateController +import com.android.systemui.kosmos.testScope +import com.android.systemui.statusbar.sysuiStatusBarStateController +import com.android.systemui.testKosmos import com.android.systemui.util.mockito.whenever import com.google.common.collect.Range import com.google.common.truth.Truth.assertThat -import dagger.Lazy -import kotlinx.coroutines.flow.MutableStateFlow -import kotlinx.coroutines.test.TestScope -import kotlinx.coroutines.test.UnconfinedTestDispatcher import kotlinx.coroutines.test.runTest import org.junit.Before import org.junit.Test import org.junit.runner.RunWith -import org.mockito.Mock -import org.mockito.MockitoAnnotations @SmallTest @RunWith(AndroidJUnit4::class) class PrimaryBouncerToGoneTransitionViewModelTest : SysuiTestCase() { - private lateinit var underTest: PrimaryBouncerToGoneTransitionViewModel - private lateinit var repository: FakeKeyguardTransitionRepository - private lateinit var featureFlags: FakeFeatureFlags - @Mock private lateinit var statusBarStateController: SysuiStatusBarStateController - @Mock private lateinit var primaryBouncerInteractor: PrimaryBouncerInteractor - @Mock private lateinit var bouncerToGoneFlows: BouncerToGoneFlows - @Mock - private lateinit var keyguardDismissActionInteractor: Lazy<KeyguardDismissActionInteractor> + val kosmos = + testKosmos().apply { + featureFlagsClassic.apply { + set(Flags.REFACTOR_KEYGUARD_DISMISS_INTENT, false) + set(Flags.FULL_SCREEN_USER_SWITCHER, false) + } + } + val testScope = kosmos.testScope - private val shadeExpansionStateFlow = MutableStateFlow(0.1f) + val keyguardTransitionRepository = kosmos.fakeKeyguardTransitionRepository + val primaryBouncerInteractor = kosmos.primaryBouncerInteractor + val sysuiStatusBarStateController = kosmos.sysuiStatusBarStateController + val underTest = kosmos.primaryBouncerToGoneTransitionViewModel @Before fun setUp() { - MockitoAnnotations.initMocks(this) - - repository = FakeKeyguardTransitionRepository() - val featureFlags = - FakeFeatureFlags().apply { set(Flags.REFACTOR_KEYGUARD_DISMISS_INTENT, false) } - val interactor = - KeyguardTransitionInteractorFactory.create( - scope = TestScope().backgroundScope, - repository = repository, - ) - .keyguardTransitionInteractor - underTest = - PrimaryBouncerToGoneTransitionViewModel( - interactor, - statusBarStateController, - primaryBouncerInteractor, - keyguardDismissActionInteractor, - featureFlags, - bouncerToGoneFlows, - ) - whenever(primaryBouncerInteractor.willRunDismissFromKeyguard()).thenReturn(false) - whenever(statusBarStateController.leaveOpenOnKeyguardHide()).thenReturn(false) + sysuiStatusBarStateController.setLeaveOpenOnKeyguardHide(false) } @Test fun bouncerAlpha() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { val values by collectValues(underTest.bouncerAlpha) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.6f)) + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0.3f), + step(0.6f), + ), + testScope, + ) assertThat(values.size).isEqualTo(3) values.forEach { assertThat(it).isIn(Range.closed(0f, 1f)) } @@ -100,14 +81,19 @@ class PrimaryBouncerToGoneTransitionViewModelTest : SysuiTestCase() { @Test fun bouncerAlpha_runDimissFromKeyguard() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { val values by collectValues(underTest.bouncerAlpha) whenever(primaryBouncerInteractor.willRunDismissFromKeyguard()).thenReturn(true) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.6f)) + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0.3f), + step(0.6f), + ), + testScope, + ) assertThat(values.size).isEqualTo(3) values.forEach { assertThat(it).isEqualTo(0f) } @@ -115,11 +101,11 @@ class PrimaryBouncerToGoneTransitionViewModelTest : SysuiTestCase() { @Test fun lockscreenAlpha() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { val values by collectValues(underTest.lockscreenAlpha) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(1f)) + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + keyguardTransitionRepository.sendTransitionStep(step(1f)) assertThat(values.size).isEqualTo(2) values.forEach { assertThat(it).isEqualTo(0f) } @@ -127,13 +113,13 @@ class PrimaryBouncerToGoneTransitionViewModelTest : SysuiTestCase() { @Test fun lockscreenAlpha_runDimissFromKeyguard() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { val values by collectValues(underTest.lockscreenAlpha) - whenever(primaryBouncerInteractor.willRunDismissFromKeyguard()).thenReturn(true) + sysuiStatusBarStateController.setLeaveOpenOnKeyguardHide(true) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(1f)) + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + keyguardTransitionRepository.sendTransitionStep(step(1f)) assertThat(values.size).isEqualTo(2) values.forEach { assertThat(it).isEqualTo(1f) } @@ -141,13 +127,13 @@ class PrimaryBouncerToGoneTransitionViewModelTest : SysuiTestCase() { @Test fun lockscreenAlpha_leaveShadeOpen() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { val values by collectValues(underTest.lockscreenAlpha) - whenever(statusBarStateController.leaveOpenOnKeyguardHide()).thenReturn(true) + sysuiStatusBarStateController.setLeaveOpenOnKeyguardHide(true) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(1f)) + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + keyguardTransitionRepository.sendTransitionStep(step(1f)) assertThat(values.size).isEqualTo(2) values.forEach { assertThat(it).isEqualTo(1f) } diff --git a/packages/SystemUI/res/color/notification_overlay_color.xml b/packages/SystemUI/res/color/notification_overlay_color.xml index c24bff9c7271..a14a7ad9d2da 100644 --- a/packages/SystemUI/res/color/notification_overlay_color.xml +++ b/packages/SystemUI/res/color/notification_overlay_color.xml @@ -17,7 +17,9 @@ <selector xmlns:android="http://schemas.android.com/apk/res/android" xmlns:androidprv="http://schemas.android.com/apk/prv/res/android"> - <item android:state_pressed="true" android:color="?androidprv:attr/materialColorOnSurface" android:alpha="0.15" /> + <!-- Pressed state's alpha is set to 0.00 temporarily until this bug is resolved permanently + b/313920497 Design intended alpha is 0.15--> + <item android:state_pressed="true" android:color="?androidprv:attr/materialColorOnSurface" android:alpha="0.00" /> <item android:state_hovered="true" android:color="?androidprv:attr/materialColorOnSurface" android:alpha="0.11" /> <item android:color="@color/transparent" /> </selector>
\ No newline at end of file diff --git a/packages/SystemUI/src/com/android/keyguard/logging/KeyguardTransitionAnimationLogger.kt b/packages/SystemUI/src/com/android/keyguard/logging/KeyguardTransitionAnimationLogger.kt new file mode 100644 index 000000000000..d9830b287be5 --- /dev/null +++ b/packages/SystemUI/src/com/android/keyguard/logging/KeyguardTransitionAnimationLogger.kt @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2023 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.keyguard.logging + +import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.log.LogBuffer +import com.android.systemui.log.core.LogLevel +import com.android.systemui.log.dagger.KeyguardTransitionAnimationLog +import javax.inject.Inject + +private const val TAG = "KeyguardTransitionAnimationLog" + +/** + * Generic logger for keyguard that's wrapping [LogBuffer]. This class should be used for adding + * temporary logs or logs for smaller classes when creating whole new [LogBuffer] wrapper might be + * an overkill. + */ +class KeyguardTransitionAnimationLogger +@Inject +constructor( + @KeyguardTransitionAnimationLog val buffer: LogBuffer, +) { + @JvmOverloads + fun logCreate( + name: String? = null, + start: Float, + ) { + if (name == null) return + + buffer.log( + TAG, + LogLevel.DEBUG, + { + str1 = name + str2 = "$start" + }, + { "[$str1] starts at: $str2" } + ) + } + + @JvmOverloads + fun logTransitionStep( + name: String? = null, + step: TransitionStep, + value: Float? = null, + ) { + if (name == null) return + + buffer.log( + TAG, + LogLevel.DEBUG, + { + str1 = "[$name][${step.transitionState}]" + str2 = "${step.value}" + str3 = "$value" + }, + { "$str1 transitionStep=$str2, animationValue=$str3" } + ) + } +} diff --git a/packages/SystemUI/src/com/android/systemui/biometrics/AuthController.java b/packages/SystemUI/src/com/android/systemui/biometrics/AuthController.java index 8fe42b536b1e..877afce7fe65 100644 --- a/packages/SystemUI/src/com/android/systemui/biometrics/AuthController.java +++ b/packages/SystemUI/src/com/android/systemui/biometrics/AuthController.java @@ -86,6 +86,8 @@ import com.android.systemui.statusbar.VibratorHelper; import com.android.systemui.util.concurrency.DelayableExecutor; import com.android.systemui.util.concurrency.Execution; +import dagger.Lazy; + import java.io.PrintWriter; import java.util.ArrayList; import java.util.Arrays; @@ -133,7 +135,7 @@ public class AuthController implements CoreStartable, CommandQueue.Callbacks, @NonNull private final Provider<PromptSelectorInteractor> mPromptSelectorInteractor; @NonNull private final Provider<CredentialViewModel> mCredentialViewModelProvider; @NonNull private final Provider<PromptViewModel> mPromptViewModelProvider; - @NonNull private final LogContextInteractor mLogContextInteractor; + @NonNull private final Lazy<LogContextInteractor> mLogContextInteractor; private final Display mDisplay; private float mScaleFactor = 1f; @@ -156,7 +158,7 @@ public class AuthController implements CoreStartable, CommandQueue.Callbacks, @Nullable private UdfpsOverlayParams mUdfpsOverlayParams; @Nullable private IUdfpsRefreshRateRequestCallback mUdfpsRefreshRateRequestCallback; @Nullable private SideFpsController mSideFpsController; - @NonNull private UdfpsLogger mUdfpsLogger; + @NonNull private Lazy<UdfpsLogger> mUdfpsLogger; @VisibleForTesting IBiometricSysuiReceiver mReceiver; @VisibleForTesting @NonNull final BiometricDisplayListener mOrientationListener; @Nullable private final List<FaceSensorPropertiesInternal> mFaceProps; @@ -309,7 +311,7 @@ public class AuthController implements CoreStartable, CommandQueue.Callbacks, }); mUdfpsController.setAuthControllerUpdateUdfpsLocation(this::updateUdfpsLocation); mUdfpsController.setUdfpsDisplayMode(new UdfpsDisplayMode(mContext, mExecution, - this, mUdfpsLogger)); + this, mUdfpsLogger.get())); mUdfpsBounds = mUdfpsProps.get(0).getLocation().getRect(); } @@ -755,8 +757,8 @@ public class AuthController implements CoreStartable, CommandQueue.Callbacks, @NonNull AuthDialogPanelInteractionDetector panelInteractionDetector, @NonNull UserManager userManager, @NonNull LockPatternUtils lockPatternUtils, - @NonNull UdfpsLogger udfpsLogger, - @NonNull LogContextInteractor logContextInteractor, + @NonNull Lazy<UdfpsLogger> udfpsLogger, + @NonNull Lazy<LogContextInteractor> logContextInteractor, @NonNull Provider<PromptCredentialInteractor> promptCredentialInteractorProvider, @NonNull Provider<PromptSelectorInteractor> promptSelectorInteractorProvider, @NonNull Provider<CredentialViewModel> credentialViewModelProvider, @@ -903,7 +905,7 @@ public class AuthController implements CoreStartable, CommandQueue.Callbacks, @Override public void setBiometricContextListener(IBiometricContextListener listener) { - mLogContextInteractor.addBiometricContextListener(listener); + mLogContextInteractor.get().addBiometricContextListener(listener); } /** @@ -932,14 +934,14 @@ public class AuthController implements CoreStartable, CommandQueue.Callbacks, */ public void requestMaxRefreshRate(boolean request) throws RemoteException { if (mUdfpsRefreshRateRequestCallback == null) { - mUdfpsLogger.log( + mUdfpsLogger.get().log( "PreAuthRefreshRate", "skip request - refreshRateCallback is null", LogLevel.DEBUG ); return; } - mUdfpsLogger.requestMaxRefreshRate(request); + mUdfpsLogger.get().requestMaxRefreshRate(request); mUdfpsRefreshRateRequestCallback.onAuthenticationPossible(mContext.getDisplayId(), request); } diff --git a/packages/SystemUI/src/com/android/systemui/clipboardoverlay/ClipboardListener.java b/packages/SystemUI/src/com/android/systemui/clipboardoverlay/ClipboardListener.java index 63b4288ce055..e0ce3db39403 100644 --- a/packages/SystemUI/src/com/android/systemui/clipboardoverlay/ClipboardListener.java +++ b/packages/SystemUI/src/com/android/systemui/clipboardoverlay/ClipboardListener.java @@ -27,7 +27,7 @@ import static com.google.android.setupcompat.util.WizardManagerHelper.SETTINGS_S import android.content.ClipData; import android.content.ClipboardManager; import android.content.Context; -import android.os.SystemProperties; +import android.os.Build; import android.provider.Settings; import android.util.Log; @@ -87,7 +87,7 @@ public class ClipboardListener implements String clipSource = mClipboardManager.getPrimaryClipSource(); ClipData clipData = mClipboardManager.getPrimaryClip(); - if (shouldSuppressOverlay(clipData, clipSource, isEmulator())) { + if (shouldSuppressOverlay(clipData, clipSource, Build.IS_EMULATOR)) { Log.i(TAG, "Clipboard overlay suppressed."); return; } @@ -141,10 +141,6 @@ public class ClipboardListener implements return true; } - private static boolean isEmulator() { - return SystemProperties.getBoolean("ro.boot.qemu", false); - } - private boolean isUserSetupComplete() { return Settings.Secure.getInt(mContext.getContentResolver(), SETTINGS_SECURE_USER_SETUP_COMPLETE, 0) == 1; diff --git a/packages/SystemUI/src/com/android/systemui/clipboardoverlay/ClipboardOverlayController.java b/packages/SystemUI/src/com/android/systemui/clipboardoverlay/ClipboardOverlayController.java index 70736ae3fcc1..bfc80a78120d 100644 --- a/packages/SystemUI/src/com/android/systemui/clipboardoverlay/ClipboardOverlayController.java +++ b/packages/SystemUI/src/com/android/systemui/clipboardoverlay/ClipboardOverlayController.java @@ -61,12 +61,12 @@ import androidx.annotation.Nullable; import com.android.internal.annotations.VisibleForTesting; import com.android.internal.logging.UiEventLogger; -import com.android.systemui.res.R; import com.android.systemui.broadcast.BroadcastDispatcher; import com.android.systemui.broadcast.BroadcastSender; import com.android.systemui.clipboardoverlay.dagger.ClipboardOverlayModule.OverlayWindowContext; import com.android.systemui.dagger.qualifiers.Background; import com.android.systemui.flags.FeatureFlags; +import com.android.systemui.res.R; import com.android.systemui.screenshot.TimeoutHandler; import java.util.Optional; @@ -297,6 +297,7 @@ public class ClipboardOverlayController implements ClipboardListener.ClipboardOv mClipboardLogger.logUnguarded(CLIPBOARD_OVERLAY_SHOWN_MINIMIZED); mIsMinimized = true; mView.setMinimized(true); + animateIn(); } else { mClipboardLogger.logUnguarded(CLIPBOARD_OVERLAY_SHOWN_EXPANDED); setExpandedView(this::animateIn); @@ -318,8 +319,8 @@ public class ClipboardOverlayController implements ClipboardListener.ClipboardOv } else { mClipboardLogger.logUnguarded(CLIPBOARD_OVERLAY_SHOWN_EXPANDED); setExpandedView(); - animateIn(); } + animateIn(); mView.announceForAccessibility( getAccessibilityAnnouncement(mClipboardModel.getType())); } else if (!mIsMinimized) { diff --git a/packages/SystemUI/src/com/android/systemui/common/ui/domain/interactor/ConfigurationInteractor.kt b/packages/SystemUI/src/com/android/systemui/common/ui/domain/interactor/ConfigurationInteractor.kt new file mode 100644 index 000000000000..3648f3b2c3b9 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/common/ui/domain/interactor/ConfigurationInteractor.kt @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2023 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 + */ +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.common.ui.domain.interactor + +import com.android.systemui.common.ui.data.repository.ConfigurationRepository +import com.android.systemui.dagger.SysUISingleton +import javax.inject.Inject +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.mapLatest +import kotlinx.coroutines.flow.onStart + +/** Business logic related to configuration changes. */ +@SysUISingleton +class ConfigurationInteractor @Inject constructor(private val repository: ConfigurationRepository) { + /** Given [resourceId], emit the dimension pixel size on config change */ + fun dimensionPixelSize(resourceId: Int): Flow<Int> { + return onAnyConfigurationChange.mapLatest { repository.getDimensionPixelSize(resourceId) } + } + + /** Given a set of [resourceId]s, emit Map<ResourceId, DimensionPixelSize> on config change */ + fun dimensionPixelSize(resourceIds: Set<Int>): Flow<Map<Int, Int>> { + return onAnyConfigurationChange.mapLatest { + resourceIds.associateWith { repository.getDimensionPixelSize(it) } + } + } + + /** Emit an event on any config change */ + val onAnyConfigurationChange: Flow<Unit> = + repository.onAnyConfigurationChange.onStart { emit(Unit) } +} diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/data/repository/KeyguardRepository.kt b/packages/SystemUI/src/com/android/systemui/keyguard/data/repository/KeyguardRepository.kt index 791ac07db5cf..2d6c0e1c13b2 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/data/repository/KeyguardRepository.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/data/repository/KeyguardRepository.kt @@ -37,7 +37,6 @@ import com.android.systemui.keyguard.shared.model.DismissAction import com.android.systemui.keyguard.shared.model.DozeStateModel import com.android.systemui.keyguard.shared.model.DozeTransitionModel import com.android.systemui.keyguard.shared.model.KeyguardDone -import com.android.systemui.keyguard.shared.model.KeyguardRootViewVisibilityState import com.android.systemui.keyguard.shared.model.StatusBarState import com.android.systemui.plugins.statusbar.StatusBarStateController import com.android.systemui.statusbar.policy.KeyguardStateController @@ -178,9 +177,6 @@ interface KeyguardRepository { /** Whether quick settings or quick-quick settings is visible. */ val isQuickSettingsVisible: Flow<Boolean> - /** Represents the current state of the KeyguardRootView visibility */ - val keyguardRootViewVisibility: Flow<KeyguardRootViewVisibilityState> - /** Receive an event for doze time tick */ val dozeTimeTick: Flow<Long> @@ -211,12 +207,6 @@ interface KeyguardRepository { /** Sets the current amount of alpha that should be used for rendering the keyguard. */ fun setKeyguardAlpha(alpha: Float) - fun setKeyguardVisibility( - statusBarState: Int, - goingToFullShade: Boolean, - occlusionTransitionRunning: Boolean - ) - /** * Sets the relative offset of the lock-screen clock from its natural position on the screen. */ @@ -621,17 +611,6 @@ constructor( private val _isActiveDreamLockscreenHosted = MutableStateFlow(false) override val isActiveDreamLockscreenHosted = _isActiveDreamLockscreenHosted.asStateFlow() - private val _keyguardRootViewVisibility = - MutableStateFlow( - KeyguardRootViewVisibilityState( - com.android.systemui.statusbar.StatusBarState.SHADE, - goingToFullShade = false, - occlusionTransitionRunning = false, - ) - ) - override val keyguardRootViewVisibility: Flow<KeyguardRootViewVisibilityState> = - _keyguardRootViewVisibility.asStateFlow() - override fun setAnimateDozingTransitions(animate: Boolean) { _animateBottomAreaDozingTransitions.value = animate } @@ -644,19 +623,6 @@ constructor( _keyguardAlpha.value = alpha } - override fun setKeyguardVisibility( - statusBarState: Int, - goingToFullShade: Boolean, - occlusionTransitionRunning: Boolean - ) { - _keyguardRootViewVisibility.value = - KeyguardRootViewVisibilityState( - statusBarState, - goingToFullShade, - occlusionTransitionRunning - ) - } - override fun setClockPosition(x: Int, y: Int) { _clockPosition.value = Position(x, y) } diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/data/repository/KeyguardTransitionRepository.kt b/packages/SystemUI/src/com/android/systemui/keyguard/data/repository/KeyguardTransitionRepository.kt index 5c76be80f1ad..0e487d297b40 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/data/repository/KeyguardTransitionRepository.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/data/repository/KeyguardTransitionRepository.kt @@ -103,7 +103,7 @@ class KeyguardTransitionRepositoryImpl @Inject constructor() : KeyguardTransitio private val _transitions = MutableSharedFlow<TransitionStep>( replay = 2, - extraBufferCapacity = 10, + extraBufferCapacity = 20, onBufferOverflow = BufferOverflow.DROP_OLDEST, ) override val transitions = _transitions.asSharedFlow().distinctUntilChanged() @@ -227,10 +227,7 @@ class KeyguardTransitionRepositoryImpl @Inject constructor() : KeyguardTransitio private fun emitTransition(nextStep: TransitionStep, isManual: Boolean = false) { logAndTrace(nextStep, isManual) - val emitted = _transitions.tryEmit(nextStep) - if (!emitted) { - Log.w(TAG, "Failed to emit next value without suspending") - } + _transitions.tryEmit(nextStep) lastStep = nextStep } diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractor.kt b/packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractor.kt index c0e8e2b60f33..b8c392591494 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractor.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractor.kt @@ -28,7 +28,7 @@ import com.android.systemui.common.coroutine.ChannelExt.trySendWithFailureLoggin import com.android.systemui.common.coroutine.ConflatedCallbackFlow.conflatedCallbackFlow import com.android.systemui.common.shared.model.NotificationContainerBounds import com.android.systemui.common.shared.model.Position -import com.android.systemui.common.ui.data.repository.ConfigurationRepository +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor import com.android.systemui.dagger.SysUISingleton import com.android.systemui.keyguard.data.repository.KeyguardRepository import com.android.systemui.keyguard.shared.model.BiometricUnlockModel @@ -76,7 +76,7 @@ constructor( powerInteractor: PowerInteractor, sceneContainerFlags: SceneContainerFlags, bouncerRepository: KeyguardBouncerRepository, - configurationRepository: ConfigurationRepository, + configurationInteractor: ConfigurationInteractor, shadeRepository: ShadeRepository, sceneInteractorProvider: Provider<SceneInteractor>, ) { @@ -212,35 +212,29 @@ constructor( /** The approximate location on the screen of the face unlock sensor, if one is available. */ val faceSensorLocation: Flow<Point?> = repository.faceSensorLocation - /** Notifies when a new configuration is set */ - val configurationChange: Flow<Unit> = - configurationRepository.onAnyConfigurationChange.onStart { emit(Unit) } - /** The position of the keyguard clock. */ val clockPosition: Flow<Position> = repository.clockPosition val keyguardAlpha: Flow<Float> = repository.keyguardAlpha val keyguardTranslationY: Flow<Float> = - configurationChange.flatMapLatest { - val translationDistance = - configurationRepository.getDimensionPixelSize( - R.dimen.keyguard_translate_distance_on_swipe_up - ) - shadeRepository.shadeModel.map { - if (it.expansionAmount == 0f) { - // Reset the translation value - 0f - } else { - // On swipe up, translate the keyguard to reveal the bouncer - MathUtils.lerp( - translationDistance, - 0, - Interpolators.FAST_OUT_LINEAR_IN.getInterpolation(it.expansionAmount) - ) + configurationInteractor + .dimensionPixelSize(R.dimen.keyguard_translate_distance_on_swipe_up) + .flatMapLatest { translationDistance -> + shadeRepository.shadeModel.map { + if (it.expansionAmount == 0f) { + // Reset the translation value + 0f + } else { + // On swipe up, translate the keyguard to reveal the bouncer + MathUtils.lerp( + translationDistance, + 0, + Interpolators.FAST_OUT_LINEAR_IN.getInterpolation(it.expansionAmount) + ) + } } } - } val clockShouldBeCentered: Flow<Boolean> = repository.clockShouldBeCentered @@ -294,18 +288,6 @@ constructor( repository.setQuickSettingsVisible(isVisible) } - fun setKeyguardRootVisibility( - statusBarState: Int, - goingToFullShade: Boolean, - isOcclusionTransitionRunning: Boolean - ) { - repository.setKeyguardVisibility( - statusBarState, - goingToFullShade, - isOcclusionTransitionRunning - ) - } - fun setClockPosition(x: Int, y: Int) { repository.setClockPosition(x, y) } diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/KeyguardTransitionAnimationFlow.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/KeyguardTransitionAnimationFlow.kt index d5ad7ab0d0d1..64ff3b0c238a 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/KeyguardTransitionAnimationFlow.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/KeyguardTransitionAnimationFlow.kt @@ -17,97 +17,134 @@ package com.android.systemui.keyguard.ui import android.view.animation.Interpolator import com.android.app.animation.Interpolators.LINEAR +import com.android.keyguard.logging.KeyguardTransitionAnimationLogger +import com.android.systemui.dagger.SysUISingleton +import com.android.systemui.dagger.qualifiers.Application import com.android.systemui.keyguard.shared.model.TransitionState.CANCELED import com.android.systemui.keyguard.shared.model.TransitionState.FINISHED import com.android.systemui.keyguard.shared.model.TransitionState.RUNNING import com.android.systemui.keyguard.shared.model.TransitionState.STARTED import com.android.systemui.keyguard.shared.model.TransitionStep +import javax.inject.Inject import kotlin.math.max import kotlin.math.min import kotlin.time.Duration import kotlin.time.Duration.Companion.milliseconds +import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.SharedFlow +import kotlinx.coroutines.flow.SharingStarted import kotlinx.coroutines.flow.filterNotNull import kotlinx.coroutines.flow.map +import kotlinx.coroutines.flow.shareIn /** - * For the given transition params, construct a flow using [createFlow] for the specified portion of - * the overall transition. + * Assists in creating sub-flows for a KeyguardTransition. Call [setup] once for a transition, and + * then [sharedFlow] for each sub animation that should be trigged when the overall transition runs. */ -class KeyguardTransitionAnimationFlow( - private val transitionDuration: Duration, - private val transitionFlow: Flow<TransitionStep>, +@SysUISingleton +class KeyguardTransitionAnimationFlow +@Inject +constructor( + @Application private val scope: CoroutineScope, + private val logger: KeyguardTransitionAnimationLogger, ) { + /** - * Transitions will occur over a [transitionDuration] with [TransitionStep]s being emitted in - * the range of [0, 1]. View animations should begin and end within a subset of this range. This - * function maps the [startTime] and [duration] into [0, 1], when this subset is valid. + * Invoke once per transition between FROM->TO states to get access to + * [SharedFlowBuilder#sharedFlow]. */ - fun createFlow( + fun setup( duration: Duration, - onStep: (Float) -> Float, - startTime: Duration = 0.milliseconds, - onStart: (() -> Unit)? = null, - onCancel: (() -> Float)? = null, - onFinish: (() -> Float)? = null, - interpolator: Interpolator = LINEAR, - ): Flow<Float> { - if (!duration.isPositive()) { - throw IllegalArgumentException("duration must be a positive number: $duration") - } - if ((startTime + duration).compareTo(transitionDuration) > 0) { - throw IllegalArgumentException( - "startTime($startTime) + duration($duration) must be" + - " <= transitionDuration($transitionDuration)" - ) - } + stepFlow: Flow<TransitionStep>, + ) = SharedFlowBuilder(duration, stepFlow) - val start = (startTime / transitionDuration).toFloat() - val chunks = (transitionDuration / duration).toFloat() - var isComplete = true + inner class SharedFlowBuilder( + private val transitionDuration: Duration, + private val stepFlow: Flow<TransitionStep>, + ) { + /** + * Transitions will occur over a [transitionDuration] with [TransitionStep]s being emitted + * in the range of [0, 1]. View animations should begin and end within a subset of this + * range. This function maps the [startTime] and [duration] into [0, 1], when this subset is + * valid. + * + * Will produce a [SharedFlow], so that identical animations can use the same value. + */ + fun sharedFlow( + duration: Duration, + onStep: (Float) -> Float, + startTime: Duration = 0.milliseconds, + onStart: (() -> Unit)? = null, + onCancel: (() -> Float)? = null, + onFinish: (() -> Float)? = null, + interpolator: Interpolator = LINEAR, + name: String? = null + ): SharedFlow<Float> { + if (!duration.isPositive()) { + throw IllegalArgumentException("duration must be a positive number: $duration") + } + if ((startTime + duration).compareTo(transitionDuration) > 0) { + throw IllegalArgumentException( + "startTime($startTime) + duration($duration) must be" + + " <= transitionDuration($transitionDuration)" + ) + } - fun stepToValue(step: TransitionStep): Float? { - val value = (step.value - start) * chunks - return when (step.transitionState) { - // When starting, make sure to always emit. If a transition is started from the - // middle, it is possible this animation is being skipped but we need to inform - // the ViewModels of the last update - STARTED -> { - isComplete = false - onStart?.invoke() - max(0f, min(1f, value)) - } - // Always send a final value of 1. Because of rounding, [value] may never be - // exactly 1. - RUNNING -> - if (isComplete) { - null - } else if (value >= 1f) { - isComplete = true - 1f - } else if (value >= 0f) { - value - } else { - null + val start = (startTime / transitionDuration).toFloat() + val chunks = (transitionDuration / duration).toFloat() + logger.logCreate(name, start) + var isComplete = true + + fun stepToValue(step: TransitionStep): Float? { + val value = (step.value - start) * chunks + return when (step.transitionState) { + // When starting, make sure to always emit. If a transition is started from the + // middle, it is possible this animation is being skipped but we need to inform + // the ViewModels of the last update + STARTED -> { + isComplete = false + onStart?.invoke() + max(0f, min(1f, value)) } - else -> null - }?.let { onStep(interpolator.getInterpolation(it)) } - } + // Always send a final value of 1. Because of rounding, [value] may never be + // exactly 1. + RUNNING -> + if (isComplete) { + null + } else if (value >= 1f) { + isComplete = true + 1f + } else if (value >= 0f) { + value + } else { + null + } + else -> null + }?.let { onStep(interpolator.getInterpolation(it)) } + } - return transitionFlow - .map { step -> - when (step.transitionState) { - STARTED -> stepToValue(step) - RUNNING -> stepToValue(step) - CANCELED -> onCancel?.invoke() - FINISHED -> onFinish?.invoke() + return stepFlow + .map { step -> + val value = + when (step.transitionState) { + STARTED -> stepToValue(step) + RUNNING -> stepToValue(step) + CANCELED -> onCancel?.invoke() + FINISHED -> onFinish?.invoke() + } + logger.logTransitionStep(name, step, value) + value } - } - .filterNotNull() - } + .filterNotNull() + .shareIn(scope, SharingStarted.WhileSubscribed()) + } - /** Immediately (after 1ms) emits the given value for every step of the KeyguardTransition. */ - fun immediatelyTransitionTo(value: Float): Flow<Float> { - return createFlow(duration = 1.milliseconds, onStep = { value }, onFinish = { value }) + /** + * Immediately (after 1ms) emits the given value for every step of the KeyguardTransition. + */ + fun immediatelyTransitionTo(value: Float): Flow<Float> { + return sharedFlow(duration = 1.milliseconds, onStep = { value }, onFinish = { value }) + } } } diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/binder/KeyguardRootViewBinder.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/binder/KeyguardRootViewBinder.kt index 51e1f60acd64..0addbd8e18b2 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/binder/KeyguardRootViewBinder.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/binder/KeyguardRootViewBinder.kt @@ -89,7 +89,7 @@ object KeyguardRootViewBinder { vibratorHelper: VibratorHelper?, ): DisposableHandle { var onLayoutChangeListener: OnLayoutChange? = null - val childViews = mutableMapOf<Int, View?>() + val childViews = mutableMapOf<Int, View>() val statusViewId = R.id.keyguard_status_view val burnInLayerId = R.id.burn_in_layer val aodNotificationIconContainerId = R.id.aod_notification_icon_container @@ -114,7 +114,12 @@ object KeyguardRootViewBinder { } if (keyguardBottomAreaRefactor()) { - launch { viewModel.alpha.collect { alpha -> view.alpha = alpha } } + launch { + viewModel.alpha.collect { alpha -> + view.alpha = alpha + childViews[statusViewId]?.alpha = alpha + } + } } if (KeyguardShadeMigrationNssl.isEnabled) { diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/preview/KeyguardPreviewRenderer.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/preview/KeyguardPreviewRenderer.kt index 11872d90cc34..fde535700a1c 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/preview/KeyguardPreviewRenderer.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/preview/KeyguardPreviewRenderer.kt @@ -27,6 +27,8 @@ import android.hardware.display.DisplayManager import android.os.Bundle import android.os.Handler import android.os.IBinder +import android.provider.Settings +import android.util.Log import android.view.ContextThemeWrapper import android.view.Display import android.view.Display.DEFAULT_DISPLAY @@ -47,6 +49,7 @@ import com.android.systemui.biometrics.domain.interactor.UdfpsOverlayInteractor import com.android.systemui.broadcast.BroadcastDispatcher import com.android.systemui.common.ui.ConfigurationState import com.android.systemui.dagger.qualifiers.Application +import com.android.systemui.dagger.qualifiers.Background import com.android.systemui.dagger.qualifiers.Main import com.android.systemui.flags.FeatureFlagsClassic import com.android.systemui.keyguard.shared.KeyguardShadeMigrationNssl @@ -64,6 +67,7 @@ import com.android.systemui.keyguard.ui.viewmodel.KeyguardQuickAffordancesCombin import com.android.systemui.keyguard.ui.viewmodel.KeyguardRootViewModel import com.android.systemui.keyguard.ui.viewmodel.OccludingAppDeviceEntryMessageViewModel import com.android.systemui.monet.ColorScheme +import com.android.systemui.monet.Style import com.android.systemui.plugins.ClockController import com.android.systemui.plugins.FalsingManager import com.android.systemui.res.R @@ -79,13 +83,21 @@ import com.android.systemui.statusbar.lockscreen.LockscreenSmartspaceController import com.android.systemui.statusbar.phone.KeyguardBottomAreaView import com.android.systemui.statusbar.phone.ScreenOffAnimationController import com.android.systemui.temporarydisplay.chipbar.ChipbarCoordinator +import com.android.systemui.util.settings.SecureSettings import dagger.assisted.Assisted import dagger.assisted.AssistedInject import kotlinx.coroutines.CoroutineDispatcher +import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.DisposableHandle import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.Job +import kotlinx.coroutines.cancel import kotlinx.coroutines.flow.flowOf +import kotlinx.coroutines.launch import kotlinx.coroutines.runBlocking +import kotlinx.coroutines.withContext +import org.json.JSONException +import org.json.JSONObject /** Renders the preview of the lock screen. */ class KeyguardPreviewRenderer @@ -93,8 +105,10 @@ class KeyguardPreviewRenderer @AssistedInject constructor( @Application private val context: Context, + @Application applicationScope: CoroutineScope, @Main private val mainDispatcher: CoroutineDispatcher, @Main private val mainHandler: Handler, + @Background private val backgroundDispatcher: CoroutineDispatcher, private val clockViewModel: KeyguardPreviewClockViewModel, private val smartspaceViewModel: KeyguardPreviewSmartspaceViewModel, private val bottomAreaViewModel: KeyguardBottomAreaViewModel, @@ -118,6 +132,7 @@ constructor( private val chipbarCoordinator: ChipbarCoordinator, private val screenOffAnimationController: ScreenOffAnimationController, private val shadeInteractor: ShadeInteractor, + private val secureSettings: SecureSettings, ) { val hostToken: IBinder? = bundle.getBinder(KEY_HOST_TOKEN) private val width: Int = bundle.getInt(KEY_VIEW_WIDTH) @@ -156,7 +171,13 @@ constructor( private val shortcutsBindings = mutableSetOf<KeyguardQuickAffordanceViewBinder.Binding>() + private val coroutineScope: CoroutineScope + private var themeStyle: Style? = null + init { + coroutineScope = CoroutineScope(applicationScope.coroutineContext + Job()) + disposables.add(DisposableHandle { coroutineScope.cancel() }) + if (keyguardBottomAreaRefactor()) { quickAffordancesCombinedViewModel.enablePreviewMode( initiallySelectedSlotId = @@ -553,29 +574,54 @@ constructor( } private fun onClockChanged() { - val clock = clockRegistry.createCurrentClock() - clockController.clock = clock - - if (clockRegistry.seedColor == null) { - // Seed color null means users do override any color on the clock. The default color - // will need to use wallpaper's extracted color and consider if the wallpaper's color - // is dark or a light. - // TODO(b/277832214) we can potentially simplify this code by checking for - // wallpaperColors being null in the if clause above and removing the many ?. - val wallpaperColorScheme = wallpaperColors?.let { ColorScheme(it, darkTheme = false) } - val lightClockColor = wallpaperColorScheme?.accent1?.s100 - val darkClockColor = wallpaperColorScheme?.accent2?.s600 - - // Note that when [wallpaperColors] is null, isWallpaperDark is true. - val isWallpaperDark: Boolean = - (wallpaperColors?.colorHints?.and(WallpaperColors.HINT_SUPPORTS_DARK_TEXT)) == 0 - clock.events.onSeedColorChanged( - if (isWallpaperDark) lightClockColor else darkClockColor - ) + coroutineScope.launch { + val clock = clockRegistry.createCurrentClock() + clockController.clock = clock + + val colors = wallpaperColors + if (clockRegistry.seedColor == null && colors != null) { + // Seed color null means users do not override any color on the clock. The default + // color will need to use wallpaper's extracted color and consider if the + // wallpaper's color is dark or light. + val style = themeStyle ?: fetchThemeStyleFromSetting().also { themeStyle = it } + val wallpaperColorScheme = ColorScheme(colors, darkTheme = false, style) + val lightClockColor = wallpaperColorScheme.accent1.s100 + val darkClockColor = wallpaperColorScheme.accent2.s600 + + // Note that when [wallpaperColors] is null, isWallpaperDark is true. + val isWallpaperDark: Boolean = + (colors.colorHints.and(WallpaperColors.HINT_SUPPORTS_DARK_TEXT)) == 0 + clock.events.onSeedColorChanged( + if (isWallpaperDark) lightClockColor else darkClockColor + ) + } + + updateLargeClock(clock) + updateSmallClock(clock) } + } - updateLargeClock(clock) - updateSmallClock(clock) + private suspend fun fetchThemeStyleFromSetting(): Style { + val overlayPackageJson = + withContext(backgroundDispatcher) { + secureSettings.getString( + Settings.Secure.THEME_CUSTOMIZATION_OVERLAY_PACKAGES, + ) + } + return if (!overlayPackageJson.isNullOrEmpty()) { + try { + val jsonObject = JSONObject(overlayPackageJson) + Style.valueOf(jsonObject.getString(OVERLAY_CATEGORY_THEME_STYLE)) + } catch (e: (JSONException)) { + Log.i(TAG, "Failed to parse THEME_CUSTOMIZATION_OVERLAY_PACKAGES.", e) + Style.TONAL_SPOT + } catch (e: IllegalArgumentException) { + Log.i(TAG, "Failed to parse THEME_CUSTOMIZATION_OVERLAY_PACKAGES.", e) + Style.TONAL_SPOT + } + } else { + Style.TONAL_SPOT + } } private fun updateLargeClock(clock: ClockController) { @@ -601,6 +647,8 @@ constructor( } companion object { + private const val TAG = "KeyguardPreviewRenderer" + private const val OVERLAY_CATEGORY_THEME_STYLE = "android.theme.customization.theme_style" private const val KEY_HOST_TOKEN = "host_token" private const val KEY_VIEW_WIDTH = "width" private const val KEY_VIEW_HEIGHT = "height" diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AlternateBouncerViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AlternateBouncerViewModel.kt index bb7bcd99ffb6..8e729f76e096 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AlternateBouncerViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AlternateBouncerViewModel.kt @@ -38,15 +38,17 @@ class AlternateBouncerViewModel constructor( private val statusBarKeyguardViewManager: StatusBarKeyguardViewManager, transitionInteractor: KeyguardTransitionInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) { // When we're fully transitioned to the AlternateBouncer, the alpha of the scrim should be: private val alternateBouncerScrimAlpha = .66f private val toAlternateBouncerTransition = - KeyguardTransitionAnimationFlow( - transitionDuration = TRANSITION_DURATION_MS, - transitionFlow = transitionInteractor.anyStateToAlternateBouncerTransition, + animationFlow + .setup( + duration = TRANSITION_DURATION_MS, + stepFlow = transitionInteractor.anyStateToAlternateBouncerTransition, ) - .createFlow( + .sharedFlow( duration = TRANSITION_DURATION_MS, onStep = { it }, onFinish = { 1f }, @@ -55,11 +57,12 @@ constructor( interpolator = Interpolators.FAST_OUT_SLOW_IN, ) private val fromAlternateBouncerTransition = - KeyguardTransitionAnimationFlow( - transitionDuration = TRANSITION_DURATION_MS, - transitionFlow = transitionInteractor.transitionStepsFromState(ALTERNATE_BOUNCER), + animationFlow + .setup( + TRANSITION_DURATION_MS, + transitionInteractor.transitionStepsFromState(ALTERNATE_BOUNCER), ) - .createFlow( + .sharedFlow( duration = TRANSITION_DURATION_MS, onStep = { 1f - it }, // Reset on cancel diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AodToGoneTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AodToGoneTransitionViewModel.kt index 4d2af0c7bd4d..2b145216cb80 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AodToGoneTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AodToGoneTransitionViewModel.kt @@ -32,12 +32,13 @@ class AodToGoneTransitionViewModel @Inject constructor( interactor: KeyguardTransitionInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = FromAodTransitionInteractor.TO_GONE_DURATION, - transitionFlow = interactor.transition(KeyguardState.AOD, KeyguardState.GONE), + animationFlow.setup( + duration = FromAodTransitionInteractor.TO_GONE_DURATION, + stepFlow = interactor.transition(KeyguardState.AOD, KeyguardState.GONE), ) override val deviceEntryParentViewAlpha = transitionAnimation.immediatelyTransitionTo(0f) diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AodToLockscreenTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AodToLockscreenTransitionViewModel.kt index 1864437a7d11..5e552e1fe00f 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AodToLockscreenTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AodToLockscreenTransitionViewModel.kt @@ -39,24 +39,25 @@ class AodToLockscreenTransitionViewModel constructor( interactor: KeyguardTransitionInteractor, deviceEntryUdfpsInteractor: DeviceEntryUdfpsInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = TO_LOCKSCREEN_DURATION, - transitionFlow = interactor.aodToLockscreenTransition, + animationFlow.setup( + duration = TO_LOCKSCREEN_DURATION, + stepFlow = interactor.aodToLockscreenTransition, ) /** Ensure alpha is set to be visible */ val lockscreenAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 500.milliseconds, onStart = { 1f }, onStep = { 1f }, ) val shortcutsAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 167.milliseconds, startTime = 67.milliseconds, onStep = { it }, @@ -67,7 +68,7 @@ constructor( deviceEntryUdfpsInteractor.isUdfpsSupported.flatMapLatest { isUdfps -> if (isUdfps) { // fade in - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { it }, onFinish = { 1f }, diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AodToOccludedTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AodToOccludedTransitionViewModel.kt index 06661d0a466b..d283af359b06 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AodToOccludedTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/AodToOccludedTransitionViewModel.kt @@ -30,11 +30,12 @@ class AodToOccludedTransitionViewModel @Inject constructor( interactor: KeyguardTransitionInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = FromAodTransitionInteractor.TO_OCCLUDED_DURATION, - transitionFlow = interactor.transition(KeyguardState.AOD, KeyguardState.OCCLUDED), + animationFlow.setup( + duration = FromAodTransitionInteractor.TO_OCCLUDED_DURATION, + stepFlow = interactor.transition(KeyguardState.AOD, KeyguardState.OCCLUDED), ) override val deviceEntryParentViewAlpha = transitionAnimation.immediatelyTransitionTo(0f) diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/BouncerToGoneFlows.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/BouncerToGoneFlows.kt index da74f2fa061e..41dc15778b0c 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/BouncerToGoneFlows.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/BouncerToGoneFlows.kt @@ -47,6 +47,7 @@ constructor( private val keyguardDismissActionInteractor: Lazy<KeyguardDismissActionInteractor>, private val featureFlags: FeatureFlagsClassic, private val shadeInteractor: ShadeInteractor, + private val animationFlow: KeyguardTransitionAnimationFlow, ) { /** Common fade for scrim alpha values during *BOUNCER->GONE */ fun scrimAlpha(duration: Duration, fromState: KeyguardState): Flow<ScrimAlpha> { @@ -73,14 +74,14 @@ constructor( var leaveShadeOpen: Boolean = false var willRunDismissFromKeyguard: Boolean = false val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = duration, - transitionFlow = interactor.transition(fromState, GONE) + animationFlow.setup( + duration = duration, + stepFlow = interactor.transition(fromState, GONE) ) return shadeInteractor.shadeExpansion.flatMapLatest { shadeExpansion -> transitionAnimation - .createFlow( + .sharedFlow( duration = duration, interpolator = EMPHASIZED_ACCELERATE, onStart = { diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DeviceEntryIconViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DeviceEntryIconViewModel.kt index 5b5a10380a5b..bd6aae8f2dcb 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DeviceEntryIconViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DeviceEntryIconViewModel.kt @@ -57,7 +57,6 @@ constructor( private val sceneContainerFlags: SceneContainerFlags, private val keyguardViewController: Lazy<KeyguardViewController>, private val deviceEntryHapticsInteractor: DeviceEntryHapticsInteractor, - udfpsInteractor: DeviceEntryUdfpsInteractor, private val deviceEntryInteractor: DeviceEntryInteractor, ) { private val intEvaluator = IntEvaluator() @@ -149,7 +148,7 @@ constructor( } val iconType: Flow<DeviceEntryIconView.IconType> = combine( - udfpsInteractor.isListeningForUdfps, + deviceEntryUdfpsInteractor.isListeningForUdfps, deviceEntryInteractor.isUnlocked, ) { isListeningForUdfps, isUnlocked -> if (isUnlocked) { diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DozingToLockscreenTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DozingToLockscreenTransitionViewModel.kt index a728a2810916..0b34326bc83d 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DozingToLockscreenTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DozingToLockscreenTransitionViewModel.kt @@ -35,15 +35,16 @@ class DozingToLockscreenTransitionViewModel @Inject constructor( interactor: KeyguardTransitionInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { - private val transitionAnimation: KeyguardTransitionAnimationFlow = - KeyguardTransitionAnimationFlow( - transitionDuration = FromDozingTransitionInteractor.TO_LOCKSCREEN_DURATION, - transitionFlow = interactor.dozingToLockscreenTransition, + private val transitionAnimation = + animationFlow.setup( + duration = FromDozingTransitionInteractor.TO_LOCKSCREEN_DURATION, + stepFlow = interactor.dozingToLockscreenTransition, ) val shortcutsAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 150.milliseconds, onStep = { it }, onCancel = { 0f }, diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DreamingHostedToLockscreenTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DreamingHostedToLockscreenTransitionViewModel.kt index 58235ae02abe..8bcf3f8a76d9 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DreamingHostedToLockscreenTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DreamingHostedToLockscreenTransitionViewModel.kt @@ -29,16 +29,17 @@ class DreamingHostedToLockscreenTransitionViewModel @Inject constructor( interactor: KeyguardTransitionInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = TO_LOCKSCREEN_DURATION, - transitionFlow = interactor.dreamingLockscreenHostedToLockscreenTransition + animationFlow.setup( + duration = TO_LOCKSCREEN_DURATION, + stepFlow = interactor.dreamingLockscreenHostedToLockscreenTransition, ) val shortcutsAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { it }, onCancel = { 0f }, diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DreamingToLockscreenTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DreamingToLockscreenTransitionViewModel.kt index f943bdfa7550..5f620afe2dea 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DreamingToLockscreenTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/DreamingToLockscreenTransitionViewModel.kt @@ -45,13 +45,14 @@ constructor( keyguardTransitionInteractor: KeyguardTransitionInteractor, private val fromDreamingTransitionInteractor: FromDreamingTransitionInteractor, private val deviceEntryUdfpsInteractor: DeviceEntryUdfpsInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { fun startTransition() = fromDreamingTransitionInteractor.startToLockscreenTransition() private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = TO_LOCKSCREEN_DURATION, - transitionFlow = keyguardTransitionInteractor.dreamingToLockscreenTransition, + animationFlow.setup( + duration = TO_LOCKSCREEN_DURATION, + stepFlow = keyguardTransitionInteractor.dreamingToLockscreenTransition, ) val transitionEnded = @@ -62,7 +63,7 @@ constructor( /** Dream overlay y-translation on exit */ fun dreamOverlayTranslationY(translatePx: Int): Flow<Float> { - return transitionAnimation.createFlow( + return transitionAnimation.sharedFlow( duration = TO_LOCKSCREEN_DURATION, onStep = { it * translatePx }, interpolator = EMPHASIZED, @@ -71,14 +72,14 @@ constructor( /** Dream overlay views alpha - fade out */ val dreamOverlayAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { 1f - it }, ) /** Lockscreen views y-translation */ fun lockscreenTranslationY(translatePx: Int): Flow<Float> { - return transitionAnimation.createFlow( + return transitionAnimation.sharedFlow( duration = TO_LOCKSCREEN_DURATION, onStep = { value -> -translatePx + value * translatePx }, // Reset on cancel or finish @@ -90,14 +91,14 @@ constructor( /** Lockscreen views alpha */ val lockscreenAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( startTime = 233.milliseconds, duration = 250.milliseconds, onStep = { it }, ) val shortcutsAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( startTime = 233.milliseconds, duration = 250.milliseconds, onStep = { it }, diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToAodTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToAodTransitionViewModel.kt index 62b2281ae473..3f27eb0c73e3 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToAodTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToAodTransitionViewModel.kt @@ -38,17 +38,18 @@ class GoneToAodTransitionViewModel constructor( interactor: KeyguardTransitionInteractor, deviceEntryUdfpsInteractor: DeviceEntryUdfpsInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = TO_AOD_DURATION, - transitionFlow = interactor.goneToAodTransition, + animationFlow.setup( + duration = TO_AOD_DURATION, + stepFlow = interactor.goneToAodTransition, ) /** y-translation from the top of the screen for AOD */ fun enterFromTopTranslationY(translatePx: Int): Flow<Float> { - return transitionAnimation.createFlow( + return transitionAnimation.sharedFlow( startTime = 600.milliseconds, duration = 500.milliseconds, onStart = { translatePx }, @@ -61,7 +62,7 @@ constructor( /** alpha animation upon entering AOD */ val enterFromTopAnimationAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( startTime = 600.milliseconds, duration = 500.milliseconds, onStart = { 0f }, @@ -74,7 +75,7 @@ constructor( if (udfpsEnrolled) { // fade in at the end of the transition to give time for FP to start running // and avoid a flicker of the unlocked icon - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( startTime = 1100.milliseconds, duration = 200.milliseconds, onStep = { it }, diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingLockscreenHostedTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingLockscreenHostedTransitionViewModel.kt index 113f01c0b122..bba790abe807 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingLockscreenHostedTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingLockscreenHostedTransitionViewModel.kt @@ -33,17 +33,18 @@ class GoneToDreamingLockscreenHostedTransitionViewModel @Inject constructor( interactor: KeyguardTransitionInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = TO_DREAMING_DURATION, - transitionFlow = interactor.goneToDreamingLockscreenHostedTransition, + animationFlow.setup( + duration = TO_DREAMING_DURATION, + stepFlow = interactor.goneToDreamingLockscreenHostedTransition, ) /** Lockscreen views alpha - hide immediately */ val lockscreenAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 1.milliseconds, onStep = { 0f }, ) diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingTransitionViewModel.kt index c1357863f3a5..6762ba6298a5 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingTransitionViewModel.kt @@ -31,17 +31,18 @@ class GoneToDreamingTransitionViewModel @Inject constructor( private val interactor: KeyguardTransitionInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = TO_DREAMING_DURATION, - transitionFlow = interactor.goneToDreamingTransition, + animationFlow.setup( + duration = TO_DREAMING_DURATION, + stepFlow = interactor.goneToDreamingTransition, ) /** Lockscreen views y-translation */ fun lockscreenTranslationY(translatePx: Int): Flow<Float> { - return transitionAnimation.createFlow( + return transitionAnimation.sharedFlow( duration = 500.milliseconds, onStep = { it * translatePx }, // Reset on cancel or finish @@ -53,7 +54,7 @@ constructor( /** Lockscreen views alpha */ val lockscreenAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { 1f - it }, ) diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToLockscreenTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToLockscreenTransitionViewModel.kt index 5804a205445c..adae8abfb9c3 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToLockscreenTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/GoneToLockscreenTransitionViewModel.kt @@ -29,16 +29,17 @@ class GoneToLockscreenTransitionViewModel @Inject constructor( interactor: KeyguardTransitionInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = TO_LOCKSCREEN_DURATION, - transitionFlow = interactor.goneToLockscreenTransition + animationFlow.setup( + duration = TO_LOCKSCREEN_DURATION, + stepFlow = interactor.goneToLockscreenTransition ) val shortcutsAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { it }, onCancel = { 0f }, diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardIndicationAreaViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardIndicationAreaViewModel.kt index 2327c028970b..6458edaecd9e 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardIndicationAreaViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardIndicationAreaViewModel.kt @@ -17,6 +17,7 @@ package com.android.systemui.keyguard.ui.viewmodel import com.android.systemui.Flags.keyguardBottomAreaRefactor +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor import com.android.systemui.doze.util.BurnInHelperWrapper import com.android.systemui.keyguard.domain.interactor.KeyguardBottomAreaInteractor import com.android.systemui.keyguard.domain.interactor.KeyguardInteractor @@ -35,10 +36,11 @@ constructor( keyguardBottomAreaViewModel: KeyguardBottomAreaViewModel, private val burnInHelperWrapper: BurnInHelperWrapper, private val shortcutsCombinedViewModel: KeyguardQuickAffordancesCombinedViewModel, + configurationInteractor: ConfigurationInteractor, ) { /** Notifies when a new configuration is set */ - val configurationChange: Flow<Unit> = keyguardInteractor.configurationChange + val configurationChange: Flow<Unit> = configurationInteractor.onAnyConfigurationChange /** An observable for the alpha level for the entire bottom area. */ val alpha: Flow<Float> = keyguardBottomAreaViewModel.alpha @@ -47,17 +49,18 @@ constructor( val isIndicationAreaPadded: Flow<Boolean> = if (keyguardBottomAreaRefactor()) { combine(shortcutsCombinedViewModel.startButton, shortcutsCombinedViewModel.endButton) { - startButtonModel, - endButtonModel -> - startButtonModel.isVisible || endButtonModel.isVisible - } + startButtonModel, + endButtonModel -> + startButtonModel.isVisible || endButtonModel.isVisible + } .distinctUntilChanged() } else { - combine(keyguardBottomAreaViewModel.startButton, keyguardBottomAreaViewModel.endButton) { - startButtonModel, - endButtonModel -> - startButtonModel.isVisible || endButtonModel.isVisible - } + combine( + keyguardBottomAreaViewModel.startButton, + keyguardBottomAreaViewModel.endButton + ) { startButtonModel, endButtonModel -> + startButtonModel.isVisible || endButtonModel.isVisible + } .distinctUntilChanged() } /** An observable for the x-offset by which the indication area should be translated. */ diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardRootViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardRootViewModel.kt index af1705369dbb..889464d59d65 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardRootViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardRootViewModel.kt @@ -17,13 +17,13 @@ package com.android.systemui.keyguard.ui.viewmodel -import android.content.Context import android.util.MathUtils import android.view.View.VISIBLE import com.android.app.animation.Interpolators import com.android.keyguard.KeyguardClockSwitch.LARGE import com.android.systemui.Flags.newAodTransition import com.android.systemui.common.shared.model.NotificationContainerBounds +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor import com.android.systemui.dagger.SysUISingleton import com.android.systemui.deviceentry.domain.interactor.DeviceEntryInteractor import com.android.systemui.flags.FeatureFlagsClassic @@ -34,6 +34,7 @@ import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInterac import com.android.systemui.keyguard.shared.model.BurnInModel import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.KeyguardState.AOD +import com.android.systemui.keyguard.shared.model.KeyguardState.GONE import com.android.systemui.keyguard.shared.model.KeyguardState.LOCKSCREEN import com.android.systemui.plugins.ClockController import com.android.systemui.res.R @@ -64,7 +65,7 @@ import kotlinx.coroutines.flow.onStart class KeyguardRootViewModel @Inject constructor( - private val context: Context, + configurationInteractor: ConfigurationInteractor, private val deviceEntryInteractor: DeviceEntryInteractor, private val dozeParameters: DozeParameters, private val keyguardInteractor: KeyguardInteractor, @@ -74,6 +75,7 @@ constructor( private val keyguardClockViewModel: KeyguardClockViewModel, private val goneToAodTransitionViewModel: GoneToAodTransitionViewModel, private val aodToLockscreenTransitionViewModel: AodToLockscreenTransitionViewModel, + private val occludedToLockscreenTransitionViewModel: OccludedToLockscreenTransitionViewModel, screenOffAnimationController: ScreenOffAnimationController, // TODO(b/310989341): remove after changing migrate_clocks_to_blueprint to aconfig private val featureFlags: FeatureFlagsClassic, @@ -97,14 +99,18 @@ constructor( .filter { it == AOD || it == LOCKSCREEN } .map { VISIBLE } - val goneToAodTransition = keyguardTransitionInteractor.goneToAodTransition + val goneToAodTransition = keyguardTransitionInteractor.transition(from = GONE, to = AOD) /** the shared notification container bounds *on the lockscreen* */ val notificationBounds: StateFlow<NotificationContainerBounds> = keyguardInteractor.notificationContainerBounds /** An observable for the alpha level for the entire keyguard root view. */ - val alpha: Flow<Float> = keyguardInteractor.keyguardAlpha.distinctUntilChanged() + val alpha: Flow<Float> = + merge( + keyguardInteractor.keyguardAlpha.distinctUntilChanged(), + occludedToLockscreenTransitionViewModel.lockscreenAlpha, + ) private fun burnIn(): Flow<BurnInModel> { val dozingAmount: Flow<Float> = @@ -150,22 +156,28 @@ constructor( val burnInLayerAlpha: Flow<Float> = goneToAodTransitionViewModel.enterFromTopAnimationAlpha val translationY: Flow<Float> = - keyguardInteractor.configurationChange.flatMapLatest { _ -> - val enterFromTopAmount = - context.resources.getDimensionPixelSize( - R.dimen.keyguard_enter_from_top_translation_y - ) - combine( - keyguardInteractor.keyguardTranslationY.onStart { emit(0f) }, - burnIn().map { it.translationY.toFloat() }.onStart { emit(0f) }, - goneToAodTransitionViewModel.enterFromTopTranslationY(enterFromTopAmount).onStart { - emit(0f) - }, - ) { keyguardTransitionY, burnInTranslationY, goneToAodTransitionTranslationY -> - // All 3 values need to be combined for a smooth translation - keyguardTransitionY + burnInTranslationY + goneToAodTransitionTranslationY + configurationInteractor + .dimensionPixelSize(R.dimen.keyguard_enter_from_top_translation_y) + .flatMapLatest { enterFromTopAmount -> + combine( + keyguardInteractor.keyguardTranslationY.onStart { emit(0f) }, + burnIn().map { it.translationY.toFloat() }.onStart { emit(0f) }, + goneToAodTransitionViewModel + .enterFromTopTranslationY(enterFromTopAmount) + .onStart { emit(0f) }, + occludedToLockscreenTransitionViewModel.lockscreenTranslationY, + ) { + keyguardTransitionY, + burnInTranslationY, + goneToAodTransitionTranslationY, + occludedToLockscreenTransitionTranslationY -> + // All values need to be combined for a smooth translation + keyguardTransitionY + + burnInTranslationY + + goneToAodTransitionTranslationY + + occludedToLockscreenTransitionTranslationY + } } - } val translationX: Flow<Float> = burnIn().map { it.translationX.toFloat() } diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToAodTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToAodTransitionViewModel.kt index 8e8fd75cc1c0..65614f47b120 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToAodTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToAodTransitionViewModel.kt @@ -39,19 +39,20 @@ constructor( interactor: KeyguardTransitionInteractor, deviceEntryUdfpsInteractor: DeviceEntryUdfpsInteractor, shadeDependentFlows: ShadeDependentFlows, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = FromLockscreenTransitionInteractor.TO_AOD_DURATION, - transitionFlow = interactor.lockscreenToAodTransition, + animationFlow.setup( + duration = FromLockscreenTransitionInteractor.TO_AOD_DURATION, + stepFlow = interactor.lockscreenToAodTransition, ) val deviceEntryBackgroundViewAlpha: Flow<Float> = shadeDependentFlows.transitionFlow( flowWhenShadeIsExpanded = transitionAnimation.immediatelyTransitionTo(0f), flowWhenShadeIsNotExpanded = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 300.milliseconds, onStep = { 1 - it }, onFinish = { 0f }, @@ -59,7 +60,7 @@ constructor( ) val shortcutsAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { 1 - it }, onFinish = { 0f }, @@ -72,7 +73,7 @@ constructor( if (isUdfpsEnrolledAndEnabled) { shadeDependentFlows.transitionFlow( flowWhenShadeIsExpanded = // fade in - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 300.milliseconds, onStep = { it }, onFinish = { 1f }, @@ -83,7 +84,7 @@ constructor( shadeDependentFlows.transitionFlow( flowWhenShadeIsExpanded = transitionAnimation.immediatelyTransitionTo(0f), flowWhenShadeIsNotExpanded = // fade out - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 200.milliseconds, onStep = { 1f - it }, onFinish = { 0f }, diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDozingTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDozingTransitionViewModel.kt index 263ed11503ba..accb20c91f98 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDozingTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDozingTransitionViewModel.kt @@ -29,16 +29,17 @@ class LockscreenToDozingTransitionViewModel @Inject constructor( interactor: KeyguardTransitionInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = TO_DOZING_DURATION, - transitionFlow = interactor.lockscreenToDozingTransition + animationFlow.setup( + duration = TO_DOZING_DURATION, + stepFlow = interactor.lockscreenToDozingTransition ) val shortcutsAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { 1 - it }, onFinish = { 0f }, diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingHostedTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingHostedTransitionViewModel.kt index 17015056bda0..c649b12b71e4 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingHostedTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingHostedTransitionViewModel.kt @@ -29,16 +29,17 @@ class LockscreenToDreamingHostedTransitionViewModel @Inject constructor( interactor: KeyguardTransitionInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = TO_DREAMING_HOSTED_DURATION, - transitionFlow = interactor.lockscreenToDreamingLockscreenHostedTransition + animationFlow.setup( + duration = TO_DREAMING_HOSTED_DURATION, + stepFlow = interactor.lockscreenToDreamingLockscreenHostedTransition ) val shortcutsAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { 1 - it }, onFinish = { 0f }, diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingTransitionViewModel.kt index 401c0ff76c29..7f75b547d717 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingTransitionViewModel.kt @@ -36,16 +36,17 @@ class LockscreenToDreamingTransitionViewModel constructor( interactor: KeyguardTransitionInteractor, shadeDependentFlows: ShadeDependentFlows, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = TO_DREAMING_DURATION, - transitionFlow = interactor.lockscreenToDreamingTransition, + animationFlow.setup( + duration = TO_DREAMING_DURATION, + stepFlow = interactor.lockscreenToDreamingTransition, ) /** Lockscreen views y-translation */ fun lockscreenTranslationY(translatePx: Int): Flow<Float> { - return transitionAnimation.createFlow( + return transitionAnimation.sharedFlow( duration = 500.milliseconds, onStep = { it * translatePx }, // Reset on cancel or finish @@ -57,13 +58,13 @@ constructor( /** Lockscreen views alpha */ val lockscreenAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { 1f - it }, ) val shortcutsAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { 1 - it }, onFinish = { 0f }, diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToGoneTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToGoneTransitionViewModel.kt index cfb4bf59c8a8..9e197138d0b2 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToGoneTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToGoneTransitionViewModel.kt @@ -36,16 +36,17 @@ class LockscreenToGoneTransitionViewModel @Inject constructor( interactor: KeyguardTransitionInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = FromLockscreenTransitionInteractor.TO_GONE_DURATION, - transitionFlow = interactor.transition(KeyguardState.LOCKSCREEN, KeyguardState.GONE), + animationFlow.setup( + duration = FromLockscreenTransitionInteractor.TO_GONE_DURATION, + stepFlow = interactor.transition(KeyguardState.LOCKSCREEN, KeyguardState.GONE), ) val shortcutsAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { 1 - it }, onFinish = { 0f }, diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToOccludedTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToOccludedTransitionViewModel.kt index a6136f95d0f6..9db0b775cd40 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToOccludedTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToOccludedTransitionViewModel.kt @@ -17,14 +17,17 @@ package com.android.systemui.keyguard.ui.viewmodel import com.android.app.animation.Interpolators.EMPHASIZED_ACCELERATE +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor import com.android.systemui.dagger.SysUISingleton import com.android.systemui.keyguard.domain.interactor.FromLockscreenTransitionInteractor.Companion.TO_OCCLUDED_DURATION import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractor import com.android.systemui.keyguard.ui.KeyguardTransitionAnimationFlow import com.android.systemui.keyguard.ui.transitions.DeviceEntryIconTransition +import com.android.systemui.res.R import javax.inject.Inject import kotlin.time.Duration.Companion.milliseconds import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.flatMapLatest /** * Breaks down LOCKSCREEN->OCCLUDED transition into discrete steps for corresponding views to @@ -36,22 +39,26 @@ class LockscreenToOccludedTransitionViewModel constructor( interactor: KeyguardTransitionInteractor, shadeDependentFlows: ShadeDependentFlows, + configurationInteractor: ConfigurationInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { + private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = TO_OCCLUDED_DURATION, - transitionFlow = interactor.lockscreenToOccludedTransition, + animationFlow.setup( + duration = TO_OCCLUDED_DURATION, + stepFlow = interactor.lockscreenToOccludedTransition, ) /** Lockscreen views alpha */ val lockscreenAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { 1f - it }, + name = "LOCKSCREEN->OCCLUDED: lockscreenAlpha", ) val shortcutsAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { 1 - it }, onFinish = { 0f }, @@ -59,16 +66,19 @@ constructor( ) /** Lockscreen views y-translation */ - fun lockscreenTranslationY(translatePx: Int): Flow<Float> { - return transitionAnimation.createFlow( - duration = TO_OCCLUDED_DURATION, - onStep = { value -> value * translatePx }, - // Reset on cancel or finish - onFinish = { 0f }, - onCancel = { 0f }, - interpolator = EMPHASIZED_ACCELERATE, - ) - } + val lockscreenTranslationY: Flow<Float> = + configurationInteractor + .dimensionPixelSize(R.dimen.lockscreen_to_occluded_transition_lockscreen_translation_y) + .flatMapLatest { translatePx -> + transitionAnimation.sharedFlow( + duration = TO_OCCLUDED_DURATION, + onStep = { value -> value * translatePx }, + // Reset on cancel or finish + onFinish = { 0f }, + onCancel = { 0f }, + interpolator = EMPHASIZED_ACCELERATE, + ) + } override val deviceEntryParentViewAlpha: Flow<Float> = shadeDependentFlows.transitionFlow( diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToPrimaryBouncerTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToPrimaryBouncerTransitionViewModel.kt index 07dd4ef49c5d..52e3257f8e18 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToPrimaryBouncerTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToPrimaryBouncerTransitionViewModel.kt @@ -39,11 +39,12 @@ class LockscreenToPrimaryBouncerTransitionViewModel constructor( interactor: KeyguardTransitionInteractor, shadeDependentFlows: ShadeDependentFlows, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = FromLockscreenTransitionInteractor.TO_PRIMARY_BOUNCER_DURATION, - transitionFlow = + animationFlow.setup( + duration = FromLockscreenTransitionInteractor.TO_PRIMARY_BOUNCER_DURATION, + stepFlow = interactor.transition(KeyguardState.LOCKSCREEN, KeyguardState.PRIMARY_BOUNCER), ) @@ -55,7 +56,7 @@ constructor( override val deviceEntryParentViewAlpha: Flow<Float> = shadeDependentFlows.transitionFlow( flowWhenShadeIsNotExpanded = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { 1f - it }, onFinish = { 0f } diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToAodTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToAodTransitionViewModel.kt index f7cff9b28542..ed5e83c44640 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToAodTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToAodTransitionViewModel.kt @@ -37,11 +37,12 @@ class OccludedToAodTransitionViewModel constructor( interactor: KeyguardTransitionInteractor, deviceEntryUdfpsInteractor: DeviceEntryUdfpsInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = FromOccludedTransitionInteractor.TO_AOD_DURATION, - transitionFlow = interactor.transition(KeyguardState.OCCLUDED, KeyguardState.AOD), + animationFlow.setup( + duration = FromOccludedTransitionInteractor.TO_AOD_DURATION, + stepFlow = interactor.transition(KeyguardState.OCCLUDED, KeyguardState.AOD), ) val deviceEntryBackgroundViewAlpha: Flow<Float> = diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToLockscreenTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToLockscreenTransitionViewModel.kt index 58be0934beca..4c24f83200b2 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToLockscreenTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToLockscreenTransitionViewModel.kt @@ -17,12 +17,14 @@ package com.android.systemui.keyguard.ui.viewmodel import com.android.app.animation.Interpolators.EMPHASIZED_DECELERATE +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor import com.android.systemui.dagger.SysUISingleton import com.android.systemui.deviceentry.domain.interactor.DeviceEntryUdfpsInteractor import com.android.systemui.keyguard.domain.interactor.FromOccludedTransitionInteractor.Companion.TO_LOCKSCREEN_DURATION import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractor import com.android.systemui.keyguard.ui.KeyguardTransitionAnimationFlow import com.android.systemui.keyguard.ui.transitions.DeviceEntryIconTransition +import com.android.systemui.res.R import javax.inject.Inject import kotlin.time.Duration.Companion.milliseconds import kotlinx.coroutines.ExperimentalCoroutinesApi @@ -40,26 +42,32 @@ class OccludedToLockscreenTransitionViewModel @Inject constructor( interactor: KeyguardTransitionInteractor, - deviceEntryUdfpsInteractor: DeviceEntryUdfpsInteractor + deviceEntryUdfpsInteractor: DeviceEntryUdfpsInteractor, + configurationInteractor: ConfigurationInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { + private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = TO_LOCKSCREEN_DURATION, - transitionFlow = interactor.occludedToLockscreenTransition, + animationFlow.setup( + duration = TO_LOCKSCREEN_DURATION, + stepFlow = interactor.occludedToLockscreenTransition, ) /** Lockscreen views y-translation */ - fun lockscreenTranslationY(translatePx: Int): Flow<Float> { - return transitionAnimation.createFlow( - duration = TO_LOCKSCREEN_DURATION, - onStep = { value -> -translatePx + value * translatePx }, - interpolator = EMPHASIZED_DECELERATE, - onCancel = { 0f }, - ) - } + val lockscreenTranslationY: Flow<Float> = + configurationInteractor + .dimensionPixelSize(R.dimen.occluded_to_lockscreen_transition_lockscreen_translation_y) + .flatMapLatest { translatePx -> + transitionAnimation.sharedFlow( + duration = TO_LOCKSCREEN_DURATION, + onStep = { value -> -translatePx + value * translatePx }, + interpolator = EMPHASIZED_DECELERATE, + onCancel = { 0f }, + ) + } val shortcutsAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { it }, onCancel = { 0f }, @@ -67,10 +75,12 @@ constructor( /** Lockscreen views alpha */ val lockscreenAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( startTime = 233.milliseconds, duration = 250.milliseconds, onStep = { it }, + onStart = { 0f }, + name = "OCCLUDED->LOCKSCREEN: lockscreenAlpha", ) val deviceEntryBackgroundViewAlpha: Flow<Float> = diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/OffToLockscreenTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/OffToLockscreenTransitionViewModel.kt index c3bc799435a8..93482ea162bb 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/OffToLockscreenTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/OffToLockscreenTransitionViewModel.kt @@ -28,16 +28,17 @@ class OffToLockscreenTransitionViewModel @Inject constructor( interactor: KeyguardTransitionInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = 250.milliseconds, - transitionFlow = interactor.offToLockscreenTransition + animationFlow.setup( + duration = 250.milliseconds, + stepFlow = interactor.offToLockscreenTransition ) val shortcutsAlpha: Flow<Float> = - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 250.milliseconds, onStep = { it }, onCancel = { 0f }, diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToAodTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToAodTransitionViewModel.kt index 05a6d5810be3..b0e2aa2d4765 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToAodTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToAodTransitionViewModel.kt @@ -41,12 +41,12 @@ class PrimaryBouncerToAodTransitionViewModel constructor( interactor: KeyguardTransitionInteractor, deviceEntryUdfpsInteractor: DeviceEntryUdfpsInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = FromPrimaryBouncerTransitionInteractor.TO_AOD_DURATION, - transitionFlow = - interactor.transition(KeyguardState.PRIMARY_BOUNCER, KeyguardState.AOD), + animationFlow.setup( + duration = FromPrimaryBouncerTransitionInteractor.TO_AOD_DURATION, + stepFlow = interactor.transition(KeyguardState.PRIMARY_BOUNCER, KeyguardState.AOD), ) val deviceEntryBackgroundViewAlpha: Flow<Float> = @@ -62,7 +62,7 @@ constructor( deviceEntryUdfpsInteractor.isUdfpsEnrolledAndEnabled.flatMapLatest { isUdfpsEnrolledAndEnabled -> if (isUdfpsEnrolledAndEnabled) { - transitionAnimation.createFlow( + transitionAnimation.sharedFlow( duration = 300.milliseconds, onStep = { it }, onFinish = { 1f }, diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToGoneTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToGoneTransitionViewModel.kt index 0e95be20d059..9dbe97fd1c20 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToGoneTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToGoneTransitionViewModel.kt @@ -50,11 +50,12 @@ constructor( keyguardDismissActionInteractor: Lazy<KeyguardDismissActionInteractor>, featureFlags: FeatureFlagsClassic, bouncerToGoneFlows: BouncerToGoneFlows, + animationFlow: KeyguardTransitionAnimationFlow, ) { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = TO_GONE_DURATION, - transitionFlow = interactor.transition(PRIMARY_BOUNCER, GONE) + animationFlow.setup( + duration = TO_GONE_DURATION, + stepFlow = interactor.transition(PRIMARY_BOUNCER, GONE) ) private var leaveShadeOpen: Boolean = false @@ -71,7 +72,7 @@ constructor( createBouncerAlphaFlow(primaryBouncerInteractor::willRunDismissFromKeyguard) } private fun createBouncerAlphaFlow(willRunAnimationOnKeyguard: () -> Boolean): Flow<Float> { - return transitionAnimation.createFlow( + return transitionAnimation.sharedFlow( duration = 200.milliseconds, onStart = { willRunDismissFromKeyguard = willRunAnimationOnKeyguard() }, onStep = { @@ -95,7 +96,7 @@ constructor( createLockscreenAlpha(primaryBouncerInteractor::willRunDismissFromKeyguard) } private fun createLockscreenAlpha(willRunAnimationOnKeyguard: () -> Boolean): Flow<Float> { - return transitionAnimation.createFlow( + return transitionAnimation.sharedFlow( duration = 50.milliseconds, onStart = { leaveShadeOpen = statusBarStateController.leaveOpenOnKeyguardHide() diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToLockscreenTransitionViewModel.kt b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToLockscreenTransitionViewModel.kt index 7ef8374023fb..b2eed60e0a9e 100644 --- a/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToLockscreenTransitionViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToLockscreenTransitionViewModel.kt @@ -41,11 +41,12 @@ class PrimaryBouncerToLockscreenTransitionViewModel constructor( interactor: KeyguardTransitionInteractor, deviceEntryUdfpsInteractor: DeviceEntryUdfpsInteractor, + animationFlow: KeyguardTransitionAnimationFlow, ) : DeviceEntryIconTransition { private val transitionAnimation = - KeyguardTransitionAnimationFlow( - transitionDuration = FromPrimaryBouncerTransitionInteractor.TO_LOCKSCREEN_DURATION, - transitionFlow = + animationFlow.setup( + duration = FromPrimaryBouncerTransitionInteractor.TO_LOCKSCREEN_DURATION, + stepFlow = interactor.transition(KeyguardState.PRIMARY_BOUNCER, KeyguardState.LOCKSCREEN), ) diff --git a/packages/SystemUI/src/com/android/systemui/log/dagger/KeyguardTransitionAnimationLog.kt b/packages/SystemUI/src/com/android/systemui/log/dagger/KeyguardTransitionAnimationLog.kt new file mode 100644 index 000000000000..ef0658867801 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/log/dagger/KeyguardTransitionAnimationLog.kt @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2023 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.systemui.log.dagger + +import javax.inject.Qualifier + +/** + * A [com.android.systemui.log.LogBuffer] for keyguard transition animations. Should be used mostly + * for adding temporary logs or logging from smaller classes when creating new separate log class + * might be an overkill. + */ +@Qualifier +@MustBeDocumented +@Retention(AnnotationRetention.RUNTIME) +annotation class KeyguardTransitionAnimationLog diff --git a/packages/SystemUI/src/com/android/systemui/log/dagger/LogModule.java b/packages/SystemUI/src/com/android/systemui/log/dagger/LogModule.java index 0b3bbb5c3d08..dc55179f53f8 100644 --- a/packages/SystemUI/src/com/android/systemui/log/dagger/LogModule.java +++ b/packages/SystemUI/src/com/android/systemui/log/dagger/LogModule.java @@ -525,6 +525,16 @@ public class LogModule { } /** + * Provides a {@link LogBuffer} for keyguard transition animation logs. + */ + @Provides + @SysUISingleton + @KeyguardTransitionAnimationLog + public static LogBuffer provideKeyguardTransitionAnimationLogBuffer(LogBufferFactory factory) { + return factory.create("KeyguardTransitionAnimationLog", 250); + } + + /** * Provides a {@link LogBuffer} for Scrims like LightRevealScrim. */ @Provides diff --git a/packages/SystemUI/src/com/android/systemui/screenrecord/ScreenRecordPermissionDialogDelegate.kt b/packages/SystemUI/src/com/android/systemui/screenrecord/ScreenRecordPermissionDialogDelegate.kt index 56ada3a9f6e8..10d51a59e44c 100644 --- a/packages/SystemUI/src/com/android/systemui/screenrecord/ScreenRecordPermissionDialogDelegate.kt +++ b/packages/SystemUI/src/com/android/systemui/screenrecord/ScreenRecordPermissionDialogDelegate.kt @@ -28,6 +28,7 @@ import android.view.MotionEvent.ACTION_MOVE import android.view.View import android.view.View.GONE import android.view.View.VISIBLE +import android.view.accessibility.AccessibilityNodeInfo import android.widget.AdapterView import android.widget.ArrayAdapter import android.widget.Spinner @@ -134,6 +135,19 @@ class ScreenRecordPermissionDialogDelegate( options.setOnItemClickListenerInt { _: AdapterView<*>?, _: View?, _: Int, _: Long -> audioSwitch.isChecked = true } + + // disable redundant Touch & Hold accessibility action for Switch Access + options.accessibilityDelegate = + object : View.AccessibilityDelegate() { + override fun onInitializeAccessibilityNodeInfo( + host: View, + info: AccessibilityNodeInfo + ) { + info.removeAction(AccessibilityNodeInfo.AccessibilityAction.ACTION_LONG_CLICK) + super.onInitializeAccessibilityNodeInfo(host, info) + } + } + options.isLongClickable = false } override fun onItemSelected(adapterView: AdapterView<*>?, view: View, pos: Int, id: Long) { diff --git a/packages/SystemUI/src/com/android/systemui/settings/brightness/BrightnessDialog.java b/packages/SystemUI/src/com/android/systemui/settings/brightness/BrightnessDialog.java index d382b7ae2bf0..d13edf01cc4a 100644 --- a/packages/SystemUI/src/com/android/systemui/settings/brightness/BrightnessDialog.java +++ b/packages/SystemUI/src/com/android/systemui/settings/brightness/BrightnessDialog.java @@ -21,8 +21,6 @@ import static android.view.ViewGroup.LayoutParams.MATCH_PARENT; import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT; import static android.view.WindowManagerPolicyConstants.EXTRA_FROM_BRIGHTNESS_KEY; -import static com.android.systemui.util.kotlin.JavaAdapterKt.collectFlow; - import android.app.Activity; import android.content.res.Configuration; import android.graphics.Rect; @@ -89,17 +87,6 @@ public class BrightnessDialog extends Activity { if (mShadeInteractor.isQsExpanded().getValue()) { finish(); } - - View view = findViewById(R.id.brightness_mirror_container); - if (view != null) { - collectFlow(view, mShadeInteractor.isQsExpanded(), this::onShadeStateChange); - } - } - - private void onShadeStateChange(boolean isQsExpanded) { - if (isQsExpanded) { - requestFinish(); - } } private void setWindowAttributes() { diff --git a/packages/SystemUI/src/com/android/systemui/shade/NotificationPanelViewController.java b/packages/SystemUI/src/com/android/systemui/shade/NotificationPanelViewController.java index 30bfe2ab38e1..fa3e172d11f1 100644 --- a/packages/SystemUI/src/com/android/systemui/shade/NotificationPanelViewController.java +++ b/packages/SystemUI/src/com/android/systemui/shade/NotificationPanelViewController.java @@ -563,7 +563,6 @@ public final class NotificationPanelViewController implements ShadeSurface, Dump private boolean mHasLayoutedSinceDown; private float mUpdateFlingVelocity; private boolean mUpdateFlingOnLayout; - private boolean mClosing; private boolean mTouchSlopExceeded; private int mTrackingPointer; private int mTouchSlop; @@ -617,10 +616,8 @@ public final class NotificationPanelViewController implements ShadeSurface, Dump private boolean mIsOcclusionTransitionRunning = false; private boolean mIsGoneToDreamingLockscreenHostedTransitionRunning; private int mDreamingToLockscreenTransitionTranslationY; - private int mOccludedToLockscreenTransitionTranslationY; private int mLockscreenToDreamingTransitionTranslationY; private int mGoneToDreamingTransitionTranslationY; - private int mLockscreenToOccludedTransitionTranslationY; private SplitShadeStateController mSplitShadeStateController; private final Runnable mFlingCollapseRunnable = () -> fling(0, false /* expand */, mNextCollapseSpeedUpFactor, false /* expandBecauseOfFalsing */); @@ -1161,11 +1158,13 @@ public final class NotificationPanelViewController implements ShadeSurface, Dump // Occluded->Lockscreen collectFlow(mView, mKeyguardTransitionInteractor.getOccludedToLockscreenTransition(), mOccludedToLockscreenTransition, mMainDispatcher); - collectFlow(mView, mOccludedToLockscreenTransitionViewModel.getLockscreenAlpha(), + if (!KeyguardShadeMigrationNssl.isEnabled()) { + collectFlow(mView, mOccludedToLockscreenTransitionViewModel.getLockscreenAlpha(), setTransitionAlpha(mNotificationStackScrollLayoutController), mMainDispatcher); - collectFlow(mView, mOccludedToLockscreenTransitionViewModel.lockscreenTranslationY( - mOccludedToLockscreenTransitionTranslationY), - setTransitionY(mNotificationStackScrollLayoutController), mMainDispatcher); + collectFlow(mView, + mOccludedToLockscreenTransitionViewModel.getLockscreenTranslationY(), + setTransitionY(mNotificationStackScrollLayoutController), mMainDispatcher); + } // Lockscreen->Dreaming collectFlow(mView, mKeyguardTransitionInteractor.getLockscreenToDreamingTransition(), @@ -1191,8 +1190,7 @@ public final class NotificationPanelViewController implements ShadeSurface, Dump mLockscreenToOccludedTransition, mMainDispatcher); collectFlow(mView, mLockscreenToOccludedTransitionViewModel.getLockscreenAlpha(), setTransitionAlpha(mNotificationStackScrollLayoutController), mMainDispatcher); - collectFlow(mView, mLockscreenToOccludedTransitionViewModel.lockscreenTranslationY( - mLockscreenToOccludedTransitionTranslationY), + collectFlow(mView, mLockscreenToOccludedTransitionViewModel.getLockscreenTranslationY(), setTransitionY(mNotificationStackScrollLayoutController), mMainDispatcher); // Primary bouncer->Gone (ensures lockscreen content is not visible on successful auth) @@ -1224,14 +1222,10 @@ public final class NotificationPanelViewController implements ShadeSurface, Dump R.dimen.split_shade_scrim_transition_distance); mDreamingToLockscreenTransitionTranslationY = mResources.getDimensionPixelSize( R.dimen.dreaming_to_lockscreen_transition_lockscreen_translation_y); - mOccludedToLockscreenTransitionTranslationY = mResources.getDimensionPixelSize( - R.dimen.occluded_to_lockscreen_transition_lockscreen_translation_y); mLockscreenToDreamingTransitionTranslationY = mResources.getDimensionPixelSize( R.dimen.lockscreen_to_dreaming_transition_lockscreen_translation_y); mGoneToDreamingTransitionTranslationY = mResources.getDimensionPixelSize( R.dimen.gone_to_dreaming_transition_lockscreen_translation_y); - mLockscreenToOccludedTransitionTranslationY = mResources.getDimensionPixelSize( - R.dimen.lockscreen_to_occluded_transition_lockscreen_translation_y); // TODO (b/265193930): remove this and make QsController listen to NotificationPanelViews mQsController.loadDimens(); } @@ -2939,10 +2933,7 @@ public final class NotificationPanelViewController implements ShadeSurface, Dump @VisibleForTesting void setClosing(boolean isClosing) { - if (mClosing != isClosing) { - mClosing = isClosing; - mShadeExpansionStateManager.notifyPanelCollapsingChanged(isClosing); - } + mShadeRepository.setLegacyIsClosing(isClosing); mAmbientState.setIsClosing(isClosing); } @@ -3473,7 +3464,7 @@ public final class NotificationPanelViewController implements ShadeSurface, Dump ipw.print("mHasLayoutedSinceDown="); ipw.println(mHasLayoutedSinceDown); ipw.print("mUpdateFlingVelocity="); ipw.println(mUpdateFlingVelocity); ipw.print("mUpdateFlingOnLayout="); ipw.println(mUpdateFlingOnLayout); - ipw.print("mClosing="); ipw.println(mClosing); + ipw.print("isClosing()="); ipw.println(isClosing()); ipw.print("mTouchSlopExceeded="); ipw.println(mTouchSlopExceeded); ipw.print("mTrackingPointer="); ipw.println(mTrackingPointer); ipw.print("mTouchSlop="); ipw.println(mTouchSlop); @@ -3812,7 +3803,7 @@ public final class NotificationPanelViewController implements ShadeSurface, Dump } private void endClosing() { - if (mClosing) { + if (isClosing()) { setClosing(false); onClosingFinished(); } @@ -3932,7 +3923,7 @@ public final class NotificationPanelViewController implements ShadeSurface, Dump mExpandedHeight = Math.min(h, maxPanelHeight); // If we are closing the panel and we are almost there due to a slow decelerating // interpolator, abort the animation. - if (mExpandedHeight < 1f && mExpandedHeight != 0f && mClosing) { + if (mExpandedHeight < 1f && mExpandedHeight != 0f && isClosing()) { mExpandedHeight = 0f; if (mHeightAnimator != null) { mHeightAnimator.end(); @@ -4007,7 +3998,7 @@ public final class NotificationPanelViewController implements ShadeSurface, Dump @Override public boolean isCollapsing() { - return mClosing || mIsLaunchAnimationRunning; + return isClosing() || mIsLaunchAnimationRunning; } public boolean isTracking() { @@ -4016,7 +4007,7 @@ public final class NotificationPanelViewController implements ShadeSurface, Dump @Override public boolean canBeCollapsed() { - return !isFullyCollapsed() && !isTracking() && !mClosing; + return !isFullyCollapsed() && !isTracking() && !isClosing(); } @Override @@ -4131,7 +4122,7 @@ public final class NotificationPanelViewController implements ShadeSurface, Dump @VisibleForTesting boolean isClosing() { - return mClosing; + return mShadeRepository.getLegacyIsClosing().getValue(); } @Override @@ -4838,15 +4829,17 @@ public final class NotificationPanelViewController implements ShadeSurface, Dump switch (event.getActionMasked()) { case MotionEvent.ACTION_DOWN: - mCentralSurfaces.userActivity(); + if (!KeyguardShadeMigrationNssl.isEnabled()) { + mCentralSurfaces.userActivity(); + } mAnimatingOnDown = mHeightAnimator != null && !mIsSpringBackAnimation; mMinExpandHeight = 0.0f; mDownTime = mSystemClock.uptimeMillis(); - if (mAnimatingOnDown && mClosing) { + if (mAnimatingOnDown && isClosing()) { cancelHeightAnimator(); mTouchSlopExceeded = true; mShadeLog.v("NotificationPanelViewController MotionEvent intercepted:" - + " mAnimatingOnDown: true, mClosing: true"); + + " mAnimatingOnDown: true, isClosing(): true"); return true; } diff --git a/packages/SystemUI/src/com/android/systemui/shade/NotificationShadeWindowViewController.java b/packages/SystemUI/src/com/android/systemui/shade/NotificationShadeWindowViewController.java index cf1dfdc3f701..73537edcc94a 100644 --- a/packages/SystemUI/src/com/android/systemui/shade/NotificationShadeWindowViewController.java +++ b/packages/SystemUI/src/com/android/systemui/shade/NotificationShadeWindowViewController.java @@ -311,6 +311,9 @@ public class NotificationShadeWindowViewController implements Dumpable { mTouchActive = true; mTouchCancelled = false; mDownEvent = ev; + if (KeyguardShadeMigrationNssl.isEnabled()) { + mService.userActivity(); + } } else if (ev.getActionMasked() == MotionEvent.ACTION_UP || ev.getActionMasked() == MotionEvent.ACTION_CANCEL) { mTouchActive = false; diff --git a/packages/SystemUI/src/com/android/systemui/shade/ShadeEmptyImplModule.kt b/packages/SystemUI/src/com/android/systemui/shade/ShadeEmptyImplModule.kt index 53eccfdf70d5..832fefc33ae0 100644 --- a/packages/SystemUI/src/com/android/systemui/shade/ShadeEmptyImplModule.kt +++ b/packages/SystemUI/src/com/android/systemui/shade/ShadeEmptyImplModule.kt @@ -17,6 +17,8 @@ package com.android.systemui.shade import com.android.systemui.dagger.SysUISingleton +import com.android.systemui.shade.domain.interactor.ShadeAnimationInteractor +import com.android.systemui.shade.domain.interactor.ShadeAnimationInteractorEmptyImpl import com.android.systemui.shade.domain.interactor.ShadeInteractor import com.android.systemui.shade.domain.interactor.ShadeInteractorEmptyImpl import dagger.Binds @@ -36,4 +38,10 @@ abstract class ShadeEmptyImplModule { @Binds @SysUISingleton abstract fun bindsShadeInteractor(si: ShadeInteractorEmptyImpl): ShadeInteractor + + @Binds + @SysUISingleton + abstract fun bindsShadeAnimationInteractor( + sai: ShadeAnimationInteractorEmptyImpl + ): ShadeAnimationInteractor } diff --git a/packages/SystemUI/src/com/android/systemui/shade/ShadeExpansionStateManager.kt b/packages/SystemUI/src/com/android/systemui/shade/ShadeExpansionStateManager.kt index e20534cc7840..d6db19e507a6 100644 --- a/packages/SystemUI/src/com/android/systemui/shade/ShadeExpansionStateManager.kt +++ b/packages/SystemUI/src/com/android/systemui/shade/ShadeExpansionStateManager.kt @@ -163,12 +163,6 @@ class ShadeExpansionStateManager @Inject constructor() : ShadeStateEvents { } } - fun notifyPanelCollapsingChanged(isCollapsing: Boolean) { - for (cb in shadeStateEventsListeners) { - cb.onPanelCollapsingChanged(isCollapsing) - } - } - private fun debugLog(msg: String) { if (!DEBUG) return Log.v(TAG, msg) diff --git a/packages/SystemUI/src/com/android/systemui/shade/ShadeModule.kt b/packages/SystemUI/src/com/android/systemui/shade/ShadeModule.kt index 54467cffa401..d9b298d0dfa9 100644 --- a/packages/SystemUI/src/com/android/systemui/shade/ShadeModule.kt +++ b/packages/SystemUI/src/com/android/systemui/shade/ShadeModule.kt @@ -19,6 +19,9 @@ package com.android.systemui.shade import com.android.systemui.dagger.SysUISingleton import com.android.systemui.scene.shared.flag.SceneContainerFlags import com.android.systemui.shade.domain.interactor.BaseShadeInteractor +import com.android.systemui.shade.domain.interactor.ShadeAnimationInteractor +import com.android.systemui.shade.domain.interactor.ShadeAnimationInteractorLegacyImpl +import com.android.systemui.shade.domain.interactor.ShadeAnimationInteractorSceneContainerImpl import com.android.systemui.shade.domain.interactor.ShadeInteractor import com.android.systemui.shade.domain.interactor.ShadeInteractorImpl import com.android.systemui.shade.domain.interactor.ShadeInteractorLegacyImpl @@ -45,6 +48,20 @@ abstract class ShadeModule { sceneContainerOff.get() } } + + @Provides + @SysUISingleton + fun provideShadeAnimationInteractor( + sceneContainerFlags: SceneContainerFlags, + sceneContainerOn: Provider<ShadeAnimationInteractorSceneContainerImpl>, + sceneContainerOff: Provider<ShadeAnimationInteractorLegacyImpl> + ): ShadeAnimationInteractor { + return if (sceneContainerFlags.isEnabled()) { + sceneContainerOn.get() + } else { + sceneContainerOff.get() + } + } } @Binds diff --git a/packages/SystemUI/src/com/android/systemui/shade/ShadeStateEvents.kt b/packages/SystemUI/src/com/android/systemui/shade/ShadeStateEvents.kt index c8511d76f5f0..ff96ca3caeea 100644 --- a/packages/SystemUI/src/com/android/systemui/shade/ShadeStateEvents.kt +++ b/packages/SystemUI/src/com/android/systemui/shade/ShadeStateEvents.kt @@ -27,10 +27,6 @@ interface ShadeStateEvents { /** Callbacks for certain notification panel events. */ interface ShadeStateEventsListener { - - /** Invoked when the notification panel starts or stops collapsing. */ - fun onPanelCollapsingChanged(isCollapsing: Boolean) {} - /** * Invoked when the notification panel starts or stops launching an [android.app.Activity]. */ diff --git a/packages/SystemUI/src/com/android/systemui/shade/data/repository/ShadeRepository.kt b/packages/SystemUI/src/com/android/systemui/shade/data/repository/ShadeRepository.kt index 47b08fe037a4..e94a3eb5db22 100644 --- a/packages/SystemUI/src/com/android/systemui/shade/data/repository/ShadeRepository.kt +++ b/packages/SystemUI/src/com/android/systemui/shade/data/repository/ShadeRepository.kt @@ -105,6 +105,12 @@ interface ShadeRepository { /** True when QS is taking up the entire screen, i.e. fully expanded on a non-unfolded phone. */ @Deprecated("Use ShadeInteractor instead") val legacyQsFullscreen: StateFlow<Boolean> + /** NPVC.mClosing as a flow. */ + @Deprecated("Use ShadeAnimationInteractor instead") val legacyIsClosing: StateFlow<Boolean> + + /** Sets whether a closing animation is happening. */ + @Deprecated("Use ShadeAnimationInteractor instead") fun setLegacyIsClosing(isClosing: Boolean) + /** */ @Deprecated("Use ShadeInteractor instead") fun setLegacyQsFullscreen(legacyQsFullscreen: Boolean) @@ -261,6 +267,15 @@ constructor(shadeExpansionStateManager: ShadeExpansionStateManager) : ShadeRepos _legacyShadeTracking.value = tracking } + private val _legacyIsClosing = MutableStateFlow(false) + @Deprecated("Use ShadeInteractor instead") + override val legacyIsClosing: StateFlow<Boolean> = _legacyIsClosing.asStateFlow() + + @Deprecated("Use ShadeInteractor instead") + override fun setLegacyIsClosing(isClosing: Boolean) { + _legacyIsClosing.value = isClosing + } + @Deprecated("Should only be called by NPVC and tests") override fun setLegacyLockscreenShadeTracking(tracking: Boolean) { legacyLockscreenShadeTracking.value = tracking diff --git a/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractor.kt b/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractor.kt new file mode 100644 index 000000000000..ff422b72c694 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractor.kt @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2023 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.systemui.shade.domain.interactor + +import kotlinx.coroutines.flow.Flow + +/** Business logic related to shade animations and transitions. */ +interface ShadeAnimationInteractor { + /** + * Whether a short animation to close the shade or QS is running. This will be false if the user + * is manually closing the shade or QS but true if they lift their finger and an animation + * completes the close. Important: if QS is collapsing back to shade, this will be false because + * that is not considered "closing". + */ + val isAnyCloseAnimationRunning: Flow<Boolean> +} diff --git a/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractorEmptyImpl.kt b/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractorEmptyImpl.kt new file mode 100644 index 000000000000..b4a134fd1910 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractorEmptyImpl.kt @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2023 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.systemui.shade.domain.interactor + +import com.android.systemui.dagger.SysUISingleton +import javax.inject.Inject +import kotlinx.coroutines.flow.flowOf + +/** Implementation of ShadeAnimationInteractor for shadeless SysUI variants. */ +@SysUISingleton +class ShadeAnimationInteractorEmptyImpl @Inject constructor() : ShadeAnimationInteractor { + override val isAnyCloseAnimationRunning = flowOf(false) +} diff --git a/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractorLegacyImpl.kt b/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractorLegacyImpl.kt new file mode 100644 index 000000000000..d51409365014 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractorLegacyImpl.kt @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2023 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.systemui.shade.domain.interactor + +import com.android.systemui.dagger.SysUISingleton +import com.android.systemui.shade.data.repository.ShadeRepository +import javax.inject.Inject + +/** Implementation of ShadeAnimationInteractor compatible with NPVC. */ +@SysUISingleton +class ShadeAnimationInteractorLegacyImpl +@Inject +constructor( + shadeRepository: ShadeRepository, +) : ShadeAnimationInteractor { + override val isAnyCloseAnimationRunning = shadeRepository.legacyIsClosing +} diff --git a/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractorSceneContainerImpl.kt b/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractorSceneContainerImpl.kt new file mode 100644 index 000000000000..7c0762d755de --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractorSceneContainerImpl.kt @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2023 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.systemui.shade.domain.interactor + +import com.android.systemui.dagger.SysUISingleton +import com.android.systemui.scene.domain.interactor.SceneInteractor +import com.android.systemui.scene.shared.model.ObservableTransitionState +import com.android.systemui.scene.shared.model.SceneKey +import javax.inject.Inject +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.flow.distinctUntilChanged +import kotlinx.coroutines.flow.flatMapLatest +import kotlinx.coroutines.flow.flowOf +import kotlinx.coroutines.flow.map + +/** Implementation of ShadeAnimationInteractor compatible with the scene container framework. */ +@SysUISingleton +class ShadeAnimationInteractorSceneContainerImpl +@Inject +constructor( + sceneInteractor: SceneInteractor, +) : ShadeAnimationInteractor { + @OptIn(ExperimentalCoroutinesApi::class) + override val isAnyCloseAnimationRunning = + sceneInteractor.transitionState + .flatMapLatest { state -> + when (state) { + is ObservableTransitionState.Idle -> flowOf(false) + is ObservableTransitionState.Transition -> + if ( + (state.fromScene == SceneKey.Shade && + state.toScene != SceneKey.QuickSettings) || + (state.fromScene == SceneKey.QuickSettings && + state.toScene != SceneKey.Shade) + ) { + state.isUserInputOngoing.map { !it } + } else { + flowOf(false) + } + } + } + .distinctUntilChanged() +} diff --git a/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeInteractorSceneContainerImpl.kt b/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeInteractorSceneContainerImpl.kt index 7cff8ea7abd2..3fd070c7146e 100644 --- a/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeInteractorSceneContainerImpl.kt +++ b/packages/SystemUI/src/com/android/systemui/shade/domain/interactor/ShadeInteractorSceneContainerImpl.kt @@ -71,14 +71,11 @@ constructor( override val isQsBypassingShade: Flow<Boolean> = sceneInteractor.transitionState - .flatMapLatest { state -> + .map { state -> when (state) { - is ObservableTransitionState.Idle -> flowOf(false) + is ObservableTransitionState.Idle -> false is ObservableTransitionState.Transition -> - flowOf( - state.toScene == SceneKey.QuickSettings && - state.fromScene != SceneKey.Shade - ) + state.toScene == SceneKey.QuickSettings && state.fromScene != SceneKey.Shade } } .distinctUntilChanged() diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/coordinator/VisualStabilityCoordinator.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/coordinator/VisualStabilityCoordinator.java index a2379b270f49..46e2391c87e8 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/coordinator/VisualStabilityCoordinator.java +++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/coordinator/VisualStabilityCoordinator.java @@ -29,6 +29,7 @@ import com.android.systemui.dump.DumpManager; import com.android.systemui.keyguard.WakefulnessLifecycle; import com.android.systemui.plugins.statusbar.StatusBarStateController; import com.android.systemui.shade.ShadeStateEvents; +import com.android.systemui.shade.domain.interactor.ShadeAnimationInteractor; import com.android.systemui.statusbar.notification.VisibilityLocationProvider; import com.android.systemui.statusbar.notification.collection.GroupEntry; import com.android.systemui.statusbar.notification.collection.ListEntry; @@ -39,6 +40,7 @@ import com.android.systemui.statusbar.notification.collection.provider.VisualSta import com.android.systemui.statusbar.policy.HeadsUpManager; import com.android.systemui.util.Compile; import com.android.systemui.util.concurrency.DelayableExecutor; +import com.android.systemui.util.kotlin.JavaAdapter; import java.io.PrintWriter; import java.util.HashMap; @@ -62,7 +64,9 @@ public class VisualStabilityCoordinator implements Coordinator, Dumpable, private final DelayableExecutor mDelayableExecutor; private final HeadsUpManager mHeadsUpManager; private final ShadeStateEvents mShadeStateEvents; + private final ShadeAnimationInteractor mShadeAnimationInteractor; private final StatusBarStateController mStatusBarStateController; + private final JavaAdapter mJavaAdapter; private final VisibilityLocationProvider mVisibilityLocationProvider; private final VisualStabilityProvider mVisualStabilityProvider; private final WakefulnessLifecycle mWakefulnessLifecycle; @@ -95,11 +99,15 @@ public class VisualStabilityCoordinator implements Coordinator, Dumpable, DumpManager dumpManager, HeadsUpManager headsUpManager, ShadeStateEvents shadeStateEvents, + ShadeAnimationInteractor shadeAnimationInteractor, + JavaAdapter javaAdapter, StatusBarStateController statusBarStateController, VisibilityLocationProvider visibilityLocationProvider, VisualStabilityProvider visualStabilityProvider, WakefulnessLifecycle wakefulnessLifecycle) { mHeadsUpManager = headsUpManager; + mShadeAnimationInteractor = shadeAnimationInteractor; + mJavaAdapter = javaAdapter; mVisibilityLocationProvider = visibilityLocationProvider; mVisualStabilityProvider = visualStabilityProvider; mWakefulnessLifecycle = wakefulnessLifecycle; @@ -119,6 +127,8 @@ public class VisualStabilityCoordinator implements Coordinator, Dumpable, mStatusBarStateController.addCallback(mStatusBarStateControllerListener); mPulsing = mStatusBarStateController.isPulsing(); mShadeStateEvents.addShadeStateEventsListener(this); + mJavaAdapter.alwaysCollectFlow(mShadeAnimationInteractor.isAnyCloseAnimationRunning(), + this::onShadeOrQsClosingChanged); pipeline.setVisualStabilityManager(mNotifStabilityManager); } @@ -322,10 +332,9 @@ public class VisualStabilityCoordinator implements Coordinator, Dumpable, } } - @Override - public void onPanelCollapsingChanged(boolean isCollapsing) { - mNotifPanelCollapsing = isCollapsing; - updateAllowedStates("notifPanelCollapsing", isCollapsing); + private void onShadeOrQsClosingChanged(boolean isClosing) { + mNotifPanelCollapsing = isClosing; + updateAllowedStates("notifPanelCollapsing", isClosing); } @Override diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewbinder/NotificationIconContainerViewBinder.kt b/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewbinder/NotificationIconContainerViewBinder.kt index b1e52afd3d8d..ecca9731f003 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewbinder/NotificationIconContainerViewBinder.kt +++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewbinder/NotificationIconContainerViewBinder.kt @@ -305,8 +305,6 @@ object NotificationIconContainerViewBinder { } } } - // Recalculate all icon positions, to reflect our updates. - view.calculateIconXTranslations() } } diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewbinder/StatusBarIconViewBinder.kt b/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewbinder/StatusBarIconViewBinder.kt index 3a2e21a048a5..03316548e979 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewbinder/StatusBarIconViewBinder.kt +++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewbinder/StatusBarIconViewBinder.kt @@ -21,6 +21,7 @@ import android.view.View import com.android.internal.util.ContrastColorUtil import com.android.systemui.res.R import com.android.systemui.statusbar.StatusBarIconView +import com.android.systemui.statusbar.StatusBarIconView.NO_COLOR import com.android.systemui.statusbar.notification.NotificationUtils import com.android.systemui.statusbar.notification.icon.ui.viewmodel.NotificationIconColors import kotlinx.coroutines.flow.Flow @@ -54,7 +55,8 @@ object StatusBarIconViewBinder { iconColors.collect { colors -> val isPreL = java.lang.Boolean.TRUE == view.getTag(R.id.icon_is_pre_L) val isColorized = !isPreL || NotificationUtils.isGrayscale(view, contrastColorUtil) - view.staticDrawableColor = colors.staticDrawableColor(view.viewBounds, isColorized) + view.staticDrawableColor = + if (isColorized) colors.staticDrawableColor(view.viewBounds) else NO_COLOR view.setDecorColor(colors.tint) } } diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewmodel/NotificationIconColors.kt b/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewmodel/NotificationIconColors.kt index 97d1e1b5f393..2365db451836 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewmodel/NotificationIconColors.kt +++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewmodel/NotificationIconColors.kt @@ -35,5 +35,5 @@ interface NotificationIconColors { * Returns the color to be applied to an icon, based on that icon's view bounds and whether or * not the notification icon is colorized. */ - fun staticDrawableColor(viewBounds: Rect, isColorized: Boolean): Int + fun staticDrawableColor(viewBounds: Rect): Int } diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewmodel/NotificationIconContainerStatusBarViewModel.kt b/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewmodel/NotificationIconContainerStatusBarViewModel.kt index af37e49c10f6..6e5ac470f1b6 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewmodel/NotificationIconContainerStatusBarViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/icon/ui/viewmodel/NotificationIconContainerStatusBarViewModel.kt @@ -117,8 +117,8 @@ constructor( override val tint: Int, private val areas: Collection<Rect>, ) : NotificationIconColors { - override fun staticDrawableColor(viewBounds: Rect, isColorized: Boolean): Int { - return if (isColorized && DarkIconDispatcher.isInAreas(areas, viewBounds)) { + override fun staticDrawableColor(viewBounds: Rect): Int { + return if (DarkIconDispatcher.isInAreas(areas, viewBounds)) { tint } else { DarkIconDispatcher.DEFAULT_ICON_TINT diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/NotificationBackgroundView.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/NotificationBackgroundView.java index 8eda96f62257..f6431a2e65ad 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/NotificationBackgroundView.java +++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/NotificationBackgroundView.java @@ -156,7 +156,7 @@ public class NotificationBackgroundView extends View implements Dumpable { new int[]{com.android.internal.R.attr.state_hovered}, new int[]{}}, - new int[]{tintColor, tintColor, tintColor} + new int[]{tintColor, 0, tintColor} ); mBackground.setTintMode(PorterDuff.Mode.SRC_ATOP); mBackground.setTintList(stateList); diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/ui/viewbinder/SharedNotificationContainerBinder.kt b/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/ui/viewbinder/SharedNotificationContainerBinder.kt index 5e60b5f4c707..7b2caea3fd9c 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/ui/viewbinder/SharedNotificationContainerBinder.kt +++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/ui/viewbinder/SharedNotificationContainerBinder.kt @@ -82,6 +82,8 @@ object SharedNotificationContainerBinder { } launch { viewModel.translationY.collect { controller.setTranslationY(it) } } + + launch { viewModel.alpha.collect { controller.setMaxAlphaForExpansion(it) } } } } diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/ui/viewmodel/SharedNotificationContainerViewModel.kt b/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/ui/viewmodel/SharedNotificationContainerViewModel.kt index 1febaf99b7b2..da847c020600 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/ui/viewmodel/SharedNotificationContainerViewModel.kt +++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/ui/viewmodel/SharedNotificationContainerViewModel.kt @@ -24,6 +24,7 @@ import com.android.systemui.dagger.qualifiers.Application import com.android.systemui.keyguard.domain.interactor.KeyguardInteractor import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractor import com.android.systemui.keyguard.shared.model.KeyguardState +import com.android.systemui.keyguard.ui.viewmodel.OccludedToLockscreenTransitionViewModel import com.android.systemui.shade.domain.interactor.ShadeInteractor import com.android.systemui.statusbar.notification.stack.domain.interactor.SharedNotificationContainerInteractor import com.android.systemui.util.kotlin.sample @@ -38,6 +39,7 @@ import kotlinx.coroutines.flow.combineTransform import kotlinx.coroutines.flow.distinctUntilChanged import kotlinx.coroutines.flow.flatMapLatest import kotlinx.coroutines.flow.map +import kotlinx.coroutines.flow.merge import kotlinx.coroutines.flow.onStart import kotlinx.coroutines.flow.stateIn @@ -50,6 +52,7 @@ constructor( keyguardInteractor: KeyguardInteractor, keyguardTransitionInteractor: KeyguardTransitionInteractor, private val shadeInteractor: ShadeInteractor, + occludedToLockscreenTransitionViewModel: OccludedToLockscreenTransitionViewModel, ) { private val statesForConstrainedNotifications = setOf( @@ -144,14 +147,20 @@ constructor( initialValue = NotificationContainerBounds(0f, 0f), ) + val alpha: Flow<Float> = occludedToLockscreenTransitionViewModel.lockscreenAlpha + /** * Under certain scenarios, such as swiping up on the lockscreen, the container will need to be * translated as the keyguard fades out. */ val translationY: Flow<Float> = - combine(isOnLockscreen, keyguardInteractor.keyguardTranslationY) { + combine( isOnLockscreen, - translationY -> + merge( + keyguardInteractor.keyguardTranslationY, + occludedToLockscreenTransitionViewModel.lockscreenTranslationY, + ) + ) { isOnLockscreen, translationY -> if (isOnLockscreen) { translationY } else { diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/SysuiDarkIconDispatcher.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/SysuiDarkIconDispatcher.java index f5e90348a7c4..93db91637a3e 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/SysuiDarkIconDispatcher.java +++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/SysuiDarkIconDispatcher.java @@ -46,7 +46,8 @@ public interface SysuiDarkIconDispatcher extends DarkIconDispatcher, Dumpable { /** Model for {@link #darkChangeFlow()} */ class DarkChange { - public static final DarkChange EMPTY = new DarkChange(new ArrayList<>(), 0, 0); + public static final DarkChange EMPTY = + new DarkChange(new ArrayList<>(), /* darkIntensity= */ 0f, DEFAULT_ICON_TINT); public DarkChange(Collection<Rect> areas, float darkIntensity, int tint) { this.areas = areas; diff --git a/packages/SystemUI/src/com/android/systemui/usb/UsbDebuggingActivity.java b/packages/SystemUI/src/com/android/systemui/usb/UsbDebuggingActivity.java index e7e907a90d34..e4f1c87fc305 100644 --- a/packages/SystemUI/src/com/android/systemui/usb/UsbDebuggingActivity.java +++ b/packages/SystemUI/src/com/android/systemui/usb/UsbDebuggingActivity.java @@ -25,6 +25,7 @@ import android.content.Intent; import android.content.IntentFilter; import android.debug.IAdbManager; import android.hardware.usb.UsbManager; +import android.os.Build; import android.os.Bundle; import android.os.IBinder; import android.os.ServiceManager; @@ -69,8 +70,7 @@ public class UsbDebuggingActivity extends AlertActivity super.onCreate(icicle); // Emulator does not support reseating the usb cable to reshow the dialog. - boolean isEmulator = SystemProperties.get("ro.boot.qemu").equals("1"); - if (SystemProperties.getInt("service.adb.tcp.port", 0) == 0 && !isEmulator) { + if (SystemProperties.getInt("service.adb.tcp.port", 0) == 0 && !Build.IS_EMULATOR) { mDisconnectedReceiver = new UsbDisconnectedReceiver(this); IntentFilter filter = new IntentFilter(UsbManager.ACTION_USB_STATE); mBroadcastDispatcher.registerReceiver(mDisconnectedReceiver, filter); diff --git a/packages/SystemUI/tests/src/com/android/systemui/biometrics/ui/viewmodel/DeviceEntryUdfpsTouchOverlayViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/biometrics/ui/viewmodel/DeviceEntryUdfpsTouchOverlayViewModelTest.kt index dfb18b9cdc79..f5f1622ac69b 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/biometrics/ui/viewmodel/DeviceEntryUdfpsTouchOverlayViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/biometrics/ui/viewmodel/DeviceEntryUdfpsTouchOverlayViewModelTest.kt @@ -17,29 +17,23 @@ package com.android.systemui.biometrics.ui.viewmodel import androidx.test.filters.SmallTest -import com.android.systemui.SysUITestComponent -import com.android.systemui.SysUITestModule import com.android.systemui.SysuiTestCase -import com.android.systemui.TestMocksModule -import com.android.systemui.collectLastValue -import com.android.systemui.dagger.SysUISingleton -import com.android.systemui.flags.FakeFeatureFlagsClassicModule +import com.android.systemui.coroutines.collectLastValue import com.android.systemui.flags.Flags -import com.android.systemui.keyguard.data.repository.FakeKeyguardRepository +import com.android.systemui.flags.featureFlagsClassic import com.android.systemui.keyguard.ui.transitions.DeviceEntryIconTransition -import com.android.systemui.runCurrent -import com.android.systemui.runTest -import com.android.systemui.shade.data.repository.FakeShadeRepository +import com.android.systemui.keyguard.ui.viewmodel.deviceEntryIconViewModelTransitionsMock +import com.android.systemui.kosmos.testScope import com.android.systemui.statusbar.phone.SystemUIDialogManager -import com.android.systemui.user.domain.UserDomainLayerModule -import com.android.systemui.util.mockito.mock +import com.android.systemui.statusbar.phone.systemUIDialogManager +import com.android.systemui.testKosmos import com.google.common.truth.Truth.assertThat -import dagger.BindsInstance -import dagger.Component import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.test.runCurrent +import kotlinx.coroutines.test.runTest import org.junit.Before import org.junit.Test import org.junit.runner.RunWith @@ -53,35 +47,11 @@ import org.mockito.MockitoAnnotations @SmallTest @RunWith(JUnit4::class) class DeviceEntryUdfpsTouchOverlayViewModelTest : SysuiTestCase() { - @Captor - private lateinit var sysuiDialogListenerCaptor: ArgumentCaptor<SystemUIDialogManager.Listener> - private var systemUIDialogManager: SystemUIDialogManager = mock() - - @Before - fun setUp() { - MockitoAnnotations.initMocks(this) - } - - @SysUISingleton - @Component( - modules = - [ - SysUITestModule::class, - UserDomainLayerModule::class, - ] - ) - interface TestComponent : SysUITestComponent<DeviceEntryUdfpsTouchOverlayViewModel> { - val keyguardRepository: FakeKeyguardRepository - val shadeRepository: FakeShadeRepository - @Component.Factory - interface Factory { - fun create( - @BindsInstance test: SysuiTestCase, - featureFlags: FakeFeatureFlagsClassicModule, - mocks: TestMocksModule, - ): TestComponent + val kosmos = + testKosmos().apply { + featureFlagsClassic.apply { set(Flags.FULL_SCREEN_USER_SWITCHER, true) } } - } + val testScope = kosmos.testScope private val testDeviceEntryIconTransitionAlpha = MutableStateFlow(0f) private val testDeviceEntryIconTransition: DeviceEntryIconTransition @@ -90,60 +60,59 @@ class DeviceEntryUdfpsTouchOverlayViewModelTest : SysuiTestCase() { override val deviceEntryParentViewAlpha: Flow<Float> = testDeviceEntryIconTransitionAlpha.asStateFlow() } - private val testComponent: TestComponent = - DaggerDeviceEntryUdfpsTouchOverlayViewModelTest_TestComponent.factory() - .create( - test = this, - featureFlags = - FakeFeatureFlagsClassicModule { set(Flags.FULL_SCREEN_USER_SWITCHER, true) }, - mocks = - TestMocksModule( - systemUIDialogManager = systemUIDialogManager, - deviceEntryIconTransitions = - setOf( - testDeviceEntryIconTransition, - ) - ), - ) + + init { + kosmos.deviceEntryIconViewModelTransitionsMock.add(testDeviceEntryIconTransition) + } + val systemUIDialogManager = kosmos.systemUIDialogManager + private val underTest = kosmos.deviceEntryUdfpsTouchOverlayViewModel + + @Captor + private lateinit var sysuiDialogListenerCaptor: ArgumentCaptor<SystemUIDialogManager.Listener> + + @Before + fun setUp() { + MockitoAnnotations.initMocks(this) + } @Test fun dialogShowing_shouldHandleTouchesFalse() = - testComponent.runTest { + testScope.runTest { val shouldHandleTouches by collectLastValue(underTest.shouldHandleTouches) - runCurrent() testDeviceEntryIconTransitionAlpha.value = 1f + runCurrent() + verify(systemUIDialogManager).registerListener(sysuiDialogListenerCaptor.capture()) sysuiDialogListenerCaptor.value.shouldHideAffordances(true) - runCurrent() assertThat(shouldHandleTouches).isFalse() } @Test fun transitionAlphaIsSmall_shouldHandleTouchesFalse() = - testComponent.runTest { + testScope.runTest { val shouldHandleTouches by collectLastValue(underTest.shouldHandleTouches) - runCurrent() testDeviceEntryIconTransitionAlpha.value = .3f + runCurrent() + verify(systemUIDialogManager).registerListener(sysuiDialogListenerCaptor.capture()) sysuiDialogListenerCaptor.value.shouldHideAffordances(false) - runCurrent() assertThat(shouldHandleTouches).isFalse() } @Test fun alphaFullyShowing_noDialog_shouldHandleTouchesTrue() = - testComponent.runTest { + testScope.runTest { val shouldHandleTouches by collectLastValue(underTest.shouldHandleTouches) - runCurrent() testDeviceEntryIconTransitionAlpha.value = 1f + runCurrent() + verify(systemUIDialogManager).registerListener(sysuiDialogListenerCaptor.capture()) sysuiDialogListenerCaptor.value.shouldHideAffordances(false) - runCurrent() assertThat(shouldHandleTouches).isTrue() } diff --git a/packages/SystemUI/tests/src/com/android/systemui/clipboardoverlay/ClipboardOverlayControllerTest.java b/packages/SystemUI/tests/src/com/android/systemui/clipboardoverlay/ClipboardOverlayControllerTest.java index 967196689650..c425e8224a4c 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/clipboardoverlay/ClipboardOverlayControllerTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/clipboardoverlay/ClipboardOverlayControllerTest.java @@ -444,6 +444,7 @@ public class ClipboardOverlayControllerTest extends SysuiTestCase { verify(mClipboardOverlayView, never()).setMinimized(true); verify(mClipboardOverlayView).setMinimized(false); + verify(mClipboardOverlayView).getEnterAnimation(); verify(mClipboardOverlayView).showTextPreview("Test Item", false); } @@ -458,6 +459,7 @@ public class ClipboardOverlayControllerTest extends SysuiTestCase { verify(mClipboardOverlayView).setMinimized(true); verify(mUiEventLogger, times(1)).log(CLIPBOARD_OVERLAY_SHOWN_MINIMIZED, 0, "abc"); + verify(mClipboardOverlayView).getEnterAnimation(); verify(mClipboardOverlayView, never()).setMinimized(false); verify(mClipboardOverlayView, never()).showTextPreview(any(), anyBoolean()); diff --git a/packages/SystemUI/tests/src/com/android/systemui/common/ui/domain/interactor/ConfigurationInteractorTest.kt b/packages/SystemUI/tests/src/com/android/systemui/common/ui/domain/interactor/ConfigurationInteractorTest.kt new file mode 100644 index 000000000000..c5c02080fb80 --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/common/ui/domain/interactor/ConfigurationInteractorTest.kt @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2023 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.systemui.common.ui.domain.interactor + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.systemui.SysuiTestCase +import com.android.systemui.common.ui.data.repository.FakeConfigurationRepository +import com.android.systemui.coroutines.collectLastValue +import com.google.common.truth.Truth.assertThat +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.test.TestScope +import kotlinx.coroutines.test.runTest +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.mockito.MockitoAnnotations + +@ExperimentalCoroutinesApi +@SmallTest +@RunWith(AndroidJUnit4::class) +class ConfigurationInteractorTest : SysuiTestCase() { + private lateinit var testScope: TestScope + private lateinit var underTest: ConfigurationInteractor + private lateinit var configurationRepository: FakeConfigurationRepository + + @Before + fun setUp() { + MockitoAnnotations.initMocks(this) + + configurationRepository = FakeConfigurationRepository() + testScope = TestScope() + underTest = ConfigurationInteractor(configurationRepository) + } + + @Test + fun dimensionPixelSize() = + testScope.runTest { + val resourceId = 1001 + val pixelSize = 501 + configurationRepository.setDimensionPixelSize(resourceId, pixelSize) + + val dimensionPixelSize by collectLastValue(underTest.dimensionPixelSize(resourceId)) + + configurationRepository.onAnyConfigurationChange() + + assertThat(dimensionPixelSize).isEqualTo(pixelSize) + } + + @Test + fun dimensionPixelSizes() = + testScope.runTest { + val resourceId1 = 1001 + val pixelSize1 = 501 + val resourceId2 = 1002 + val pixelSize2 = 502 + configurationRepository.setDimensionPixelSize(resourceId1, pixelSize1) + configurationRepository.setDimensionPixelSize(resourceId2, pixelSize2) + + val dimensionPixelSizes by + collectLastValue(underTest.dimensionPixelSize(setOf(resourceId1, resourceId2))) + + configurationRepository.onAnyConfigurationChange() + + assertThat(dimensionPixelSizes!![resourceId1]).isEqualTo(pixelSize1) + assertThat(dimensionPixelSizes!![resourceId2]).isEqualTo(pixelSize2) + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/KeyguardTransitionAnimationFlowTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/KeyguardTransitionAnimationFlowTest.kt index a04ea2e4fa9c..edd781dec3a0 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/KeyguardTransitionAnimationFlowTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/KeyguardTransitionAnimationFlowTest.kt @@ -24,8 +24,10 @@ import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepos import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.util.mockito.mock import com.google.common.truth.Truth.assertThat import kotlin.time.Duration.Companion.milliseconds +import kotlinx.coroutines.test.TestScope import kotlinx.coroutines.test.runTest import org.junit.Before import org.junit.Test @@ -35,125 +37,138 @@ import org.junit.runners.JUnit4 @SmallTest @RunWith(JUnit4::class) class KeyguardTransitionAnimationFlowTest : SysuiTestCase() { - private lateinit var underTest: KeyguardTransitionAnimationFlow + private lateinit var underTest: KeyguardTransitionAnimationFlow.SharedFlowBuilder private lateinit var repository: FakeKeyguardTransitionRepository + private lateinit var testScope: TestScope @Before fun setUp() { + testScope = TestScope() repository = FakeKeyguardTransitionRepository() underTest = KeyguardTransitionAnimationFlow( - 1000.milliseconds, - repository.transitions, - ) + testScope.backgroundScope, + mock(), + ) + .setup( + duration = 1000.milliseconds, + stepFlow = repository.transitions, + ) } @Test(expected = IllegalArgumentException::class) - fun zeroDurationThrowsException() = runTest { - val flow = underTest.createFlow(duration = 0.milliseconds, onStep = { it }) - } + fun zeroDurationThrowsException() = + testScope.runTest { + val flow = underTest.sharedFlow(duration = 0.milliseconds, onStep = { it }) + } @Test(expected = IllegalArgumentException::class) - fun startTimePlusDurationGreaterThanTransitionDurationThrowsException() = runTest { - val flow = - underTest.createFlow( - startTime = 300.milliseconds, - duration = 800.milliseconds, - onStep = { it } - ) - } + fun startTimePlusDurationGreaterThanTransitionDurationThrowsException() = + testScope.runTest { + val flow = + underTest.sharedFlow( + startTime = 300.milliseconds, + duration = 800.milliseconds, + onStep = { it } + ) + } @Test - fun onFinishRunsWhenSpecified() = runTest { - val flow = - underTest.createFlow( - duration = 100.milliseconds, - onStep = { it }, - onFinish = { 10f }, - ) - var animationValues = collectLastValue(flow) - repository.sendTransitionStep(step(1f, TransitionState.FINISHED), validateStep = false) - assertThat(animationValues()).isEqualTo(10f) - } + fun onFinishRunsWhenSpecified() = + testScope.runTest { + val flow = + underTest.sharedFlow( + duration = 100.milliseconds, + onStep = { it }, + onFinish = { 10f }, + ) + var animationValues = collectLastValue(flow) + repository.sendTransitionStep(step(1f, TransitionState.FINISHED), validateStep = false) + assertThat(animationValues()).isEqualTo(10f) + } @Test - fun onCancelRunsWhenSpecified() = runTest { - val flow = - underTest.createFlow( - duration = 100.milliseconds, - onStep = { it }, - onCancel = { 100f }, - ) - var animationValues = collectLastValue(flow) - repository.sendTransitionStep(step(0.5f, TransitionState.CANCELED)) - assertThat(animationValues()).isEqualTo(100f) - } + fun onCancelRunsWhenSpecified() = + testScope.runTest { + val flow = + underTest.sharedFlow( + duration = 100.milliseconds, + onStep = { it }, + onCancel = { 100f }, + ) + var animationValues = collectLastValue(flow) + repository.sendTransitionStep(step(0.5f, TransitionState.CANCELED)) + assertThat(animationValues()).isEqualTo(100f) + } @Test - fun usesStartTime() = runTest { - val flow = - underTest.createFlow( - startTime = 500.milliseconds, - duration = 500.milliseconds, - onStep = { it }, - ) - var animationValues = collectLastValue(flow) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertThat(animationValues()).isEqualTo(0f) + fun usesStartTime() = + testScope.runTest { + val flow = + underTest.sharedFlow( + startTime = 500.milliseconds, + duration = 500.milliseconds, + onStep = { it }, + ) + var animationValues = collectLastValue(flow) + repository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertThat(animationValues()).isEqualTo(0f) - // Should not emit a value - repository.sendTransitionStep(step(0.1f, TransitionState.RUNNING)) + // Should not emit a value + repository.sendTransitionStep(step(0.1f, TransitionState.RUNNING)) - repository.sendTransitionStep(step(0.5f, TransitionState.RUNNING)) - assertFloat(animationValues(), 0f) - repository.sendTransitionStep(step(0.6f, TransitionState.RUNNING)) - assertFloat(animationValues(), 0.2f) - repository.sendTransitionStep(step(0.8f, TransitionState.RUNNING)) - assertFloat(animationValues(), 0.6f) - repository.sendTransitionStep(step(1f, TransitionState.RUNNING)) - assertFloat(animationValues(), 1f) - } + repository.sendTransitionStep(step(0.5f, TransitionState.RUNNING)) + assertFloat(animationValues(), 0f) + repository.sendTransitionStep(step(0.6f, TransitionState.RUNNING)) + assertFloat(animationValues(), 0.2f) + repository.sendTransitionStep(step(0.8f, TransitionState.RUNNING)) + assertFloat(animationValues(), 0.6f) + repository.sendTransitionStep(step(1f, TransitionState.RUNNING)) + assertFloat(animationValues(), 1f) + } @Test - fun usesInterpolator() = runTest { - val flow = - underTest.createFlow( - duration = 1000.milliseconds, - interpolator = EMPHASIZED_ACCELERATE, - onStep = { it }, - ) - var animationValues = collectLastValue(flow) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertFloat(animationValues(), EMPHASIZED_ACCELERATE.getInterpolation(0f)) - repository.sendTransitionStep(step(0.5f, TransitionState.RUNNING)) - assertFloat(animationValues(), EMPHASIZED_ACCELERATE.getInterpolation(0.5f)) - repository.sendTransitionStep(step(0.6f, TransitionState.RUNNING)) - assertFloat(animationValues(), EMPHASIZED_ACCELERATE.getInterpolation(0.6f)) - repository.sendTransitionStep(step(0.8f, TransitionState.RUNNING)) - assertFloat(animationValues(), EMPHASIZED_ACCELERATE.getInterpolation(0.8f)) - repository.sendTransitionStep(step(1f, TransitionState.RUNNING)) - assertFloat(animationValues(), EMPHASIZED_ACCELERATE.getInterpolation(1f)) - } + fun usesInterpolator() = + testScope.runTest { + val flow = + underTest.sharedFlow( + duration = 1000.milliseconds, + interpolator = EMPHASIZED_ACCELERATE, + onStep = { it }, + ) + var animationValues = collectLastValue(flow) + repository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertFloat(animationValues(), EMPHASIZED_ACCELERATE.getInterpolation(0f)) + repository.sendTransitionStep(step(0.5f, TransitionState.RUNNING)) + assertFloat(animationValues(), EMPHASIZED_ACCELERATE.getInterpolation(0.5f)) + repository.sendTransitionStep(step(0.6f, TransitionState.RUNNING)) + assertFloat(animationValues(), EMPHASIZED_ACCELERATE.getInterpolation(0.6f)) + repository.sendTransitionStep(step(0.8f, TransitionState.RUNNING)) + assertFloat(animationValues(), EMPHASIZED_ACCELERATE.getInterpolation(0.8f)) + repository.sendTransitionStep(step(1f, TransitionState.RUNNING)) + assertFloat(animationValues(), EMPHASIZED_ACCELERATE.getInterpolation(1f)) + } @Test - fun usesOnStepToDoubleValue() = runTest { - val flow = - underTest.createFlow( - duration = 1000.milliseconds, - onStep = { it * 2 }, - ) - var animationValues = collectLastValue(flow) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertFloat(animationValues(), 0f) - repository.sendTransitionStep(step(0.3f, TransitionState.RUNNING)) - assertFloat(animationValues(), 0.6f) - repository.sendTransitionStep(step(0.6f, TransitionState.RUNNING)) - assertFloat(animationValues(), 1.2f) - repository.sendTransitionStep(step(0.8f, TransitionState.RUNNING)) - assertFloat(animationValues(), 1.6f) - repository.sendTransitionStep(step(1f, TransitionState.RUNNING)) - assertFloat(animationValues(), 2f) - } + fun usesOnStepToDoubleValue() = + testScope.runTest { + val flow = + underTest.sharedFlow( + duration = 1000.milliseconds, + onStep = { it * 2 }, + ) + var animationValues = collectLastValue(flow) + repository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertFloat(animationValues(), 0f) + repository.sendTransitionStep(step(0.3f, TransitionState.RUNNING)) + assertFloat(animationValues(), 0.6f) + repository.sendTransitionStep(step(0.6f, TransitionState.RUNNING)) + assertFloat(animationValues(), 1.2f) + repository.sendTransitionStep(step(0.8f, TransitionState.RUNNING)) + assertFloat(animationValues(), 1.6f) + repository.sendTransitionStep(step(1f, TransitionState.RUNNING)) + assertFloat(animationValues(), 2f) + } private fun assertFloat(actual: Float?, expected: Float) { assertThat(actual!!).isWithin(0.01f).of(expected) diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AlternateBouncerViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AlternateBouncerViewModelTest.kt index fc9f54ec74f7..d959872fa80c 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AlternateBouncerViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AlternateBouncerViewModelTest.kt @@ -21,66 +21,45 @@ import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase import com.android.systemui.coroutines.collectLastValue import com.android.systemui.coroutines.collectValues -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractor -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractorFactory +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep -import com.android.systemui.statusbar.phone.StatusBarKeyguardViewManager +import com.android.systemui.kosmos.testScope +import com.android.systemui.statusbar.phone.statusBarKeyguardViewManager +import com.android.systemui.testKosmos import com.google.common.collect.Range import com.google.common.truth.Truth.assertThat import kotlinx.coroutines.ExperimentalCoroutinesApi -import kotlinx.coroutines.test.TestScope -import kotlinx.coroutines.test.UnconfinedTestDispatcher import kotlinx.coroutines.test.runTest -import org.junit.Before import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.JUnit4 -import org.mockito.Mock -import org.mockito.MockitoAnnotations @ExperimentalCoroutinesApi @RunWith(JUnit4::class) @SmallTest class AlternateBouncerViewModelTest : SysuiTestCase() { - - private lateinit var testScope: TestScope - - @Mock private lateinit var statusBarKeyguardViewManager: StatusBarKeyguardViewManager - - private lateinit var transitionRepository: FakeKeyguardTransitionRepository - private lateinit var transitionInteractor: KeyguardTransitionInteractor - private lateinit var underTest: AlternateBouncerViewModel - - @Before - fun setup() { - MockitoAnnotations.initMocks(this) - testScope = TestScope() - - val transitionInteractorWithDependencies = - KeyguardTransitionInteractorFactory.create(testScope.backgroundScope) - transitionInteractor = transitionInteractorWithDependencies.keyguardTransitionInteractor - transitionRepository = transitionInteractorWithDependencies.repository - underTest = - AlternateBouncerViewModel( - statusBarKeyguardViewManager, - transitionInteractor, - ) - } + private val kosmos = testKosmos() + private val testScope = kosmos.testScope + private val transitionRepository = kosmos.fakeKeyguardTransitionRepository + private val statusBarKeyguardViewManager = kosmos.statusBarKeyguardViewManager + private val underTest = kosmos.alternateBouncerViewModel @Test fun transitionToAlternateBouncer_scrimAlphaUpdate() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { val scrimAlphas by collectValues(underTest.scrimAlpha) - transitionRepository.sendTransitionStep( - stepToAlternateBouncer(0f, TransitionState.STARTED) + transitionRepository.sendTransitionSteps( + listOf( + stepToAlternateBouncer(0f, TransitionState.STARTED), + stepToAlternateBouncer(.4f), + stepToAlternateBouncer(.6f), + stepToAlternateBouncer(1f), + ), + testScope, ) - transitionRepository.sendTransitionStep(stepToAlternateBouncer(.4f)) - transitionRepository.sendTransitionStep(stepToAlternateBouncer(.6f)) - transitionRepository.sendTransitionStep(stepToAlternateBouncer(1f)) assertThat(scrimAlphas.size).isEqualTo(4) scrimAlphas.forEach { assertThat(it).isIn(Range.closed(0f, 1f)) } @@ -88,15 +67,18 @@ class AlternateBouncerViewModelTest : SysuiTestCase() { @Test fun transitionFromAlternateBouncer_scrimAlphaUpdate() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { val scrimAlphas by collectValues(underTest.scrimAlpha) - transitionRepository.sendTransitionStep( - stepFromAlternateBouncer(0f, TransitionState.STARTED) + transitionRepository.sendTransitionSteps( + listOf( + stepToAlternateBouncer(0f, TransitionState.STARTED), + stepToAlternateBouncer(.4f), + stepToAlternateBouncer(.6f), + stepToAlternateBouncer(1f), + ), + testScope, ) - transitionRepository.sendTransitionStep(stepFromAlternateBouncer(.4f)) - transitionRepository.sendTransitionStep(stepFromAlternateBouncer(.6f)) - transitionRepository.sendTransitionStep(stepFromAlternateBouncer(1f)) assertThat(scrimAlphas.size).isEqualTo(4) scrimAlphas.forEach { assertThat(it).isIn(Range.closed(0f, 1f)) } @@ -104,43 +86,57 @@ class AlternateBouncerViewModelTest : SysuiTestCase() { @Test fun forcePluginOpen() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { val forcePluginOpen by collectLastValue(underTest.forcePluginOpen) - transitionRepository.sendTransitionStep( - stepToAlternateBouncer(0f, TransitionState.STARTED) + + transitionRepository.sendTransitionSteps( + listOf( + stepToAlternateBouncer(0f, TransitionState.STARTED), + stepToAlternateBouncer(.4f), + stepToAlternateBouncer(.6f), + stepToAlternateBouncer(1f), + ), + testScope, ) - transitionRepository.sendTransitionStep(stepToAlternateBouncer(.3f)) - transitionRepository.sendTransitionStep(stepToAlternateBouncer(.6f)) - transitionRepository.sendTransitionStep(stepToAlternateBouncer(1f)) assertThat(forcePluginOpen).isTrue() - transitionRepository.sendTransitionStep( - stepFromAlternateBouncer(0f, TransitionState.STARTED) + transitionRepository.sendTransitionSteps( + listOf( + stepFromAlternateBouncer(0f, TransitionState.STARTED), + stepFromAlternateBouncer(.3f), + stepFromAlternateBouncer(.6f), + stepFromAlternateBouncer(1f), + ), + testScope, ) - transitionRepository.sendTransitionStep(stepFromAlternateBouncer(.3f)) - transitionRepository.sendTransitionStep(stepFromAlternateBouncer(.6f)) - transitionRepository.sendTransitionStep(stepFromAlternateBouncer(1f)) assertThat(forcePluginOpen).isFalse() } @Test fun registerForDismissGestures() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { val registerForDismissGestures by collectLastValue(underTest.registerForDismissGestures) - transitionRepository.sendTransitionStep( - stepToAlternateBouncer(0f, TransitionState.STARTED) + + transitionRepository.sendTransitionSteps( + listOf( + stepToAlternateBouncer(0f, TransitionState.STARTED), + stepToAlternateBouncer(.4f), + stepToAlternateBouncer(.6f), + stepToAlternateBouncer(1f), + ), + testScope, ) - transitionRepository.sendTransitionStep(stepToAlternateBouncer(.3f)) - transitionRepository.sendTransitionStep(stepToAlternateBouncer(.6f)) - transitionRepository.sendTransitionStep(stepToAlternateBouncer(1f)) assertThat(registerForDismissGestures).isTrue() - transitionRepository.sendTransitionStep( - stepFromAlternateBouncer(0f, TransitionState.STARTED) + transitionRepository.sendTransitionSteps( + listOf( + stepFromAlternateBouncer(0f, TransitionState.STARTED), + stepFromAlternateBouncer(.3f), + stepFromAlternateBouncer(.6f), + stepFromAlternateBouncer(1f), + ), + testScope, ) - transitionRepository.sendTransitionStep(stepFromAlternateBouncer(.3f)) - transitionRepository.sendTransitionStep(stepFromAlternateBouncer(.6f)) - transitionRepository.sendTransitionStep(stepFromAlternateBouncer(1f)) assertThat(registerForDismissGestures).isFalse() } diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AodToGoneTransitionViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AodToGoneTransitionViewModelTest.kt index f282481ba01c..4c972e9195e9 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AodToGoneTransitionViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AodToGoneTransitionViewModelTest.kt @@ -20,16 +20,15 @@ import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase import com.android.systemui.coroutines.collectValues -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractorFactory +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.kosmos.testScope +import com.android.systemui.testKosmos import com.google.common.truth.Truth.assertThat import kotlinx.coroutines.ExperimentalCoroutinesApi -import kotlinx.coroutines.test.TestScope import kotlinx.coroutines.test.runTest -import org.junit.Before import org.junit.Test import org.junit.runner.RunWith @@ -37,34 +36,25 @@ import org.junit.runner.RunWith @SmallTest @RunWith(AndroidJUnit4::class) class AodToGoneTransitionViewModelTest : SysuiTestCase() { - private lateinit var underTest: AodToGoneTransitionViewModel - private lateinit var repository: FakeKeyguardTransitionRepository - - @Before - fun setUp() { - repository = FakeKeyguardTransitionRepository() - val interactor = - KeyguardTransitionInteractorFactory.create( - scope = TestScope().backgroundScope, - repository = repository, - ) - .keyguardTransitionInteractor - underTest = AodToGoneTransitionViewModel(interactor) - } + val kosmos = testKosmos() + val testScope = kosmos.testScope + val repository = kosmos.fakeKeyguardTransitionRepository + val underTest = kosmos.aodToGoneTransitionViewModel @Test - fun deviceEntryParentViewHides() = runTest { - val deviceEntryParentViewAlpha by collectValues(underTest.deviceEntryParentViewAlpha) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.1f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.4f)) - repository.sendTransitionStep(step(0.5f)) - repository.sendTransitionStep(step(0.6f)) - repository.sendTransitionStep(step(0.8f)) - repository.sendTransitionStep(step(1f)) - deviceEntryParentViewAlpha.forEach { assertThat(it).isEqualTo(0f) } - } + fun deviceEntryParentViewHides() = + testScope.runTest { + val deviceEntryParentViewAlpha by collectValues(underTest.deviceEntryParentViewAlpha) + repository.sendTransitionStep(step(0f, TransitionState.STARTED)) + repository.sendTransitionStep(step(0.1f)) + repository.sendTransitionStep(step(0.3f)) + repository.sendTransitionStep(step(0.4f)) + repository.sendTransitionStep(step(0.5f)) + repository.sendTransitionStep(step(0.6f)) + repository.sendTransitionStep(step(0.8f)) + repository.sendTransitionStep(step(1f)) + deviceEntryParentViewAlpha.forEach { assertThat(it).isEqualTo(0f) } + } private fun step( value: Float, diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AodToLockscreenTransitionViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AodToLockscreenTransitionViewModelTest.kt index 517149c99a62..af8d8a8978b5 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AodToLockscreenTransitionViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AodToLockscreenTransitionViewModelTest.kt @@ -19,22 +19,18 @@ package com.android.systemui.keyguard.ui.viewmodel import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase -import com.android.systemui.biometrics.data.repository.FakeFingerprintPropertyRepository +import com.android.systemui.biometrics.data.repository.fingerprintPropertyRepository import com.android.systemui.coroutines.collectLastValue import com.android.systemui.coroutines.collectValues -import com.android.systemui.deviceentry.domain.interactor.DeviceEntryUdfpsInteractor -import com.android.systemui.keyguard.data.repository.FakeBiometricSettingsRepository -import com.android.systemui.keyguard.data.repository.FakeDeviceEntryFingerprintAuthRepository -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractorFactory +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.kosmos.testScope +import com.android.systemui.testKosmos import com.google.common.truth.Truth.assertThat import kotlinx.coroutines.ExperimentalCoroutinesApi -import kotlinx.coroutines.test.TestScope import kotlinx.coroutines.test.runTest -import org.junit.Before import org.junit.Test import org.junit.runner.RunWith @@ -42,83 +38,67 @@ import org.junit.runner.RunWith @SmallTest @RunWith(AndroidJUnit4::class) class AodToLockscreenTransitionViewModelTest : SysuiTestCase() { - private lateinit var underTest: AodToLockscreenTransitionViewModel - private lateinit var repository: FakeKeyguardTransitionRepository - private lateinit var fingerprintPropertyRepository: FakeFingerprintPropertyRepository - - @Before - fun setUp() { - repository = FakeKeyguardTransitionRepository() - fingerprintPropertyRepository = FakeFingerprintPropertyRepository() - underTest = - AodToLockscreenTransitionViewModel( - interactor = - KeyguardTransitionInteractorFactory.create( - scope = TestScope().backgroundScope, - repository = repository, - ) - .keyguardTransitionInteractor, - deviceEntryUdfpsInteractor = - DeviceEntryUdfpsInteractor( - fingerprintPropertyRepository = fingerprintPropertyRepository, - fingerprintAuthRepository = FakeDeviceEntryFingerprintAuthRepository(), - biometricSettingsRepository = FakeBiometricSettingsRepository(), - ), - ) - } + val kosmos = testKosmos() + val testScope = kosmos.testScope + val repository = kosmos.fakeKeyguardTransitionRepository + val fingerprintPropertyRepository = kosmos.fingerprintPropertyRepository + val underTest = kosmos.aodToLockscreenTransitionViewModel @Test - fun deviceEntryParentViewShows() = runTest { - val deviceEntryParentViewAlpha by collectValues(underTest.deviceEntryParentViewAlpha) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.1f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.5f)) - repository.sendTransitionStep(step(0.6f)) - repository.sendTransitionStep(step(1f)) - deviceEntryParentViewAlpha.forEach { assertThat(it).isEqualTo(1f) } - } + fun deviceEntryParentViewShows() = + testScope.runTest { + val deviceEntryParentViewAlpha by collectValues(underTest.deviceEntryParentViewAlpha) + repository.sendTransitionStep(step(0f, TransitionState.STARTED)) + repository.sendTransitionStep(step(0.1f)) + repository.sendTransitionStep(step(0.3f)) + repository.sendTransitionStep(step(0.5f)) + repository.sendTransitionStep(step(0.6f)) + repository.sendTransitionStep(step(1f)) + deviceEntryParentViewAlpha.forEach { assertThat(it).isEqualTo(1f) } + } @Test - fun deviceEntryBackgroundView_udfps_alphaFadeIn() = runTest { - fingerprintPropertyRepository.supportsUdfps() - val deviceEntryBackgroundViewAlpha by - collectLastValue(underTest.deviceEntryBackgroundViewAlpha) + fun deviceEntryBackgroundView_udfps_alphaFadeIn() = + testScope.runTest { + fingerprintPropertyRepository.supportsUdfps() + val deviceEntryBackgroundViewAlpha by + collectLastValue(underTest.deviceEntryBackgroundViewAlpha) - // fade in - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) + // fade in + repository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) - repository.sendTransitionStep(step(0.1f)) - assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(.2f) + repository.sendTransitionStep(step(0.1f)) + assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(.2f) - repository.sendTransitionStep(step(0.3f)) - assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(.6f) + repository.sendTransitionStep(step(0.3f)) + assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(.6f) - repository.sendTransitionStep(step(0.6f)) - assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(1f) + repository.sendTransitionStep(step(0.6f)) + assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(1f) - repository.sendTransitionStep(step(1f)) - assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(1f) - } + repository.sendTransitionStep(step(1f)) + assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(1f) + } @Test - fun deviceEntryBackgroundView_rearFp_noUpdates() = runTest { - fingerprintPropertyRepository.supportsRearFps() - val deviceEntryBackgroundViewAlpha by - collectLastValue(underTest.deviceEntryBackgroundViewAlpha) - // no updates - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertThat(deviceEntryBackgroundViewAlpha).isNull() - repository.sendTransitionStep(step(0.1f)) - assertThat(deviceEntryBackgroundViewAlpha).isNull() - repository.sendTransitionStep(step(0.3f)) - assertThat(deviceEntryBackgroundViewAlpha).isNull() - repository.sendTransitionStep(step(0.6f)) - assertThat(deviceEntryBackgroundViewAlpha).isNull() - repository.sendTransitionStep(step(1f)) - assertThat(deviceEntryBackgroundViewAlpha).isNull() - } + fun deviceEntryBackgroundView_rearFp_noUpdates() = + testScope.runTest { + fingerprintPropertyRepository.supportsRearFps() + val deviceEntryBackgroundViewAlpha by + collectLastValue(underTest.deviceEntryBackgroundViewAlpha) + // no updates + repository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertThat(deviceEntryBackgroundViewAlpha).isNull() + repository.sendTransitionStep(step(0.1f)) + assertThat(deviceEntryBackgroundViewAlpha).isNull() + repository.sendTransitionStep(step(0.3f)) + assertThat(deviceEntryBackgroundViewAlpha).isNull() + repository.sendTransitionStep(step(0.6f)) + assertThat(deviceEntryBackgroundViewAlpha).isNull() + repository.sendTransitionStep(step(1f)) + assertThat(deviceEntryBackgroundViewAlpha).isNull() + } private fun step( value: Float, diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AodToOccludedTransitionViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AodToOccludedTransitionViewModelTest.kt index 96f69462accf..db8fbf604430 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AodToOccludedTransitionViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/AodToOccludedTransitionViewModelTest.kt @@ -20,16 +20,15 @@ import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase import com.android.systemui.coroutines.collectValues -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractorFactory +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.kosmos.testScope +import com.android.systemui.testKosmos import com.google.common.truth.Truth import kotlinx.coroutines.ExperimentalCoroutinesApi -import kotlinx.coroutines.test.TestScope import kotlinx.coroutines.test.runTest -import org.junit.Before import org.junit.Test import org.junit.runner.RunWith @@ -37,34 +36,25 @@ import org.junit.runner.RunWith @SmallTest @RunWith(AndroidJUnit4::class) class AodToOccludedTransitionViewModelTest : SysuiTestCase() { - private lateinit var underTest: AodToOccludedTransitionViewModel - private lateinit var repository: FakeKeyguardTransitionRepository - - @Before - fun setUp() { - repository = FakeKeyguardTransitionRepository() - val interactor = - KeyguardTransitionInteractorFactory.create( - scope = TestScope().backgroundScope, - repository = repository, - ) - .keyguardTransitionInteractor - underTest = AodToOccludedTransitionViewModel(interactor) - } + private val kosmos = testKosmos() + private val testScope = kosmos.testScope + private val repository = kosmos.fakeKeyguardTransitionRepository + private val underTest = kosmos.aodToOccludedTransitionViewModel @Test - fun deviceEntryParentViewHides() = runTest { - val deviceEntryParentViewAlpha by collectValues(underTest.deviceEntryParentViewAlpha) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.1f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.4f)) - repository.sendTransitionStep(step(0.5f)) - repository.sendTransitionStep(step(0.6f)) - repository.sendTransitionStep(step(0.8f)) - repository.sendTransitionStep(step(1f)) - deviceEntryParentViewAlpha.forEach { Truth.assertThat(it).isEqualTo(0f) } - } + fun deviceEntryParentViewHides() = + testScope.runTest { + val deviceEntryParentViewAlpha by collectValues(underTest.deviceEntryParentViewAlpha) + repository.sendTransitionStep(step(0f, TransitionState.STARTED)) + repository.sendTransitionStep(step(0.1f)) + repository.sendTransitionStep(step(0.3f)) + repository.sendTransitionStep(step(0.4f)) + repository.sendTransitionStep(step(0.5f)) + repository.sendTransitionStep(step(0.6f)) + repository.sendTransitionStep(step(0.8f)) + repository.sendTransitionStep(step(1f)) + deviceEntryParentViewAlpha.forEach { Truth.assertThat(it).isEqualTo(0f) } + } private fun step( value: Float, diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/BouncerToGoneFlowsTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/BouncerToGoneFlowsTest.kt index 1ff46db99624..c9b14a41edca 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/BouncerToGoneFlowsTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/BouncerToGoneFlowsTest.kt @@ -19,28 +19,26 @@ package com.android.systemui.keyguard.ui.viewmodel import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase -import com.android.systemui.bouncer.domain.interactor.PrimaryBouncerInteractor +import com.android.systemui.bouncer.domain.interactor.primaryBouncerInteractor import com.android.systemui.coroutines.collectValues -import com.android.systemui.flags.FakeFeatureFlags import com.android.systemui.flags.Flags -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.KeyguardDismissActionInteractor -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractorFactory +import com.android.systemui.flags.featureFlagsClassic +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.KeyguardState.PRIMARY_BOUNCER import com.android.systemui.keyguard.shared.model.ScrimAlpha import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.kosmos.testScope +import com.android.systemui.shade.data.repository.shadeRepository import com.android.systemui.shade.domain.interactor.ShadeInteractor -import com.android.systemui.statusbar.SysuiStatusBarStateController +import com.android.systemui.statusbar.sysuiStatusBarStateController +import com.android.systemui.testKosmos import com.android.systemui.util.mockito.whenever import com.google.common.collect.Range import com.google.common.truth.Truth.assertThat -import dagger.Lazy import kotlin.time.Duration.Companion.milliseconds import kotlinx.coroutines.flow.MutableStateFlow -import kotlinx.coroutines.test.TestScope -import kotlinx.coroutines.test.UnconfinedTestDispatcher import kotlinx.coroutines.test.runTest import org.junit.Before import org.junit.Test @@ -51,56 +49,47 @@ import org.mockito.MockitoAnnotations @SmallTest @RunWith(AndroidJUnit4::class) class BouncerToGoneFlowsTest : SysuiTestCase() { - private lateinit var underTest: BouncerToGoneFlows - private lateinit var repository: FakeKeyguardTransitionRepository - private lateinit var featureFlags: FakeFeatureFlags - @Mock private lateinit var statusBarStateController: SysuiStatusBarStateController - @Mock private lateinit var primaryBouncerInteractor: PrimaryBouncerInteractor - @Mock - private lateinit var keyguardDismissActionInteractor: Lazy<KeyguardDismissActionInteractor> @Mock private lateinit var shadeInteractor: ShadeInteractor private val shadeExpansionStateFlow = MutableStateFlow(0.1f) + private val kosmos = + testKosmos().apply { + featureFlagsClassic.apply { + set(Flags.REFACTOR_KEYGUARD_DISMISS_INTENT, false) + set(Flags.FULL_SCREEN_USER_SWITCHER, false) + } + } + private val testScope = kosmos.testScope + private val keyguardTransitionRepository = kosmos.fakeKeyguardTransitionRepository + private val shadeRepository = kosmos.shadeRepository + private val sysuiStatusBarStateController = kosmos.sysuiStatusBarStateController + private val primaryBouncerInteractor = kosmos.primaryBouncerInteractor + private val underTest = kosmos.bouncerToGoneFlows + @Before fun setUp() { MockitoAnnotations.initMocks(this) - whenever(shadeInteractor.shadeExpansion).thenReturn(shadeExpansionStateFlow) - - repository = FakeKeyguardTransitionRepository() - val featureFlags = - FakeFeatureFlags().apply { set(Flags.REFACTOR_KEYGUARD_DISMISS_INTENT, false) } - val interactor = - KeyguardTransitionInteractorFactory.create( - scope = TestScope().backgroundScope, - repository = repository, - ) - .keyguardTransitionInteractor - underTest = - BouncerToGoneFlows( - interactor, - statusBarStateController, - primaryBouncerInteractor, - keyguardDismissActionInteractor, - featureFlags, - shadeInteractor, - ) - whenever(primaryBouncerInteractor.willRunDismissFromKeyguard()).thenReturn(false) - whenever(statusBarStateController.leaveOpenOnKeyguardHide()).thenReturn(false) + sysuiStatusBarStateController.setLeaveOpenOnKeyguardHide(false) } @Test fun scrimAlpha_runDimissFromKeyguard_shadeExpanded() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { val values by collectValues(underTest.scrimAlpha(500.milliseconds, PRIMARY_BOUNCER)) - shadeExpansionStateFlow.value = 1f + shadeRepository.setLockscreenShadeExpansion(1f) whenever(primaryBouncerInteractor.willRunDismissFromKeyguard()).thenReturn(true) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.6f)) - repository.sendTransitionStep(step(1f)) + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0.3f), + step(0.6f), + step(1f), + ), + testScope, + ) assertThat(values.size).isEqualTo(4) values.forEach { assertThat(it.frontAlpha).isEqualTo(0f) } @@ -110,16 +99,21 @@ class BouncerToGoneFlowsTest : SysuiTestCase() { @Test fun scrimAlpha_runDimissFromKeyguard_shadeNotExpanded() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { val values by collectValues(underTest.scrimAlpha(500.milliseconds, PRIMARY_BOUNCER)) - shadeExpansionStateFlow.value = 0f + shadeRepository.setLockscreenShadeExpansion(0f) whenever(primaryBouncerInteractor.willRunDismissFromKeyguard()).thenReturn(true) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.6f)) - repository.sendTransitionStep(step(1f)) + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0.3f), + step(0.6f), + step(1f), + ), + testScope, + ) assertThat(values.size).isEqualTo(4) values.forEach { assertThat(it).isEqualTo(ScrimAlpha()) } @@ -127,15 +121,20 @@ class BouncerToGoneFlowsTest : SysuiTestCase() { @Test fun scrimBehindAlpha_leaveShadeOpen() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { val values by collectValues(underTest.scrimAlpha(500.milliseconds, PRIMARY_BOUNCER)) - whenever(statusBarStateController.leaveOpenOnKeyguardHide()).thenReturn(true) + sysuiStatusBarStateController.setLeaveOpenOnKeyguardHide(true) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.6f)) - repository.sendTransitionStep(step(1f)) + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0.3f), + step(0.6f), + step(1f), + ), + testScope, + ) assertThat(values.size).isEqualTo(4) values.forEach { @@ -145,15 +144,17 @@ class BouncerToGoneFlowsTest : SysuiTestCase() { @Test fun scrimBehindAlpha_doNotLeaveShadeOpen() = - runTest(UnconfinedTestDispatcher()) { + testScope.runTest { val values by collectValues(underTest.scrimAlpha(500.milliseconds, PRIMARY_BOUNCER)) - - whenever(statusBarStateController.leaveOpenOnKeyguardHide()).thenReturn(false) - - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.6f)) - repository.sendTransitionStep(step(1f)) + keyguardTransitionRepository.sendTransitionSteps( + listOf( + step(0f, TransitionState.STARTED), + step(0.3f), + step(0.6f), + step(1f), + ), + testScope, + ) assertThat(values.size).isEqualTo(4) values.forEach { assertThat(it.notificationsAlpha).isEqualTo(0f) } diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/DozingToLockscreenTransitionViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/DozingToLockscreenTransitionViewModelTest.kt index 5dccc3b1d05f..dd542d482745 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/DozingToLockscreenTransitionViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/DozingToLockscreenTransitionViewModelTest.kt @@ -25,6 +25,8 @@ import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInterac import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.keyguard.ui.KeyguardTransitionAnimationFlow +import com.android.systemui.util.mockito.mock import com.google.common.truth.Truth.assertThat import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.test.TestScope @@ -43,29 +45,36 @@ class DozingToLockscreenTransitionViewModelTest : SysuiTestCase() { @Before fun setUp() { + testScope = TestScope() repository = FakeKeyguardTransitionRepository() underTest = DozingToLockscreenTransitionViewModel( interactor = KeyguardTransitionInteractorFactory.create( - scope = TestScope().backgroundScope, + scope = testScope.backgroundScope, repository = repository, ) .keyguardTransitionInteractor, + animationFlow = + KeyguardTransitionAnimationFlow( + scope = testScope.backgroundScope, + logger = mock() + ), ) } @Test - fun deviceEntryParentViewShows() = runTest { - val deviceEntryParentViewAlpha by collectValues(underTest.deviceEntryParentViewAlpha) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.1f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.5f)) - repository.sendTransitionStep(step(0.6f)) - repository.sendTransitionStep(step(1f)) - deviceEntryParentViewAlpha.forEach { assertThat(it).isEqualTo(1f) } - } + fun deviceEntryParentViewShows() = + testScope.runTest { + val deviceEntryParentViewAlpha by collectValues(underTest.deviceEntryParentViewAlpha) + repository.sendTransitionStep(step(0f, TransitionState.STARTED)) + repository.sendTransitionStep(step(0.1f)) + repository.sendTransitionStep(step(0.3f)) + repository.sendTransitionStep(step(0.5f)) + repository.sendTransitionStep(step(0.6f)) + repository.sendTransitionStep(step(1f)) + deviceEntryParentViewAlpha.forEach { assertThat(it).isEqualTo(1f) } + } private fun step( value: Float, diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/GoneToAodTransitionViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/GoneToAodTransitionViewModelTest.kt index c1444a55f7d9..a105008f3f37 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/GoneToAodTransitionViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/GoneToAodTransitionViewModelTest.kt @@ -19,23 +19,19 @@ package com.android.systemui.keyguard.ui.viewmodel import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase -import com.android.systemui.biometrics.data.repository.FakeFingerprintPropertyRepository +import com.android.systemui.biometrics.data.repository.fingerprintPropertyRepository import com.android.systemui.coroutines.collectLastValue -import com.android.systemui.deviceentry.domain.interactor.DeviceEntryUdfpsInteractor -import com.android.systemui.keyguard.data.repository.FakeBiometricSettingsRepository -import com.android.systemui.keyguard.data.repository.FakeDeviceEntryFingerprintAuthRepository -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractorFactory +import com.android.systemui.keyguard.data.repository.biometricSettingsRepository +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.kosmos.testScope +import com.android.systemui.testKosmos import com.google.common.collect.Range import com.google.common.truth.Truth.assertThat import kotlinx.coroutines.ExperimentalCoroutinesApi -import kotlinx.coroutines.test.StandardTestDispatcher -import kotlinx.coroutines.test.TestScope import kotlinx.coroutines.test.runTest -import org.junit.Before import org.junit.Test import org.junit.runner.RunWith @@ -43,37 +39,12 @@ import org.junit.runner.RunWith @SmallTest @RunWith(AndroidJUnit4::class) class GoneToAodTransitionViewModelTest : SysuiTestCase() { - private lateinit var underTest: GoneToAodTransitionViewModel - private lateinit var repository: FakeKeyguardTransitionRepository - private lateinit var fingerprintPropertyRepository: FakeFingerprintPropertyRepository - private lateinit var biometricSettingsRepository: FakeBiometricSettingsRepository - private lateinit var testScope: TestScope - - @Before - fun setUp() { - val testDispatcher = StandardTestDispatcher() - testScope = TestScope(testDispatcher) - - repository = FakeKeyguardTransitionRepository() - fingerprintPropertyRepository = FakeFingerprintPropertyRepository() - biometricSettingsRepository = FakeBiometricSettingsRepository() - - underTest = - GoneToAodTransitionViewModel( - interactor = - KeyguardTransitionInteractorFactory.create( - scope = testScope.backgroundScope, - repository = repository, - ) - .keyguardTransitionInteractor, - deviceEntryUdfpsInteractor = - DeviceEntryUdfpsInteractor( - fingerprintPropertyRepository = fingerprintPropertyRepository, - fingerprintAuthRepository = FakeDeviceEntryFingerprintAuthRepository(), - biometricSettingsRepository = biometricSettingsRepository, - ), - ) - } + private val kosmos = testKosmos() + private val testScope = kosmos.testScope + private val repository = kosmos.fakeKeyguardTransitionRepository + private val underTest = kosmos.goneToAodTransitionViewModel + private val fingerprintPropertyRepository = kosmos.fingerprintPropertyRepository + private val biometricSettingsRepository = kosmos.biometricSettingsRepository @Test fun enterFromTopTranslationY() = diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardIndicationAreaViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardIndicationAreaViewModelTest.kt index 88a4aa509c37..864acfb1ddb9 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardIndicationAreaViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardIndicationAreaViewModelTest.kt @@ -17,7 +17,10 @@ package com.android.systemui.keyguard.ui.viewmodel import androidx.test.filters.SmallTest +import com.android.systemui.Flags as AConfigFlags import com.android.systemui.SysuiTestCase +import com.android.systemui.common.ui.data.repository.FakeConfigurationRepository +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor import com.android.systemui.coroutines.collectLastValue import com.android.systemui.doze.util.BurnInHelperWrapper import com.android.systemui.keyguard.data.repository.FakeKeyguardRepository @@ -65,6 +68,9 @@ class KeyguardIndicationAreaViewModelTest : SysuiTestCase() { @Before fun setUp() { MockitoAnnotations.initMocks(this) + + mSetFlagsRule.disableFlags(AConfigFlags.FLAG_KEYGUARD_BOTTOM_AREA_REFACTOR) + whenever(burnInHelperWrapper.burnInOffset(anyInt(), any())) .thenReturn(RETURNED_BURN_IN_OFFSET) @@ -83,6 +89,7 @@ class KeyguardIndicationAreaViewModelTest : SysuiTestCase() { keyguardBottomAreaViewModel = bottomAreaViewModel, burnInHelperWrapper = burnInHelperWrapper, shortcutsCombinedViewModel = shortcutsCombinedViewModel, + configurationInteractor = ConfigurationInteractor(FakeConfigurationRepository()), ) } diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardRootViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardRootViewModelTest.kt index bc60364f27cb..bc0e4164de20 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardRootViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardRootViewModelTest.kt @@ -24,48 +24,41 @@ import androidx.test.filters.SmallTest import com.android.keyguard.KeyguardClockSwitch.LARGE import com.android.systemui.Flags as AConfigFlags import com.android.systemui.Flags.FLAG_NEW_AOD_TRANSITION -import com.android.systemui.SysUITestComponent -import com.android.systemui.SysUITestModule import com.android.systemui.SysuiTestCase -import com.android.systemui.TestMocksModule import com.android.systemui.collectLastValue -import com.android.systemui.common.ui.data.repository.FakeConfigurationRepository +import com.android.systemui.common.ui.data.repository.fakeConfigurationRepository +import com.android.systemui.common.ui.domain.interactor.configurationInteractor import com.android.systemui.coroutines.collectLastValue -import com.android.systemui.dagger.SysUISingleton -import com.android.systemui.deviceentry.data.repository.FakeDeviceEntryRepository -import com.android.systemui.flags.FakeFeatureFlagsClassic -import com.android.systemui.flags.FakeFeatureFlagsClassicModule +import com.android.systemui.deviceentry.data.repository.fakeDeviceEntryRepository +import com.android.systemui.deviceentry.domain.interactor.deviceEntryInteractor import com.android.systemui.flags.Flags -import com.android.systemui.keyguard.data.repository.FakeKeyguardRepository -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository +import com.android.systemui.flags.featureFlagsClassic +import com.android.systemui.keyguard.data.repository.fakeKeyguardRepository +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.domain.interactor.BurnInInteractor -import com.android.systemui.keyguard.domain.interactor.KeyguardInteractor -import com.android.systemui.keyguard.domain.interactor.KeyguardInteractorFactory -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractor +import com.android.systemui.keyguard.domain.interactor.keyguardInteractor +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor import com.android.systemui.keyguard.shared.model.BurnInModel import com.android.systemui.keyguard.shared.model.KeyguardState +import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.kosmos.testScope import com.android.systemui.plugins.ClockController -import com.android.systemui.runCurrent -import com.android.systemui.runTest -import com.android.systemui.statusbar.notification.data.repository.FakeNotificationsKeyguardViewStateRepository -import com.android.systemui.statusbar.phone.DozeParameters -import com.android.systemui.statusbar.phone.ScreenOffAnimationController -import com.android.systemui.util.mockito.mock +import com.android.systemui.statusbar.notification.data.repository.fakeNotificationsKeyguardViewStateRepository +import com.android.systemui.statusbar.notification.stack.domain.interactor.notificationsKeyguardInteractor +import com.android.systemui.statusbar.phone.dozeParameters +import com.android.systemui.statusbar.phone.screenOffAnimationController +import com.android.systemui.testKosmos import com.android.systemui.util.mockito.whenever import com.android.systemui.util.ui.isAnimating import com.android.systemui.util.ui.stopAnimating import com.android.systemui.util.ui.value import com.google.common.truth.Truth.assertThat -import dagger.BindsInstance -import dagger.Component import javax.inject.Provider import kotlinx.coroutines.ExperimentalCoroutinesApi -import kotlinx.coroutines.flow.MutableSharedFlow import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.emptyFlow -import kotlinx.coroutines.test.StandardTestDispatcher -import kotlinx.coroutines.test.TestScope +import kotlinx.coroutines.test.runCurrent import kotlinx.coroutines.test.runTest import org.junit.Before import org.junit.Test @@ -75,49 +68,48 @@ import org.mockito.Answers import org.mockito.Mock import org.mockito.Mockito.RETURNS_DEEP_STUBS import org.mockito.Mockito.anyInt -import org.mockito.Mockito.reset -import org.mockito.Mockito.withSettings import org.mockito.MockitoAnnotations @SmallTest @RunWith(JUnit4::class) class KeyguardRootViewModelTest : SysuiTestCase() { + private val kosmos = testKosmos().apply { + featureFlagsClassic.apply { set(Flags.MIGRATE_CLOCKS_TO_BLUEPRINT, false) } + } + private val testScope = kosmos.testScope + private val repository = kosmos.fakeKeyguardRepository + private val configurationRepository = kosmos.fakeConfigurationRepository + private val keyguardTransitionRepository = kosmos.fakeKeyguardTransitionRepository + private val screenOffAnimationController = kosmos.screenOffAnimationController + private val deviceEntryRepository = kosmos.fakeDeviceEntryRepository + private val notificationsKeyguardInteractor = kosmos.notificationsKeyguardInteractor + private val fakeNotificationsKeyguardViewStateRepository = + kosmos.fakeNotificationsKeyguardViewStateRepository + private val dozeParameters = kosmos.dozeParameters private lateinit var underTest: KeyguardRootViewModel - private lateinit var testScope: TestScope - private lateinit var repository: FakeKeyguardRepository - private lateinit var keyguardInteractor: KeyguardInteractor - private lateinit var configurationRepository: FakeConfigurationRepository + @Mock private lateinit var burnInInteractor: BurnInInteractor - @Mock private lateinit var keyguardClockViewModel: KeyguardClockViewModel - @Mock private lateinit var keyguardTransitionInteractor: KeyguardTransitionInteractor + private val burnInFlow = MutableStateFlow(BurnInModel()) + @Mock private lateinit var goneToAodTransitionViewModel: GoneToAodTransitionViewModel + private val enterFromTopAnimationAlpha = MutableStateFlow(0f) + @Mock private lateinit var aodToLockscreenTransitionViewModel: AodToLockscreenTransitionViewModel - @Mock(answer = Answers.RETURNS_DEEP_STUBS) private lateinit var clockController: ClockController + @Mock + private lateinit var occludedToLockscreenTransitionViewModel: + OccludedToLockscreenTransitionViewModel + private val occludedToLockscreenTranslationY = MutableStateFlow(0f) + private val occludedToLockscreenAlpha = MutableStateFlow(0f) - private val burnInFlow = MutableStateFlow(BurnInModel()) - private val goneToAodTransitionViewModelVisibility = MutableStateFlow(0) - private val enterFromTopAnimationAlpha = MutableStateFlow(0f) - private val goneToAodTransitionStep = MutableSharedFlow<TransitionStep>(replay = 1) - private val dozeAmountTransitionStep = MutableSharedFlow<TransitionStep>(replay = 1) - private val clockSize = MutableStateFlow(LARGE) - private val startedKeyguardState = MutableStateFlow(KeyguardState.GONE) - private val featureFlags: FakeFeatureFlagsClassic = FakeFeatureFlagsClassic() + @Mock(answer = Answers.RETURNS_DEEP_STUBS) private lateinit var clockController: ClockController @Before fun setUp() { - val testDispatcher = StandardTestDispatcher() - testScope = TestScope(testDispatcher) MockitoAnnotations.initMocks(this) mSetFlagsRule.enableFlags(AConfigFlags.FLAG_KEYGUARD_BOTTOM_AREA_REFACTOR) - - featureFlags.set(Flags.MIGRATE_CLOCKS_TO_BLUEPRINT, false) - - val withDeps = KeyguardInteractorFactory.create(featureFlags = featureFlags) - keyguardInteractor = withDeps.keyguardInteractor - repository = withDeps.repository - configurationRepository = withDeps.configurationRepository + mSetFlagsRule.enableFlags(FLAG_NEW_AOD_TRANSITION) whenever(goneToAodTransitionViewModel.enterFromTopTranslationY(anyInt())) .thenReturn(emptyFlow<Float>()) @@ -126,34 +118,29 @@ class KeyguardRootViewModelTest : SysuiTestCase() { whenever(burnInInteractor.keyguardBurnIn).thenReturn(burnInFlow) - whenever(keyguardTransitionInteractor.goneToAodTransition) - .thenReturn(goneToAodTransitionStep) - whenever(keyguardTransitionInteractor.dozeAmountTransition) - .thenReturn(dozeAmountTransitionStep) - whenever(keyguardTransitionInteractor.startedKeyguardState).thenReturn(startedKeyguardState) - whenever(keyguardClockViewModel.clockSize).thenReturn(clockSize) + whenever(occludedToLockscreenTransitionViewModel.lockscreenTranslationY) + .thenReturn(occludedToLockscreenTranslationY) + whenever(occludedToLockscreenTransitionViewModel.lockscreenAlpha) + .thenReturn(occludedToLockscreenAlpha) underTest = KeyguardRootViewModel( - context, - deviceEntryInteractor = - mock { whenever(isBypassEnabled).thenReturn(MutableStateFlow(false)) }, - dozeParameters = mock(), - keyguardInteractor, - keyguardTransitionInteractor, - notificationsKeyguardInteractor = - mock { - whenever(areNotificationsFullyHidden).thenReturn(emptyFlow()) - whenever(isPulseExpanding).thenReturn(emptyFlow()) - }, - burnInInteractor, - keyguardClockViewModel, - goneToAodTransitionViewModel, - aodToLockscreenTransitionViewModel, - screenOffAnimationController = mock(), + configurationInteractor = kosmos.configurationInteractor, + deviceEntryInteractor = kosmos.deviceEntryInteractor, + dozeParameters = kosmos.dozeParameters, + keyguardInteractor = kosmos.keyguardInteractor, + keyguardTransitionInteractor = kosmos.keyguardTransitionInteractor, + notificationsKeyguardInteractor = kosmos.notificationsKeyguardInteractor, + burnInInteractor = burnInInteractor, + keyguardClockViewModel = kosmos.keyguardClockViewModel, + goneToAodTransitionViewModel = goneToAodTransitionViewModel, + aodToLockscreenTransitionViewModel = aodToLockscreenTransitionViewModel, + occludedToLockscreenTransitionViewModel = occludedToLockscreenTransitionViewModel, + screenOffAnimationController = screenOffAnimationController, // TODO(b/310989341): remove after change to aconfig - featureFlags + featureFlags = kosmos.featureFlagsClassic ) + underTest.clockControllerProvider = Provider { clockController } } @@ -161,8 +148,8 @@ class KeyguardRootViewModelTest : SysuiTestCase() { fun alpha() = testScope.runTest { val value = collectLastValue(underTest.alpha) + assertThat(value()).isEqualTo(0f) - assertThat(value()).isEqualTo(1f) repository.setKeyguardAlpha(0.1f) assertThat(value()).isEqualTo(0.1f) repository.setKeyguardAlpha(0.5f) @@ -171,6 +158,8 @@ class KeyguardRootViewModelTest : SysuiTestCase() { assertThat(value()).isEqualTo(0.2f) repository.setKeyguardAlpha(0f) assertThat(value()).isEqualTo(0f) + occludedToLockscreenAlpha.value = 0.8f + assertThat(value()).isEqualTo(0.8f) } @Test @@ -181,7 +170,15 @@ class KeyguardRootViewModelTest : SysuiTestCase() { val scale by collectLastValue(underTest.scale) // Set to not dozing (on lockscreen) - dozeAmountTransitionStep.emit(TransitionStep(value = 0f)) + keyguardTransitionRepository.sendTransitionStep( + TransitionStep( + from = KeyguardState.AOD, + to = KeyguardState.LOCKSCREEN, + value = 1f, + transitionState = TransitionState.FINISHED + ), + validateStep = false, + ) // Trigger a change to the burn-in model burnInFlow.value = @@ -206,7 +203,15 @@ class KeyguardRootViewModelTest : SysuiTestCase() { underTest.statusViewTop = 100 // Set to dozing (on AOD) - dozeAmountTransitionStep.emit(TransitionStep(value = 1f)) + keyguardTransitionRepository.sendTransitionStep( + TransitionStep( + from = KeyguardState.GONE, + to = KeyguardState.AOD, + value = 1f, + transitionState = TransitionState.FINISHED + ), + validateStep = false, + ) // Trigger a change to the burn-in model burnInFlow.value = BurnInModel( @@ -214,12 +219,21 @@ class KeyguardRootViewModelTest : SysuiTestCase() { translationY = 30, scale = 0.5f, ) + assertThat(translationX).isEqualTo(20) assertThat(translationY).isEqualTo(30) assertThat(scale).isEqualTo(Pair(0.5f, true /* scaleClockOnly */)) // Set to the beginning of GONE->AOD transition - goneToAodTransitionStep.emit(TransitionStep(value = 0f)) + keyguardTransitionRepository.sendTransitionStep( + TransitionStep( + from = KeyguardState.GONE, + to = KeyguardState.AOD, + value = 0f, + transitionState = TransitionState.STARTED + ), + validateStep = false, + ) assertThat(translationX).isEqualTo(0) assertThat(translationY).isEqualTo(0) assertThat(scale).isEqualTo(Pair(1f, true /* scaleClockOnly */)) @@ -236,7 +250,16 @@ class KeyguardRootViewModelTest : SysuiTestCase() { underTest.topInset = 80 // Set to dozing (on AOD) - dozeAmountTransitionStep.emit(TransitionStep(value = 1f)) + keyguardTransitionRepository.sendTransitionStep( + TransitionStep( + from = KeyguardState.GONE, + to = KeyguardState.AOD, + value = 1f, + transitionState = TransitionState.FINISHED + ), + validateStep = false, + ) + // Trigger a change to the burn-in model burnInFlow.value = BurnInModel( @@ -250,7 +273,15 @@ class KeyguardRootViewModelTest : SysuiTestCase() { assertThat(scale).isEqualTo(Pair(0.5f, true /* scaleClockOnly */)) // Set to the beginning of GONE->AOD transition - goneToAodTransitionStep.emit(TransitionStep(value = 0f)) + keyguardTransitionRepository.sendTransitionStep( + TransitionStep( + from = KeyguardState.GONE, + to = KeyguardState.AOD, + value = 0f, + transitionState = TransitionState.STARTED + ), + validateStep = false, + ) assertThat(translationX).isEqualTo(0) assertThat(translationY).isEqualTo(0) assertThat(scale).isEqualTo(Pair(1f, true /* scaleClockOnly */)) @@ -266,7 +297,15 @@ class KeyguardRootViewModelTest : SysuiTestCase() { val scale by collectLastValue(underTest.scale) // Set to dozing (on AOD) - dozeAmountTransitionStep.emit(TransitionStep(value = 1f)) + keyguardTransitionRepository.sendTransitionStep( + TransitionStep( + from = KeyguardState.GONE, + to = KeyguardState.AOD, + value = 1f, + transitionState = TransitionState.FINISHED + ), + validateStep = false, + ) // Trigger a change to the burn-in model burnInFlow.value = @@ -286,10 +325,15 @@ class KeyguardRootViewModelTest : SysuiTestCase() { testScope.runTest { val burnInLayerVisibility by collectLastValue(underTest.burnInLayerVisibility) - startedKeyguardState.value = KeyguardState.OCCLUDED - assertThat(burnInLayerVisibility).isNull() - - startedKeyguardState.value = KeyguardState.AOD + keyguardTransitionRepository.sendTransitionStep( + TransitionStep( + from = KeyguardState.LOCKSCREEN, + to = KeyguardState.AOD, + value = 0f, + transitionState = TransitionState.STARTED + ), + validateStep = false, + ) assertThat(burnInLayerVisibility).isEqualTo(View.VISIBLE) } @@ -304,165 +348,124 @@ class KeyguardRootViewModelTest : SysuiTestCase() { enterFromTopAnimationAlpha.value = 1f assertThat(burnInLayerAlpha).isEqualTo(1f) } -} - -@SmallTest -class KeyguardRootViewModelTestWithFakes : SysuiTestCase() { - - @Component(modules = [SysUITestModule::class]) - @SysUISingleton - interface TestComponent : SysUITestComponent<KeyguardRootViewModel> { - val deviceEntryRepository: FakeDeviceEntryRepository - val notifsKeyguardRepository: FakeNotificationsKeyguardViewStateRepository - val repository: FakeKeyguardRepository - val transitionRepository: FakeKeyguardTransitionRepository - - @Component.Factory - interface Factory { - fun create( - @BindsInstance test: SysuiTestCase, - featureFlags: FakeFeatureFlagsClassicModule, - mocks: TestMocksModule, - ): TestComponent - } - } - private val clockController: ClockController = - mock(withSettings().defaultAnswer(RETURNS_DEEP_STUBS)) - private val dozeParams: DozeParameters = mock() - private val screenOffAnimController: ScreenOffAnimationController = mock() - - private fun runTest(block: suspend TestComponent.() -> Unit): Unit = - DaggerKeyguardRootViewModelTestWithFakes_TestComponent.factory() - .create( - test = this, - featureFlags = FakeFeatureFlagsClassicModule(), - mocks = - TestMocksModule( - dozeParameters = dozeParams, - screenOffAnimationController = screenOffAnimController, - ), + @Test + fun iconContainer_isNotVisible_notOnKeyguard_dontShowAodIconsWhenShade() = + testScope.runTest { + val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) + runCurrent() + keyguardTransitionRepository.sendTransitionSteps( + from = KeyguardState.OFF, + to = KeyguardState.GONE, + testScope, ) - .runTest { - reset(clockController) - underTest.clockControllerProvider = Provider { clockController } - block() - } - - @Before - fun before() { - mSetFlagsRule.enableFlags(FLAG_NEW_AOD_TRANSITION) - } + whenever(screenOffAnimationController.shouldShowAodIconsWhenShade()).thenReturn(false) + runCurrent() - @Test - fun iconContainer_isNotVisible_notOnKeyguard_dontShowAodIconsWhenShade() = runTest { - val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) - runCurrent() - transitionRepository.sendTransitionSteps( - from = KeyguardState.OFF, - to = KeyguardState.GONE, - testScope, - ) - whenever(screenOffAnimController.shouldShowAodIconsWhenShade()).thenReturn(false) - runCurrent() - - assertThat(isVisible?.value).isFalse() - assertThat(isVisible?.isAnimating).isFalse() - } + assertThat(isVisible?.value).isFalse() + assertThat(isVisible?.isAnimating).isFalse() + } @Test - fun iconContainer_isVisible_bypassEnabled() = runTest { - val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) - runCurrent() - deviceEntryRepository.setBypassEnabled(true) - runCurrent() + fun iconContainer_isVisible_bypassEnabled() = + testScope.runTest { + val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) + runCurrent() + deviceEntryRepository.setBypassEnabled(true) + runCurrent() - assertThat(isVisible?.value).isTrue() - } + assertThat(isVisible?.value).isTrue() + } @Test - fun iconContainer_isNotVisible_pulseExpanding_notBypassing() = runTest { - val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) - runCurrent() - notifsKeyguardRepository.setPulseExpanding(true) - deviceEntryRepository.setBypassEnabled(false) - runCurrent() - - assertThat(isVisible?.value).isEqualTo(false) - } + fun iconContainer_isNotVisible_pulseExpanding_notBypassing() = + testScope.runTest { + val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) + runCurrent() + fakeNotificationsKeyguardViewStateRepository.setPulseExpanding(true) + deviceEntryRepository.setBypassEnabled(false) + runCurrent() + + assertThat(isVisible?.value).isEqualTo(false) + } @Test - fun iconContainer_isVisible_notifsFullyHidden_bypassEnabled() = runTest { - val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) - runCurrent() - notifsKeyguardRepository.setPulseExpanding(false) - deviceEntryRepository.setBypassEnabled(true) - notifsKeyguardRepository.setNotificationsFullyHidden(true) - runCurrent() - - assertThat(isVisible?.value).isTrue() - assertThat(isVisible?.isAnimating).isTrue() - } + fun iconContainer_isVisible_notifsFullyHidden_bypassEnabled() = + testScope.runTest { + val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) + runCurrent() + fakeNotificationsKeyguardViewStateRepository.setPulseExpanding(false) + deviceEntryRepository.setBypassEnabled(true) + fakeNotificationsKeyguardViewStateRepository.setNotificationsFullyHidden(true) + runCurrent() + + assertThat(isVisible?.value).isTrue() + assertThat(isVisible?.isAnimating).isTrue() + } @Test - fun iconContainer_isVisible_notifsFullyHidden_bypassDisabled_aodDisabled() = runTest { - val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) - runCurrent() - notifsKeyguardRepository.setPulseExpanding(false) - deviceEntryRepository.setBypassEnabled(false) - whenever(dozeParams.alwaysOn).thenReturn(false) - notifsKeyguardRepository.setNotificationsFullyHidden(true) - runCurrent() - - assertThat(isVisible?.value).isTrue() - assertThat(isVisible?.isAnimating).isFalse() - } + fun iconContainer_isVisible_notifsFullyHidden_bypassDisabled_aodDisabled() = + testScope.runTest { + val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) + runCurrent() + fakeNotificationsKeyguardViewStateRepository.setPulseExpanding(false) + deviceEntryRepository.setBypassEnabled(false) + whenever(dozeParameters.alwaysOn).thenReturn(false) + fakeNotificationsKeyguardViewStateRepository.setNotificationsFullyHidden(true) + runCurrent() + + assertThat(isVisible?.value).isTrue() + assertThat(isVisible?.isAnimating).isFalse() + } @Test - fun iconContainer_isVisible_notifsFullyHidden_bypassDisabled_displayNeedsBlanking() = runTest { - val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) - runCurrent() - notifsKeyguardRepository.setPulseExpanding(false) - deviceEntryRepository.setBypassEnabled(false) - whenever(dozeParams.alwaysOn).thenReturn(true) - whenever(dozeParams.displayNeedsBlanking).thenReturn(true) - notifsKeyguardRepository.setNotificationsFullyHidden(true) - runCurrent() - - assertThat(isVisible?.value).isTrue() - assertThat(isVisible?.isAnimating).isFalse() - } + fun iconContainer_isVisible_notifsFullyHidden_bypassDisabled_displayNeedsBlanking() = + testScope.runTest { + val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) + runCurrent() + fakeNotificationsKeyguardViewStateRepository.setPulseExpanding(false) + deviceEntryRepository.setBypassEnabled(false) + whenever(dozeParameters.alwaysOn).thenReturn(true) + whenever(dozeParameters.displayNeedsBlanking).thenReturn(true) + fakeNotificationsKeyguardViewStateRepository.setNotificationsFullyHidden(true) + runCurrent() + + assertThat(isVisible?.value).isTrue() + assertThat(isVisible?.isAnimating).isFalse() + } @Test - fun iconContainer_isVisible_notifsFullyHidden_bypassDisabled() = runTest { - val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) - runCurrent() - notifsKeyguardRepository.setPulseExpanding(false) - deviceEntryRepository.setBypassEnabled(false) - whenever(dozeParams.alwaysOn).thenReturn(true) - whenever(dozeParams.displayNeedsBlanking).thenReturn(false) - notifsKeyguardRepository.setNotificationsFullyHidden(true) - runCurrent() - - assertThat(isVisible?.value).isTrue() - assertThat(isVisible?.isAnimating).isTrue() - } + fun iconContainer_isVisible_notifsFullyHidden_bypassDisabled() = + testScope.runTest { + val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) + runCurrent() + fakeNotificationsKeyguardViewStateRepository.setPulseExpanding(false) + deviceEntryRepository.setBypassEnabled(false) + whenever(dozeParameters.alwaysOn).thenReturn(true) + whenever(dozeParameters.displayNeedsBlanking).thenReturn(false) + fakeNotificationsKeyguardViewStateRepository.setNotificationsFullyHidden(true) + runCurrent() + + assertThat(isVisible?.value).isTrue() + assertThat(isVisible?.isAnimating).isTrue() + } @Test - fun isIconContainerVisible_stopAnimation() = runTest { - val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) - runCurrent() - notifsKeyguardRepository.setPulseExpanding(false) - deviceEntryRepository.setBypassEnabled(false) - whenever(dozeParams.alwaysOn).thenReturn(true) - whenever(dozeParams.displayNeedsBlanking).thenReturn(false) - notifsKeyguardRepository.setNotificationsFullyHidden(true) - runCurrent() - - assertThat(isVisible?.isAnimating).isEqualTo(true) - isVisible?.stopAnimating() - runCurrent() - - assertThat(isVisible?.isAnimating).isEqualTo(false) - } + fun isIconContainerVisible_stopAnimation() = + testScope.runTest { + val isVisible by collectLastValue(underTest.isNotifIconContainerVisible) + runCurrent() + fakeNotificationsKeyguardViewStateRepository.setPulseExpanding(false) + deviceEntryRepository.setBypassEnabled(false) + whenever(dozeParameters.alwaysOn).thenReturn(true) + whenever(dozeParameters.displayNeedsBlanking).thenReturn(false) + fakeNotificationsKeyguardViewStateRepository.setNotificationsFullyHidden(true) + runCurrent() + + assertThat(isVisible?.isAnimating).isEqualTo(true) + isVisible?.stopAnimating() + runCurrent() + + assertThat(isVisible?.isAnimating).isEqualTo(false) + } } diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToAodTransitionViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToAodTransitionViewModelTest.kt index 2314c8358ff8..c15a2c6a3df7 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToAodTransitionViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToAodTransitionViewModelTest.kt @@ -18,88 +18,47 @@ package com.android.systemui.keyguard.ui.viewmodel import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest -import com.android.systemui.SysUITestComponent -import com.android.systemui.SysUITestModule import com.android.systemui.SysuiTestCase -import com.android.systemui.TestMocksModule -import com.android.systemui.biometrics.data.repository.FakeFingerprintPropertyRepository -import com.android.systemui.collectLastValue -import com.android.systemui.collectValues -import com.android.systemui.dagger.SysUISingleton -import com.android.systemui.deviceentry.data.repository.FakeDeviceEntryRepository -import com.android.systemui.flags.FakeFeatureFlagsClassicModule +import com.android.systemui.biometrics.data.repository.fingerprintPropertyRepository +import com.android.systemui.coroutines.collectLastValue +import com.android.systemui.coroutines.collectValues import com.android.systemui.flags.Flags.FULL_SCREEN_USER_SWITCHER -import com.android.systemui.keyguard.data.repository.FakeBiometricSettingsRepository -import com.android.systemui.keyguard.data.repository.FakeKeyguardRepository -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository +import com.android.systemui.flags.featureFlagsClassic +import com.android.systemui.keyguard.data.repository.biometricSettingsRepository +import com.android.systemui.keyguard.data.repository.fakeKeyguardRepository +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.StatusBarState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep -import com.android.systemui.runCurrent -import com.android.systemui.runTest -import com.android.systemui.shade.data.repository.FakeShadeRepository -import com.android.systemui.user.domain.UserDomainLayerModule +import com.android.systemui.kosmos.testScope +import com.android.systemui.shade.data.repository.shadeRepository +import com.android.systemui.testKosmos import com.google.common.collect.Range import com.google.common.truth.Truth.assertThat -import dagger.BindsInstance -import dagger.Component import kotlin.test.Test import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.test.runCurrent +import kotlinx.coroutines.test.runTest import org.junit.runner.RunWith @ExperimentalCoroutinesApi @SmallTest @RunWith(AndroidJUnit4::class) class LockscreenToAodTransitionViewModelTest : SysuiTestCase() { - @SysUISingleton - @Component( - modules = - [ - SysUITestModule::class, - UserDomainLayerModule::class, - ] - ) - interface TestComponent : SysUITestComponent<LockscreenToAodTransitionViewModel> { - val repository: FakeKeyguardTransitionRepository - val deviceEntryRepository: FakeDeviceEntryRepository - val keyguardRepository: FakeKeyguardRepository - val shadeRepository: FakeShadeRepository - val fingerprintPropertyRepository: FakeFingerprintPropertyRepository - val biometricSettingsRepository: FakeBiometricSettingsRepository - - @Component.Factory - interface Factory { - fun create( - @BindsInstance test: SysuiTestCase, - featureFlags: FakeFeatureFlagsClassicModule, - mocks: TestMocksModule, - ): TestComponent - } - } - - private fun TestComponent.shadeExpanded(expanded: Boolean) { - if (expanded) { - shadeRepository.setQsExpansion(1f) - } else { - keyguardRepository.setStatusBarState(StatusBarState.KEYGUARD) - shadeRepository.setQsExpansion(0f) - shadeRepository.setLockscreenShadeExpansion(0f) - } - } - - private val testComponent: TestComponent = - DaggerLockscreenToAodTransitionViewModelTest_TestComponent.factory() - .create( - test = this, - featureFlags = - FakeFeatureFlagsClassicModule { set(FULL_SCREEN_USER_SWITCHER, true) }, - mocks = TestMocksModule(), - ) + private val kosmos = + testKosmos().apply { featureFlagsClassic.apply { set(FULL_SCREEN_USER_SWITCHER, false) } } + private val testScope = kosmos.testScope + private val repository = kosmos.fakeKeyguardTransitionRepository + private val shadeRepository = kosmos.shadeRepository + private val keyguardRepository = kosmos.fakeKeyguardRepository + private val fingerprintPropertyRepository = kosmos.fingerprintPropertyRepository + private val biometricSettingsRepository = kosmos.biometricSettingsRepository + private val underTest = kosmos.lockscreenToAodTransitionViewModel @Test fun backgroundViewAlpha_shadeNotExpanded() = - testComponent.runTest { + testScope.runTest { val actual by collectLastValue(underTest.deviceEntryBackgroundViewAlpha) shadeExpanded(false) runCurrent() @@ -121,7 +80,7 @@ class LockscreenToAodTransitionViewModelTest : SysuiTestCase() { @Test fun backgroundViewAlpha_shadeExpanded() = - testComponent.runTest { + testScope.runTest { val actual by collectLastValue(underTest.deviceEntryBackgroundViewAlpha) shadeExpanded(true) runCurrent() @@ -142,7 +101,7 @@ class LockscreenToAodTransitionViewModelTest : SysuiTestCase() { @Test fun deviceEntryParentViewAlpha_udfpsEnrolled_shadeNotExpanded() = - testComponent.runTest { + testScope.runTest { val values by collectValues(underTest.deviceEntryParentViewAlpha) fingerprintPropertyRepository.supportsUdfps() biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(true) @@ -165,7 +124,7 @@ class LockscreenToAodTransitionViewModelTest : SysuiTestCase() { @Test fun deviceEntryParentViewAlpha_udfpsEnrolled_shadeExpanded() = - testComponent.runTest { + testScope.runTest { val actual by collectLastValue(underTest.deviceEntryParentViewAlpha) fingerprintPropertyRepository.supportsUdfps() biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(true) @@ -189,7 +148,7 @@ class LockscreenToAodTransitionViewModelTest : SysuiTestCase() { @Test fun deviceEntryParentViewAlpha_rearFp_shadeNotExpanded() = - testComponent.runTest { + testScope.runTest { val actual by collectLastValue(underTest.deviceEntryParentViewAlpha) fingerprintPropertyRepository.supportsRearFps() shadeExpanded(false) @@ -212,7 +171,7 @@ class LockscreenToAodTransitionViewModelTest : SysuiTestCase() { @Test fun deviceEntryParentViewAlpha_rearFp_shadeExpanded() = - testComponent.runTest { + testScope.runTest { val values by collectValues(underTest.deviceEntryParentViewAlpha) fingerprintPropertyRepository.supportsRearFps() shadeExpanded(true) @@ -232,6 +191,16 @@ class LockscreenToAodTransitionViewModelTest : SysuiTestCase() { values.forEach { assertThat(it).isEqualTo(0f) } } + private fun shadeExpanded(expanded: Boolean) { + if (expanded) { + shadeRepository.setQsExpansion(1f) + } else { + keyguardRepository.setStatusBarState(StatusBarState.KEYGUARD) + shadeRepository.setQsExpansion(0f) + shadeRepository.setLockscreenShadeExpansion(0f) + } + } + private fun step( value: Float, state: TransitionState = TransitionState.RUNNING diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToGoneTransitionViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToGoneTransitionViewModelTest.kt index 1494c92cdb06..8b05a54fe7cf 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToGoneTransitionViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToGoneTransitionViewModelTest.kt @@ -20,16 +20,15 @@ import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase import com.android.systemui.coroutines.collectValues -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractorFactory +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.kosmos.testScope +import com.android.systemui.testKosmos import com.google.common.truth.Truth.assertThat import kotlinx.coroutines.ExperimentalCoroutinesApi -import kotlinx.coroutines.test.TestScope import kotlinx.coroutines.test.runTest -import org.junit.Before import org.junit.Test import org.junit.runner.RunWith @@ -37,37 +36,25 @@ import org.junit.runner.RunWith @SmallTest @RunWith(AndroidJUnit4::class) class LockscreenToGoneTransitionViewModelTest : SysuiTestCase() { - private lateinit var underTest: LockscreenToGoneTransitionViewModel - private lateinit var repository: FakeKeyguardTransitionRepository - - @Before - fun setUp() { - repository = FakeKeyguardTransitionRepository() - val interactor = - KeyguardTransitionInteractorFactory.create( - scope = TestScope().backgroundScope, - repository = repository, - ) - .keyguardTransitionInteractor - underTest = - LockscreenToGoneTransitionViewModel( - interactor, - ) - } + private val kosmos = testKosmos() + private val testScope = kosmos.testScope + private val repository = kosmos.fakeKeyguardTransitionRepository + private val underTest = kosmos.lockscreenToGoneTransitionViewModel @Test - fun deviceEntryParentViewHides() = runTest { - val deviceEntryParentViewAlpha by collectValues(underTest.deviceEntryParentViewAlpha) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.1f)) - repository.sendTransitionStep(step(0.3f)) - repository.sendTransitionStep(step(0.4f)) - repository.sendTransitionStep(step(0.5f)) - repository.sendTransitionStep(step(0.6f)) - repository.sendTransitionStep(step(0.8f)) - repository.sendTransitionStep(step(1f)) - deviceEntryParentViewAlpha.forEach { assertThat(it).isEqualTo(0f) } - } + fun deviceEntryParentViewHides() = + testScope.runTest { + val deviceEntryParentViewAlpha by collectValues(underTest.deviceEntryParentViewAlpha) + repository.sendTransitionStep(step(0f, TransitionState.STARTED)) + repository.sendTransitionStep(step(0.1f)) + repository.sendTransitionStep(step(0.3f)) + repository.sendTransitionStep(step(0.4f)) + repository.sendTransitionStep(step(0.5f)) + repository.sendTransitionStep(step(0.6f)) + repository.sendTransitionStep(step(0.8f)) + repository.sendTransitionStep(step(1f)) + deviceEntryParentViewAlpha.forEach { assertThat(it).isEqualTo(0f) } + } private fun step( value: Float, diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToPrimaryBouncerTransitionViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToPrimaryBouncerTransitionViewModelTest.kt index 049e4e27e374..b31968c79647 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToPrimaryBouncerTransitionViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToPrimaryBouncerTransitionViewModelTest.kt @@ -18,81 +18,44 @@ package com.android.systemui.keyguard.ui.viewmodel import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest -import com.android.systemui.SysUITestComponent -import com.android.systemui.SysUITestModule import com.android.systemui.SysuiTestCase -import com.android.systemui.TestMocksModule -import com.android.systemui.collectLastValue -import com.android.systemui.dagger.SysUISingleton -import com.android.systemui.flags.FakeFeatureFlagsClassicModule +import com.android.systemui.coroutines.collectLastValue import com.android.systemui.flags.Flags -import com.android.systemui.keyguard.data.repository.FakeKeyguardRepository -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository +import com.android.systemui.flags.featureFlagsClassic +import com.android.systemui.keyguard.data.repository.fakeKeyguardRepository +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.StatusBarState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep -import com.android.systemui.runCurrent -import com.android.systemui.runTest -import com.android.systemui.shade.data.repository.FakeShadeRepository -import com.android.systemui.user.domain.UserDomainLayerModule +import com.android.systemui.kosmos.testScope +import com.android.systemui.shade.data.repository.shadeRepository +import com.android.systemui.testKosmos import com.google.common.collect.Range import com.google.common.truth.Truth -import dagger.BindsInstance -import dagger.Component import kotlin.test.Test import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.test.runCurrent +import kotlinx.coroutines.test.runTest import org.junit.runner.RunWith @ExperimentalCoroutinesApi @SmallTest @RunWith(AndroidJUnit4::class) class LockscreenToPrimaryBouncerTransitionViewModelTest : SysuiTestCase() { - @SysUISingleton - @Component( - modules = - [ - SysUITestModule::class, - UserDomainLayerModule::class, - ] - ) - interface TestComponent : SysUITestComponent<LockscreenToPrimaryBouncerTransitionViewModel> { - val repository: FakeKeyguardTransitionRepository - val keyguardRepository: FakeKeyguardRepository - val shadeRepository: FakeShadeRepository - - @Component.Factory - interface Factory { - fun create( - @BindsInstance test: SysuiTestCase, - featureFlags: FakeFeatureFlagsClassicModule, - mocks: TestMocksModule, - ): TestComponent + private val kosmos = + testKosmos().apply { + featureFlagsClassic.apply { set(Flags.FULL_SCREEN_USER_SWITCHER, false) } } - } - - private fun TestComponent.shadeExpanded(expanded: Boolean) { - if (expanded) { - shadeRepository.setQsExpansion(1f) - } else { - keyguardRepository.setStatusBarState(StatusBarState.KEYGUARD) - shadeRepository.setQsExpansion(0f) - shadeRepository.setLockscreenShadeExpansion(0f) - } - } - - private val testComponent: TestComponent = - DaggerLockscreenToPrimaryBouncerTransitionViewModelTest_TestComponent.factory() - .create( - test = this, - featureFlags = - FakeFeatureFlagsClassicModule { set(Flags.FULL_SCREEN_USER_SWITCHER, true) }, - mocks = TestMocksModule(), - ) + private val testScope = kosmos.testScope + private val repository = kosmos.fakeKeyguardTransitionRepository + private val shadeRepository = kosmos.shadeRepository + private val keyguardRepository = kosmos.fakeKeyguardRepository + private val underTest = kosmos.lockscreenToPrimaryBouncerTransitionViewModel @Test fun deviceEntryParentViewAlpha_shadeExpanded() = - testComponent.runTest { + testScope.runTest { val actual by collectLastValue(underTest.deviceEntryParentViewAlpha) shadeExpanded(true) runCurrent() @@ -117,7 +80,7 @@ class LockscreenToPrimaryBouncerTransitionViewModelTest : SysuiTestCase() { @Test fun deviceEntryParentViewAlpha_shadeNotExpanded() = - testComponent.runTest { + testScope.runTest { val actual by collectLastValue(underTest.deviceEntryParentViewAlpha) shadeExpanded(false) runCurrent() @@ -153,4 +116,14 @@ class LockscreenToPrimaryBouncerTransitionViewModelTest : SysuiTestCase() { ownerName = "LockscreenToPrimaryBouncerTransitionViewModelTest" ) } + + private fun shadeExpanded(expanded: Boolean) { + if (expanded) { + shadeRepository.setQsExpansion(1f) + } else { + keyguardRepository.setStatusBarState(StatusBarState.KEYGUARD) + shadeRepository.setQsExpansion(0f) + shadeRepository.setLockscreenShadeExpansion(0f) + } + } } diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToAodTransitionViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToAodTransitionViewModelTest.kt index 0eb8ff6ba966..5e6231734d32 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToAodTransitionViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToAodTransitionViewModelTest.kt @@ -19,21 +19,18 @@ package com.android.systemui.keyguard.ui.viewmodel import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase -import com.android.systemui.biometrics.data.repository.FakeFingerprintPropertyRepository +import com.android.systemui.biometrics.data.repository.fingerprintPropertyRepository import com.android.systemui.coroutines.collectLastValue -import com.android.systemui.deviceentry.domain.interactor.DeviceEntryUdfpsInteractor -import com.android.systemui.keyguard.data.repository.FakeBiometricSettingsRepository -import com.android.systemui.keyguard.data.repository.FakeDeviceEntryFingerprintAuthRepository -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractorFactory +import com.android.systemui.keyguard.data.repository.biometricSettingsRepository +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.kosmos.testScope +import com.android.systemui.testKosmos import com.google.common.truth.Truth.assertThat import kotlinx.coroutines.ExperimentalCoroutinesApi -import kotlinx.coroutines.test.TestScope import kotlinx.coroutines.test.runTest -import org.junit.Before import org.junit.Test import org.junit.runner.RunWith @@ -41,119 +38,105 @@ import org.junit.runner.RunWith @SmallTest @RunWith(AndroidJUnit4::class) class OccludedToAodTransitionViewModelTest : SysuiTestCase() { - private lateinit var underTest: OccludedToAodTransitionViewModel - private lateinit var repository: FakeKeyguardTransitionRepository - private lateinit var fingerprintPropertyRepository: FakeFingerprintPropertyRepository - private lateinit var biometricSettingsRepository: FakeBiometricSettingsRepository - - @Before - fun setUp() { - repository = FakeKeyguardTransitionRepository() - fingerprintPropertyRepository = FakeFingerprintPropertyRepository() - biometricSettingsRepository = FakeBiometricSettingsRepository() - - underTest = - OccludedToAodTransitionViewModel( - KeyguardTransitionInteractorFactory.create( - scope = TestScope().backgroundScope, - repository = repository, - ) - .keyguardTransitionInteractor, - DeviceEntryUdfpsInteractor( - fingerprintPropertyRepository = fingerprintPropertyRepository, - fingerprintAuthRepository = FakeDeviceEntryFingerprintAuthRepository(), - biometricSettingsRepository = biometricSettingsRepository, - ), - ) - } + val kosmos = testKosmos() + val testScope = kosmos.testScope + + val biometricSettingsRepository = kosmos.biometricSettingsRepository + val keyguardTransitionRepository = kosmos.fakeKeyguardTransitionRepository + val fingerprintPropertyRepository = kosmos.fingerprintPropertyRepository + val underTest = kosmos.occludedToAodTransitionViewModel @Test - fun deviceEntryBackgroundViewAlpha() = runTest { - val deviceEntryBackgroundViewAlpha by - collectLastValue(underTest.deviceEntryBackgroundViewAlpha) + fun deviceEntryBackgroundViewAlpha() = + testScope.runTest { + val deviceEntryBackgroundViewAlpha by + collectLastValue(underTest.deviceEntryBackgroundViewAlpha) - // immediately 0f - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) + // immediately 0f + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) - repository.sendTransitionStep(step(0.4f)) - assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) + keyguardTransitionRepository.sendTransitionStep(step(0.4f)) + assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) - repository.sendTransitionStep(step(.85f)) - assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) + keyguardTransitionRepository.sendTransitionStep(step(.85f)) + assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) - repository.sendTransitionStep(step(1f)) - assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) - } + keyguardTransitionRepository.sendTransitionStep(step(1f)) + assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) + } @Test - fun deviceEntryParentViewAlpha_udfpsEnrolled() = runTest { - fingerprintPropertyRepository.supportsUdfps() - biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(true) - val deviceEntryParentViewAlpha by collectLastValue(underTest.deviceEntryParentViewAlpha) + fun deviceEntryParentViewAlpha_udfpsEnrolled() = + testScope.runTest { + fingerprintPropertyRepository.supportsUdfps() + biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(true) + val deviceEntryParentViewAlpha by collectLastValue(underTest.deviceEntryParentViewAlpha) - // immediately 1f - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) + // immediately 1f + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) - repository.sendTransitionStep(step(0.5f)) - assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) + keyguardTransitionRepository.sendTransitionStep(step(0.5f)) + assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) - repository.sendTransitionStep(step(.95f)) - assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) + keyguardTransitionRepository.sendTransitionStep(step(.95f)) + assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) - repository.sendTransitionStep(step(1f)) - assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) + keyguardTransitionRepository.sendTransitionStep(step(1f)) + assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) - repository.sendTransitionStep(step(1f, TransitionState.FINISHED)) - assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) - } + keyguardTransitionRepository.sendTransitionStep(step(1f, TransitionState.FINISHED)) + assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) + } @Test - fun deviceEntryParentViewAlpha_rearFpEnrolled_noUpdates() = runTest { - fingerprintPropertyRepository.supportsRearFps() - biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(true) - val deviceEntryParentViewAlpha by collectLastValue(underTest.deviceEntryParentViewAlpha) + fun deviceEntryParentViewAlpha_rearFpEnrolled_noUpdates() = + testScope.runTest { + fingerprintPropertyRepository.supportsRearFps() + biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(true) + val deviceEntryParentViewAlpha by collectLastValue(underTest.deviceEntryParentViewAlpha) - // no updates - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertThat(deviceEntryParentViewAlpha).isNull() + // no updates + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(0.5f)) - assertThat(deviceEntryParentViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(0.5f)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(.95f)) - assertThat(deviceEntryParentViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(.95f)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(1f)) - assertThat(deviceEntryParentViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(1f)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(1f, TransitionState.FINISHED)) - assertThat(deviceEntryParentViewAlpha).isNull() - } + keyguardTransitionRepository.sendTransitionStep(step(1f, TransitionState.FINISHED)) + assertThat(deviceEntryParentViewAlpha).isNull() + } @Test - fun deviceEntryParentViewAlpha_udfpsNotEnrolled_noUpdates() = runTest { - fingerprintPropertyRepository.supportsUdfps() - biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(false) - val deviceEntryParentViewAlpha by collectLastValue(underTest.deviceEntryParentViewAlpha) + fun deviceEntryParentViewAlpha_udfpsNotEnrolled_noUpdates() = + testScope.runTest { + fingerprintPropertyRepository.supportsUdfps() + biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(false) + val deviceEntryParentViewAlpha by collectLastValue(underTest.deviceEntryParentViewAlpha) - // no updates - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertThat(deviceEntryParentViewAlpha).isNull() + // no updates + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(0.5f)) - assertThat(deviceEntryParentViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(0.5f)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(.95f)) - assertThat(deviceEntryParentViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(.95f)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(1f)) - assertThat(deviceEntryParentViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(1f)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(1f, TransitionState.FINISHED)) - assertThat(deviceEntryParentViewAlpha).isNull() - } + keyguardTransitionRepository.sendTransitionStep(step(1f, TransitionState.FINISHED)) + assertThat(deviceEntryParentViewAlpha).isNull() + } private fun step( value: Float, diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToAodTransitionViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToAodTransitionViewModelTest.kt index 350b31008478..9729022ca890 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToAodTransitionViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToAodTransitionViewModelTest.kt @@ -19,21 +19,18 @@ package com.android.systemui.keyguard.ui.viewmodel import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase -import com.android.systemui.biometrics.data.repository.FakeFingerprintPropertyRepository +import com.android.systemui.biometrics.data.repository.fingerprintPropertyRepository import com.android.systemui.coroutines.collectLastValue -import com.android.systemui.deviceentry.domain.interactor.DeviceEntryUdfpsInteractor -import com.android.systemui.keyguard.data.repository.FakeBiometricSettingsRepository -import com.android.systemui.keyguard.data.repository.FakeDeviceEntryFingerprintAuthRepository -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractorFactory +import com.android.systemui.keyguard.data.repository.biometricSettingsRepository +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.kosmos.testScope +import com.android.systemui.testKosmos import com.google.common.truth.Truth.assertThat import kotlinx.coroutines.ExperimentalCoroutinesApi -import kotlinx.coroutines.test.TestScope import kotlinx.coroutines.test.runTest -import org.junit.Before import org.junit.Test import org.junit.runner.RunWith @@ -41,113 +38,100 @@ import org.junit.runner.RunWith @SmallTest @RunWith(AndroidJUnit4::class) class PrimaryBouncerToAodTransitionViewModelTest : SysuiTestCase() { - private lateinit var underTest: PrimaryBouncerToAodTransitionViewModel - private lateinit var repository: FakeKeyguardTransitionRepository - private lateinit var fingerprintPropertyRepository: FakeFingerprintPropertyRepository - private lateinit var biometricSettingsRepository: FakeBiometricSettingsRepository - - @Before - fun setUp() { - repository = FakeKeyguardTransitionRepository() - fingerprintPropertyRepository = FakeFingerprintPropertyRepository() - biometricSettingsRepository = FakeBiometricSettingsRepository() - val interactor = - KeyguardTransitionInteractorFactory.create( - scope = TestScope().backgroundScope, - repository = repository, - ) - .keyguardTransitionInteractor - underTest = - PrimaryBouncerToAodTransitionViewModel( - interactor, - DeviceEntryUdfpsInteractor( - fingerprintPropertyRepository = fingerprintPropertyRepository, - fingerprintAuthRepository = FakeDeviceEntryFingerprintAuthRepository(), - biometricSettingsRepository = biometricSettingsRepository, - ), - ) - } + + val kosmos = testKosmos() + val testScope = kosmos.testScope + + val keyguardTransitionRepository = kosmos.fakeKeyguardTransitionRepository + val fingerprintPropertyRepository = kosmos.fingerprintPropertyRepository + val biometricSettingsRepository = kosmos.biometricSettingsRepository + + val underTest = kosmos.primaryBouncerToAodTransitionViewModel @Test - fun deviceEntryBackgroundViewAlpha() = runTest { - fingerprintPropertyRepository.supportsUdfps() - val deviceEntryBackgroundViewAlpha by - collectLastValue(underTest.deviceEntryBackgroundViewAlpha) + fun deviceEntryBackgroundViewAlpha() = + testScope.runTest { + fingerprintPropertyRepository.supportsUdfps() + val deviceEntryBackgroundViewAlpha by + collectLastValue(underTest.deviceEntryBackgroundViewAlpha) - // immediately 0f - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) + // immediately 0f + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) - repository.sendTransitionStep(step(0.4f)) - assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) + keyguardTransitionRepository.sendTransitionStep(step(0.4f)) + assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) - repository.sendTransitionStep(step(.85f)) - assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) + keyguardTransitionRepository.sendTransitionStep(step(.85f)) + assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) - repository.sendTransitionStep(step(1f)) - assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) - } + keyguardTransitionRepository.sendTransitionStep(step(1f)) + assertThat(deviceEntryBackgroundViewAlpha).isEqualTo(0f) + } @Test - fun deviceEntryParentViewAlpha_udfpsEnrolled_fadeIn() = runTest { - fingerprintPropertyRepository.supportsUdfps() - biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(true) - val deviceEntryParentViewAlpha by collectLastValue(underTest.deviceEntryParentViewAlpha) + fun deviceEntryParentViewAlpha_udfpsEnrolled_fadeIn() = + testScope.runTest { + fingerprintPropertyRepository.supportsUdfps() + biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(true) + val deviceEntryParentViewAlpha by collectLastValue(underTest.deviceEntryParentViewAlpha) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) - repository.sendTransitionStep(step(0.5f)) - repository.sendTransitionStep(step(.75f)) - repository.sendTransitionStep(step(1f)) + keyguardTransitionRepository.sendTransitionStep(step(0.5f)) + keyguardTransitionRepository.sendTransitionStep(step(.75f)) + keyguardTransitionRepository.sendTransitionStep(step(1f)) - repository.sendTransitionStep(step(1f, TransitionState.FINISHED)) - assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) - } + keyguardTransitionRepository.sendTransitionStep(step(1f, TransitionState.FINISHED)) + assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) + } @Test - fun deviceEntryParentViewAlpha_rearFpEnrolled_noUpdates() = runTest { - fingerprintPropertyRepository.supportsRearFps() - biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(true) - val deviceEntryParentViewAlpha by collectLastValue(underTest.deviceEntryParentViewAlpha) + fun deviceEntryParentViewAlpha_rearFpEnrolled_noUpdates() = + testScope.runTest { + fingerprintPropertyRepository.supportsRearFps() + biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(true) + val deviceEntryParentViewAlpha by collectLastValue(underTest.deviceEntryParentViewAlpha) - // animation doesn't start until the end - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertThat(deviceEntryParentViewAlpha).isNull() + // animation doesn't start until the end + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(0.5f)) - assertThat(deviceEntryParentViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(0.5f)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(.95f)) - assertThat(deviceEntryParentViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(.95f)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(1f)) - assertThat(deviceEntryParentViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(1f)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(1f, TransitionState.FINISHED)) - assertThat(deviceEntryParentViewAlpha).isNull() - } + keyguardTransitionRepository.sendTransitionStep(step(1f, TransitionState.FINISHED)) + assertThat(deviceEntryParentViewAlpha).isNull() + } @Test - fun deviceEntryParentViewAlpha_udfpsNotEnrolled_noUpdates() = runTest { - fingerprintPropertyRepository.supportsUdfps() - biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(false) - val deviceEntryParentViewAlpha by collectLastValue(underTest.deviceEntryParentViewAlpha) + fun deviceEntryParentViewAlpha_udfpsNotEnrolled_noUpdates() = + testScope.runTest { + fingerprintPropertyRepository.supportsUdfps() + biometricSettingsRepository.setIsFingerprintAuthEnrolledAndEnabled(false) + val deviceEntryParentViewAlpha by collectLastValue(underTest.deviceEntryParentViewAlpha) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertThat(deviceEntryParentViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(0.5f)) - assertThat(deviceEntryParentViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(0.5f)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(.75f)) - assertThat(deviceEntryParentViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(.75f)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(1f)) - assertThat(deviceEntryParentViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(1f)) + assertThat(deviceEntryParentViewAlpha).isNull() - repository.sendTransitionStep(step(1f, TransitionState.FINISHED)) - assertThat(deviceEntryParentViewAlpha).isNull() - } + keyguardTransitionRepository.sendTransitionStep(step(1f, TransitionState.FINISHED)) + assertThat(deviceEntryParentViewAlpha).isNull() + } private fun step( value: Float, diff --git a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToLockscreenTransitionViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToLockscreenTransitionViewModelTest.kt index 24e4920c66d6..2c6436e07b91 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToLockscreenTransitionViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToLockscreenTransitionViewModelTest.kt @@ -19,21 +19,18 @@ package com.android.systemui.keyguard.ui.viewmodel import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase -import com.android.systemui.biometrics.data.repository.FakeFingerprintPropertyRepository +import com.android.systemui.biometrics.data.repository.fingerprintPropertyRepository import com.android.systemui.coroutines.collectLastValue -import com.android.systemui.deviceentry.domain.interactor.DeviceEntryUdfpsInteractor -import com.android.systemui.keyguard.data.repository.FakeBiometricSettingsRepository -import com.android.systemui.keyguard.data.repository.FakeDeviceEntryFingerprintAuthRepository -import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository -import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInteractorFactory +import com.android.systemui.keyguard.data.repository.biometricSettingsRepository +import com.android.systemui.keyguard.data.repository.fakeKeyguardTransitionRepository import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.TransitionState import com.android.systemui.keyguard.shared.model.TransitionStep +import com.android.systemui.kosmos.testScope +import com.android.systemui.testKosmos import com.google.common.truth.Truth.assertThat import kotlinx.coroutines.ExperimentalCoroutinesApi -import kotlinx.coroutines.test.TestScope import kotlinx.coroutines.test.runTest -import org.junit.Before import org.junit.Test import org.junit.runner.RunWith @@ -41,91 +38,77 @@ import org.junit.runner.RunWith @SmallTest @RunWith(AndroidJUnit4::class) class PrimaryBouncerToLockscreenTransitionViewModelTest : SysuiTestCase() { - private lateinit var underTest: PrimaryBouncerToLockscreenTransitionViewModel - private lateinit var repository: FakeKeyguardTransitionRepository - private lateinit var fingerprintPropertyRepository: FakeFingerprintPropertyRepository - private lateinit var biometricSettingsRepository: FakeBiometricSettingsRepository - - @Before - fun setUp() { - repository = FakeKeyguardTransitionRepository() - fingerprintPropertyRepository = FakeFingerprintPropertyRepository() - biometricSettingsRepository = FakeBiometricSettingsRepository() - - underTest = - PrimaryBouncerToLockscreenTransitionViewModel( - KeyguardTransitionInteractorFactory.create( - scope = TestScope().backgroundScope, - repository = repository, - ) - .keyguardTransitionInteractor, - DeviceEntryUdfpsInteractor( - fingerprintPropertyRepository = fingerprintPropertyRepository, - fingerprintAuthRepository = FakeDeviceEntryFingerprintAuthRepository(), - biometricSettingsRepository = biometricSettingsRepository, - ), - ) - } + val kosmos = testKosmos() + val testScope = kosmos.testScope + + val keyguardTransitionRepository = kosmos.fakeKeyguardTransitionRepository + val fingerprintPropertyRepository = kosmos.fingerprintPropertyRepository + val biometricSettingsRepository = kosmos.biometricSettingsRepository + + val underTest = kosmos.primaryBouncerToLockscreenTransitionViewModel @Test - fun deviceEntryParentViewAlpha() = runTest { - val deviceEntryParentViewAlpha by collectLastValue(underTest.deviceEntryParentViewAlpha) + fun deviceEntryParentViewAlpha() = + testScope.runTest { + val deviceEntryParentViewAlpha by collectLastValue(underTest.deviceEntryParentViewAlpha) - // immediately 1f - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) + // immediately 1f + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) - repository.sendTransitionStep(step(0.4f)) - assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) + keyguardTransitionRepository.sendTransitionStep(step(0.4f)) + assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) - repository.sendTransitionStep(step(.85f)) - assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) + keyguardTransitionRepository.sendTransitionStep(step(.85f)) + assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) - repository.sendTransitionStep(step(1f)) - assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) - } + keyguardTransitionRepository.sendTransitionStep(step(1f)) + assertThat(deviceEntryParentViewAlpha).isEqualTo(1f) + } @Test - fun deviceEntryBackgroundViewAlpha_udfpsEnrolled_show() = runTest { - fingerprintPropertyRepository.supportsUdfps() - val bgViewAlpha by collectLastValue(underTest.deviceEntryBackgroundViewAlpha) + fun deviceEntryBackgroundViewAlpha_udfpsEnrolled_show() = + testScope.runTest { + fingerprintPropertyRepository.supportsUdfps() + val bgViewAlpha by collectLastValue(underTest.deviceEntryBackgroundViewAlpha) - // immediately 1f - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertThat(bgViewAlpha).isEqualTo(1f) + // immediately 1f + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertThat(bgViewAlpha).isEqualTo(1f) - repository.sendTransitionStep(step(0.1f)) - assertThat(bgViewAlpha).isEqualTo(1f) + keyguardTransitionRepository.sendTransitionStep(step(0.1f)) + assertThat(bgViewAlpha).isEqualTo(1f) - repository.sendTransitionStep(step(.3f)) - assertThat(bgViewAlpha).isEqualTo(1f) + keyguardTransitionRepository.sendTransitionStep(step(.3f)) + assertThat(bgViewAlpha).isEqualTo(1f) - repository.sendTransitionStep(step(.5f)) - assertThat(bgViewAlpha).isEqualTo(1f) + keyguardTransitionRepository.sendTransitionStep(step(.5f)) + assertThat(bgViewAlpha).isEqualTo(1f) - repository.sendTransitionStep(step(1f, TransitionState.FINISHED)) - assertThat(bgViewAlpha).isEqualTo(1f) - } + keyguardTransitionRepository.sendTransitionStep(step(1f, TransitionState.FINISHED)) + assertThat(bgViewAlpha).isEqualTo(1f) + } @Test - fun deviceEntryBackgroundViewAlpha_rearFpEnrolled_noUpdates() = runTest { - fingerprintPropertyRepository.supportsRearFps() - val bgViewAlpha by collectLastValue(underTest.deviceEntryBackgroundViewAlpha) - repository.sendTransitionStep(step(0f, TransitionState.STARTED)) - assertThat(bgViewAlpha).isNull() + fun deviceEntryBackgroundViewAlpha_rearFpEnrolled_noUpdates() = + testScope.runTest { + fingerprintPropertyRepository.supportsRearFps() + val bgViewAlpha by collectLastValue(underTest.deviceEntryBackgroundViewAlpha) + keyguardTransitionRepository.sendTransitionStep(step(0f, TransitionState.STARTED)) + assertThat(bgViewAlpha).isNull() - repository.sendTransitionStep(step(0.5f)) - assertThat(bgViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(0.5f)) + assertThat(bgViewAlpha).isNull() - repository.sendTransitionStep(step(.75f)) - assertThat(bgViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(.75f)) + assertThat(bgViewAlpha).isNull() - repository.sendTransitionStep(step(1f)) - assertThat(bgViewAlpha).isNull() + keyguardTransitionRepository.sendTransitionStep(step(1f)) + assertThat(bgViewAlpha).isNull() - repository.sendTransitionStep(step(1f, TransitionState.FINISHED)) - assertThat(bgViewAlpha).isNull() - } + keyguardTransitionRepository.sendTransitionStep(step(1f, TransitionState.FINISHED)) + assertThat(bgViewAlpha).isNull() + } private fun step( value: Float, diff --git a/packages/SystemUI/tests/src/com/android/systemui/settings/brightness/BrightnessDialogTest.kt b/packages/SystemUI/tests/src/com/android/systemui/settings/brightness/BrightnessDialogTest.kt index 569c8d9d350d..88c728fd1b66 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/settings/brightness/BrightnessDialogTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/settings/brightness/BrightnessDialogTest.kt @@ -36,10 +36,8 @@ import com.android.systemui.util.mockito.any import com.android.systemui.util.mockito.whenever import com.android.systemui.util.time.FakeSystemClock import com.google.common.truth.Truth.assertThat -import kotlinx.coroutines.ExperimentalCoroutinesApi +import dagger.Lazy import kotlinx.coroutines.flow.MutableStateFlow -import kotlinx.coroutines.test.advanceUntilIdle -import kotlinx.coroutines.test.runTest import org.junit.After import org.junit.Before import org.junit.Rule @@ -61,6 +59,7 @@ class BrightnessDialogTest : SysuiTestCase() { @Mock private lateinit var brightnessControllerFactory: BrightnessController.Factory @Mock private lateinit var brightnessController: BrightnessController @Mock private lateinit var accessibilityMgr: AccessibilityManagerWrapper + @Mock private lateinit var shadeInteractorLazy: Lazy<ShadeInteractor> @Mock private lateinit var shadeInteractor: ShadeInteractor private val clock = FakeSystemClock() @@ -90,6 +89,7 @@ class BrightnessDialogTest : SysuiTestCase() { .thenReturn(brightnessSliderController) `when`(brightnessSliderController.rootView).thenReturn(View(context)) `when`(brightnessControllerFactory.create(any())).thenReturn(brightnessController) + whenever(shadeInteractorLazy.get()).thenReturn(shadeInteractor) whenever(shadeInteractor.isQsExpanded).thenReturn(MutableStateFlow(false)) } @@ -180,20 +180,6 @@ class BrightnessDialogTest : SysuiTestCase() { assertThat(activityRule.activity.isFinishing()).isFalse() } - @OptIn(ExperimentalCoroutinesApi::class) - @Test - fun testFinishOnQSExpanded() = runTest { - val isQSExpanded = MutableStateFlow(false) - `when`(shadeInteractor.isQsExpanded).thenReturn(isQSExpanded) - activityRule.launchActivity(Intent(Intent.ACTION_SHOW_BRIGHTNESS_DIALOG)) - - assertThat(activityRule.activity.isFinishing()).isFalse() - - isQSExpanded.value = true - advanceUntilIdle() - assertThat(activityRule.activity.isFinishing()).isTrue() - } - class TestDialog( brightnessSliderControllerFactory: BrightnessSliderController.Factory, brightnessControllerFactory: BrightnessController.Factory, diff --git a/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationPanelViewControllerBaseTest.java b/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationPanelViewControllerBaseTest.java index 97378c3cc5a9..b0b29e500fe4 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationPanelViewControllerBaseTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationPanelViewControllerBaseTest.java @@ -529,7 +529,7 @@ public class NotificationPanelViewControllerBaseTest extends SysuiTestCase { .thenReturn(emptyFlow()); when(mOccludedToLockscreenTransitionViewModel.getLockscreenAlpha()) .thenReturn(emptyFlow()); - when(mOccludedToLockscreenTransitionViewModel.lockscreenTranslationY(anyInt())) + when(mOccludedToLockscreenTransitionViewModel.getLockscreenTranslationY()) .thenReturn(emptyFlow()); // Lockscreen->Dreaming @@ -567,7 +567,7 @@ public class NotificationPanelViewControllerBaseTest extends SysuiTestCase { .thenReturn(emptyFlow()); when(mLockscreenToOccludedTransitionViewModel.getLockscreenAlpha()) .thenReturn(emptyFlow()); - when(mLockscreenToOccludedTransitionViewModel.lockscreenTranslationY(anyInt())) + when(mLockscreenToOccludedTransitionViewModel.getLockscreenTranslationY()) .thenReturn(emptyFlow()); // Primary Bouncer->Gone diff --git a/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationPanelViewControllerTest.java b/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationPanelViewControllerTest.java index 36b4435e2137..28fe8e4e8d3a 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationPanelViewControllerTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationPanelViewControllerTest.java @@ -362,6 +362,28 @@ public class NotificationPanelViewControllerTest extends NotificationPanelViewCo } @Test + public void onInterceptTouchEvent_nsslMigrationOff_userActivity() { + mSetFlagsRule.disableFlags(com.android.systemui.Flags.FLAG_KEYGUARD_SHADE_MIGRATION_NSSL); + + mTouchHandler.onInterceptTouchEvent(MotionEvent.obtain(0L /* downTime */, + 0L /* eventTime */, MotionEvent.ACTION_DOWN, 0f /* x */, 0f /* y */, + 0 /* metaState */)); + + verify(mCentralSurfaces).userActivity(); + } + + @Test + public void onInterceptTouchEvent_nsslMigrationOn_userActivity_not_called() { + mSetFlagsRule.enableFlags(com.android.systemui.Flags.FLAG_KEYGUARD_SHADE_MIGRATION_NSSL); + + mTouchHandler.onInterceptTouchEvent(MotionEvent.obtain(0L /* downTime */, + 0L /* eventTime */, MotionEvent.ACTION_DOWN, 0f /* x */, 0f /* y */, + 0 /* metaState */)); + + verify(mCentralSurfaces, times(0)).userActivity(); + } + + @Test public void testOnTouchEvent_expansionResumesAfterBriefTouch() { mFalsingManager.setIsClassifierEnabled(true); mFalsingManager.setIsFalseTouch(false); diff --git a/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationShadeWindowControllerImplTest.java b/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationShadeWindowControllerImplTest.java index 39b306b781f9..39739e7bb93d 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationShadeWindowControllerImplTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationShadeWindowControllerImplTest.java @@ -53,6 +53,7 @@ import com.android.systemui.biometrics.AuthController; import com.android.systemui.bouncer.data.repository.FakeKeyguardBouncerRepository; import com.android.systemui.colorextraction.SysuiColorExtractor; import com.android.systemui.common.ui.data.repository.FakeConfigurationRepository; +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor; import com.android.systemui.dump.DumpManager; import com.android.systemui.flags.FakeFeatureFlagsClassic; import com.android.systemui.keyguard.KeyguardViewMediator; @@ -190,7 +191,7 @@ public class NotificationShadeWindowControllerImplTest extends SysuiTestCase { powerInteractor, sceneContainerFlags, new FakeKeyguardBouncerRepository(), - configurationRepository, + new ConfigurationInteractor(configurationRepository), shadeRepository, () -> sceneInteractor); diff --git a/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationShadeWindowViewControllerTest.kt b/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationShadeWindowViewControllerTest.kt index 0587633b09cf..6ff79660efec 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationShadeWindowViewControllerTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/shade/NotificationShadeWindowViewControllerTest.kt @@ -98,7 +98,6 @@ import com.android.systemui.util.mockito.any import com.android.systemui.util.mockito.eq import com.android.systemui.util.time.FakeSystemClock import com.google.common.truth.Truth.assertThat -import java.util.Optional import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.flow.emptyFlow import kotlinx.coroutines.test.TestScope @@ -113,8 +112,9 @@ import org.mockito.Mockito.mock import org.mockito.Mockito.never import org.mockito.Mockito.times import org.mockito.Mockito.verify -import org.mockito.Mockito.`when` as whenever import org.mockito.MockitoAnnotations +import java.util.Optional +import org.mockito.Mockito.`when` as whenever @OptIn(ExperimentalCoroutinesApi::class) @SmallTest @@ -446,6 +446,26 @@ class NotificationShadeWindowViewControllerTest : SysuiTestCase() { } @Test + fun handleDispatchTouchEvent_nsslMigrationOff_userActivity_not_called() { + mSetFlagsRule.disableFlags(Flags.FLAG_KEYGUARD_SHADE_MIGRATION_NSSL) + underTest.setStatusBarViewController(phoneStatusBarViewController) + + interactionEventHandler.handleDispatchTouchEvent(DOWN_EVENT) + + verify(centralSurfaces, times(0)).userActivity() + } + + @Test + fun handleDispatchTouchEvent_nsslMigrationOn_userActivity() { + mSetFlagsRule.enableFlags(Flags.FLAG_KEYGUARD_SHADE_MIGRATION_NSSL) + underTest.setStatusBarViewController(phoneStatusBarViewController) + + interactionEventHandler.handleDispatchTouchEvent(DOWN_EVENT) + + verify(centralSurfaces).userActivity() + } + + @Test fun shouldInterceptTouchEvent_statusBarKeyguardViewManagerShouldIntercept() { // down event should be intercepted by keyguardViewManager whenever(statusBarKeyguardViewManager.shouldInterceptTouchEvent(DOWN_EVENT)) diff --git a/packages/SystemUI/tests/src/com/android/systemui/shade/QuickSettingsControllerBaseTest.java b/packages/SystemUI/tests/src/com/android/systemui/shade/QuickSettingsControllerBaseTest.java index 62c0ebeb8c07..e723d7d0367b 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/shade/QuickSettingsControllerBaseTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/shade/QuickSettingsControllerBaseTest.java @@ -40,6 +40,7 @@ import com.android.keyguard.KeyguardUpdateMonitor; import com.android.systemui.SysuiTestCase; import com.android.systemui.bouncer.data.repository.FakeKeyguardBouncerRepository; import com.android.systemui.common.ui.data.repository.FakeConfigurationRepository; +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor; import com.android.systemui.dump.DumpManager; import com.android.systemui.flags.FakeFeatureFlagsClassic; import com.android.systemui.flags.FeatureFlags; @@ -228,7 +229,7 @@ public class QuickSettingsControllerBaseTest extends SysuiTestCase { powerInteractor, sceneContainerFlags, new FakeKeyguardBouncerRepository(), - configurationRepository, + new ConfigurationInteractor(configurationRepository), mShadeRepository, () -> sceneInteractor); diff --git a/packages/SystemUI/tests/src/com/android/systemui/shade/data/repository/ShadeRepositoryImplTest.kt b/packages/SystemUI/tests/src/com/android/systemui/shade/data/repository/ShadeRepositoryImplTest.kt index 5f8777ddcbb6..f8aa359b569d 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/shade/data/repository/ShadeRepositoryImplTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/shade/data/repository/ShadeRepositoryImplTest.kt @@ -225,4 +225,13 @@ class ShadeRepositoryImplTest : SysuiTestCase() { underTest.setLegacyQsFullscreen(true) assertThat(underTest.legacyQsFullscreen.value).isEqualTo(true) } + + @Test + fun updateLegacyIsClosing() = + testScope.runTest { + assertThat(underTest.legacyIsClosing.value).isEqualTo(false) + + underTest.setLegacyIsClosing(true) + assertThat(underTest.legacyIsClosing.value).isEqualTo(true) + } } diff --git a/packages/SystemUI/tests/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractorSceneContainerImplTest.kt b/packages/SystemUI/tests/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractorSceneContainerImplTest.kt new file mode 100644 index 000000000000..40006ba8dd82 --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/shade/domain/interactor/ShadeAnimationInteractorSceneContainerImplTest.kt @@ -0,0 +1,149 @@ +/* + * Copyright (C) 2023 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.systemui.shade.domain.interactor + +import androidx.test.filters.SmallTest +import com.android.systemui.SysUITestComponent +import com.android.systemui.SysUITestModule +import com.android.systemui.SysuiTestCase +import com.android.systemui.TestMocksModule +import com.android.systemui.collectLastValue +import com.android.systemui.dagger.SysUISingleton +import com.android.systemui.flags.FakeFeatureFlagsClassicModule +import com.android.systemui.flags.Flags +import com.android.systemui.runCurrent +import com.android.systemui.runTest +import com.android.systemui.scene.domain.interactor.SceneInteractor +import com.android.systemui.scene.shared.model.ObservableTransitionState +import com.android.systemui.scene.shared.model.SceneKey +import com.android.systemui.statusbar.phone.DozeParameters +import com.android.systemui.user.domain.UserDomainLayerModule +import com.android.systemui.util.mockito.mock +import com.google.common.truth.Truth +import dagger.BindsInstance +import dagger.Component +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.flowOf +import org.junit.Test + +@SmallTest +class ShadeAnimationInteractorSceneContainerImplTest : SysuiTestCase() { + + @SysUISingleton + @Component( + modules = + [ + SysUITestModule::class, + UserDomainLayerModule::class, + ] + ) + interface TestComponent : SysUITestComponent<ShadeAnimationInteractorSceneContainerImpl> { + val sceneInteractor: SceneInteractor + + @Component.Factory + interface Factory { + fun create( + @BindsInstance test: SysuiTestCase, + featureFlags: FakeFeatureFlagsClassicModule, + mocks: TestMocksModule, + ): TestComponent + } + } + + private val dozeParameters: DozeParameters = mock() + + private val testComponent: TestComponent = + DaggerShadeAnimationInteractorSceneContainerImplTest_TestComponent.factory() + .create( + test = this, + featureFlags = + FakeFeatureFlagsClassicModule { set(Flags.FULL_SCREEN_USER_SWITCHER, true) }, + mocks = + TestMocksModule( + dozeParameters = dozeParameters, + ), + ) + + @Test + fun isAnyCloseAnimationRunning_qsToShade() = + testComponent.runTest() { + val actual by collectLastValue(underTest.isAnyCloseAnimationRunning) + + // WHEN transitioning from QS to Shade + val transitionState = + MutableStateFlow<ObservableTransitionState>( + ObservableTransitionState.Transition( + fromScene = SceneKey.QuickSettings, + toScene = SceneKey.Shade, + progress = MutableStateFlow(.1f), + isInitiatedByUserInput = false, + isUserInputOngoing = flowOf(false), + ) + ) + sceneInteractor.setTransitionState(transitionState) + runCurrent() + + // THEN qs is animating closed + Truth.assertThat(actual).isFalse() + } + + @Test + fun isAnyCloseAnimationRunning_qsToGone_userInputNotOngoing() = + testComponent.runTest() { + val actual by collectLastValue(underTest.isAnyCloseAnimationRunning) + + // WHEN transitioning from QS to Gone with no ongoing user input + val transitionState = + MutableStateFlow<ObservableTransitionState>( + ObservableTransitionState.Transition( + fromScene = SceneKey.QuickSettings, + toScene = SceneKey.Gone, + progress = MutableStateFlow(.1f), + isInitiatedByUserInput = false, + isUserInputOngoing = flowOf(false), + ) + ) + sceneInteractor.setTransitionState(transitionState) + runCurrent() + + // THEN qs is animating closed + Truth.assertThat(actual).isTrue() + } + + @Test + fun isAnyCloseAnimationRunning_qsToGone_userInputOngoing() = + testComponent.runTest() { + val actual by collectLastValue(underTest.isAnyCloseAnimationRunning) + + // WHEN transitioning from QS to Gone with user input ongoing + val transitionState = + MutableStateFlow<ObservableTransitionState>( + ObservableTransitionState.Transition( + fromScene = SceneKey.QuickSettings, + toScene = SceneKey.Gone, + progress = MutableStateFlow(.1f), + isInitiatedByUserInput = false, + isUserInputOngoing = flowOf(true), + ) + ) + sceneInteractor.setTransitionState(transitionState) + runCurrent() + + // THEN qs is not animating closed + Truth.assertThat(actual).isFalse() + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/shade/domain/interactor/ShadeInteractorSceneContainerImplTest.kt b/packages/SystemUI/tests/src/com/android/systemui/shade/domain/interactor/ShadeInteractorSceneContainerImplTest.kt index 565e20a034db..310b86f908c5 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/shade/domain/interactor/ShadeInteractorSceneContainerImplTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/shade/domain/interactor/ShadeInteractorSceneContainerImplTest.kt @@ -127,22 +127,22 @@ class ShadeInteractorSceneContainerImplTest : SysuiTestCase() { val actual by collectLastValue(underTest.qsExpansion) // WHEN split shade is enabled and QS is expanded - keyguardRepository.setStatusBarState(StatusBarState.SHADE) overrideResource(R.bool.config_use_split_notification_shade, true) configurationRepository.onAnyConfigurationChange() - val progress = MutableStateFlow(.3f) + runCurrent() val transitionState = MutableStateFlow<ObservableTransitionState>( ObservableTransitionState.Transition( fromScene = SceneKey.QuickSettings, toScene = SceneKey.Shade, - progress = progress, + progress = MutableStateFlow(.3f), isInitiatedByUserInput = false, isUserInputOngoing = flowOf(false), ) ) sceneInteractor.setTransitionState(transitionState) runCurrent() + keyguardRepository.setStatusBarState(StatusBarState.SHADE) // THEN legacy shade expansion is passed through Truth.assertThat(actual).isEqualTo(.3f) @@ -157,6 +157,8 @@ class ShadeInteractorSceneContainerImplTest : SysuiTestCase() { // WHEN split shade is not enabled and QS is expanded keyguardRepository.setStatusBarState(StatusBarState.SHADE) overrideResource(R.bool.config_use_split_notification_shade, false) + configurationRepository.onAnyConfigurationChange() + runCurrent() val progress = MutableStateFlow(.3f) val transitionState = MutableStateFlow<ObservableTransitionState>( @@ -182,13 +184,12 @@ class ShadeInteractorSceneContainerImplTest : SysuiTestCase() { // WHEN scene transition active keyguardRepository.setStatusBarState(StatusBarState.SHADE) - val progress = MutableStateFlow(.3f) val transitionState = MutableStateFlow<ObservableTransitionState>( ObservableTransitionState.Transition( fromScene = SceneKey.QuickSettings, toScene = SceneKey.Shade, - progress = progress, + progress = MutableStateFlow(.3f), isInitiatedByUserInput = false, isUserInputOngoing = flowOf(false), ) @@ -347,6 +348,52 @@ class ShadeInteractorSceneContainerImplTest : SysuiTestCase() { Truth.assertThat(expansionAmount).isEqualTo(0f) } + fun isQsBypassingShade_goneToQs() = + testComponent.runTest() { + val actual by collectLastValue(underTest.isQsBypassingShade) + + // WHEN transitioning from QS directly to Gone + configurationRepository.onAnyConfigurationChange() + val transitionState = + MutableStateFlow<ObservableTransitionState>( + ObservableTransitionState.Transition( + fromScene = SceneKey.Gone, + toScene = SceneKey.QuickSettings, + progress = MutableStateFlow(.1f), + isInitiatedByUserInput = false, + isUserInputOngoing = flowOf(false), + ) + ) + sceneInteractor.setTransitionState(transitionState) + runCurrent() + + // THEN qs is bypassing shade + Truth.assertThat(actual).isTrue() + } + + fun isQsBypassingShade_shadeToQs() = + testComponent.runTest() { + val actual by collectLastValue(underTest.isQsBypassingShade) + + // WHEN transitioning from QS to Shade + configurationRepository.onAnyConfigurationChange() + val transitionState = + MutableStateFlow<ObservableTransitionState>( + ObservableTransitionState.Transition( + fromScene = SceneKey.Shade, + toScene = SceneKey.QuickSettings, + progress = MutableStateFlow(.1f), + isInitiatedByUserInput = false, + isUserInputOngoing = flowOf(false), + ) + ) + sceneInteractor.setTransitionState(transitionState) + runCurrent() + + // THEN qs is not bypassing shade + Truth.assertThat(actual).isFalse() + } + @Test fun lockscreenShadeExpansion_transitioning_toAndFromDifferentScenes() = testComponent.runTest() { diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/StatusBarStateControllerImplTest.kt b/packages/SystemUI/tests/src/com/android/systemui/statusbar/StatusBarStateControllerImplTest.kt index 7546dfa1cbf9..dff91ddf559f 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/StatusBarStateControllerImplTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/StatusBarStateControllerImplTest.kt @@ -26,6 +26,7 @@ import com.android.systemui.SysuiTestCase import com.android.systemui.bouncer.data.repository.FakeKeyguardBouncerRepository import com.android.systemui.classifier.FalsingCollectorFake import com.android.systemui.common.ui.data.repository.FakeConfigurationRepository +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor import com.android.systemui.flags.FakeFeatureFlagsClassic import com.android.systemui.keyguard.data.repository.FakeCommandQueue import com.android.systemui.keyguard.data.repository.FakeKeyguardRepository @@ -121,7 +122,7 @@ class StatusBarStateControllerImplTest : SysuiTestCase() { powerInteractor, sceneContainerFlags, FakeKeyguardBouncerRepository(), - configurationRepository, + ConfigurationInteractor(configurationRepository), shadeRepository, utils::sceneInteractor ) diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/coordinator/VisualStabilityCoordinatorTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/coordinator/VisualStabilityCoordinatorTest.java index e488f39bf27d..bd4647431ab9 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/coordinator/VisualStabilityCoordinatorTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/coordinator/VisualStabilityCoordinatorTest.java @@ -34,12 +34,14 @@ import android.testing.TestableLooper; import androidx.test.filters.SmallTest; +import com.android.keyguard.TestScopeProvider; import com.android.systemui.SysuiTestCase; import com.android.systemui.dump.DumpManager; import com.android.systemui.keyguard.WakefulnessLifecycle; import com.android.systemui.plugins.statusbar.StatusBarStateController; import com.android.systemui.shade.ShadeStateEvents; import com.android.systemui.shade.ShadeStateEvents.ShadeStateEventsListener; +import com.android.systemui.shade.domain.interactor.ShadeAnimationInteractor; import com.android.systemui.statusbar.notification.VisibilityLocationProvider; import com.android.systemui.statusbar.notification.collection.GroupEntry; import com.android.systemui.statusbar.notification.collection.GroupEntryBuilder; @@ -51,6 +53,7 @@ import com.android.systemui.statusbar.notification.collection.listbuilder.plugga import com.android.systemui.statusbar.notification.collection.provider.VisualStabilityProvider; import com.android.systemui.statusbar.policy.HeadsUpManager; import com.android.systemui.util.concurrency.FakeExecutor; +import com.android.systemui.util.kotlin.JavaAdapter; import com.android.systemui.util.time.FakeSystemClock; import org.junit.Before; @@ -62,6 +65,10 @@ import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.mockito.verification.VerificationMode; +import kotlinx.coroutines.flow.MutableStateFlow; +import kotlinx.coroutines.flow.StateFlowKt; +import kotlinx.coroutines.test.TestScope; + @SmallTest @RunWith(AndroidTestingRunner.class) @TestableLooper.RunWithLooper @@ -78,6 +85,7 @@ public class VisualStabilityCoordinatorTest extends SysuiTestCase { @Mock private ShadeStateEvents mShadeStateEvents; @Mock private VisibilityLocationProvider mVisibilityLocationProvider; @Mock private VisualStabilityProvider mVisualStabilityProvider; + @Mock private ShadeAnimationInteractor mShadeAnimationInteractor; @Captor private ArgumentCaptor<WakefulnessLifecycle.Observer> mWakefulnessObserverCaptor; @Captor private ArgumentCaptor<StatusBarStateController.StateListener> mSBStateListenerCaptor; @@ -86,6 +94,9 @@ public class VisualStabilityCoordinatorTest extends SysuiTestCase { private FakeSystemClock mFakeSystemClock = new FakeSystemClock(); private FakeExecutor mFakeExecutor = new FakeExecutor(mFakeSystemClock); + private final TestScope mTestScope = TestScopeProvider.getTestScope(); + private final JavaAdapter mJavaAdapter = new JavaAdapter(mTestScope.getBackgroundScope()); + private final MutableStateFlow<Boolean> mShadeClosing = StateFlowKt.MutableStateFlow(false); private WakefulnessLifecycle.Observer mWakefulnessObserver; private StatusBarStateController.StateListener mStatusBarStateListener; @@ -103,11 +114,13 @@ public class VisualStabilityCoordinatorTest extends SysuiTestCase { mDumpManager, mHeadsUpManager, mShadeStateEvents, + mShadeAnimationInteractor, + mJavaAdapter, mStatusBarStateController, mVisibilityLocationProvider, mVisualStabilityProvider, mWakefulnessLifecycle); - + when(mShadeAnimationInteractor.isAnyCloseAnimationRunning()).thenReturn(mShadeClosing); mCoordinator.attach(mNotifPipeline); // capture arguments: @@ -549,7 +562,8 @@ public class VisualStabilityCoordinatorTest extends SysuiTestCase { } private void setPanelCollapsing(boolean collapsing) { - mNotifPanelEventsCallback.onPanelCollapsingChanged(collapsing); + mShadeClosing.setValue(collapsing); + mTestScope.getTestScheduler().runCurrent(); } private void setPulsing(boolean pulsing) { diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/icon/ui/viewmodel/NotificationIconContainerStatusBarViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/icon/ui/viewmodel/NotificationIconContainerStatusBarViewModelTest.kt index 741564505b53..349a35ebf798 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/icon/ui/viewmodel/NotificationIconContainerStatusBarViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/icon/ui/viewmodel/NotificationIconContainerStatusBarViewModelTest.kt @@ -285,28 +285,13 @@ class NotificationIconContainerStatusBarViewModelTest : SysuiTestCase() { assertThat(iconColors.tint).isEqualTo(0xAABBCC) - val staticDrawableColor = iconColors.staticDrawableColor(Rect(), isColorized = true) + val staticDrawableColor = iconColors.staticDrawableColor(Rect()) assertThat(staticDrawableColor).isEqualTo(0xAABBCC) } @Test - fun iconColors_staticDrawableColor_nonColorized() = - testComponent.runTest { - darkIconRepository.darkState.value = - SysuiDarkIconDispatcher.DarkChange( - emptyList(), - 0f, - 0xAABBCC, - ) - val iconColorsLookup by collectLastValue(underTest.iconColors) - val iconColors = iconColorsLookup?.iconColors(Rect()) - val staticDrawableColor = iconColors?.staticDrawableColor(Rect(), isColorized = false) - assertThat(staticDrawableColor).isEqualTo(DarkIconDispatcher.DEFAULT_ICON_TINT) - } - - @Test - fun iconColors_staticDrawableColor_isColorized_notInDarkTintArea() = + fun iconColors_staticDrawableColor_notInDarkTintArea() = testComponent.runTest { darkIconRepository.darkState.value = SysuiDarkIconDispatcher.DarkChange( @@ -316,8 +301,7 @@ class NotificationIconContainerStatusBarViewModelTest : SysuiTestCase() { ) val iconColorsLookup by collectLastValue(underTest.iconColors) val iconColors = iconColorsLookup?.iconColors(Rect(1, 1, 4, 4)) - val staticDrawableColor = - iconColors?.staticDrawableColor(Rect(6, 6, 7, 7), isColorized = true) + val staticDrawableColor = iconColors?.staticDrawableColor(Rect(6, 6, 7, 7)) assertThat(staticDrawableColor).isEqualTo(DarkIconDispatcher.DEFAULT_ICON_TINT) } diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/KeyguardStatusBarViewControllerTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/KeyguardStatusBarViewControllerTest.java index 62a2bc54af20..5102b4f7a817 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/KeyguardStatusBarViewControllerTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/KeyguardStatusBarViewControllerTest.java @@ -55,6 +55,7 @@ import com.android.systemui.SysuiTestCase; import com.android.systemui.battery.BatteryMeterViewController; import com.android.systemui.bouncer.data.repository.FakeKeyguardBouncerRepository; import com.android.systemui.common.ui.data.repository.FakeConfigurationRepository; +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor; import com.android.systemui.flags.FakeFeatureFlagsClassic; import com.android.systemui.flags.Flags; import com.android.systemui.keyguard.data.repository.FakeKeyguardRepository; @@ -167,7 +168,7 @@ public class KeyguardStatusBarViewControllerTest extends SysuiTestCase { PowerInteractorFactory.create().getPowerInteractor(), mSceneTestUtils.getSceneContainerFlags(), new FakeKeyguardBouncerRepository(), - new FakeConfigurationRepository(), + new ConfigurationInteractor(new FakeConfigurationRepository()), new FakeShadeRepository(), () -> mSceneTestUtils.sceneInteractor()); mViewModel = diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/ui/viewmodel/KeyguardStatusBarViewModelTest.kt b/packages/SystemUI/tests/src/com/android/systemui/statusbar/ui/viewmodel/KeyguardStatusBarViewModelTest.kt index 59bf9f30a828..9419d638b1c7 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/ui/viewmodel/KeyguardStatusBarViewModelTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/ui/viewmodel/KeyguardStatusBarViewModelTest.kt @@ -20,6 +20,7 @@ import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase import com.android.systemui.bouncer.data.repository.FakeKeyguardBouncerRepository import com.android.systemui.common.ui.data.repository.FakeConfigurationRepository +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor import com.android.systemui.coroutines.collectLastValue import com.android.systemui.keyguard.data.repository.FakeKeyguardRepository import com.android.systemui.keyguard.domain.interactor.KeyguardInteractor @@ -56,7 +57,7 @@ class KeyguardStatusBarViewModelTest : SysuiTestCase() { PowerInteractorFactory.create().powerInteractor, sceneTestUtils.sceneContainerFlags, FakeKeyguardBouncerRepository(), - FakeConfigurationRepository(), + ConfigurationInteractor(FakeConfigurationRepository()), FakeShadeRepository(), ) { sceneTestUtils.sceneInteractor() diff --git a/packages/SystemUI/tests/src/com/android/systemui/wmshell/BubblesTest.java b/packages/SystemUI/tests/src/com/android/systemui/wmshell/BubblesTest.java index 52c25f7b2b71..8585d46fa8a5 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/wmshell/BubblesTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/wmshell/BubblesTest.java @@ -96,6 +96,7 @@ import com.android.systemui.biometrics.AuthController; import com.android.systemui.bouncer.data.repository.FakeKeyguardBouncerRepository; import com.android.systemui.colorextraction.SysuiColorExtractor; import com.android.systemui.common.ui.data.repository.FakeConfigurationRepository; +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor; import com.android.systemui.dump.DumpManager; import com.android.systemui.flags.FakeFeatureFlags; import com.android.systemui.flags.FakeFeatureFlagsClassic; @@ -415,7 +416,7 @@ public class BubblesTest extends SysuiTestCase { powerInteractor, sceneContainerFlags, new FakeKeyguardBouncerRepository(), - configurationRepository, + new ConfigurationInteractor(configurationRepository), shadeRepository, () -> sceneInteractor); diff --git a/packages/SystemUI/tests/utils/src/com/android/keyguard/logging/BiometricUnlockLoggerKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/keyguard/logging/BiometricUnlockLoggerKosmos.kt new file mode 100644 index 000000000000..f55ae2fd9466 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/keyguard/logging/BiometricUnlockLoggerKosmos.kt @@ -0,0 +1,22 @@ +/* + * Copyright (C) 2023 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.keyguard.logging + +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.util.mockito.mock + +var Kosmos.biometricUnlockLogger by Kosmos.Fixture { mock<BiometricUnlockLogger>() } diff --git a/packages/SystemUI/tests/utils/src/com/android/keyguard/logging/KeyguardTransitionAnimationLoggerKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/keyguard/logging/KeyguardTransitionAnimationLoggerKosmos.kt new file mode 100644 index 000000000000..db2a87ebafbc --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/keyguard/logging/KeyguardTransitionAnimationLoggerKosmos.kt @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2023 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.keyguard.logging + +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.util.mockito.mock + +var Kosmos.keyguardTransitionAnimationLogger by + Kosmos.Fixture { mock<KeyguardTransitionAnimationLogger>() } diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/biometrics/ui/viewmodel/DeviceEntryUdfpsTouchOverlayViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/biometrics/ui/viewmodel/DeviceEntryUdfpsTouchOverlayViewModelKosmos.kt new file mode 100644 index 000000000000..54756590ee83 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/biometrics/ui/viewmodel/DeviceEntryUdfpsTouchOverlayViewModelKosmos.kt @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2023 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.systemui.biometrics.ui.viewmodel + +import com.android.systemui.keyguard.ui.viewmodel.deviceEntryIconViewModel +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import com.android.systemui.statusbar.phone.systemUIDialogManager + +val Kosmos.deviceEntryUdfpsTouchOverlayViewModel by Fixture { + DeviceEntryUdfpsTouchOverlayViewModel( + deviceEntryIconViewModel = deviceEntryIconViewModel, + systemUIDialogManager = systemUIDialogManager, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/bouncer/domain/interactor/PrimaryBouncerInteractorKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/bouncer/domain/interactor/PrimaryBouncerInteractorKosmos.kt new file mode 100644 index 000000000000..06b6cda62806 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/bouncer/domain/interactor/PrimaryBouncerInteractorKosmos.kt @@ -0,0 +1,22 @@ +/* + * Copyright (C) 2023 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.systemui.bouncer.domain.interactor + +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.util.mockito.mock + +var Kosmos.primaryBouncerInteractor by Kosmos.Fixture { mock<PrimaryBouncerInteractor>() } diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/common/ui/domain/interactor/ConfigurationInteractorKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/common/ui/domain/interactor/ConfigurationInteractorKosmos.kt new file mode 100644 index 000000000000..7e0e5f39c708 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/common/ui/domain/interactor/ConfigurationInteractorKosmos.kt @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2023 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.systemui.common.ui.domain.interactor + +import com.android.systemui.common.ui.data.repository.configurationRepository +import com.android.systemui.kosmos.Kosmos + +var Kosmos.configurationInteractor: ConfigurationInteractor by + Kosmos.Fixture { ConfigurationInteractor(configurationRepository) } diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/deviceentry/data/repository/DeviceEntryHapticsRepositoryKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/deviceentry/data/repository/DeviceEntryHapticsRepositoryKosmos.kt new file mode 100644 index 000000000000..8bb07d9487cd --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/deviceentry/data/repository/DeviceEntryHapticsRepositoryKosmos.kt @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2023 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.systemui.deviceentry.data.repository + +import com.android.systemui.kosmos.Kosmos + +var Kosmos.deviceEntryHapticsRepository: DeviceEntryHapticsRepository by + Kosmos.Fixture { fakeDeviceEntryHapticsRepository } +val Kosmos.fakeDeviceEntryHapticsRepository by Kosmos.Fixture { FakeDeviceEntryHapticsRepository() } diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/deviceentry/domain/interactor/DeviceEntryHapticsInteractorKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/deviceentry/domain/interactor/DeviceEntryHapticsInteractorKosmos.kt new file mode 100644 index 000000000000..de6cacb00faa --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/deviceentry/domain/interactor/DeviceEntryHapticsInteractorKosmos.kt @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.deviceentry.domain.interactor + +import com.android.keyguard.logging.biometricUnlockLogger +import com.android.systemui.biometrics.data.repository.fingerprintPropertyRepository +import com.android.systemui.deviceentry.data.repository.fakeDeviceEntryHapticsRepository +import com.android.systemui.keyevent.domain.interactor.keyEventInteractor +import com.android.systemui.keyguard.data.repository.biometricSettingsRepository +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.power.domain.interactor.powerInteractor +import com.android.systemui.util.time.fakeSystemClock +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.deviceEntryHapticsInteractor by + Kosmos.Fixture { + DeviceEntryHapticsInteractor( + repository = fakeDeviceEntryHapticsRepository, + fingerprintPropertyRepository = fingerprintPropertyRepository, + biometricSettingsRepository = biometricSettingsRepository, + keyEventInteractor = keyEventInteractor, + powerInteractor = powerInteractor, + systemClock = fakeSystemClock, + logger = biometricUnlockLogger, + ) + } diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyevent/data/repository/KeyEventRepositoryKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyevent/data/repository/KeyEventRepositoryKosmos.kt new file mode 100644 index 000000000000..1238a7a0021e --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyevent/data/repository/KeyEventRepositoryKosmos.kt @@ -0,0 +1,22 @@ +/* + * Copyright (C) 2023 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.systemui.keyevent.data.repository + +import com.android.systemui.kosmos.Kosmos + +var Kosmos.keyEventRepository: KeyEventRepository by Kosmos.Fixture { fakeKeyEventRepository } +val Kosmos.fakeKeyEventRepository by Kosmos.Fixture { FakeKeyEventRepository() } diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyevent/domain/interactor/KeyEventInteractorKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyevent/domain/interactor/KeyEventInteractorKosmos.kt new file mode 100644 index 000000000000..53a1b034e4ed --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyevent/domain/interactor/KeyEventInteractorKosmos.kt @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2023 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.systemui.keyevent.domain.interactor + +import com.android.systemui.keyevent.data.repository.keyEventRepository +import com.android.systemui.kosmos.Kosmos + +var Kosmos.keyEventInteractor by + Kosmos.Fixture { KeyEventInteractor(repository = keyEventRepository) } diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/data/repository/FakeKeyguardRepository.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/data/repository/FakeKeyguardRepository.kt index 75fe37eddd70..81a7bec52bb5 100644 --- a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/data/repository/FakeKeyguardRepository.kt +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/data/repository/FakeKeyguardRepository.kt @@ -25,7 +25,6 @@ import com.android.systemui.keyguard.shared.model.BiometricUnlockSource import com.android.systemui.keyguard.shared.model.DismissAction import com.android.systemui.keyguard.shared.model.DozeTransitionModel import com.android.systemui.keyguard.shared.model.KeyguardDone -import com.android.systemui.keyguard.shared.model.KeyguardRootViewVisibilityState import com.android.systemui.keyguard.shared.model.StatusBarState import dagger.Binds import dagger.Module @@ -120,17 +119,6 @@ class FakeKeyguardRepository @Inject constructor() : KeyguardRepository { private val _keyguardAlpha = MutableStateFlow(1f) override val keyguardAlpha: StateFlow<Float> = _keyguardAlpha - private val _keyguardRootViewVisibility = - MutableStateFlow( - KeyguardRootViewVisibilityState( - 0, - goingToFullShade = false, - occlusionTransitionRunning = false - ) - ) - override val keyguardRootViewVisibility: Flow<KeyguardRootViewVisibilityState> = - _keyguardRootViewVisibility.asStateFlow() - override fun setQuickSettingsVisible(isVisible: Boolean) { _isQuickSettingsVisible.value = isVisible } @@ -247,19 +235,6 @@ class FakeKeyguardRepository @Inject constructor() : KeyguardRepository { override fun setKeyguardAlpha(alpha: Float) { _keyguardAlpha.value = alpha } - - override fun setKeyguardVisibility( - statusBarState: Int, - goingToFullShade: Boolean, - occlusionTransitionRunning: Boolean - ) { - _keyguardRootViewVisibility.value = - KeyguardRootViewVisibilityState( - statusBarState, - goingToFullShade, - occlusionTransitionRunning - ) - } } @Module diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractorFactory.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractorFactory.kt index c575bb3fe25d..0bba36b172c0 100644 --- a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractorFactory.kt +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractorFactory.kt @@ -19,6 +19,7 @@ package com.android.systemui.keyguard.domain.interactor import com.android.systemui.bouncer.data.repository.FakeKeyguardBouncerRepository import com.android.systemui.common.ui.data.repository.FakeConfigurationRepository +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor import com.android.systemui.flags.FakeFeatureFlags import com.android.systemui.keyguard.data.repository.FakeCommandQueue import com.android.systemui.keyguard.data.repository.FakeKeyguardRepository @@ -63,7 +64,7 @@ object KeyguardInteractorFactory { commandQueue = commandQueue, sceneContainerFlags = sceneContainerFlags, bouncerRepository = bouncerRepository, - configurationRepository = configurationRepository, + configurationInteractor = ConfigurationInteractor(configurationRepository), shadeRepository = shadeRepository, sceneInteractorProvider = { sceneInteractor }, powerInteractor = powerInteractor, diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractorKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractorKosmos.kt index bb840362185f..58d99b5bcc12 100644 --- a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractorKosmos.kt +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/domain/interactor/KeyguardInteractorKosmos.kt @@ -17,7 +17,7 @@ package com.android.systemui.keyguard.domain.interactor import com.android.systemui.bouncer.data.repository.keyguardBouncerRepository -import com.android.systemui.common.ui.data.repository.configurationRepository +import com.android.systemui.common.ui.domain.interactor.configurationInteractor import com.android.systemui.keyguard.data.repository.keyguardRepository import com.android.systemui.kosmos.Kosmos import com.android.systemui.power.domain.interactor.powerInteractor @@ -34,7 +34,7 @@ val Kosmos.keyguardInteractor by powerInteractor = powerInteractor, sceneContainerFlags = sceneContainerFlags, bouncerRepository = keyguardBouncerRepository, - configurationRepository = configurationRepository, + configurationInteractor = configurationInteractor, shadeRepository = shadeRepository, sceneInteractorProvider = { sceneInteractor }, ) diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/KeyguardTransitionAnimationFlowKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/KeyguardTransitionAnimationFlowKosmos.kt new file mode 100644 index 000000000000..8d6529a114b8 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/KeyguardTransitionAnimationFlowKosmos.kt @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui + +import com.android.keyguard.logging.keyguardTransitionAnimationLogger +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import com.android.systemui.kosmos.applicationCoroutineScope +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.keyguardTransitionAnimationFlow by Fixture { + KeyguardTransitionAnimationFlow( + scope = applicationCoroutineScope, + logger = keyguardTransitionAnimationLogger, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/AlternateBouncerViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/AlternateBouncerViewModelKosmos.kt new file mode 100644 index 000000000000..9f0466dda51e --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/AlternateBouncerViewModelKosmos.kt @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import com.android.systemui.statusbar.phone.statusBarKeyguardViewManager +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.alternateBouncerViewModel by Fixture { + AlternateBouncerViewModel( + statusBarKeyguardViewManager = statusBarKeyguardViewManager, + transitionInteractor = keyguardTransitionInteractor, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/AodToGoneTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/AodToGoneTransitionViewModelKosmos.kt new file mode 100644 index 000000000000..44e542660971 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/AodToGoneTransitionViewModelKosmos.kt @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.aodToGoneTransitionViewModel by Fixture { + AodToGoneTransitionViewModel( + interactor = keyguardTransitionInteractor, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/AodToLockscreenTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/AodToLockscreenTransitionViewModelKosmos.kt index a31ab3ee1fc4..b5a5f039200f 100644 --- a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/AodToLockscreenTransitionViewModelKosmos.kt +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/AodToLockscreenTransitionViewModelKosmos.kt @@ -20,6 +20,7 @@ package com.android.systemui.keyguard.ui.viewmodel import com.android.systemui.deviceentry.domain.interactor.deviceEntryUdfpsInteractor import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow import com.android.systemui.kosmos.Kosmos import com.android.systemui.kosmos.Kosmos.Fixture import kotlinx.coroutines.ExperimentalCoroutinesApi @@ -28,5 +29,6 @@ val Kosmos.aodToLockscreenTransitionViewModel by Fixture { AodToLockscreenTransitionViewModel( interactor = keyguardTransitionInteractor, deviceEntryUdfpsInteractor = deviceEntryUdfpsInteractor, + animationFlow = keyguardTransitionAnimationFlow, ) } diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/AodToOccludedTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/AodToOccludedTransitionViewModelKosmos.kt new file mode 100644 index 000000000000..27ad0f0f01e3 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/AodToOccludedTransitionViewModelKosmos.kt @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.aodToOccludedTransitionViewModel by Fixture { + AodToOccludedTransitionViewModel( + interactor = keyguardTransitionInteractor, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/BouncerToGoneFlowsKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/BouncerToGoneFlowsKosmos.kt new file mode 100644 index 000000000000..6ffcc9a03b05 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/BouncerToGoneFlowsKosmos.kt @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.bouncer.domain.interactor.primaryBouncerInteractor +import com.android.systemui.flags.featureFlagsClassic +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import com.android.systemui.shade.domain.interactor.shadeInteractor +import com.android.systemui.statusbar.sysuiStatusBarStateController +import com.android.systemui.util.mockito.mock +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.bouncerToGoneFlows by Fixture { + BouncerToGoneFlows( + interactor = keyguardTransitionInteractor, + statusBarStateController = sysuiStatusBarStateController, + primaryBouncerInteractor = primaryBouncerInteractor, + keyguardDismissActionInteractor = mock(), + featureFlags = featureFlagsClassic, + shadeInteractor = shadeInteractor, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/DeviceEntryIconViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/DeviceEntryIconViewModelKosmos.kt new file mode 100644 index 000000000000..299262b91027 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/DeviceEntryIconViewModelKosmos.kt @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2023 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.systemui.keyguard.ui.viewmodel + +import com.android.systemui.deviceentry.domain.interactor.deviceEntryHapticsInteractor +import com.android.systemui.deviceentry.domain.interactor.deviceEntryInteractor +import com.android.systemui.deviceentry.domain.interactor.deviceEntryUdfpsInteractor +import com.android.systemui.keyguard.domain.interactor.burnInInteractor +import com.android.systemui.keyguard.domain.interactor.keyguardInteractor +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.transitions.DeviceEntryIconTransition +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import com.android.systemui.scene.shared.flag.sceneContainerFlags +import com.android.systemui.shade.domain.interactor.shadeInteractor +import com.android.systemui.statusbar.phone.statusBarKeyguardViewManager + +val Kosmos.deviceEntryIconViewModelTransitionsMock by Fixture { + mutableSetOf<DeviceEntryIconTransition>() +} + +val Kosmos.deviceEntryIconViewModel by Fixture { + DeviceEntryIconViewModel( + transitions = deviceEntryIconViewModelTransitionsMock, + burnInInteractor = burnInInteractor, + shadeInteractor = shadeInteractor, + deviceEntryUdfpsInteractor = deviceEntryUdfpsInteractor, + transitionInteractor = keyguardTransitionInteractor, + keyguardInteractor = keyguardInteractor, + viewModel = aodToLockscreenTransitionViewModel, + shadeDependentFlows = shadeDependentFlows, + sceneContainerFlags = sceneContainerFlags, + keyguardViewController = { statusBarKeyguardViewManager }, + deviceEntryHapticsInteractor = deviceEntryHapticsInteractor, + deviceEntryInteractor = deviceEntryInteractor, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/DreamingToLockscreenTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/DreamingToLockscreenTransitionViewModelKosmos.kt new file mode 100644 index 000000000000..8b5407cc7e17 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/DreamingToLockscreenTransitionViewModelKosmos.kt @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.deviceentry.domain.interactor.deviceEntryUdfpsInteractor +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import com.android.systemui.util.mockito.mock +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.dreamingToLockscreenTransitionViewModel by Fixture { + DreamingToLockscreenTransitionViewModel( + keyguardTransitionInteractor = keyguardTransitionInteractor, + fromDreamingTransitionInteractor = mock(), + deviceEntryUdfpsInteractor = deviceEntryUdfpsInteractor, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/GoneToAodTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/GoneToAodTransitionViewModelKosmos.kt index 5db95cf3ebc5..14e2cff6a7a5 100644 --- a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/GoneToAodTransitionViewModelKosmos.kt +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/GoneToAodTransitionViewModelKosmos.kt @@ -20,6 +20,7 @@ package com.android.systemui.keyguard.ui.viewmodel import com.android.systemui.deviceentry.domain.interactor.deviceEntryUdfpsInteractor import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow import com.android.systemui.kosmos.Kosmos import com.android.systemui.kosmos.Kosmos.Fixture import kotlinx.coroutines.ExperimentalCoroutinesApi @@ -27,6 +28,7 @@ import kotlinx.coroutines.ExperimentalCoroutinesApi val Kosmos.goneToAodTransitionViewModel by Fixture { GoneToAodTransitionViewModel( interactor = keyguardTransitionInteractor, - deviceEntryUdfpsInteractor = deviceEntryUdfpsInteractor + deviceEntryUdfpsInteractor = deviceEntryUdfpsInteractor, + animationFlow = keyguardTransitionAnimationFlow, ) } diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingTransitionViewModelKosmos.kt new file mode 100644 index 000000000000..073b34bcf277 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/GoneToDreamingTransitionViewModelKosmos.kt @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.goneToDreamingTransitionViewModel by Fixture { + GoneToDreamingTransitionViewModel( + interactor = keyguardTransitionInteractor, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardRootViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardRootViewModelKosmos.kt index 4f807e3ddb64..13ee74738437 100644 --- a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardRootViewModelKosmos.kt +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/KeyguardRootViewModelKosmos.kt @@ -18,7 +18,7 @@ package com.android.systemui.keyguard.ui.viewmodel -import android.content.applicationContext +import com.android.systemui.common.ui.domain.interactor.configurationInteractor import com.android.systemui.deviceentry.domain.interactor.deviceEntryInteractor import com.android.systemui.flags.FakeFeatureFlagsClassic import com.android.systemui.keyguard.domain.interactor.burnInInteractor @@ -33,7 +33,7 @@ import kotlinx.coroutines.ExperimentalCoroutinesApi val Kosmos.keyguardRootViewModel by Fixture { KeyguardRootViewModel( - context = applicationContext, + configurationInteractor = configurationInteractor, deviceEntryInteractor = deviceEntryInteractor, dozeParameters = dozeParameters, keyguardInteractor = keyguardInteractor, @@ -42,6 +42,7 @@ val Kosmos.keyguardRootViewModel by Fixture { burnInInteractor = burnInInteractor, goneToAodTransitionViewModel = goneToAodTransitionViewModel, aodToLockscreenTransitionViewModel = aodToLockscreenTransitionViewModel, + occludedToLockscreenTransitionViewModel = occludedToLockscreenTransitionViewModel, screenOffAnimationController = screenOffAnimationController, keyguardClockViewModel = keyguardClockViewModel, featureFlags = FakeFeatureFlagsClassic(), diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToAodTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToAodTransitionViewModelKosmos.kt new file mode 100644 index 000000000000..7865f71ead83 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToAodTransitionViewModelKosmos.kt @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.deviceentry.domain.interactor.deviceEntryUdfpsInteractor +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.lockscreenToAodTransitionViewModel by Fixture { + LockscreenToAodTransitionViewModel( + interactor = keyguardTransitionInteractor, + deviceEntryUdfpsInteractor = deviceEntryUdfpsInteractor, + shadeDependentFlows = shadeDependentFlows, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingTransitionViewModelKosmos.kt new file mode 100644 index 000000000000..b9f4b71d24d6 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToDreamingTransitionViewModelKosmos.kt @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.lockscreenToDreamingTransitionViewModel by Fixture { + LockscreenToDreamingTransitionViewModel( + interactor = keyguardTransitionInteractor, + shadeDependentFlows = shadeDependentFlows, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToGoneTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToGoneTransitionViewModelKosmos.kt new file mode 100644 index 000000000000..475aa2de3f9b --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToGoneTransitionViewModelKosmos.kt @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.lockscreenToGoneTransitionViewModel by Fixture { + LockscreenToGoneTransitionViewModel( + interactor = keyguardTransitionInteractor, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToOccludedTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToOccludedTransitionViewModelKosmos.kt new file mode 100644 index 000000000000..8541a4fe7096 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToOccludedTransitionViewModelKosmos.kt @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.common.ui.domain.interactor.configurationInteractor +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.lockscreenToOccludedTransitionViewModel by Fixture { + LockscreenToOccludedTransitionViewModel( + interactor = keyguardTransitionInteractor, + shadeDependentFlows = shadeDependentFlows, + configurationInteractor = configurationInteractor, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToPrimaryBouncerTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToPrimaryBouncerTransitionViewModelKosmos.kt new file mode 100644 index 000000000000..65c47fc9c2c7 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/LockscreenToPrimaryBouncerTransitionViewModelKosmos.kt @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.lockscreenToPrimaryBouncerTransitionViewModel by Fixture { + LockscreenToPrimaryBouncerTransitionViewModel( + interactor = keyguardTransitionInteractor, + shadeDependentFlows = shadeDependentFlows, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToAodTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToAodTransitionViewModelKosmos.kt new file mode 100644 index 000000000000..ddde5498d544 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToAodTransitionViewModelKosmos.kt @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.deviceentry.domain.interactor.deviceEntryUdfpsInteractor +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.occludedToAodTransitionViewModel by Fixture { + OccludedToAodTransitionViewModel( + interactor = keyguardTransitionInteractor, + deviceEntryUdfpsInteractor = deviceEntryUdfpsInteractor, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToLockscreenTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToLockscreenTransitionViewModelKosmos.kt new file mode 100644 index 000000000000..5bbde2b1c419 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/OccludedToLockscreenTransitionViewModelKosmos.kt @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.common.ui.domain.interactor.configurationInteractor +import com.android.systemui.deviceentry.domain.interactor.deviceEntryUdfpsInteractor +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.occludedToLockscreenTransitionViewModel by Fixture { + OccludedToLockscreenTransitionViewModel( + interactor = keyguardTransitionInteractor, + deviceEntryUdfpsInteractor = deviceEntryUdfpsInteractor, + configurationInteractor = configurationInteractor, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToAodTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToAodTransitionViewModelKosmos.kt new file mode 100644 index 000000000000..a7f29d637281 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToAodTransitionViewModelKosmos.kt @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.deviceentry.domain.interactor.deviceEntryUdfpsInteractor +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.primaryBouncerToAodTransitionViewModel by Fixture { + PrimaryBouncerToAodTransitionViewModel( + interactor = keyguardTransitionInteractor, + deviceEntryUdfpsInteractor = deviceEntryUdfpsInteractor, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToGoneTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToGoneTransitionViewModelKosmos.kt new file mode 100644 index 000000000000..ace6ae3e3eec --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToGoneTransitionViewModelKosmos.kt @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.bouncer.domain.interactor.primaryBouncerInteractor +import com.android.systemui.flags.featureFlagsClassic +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import com.android.systemui.statusbar.sysuiStatusBarStateController +import com.android.systemui.util.mockito.mock +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.primaryBouncerToGoneTransitionViewModel by Fixture { + PrimaryBouncerToGoneTransitionViewModel( + interactor = keyguardTransitionInteractor, + statusBarStateController = sysuiStatusBarStateController, + primaryBouncerInteractor = primaryBouncerInteractor, + keyguardDismissActionInteractor = mock(), + featureFlags = featureFlagsClassic, + bouncerToGoneFlows = bouncerToGoneFlows, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToLockscreenTransitionViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToLockscreenTransitionViewModelKosmos.kt new file mode 100644 index 000000000000..3bbabf713b91 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/keyguard/ui/viewmodel/PrimaryBouncerToLockscreenTransitionViewModelKosmos.kt @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2023 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. + */ + +@file:OptIn(ExperimentalCoroutinesApi::class) + +package com.android.systemui.keyguard.ui.viewmodel + +import com.android.systemui.deviceentry.domain.interactor.deviceEntryUdfpsInteractor +import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.keyguardTransitionAnimationFlow +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.kosmos.Kosmos.Fixture +import kotlinx.coroutines.ExperimentalCoroutinesApi + +val Kosmos.primaryBouncerToLockscreenTransitionViewModel by Fixture { + PrimaryBouncerToLockscreenTransitionViewModel( + interactor = keyguardTransitionInteractor, + deviceEntryUdfpsInteractor = deviceEntryUdfpsInteractor, + animationFlow = keyguardTransitionAnimationFlow, + ) +} diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/scene/SceneTestUtils.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/scene/SceneTestUtils.kt index 3c96051a718f..d78bcb93b256 100644 --- a/packages/SystemUI/tests/utils/src/com/android/systemui/scene/SceneTestUtils.kt +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/scene/SceneTestUtils.kt @@ -47,6 +47,7 @@ import com.android.systemui.classifier.FalsingCollectorFake import com.android.systemui.classifier.domain.interactor.FalsingInteractor import com.android.systemui.common.shared.model.Text import com.android.systemui.common.ui.data.repository.FakeConfigurationRepository +import com.android.systemui.common.ui.domain.interactor.ConfigurationInteractor import com.android.systemui.communal.data.repository.FakeCommunalRepository import com.android.systemui.communal.domain.interactor.CommunalInteractor import com.android.systemui.communal.domain.interactor.CommunalInteractorFactory @@ -133,6 +134,9 @@ class SceneTestUtils( val configurationRepository: FakeConfigurationRepository by lazy { FakeConfigurationRepository() } + val configurationInteractor: ConfigurationInteractor by lazy { + ConfigurationInteractor(configurationRepository) + } private val emergencyServicesRepository: EmergencyServicesRepository by lazy { EmergencyServicesRepository( applicationScope = applicationScope(), @@ -246,7 +250,7 @@ class SceneTestUtils( commandQueue = FakeCommandQueue(), sceneContainerFlags = sceneContainerFlags, bouncerRepository = FakeKeyguardBouncerRepository(), - configurationRepository = configurationRepository, + configurationInteractor = configurationInteractor, shadeRepository = FakeShadeRepository(), sceneInteractorProvider = { sceneInteractor() }, powerInteractor = PowerInteractorFactory.create().powerInteractor, diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/shade/data/repository/FakeShadeRepository.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/shade/data/repository/FakeShadeRepository.kt index a70b91da6145..9c108487e4c5 100644 --- a/packages/SystemUI/tests/utils/src/com/android/systemui/shade/data/repository/FakeShadeRepository.kt +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/shade/data/repository/FakeShadeRepository.kt @@ -106,6 +106,14 @@ class FakeShadeRepository @Inject constructor() : ShadeRepository { _legacyQsFullscreen.value = legacyQsFullscreen } + private val _legacyIsClosing = MutableStateFlow(false) + @Deprecated("Use ShadeInteractor instead") override val legacyIsClosing = _legacyIsClosing + + @Deprecated("Use ShadeInteractor instead") + override fun setLegacyIsClosing(isClosing: Boolean) { + _legacyIsClosing.value = isClosing + } + fun setShadeModel(model: ShadeModel) { _shadeModel.value = model } diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/SysuiStatusBarStateControllerKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/SysuiStatusBarStateControllerKosmos.kt new file mode 100644 index 000000000000..fead581d5434 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/SysuiStatusBarStateControllerKosmos.kt @@ -0,0 +1,21 @@ +/* + * Copyright (C) 2023 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.systemui.statusbar + +import com.android.systemui.kosmos.Kosmos + +var Kosmos.sysuiStatusBarStateController by Kosmos.Fixture { FakeStatusBarStateController() } diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/notification/stack/ui/viewmodel/SharedNotificationContainerViewModelKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/notification/stack/ui/viewmodel/SharedNotificationContainerViewModelKosmos.kt index c17083c5fb1c..e2479fe45405 100644 --- a/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/notification/stack/ui/viewmodel/SharedNotificationContainerViewModelKosmos.kt +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/notification/stack/ui/viewmodel/SharedNotificationContainerViewModelKosmos.kt @@ -18,6 +18,7 @@ package com.android.systemui.statusbar.notification.stack.ui.viewmodel import com.android.systemui.keyguard.domain.interactor.keyguardInteractor import com.android.systemui.keyguard.domain.interactor.keyguardTransitionInteractor +import com.android.systemui.keyguard.ui.viewmodel.occludedToLockscreenTransitionViewModel import com.android.systemui.kosmos.Kosmos import com.android.systemui.kosmos.Kosmos.Fixture import com.android.systemui.kosmos.applicationCoroutineScope @@ -31,5 +32,6 @@ val Kosmos.sharedNotificationContainerViewModel by Fixture { keyguardInteractor = keyguardInteractor, keyguardTransitionInteractor = keyguardTransitionInteractor, shadeInteractor = shadeInteractor, + occludedToLockscreenTransitionViewModel = occludedToLockscreenTransitionViewModel, ) } diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/phone/StatusBarKeyguardViewManagerKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/phone/StatusBarKeyguardViewManagerKosmos.kt new file mode 100644 index 000000000000..4e15ea2d9377 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/phone/StatusBarKeyguardViewManagerKosmos.kt @@ -0,0 +1,22 @@ +/* + * Copyright (C) 2023 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.systemui.statusbar.phone + +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.util.mockito.mock + +var Kosmos.statusBarKeyguardViewManager by Kosmos.Fixture { mock<StatusBarKeyguardViewManager>() } diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/phone/SystemUIDialogManagerKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/phone/SystemUIDialogManagerKosmos.kt new file mode 100644 index 000000000000..7dfbf2a38de6 --- /dev/null +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/phone/SystemUIDialogManagerKosmos.kt @@ -0,0 +1,22 @@ +/* + * Copyright (C) 2023 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.systemui.statusbar.phone + +import com.android.systemui.kosmos.Kosmos +import com.android.systemui.util.mockito.mock + +var Kosmos.systemUIDialogManager by Kosmos.Fixture { mock<SystemUIDialogManager>() } diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/phone/data/repository/FakeDarkIconRepository.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/phone/data/repository/FakeDarkIconRepository.kt index 50d3f0a106f2..282e2e859afe 100644 --- a/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/phone/data/repository/FakeDarkIconRepository.kt +++ b/packages/SystemUI/tests/utils/src/com/android/systemui/statusbar/phone/data/repository/FakeDarkIconRepository.kt @@ -24,7 +24,7 @@ import kotlinx.coroutines.flow.MutableStateFlow @SysUISingleton class FakeDarkIconRepository @Inject constructor() : DarkIconRepository { - override val darkState = MutableStateFlow(DarkChange(emptyList(), 0f, 0)) + override val darkState = MutableStateFlow(DarkChange.EMPTY) } @Module diff --git a/ravenwood/TEST_MAPPING b/ravenwood/TEST_MAPPING index 540b3a99e19d..031984829e77 100644 --- a/ravenwood/TEST_MAPPING +++ b/ravenwood/TEST_MAPPING @@ -6,6 +6,10 @@ ], "ravenwood-presubmit": [ { + "name": "RavenwoodMinimumTest", + "host": true + }, + { "name": "RavenwoodMockitoTest", "host": true }, diff --git a/ravenwood/framework-minus-apex-ravenwood-policies.txt b/ravenwood/framework-minus-apex-ravenwood-policies.txt index 96cfa4896808..a75bba6a347f 100644 --- a/ravenwood/framework-minus-apex-ravenwood-policies.txt +++ b/ravenwood/framework-minus-apex-ravenwood-policies.txt @@ -85,6 +85,7 @@ class com.android.internal.util.FastMath stubclass class com.android.internal.util.FastPrintWriter stubclass class com.android.internal.util.GrowingArrayUtils stubclass class com.android.internal.util.LineBreakBufferedWriter stubclass +class com.android.internal.util.Parcelling stubclass class com.android.internal.util.Preconditions stubclass class com.android.internal.util.StringPool stubclass diff --git a/ravenwood/minimum-test/Android.bp b/ravenwood/minimum-test/Android.bp new file mode 100644 index 000000000000..bf3583cebd2c --- /dev/null +++ b/ravenwood/minimum-test/Android.bp @@ -0,0 +1,24 @@ +package { + // See: http://go/android-license-faq + // A large-scale-change added 'default_applicable_licenses' to import + // all of the 'license_kinds' from "frameworks_base_license" + // to get the below license kinds: + // SPDX-license-identifier-Apache-2.0 + default_applicable_licenses: ["frameworks_base_license"], +} + +// Minimum ravenwood test according to test-authors.md. +android_ravenwood_test { + name: "RavenwoodMinimumTest", + + static_libs: [ + "androidx.annotation_annotation", + "androidx.test.rules", + ], + + srcs: [ + "test/**/*.java", + ], + sdk_version: "test_current", + auto_gen_config: true, +} diff --git a/ravenwood/minimum-test/test/com/android/ravenwood/RavenwoodMinimumTest.java b/ravenwood/minimum-test/test/com/android/ravenwood/RavenwoodMinimumTest.java new file mode 100644 index 000000000000..085c18622885 --- /dev/null +++ b/ravenwood/minimum-test/test/com/android/ravenwood/RavenwoodMinimumTest.java @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2023 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.ravenwood; + +import android.platform.test.annotations.IgnoreUnderRavenwood; +import android.platform.test.ravenwood.RavenwoodRule; + +import androidx.test.runner.AndroidJUnit4; + +import org.junit.Assert; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class RavenwoodMinimumTest { + @Rule + public RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProcessApp() + .build(); + + @Test + public void testSimple() { + Assert.assertTrue(android.os.Process.isApplicationUid(android.os.Process.myUid())); + } + + @Test + @IgnoreUnderRavenwood + public void testIgnored() { + throw new RuntimeException("Shouldn't be executed under ravenwood"); + } +} diff --git a/ravenwood/test-authors.md b/ravenwood/test-authors.md index 2b5bd9083a40..5adef534a2b2 100644 --- a/ravenwood/test-authors.md +++ b/ravenwood/test-authors.md @@ -31,6 +31,14 @@ android_ravenwood_test { * Write your unit test just like you would for an Android device: ``` +import android.platform.test.annotations.IgnoreUnderRavenwood; +import android.platform.test.ravenwood.RavenwoodRule; + +import androidx.test.runner.AndroidJUnit4; + +import org.junit.Test; +import org.junit.runner.RunWith; + @RunWith(AndroidJUnit4.class) public class MyCodeTest { @Test @@ -43,6 +51,14 @@ public class MyCodeTest { * APIs available under Ravenwood are stateless by default. If your test requires explicit states (such as defining the UID you’re running under, or requiring a main `Looper` thread), add a `RavenwoodRule` to declare that: ``` +import android.platform.test.annotations.IgnoreUnderRavenwood; +import android.platform.test.ravenwood.RavenwoodRule; + +import androidx.test.runner.AndroidJUnit4; + +import org.junit.Test; +import org.junit.runner.RunWith; + @RunWith(AndroidJUnit4.class) public class MyCodeTest { @Rule diff --git a/services/core/java/com/android/server/am/BatteryStatsService.java b/services/core/java/com/android/server/am/BatteryStatsService.java index f2d9759a7cc9..f8f3d82556fa 100644 --- a/services/core/java/com/android/server/am/BatteryStatsService.java +++ b/services/core/java/com/android/server/am/BatteryStatsService.java @@ -886,9 +886,7 @@ public final class BatteryStatsService extends IBatteryStats.Stub syncStats("get-stats", BatteryExternalStatsWorker.UPDATE_ALL); } - synchronized (mStats) { - return mBatteryUsageStatsProvider.getBatteryUsageStats(mStats, queries); - } + return mBatteryUsageStatsProvider.getBatteryUsageStats(mStats, queries); } /** Register callbacks for statsd pulled atoms. */ @@ -2730,13 +2728,13 @@ public final class BatteryStatsService extends IBatteryStats.Stub BatteryUsageStatsQuery query = builder.build(); synchronized (mStats) { mStats.prepareForDumpLocked(); - BatteryUsageStats batteryUsageStats = - mBatteryUsageStatsProvider.getBatteryUsageStats(mStats, query); - if (proto) { - batteryUsageStats.dumpToProto(fd); - } else { - batteryUsageStats.dump(pw, ""); - } + } + BatteryUsageStats batteryUsageStats = + mBatteryUsageStatsProvider.getBatteryUsageStats(mStats, query); + if (proto) { + batteryUsageStats.dumpToProto(fd); + } else { + batteryUsageStats.dump(pw, ""); } } diff --git a/services/core/java/com/android/server/appop/AudioRestrictionManager.java b/services/core/java/com/android/server/appop/AudioRestrictionManager.java index be870373af63..b9ccc5389337 100644 --- a/services/core/java/com/android/server/appop/AudioRestrictionManager.java +++ b/services/core/java/com/android/server/appop/AudioRestrictionManager.java @@ -43,7 +43,7 @@ public class AudioRestrictionManager { static { SparseBooleanArray audioMutedUsages = new SparseBooleanArray(); SparseBooleanArray vibrationMutedUsages = new SparseBooleanArray(); - for (int usage : AudioAttributes.SDK_USAGES) { + for (int usage : AudioAttributes.SDK_USAGES.toArray()) { final int suppressionBehavior = AudioAttributes.SUPPRESSIBLE_USAGES.get(usage); if (suppressionBehavior == AudioAttributes.SUPPRESSIBLE_NOTIFICATION || suppressionBehavior == AudioAttributes.SUPPRESSIBLE_CALL || diff --git a/services/core/java/com/android/server/audio/AudioDeviceBroker.java b/services/core/java/com/android/server/audio/AudioDeviceBroker.java index b1706ed61e36..2f7d99fcbc4b 100644 --- a/services/core/java/com/android/server/audio/AudioDeviceBroker.java +++ b/services/core/java/com/android/server/audio/AudioDeviceBroker.java @@ -1595,8 +1595,8 @@ public class AudioDeviceBroker { sendILMsg(MSG_IL_BTA2DP_TIMEOUT, SENDMSG_QUEUE, a2dpCodec, address, delayMs); } - /*package*/ void setLeAudioTimeout(String address, int device, int delayMs) { - sendILMsg(MSG_IL_BTLEAUDIO_TIMEOUT, SENDMSG_QUEUE, device, address, delayMs); + /*package*/ void setLeAudioTimeout(String address, int device, int codec, int delayMs) { + sendIILMsg(MSG_IIL_BTLEAUDIO_TIMEOUT, SENDMSG_QUEUE, device, codec, address, delayMs); } /*package*/ void setAvrcpAbsoluteVolumeSupported(boolean supported) { @@ -1794,8 +1794,9 @@ public class AudioDeviceBroker { return; } @AudioSystem.AudioFormatNativeEnumForBtCodec final int codec = - mBtHelper.getA2dpCodecWithFallbackToSBC( - btInfo.mDevice, "MSG_L_SET_BT_ACTIVE_DEVICE"); + mBtHelper.getCodecWithFallback(btInfo.mDevice, + btInfo.mProfile, btInfo.mIsLeOutput, + "MSG_L_SET_BT_ACTIVE_DEVICE"); mDeviceInventory.onSetBtActiveDevice(btInfo, codec, (btInfo.mProfile != BluetoothProfile.LE_AUDIO || btInfo.mIsLeOutput) @@ -1819,22 +1820,24 @@ public class AudioDeviceBroker { case MSG_IL_BTA2DP_TIMEOUT: // msg.obj == address of BTA2DP device synchronized (mDeviceStateLock) { - mDeviceInventory.onMakeA2dpDeviceUnavailableNow((String) msg.obj, msg.arg1); + mDeviceInventory.onMakeA2dpDeviceUnavailableNow( + (String) msg.obj, msg.arg1); } break; - case MSG_IL_BTLEAUDIO_TIMEOUT: + case MSG_IIL_BTLEAUDIO_TIMEOUT: // msg.obj == address of LE Audio device synchronized (mDeviceStateLock) { mDeviceInventory.onMakeLeAudioDeviceUnavailableNow( - (String) msg.obj, msg.arg1); + (String) msg.obj, msg.arg1, msg.arg2); } break; case MSG_L_BLUETOOTH_DEVICE_CONFIG_CHANGE: { final BtDeviceInfo btInfo = (BtDeviceInfo) msg.obj; synchronized (mDeviceStateLock) { @AudioSystem.AudioFormatNativeEnumForBtCodec final int codec = - mBtHelper.getA2dpCodecWithFallbackToSBC( - btInfo.mDevice, "MSG_L_BLUETOOTH_DEVICE_CONFIG_CHANGE"); + mBtHelper.getCodecWithFallback(btInfo.mDevice, + btInfo.mProfile, btInfo.mIsLeOutput, + "MSG_L_BLUETOOTH_DEVICE_CONFIG_CHANGE"); mDeviceInventory.onBluetoothDeviceConfigChange( btInfo, codec, BtHelper.EVENT_DEVICE_CONFIG_CHANGE); } @@ -2084,7 +2087,7 @@ public class AudioDeviceBroker { private static final int MSG_IL_SAVE_NDEF_DEVICE_FOR_STRATEGY = 47; private static final int MSG_IL_SAVE_REMOVE_NDEF_DEVICE_FOR_STRATEGY = 48; - private static final int MSG_IL_BTLEAUDIO_TIMEOUT = 49; + private static final int MSG_IIL_BTLEAUDIO_TIMEOUT = 49; private static final int MSG_L_NOTIFY_PREFERRED_AUDIOPROFILE_APPLIED = 52; private static final int MSG_L_CHECK_COMMUNICATION_DEVICE_REMOVAL = 53; @@ -2104,7 +2107,7 @@ public class AudioDeviceBroker { case MSG_L_SET_WIRED_DEVICE_CONNECTION_STATE: case MSG_L_SET_BT_ACTIVE_DEVICE: case MSG_IL_BTA2DP_TIMEOUT: - case MSG_IL_BTLEAUDIO_TIMEOUT: + case MSG_IIL_BTLEAUDIO_TIMEOUT: case MSG_L_BLUETOOTH_DEVICE_CONFIG_CHANGE: case MSG_TOGGLE_HDMI: case MSG_L_A2DP_DEVICE_CONNECTION_CHANGE_EXT: @@ -2196,7 +2199,7 @@ public class AudioDeviceBroker { case MSG_L_SET_BT_ACTIVE_DEVICE: case MSG_L_SET_WIRED_DEVICE_CONNECTION_STATE: case MSG_IL_BTA2DP_TIMEOUT: - case MSG_IL_BTLEAUDIO_TIMEOUT: + case MSG_IIL_BTLEAUDIO_TIMEOUT: case MSG_L_BLUETOOTH_DEVICE_CONFIG_CHANGE: if (sLastDeviceConnectMsgTime >= time) { // add a little delay to make sure messages are ordered as expected diff --git a/services/core/java/com/android/server/audio/AudioDeviceInventory.java b/services/core/java/com/android/server/audio/AudioDeviceInventory.java index e9b102bc67b8..e503f1f2c8c2 100644 --- a/services/core/java/com/android/server/audio/AudioDeviceInventory.java +++ b/services/core/java/com/android/server/audio/AudioDeviceInventory.java @@ -689,9 +689,11 @@ public class AudioDeviceInventory { case BluetoothProfile.LE_AUDIO: case BluetoothProfile.LE_AUDIO_BROADCAST: if (switchToUnavailable) { - makeLeAudioDeviceUnavailableNow(address, btInfo.mAudioSystemDevice); + makeLeAudioDeviceUnavailableNow(address, + btInfo.mAudioSystemDevice, di.mDeviceCodecFormat); } else if (switchToAvailable) { - makeLeAudioDeviceAvailable(btInfo, streamType, "onSetBtActiveDevice"); + makeLeAudioDeviceAvailable( + btInfo, streamType, codec, "onSetBtActiveDevice"); } break; default: throw new IllegalArgumentException("Invalid profile " @@ -752,12 +754,13 @@ public class AudioDeviceInventory { if (event == BtHelper.EVENT_DEVICE_CONFIG_CHANGE) { - boolean a2dpCodecChange = false; - if (btInfo.mProfile == BluetoothProfile.A2DP) { + boolean codecChange = false; + if (btInfo.mProfile == BluetoothProfile.A2DP + || btInfo.mProfile == BluetoothProfile.LE_AUDIO) { if (di.mDeviceCodecFormat != codec) { di.mDeviceCodecFormat = codec; mConnectedDevices.replace(key, di); - a2dpCodecChange = true; + codecChange = true; } final int res = mAudioSystem.handleDeviceConfigChange( btInfo.mAudioSystemDevice, address, BtHelper.getName(btDevice), codec); @@ -782,7 +785,7 @@ public class AudioDeviceInventory { } } - if (!a2dpCodecChange) { + if (!codecChange) { updateBluetoothPreferredModes_l(btDevice /*connectedDevice*/); } } @@ -796,9 +799,9 @@ public class AudioDeviceInventory { } } - /*package*/ void onMakeLeAudioDeviceUnavailableNow(String address, int device) { + /*package*/ void onMakeLeAudioDeviceUnavailableNow(String address, int device, int codec) { synchronized (mDevicesLock) { - makeLeAudioDeviceUnavailableNow(address, device); + makeLeAudioDeviceUnavailableNow(address, device, codec); } } @@ -1335,6 +1338,27 @@ public class AudioDeviceInventory { } } + private static boolean devicesListEqual(@NonNull List<AudioDeviceAttributes> list1, + @NonNull List<AudioDeviceAttributes> list2) { + if (list1.size() != list2.size()) { + return false; + } + // This assumes a given device is only present once in a list + for (AudioDeviceAttributes d1 : list1) { + boolean found = false; + for (AudioDeviceAttributes d2 : list2) { + if (d1.equalTypeAddress(d2)) { + found = true; + break; + } + } + if (!found) { + return false; + } + } + return true; + } + private int setDevicesRole( ArrayMap<Pair<Integer, Integer>, List<AudioDeviceAttributes>> rolesMap, AudioSystemInterface addOp, @@ -1342,31 +1366,26 @@ public class AudioDeviceInventory { int useCase, int role, @NonNull List<AudioDeviceAttributes> devices) { synchronized (rolesMap) { Pair<Integer, Integer> key = new Pair<>(useCase, role); - List<AudioDeviceAttributes> roleDevices = new ArrayList<>(); - List<AudioDeviceAttributes> appliedDevices = new ArrayList<>(); - if (rolesMap.containsKey(key)) { - roleDevices = rolesMap.get(key); - boolean equal = false; - if (roleDevices.size() == devices.size()) { - roleDevices.retainAll(devices); - equal = roleDevices.size() == devices.size(); - } - if (!equal) { - clearOp.deviceRoleAction(useCase, role, null); - roleDevices.clear(); - appliedDevices.addAll(devices); + if (devicesListEqual(devices, rolesMap.get(key))) { + // NO OP: no change in preference + return AudioSystem.SUCCESS; } - } else { - appliedDevices.addAll(devices); - } - if (appliedDevices.isEmpty()) { + } else if (devices.isEmpty()) { + // NO OP: no preference to no preference return AudioSystem.SUCCESS; } - final int status = addOp.deviceRoleAction(useCase, role, appliedDevices); - if (status == AudioSystem.SUCCESS) { - roleDevices.addAll(appliedDevices); - rolesMap.put(key, roleDevices); + int status; + if (devices.isEmpty()) { + status = clearOp.deviceRoleAction(useCase, role, null); + if (status == AudioSystem.SUCCESS) { + rolesMap.remove(key); + } + } else { + status = addOp.deviceRoleAction(useCase, role, devices); + if (status == AudioSystem.SUCCESS) { + rolesMap.put(key, devices); + } } return status; } @@ -1641,11 +1660,12 @@ public class AudioDeviceInventory { } synchronized (mDevicesLock) { - final ArraySet<String> toRemove = new ArraySet<>(); + final ArraySet<Pair<String, Integer>> toRemove = new ArraySet<>(); // Disconnect ALL DEVICE_OUT_BLE_HEADSET or DEVICE_OUT_BLE_BROADCAST devices mConnectedDevices.values().forEach(deviceInfo -> { if (deviceInfo.mDeviceType == device) { - toRemove.add(deviceInfo.mDeviceAddress); + toRemove.add( + new Pair<>(deviceInfo.mDeviceAddress, deviceInfo.mDeviceCodecFormat)); } }); new MediaMetrics.Item(mMetricsId + "disconnectLeAudio") @@ -1655,8 +1675,8 @@ public class AudioDeviceInventory { final int delay = checkSendBecomingNoisyIntentInt(device, AudioService.CONNECTION_STATE_DISCONNECTED, AudioSystem.DEVICE_NONE); - toRemove.stream().forEach(deviceAddress -> - makeLeAudioDeviceUnavailableLater(deviceAddress, device, delay) + toRemove.stream().forEach(entry -> + makeLeAudioDeviceUnavailableLater(entry.first, device, entry.second, delay) ); } } @@ -2200,7 +2220,8 @@ public class AudioDeviceInventory { @GuardedBy("mDevicesLock") private void makeLeAudioDeviceAvailable( - AudioDeviceBroker.BtDeviceInfo btInfo, int streamType, String eventSource) { + AudioDeviceBroker.BtDeviceInfo btInfo, int streamType, + @AudioSystem.AudioFormatNativeEnumForBtCodec int codec, String eventSource) { final int volumeIndex = btInfo.mVolume == -1 ? -1 : btInfo.mVolume * 10; final int device = btInfo.mAudioSystemDevice; @@ -2234,7 +2255,7 @@ public class AudioDeviceInventory { AudioDeviceAttributes ada = new AudioDeviceAttributes(device, address, name); final int res = AudioSystem.setDeviceConnectionState(ada, - AudioSystem.DEVICE_STATE_AVAILABLE, AudioSystem.AUDIO_FORMAT_DEFAULT); + AudioSystem.DEVICE_STATE_AVAILABLE, codec); if (res != AudioSystem.AUDIO_STATUS_OK) { AudioService.sDeviceLogger.enqueue(new EventLogger.StringEvent( "APM failed to make available LE Audio device addr=" + address @@ -2249,7 +2270,7 @@ public class AudioDeviceInventory { // Reset LEA suspend state each time a new sink is connected mDeviceBroker.clearLeAudioSuspended(true /* internalOnly */); mConnectedDevices.put(DeviceInfo.makeDeviceListKey(device, address), - new DeviceInfo(device, name, address, AudioSystem.AUDIO_FORMAT_DEFAULT, + new DeviceInfo(device, name, address, codec, peerAddress, groupId)); mDeviceBroker.postAccessoryPlugMediaUnmute(device); setCurrentAudioRouteNameIfPossible(name, /*fromA2dp=*/false); @@ -2272,13 +2293,14 @@ public class AudioDeviceInventory { } @GuardedBy("mDevicesLock") - private void makeLeAudioDeviceUnavailableNow(String address, int device) { + private void makeLeAudioDeviceUnavailableNow(String address, int device, + @AudioSystem.AudioFormatNativeEnumForBtCodec int codec) { AudioDeviceAttributes ada = null; if (device != AudioSystem.DEVICE_NONE) { ada = new AudioDeviceAttributes(device, address); final int res = AudioSystem.setDeviceConnectionState(ada, AudioSystem.DEVICE_STATE_UNAVAILABLE, - AudioSystem.AUDIO_FORMAT_DEFAULT); + codec); if (res != AudioSystem.AUDIO_STATUS_OK) { AudioService.sDeviceLogger.enqueue(new EventLogger.StringEvent( @@ -2303,7 +2325,8 @@ public class AudioDeviceInventory { } @GuardedBy("mDevicesLock") - private void makeLeAudioDeviceUnavailableLater(String address, int device, int delayMs) { + private void makeLeAudioDeviceUnavailableLater( + String address, int device, int codec, int delayMs) { // prevent any activity on the LEA output to avoid unwanted // reconnection of the sink. mDeviceBroker.setLeAudioSuspended( @@ -2311,7 +2334,7 @@ public class AudioDeviceInventory { // the device will be made unavailable later, so consider it disconnected right away mConnectedDevices.remove(DeviceInfo.makeDeviceListKey(device, address)); // send the delayed message to make the device unavailable later - mDeviceBroker.setLeAudioTimeout(address, device, delayMs); + mDeviceBroker.setLeAudioTimeout(address, device, codec, delayMs); } @GuardedBy("mDevicesLock") diff --git a/services/core/java/com/android/server/audio/BtHelper.java b/services/core/java/com/android/server/audio/BtHelper.java index 7b9621581adf..a078d08a2c8f 100644 --- a/services/core/java/com/android/server/audio/BtHelper.java +++ b/services/core/java/com/android/server/audio/BtHelper.java @@ -26,6 +26,7 @@ import android.bluetooth.BluetoothDevice; import android.bluetooth.BluetoothHeadset; import android.bluetooth.BluetoothHearingAid; import android.bluetooth.BluetoothLeAudio; +import android.bluetooth.BluetoothLeAudioCodecConfig; import android.bluetooth.BluetoothLeAudioCodecStatus; import android.bluetooth.BluetoothProfile; import android.content.Context; @@ -250,35 +251,73 @@ public class BtHelper { } } - /*package*/ synchronized @AudioSystem.AudioFormatNativeEnumForBtCodec int getA2dpCodec( - @NonNull BluetoothDevice device) { - if (mA2dp == null) { - return AudioSystem.AUDIO_FORMAT_DEFAULT; - } - BluetoothCodecStatus btCodecStatus = null; - try { - btCodecStatus = mA2dp.getCodecStatus(device); - } catch (Exception e) { - Log.e(TAG, "Exception while getting status of " + device, e); - } - if (btCodecStatus == null) { - return AudioSystem.AUDIO_FORMAT_DEFAULT; - } - final BluetoothCodecConfig btCodecConfig = btCodecStatus.getCodecConfig(); - if (btCodecConfig == null) { - return AudioSystem.AUDIO_FORMAT_DEFAULT; + /*package*/ synchronized @AudioSystem.AudioFormatNativeEnumForBtCodec int getCodec( + @NonNull BluetoothDevice device, @AudioService.BtProfile int profile) { + switch (profile) { + case BluetoothProfile.A2DP: { + if (mA2dp == null) { + return AudioSystem.AUDIO_FORMAT_DEFAULT; + } + BluetoothCodecStatus btCodecStatus = null; + try { + btCodecStatus = mA2dp.getCodecStatus(device); + } catch (Exception e) { + Log.e(TAG, "Exception while getting status of " + device, e); + } + if (btCodecStatus == null) { + return AudioSystem.AUDIO_FORMAT_DEFAULT; + } + final BluetoothCodecConfig btCodecConfig = btCodecStatus.getCodecConfig(); + if (btCodecConfig == null) { + return AudioSystem.AUDIO_FORMAT_DEFAULT; + } + return AudioSystem.bluetoothA2dpCodecToAudioFormat(btCodecConfig.getCodecType()); + } + case BluetoothProfile.LE_AUDIO: { + if (mLeAudio == null) { + return AudioSystem.AUDIO_FORMAT_DEFAULT; + } + BluetoothLeAudioCodecStatus btLeCodecStatus = null; + int groupId = mLeAudio.getGroupId(device); + try { + btLeCodecStatus = mLeAudio.getCodecStatus(groupId); + } catch (Exception e) { + Log.e(TAG, "Exception while getting status of " + device, e); + } + if (btLeCodecStatus == null) { + return AudioSystem.AUDIO_FORMAT_DEFAULT; + } + BluetoothLeAudioCodecConfig btLeCodecConfig = + btLeCodecStatus.getOutputCodecConfig(); + if (btLeCodecConfig == null) { + return AudioSystem.AUDIO_FORMAT_DEFAULT; + } + return AudioSystem.bluetoothLeCodecToAudioFormat(btLeCodecConfig.getCodecType()); + } + default: + return AudioSystem.AUDIO_FORMAT_DEFAULT; } - return AudioSystem.bluetoothCodecToAudioFormat(btCodecConfig.getCodecType()); } /*package*/ synchronized @AudioSystem.AudioFormatNativeEnumForBtCodec - int getA2dpCodecWithFallbackToSBC( - @NonNull BluetoothDevice device, @NonNull String source) { - @AudioSystem.AudioFormatNativeEnumForBtCodec int codec = getA2dpCodec(device); + int getCodecWithFallback( + @NonNull BluetoothDevice device, @AudioService.BtProfile int profile, + boolean isLeOutput, @NonNull String source) { + // For profiles other than A2DP and LE Audio output, the audio codec format must be + // AUDIO_FORMAT_DEFAULT as native audio policy manager expects a specific audio format + // only if audio HW module selection based on format is supported for the device type. + if (!(profile == BluetoothProfile.A2DP + || (profile == BluetoothProfile.LE_AUDIO && isLeOutput))) { + return AudioSystem.AUDIO_FORMAT_DEFAULT; + } + @AudioSystem.AudioFormatNativeEnumForBtCodec int codec = + getCodec(device, profile); if (codec == AudioSystem.AUDIO_FORMAT_DEFAULT) { AudioService.sDeviceLogger.enqueue(new EventLogger.StringEvent( - "getA2dpCodec DEFAULT from " + source + " fallback to SBC")); - return AudioSystem.AUDIO_FORMAT_SBC; + "getCodec DEFAULT from " + source + " fallback to " + + (profile == BluetoothProfile.A2DP ? "SBC" : "LC3"))); + return profile == BluetoothProfile.A2DP + ? AudioSystem.AUDIO_FORMAT_SBC : AudioSystem.AUDIO_FORMAT_LC3; } return codec; } diff --git a/services/core/java/com/android/server/biometrics/log/BiometricContextProvider.java b/services/core/java/com/android/server/biometrics/log/BiometricContextProvider.java index 745222873698..95a047faef07 100644 --- a/services/core/java/com/android/server/biometrics/log/BiometricContextProvider.java +++ b/services/core/java/com/android/server/biometrics/log/BiometricContextProvider.java @@ -116,8 +116,10 @@ public final class BiometricContextProvider implements BiometricContext { service.setBiometicContextListener(new IBiometricContextListener.Stub() { @Override public void onFoldChanged(int foldState) { - mFoldState = foldState; - // no need to notify, not sent to HAL + if (mFoldState != foldState) { + mFoldState = foldState; + notifyChanged(); + } } @Override @@ -254,6 +256,7 @@ public final class BiometricContextProvider implements BiometricContext { + "isAwake: " + isAwake() + ", " + "isDisplayOn: " + isDisplayOn() + ", " + "dock: " + getDockedState() + ", " - + "rotation: " + getCurrentRotation() + "]"; + + "rotation: " + getCurrentRotation() + ", " + + "foldState: " + mFoldState + "]"; } } diff --git a/services/core/java/com/android/server/biometrics/log/OperationContextExt.java b/services/core/java/com/android/server/biometrics/log/OperationContextExt.java index f78ca43253f6..b4e0dff615f5 100644 --- a/services/core/java/com/android/server/biometrics/log/OperationContextExt.java +++ b/services/core/java/com/android/server/biometrics/log/OperationContextExt.java @@ -23,6 +23,7 @@ import android.hardware.biometrics.AuthenticateOptions; import android.hardware.biometrics.IBiometricContextListener; import android.hardware.biometrics.common.AuthenticateReason; import android.hardware.biometrics.common.DisplayState; +import android.hardware.biometrics.common.FoldState; import android.hardware.biometrics.common.OperationContext; import android.hardware.biometrics.common.OperationReason; import android.hardware.biometrics.common.WakeReason; @@ -250,6 +251,7 @@ public class OperationContextExt { OperationContextExt update(@NonNull BiometricContext biometricContext, boolean isCrypto) { mAidlContext.isAod = biometricContext.isAod(); mAidlContext.displayState = toAidlDisplayState(biometricContext.getDisplayState()); + mAidlContext.foldState = toAidlFoldState(biometricContext.getFoldState()); mAidlContext.isCrypto = isCrypto; setFirstSessionId(biometricContext); @@ -276,6 +278,19 @@ public class OperationContextExt { return DisplayState.UNKNOWN; } + @FoldState + private static int toAidlFoldState(@IBiometricContextListener.FoldState int state) { + switch (state) { + case IBiometricContextListener.FoldState.FULLY_CLOSED: + return FoldState.FULLY_CLOSED; + case IBiometricContextListener.FoldState.FULLY_OPENED: + return FoldState.FULLY_OPENED; + case IBiometricContextListener.FoldState.HALF_OPENED: + return FoldState.HALF_OPENED; + } + return FoldState.UNKNOWN; + } + private void setFirstSessionId(@NonNull BiometricContext biometricContext) { if (mIsBP) { mSessionInfo = biometricContext.getBiometricPromptSessionInfo(); diff --git a/services/core/java/com/android/server/clipboard/ClipboardService.java b/services/core/java/com/android/server/clipboard/ClipboardService.java index b394fb5b3afe..56a94ec06ad4 100644 --- a/services/core/java/com/android/server/clipboard/ClipboardService.java +++ b/services/core/java/com/android/server/clipboard/ClipboardService.java @@ -56,6 +56,7 @@ import android.graphics.drawable.Drawable; import android.hardware.display.DisplayManager; import android.net.Uri; import android.os.Binder; +import android.os.Build; import android.os.Bundle; import android.os.Handler; import android.os.HandlerThread; @@ -67,7 +68,6 @@ import android.os.Parcel; import android.os.RemoteCallbackList; import android.os.RemoteException; import android.os.ServiceManager; -import android.os.SystemProperties; import android.os.UserHandle; import android.os.UserManager; import android.provider.DeviceConfig; @@ -116,8 +116,6 @@ import java.util.function.Consumer; public class ClipboardService extends SystemService { private static final String TAG = "ClipboardService"; - private static final boolean IS_EMULATOR = - SystemProperties.getBoolean("ro.boot.qemu", false); @VisibleForTesting public static final long DEFAULT_CLIPBOARD_TIMEOUT_MILLIS = 3600000; @@ -193,7 +191,7 @@ public class ClipboardService extends SystemService { mAutofillInternal = LocalServices.getService(AutofillManagerInternal.class); final IBinder permOwner = mUgmInternal.newUriPermissionOwner("clipboard"); mPermissionOwner = permOwner; - if (IS_EMULATOR) { + if (Build.IS_EMULATOR) { mEmulatorClipboardMonitor = new EmulatorClipboardMonitor((clip) -> { synchronized (mLock) { Clipboard clipboard = getClipboardLocked(0, DEVICE_ID_DEFAULT); diff --git a/services/core/java/com/android/server/connectivity/Vpn.java b/services/core/java/com/android/server/connectivity/Vpn.java index aef224843b2f..c5170585a1b3 100644 --- a/services/core/java/com/android/server/connectivity/Vpn.java +++ b/services/core/java/com/android/server/connectivity/Vpn.java @@ -56,7 +56,6 @@ import android.content.pm.ResolveInfo; import android.content.pm.UserInfo; import android.net.ConnectivityDiagnosticsManager; import android.net.ConnectivityManager; -import android.net.DnsResolver; import android.net.INetd; import android.net.INetworkManagementEventObserver; import android.net.Ikev2VpnProfile; @@ -67,8 +66,6 @@ import android.net.IpSecManager.IpSecTunnelInterface; import android.net.IpSecTransform; import android.net.LinkAddress; import android.net.LinkProperties; -import android.net.LocalSocket; -import android.net.LocalSocketAddress; import android.net.Network; import android.net.NetworkAgent; import android.net.NetworkAgentConfig; @@ -109,7 +106,6 @@ import android.net.vcn.VcnTransportInfo; import android.os.Binder; import android.os.Build.VERSION_CODES; import android.os.Bundle; -import android.os.CancellationSignal; import android.os.Handler; import android.os.IBinder; import android.os.INetworkManagementService; @@ -120,7 +116,6 @@ import android.os.PersistableBundle; import android.os.Process; import android.os.RemoteException; import android.os.SystemClock; -import android.os.SystemService; import android.os.UserHandle; import android.os.UserManager; import android.provider.Settings; @@ -160,11 +155,8 @@ import com.android.server.vcn.util.PersistableBundleUtils; import libcore.io.IoUtils; -import java.io.File; import java.io.FileDescriptor; import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; import java.net.Inet4Address; import java.net.Inet6Address; import java.net.InetAddress; @@ -190,8 +182,6 @@ import java.util.Set; import java.util.SortedSet; import java.util.TreeSet; import java.util.UUID; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ExecutionException; import java.util.concurrent.Executor; import java.util.concurrent.RejectedExecutionException; import java.util.concurrent.ScheduledFuture; @@ -451,10 +441,6 @@ public class Vpn { // The user id of initiating VPN. private final int mUserId; - interface RetryScheduler { - void checkInterruptAndDelay(boolean sleepLonger) throws InterruptedException; - } - private static class CarrierConfigInfo { public final String mccMnc; public final int keepaliveDelaySec; @@ -483,26 +469,6 @@ public class Vpn { return Binder.getCallingUid() == Process.SYSTEM_UID; } - public void startService(final String serviceName) { - SystemService.start(serviceName); - } - - public void stopService(final String serviceName) { - SystemService.stop(serviceName); - } - - public boolean isServiceRunning(final String serviceName) { - return SystemService.isRunning(serviceName); - } - - public boolean isServiceStopped(final String serviceName) { - return SystemService.isStopped(serviceName); - } - - public File getStateFile() { - return new File("/data/misc/vpn/state"); - } - public DeviceIdleInternal getDeviceIdleInternal() { return LocalServices.getService(DeviceIdleInternal.class); } @@ -511,104 +477,6 @@ public class Vpn { return VpnConfig.getIntentForStatusPanel(context); } - public void sendArgumentsToDaemon( - final String daemon, final LocalSocket socket, final String[] arguments, - final RetryScheduler retryScheduler) throws IOException, InterruptedException { - final LocalSocketAddress address = new LocalSocketAddress( - daemon, LocalSocketAddress.Namespace.RESERVED); - - // Wait for the socket to connect. - while (true) { - try { - socket.connect(address); - break; - } catch (Exception e) { - // ignore - } - retryScheduler.checkInterruptAndDelay(true /* sleepLonger */); - } - socket.setSoTimeout(500); - - final OutputStream out = socket.getOutputStream(); - for (String argument : arguments) { - byte[] bytes = argument.getBytes(StandardCharsets.UTF_8); - if (bytes.length >= 0xFFFF) { - throw new IllegalArgumentException("Argument is too large"); - } - out.write(bytes.length >> 8); - out.write(bytes.length); - out.write(bytes); - retryScheduler.checkInterruptAndDelay(false /* sleepLonger */); - } - out.write(0xFF); - out.write(0xFF); - - // Wait for End-of-File. - final InputStream in = socket.getInputStream(); - while (true) { - try { - if (in.read() == -1) { - break; - } - } catch (Exception e) { - // ignore - } - retryScheduler.checkInterruptAndDelay(true /* sleepLonger */); - } - } - - @NonNull - public InetAddress resolve(final String endpoint) - throws ExecutionException, InterruptedException { - try { - return InetAddresses.parseNumericAddress(endpoint); - } catch (IllegalArgumentException e) { - // Endpoint is not numeric : fall through and resolve - } - - final CancellationSignal cancellationSignal = new CancellationSignal(); - try { - final DnsResolver resolver = DnsResolver.getInstance(); - final CompletableFuture<InetAddress> result = new CompletableFuture(); - final DnsResolver.Callback<List<InetAddress>> cb = - new DnsResolver.Callback<List<InetAddress>>() { - @Override - public void onAnswer(@NonNull final List<InetAddress> answer, - final int rcode) { - if (answer.size() > 0) { - result.complete(answer.get(0)); - } else { - result.completeExceptionally( - new UnknownHostException(endpoint)); - } - } - - @Override - public void onError(@Nullable final DnsResolver.DnsException error) { - // Unfortunately UnknownHostException doesn't accept a cause, so - // print a message here instead. Only show the summary, not the - // full stack trace. - Log.e(TAG, "Async dns resolver error : " + error); - result.completeExceptionally(new UnknownHostException(endpoint)); - } - }; - resolver.query(null /* network, null for default */, endpoint, - DnsResolver.FLAG_EMPTY, r -> r.run(), cancellationSignal, cb); - return result.get(); - } catch (final ExecutionException e) { - Log.e(TAG, "Cannot resolve VPN endpoint : " + endpoint + ".", e); - throw e; - } catch (final InterruptedException e) { - Log.e(TAG, "Legacy VPN was interrupted while resolving the endpoint", e); - cancellationSignal.cancel(); - throw e; - } - } - - public boolean isInterfacePresent(final Vpn vpn, final String iface) { - return vpn.jniCheck(iface) != 0; - } - /** * @see ParcelFileDescriptor#adoptFd(int) */ diff --git a/services/core/java/com/android/server/display/DisplayPowerController.java b/services/core/java/com/android/server/display/DisplayPowerController.java index f09fcea69a88..2cca72e4c883 100644 --- a/services/core/java/com/android/server/display/DisplayPowerController.java +++ b/services/core/java/com/android/server/display/DisplayPowerController.java @@ -1978,8 +1978,9 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call || sdrAnimateValue != currentSdrBrightness)) { boolean skipAnimation = initialRampSkip || hasBrightnessBuckets || !isDisplayContentVisible || brightnessIsTemporary; - if (!skipAnimation && BrightnessSynchronizer.floatEquals( - sdrAnimateValue, currentSdrBrightness)) { + final boolean isHdrOnlyChange = BrightnessSynchronizer.floatEquals( + sdrAnimateValue, currentSdrBrightness); + if (mFlags.isFastHdrTransitionsEnabled() && !skipAnimation && isHdrOnlyChange) { // SDR brightness is unchanged, so animate quickly as this is only impacting // a likely minority amount of display content // ie, the highlights of an HDR video or UltraHDR image diff --git a/services/core/java/com/android/server/display/DisplayPowerController2.java b/services/core/java/com/android/server/display/DisplayPowerController2.java index 5310e43eaf1b..810ac08e32c1 100644 --- a/services/core/java/com/android/server/display/DisplayPowerController2.java +++ b/services/core/java/com/android/server/display/DisplayPowerController2.java @@ -1602,8 +1602,9 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal || sdrAnimateValue != currentSdrBrightness)) { boolean skipAnimation = initialRampSkip || hasBrightnessBuckets || !isDisplayContentVisible || brightnessIsTemporary; - if (!skipAnimation && BrightnessSynchronizer.floatEquals( - sdrAnimateValue, currentSdrBrightness)) { + final boolean isHdrOnlyChange = BrightnessSynchronizer.floatEquals( + sdrAnimateValue, currentSdrBrightness); + if (mFlags.isFastHdrTransitionsEnabled() && !skipAnimation && isHdrOnlyChange) { // SDR brightness is unchanged, so animate quickly as this is only impacting // a likely minority amount of display content // ie, the highlights of an HDR video or UltraHDR image diff --git a/services/core/java/com/android/server/display/feature/DisplayManagerFlags.java b/services/core/java/com/android/server/display/feature/DisplayManagerFlags.java index f579dbd16592..bd5e189a5404 100644 --- a/services/core/java/com/android/server/display/feature/DisplayManagerFlags.java +++ b/services/core/java/com/android/server/display/feature/DisplayManagerFlags.java @@ -101,6 +101,10 @@ public class DisplayManagerFlags { Flags.FLAG_AUTO_BRIGHTNESS_MODES, Flags::autoBrightnessModes); + private final FlagState mFastHdrTransitions = new FlagState( + Flags.FLAG_FAST_HDR_TRANSITIONS, + Flags::fastHdrTransitions); + /** Returns whether connected display management is enabled or not. */ public boolean isConnectedDisplayManagementEnabled() { return mConnectedDisplayManagementFlagState.isEnabled(); @@ -205,6 +209,10 @@ public class DisplayManagerFlags { return mAutoBrightnessModesFlagState.isEnabled(); } + public boolean isFastHdrTransitionsEnabled() { + return mFastHdrTransitions.isEnabled(); + } + /** * dumps all flagstates * @param pw printWriter @@ -226,6 +234,7 @@ public class DisplayManagerFlags { pw.println(" " + mVsyncProximityVote); pw.println(" " + mBrightnessWearBedtimeModeClamperFlagState); pw.println(" " + mAutoBrightnessModesFlagState); + pw.println(" " + mFastHdrTransitions); } private static class FlagState { diff --git a/services/core/java/com/android/server/display/feature/display_flags.aconfig b/services/core/java/com/android/server/display/feature/display_flags.aconfig index 1b4d74cdff1f..7a723a3290a9 100644 --- a/services/core/java/com/android/server/display/feature/display_flags.aconfig +++ b/services/core/java/com/android/server/display/feature/display_flags.aconfig @@ -144,3 +144,12 @@ flag { bug: "293613040" is_fixed_read_only: true } + +flag { + name: "fast_hdr_transitions" + namespace: "display_manager" + description: "Feature flag for fast transitions into/out of HDR" + bug: "292124102" + is_fixed_read_only: true +} + diff --git a/services/core/java/com/android/server/hdmi/NewDeviceAction.java b/services/core/java/com/android/server/hdmi/NewDeviceAction.java index 6147c10f85d5..f3532e5ce7e9 100644 --- a/services/core/java/com/android/server/hdmi/NewDeviceAction.java +++ b/services/core/java/com/android/server/hdmi/NewDeviceAction.java @@ -182,7 +182,7 @@ final class NewDeviceAction extends HdmiCecFeatureAction { .setVendorId(mVendorId) .setDisplayName(mDisplayName) .build(); - localDevice().mService.getHdmiCecNetwork().addCecDevice(deviceInfo); + localDevice().mService.getHdmiCecNetwork().updateCecDevice(deviceInfo); // Consume CEC messages we already got for this newly found device. tv().processDelayedMessages(mDeviceLogicalAddress); diff --git a/services/core/java/com/android/server/notification/ZenModeEventLogger.java b/services/core/java/com/android/server/notification/ZenModeEventLogger.java index 1641d4a6ed46..87158cd6fe29 100644 --- a/services/core/java/com/android/server/notification/ZenModeEventLogger.java +++ b/services/core/java/com/android/server/notification/ZenModeEventLogger.java @@ -23,6 +23,7 @@ import static android.service.notification.NotificationServiceProto.RULE_TYPE_MA import static android.service.notification.NotificationServiceProto.RULE_TYPE_UNKNOWN; import android.annotation.NonNull; +import android.app.Flags; import android.app.NotificationManager; import android.content.pm.PackageManager; import android.os.Process; @@ -502,6 +503,13 @@ class ZenModeEventLogger { ZenModeConfig.getZenPolicySenders(mNewPolicy.allowMessagesFrom())); proto.write(DNDPolicyProto.ALLOW_CONVERSATIONS_FROM, mNewPolicy.allowConversationsFrom()); + + if (Flags.modesApi()) { + proto.write(DNDPolicyProto.ALLOW_CHANNELS, + mNewPolicy.allowPriorityChannels() + ? ZenPolicy.CHANNEL_TYPE_PRIORITY + : ZenPolicy.CHANNEL_TYPE_NONE); + } } else { Log.wtf(TAG, "attempted to write zen mode log event with null policy"); } diff --git a/services/core/java/com/android/server/notification/ZenModeHelper.java b/services/core/java/com/android/server/notification/ZenModeHelper.java index 89d820050b03..d0ded63162db 100644 --- a/services/core/java/com/android/server/notification/ZenModeHelper.java +++ b/services/core/java/com/android/server/notification/ZenModeHelper.java @@ -1519,7 +1519,7 @@ public class ZenModeHelper { final boolean muteEverything = zenSilence || (zenPriorityOnly && ZenModeConfig.areAllZenBehaviorSoundsMuted(mConsolidatedPolicy)); - for (int usage : AudioAttributes.SDK_USAGES) { + for (int usage : AudioAttributes.SDK_USAGES.toArray()) { final int suppressionBehavior = AudioAttributes.SUPPRESSIBLE_USAGES.get(usage); if (suppressionBehavior == AudioAttributes.SUPPRESSIBLE_NEVER) { applyRestrictions(zenPriorityOnly, false /*mute*/, usage); diff --git a/services/core/java/com/android/server/pm/PackageArchiver.java b/services/core/java/com/android/server/pm/PackageArchiver.java index 9f072f932a95..e3bab3f243c3 100644 --- a/services/core/java/com/android/server/pm/PackageArchiver.java +++ b/services/core/java/com/android/server/pm/PackageArchiver.java @@ -54,6 +54,7 @@ import android.content.pm.LauncherActivityInfo; import android.content.pm.LauncherApps; import android.content.pm.PackageInstaller; import android.content.pm.PackageManager; +import android.content.pm.PackageManager.DeleteFlags; import android.content.pm.ParceledListSlice; import android.content.pm.ResolveInfo; import android.content.pm.VersionedPackage; @@ -154,7 +155,8 @@ public class PackageArchiver { @NonNull String packageName, @NonNull String callerPackageName, @NonNull IntentSender intentSender, - @NonNull UserHandle userHandle) { + @NonNull UserHandle userHandle, + @DeleteFlags int flags) { Objects.requireNonNull(packageName); Objects.requireNonNull(callerPackageName); Objects.requireNonNull(intentSender); @@ -195,7 +197,7 @@ public class PackageArchiver { new VersionedPackage(packageName, PackageManager.VERSION_CODE_HIGHEST), callerPackageName, - DELETE_ARCHIVE | DELETE_KEEP_DATA, + DELETE_ARCHIVE | DELETE_KEEP_DATA | flags, intentSender, userId, binderUid); diff --git a/services/core/java/com/android/server/pm/PackageInstallerService.java b/services/core/java/com/android/server/pm/PackageInstallerService.java index f731f95b404d..7d6dd62153c1 100644 --- a/services/core/java/com/android/server/pm/PackageInstallerService.java +++ b/services/core/java/com/android/server/pm/PackageInstallerService.java @@ -67,6 +67,7 @@ import android.content.pm.PackageInstaller.SessionParams; import android.content.pm.PackageInstaller.UnarchivalStatus; import android.content.pm.PackageItemInfo; import android.content.pm.PackageManager; +import android.content.pm.PackageManager.DeleteFlags; import android.content.pm.ParceledListSlice; import android.content.pm.VersionedPackage; import android.content.pm.parsing.FrameworkParsingPackageUtils; @@ -1390,11 +1391,14 @@ public class PackageInstallerService extends IPackageInstaller.Stub implements final PackageDeleteObserverAdapter adapter = new PackageDeleteObserverAdapter(mContext, statusReceiver, versionedPackage.getPackageName(), canSilentlyInstallPackage, userId); - if (mContext.checkCallingOrSelfPermission(Manifest.permission.DELETE_PACKAGES) + final boolean shouldShowConfirmationDialog = + (flags & PackageManager.DELETE_SHOW_DIALOG) != 0; + if (!shouldShowConfirmationDialog + && mContext.checkCallingOrSelfPermission(Manifest.permission.DELETE_PACKAGES) == PackageManager.PERMISSION_GRANTED) { // Sweet, call straight through! mPm.deletePackageVersioned(versionedPackage, adapter.getBinder(), userId, flags); - } else if (canSilentlyInstallPackage) { + } else if (!shouldShowConfirmationDialog && canSilentlyInstallPackage) { // Allow the device owner and affiliated profile owner to silently delete packages // Need to clear the calling identity to get DELETE_PACKAGES permission final long ident = Binder.clearCallingIdentity(); @@ -1419,6 +1423,11 @@ public class PackageInstallerService extends IPackageInstaller.Stub implements intent.setData(Uri.fromParts("package", versionedPackage.getPackageName(), null)); intent.putExtra(PackageInstaller.EXTRA_CALLBACK, new PackageManager.UninstallCompleteCallback(adapter.getBinder().asBinder())); + if ((flags & PackageManager.DELETE_ARCHIVE) != 0) { + // Delete flags are passed to the uninstaller activity so it can be preserved + // in the follow-up uninstall operation after the user confirmation + intent.putExtra(PackageInstaller.EXTRA_DELETE_FLAGS, flags); + } adapter.onUserActionRequired(intent); } } @@ -1631,9 +1640,10 @@ public class PackageInstallerService extends IPackageInstaller.Stub implements @NonNull String packageName, @NonNull String callerPackageName, @NonNull IntentSender intentSender, - @NonNull UserHandle userHandle) { + @NonNull UserHandle userHandle, + @DeleteFlags int flags) { mPackageArchiver.requestArchive(packageName, callerPackageName, intentSender, - userHandle); + userHandle, flags); } @Override diff --git a/services/core/java/com/android/server/pm/PackageManagerShellCommand.java b/services/core/java/com/android/server/pm/PackageManagerShellCommand.java index fc662038d5d5..215e9528a35e 100644 --- a/services/core/java/com/android/server/pm/PackageManagerShellCommand.java +++ b/services/core/java/com/android/server/pm/PackageManagerShellCommand.java @@ -4639,7 +4639,7 @@ class PackageManagerShellCommand extends ShellCommand { try { mInterface.getPackageInstaller().requestArchive(packageName, /* callerPackageName= */ "", receiver.getIntentSender(), - new UserHandle(translatedUserId)); + new UserHandle(translatedUserId), 0); } catch (Exception e) { pw.println("Failure [" + e.getMessage() + "]"); return 1; diff --git a/services/core/java/com/android/server/power/TEST_MAPPING b/services/core/java/com/android/server/power/TEST_MAPPING index 05a0e85d790f..e64704a84cdf 100644 --- a/services/core/java/com/android/server/power/TEST_MAPPING +++ b/services/core/java/com/android/server/power/TEST_MAPPING @@ -45,6 +45,17 @@ {"include-filter": "com.android.server.power"}, {"exclude-annotation": "org.junit.Ignore"} ] + }, + { + "name": "CtsStatsdAtomHostTestCases", + "options": [ + {"exclude-annotation": "androidx.test.filters.FlakyTest"}, + {"exclude-annotation": "org.junit.Ignore"}, + {"include-filter": "android.cts.statsdatom.powermanager"} + ], + "file_patterns": [ + "(/|^)ThermalManagerService.java" + ] } ] } diff --git a/services/core/java/com/android/server/power/ThermalManagerService.java b/services/core/java/com/android/server/power/ThermalManagerService.java index d17207b8f261..99653ae1cd72 100644 --- a/services/core/java/com/android/server/power/ThermalManagerService.java +++ b/services/core/java/com/android/server/power/ThermalManagerService.java @@ -16,8 +16,17 @@ package com.android.server.power; +import static com.android.internal.util.ConcurrentUtils.DIRECT_EXECUTOR; +import static com.android.internal.util.FrameworkStatsLog.THERMAL_HEADROOM_CALLED__API_STATUS__NO_TEMPERATURE_THRESHOLD; +import static com.android.internal.util.FrameworkStatsLog.THERMAL_HEADROOM_THRESHOLDS_CALLED__API_STATUS__FEATURE_NOT_SUPPORTED; +import static com.android.internal.util.FrameworkStatsLog.THERMAL_HEADROOM_THRESHOLDS_CALLED__API_STATUS__HAL_NOT_READY; +import static com.android.internal.util.FrameworkStatsLog.THERMAL_HEADROOM_THRESHOLDS_CALLED__API_STATUS__SUCCESS; +import static com.android.internal.util.FrameworkStatsLog.THERMAL_STATUS_CALLED__API_STATUS__HAL_NOT_READY; +import static com.android.internal.util.FrameworkStatsLog.THERMAL_STATUS_CALLED__API_STATUS__SUCCESS; + import android.annotation.NonNull; import android.annotation.Nullable; +import android.app.StatsManager; import android.content.Context; import android.hardware.thermal.IThermal; import android.hardware.thermal.IThermalChangedCallback; @@ -48,11 +57,13 @@ import android.os.Temperature; import android.util.ArrayMap; import android.util.EventLog; import android.util.Slog; +import android.util.StatsEvent; import com.android.internal.annotations.GuardedBy; import com.android.internal.annotations.VisibleForTesting; import com.android.internal.os.BackgroundThread; import com.android.internal.util.DumpUtils; +import com.android.internal.util.FrameworkStatsLog; import com.android.server.EventLogTags; import com.android.server.FgThread; import com.android.server.SystemService; @@ -122,6 +133,8 @@ public class ThermalManagerService extends SystemService { @VisibleForTesting final TemperatureWatcher mTemperatureWatcher = new TemperatureWatcher(); + private final Context mContext; + public ThermalManagerService(Context context) { this(context, null); } @@ -129,6 +142,7 @@ public class ThermalManagerService extends SystemService { @VisibleForTesting ThermalManagerService(Context context, @Nullable ThermalHalWrapper halWrapper) { super(context); + mContext = context; mHalWrapper = halWrapper; if (halWrapper != null) { halWrapper.setCallback(this::onTemperatureChangedCallback); @@ -146,6 +160,9 @@ public class ThermalManagerService extends SystemService { if (phase == SystemService.PHASE_ACTIVITY_MANAGER_READY) { onActivityManagerReady(); } + if (phase == SystemService.PHASE_BOOT_COMPLETED) { + registerStatsCallbacks(); + } } private void onActivityManagerReady() { @@ -326,6 +343,31 @@ public class ThermalManagerService extends SystemService { } } + private void registerStatsCallbacks() { + final StatsManager statsManager = mContext.getSystemService(StatsManager.class); + if (statsManager != null) { + statsManager.setPullAtomCallback( + FrameworkStatsLog.THERMAL_HEADROOM_THRESHOLDS, + null, // use default PullAtomMetadata values + DIRECT_EXECUTOR, + this::onPullAtom); + } + } + + private int onPullAtom(int atomTag, @NonNull List<StatsEvent> data) { + if (atomTag == FrameworkStatsLog.THERMAL_HEADROOM_THRESHOLDS) { + final float[] thresholds; + synchronized (mTemperatureWatcher.mSamples) { + thresholds = Arrays.copyOf(mTemperatureWatcher.mHeadroomThresholds, + mTemperatureWatcher.mHeadroomThresholds.length); + } + data.add( + FrameworkStatsLog.buildStatsEvent(FrameworkStatsLog.THERMAL_HEADROOM_THRESHOLDS, + thresholds)); + } + return android.app.StatsManager.PULL_SUCCESS; + } + @VisibleForTesting final IThermalService.Stub mService = new IThermalService.Stub() { @Override @@ -449,6 +491,12 @@ public class ThermalManagerService extends SystemService { synchronized (mLock) { final long token = Binder.clearCallingIdentity(); try { + FrameworkStatsLog.write(FrameworkStatsLog.THERMAL_STATUS_CALLED, + Binder.getCallingUid(), + mHalReady.get() + ? THERMAL_STATUS_CALLED__API_STATUS__SUCCESS + : THERMAL_STATUS_CALLED__API_STATUS__HAL_NOT_READY, + thermalSeverityToStatsdStatus(mStatus)); return mStatus; } finally { Binder.restoreCallingIdentity(token); @@ -493,6 +541,9 @@ public class ThermalManagerService extends SystemService { @Override public float getThermalHeadroom(int forecastSeconds) { if (!mHalReady.get()) { + FrameworkStatsLog.write(FrameworkStatsLog.THERMAL_HEADROOM_CALLED, getCallingUid(), + FrameworkStatsLog.THERMAL_HEADROOM_CALLED__API_STATUS__HAL_NOT_READY, + Float.NaN); return Float.NaN; } @@ -500,6 +551,9 @@ public class ThermalManagerService extends SystemService { if (DEBUG) { Slog.d(TAG, "Invalid forecastSeconds: " + forecastSeconds); } + FrameworkStatsLog.write(FrameworkStatsLog.THERMAL_HEADROOM_CALLED, getCallingUid(), + FrameworkStatsLog.THERMAL_HEADROOM_CALLED__API_STATUS__INVALID_ARGUMENT, + Float.NaN); return Float.NaN; } @@ -509,12 +563,21 @@ public class ThermalManagerService extends SystemService { @Override public float[] getThermalHeadroomThresholds() { if (!mHalReady.get()) { + FrameworkStatsLog.write(FrameworkStatsLog.THERMAL_HEADROOM_THRESHOLDS_CALLED, + Binder.getCallingUid(), + THERMAL_HEADROOM_THRESHOLDS_CALLED__API_STATUS__HAL_NOT_READY); throw new IllegalStateException("Thermal HAL connection is not initialized"); } if (!Flags.allowThermalHeadroomThresholds()) { + FrameworkStatsLog.write(FrameworkStatsLog.THERMAL_HEADROOM_THRESHOLDS_CALLED, + Binder.getCallingUid(), + THERMAL_HEADROOM_THRESHOLDS_CALLED__API_STATUS__FEATURE_NOT_SUPPORTED); throw new UnsupportedOperationException("Thermal headroom thresholds not enabled"); } synchronized (mTemperatureWatcher.mSamples) { + FrameworkStatsLog.write(FrameworkStatsLog.THERMAL_HEADROOM_THRESHOLDS_CALLED, + Binder.getCallingUid(), + THERMAL_HEADROOM_THRESHOLDS_CALLED__API_STATUS__SUCCESS); return Arrays.copyOf(mTemperatureWatcher.mHeadroomThresholds, mTemperatureWatcher.mHeadroomThresholds.length); } @@ -544,6 +607,27 @@ public class ThermalManagerService extends SystemService { }; + private static int thermalSeverityToStatsdStatus(int severity) { + switch (severity) { + case PowerManager.THERMAL_STATUS_NONE: + return FrameworkStatsLog.THERMAL_STATUS_CALLED__STATUS__NONE; + case PowerManager.THERMAL_STATUS_LIGHT: + return FrameworkStatsLog.THERMAL_STATUS_CALLED__STATUS__LIGHT; + case PowerManager.THERMAL_STATUS_MODERATE: + return FrameworkStatsLog.THERMAL_STATUS_CALLED__STATUS__MODERATE; + case PowerManager.THERMAL_STATUS_SEVERE: + return FrameworkStatsLog.THERMAL_STATUS_CALLED__STATUS__SEVERE; + case PowerManager.THERMAL_STATUS_CRITICAL: + return FrameworkStatsLog.THERMAL_STATUS_CALLED__STATUS__CRITICAL; + case PowerManager.THERMAL_STATUS_EMERGENCY: + return FrameworkStatsLog.THERMAL_STATUS_CALLED__STATUS__EMERGENCY; + case PowerManager.THERMAL_STATUS_SHUTDOWN: + return FrameworkStatsLog.THERMAL_STATUS_CALLED__STATUS__SHUTDOWN; + default: + return FrameworkStatsLog.THERMAL_STATUS_CALLED__STATUS__NONE; + } + } + private static void dumpItemsLocked(PrintWriter pw, String prefix, Collection<?> items) { for (Iterator iterator = items.iterator(); iterator.hasNext();) { @@ -1492,13 +1576,15 @@ public class ThermalManagerService extends SystemService { threshold.hotThrottlingThresholds[ThrottlingSeverity.SEVERE]; if (!Float.isNaN(severeThreshold)) { mSevereThresholds.put(threshold.name, severeThreshold); - for (int severity = ThrottlingSeverity.LIGHT; - severity <= ThrottlingSeverity.SHUTDOWN; severity++) { - if (Flags.allowThermalHeadroomThresholds() - && threshold.hotThrottlingThresholds.length > severity) { - updateHeadroomThreshold(severity, - threshold.hotThrottlingThresholds[severity], - severeThreshold); + if (Flags.allowThermalHeadroomThresholds()) { + for (int severity = ThrottlingSeverity.LIGHT; + severity <= ThrottlingSeverity.SHUTDOWN; severity++) { + if (severity != ThrottlingSeverity.SEVERE + && threshold.hotThrottlingThresholds.length > severity) { + updateHeadroomThreshold(severity, + threshold.hotThrottlingThresholds[severity], + severeThreshold); + } } } } @@ -1506,11 +1592,15 @@ public class ThermalManagerService extends SystemService { } } - // For a older device with multiple SKIN sensors, we will set a severity's headroom + // For an older device with multiple SKIN sensors, we will set a severity's headroom // threshold based on the minimum value of all as a workaround. void updateHeadroomThreshold(int severity, float threshold, float severeThreshold) { if (!Float.isNaN(threshold)) { synchronized (mSamples) { + if (severity == ThrottlingSeverity.SEVERE) { + mHeadroomThresholds[severity] = 1.0f; + return; + } float headroom = normalizeTemperature(threshold, severeThreshold); if (Float.isNaN(mHeadroomThresholds[severity])) { mHeadroomThresholds[severity] = headroom; @@ -1620,6 +1710,10 @@ public class ThermalManagerService extends SystemService { // to sample, return early if (mSamples.isEmpty()) { Slog.e(TAG, "No temperature samples found"); + FrameworkStatsLog.write(FrameworkStatsLog.THERMAL_HEADROOM_CALLED, + Binder.getCallingUid(), + FrameworkStatsLog.THERMAL_HEADROOM_CALLED__API_STATUS__NO_TEMPERATURE, + Float.NaN); return Float.NaN; } @@ -1627,16 +1721,22 @@ public class ThermalManagerService extends SystemService { // so return early if (mSevereThresholds.isEmpty()) { Slog.e(TAG, "No temperature thresholds found"); + FrameworkStatsLog.write(FrameworkStatsLog.THERMAL_HEADROOM_CALLED, + Binder.getCallingUid(), + THERMAL_HEADROOM_CALLED__API_STATUS__NO_TEMPERATURE_THRESHOLD, + Float.NaN); return Float.NaN; } float maxNormalized = Float.NaN; + int noThresholdSampleCount = 0; for (Map.Entry<String, ArrayList<Sample>> entry : mSamples.entrySet()) { String name = entry.getKey(); ArrayList<Sample> samples = entry.getValue(); Float threshold = mSevereThresholds.get(name); if (threshold == null) { + noThresholdSampleCount++; Slog.e(TAG, "No threshold found for " + name); continue; } @@ -1659,7 +1759,17 @@ public class ThermalManagerService extends SystemService { maxNormalized = normalized; } } - + if (noThresholdSampleCount == mSamples.size()) { + FrameworkStatsLog.write(FrameworkStatsLog.THERMAL_HEADROOM_CALLED, + Binder.getCallingUid(), + THERMAL_HEADROOM_CALLED__API_STATUS__NO_TEMPERATURE_THRESHOLD, + Float.NaN); + } else { + FrameworkStatsLog.write(FrameworkStatsLog.THERMAL_HEADROOM_CALLED, + Binder.getCallingUid(), + FrameworkStatsLog.THERMAL_HEADROOM_CALLED__API_STATUS__SUCCESS, + maxNormalized); + } return maxNormalized; } } diff --git a/services/core/java/com/android/server/power/stats/BatteryStatsImpl.java b/services/core/java/com/android/server/power/stats/BatteryStatsImpl.java index b8d26d9cac42..698f6ea4b443 100644 --- a/services/core/java/com/android/server/power/stats/BatteryStatsImpl.java +++ b/services/core/java/com/android/server/power/stats/BatteryStatsImpl.java @@ -49,6 +49,7 @@ import android.os.BatteryUsageStatsQuery; import android.os.Binder; import android.os.BluetoothBatteryStats; import android.os.Build; +import android.os.ConditionVariable; import android.os.Handler; import android.os.IBatteryPropertiesRegistrar; import android.os.Looper; @@ -137,7 +138,6 @@ import com.android.internal.util.XmlUtils; import com.android.modules.utils.TypedXmlPullParser; import com.android.modules.utils.TypedXmlSerializer; import com.android.net.module.util.NetworkCapabilitiesUtils; -import com.android.server.power.optimization.Flags; import com.android.server.power.stats.SystemServerCpuThreadReader.SystemServiceCpuThreadTimes; import libcore.util.EmptyArray; @@ -10543,7 +10543,7 @@ public class BatteryStatsImpl extends BatteryStats { final int batteryConsumerProcessState = mapUidProcessStateToBatteryConsumerProcessState(uidRunningState); - if (mBsi.mSystemReady && Flags.streamlinedBatteryStats()) { + if (mBsi.mSystemReady && mBsi.mPowerStatsCollectorEnabled) { mBsi.mHistory.recordProcessStateChange(elapsedRealtimeMs, uptimeMs, mUid, batteryConsumerProcessState); } @@ -11712,6 +11712,10 @@ public class BatteryStatsImpl extends BatteryStats { // Store the empty state to disk to ensure consistency writeSyncLocked(); + if (mPowerStatsCollectorEnabled) { + schedulePowerStatsSampleCollection(); + } + // Flush external data, gathering snapshots, but don't process it since it is pre-reset data mIgnoreNextExternalStats = true; mExternalSync.scheduleSync("reset", ExternalStatsSync.UPDATE_ON_RESET); @@ -15762,6 +15766,16 @@ public class BatteryStatsImpl extends BatteryStats { } /** + * Schedules an immediate collection of PowerStats samples and awaits the result. + */ + public void collectPowerStatsSamples() { + schedulePowerStatsSampleCollection(); + ConditionVariable done = new ConditionVariable(); + mHandler.post(done::open); + done.block(); + } + + /** * Grabs one sample of PowerStats and prints it. */ public void dumpStatsSample(PrintWriter pw) { diff --git a/services/core/java/com/android/server/power/stats/BatteryUsageStatsProvider.java b/services/core/java/com/android/server/power/stats/BatteryUsageStatsProvider.java index 391dd77e3506..096c5e6697b7 100644 --- a/services/core/java/com/android/server/power/stats/BatteryUsageStatsProvider.java +++ b/services/core/java/com/android/server/power/stats/BatteryUsageStatsProvider.java @@ -126,6 +126,10 @@ public class BatteryUsageStatsProvider { */ public List<BatteryUsageStats> getBatteryUsageStats(BatteryStatsImpl stats, List<BatteryUsageStatsQuery> queries) { + if (mPowerStatsExporterEnabled) { + stats.collectPowerStatsSamples(); + } + ArrayList<BatteryUsageStats> results = new ArrayList<>(queries.size()); synchronized (stats) { stats.prepareForDumpLocked(); @@ -168,15 +172,16 @@ public class BatteryUsageStatsProvider { & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_VIRTUAL_UIDS) != 0); final double minConsumedPowerThreshold = query.getMinConsumedPowerThreshold(); - final BatteryUsageStats.Builder batteryUsageStatsBuilder = new BatteryUsageStats.Builder( - stats.getCustomEnergyConsumerNames(), includePowerModels, - includeProcessStateData, minConsumedPowerThreshold); - // TODO(b/188068523): use a monotonic clock to ensure resilience of order and duration - // of batteryUsageStats sessions to wall-clock adjustments - batteryUsageStatsBuilder.setStatsStartTimestamp(stats.getStartClockTime()); - batteryUsageStatsBuilder.setStatsEndTimestamp(currentTimeMs); - + final BatteryUsageStats.Builder batteryUsageStatsBuilder; synchronized (stats) { + batteryUsageStatsBuilder = new BatteryUsageStats.Builder( + stats.getCustomEnergyConsumerNames(), includePowerModels, + includeProcessStateData, minConsumedPowerThreshold); + + // TODO(b/188068523): use a monotonic clock to ensure resilience of order and duration + // of batteryUsageStats sessions to wall-clock adjustments + batteryUsageStatsBuilder.setStatsStartTimestamp(stats.getStartClockTime()); + batteryUsageStatsBuilder.setStatsEndTimestamp(currentTimeMs); SparseArray<? extends BatteryStats.Uid> uidStats = stats.getUidStats(); for (int i = uidStats.size() - 1; i >= 0; i--) { final BatteryStats.Uid uid = uidStats.valueAt(i); diff --git a/services/core/java/com/android/server/power/stats/PowerStatsExporter.java b/services/core/java/com/android/server/power/stats/PowerStatsExporter.java index 70c24d58bb2a..1f6f11320f1b 100644 --- a/services/core/java/com/android/server/power/stats/PowerStatsExporter.java +++ b/services/core/java/com/android/server/power/stats/PowerStatsExporter.java @@ -60,6 +60,7 @@ public class PowerStatsExporter { */ public void exportAggregatedPowerStats(BatteryUsageStats.Builder batteryUsageStatsBuilder, long monotonicStartTime, long monotonicEndTime) { + boolean hasStoredSpans = false; long maxEndTime = monotonicStartTime; List<PowerStatsSpan.Metadata> spans = mPowerStatsStore.getTableOfContents(); for (int i = spans.size() - 1; i >= 0; i--) { @@ -99,13 +100,14 @@ public class PowerStatsExporter { } List<PowerStatsSpan.Section> sections = span.getSections(); for (int k = 0; k < sections.size(); k++) { + hasStoredSpans = true; PowerStatsSpan.Section section = sections.get(k); populateBatteryUsageStatsBuilder(batteryUsageStatsBuilder, ((AggregatedPowerStatsSection) section).getAggregatedPowerStats()); } } - if (maxEndTime < monotonicEndTime - mBatterySessionTimeSpanSlackMillis) { + if (!hasStoredSpans || maxEndTime < monotonicEndTime - mBatterySessionTimeSpanSlackMillis) { mPowerStatsAggregator.aggregatePowerStats(maxEndTime, monotonicEndTime, stats -> populateBatteryUsageStatsBuilder(batteryUsageStatsBuilder, stats)); } diff --git a/services/core/java/com/android/server/power/stats/PowerStatsStore.java b/services/core/java/com/android/server/power/stats/PowerStatsStore.java index 7123bcb2d095..7bcdc7129d10 100644 --- a/services/core/java/com/android/server/power/stats/PowerStatsStore.java +++ b/services/core/java/com/android/server/power/stats/PowerStatsStore.java @@ -171,7 +171,7 @@ public class PowerStatsStore { try (InputStream inputStream = new BufferedInputStream(new FileInputStream(file))) { return PowerStatsSpan.read(inputStream, parser, mSectionReader, sectionTypes); } catch (IOException | XmlPullParserException e) { - Slog.wtf(TAG, "Cannot read PowerStatsSpan file: " + file); + Slog.wtf(TAG, "Cannot read PowerStatsSpan file: " + file, e); } } finally { unlockStoreDirectory(); diff --git a/services/core/java/com/android/server/wm/ActivityRecord.java b/services/core/java/com/android/server/wm/ActivityRecord.java index 6e9219a75324..0d06f5b256b0 100644 --- a/services/core/java/com/android/server/wm/ActivityRecord.java +++ b/services/core/java/com/android/server/wm/ActivityRecord.java @@ -3390,7 +3390,8 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A if (currentFocusedApp != null && currentFocusedApp.task == task && topFocusedDisplayId == mDisplayContent.getDisplayId()) { final Task topFocusableTask = mDisplayContent.getTask( - (t) -> t.isLeafTask() && t.isFocusable(), true /* traverseTopToBottom */); + (t) -> t.isLeafTask() && t.isFocusable() && !t.inPinnedWindowingMode(), + true /* traverseTopToBottom */); if (task == topFocusableTask) { if (currentFocusedApp == this) { ProtoLog.d(WM_DEBUG_FOCUS, "moveFocusableActivityToTop: already on top " diff --git a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java index 6f5c676187e1..b8b102faa7d4 100644 --- a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java +++ b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java @@ -5280,6 +5280,9 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { /** Applies latest configuration and/or visibility updates if needed. */ boolean ensureConfigAndVisibilityAfterUpdate(ActivityRecord starting, int changes) { + if (starting == null && mTaskSupervisor.isRootVisibilityUpdateDeferred()) { + return true; + } boolean kept = true; final Task mainRootTask = mRootWindowContainer.getTopDisplayFocusedRootTask(); // mainRootTask is null during startup. diff --git a/services/core/java/com/android/server/wm/Transition.java b/services/core/java/com/android/server/wm/Transition.java index e5604eca3df0..424394872821 100644 --- a/services/core/java/com/android/server/wm/Transition.java +++ b/services/core/java/com/android/server/wm/Transition.java @@ -2857,12 +2857,18 @@ class Transition implements BLASTSyncEngine.TransactionReadyListener { return false; } - /** Applies the new configuration for the changed displays. */ - void applyDisplayChangeIfNeeded() { + /** + * Applies the new configuration for the changed displays. Returns the activities that should + * check whether to deliver the new configuration to clients. + */ + @Nullable + ArrayList<ActivityRecord> applyDisplayChangeIfNeeded() { + ArrayList<ActivityRecord> activitiesMayChange = null; for (int i = mParticipants.size() - 1; i >= 0; --i) { final WindowContainer<?> wc = mParticipants.valueAt(i); final DisplayContent dc = wc.asDisplayContent(); if (dc == null || !mChanges.get(dc).hasChanged()) continue; + final int originalSeq = dc.getConfiguration().seq; dc.sendNewConfiguration(); // Set to ready if no other change controls the ready state. But if there is, such as // if an activity is pausing, it will call setReady(ar, false) and wait for the next @@ -2871,7 +2877,22 @@ class Transition implements BLASTSyncEngine.TransactionReadyListener { if (!mReadyTrackerOld.mUsed) { setReady(dc, true); } + if (originalSeq == dc.getConfiguration().seq) continue; + // If the update is deferred, sendNewConfiguration won't deliver new configuration to + // clients, then it is the caller's responsibility to deliver the changes. + if (mController.mAtm.mTaskSupervisor.isRootVisibilityUpdateDeferred()) { + if (activitiesMayChange == null) { + activitiesMayChange = new ArrayList<>(); + } + final ArrayList<ActivityRecord> visibleActivities = activitiesMayChange; + dc.forAllActivities(r -> { + if (r.isVisibleRequested()) { + visibleActivities.add(r); + } + }); + } } + return activitiesMayChange; } boolean getLegacyIsReady() { diff --git a/services/core/java/com/android/server/wm/TrustedPresentationListenerController.java b/services/core/java/com/android/server/wm/TrustedPresentationListenerController.java new file mode 100644 index 000000000000..e82dc37c2b6a --- /dev/null +++ b/services/core/java/com/android/server/wm/TrustedPresentationListenerController.java @@ -0,0 +1,448 @@ +/* + * Copyright 2023 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.wm; + +import static android.graphics.Matrix.MSCALE_X; +import static android.graphics.Matrix.MSCALE_Y; +import static android.graphics.Matrix.MSKEW_X; +import static android.graphics.Matrix.MSKEW_Y; + +import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_TPL; + +import android.graphics.Matrix; +import android.graphics.Rect; +import android.graphics.RectF; +import android.graphics.Region; +import android.os.Handler; +import android.os.HandlerThread; +import android.os.IBinder; +import android.os.RemoteException; +import android.util.ArrayMap; +import android.util.ArraySet; +import android.util.IntArray; +import android.util.Pair; +import android.util.Size; +import android.view.InputWindowHandle; +import android.window.ITrustedPresentationListener; +import android.window.TrustedPresentationThresholds; +import android.window.WindowInfosListener; + +import com.android.internal.protolog.common.ProtoLog; +import com.android.server.wm.utils.RegionUtils; + +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.Optional; + +/** + * Class to handle TrustedPresentationListener registrations in a thread safe manner. This class + * also takes care of cleaning up listeners when the remote process dies. + */ +public class TrustedPresentationListenerController { + + // Should only be accessed by the posting to the handler + private class Listeners { + private final class ListenerDeathRecipient implements IBinder.DeathRecipient { + IBinder mListenerBinder; + int mInstances; + + ListenerDeathRecipient(IBinder listenerBinder) { + mListenerBinder = listenerBinder; + mInstances = 0; + try { + mListenerBinder.linkToDeath(this, 0); + } catch (RemoteException ignore) { + } + } + + void addInstance() { + mInstances++; + } + + // return true if there are no instances alive + boolean removeInstance() { + mInstances--; + if (mInstances > 0) { + return false; + } + mListenerBinder.unlinkToDeath(this, 0); + return true; + } + + public void binderDied() { + mHandler.post(() -> { + mUniqueListeners.remove(mListenerBinder); + removeListeners(mListenerBinder, Optional.empty()); + }); + } + } + + // tracks binder deaths for cleanup + ArrayMap<IBinder, ListenerDeathRecipient> mUniqueListeners = new ArrayMap<>(); + ArrayMap<IBinder /*window*/, ArrayList<TrustedPresentationInfo>> mWindowToListeners = + new ArrayMap<>(); + + void register(IBinder window, ITrustedPresentationListener listener, + TrustedPresentationThresholds thresholds, int id) { + var listenersForWindow = mWindowToListeners.computeIfAbsent(window, + iBinder -> new ArrayList<>()); + listenersForWindow.add(new TrustedPresentationInfo(thresholds, id, listener)); + + // register death listener + var listenerBinder = listener.asBinder(); + var deathRecipient = mUniqueListeners.computeIfAbsent(listenerBinder, + ListenerDeathRecipient::new); + deathRecipient.addInstance(); + } + + void unregister(ITrustedPresentationListener trustedPresentationListener, int id) { + var listenerBinder = trustedPresentationListener.asBinder(); + var deathRecipient = mUniqueListeners.get(listenerBinder); + if (deathRecipient == null) { + ProtoLog.e(WM_DEBUG_TPL, "unregister failed, couldn't find" + + " deathRecipient for %s with id=%d", trustedPresentationListener, id); + return; + } + + if (deathRecipient.removeInstance()) { + mUniqueListeners.remove(listenerBinder); + } + removeListeners(listenerBinder, Optional.of(id)); + } + + boolean isEmpty() { + return mWindowToListeners.isEmpty(); + } + + ArrayList<TrustedPresentationInfo> get(IBinder windowToken) { + return mWindowToListeners.get(windowToken); + } + + private void removeListeners(IBinder listenerBinder, Optional<Integer> id) { + for (int i = mWindowToListeners.size() - 1; i >= 0; i--) { + var listeners = mWindowToListeners.valueAt(i); + for (int j = listeners.size() - 1; j >= 0; j--) { + var listener = listeners.get(j); + if (listener.mListener.asBinder() == listenerBinder && (id.isEmpty() + || listener.mId == id.get())) { + listeners.remove(j); + } + } + if (listeners.isEmpty()) { + mWindowToListeners.removeAt(i); + } + } + } + } + + private final Object mHandlerThreadLock = new Object(); + private HandlerThread mHandlerThread; + private Handler mHandler; + + private WindowInfosListener mWindowInfosListener; + + Listeners mRegisteredListeners = new Listeners(); + + private InputWindowHandle[] mLastWindowHandles; + + private final Object mIgnoredWindowTokensLock = new Object(); + + private final ArraySet<IBinder> mIgnoredWindowTokens = new ArraySet<>(); + + private void startHandlerThreadIfNeeded() { + synchronized (mHandlerThreadLock) { + if (mHandler == null) { + mHandlerThread = new HandlerThread("WindowInfosListenerForTpl"); + mHandlerThread.start(); + mHandler = new Handler(mHandlerThread.getLooper()); + } + } + } + + void addIgnoredWindowTokens(IBinder token) { + synchronized (mIgnoredWindowTokensLock) { + mIgnoredWindowTokens.add(token); + } + } + + void removeIgnoredWindowTokens(IBinder token) { + synchronized (mIgnoredWindowTokensLock) { + mIgnoredWindowTokens.remove(token); + } + } + + void registerListener(IBinder window, ITrustedPresentationListener listener, + TrustedPresentationThresholds thresholds, int id) { + startHandlerThreadIfNeeded(); + mHandler.post(() -> { + ProtoLog.d(WM_DEBUG_TPL, "Registering listener=%s with id=%d for window=%s with %s", + listener, id, window, thresholds); + + mRegisteredListeners.register(window, listener, thresholds, id); + registerWindowInfosListener(); + // Update the initial state for the new registered listener + computeTpl(mLastWindowHandles); + }); + } + + void unregisterListener(ITrustedPresentationListener listener, int id) { + startHandlerThreadIfNeeded(); + mHandler.post(() -> { + ProtoLog.d(WM_DEBUG_TPL, "Unregistering listener=%s with id=%d", + listener, id); + + mRegisteredListeners.unregister(listener, id); + if (mRegisteredListeners.isEmpty()) { + unregisterWindowInfosListener(); + } + }); + } + + void dump(PrintWriter pw) { + final String innerPrefix = " "; + pw.println("TrustedPresentationListenerController:"); + pw.println(innerPrefix + "Active unique listeners (" + + mRegisteredListeners.mUniqueListeners.size() + "):"); + for (int i = 0; i < mRegisteredListeners.mWindowToListeners.size(); i++) { + pw.println( + innerPrefix + " window=" + mRegisteredListeners.mWindowToListeners.keyAt(i)); + final var listeners = mRegisteredListeners.mWindowToListeners.valueAt(i); + for (int j = 0; j < listeners.size(); j++) { + final var listener = listeners.get(j); + pw.println(innerPrefix + innerPrefix + " listener=" + listener.mListener.asBinder() + + " id=" + listener.mId + + " thresholds=" + listener.mThresholds); + } + } + } + + private void registerWindowInfosListener() { + if (mWindowInfosListener != null) { + return; + } + + mWindowInfosListener = new WindowInfosListener() { + @Override + public void onWindowInfosChanged(InputWindowHandle[] windowHandles, + DisplayInfo[] displayInfos) { + mHandler.post(() -> computeTpl(windowHandles)); + } + }; + mLastWindowHandles = mWindowInfosListener.register().first; + } + + private void unregisterWindowInfosListener() { + if (mWindowInfosListener == null) { + return; + } + + mWindowInfosListener.unregister(); + mWindowInfosListener = null; + mLastWindowHandles = null; + } + + private void computeTpl(InputWindowHandle[] windowHandles) { + mLastWindowHandles = windowHandles; + if (mLastWindowHandles == null || mLastWindowHandles.length == 0 + || mRegisteredListeners.isEmpty()) { + return; + } + + Rect tmpRect = new Rect(); + Matrix tmpInverseMatrix = new Matrix(); + float[] tmpMatrix = new float[9]; + Region coveredRegionsAbove = new Region(); + long currTimeMs = System.currentTimeMillis(); + ProtoLog.v(WM_DEBUG_TPL, "Checking %d windows", mLastWindowHandles.length); + + ArrayMap<ITrustedPresentationListener, Pair<IntArray, IntArray>> listenerUpdates = + new ArrayMap<>(); + ArraySet<IBinder> ignoredWindowTokens; + synchronized (mIgnoredWindowTokensLock) { + ignoredWindowTokens = new ArraySet<>(mIgnoredWindowTokens); + } + for (var windowHandle : mLastWindowHandles) { + if (ignoredWindowTokens.contains(windowHandle.getWindowToken())) { + ProtoLog.v(WM_DEBUG_TPL, "Skipping %s", windowHandle.name); + continue; + } + tmpRect.set(windowHandle.frame); + var listeners = mRegisteredListeners.get(windowHandle.getWindowToken()); + if (listeners != null) { + Region region = new Region(); + region.op(tmpRect, coveredRegionsAbove, Region.Op.DIFFERENCE); + windowHandle.transform.invert(tmpInverseMatrix); + tmpInverseMatrix.getValues(tmpMatrix); + float scaleX = (float) Math.sqrt(tmpMatrix[MSCALE_X] * tmpMatrix[MSCALE_X] + + tmpMatrix[MSKEW_X] * tmpMatrix[MSKEW_X]); + float scaleY = (float) Math.sqrt(tmpMatrix[MSCALE_Y] * tmpMatrix[MSCALE_Y] + + tmpMatrix[MSKEW_Y] * tmpMatrix[MSKEW_Y]); + + float fractionRendered = computeFractionRendered(region, new RectF(tmpRect), + windowHandle.contentSize, + scaleX, scaleY); + + checkIfInThreshold(listeners, listenerUpdates, fractionRendered, windowHandle.alpha, + currTimeMs); + } + + coveredRegionsAbove.op(tmpRect, Region.Op.UNION); + ProtoLog.v(WM_DEBUG_TPL, "coveredRegionsAbove updated with %s frame:%s region:%s", + windowHandle.name, tmpRect.toShortString(), coveredRegionsAbove); + } + + for (int i = 0; i < listenerUpdates.size(); i++) { + var updates = listenerUpdates.valueAt(i); + var listener = listenerUpdates.keyAt(i); + try { + listener.onTrustedPresentationChanged(updates.first.toArray(), + updates.second.toArray()); + } catch (RemoteException ignore) { + } + } + } + + private void addListenerUpdate( + ArrayMap<ITrustedPresentationListener, Pair<IntArray, IntArray>> listenerUpdates, + ITrustedPresentationListener listener, int id, boolean presentationState) { + var updates = listenerUpdates.get(listener); + if (updates == null) { + updates = new Pair<>(new IntArray(), new IntArray()); + listenerUpdates.put(listener, updates); + } + if (presentationState) { + updates.first.add(id); + } else { + updates.second.add(id); + } + } + + + private void checkIfInThreshold( + ArrayList<TrustedPresentationInfo> listeners, + ArrayMap<ITrustedPresentationListener, Pair<IntArray, IntArray>> listenerUpdates, + float fractionRendered, float alpha, long currTimeMs) { + ProtoLog.v(WM_DEBUG_TPL, "checkIfInThreshold fractionRendered=%f alpha=%f currTimeMs=%d", + fractionRendered, alpha, currTimeMs); + for (int i = 0; i < listeners.size(); i++) { + var trustedPresentationInfo = listeners.get(i); + var listener = trustedPresentationInfo.mListener; + boolean lastState = trustedPresentationInfo.mLastComputedTrustedPresentationState; + boolean newState = + (alpha >= trustedPresentationInfo.mThresholds.mMinAlpha) && (fractionRendered + >= trustedPresentationInfo.mThresholds.mMinFractionRendered); + trustedPresentationInfo.mLastComputedTrustedPresentationState = newState; + + ProtoLog.v(WM_DEBUG_TPL, + "lastState=%s newState=%s alpha=%f minAlpha=%f fractionRendered=%f " + + "minFractionRendered=%f", + lastState, newState, alpha, trustedPresentationInfo.mThresholds.mMinAlpha, + fractionRendered, trustedPresentationInfo.mThresholds.mMinFractionRendered); + + if (lastState && !newState) { + // We were in the trusted presentation state, but now we left it, + // emit the callback if needed + if (trustedPresentationInfo.mLastReportedTrustedPresentationState) { + trustedPresentationInfo.mLastReportedTrustedPresentationState = false; + addListenerUpdate(listenerUpdates, listener, + trustedPresentationInfo.mId, /*presentationState*/ false); + ProtoLog.d(WM_DEBUG_TPL, "Adding untrusted state listener=%s with id=%d", + listener, trustedPresentationInfo.mId); + } + // Reset the timer + trustedPresentationInfo.mEnteredTrustedPresentationStateTime = -1; + } else if (!lastState && newState) { + // We were not in the trusted presentation state, but we entered it, begin the timer + // and make sure this gets called at least once more! + trustedPresentationInfo.mEnteredTrustedPresentationStateTime = currTimeMs; + mHandler.postDelayed(() -> { + computeTpl(mLastWindowHandles); + }, (long) (trustedPresentationInfo.mThresholds.mStabilityRequirementMs * 1.5)); + } + + // Has the timer elapsed, but we are still in the state? Emit a callback if needed + if (!trustedPresentationInfo.mLastReportedTrustedPresentationState && newState && ( + currTimeMs - trustedPresentationInfo.mEnteredTrustedPresentationStateTime + > trustedPresentationInfo.mThresholds.mStabilityRequirementMs)) { + trustedPresentationInfo.mLastReportedTrustedPresentationState = true; + addListenerUpdate(listenerUpdates, listener, + trustedPresentationInfo.mId, /*presentationState*/ true); + ProtoLog.d(WM_DEBUG_TPL, "Adding trusted state listener=%s with id=%d", + listener, trustedPresentationInfo.mId); + } + } + } + + private float computeFractionRendered(Region visibleRegion, RectF screenBounds, + Size contentSize, + float sx, float sy) { + ProtoLog.v(WM_DEBUG_TPL, + "computeFractionRendered: visibleRegion=%s screenBounds=%s contentSize=%s " + + "scale=%f,%f", + visibleRegion, screenBounds, contentSize, sx, sy); + + if (contentSize.getWidth() == 0 || contentSize.getHeight() == 0) { + return -1; + } + if (screenBounds.width() == 0 || screenBounds.height() == 0) { + return -1; + } + + float fractionRendered = Math.min(sx * sy, 1.0f); + ProtoLog.v(WM_DEBUG_TPL, "fractionRendered scale=%f", fractionRendered); + + float boundsOverSourceW = screenBounds.width() / (float) contentSize.getWidth(); + float boundsOverSourceH = screenBounds.height() / (float) contentSize.getHeight(); + fractionRendered *= boundsOverSourceW * boundsOverSourceH; + ProtoLog.v(WM_DEBUG_TPL, "fractionRendered boundsOverSource=%f", fractionRendered); + // Compute the size of all the rects since they may be disconnected. + float[] visibleSize = new float[1]; + RegionUtils.forEachRect(visibleRegion, rect -> { + float size = rect.width() * rect.height(); + visibleSize[0] += size; + }); + + fractionRendered *= visibleSize[0] / (screenBounds.width() * screenBounds.height()); + return fractionRendered; + } + + private static class TrustedPresentationInfo { + boolean mLastComputedTrustedPresentationState = false; + boolean mLastReportedTrustedPresentationState = false; + long mEnteredTrustedPresentationStateTime = -1; + final TrustedPresentationThresholds mThresholds; + + final ITrustedPresentationListener mListener; + final int mId; + + private TrustedPresentationInfo(TrustedPresentationThresholds thresholds, int id, + ITrustedPresentationListener listener) { + mThresholds = thresholds; + mId = id; + mListener = listener; + checkValid(thresholds); + } + + private void checkValid(TrustedPresentationThresholds thresholds) { + if (thresholds.mMinAlpha <= 0 || thresholds.mMinFractionRendered <= 0 + || thresholds.mStabilityRequirementMs < 1) { + throw new IllegalArgumentException( + "TrustedPresentationThresholds values are invalid"); + } + } + } +} diff --git a/services/core/java/com/android/server/wm/WindowManagerService.java b/services/core/java/com/android/server/wm/WindowManagerService.java index 0d2c94d103fb..0c57036a3b02 100644 --- a/services/core/java/com/android/server/wm/WindowManagerService.java +++ b/services/core/java/com/android/server/wm/WindowManagerService.java @@ -303,9 +303,11 @@ import android.window.AddToSurfaceSyncGroupResult; import android.window.ClientWindowFrames; import android.window.ISurfaceSyncGroupCompletedListener; import android.window.ITaskFpsCallback; +import android.window.ITrustedPresentationListener; import android.window.ScreenCapture; import android.window.SystemPerformanceHinter; import android.window.TaskSnapshot; +import android.window.TrustedPresentationThresholds; import android.window.WindowContainerToken; import android.window.WindowContextInfo; @@ -764,6 +766,9 @@ public class WindowManagerService extends IWindowManager.Stub private final SurfaceSyncGroupController mSurfaceSyncGroupController = new SurfaceSyncGroupController(); + final TrustedPresentationListenerController mTrustedPresentationListenerController = + new TrustedPresentationListenerController(); + @VisibleForTesting final class SettingsObserver extends ContentObserver { private final Uri mDisplayInversionEnabledUri = @@ -7171,6 +7176,7 @@ public class WindowManagerService extends IWindowManager.Stub pw.println(separator); } mSystemPerformanceHinter.dump(pw, ""); + mTrustedPresentationListenerController.dump(pw); } } @@ -9771,4 +9777,17 @@ public class WindowManagerService extends IWindowManager.Stub Binder.restoreCallingIdentity(origId); } } + + @Override + public void registerTrustedPresentationListener(IBinder window, + ITrustedPresentationListener listener, + TrustedPresentationThresholds thresholds, int id) { + mTrustedPresentationListenerController.registerListener(window, listener, thresholds, id); + } + + @Override + public void unregisterTrustedPresentationListener(ITrustedPresentationListener listener, + int id) { + mTrustedPresentationListenerController.unregisterListener(listener, id); + } } diff --git a/services/core/java/com/android/server/wm/WindowOrganizerController.java b/services/core/java/com/android/server/wm/WindowOrganizerController.java index 2af656942a2a..a872fd0baaae 100644 --- a/services/core/java/com/android/server/wm/WindowOrganizerController.java +++ b/services/core/java/com/android/server/wm/WindowOrganizerController.java @@ -570,8 +570,10 @@ class WindowOrganizerController extends IWindowOrganizerController.Stub mService.deferWindowLayout(); mService.mTaskSupervisor.setDeferRootVisibilityUpdate(true /* deferUpdate */); try { - if (transition != null) { - transition.applyDisplayChangeIfNeeded(); + final ArrayList<ActivityRecord> activitiesMayChange = + transition != null ? transition.applyDisplayChangeIfNeeded() : null; + if (activitiesMayChange != null) { + effects |= TRANSACT_EFFECTS_CLIENT_CONFIG; } final List<WindowContainerTransaction.HierarchyOp> hops = t.getHierarchyOps(); final int hopSize = hops.size(); @@ -695,8 +697,23 @@ class WindowOrganizerController extends IWindowOrganizerController.Stub for (int i = haveConfigChanges.size() - 1; i >= 0; --i) { haveConfigChanges.valueAt(i).forAllActivities(r -> { r.ensureActivityConfiguration(0, PRESERVE_WINDOWS); + if (activitiesMayChange != null) { + activitiesMayChange.remove(r); + } }); } + // TODO(b/258618073): Combine with haveConfigChanges after confirming that there + // is no problem to always preserve window. Currently this uses the parameters + // as ATMS#ensureConfigAndVisibilityAfterUpdate. + if (activitiesMayChange != null) { + for (int i = activitiesMayChange.size() - 1; i >= 0; --i) { + final ActivityRecord ar = activitiesMayChange.get(i); + if (!ar.isVisibleRequested()) continue; + ar.ensureActivityConfiguration(0 /* globalChanges */, + !PRESERVE_WINDOWS, true /* ignoreVisibility */, + false /* isRequestedOrientationChanged */); + } + } } if (effects != 0) { diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java index e1f1f662c5aa..7bc7e2cb780b 100644 --- a/services/core/java/com/android/server/wm/WindowState.java +++ b/services/core/java/com/android/server/wm/WindowState.java @@ -1189,6 +1189,11 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP ProtoLog.v(WM_DEBUG_ADD_REMOVE, "Adding %s to %s", this, parentWindow); parentWindow.addChild(this, sWindowSubLayerComparator); } + + if (token.mRoundedCornerOverlay) { + mWmService.mTrustedPresentationListenerController.addIgnoredWindowTokens( + getWindowToken()); + } } @Override @@ -2393,6 +2398,9 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP } mWmService.postWindowRemoveCleanupLocked(this); + + mWmService.mTrustedPresentationListenerController.removeIgnoredWindowTokens( + getWindowToken()); } @Override diff --git a/services/java/com/android/server/SystemServer.java b/services/java/com/android/server/SystemServer.java index 0047d06ae09c..59e95e7571d0 100644 --- a/services/java/com/android/server/SystemServer.java +++ b/services/java/com/android/server/SystemServer.java @@ -1491,8 +1491,6 @@ public final class SystemServer implements Dumpable { boolean disableCameraService = SystemProperties.getBoolean("config.disable_cameraservice", false); - boolean isEmulator = SystemProperties.get("ro.boot.qemu").equals("1"); - boolean isWatch = context.getPackageManager().hasSystemFeature( PackageManager.FEATURE_WATCH); @@ -2326,7 +2324,7 @@ public final class SystemServer implements Dumpable { if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST) || mPackageManager.hasSystemFeature( PackageManager.FEATURE_USB_ACCESSORY) - || isEmulator) { + || Build.IS_EMULATOR) { // Manage USB host and device support t.traceBegin("StartUsbService"); mSystemServiceManager.startService(USB_SERVICE_CLASS); diff --git a/services/tests/displayservicetests/src/com/android/server/display/DisplayPowerController2Test.java b/services/tests/displayservicetests/src/com/android/server/display/DisplayPowerController2Test.java index 693cafefa2c0..acd9dceb16d5 100644 --- a/services/tests/displayservicetests/src/com/android/server/display/DisplayPowerController2Test.java +++ b/services/tests/displayservicetests/src/com/android/server/display/DisplayPowerController2Test.java @@ -727,6 +727,7 @@ public final class DisplayPowerController2Test { } @Test + @RequiresFlagsEnabled(Flags.FLAG_FAST_HDR_TRANSITIONS) public void testDisplayBrightnessHdr_SkipAnimationOnHdrAppearance() { Settings.System.putInt(mContext.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS_MODE, @@ -762,6 +763,7 @@ public final class DisplayPowerController2Test { } @Test + @RequiresFlagsEnabled(Flags.FLAG_FAST_HDR_TRANSITIONS) public void testDisplayBrightnessHdr_SkipAnimationOnHdrRemoval() { Settings.System.putInt(mContext.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS_MODE, diff --git a/services/tests/displayservicetests/src/com/android/server/display/DisplayPowerControllerTest.java b/services/tests/displayservicetests/src/com/android/server/display/DisplayPowerControllerTest.java index b22799377872..50b0e167ef99 100644 --- a/services/tests/displayservicetests/src/com/android/server/display/DisplayPowerControllerTest.java +++ b/services/tests/displayservicetests/src/com/android/server/display/DisplayPowerControllerTest.java @@ -1202,6 +1202,7 @@ public final class DisplayPowerControllerTest { } @Test + @RequiresFlagsEnabled(Flags.FLAG_FAST_HDR_TRANSITIONS) public void testDisplayBrightnessHdr_SkipAnimationOnHdrAppearance() { Settings.System.putInt(mContext.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS_MODE, @@ -1236,6 +1237,7 @@ public final class DisplayPowerControllerTest { } @Test + @RequiresFlagsEnabled(Flags.FLAG_FAST_HDR_TRANSITIONS) public void testDisplayBrightnessHdr_SkipAnimationOnHdrRemoval() { Settings.System.putInt(mContext.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS_MODE, diff --git a/services/tests/mockingservicestests/src/com/android/server/am/BaseBroadcastQueueTest.java b/services/tests/mockingservicestests/src/com/android/server/am/BaseBroadcastQueueTest.java index 72dc7259dc1f..4ba9d60a5abf 100644 --- a/services/tests/mockingservicestests/src/com/android/server/am/BaseBroadcastQueueTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/am/BaseBroadcastQueueTest.java @@ -17,7 +17,6 @@ package com.android.server.am; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyBoolean; import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.anyLong; import static org.mockito.ArgumentMatchers.eq; @@ -44,6 +43,9 @@ import android.util.SparseArray; import androidx.test.platform.app.InstrumentationRegistry; +import com.android.dx.mockito.inline.extended.ExtendedMockito; +import com.android.internal.util.FrameworkStatsLog; +import com.android.modules.utils.testing.ExtendedMockitoRule; import com.android.server.AlarmManagerInternal; import com.android.server.DropBoxManagerInternal; import com.android.server.LocalServices; @@ -85,6 +87,12 @@ public abstract class BaseBroadcastQueueTest { public final ApplicationExitInfoTest.ServiceThreadRule mServiceThreadRule = new ApplicationExitInfoTest.ServiceThreadRule(); + @Rule + public final ExtendedMockitoRule mExtendedMockitoRule = new ExtendedMockitoRule.Builder(this) + .spyStatic(FrameworkStatsLog.class) + .spyStatic(ProcessList.class) + .build(); + @Mock AppOpsService mAppOpsService; @Mock @@ -140,6 +148,7 @@ public abstract class BaseBroadcastQueueTest { realAms.mActivityTaskManager.initialize(null, null, mContext.getMainLooper()); realAms.mAtmInternal = spy(realAms.mActivityTaskManager.getAtmInternal()); realAms.mOomAdjuster = spy(realAms.mOomAdjuster); + ExtendedMockito.doNothing().when(() -> ProcessList.setOomAdj(anyInt(), anyInt(), anyInt())); realAms.mPackageManagerInt = mPackageManagerInt; realAms.mUsageStatsService = mUsageStatsManagerInt; realAms.mProcessesReady = true; diff --git a/services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueModernImplTest.java b/services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueModernImplTest.java index 2378416f8bd0..c03799d8b41f 100644 --- a/services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueModernImplTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueModernImplTest.java @@ -79,11 +79,9 @@ import androidx.test.filters.SmallTest; import androidx.test.platform.app.InstrumentationRegistry; import com.android.internal.util.FrameworkStatsLog; -import com.android.modules.utils.testing.ExtendedMockitoRule; import org.junit.After; import org.junit.Before; -import org.junit.Rule; import org.junit.Test; import org.mockito.Mock; @@ -112,11 +110,6 @@ public final class BroadcastQueueModernImplTest extends BaseBroadcastQueueTest { BroadcastProcessQueue mHead; - @Rule - public final ExtendedMockitoRule mExtendedMockitoRule = new ExtendedMockitoRule.Builder(this) - .spyStatic(FrameworkStatsLog.class) - .build(); - @Before public void setUp() throws Exception { super.setUp(); diff --git a/services/tests/mockingservicestests/src/com/android/server/job/controllers/FlexibilityControllerTest.java b/services/tests/mockingservicestests/src/com/android/server/job/controllers/FlexibilityControllerTest.java index debc69604690..4fb9472021c5 100644 --- a/services/tests/mockingservicestests/src/com/android/server/job/controllers/FlexibilityControllerTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/job/controllers/FlexibilityControllerTest.java @@ -70,6 +70,8 @@ import com.android.server.LocalServices; import com.android.server.job.JobSchedulerService; import com.android.server.job.JobStore; +import libcore.junit.util.compat.CoreCompatChangeRule; + import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -269,19 +271,19 @@ public class FlexibilityControllerTest { @Test public void testOnConstantsUpdated_PercentsToDropConstraintsInvalidValues() { - JobInfo.Builder jb = createJob(0).setOverrideDeadline(100L); + JobInfo.Builder jb = createJob(0).setOverrideDeadline(HOUR_IN_MILLIS); JobStatus js = createJobStatus("testPercentsToDropConstraintsConfig", jb); - js.enqueueTime = 100L; - assertEquals(150L, + js.enqueueTime = JobSchedulerService.sElapsedRealtimeClock.millis(); + assertEquals(js.enqueueTime + HOUR_IN_MILLIS / 2, mFlexibilityController.getNextConstraintDropTimeElapsedLocked(js)); setDeviceConfigString(KEY_PERCENTS_TO_DROP_NUM_FLEXIBLE_CONSTRAINTS, "10,20a,030,40"); - assertEquals(150L, + assertEquals(js.enqueueTime + HOUR_IN_MILLIS / 2, mFlexibilityController.getNextConstraintDropTimeElapsedLocked(js)); setDeviceConfigString(KEY_PERCENTS_TO_DROP_NUM_FLEXIBLE_CONSTRAINTS, "10,40"); - assertEquals(150L, + assertEquals(js.enqueueTime + HOUR_IN_MILLIS / 2, mFlexibilityController.getNextConstraintDropTimeElapsedLocked(js)); setDeviceConfigString(KEY_PERCENTS_TO_DROP_NUM_FLEXIBLE_CONSTRAINTS, "50,40,10,40"); - assertEquals(150L, + assertEquals(js.enqueueTime + HOUR_IN_MILLIS / 2, mFlexibilityController.getNextConstraintDropTimeElapsedLocked(js)); } @@ -369,7 +371,7 @@ public class FlexibilityControllerTest { @Test public void testCurPercent() { - long deadline = 1000; + long deadline = 100 * MINUTE_IN_MILLIS; long nowElapsed; JobInfo.Builder jb = createJob(0).setOverrideDeadline(deadline); JobStatus js = createJobStatus("time", jb); @@ -377,17 +379,17 @@ public class FlexibilityControllerTest { assertEquals(FROZEN_TIME, mFlexibilityController.getLifeCycleBeginningElapsedLocked(js)); assertEquals(deadline + FROZEN_TIME, mFlexibilityController.getLifeCycleEndElapsedLocked(js, FROZEN_TIME)); - nowElapsed = 600 + FROZEN_TIME; + nowElapsed = FROZEN_TIME + 60 * MINUTE_IN_MILLIS; JobSchedulerService.sElapsedRealtimeClock = Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); assertEquals(60, mFlexibilityController.getCurPercentOfLifecycleLocked(js, nowElapsed)); - nowElapsed = 1400; + nowElapsed = FROZEN_TIME + 130 * MINUTE_IN_MILLIS; JobSchedulerService.sElapsedRealtimeClock = Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); assertEquals(100, mFlexibilityController.getCurPercentOfLifecycleLocked(js, nowElapsed)); - nowElapsed = 950 + FROZEN_TIME; + nowElapsed = FROZEN_TIME + 95 * MINUTE_IN_MILLIS; JobSchedulerService.sElapsedRealtimeClock = Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); assertEquals(95, mFlexibilityController.getCurPercentOfLifecycleLocked(js, nowElapsed)); @@ -395,8 +397,8 @@ public class FlexibilityControllerTest { nowElapsed = FROZEN_TIME; JobSchedulerService.sElapsedRealtimeClock = Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); - long delay = 100; - deadline = 1100; + long delay = MINUTE_IN_MILLIS; + deadline = 101 * MINUTE_IN_MILLIS; jb = createJob(0).setOverrideDeadline(deadline).setMinimumLatency(delay); js = createJobStatus("time", jb); @@ -405,18 +407,18 @@ public class FlexibilityControllerTest { assertEquals(deadline + FROZEN_TIME, mFlexibilityController.getLifeCycleEndElapsedLocked(js, FROZEN_TIME + delay)); - nowElapsed = 600 + FROZEN_TIME + delay; + nowElapsed = FROZEN_TIME + delay + 60 * MINUTE_IN_MILLIS; JobSchedulerService.sElapsedRealtimeClock = Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); assertEquals(60, mFlexibilityController.getCurPercentOfLifecycleLocked(js, nowElapsed)); - nowElapsed = 1400; + nowElapsed = FROZEN_TIME + 130 * MINUTE_IN_MILLIS; JobSchedulerService.sElapsedRealtimeClock = Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); assertEquals(100, mFlexibilityController.getCurPercentOfLifecycleLocked(js, nowElapsed)); - nowElapsed = 950 + FROZEN_TIME + delay; + nowElapsed = FROZEN_TIME + delay + 95 * MINUTE_IN_MILLIS; JobSchedulerService.sElapsedRealtimeClock = Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); assertEquals(95, mFlexibilityController.getCurPercentOfLifecycleLocked(js, nowElapsed)); @@ -541,20 +543,20 @@ public class FlexibilityControllerTest { @Test public void testGetLifeCycleEndElapsedLocked_NonPrefetch() { // deadline - JobInfo.Builder jb = createJob(0).setOverrideDeadline(1000L); + JobInfo.Builder jb = createJob(0).setOverrideDeadline(HOUR_IN_MILLIS); JobStatus js = createJobStatus("time", jb); - assertEquals(1000L + FROZEN_TIME, + assertEquals(HOUR_IN_MILLIS + FROZEN_TIME, mFlexibilityController.getLifeCycleEndElapsedLocked(js, 0)); // no deadline jb = createJob(0); js = createJobStatus("time", jb); - assertEquals(100L + DEFAULT_FALLBACK_FLEXIBILITY_DEADLINE_MS, + assertEquals(FROZEN_TIME + DEFAULT_FALLBACK_FLEXIBILITY_DEADLINE_MS, mFlexibilityController.getLifeCycleEndElapsedLocked(js, 100L)); } @Test public void testGetLifeCycleEndElapsedLocked_Rescheduled() { - JobInfo.Builder jb = createJob(0).setOverrideDeadline(1000L); + JobInfo.Builder jb = createJob(0).setOverrideDeadline(HOUR_IN_MILLIS); JobStatus js = createJobStatus("time", jb); js = new JobStatus( js, FROZEN_TIME, NO_LATEST_RUNTIME, /* numFailures */ 2, /* numSystemStops */ 0, @@ -693,6 +695,7 @@ public class FlexibilityControllerTest { } @Test + @CoreCompatChangeRule.DisableCompatChanges({JobInfo.ENFORCE_MINIMUM_TIME_WINDOWS}) public void testExceptions_ShortWindow() { JobInfo.Builder jb = createJob(0); jb.setMinimumLatency(1); diff --git a/services/tests/mockingservicestests/src/com/android/server/job/controllers/JobStatusTest.java b/services/tests/mockingservicestests/src/com/android/server/job/controllers/JobStatusTest.java index 92aa982c3dd1..8397b87706d6 100644 --- a/services/tests/mockingservicestests/src/com/android/server/job/controllers/JobStatusTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/job/controllers/JobStatusTest.java @@ -16,6 +16,8 @@ package com.android.server.job.controllers; +import static android.text.format.DateUtils.HOUR_IN_MILLIS; + import static com.android.dx.mockito.inline.extended.ExtendedMockito.doReturn; import static com.android.dx.mockito.inline.extended.ExtendedMockito.mock; import static com.android.dx.mockito.inline.extended.ExtendedMockito.mockitoSession; @@ -261,7 +263,7 @@ public class JobStatusTest { public void testMediaBackupExemption_lateConstraint() { final JobInfo triggerContentJob = new JobInfo.Builder(42, TEST_JOB_COMPONENT) .addTriggerContentUri(new JobInfo.TriggerContentUri(IMAGES_MEDIA_URI, 0)) - .setOverrideDeadline(12) + .setOverrideDeadline(HOUR_IN_MILLIS) .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY) .build(); when(mJobSchedulerInternal.getCloudMediaProviderPackage(eq(0))).thenReturn(TEST_PACKAGE); @@ -869,7 +871,7 @@ public class JobStatusTest { public void testWouldBeReadyWithConstraint_RequestedOverrideDeadline() { final JobInfo jobInfo = new JobInfo.Builder(101, new ComponentName("foo", "bar")) - .setOverrideDeadline(300_000) + .setOverrideDeadline(HOUR_IN_MILLIS) .build(); final JobStatus job = createJobStatus(jobInfo); @@ -1025,7 +1027,7 @@ public class JobStatusTest { final JobInfo jobInfo = new JobInfo.Builder(101, new ComponentName("foo", "bar")) .setRequiresCharging(true) - .setOverrideDeadline(300_000) + .setOverrideDeadline(HOUR_IN_MILLIS) .addTriggerContentUri(new JobInfo.TriggerContentUri( MediaStore.Images.Media.INTERNAL_CONTENT_URI, JobInfo.TriggerContentUri.FLAG_NOTIFY_FOR_DESCENDANTS)) diff --git a/services/tests/mockingservicestests/src/com/android/server/job/controllers/TimeControllerTest.java b/services/tests/mockingservicestests/src/com/android/server/job/controllers/TimeControllerTest.java index 27efcfabea0c..8fb7bd2a6643 100644 --- a/services/tests/mockingservicestests/src/com/android/server/job/controllers/TimeControllerTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/job/controllers/TimeControllerTest.java @@ -48,6 +48,8 @@ import com.android.server.LocalServices; import com.android.server.job.JobSchedulerService; import com.android.server.job.JobSchedulerService.Constants; +import libcore.junit.util.compat.CoreCompatChangeRule; + import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -141,6 +143,7 @@ public class TimeControllerTest { } @Test + @CoreCompatChangeRule.DisableCompatChanges({JobInfo.ENFORCE_MINIMUM_TIME_WINDOWS}) public void testMaybeStartTrackingJobLocked_AlreadySatisfied() { JobStatus delaySatisfied = createJobStatus( "testMaybeStartTrackingJobLocked_AlreadySatisfied", @@ -294,6 +297,7 @@ public class TimeControllerTest { runTestMaybeStartTrackingJobLocked_DeadlineInOrder(); } + @CoreCompatChangeRule.DisableCompatChanges({JobInfo.ENFORCE_MINIMUM_TIME_WINDOWS}) private void runTestMaybeStartTrackingJobLocked_DeadlineInOrder() { final long now = JobSchedulerService.sElapsedRealtimeClock.millis(); @@ -319,6 +323,7 @@ public class TimeControllerTest { } @Test + @CoreCompatChangeRule.DisableCompatChanges({JobInfo.ENFORCE_MINIMUM_TIME_WINDOWS}) public void testMaybeStartTrackingJobLocked_DeadlineInOrder_SomeNotReady() { final long now = JobSchedulerService.sElapsedRealtimeClock.millis(); @@ -357,6 +362,7 @@ public class TimeControllerTest { runTestMaybeStartTrackingJobLocked_DeadlineReverseOrder(); } + @CoreCompatChangeRule.DisableCompatChanges({JobInfo.ENFORCE_MINIMUM_TIME_WINDOWS}) private void runTestMaybeStartTrackingJobLocked_DeadlineReverseOrder() { final long now = JobSchedulerService.sElapsedRealtimeClock.millis(); @@ -387,6 +393,7 @@ public class TimeControllerTest { } @Test + @CoreCompatChangeRule.DisableCompatChanges({JobInfo.ENFORCE_MINIMUM_TIME_WINDOWS}) public void testMaybeStartTrackingJobLocked_DeadlineReverseOrder_SomeNotReady() { final long now = JobSchedulerService.sElapsedRealtimeClock.millis(); @@ -535,6 +542,7 @@ public class TimeControllerTest { runTestCheckExpiredDeadlinesAndResetAlarm(); } + @CoreCompatChangeRule.DisableCompatChanges({JobInfo.ENFORCE_MINIMUM_TIME_WINDOWS}) private void runTestCheckExpiredDeadlinesAndResetAlarm() { final long now = JobSchedulerService.sElapsedRealtimeClock.millis(); @@ -585,6 +593,7 @@ public class TimeControllerTest { } @Test + @CoreCompatChangeRule.DisableCompatChanges({JobInfo.ENFORCE_MINIMUM_TIME_WINDOWS}) public void testCheckExpiredDeadlinesAndResetAlarm_SomeNotReady() { final long now = JobSchedulerService.sElapsedRealtimeClock.millis(); @@ -740,6 +749,7 @@ public class TimeControllerTest { } @Test + @CoreCompatChangeRule.DisableCompatChanges({JobInfo.ENFORCE_MINIMUM_TIME_WINDOWS}) public void testEvaluateStateLocked_Deadline() { final long now = JobSchedulerService.sElapsedRealtimeClock.millis(); diff --git a/services/tests/mockingservicestests/src/com/android/server/pm/PackageArchiverTest.java b/services/tests/mockingservicestests/src/com/android/server/pm/PackageArchiverTest.java index a3ec936273b4..3e73aa30b1cd 100644 --- a/services/tests/mockingservicestests/src/com/android/server/pm/PackageArchiverTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/pm/PackageArchiverTest.java @@ -228,7 +228,7 @@ public class PackageArchiverTest { Exception e = assertThrows( SecurityException.class, () -> mArchiveManager.requestArchive(PACKAGE, "different", mIntentSender, - UserHandle.CURRENT)); + UserHandle.CURRENT, 0)); assertThat(e).hasMessageThat().isEqualTo( String.format( "The UID %s of callerPackageName set by the caller doesn't match the " @@ -245,7 +245,7 @@ public class PackageArchiverTest { Exception e = assertThrows( ParcelableException.class, () -> mArchiveManager.requestArchive(PACKAGE, CALLER_PACKAGE, mIntentSender, - UserHandle.CURRENT)); + UserHandle.CURRENT, 0)); assertThat(e.getCause()).isInstanceOf(PackageManager.NameNotFoundException.class); assertThat(e.getCause()).hasMessageThat().isEqualTo( String.format("Package %s not found.", PACKAGE)); @@ -255,7 +255,8 @@ public class PackageArchiverTest { public void archiveApp_packageNotInstalledForUser() throws IntentSender.SendIntentException { mPackageSetting.modifyUserState(UserHandle.CURRENT.getIdentifier()).setInstalled(false); - mArchiveManager.requestArchive(PACKAGE, CALLER_PACKAGE, mIntentSender, UserHandle.CURRENT); + mArchiveManager.requestArchive(PACKAGE, CALLER_PACKAGE, mIntentSender, UserHandle.CURRENT, + 0); rule.mocks().getHandler().flush(); ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class); @@ -285,7 +286,7 @@ public class PackageArchiverTest { Exception e = assertThrows( ParcelableException.class, () -> mArchiveManager.requestArchive(PACKAGE, CALLER_PACKAGE, mIntentSender, - UserHandle.CURRENT)); + UserHandle.CURRENT, 0)); assertThat(e.getCause()).isInstanceOf(PackageManager.NameNotFoundException.class); assertThat(e.getCause()).hasMessageThat().isEqualTo("No installer found"); } @@ -299,7 +300,7 @@ public class PackageArchiverTest { Exception e = assertThrows( ParcelableException.class, () -> mArchiveManager.requestArchive(PACKAGE, CALLER_PACKAGE, mIntentSender, - UserHandle.CURRENT)); + UserHandle.CURRENT, 0)); assertThat(e.getCause()).isInstanceOf(PackageManager.NameNotFoundException.class); assertThat(e.getCause()).hasMessageThat().isEqualTo( "Installer does not support unarchival"); @@ -313,7 +314,7 @@ public class PackageArchiverTest { Exception e = assertThrows( ParcelableException.class, () -> mArchiveManager.requestArchive(PACKAGE, CALLER_PACKAGE, mIntentSender, - UserHandle.CURRENT)); + UserHandle.CURRENT, 0)); assertThat(e.getCause()).isInstanceOf(PackageManager.NameNotFoundException.class); assertThat(e.getCause()).hasMessageThat().isEqualTo( TextUtils.formatSimple("The app %s does not have a main activity.", PACKAGE)); @@ -325,7 +326,8 @@ public class PackageArchiverTest { doThrow(e).when(mArchiveManager).storeIcon(eq(PACKAGE), any(LauncherActivityInfo.class), eq(mUserId), anyInt(), anyInt()); - mArchiveManager.requestArchive(PACKAGE, CALLER_PACKAGE, mIntentSender, UserHandle.CURRENT); + mArchiveManager.requestArchive(PACKAGE, CALLER_PACKAGE, mIntentSender, UserHandle.CURRENT, + 0); rule.mocks().getHandler().flush(); ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class); @@ -348,15 +350,16 @@ public class PackageArchiverTest { Exception e = assertThrows( ParcelableException.class, () -> mArchiveManager.requestArchive(PACKAGE, CALLER_PACKAGE, mIntentSender, - UserHandle.CURRENT)); + UserHandle.CURRENT, 0)); assertThat(e.getCause()).isInstanceOf(PackageManager.NameNotFoundException.class); assertThat(e.getCause()).hasMessageThat().isEqualTo( TextUtils.formatSimple("The app %s is opted out of archiving.", PACKAGE)); } @Test - public void archiveApp_success() { - mArchiveManager.requestArchive(PACKAGE, CALLER_PACKAGE, mIntentSender, UserHandle.CURRENT); + public void archiveApp_withNoAdditionalFlags_success() { + mArchiveManager.requestArchive(PACKAGE, CALLER_PACKAGE, mIntentSender, UserHandle.CURRENT, + 0); rule.mocks().getHandler().flush(); verify(mInstallerService).uninstall( @@ -369,6 +372,23 @@ public class PackageArchiverTest { } @Test + public void archiveApp_withAdditionalFlags_success() { + mArchiveManager.requestArchive(PACKAGE, CALLER_PACKAGE, mIntentSender, UserHandle.CURRENT, + PackageManager.DELETE_SHOW_DIALOG); + rule.mocks().getHandler().flush(); + + verify(mInstallerService).uninstall( + eq(new VersionedPackage(PACKAGE, PackageManager.VERSION_CODE_HIGHEST)), + eq(CALLER_PACKAGE), + eq(DELETE_ARCHIVE | DELETE_KEEP_DATA | PackageManager.DELETE_SHOW_DIALOG), + eq(mIntentSender), + eq(UserHandle.CURRENT.getIdentifier()), anyInt()); + assertThat(mPackageSetting.readUserState( + UserHandle.CURRENT.getIdentifier()).getArchiveState()).isEqualTo( + createArchiveState()); + } + + @Test public void isAppArchivable_success() throws PackageManager.NameNotFoundException { assertThat(mArchiveManager.isAppArchivable(PACKAGE, UserHandle.CURRENT)).isTrue(); } diff --git a/services/tests/servicestests/src/com/android/server/biometrics/log/BiometricContextProviderTest.java b/services/tests/servicestests/src/com/android/server/biometrics/log/BiometricContextProviderTest.java index 437510595ecb..1b9e6fb6e247 100644 --- a/services/tests/servicestests/src/com/android/server/biometrics/log/BiometricContextProviderTest.java +++ b/services/tests/servicestests/src/com/android/server/biometrics/log/BiometricContextProviderTest.java @@ -179,6 +179,29 @@ public class BiometricContextProviderTest { } @Test + public void testSubscribesToFoldState() throws RemoteException { + final List<Integer> actual = new ArrayList<>(); + final List<Integer> expected = List.of(FoldState.FULLY_CLOSED, FoldState.FULLY_OPENED, + FoldState.UNKNOWN, FoldState.HALF_OPENED); + mProvider.subscribe(mOpContext, ctx -> { + assertThat(ctx).isSameInstanceAs(mOpContext.toAidlContext()); + assertThat(mProvider.getFoldState()).isEqualTo(ctx.foldState); + actual.add(ctx.foldState); + }); + + for (int v : expected) { + mListener.onFoldChanged(v); + } + + assertThat(actual).containsExactly( + FoldState.FULLY_CLOSED, + FoldState.FULLY_OPENED, + FoldState.UNKNOWN, + FoldState.HALF_OPENED + ).inOrder(); + } + + @Test public void testSubscribesToDisplayState() throws RemoteException { final List<Integer> actual = new ArrayList<>(); final List<Integer> expected = List.of(AuthenticateOptions.DISPLAY_STATE_AOD, diff --git a/services/tests/servicestests/src/com/android/server/job/BiasSchedulingTest.java b/services/tests/servicestests/src/com/android/server/job/BiasSchedulingTest.java index 1726ec18e45b..a33f35aa11d3 100644 --- a/services/tests/servicestests/src/com/android/server/job/BiasSchedulingTest.java +++ b/services/tests/servicestests/src/com/android/server/job/BiasSchedulingTest.java @@ -29,6 +29,8 @@ import androidx.test.filters.FlakyTest; import com.android.server.job.MockBiasJobService.TestEnvironment; import com.android.server.job.MockBiasJobService.TestEnvironment.Event; +import libcore.junit.util.compat.CoreCompatChangeRule; + import java.util.ArrayList; @TargetApi(24) @@ -61,6 +63,7 @@ public class BiasSchedulingTest extends AndroidTestCase { } @FlakyTest(bugId = 293589359) + @CoreCompatChangeRule.DisableCompatChanges({JobInfo.ENFORCE_MINIMUM_TIME_WINDOWS}) public void testLowerBiasJobPreempted() throws Exception { for (int i = 0; i < JobConcurrencyManager.MAX_CONCURRENCY_LIMIT; ++i) { JobInfo job = new JobInfo.Builder(100 + i, sJobServiceComponent) @@ -92,6 +95,7 @@ public class BiasSchedulingTest extends AndroidTestCase { assertTrue("Lower bias jobs were not preempted.", wasJobHigherExecuted); } + @CoreCompatChangeRule.DisableCompatChanges({JobInfo.ENFORCE_MINIMUM_TIME_WINDOWS}) public void testHigherBiasJobNotPreempted() throws Exception { for (int i = 0; i < JobConcurrencyManager.DEFAULT_CONCURRENCY_LIMIT; ++i) { JobInfo job = new JobInfo.Builder(100 + i, sJobServiceComponent) diff --git a/services/tests/servicestests/src/com/android/server/job/JobStoreTest.java b/services/tests/servicestests/src/com/android/server/job/JobStoreTest.java index 46ead854bded..3069b673f8fc 100644 --- a/services/tests/servicestests/src/com/android/server/job/JobStoreTest.java +++ b/services/tests/servicestests/src/com/android/server/job/JobStoreTest.java @@ -3,6 +3,7 @@ package com.android.server.job; import static android.net.NetworkCapabilities.NET_CAPABILITY_IMS; import static android.net.NetworkCapabilities.NET_CAPABILITY_OEM_PAID; import static android.net.NetworkCapabilities.TRANSPORT_WIFI; +import static android.text.format.DateUtils.HOUR_IN_MILLIS; import static com.android.server.job.JobStore.JOB_FILE_SPLIT_PREFIX; @@ -141,7 +142,7 @@ public class JobStoreTest { final JobInfo task2 = new Builder(12, mComponent) .setMinimumLatency(5000L) .setBackoffCriteria(15000L, JobInfo.BACKOFF_POLICY_LINEAR) - .setOverrideDeadline(30000L) + .setOverrideDeadline(4 * HOUR_IN_MILLIS) .setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED) .setPersisted(true) .build(); @@ -194,7 +195,7 @@ public class JobStoreTest { final JobInfo task2 = new Builder(12, mComponent) .setMinimumLatency(5000L) .setBackoffCriteria(15000L, JobInfo.BACKOFF_POLICY_LINEAR) - .setOverrideDeadline(30000L) + .setOverrideDeadline(3 * HOUR_IN_MILLIS) .setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED) .setPersisted(true) .build(); @@ -224,7 +225,7 @@ public class JobStoreTest { final JobInfo task2 = new Builder(12, mComponent) .setMinimumLatency(5000L) .setBackoffCriteria(15000L, JobInfo.BACKOFF_POLICY_LINEAR) - .setOverrideDeadline(30000L) + .setOverrideDeadline(5 * HOUR_IN_MILLIS) .setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED) .setPersisted(true) .build(); @@ -330,7 +331,6 @@ public class JobStoreTest { @Test public void testMaybeWriteStatusToDisk() throws Exception { int taskId = 5; - long runByMillis = 20000L; // 20s long runFromMillis = 2000L; // 2s long initialBackoff = 10000L; // 10s @@ -338,7 +338,7 @@ public class JobStoreTest { .setRequiresCharging(true) .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY) .setBackoffCriteria(initialBackoff, JobInfo.BACKOFF_POLICY_EXPONENTIAL) - .setOverrideDeadline(runByMillis) + .setOverrideDeadline(6 * HOUR_IN_MILLIS) .setMinimumLatency(runFromMillis) .setPersisted(true) .build(); @@ -379,7 +379,7 @@ public class JobStoreTest { final JobInfo task2 = new Builder(12, mComponent) .setMinimumLatency(5000L) .setBackoffCriteria(15000L, JobInfo.BACKOFF_POLICY_LINEAR) - .setOverrideDeadline(30000L) + .setOverrideDeadline(7 * HOUR_IN_MILLIS) .setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED) .setPersisted(true) .build(); @@ -542,7 +542,7 @@ public class JobStoreTest { @Test public void testBiasPersisted() throws Exception { JobInfo.Builder b = new Builder(92, mComponent) - .setOverrideDeadline(5000) + .setOverrideDeadline(8 * HOUR_IN_MILLIS) .setBias(42) .setPersisted(true); final JobStatus js = JobStatus.createFromJobInfo(b.build(), SOME_UID, null, -1, null, null); @@ -613,7 +613,7 @@ public class JobStoreTest { @Test public void testPriorityPersisted() throws Exception { final JobInfo job = new Builder(92, mComponent) - .setOverrideDeadline(5000) + .setOverrideDeadline(9 * HOUR_IN_MILLIS) .setPriority(JobInfo.PRIORITY_MIN) .setPersisted(true) .build(); @@ -634,13 +634,13 @@ public class JobStoreTest { @Test public void testNonPersistedTaskIsNotPersisted() throws Exception { JobInfo.Builder b = new Builder(42, mComponent) - .setOverrideDeadline(10000) + .setOverrideDeadline(10 * HOUR_IN_MILLIS) .setPersisted(false); JobStatus jsNonPersisted = JobStatus.createFromJobInfo(b.build(), SOME_UID, null, -1, null, null); mTaskStoreUnderTest.add(jsNonPersisted); b = new Builder(43, mComponent) - .setOverrideDeadline(10000) + .setOverrideDeadline(11 * HOUR_IN_MILLIS) .setPersisted(true); JobStatus jsPersisted = JobStatus.createFromJobInfo(b.build(), SOME_UID, null, -1, null, null); diff --git a/services/tests/servicestests/src/com/android/server/power/ThermalManagerServiceTest.java b/services/tests/servicestests/src/com/android/server/power/ThermalManagerServiceTest.java index 44dad593810a..32bbc7a618d1 100644 --- a/services/tests/servicestests/src/com/android/server/power/ThermalManagerServiceTest.java +++ b/services/tests/servicestests/src/com/android/server/power/ThermalManagerServiceTest.java @@ -482,6 +482,35 @@ public class ThermalManagerServiceTest { } @Test + public void testGetThermalHeadroomThresholdsOnDefaultHalResult() throws Exception { + TemperatureWatcher watcher = mService.mTemperatureWatcher; + ArrayList<TemperatureThreshold> thresholds = new ArrayList<>(); + mFakeHal.mTemperatureThresholdList = thresholds; + watcher.updateThresholds(); + synchronized (watcher.mSamples) { + assertArrayEquals( + new float[]{Float.NaN, Float.NaN, Float.NaN, Float.NaN, Float.NaN, Float.NaN, + Float.NaN}, + watcher.mHeadroomThresholds, 0.01f); + } + TemperatureThreshold nanThresholds = new TemperatureThreshold(); + nanThresholds.name = "nan"; + nanThresholds.type = Temperature.TYPE_SKIN; + nanThresholds.hotThrottlingThresholds = new float[ThrottlingSeverity.SHUTDOWN + 1]; + nanThresholds.coldThrottlingThresholds = new float[ThrottlingSeverity.SHUTDOWN + 1]; + Arrays.fill(nanThresholds.hotThrottlingThresholds, Float.NaN); + Arrays.fill(nanThresholds.coldThrottlingThresholds, Float.NaN); + thresholds.add(nanThresholds); + watcher.updateThresholds(); + synchronized (watcher.mSamples) { + assertArrayEquals( + new float[]{Float.NaN, Float.NaN, Float.NaN, Float.NaN, Float.NaN, Float.NaN, + Float.NaN}, + watcher.mHeadroomThresholds, 0.01f); + } + } + + @Test public void testTemperatureWatcherGetSlopeOf() throws RemoteException { TemperatureWatcher watcher = mService.mTemperatureWatcher; List<TemperatureWatcher.Sample> samples = new ArrayList<>(); diff --git a/services/tests/uiservicestests/src/com/android/server/notification/NotificationVisitUrisTest.java b/services/tests/uiservicestests/src/com/android/server/notification/NotificationVisitUrisTest.java index 337dd22e8712..44dbe385a144 100644 --- a/services/tests/uiservicestests/src/com/android/server/notification/NotificationVisitUrisTest.java +++ b/services/tests/uiservicestests/src/com/android/server/notification/NotificationVisitUrisTest.java @@ -20,6 +20,7 @@ import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkState; import static com.google.common.truth.Truth.assertThat; +import android.app.Flags; import android.app.Notification; import android.app.PendingIntent; import android.app.Person; @@ -33,6 +34,7 @@ import android.net.Uri; import android.os.Bundle; import android.os.IBinder; import android.os.Parcel; +import android.platform.test.flag.junit.SetFlagsRule; import android.util.Log; import android.view.LayoutInflater; import android.view.View; @@ -42,6 +44,7 @@ import androidx.annotation.NonNull; import androidx.test.InstrumentationRegistry; import androidx.test.runner.AndroidJUnit4; +import com.android.internal.config.sysui.SystemUiSystemPropertiesFlags; import com.android.server.UiServiceTestCase; import com.google.common.base.Strings; @@ -54,6 +57,7 @@ import com.google.common.collect.ListMultimap; import com.google.common.collect.Multimap; import com.google.common.truth.Expect; +import org.junit.After; import org.junit.Before; import org.junit.Rule; import org.junit.Test; @@ -72,6 +76,7 @@ import java.lang.reflect.Type; import java.util.ArrayList; import java.util.Arrays; import java.util.Comparator; +import java.util.HashSet; import java.util.List; import java.util.Optional; import java.util.Set; @@ -83,15 +88,16 @@ import javax.annotation.Nullable; @RunWith(AndroidJUnit4.class) public class NotificationVisitUrisTest extends UiServiceTestCase { + @Rule + public final SetFlagsRule mSetFlagsRule = new SetFlagsRule(); private static final String TAG = "VisitUrisTest"; // Methods that are known to add Uris that are *NOT* verified. - // This list should be emptied! Items can be removed as bugs are fixed. + // This list should only be used temporarily if needed, and any element in this list should + // have a tracking bug associated. private static final Multimap<Class<?>, String> KNOWN_BAD = - ImmutableMultimap.<Class<?>, String>builder() - .put(Person.Builder.class, "setUri") // TODO: b/281044385 - .build(); + ImmutableMultimap.<Class<?>, String>builder().build(); // Types that we can't really produce. No methods receiving these parameters will be invoked. private static final ImmutableSet<Class<?>> UNUSABLE_TYPES = @@ -155,6 +161,12 @@ public class NotificationVisitUrisTest extends UiServiceTestCase { @Before public void setUp() { mContext = InstrumentationRegistry.getInstrumentation().getContext(); + mSetFlagsRule.enableFlags(Flags.FLAG_VISIT_RISKY_URIS); + } + + @After + public void tearDown() { + SystemUiSystemPropertiesFlags.TEST_RESOLVER = null; } @Test // This is a meta-test, checks that the generators are not broken. @@ -229,13 +241,12 @@ public class NotificationVisitUrisTest extends UiServiceTestCase { notification.visitUris(visitor); Mockito.verify(visitor, Mockito.atLeastOnce()).accept(visitedUriCaptor.capture()); - List<Uri> visitedUris = new ArrayList<>(visitedUriCaptor.getAllValues()); + Set<Uri> visitedUris = new HashSet<>(visitedUriCaptor.getAllValues()); visitedUris.remove(null); expect.withMessage(notificationTypeMessage) .that(visitedUris) - .containsAtLeastElementsIn(includedUris); - expect.that(KNOWN_BAD).isNotEmpty(); // Once empty, switch to containsExactlyElementsIn() + .containsExactlyElementsIn(includedUris); } private static Generated<Notification> buildNotification(Context context, @@ -520,7 +531,7 @@ public class NotificationVisitUrisTest extends UiServiceTestCase { && !EXCLUDED_SETTERS.containsEntry(clazz, method.getName()) && !EXCLUDED_SETTERS_OVERLOADS.containsEntry(clazz, method) && Arrays.stream(method.getParameterTypes()) - .noneMatch(excludingParameterTypes::contains)) { + .noneMatch(excludingParameterTypes::contains)) { methods.put(method.getName(), method); } } @@ -535,14 +546,14 @@ public class NotificationVisitUrisTest extends UiServiceTestCase { List<Method> excludedSetters = setters.stream().filter( m1 -> m1.getName().startsWith("set") && setters.stream().anyMatch( - m2 -> { - Class<?> param1 = m1.getParameterTypes()[0]; - Class<?> param2 = m2.getParameterTypes()[0]; - return m2.getName().startsWith("add") - && param1.isArray() - && !param2.isArray() && !param2.isPrimitive() - && param1.getComponentType().equals(param2); - })).toList(); + m2 -> { + Class<?> param1 = m1.getParameterTypes()[0]; + Class<?> param2 = m2.getParameterTypes()[0]; + return m2.getName().startsWith("add") + && param1.isArray() + && !param2.isArray() && !param2.isPrimitive() + && param1.getComponentType().equals(param2); + })).toList(); setters.removeAll(excludedSetters); return setters; @@ -597,9 +608,8 @@ public class NotificationVisitUrisTest extends UiServiceTestCase { private static class SpecialParameterGenerator { private static final ImmutableSet<Class<?>> INTERESTING_CLASSES = - ImmutableSet.of( - Person.class, Uri.class, Icon.class, Intent.class, PendingIntent.class, - RemoteViews.class); + ImmutableSet.of(Person.class, Uri.class, Icon.class, Intent.class, + PendingIntent.class, RemoteViews.class); private static final ImmutableSet<Class<?>> MOCKED_CLASSES = ImmutableSet.of(); private static final ImmutableMap<Class<?>, Object> PRIMITIVE_VALUES = @@ -623,7 +633,7 @@ public class NotificationVisitUrisTest extends UiServiceTestCase { } static boolean canGenerate(Class<?> clazz) { - return (INTERESTING_CLASSES.contains(clazz) && !clazz.equals(Person.class)) + return INTERESTING_CLASSES.contains(clazz) || MOCKED_CLASSES.contains(clazz) || clazz.equals(Context.class) || clazz.equals(Bundle.class) @@ -658,6 +668,17 @@ public class NotificationVisitUrisTest extends UiServiceTestCase { return Icon.createWithContentUri(iconUri); } + if (clazz == Person.class) { + // TODO(b/310189261): Person.setUri takes a string instead of a URI. We should + // find a way to use the SpecialParameterGenerator instead of this custom one. + Uri personUri = generateUri( + where.plus(Person.Builder.class).plus("setUri", String.class)); + Uri iconUri = generateUri(where.plus(Person.Builder.class).plus("setIcon", + Icon.class).plus(Icon.class).plus("createWithContentUri", Uri.class)); + return new Person.Builder().setUri(personUri.toString()).setIcon( + Icon.createWithContentUri(iconUri)).setName("John Doe").build(); + } + if (clazz == Intent.class) { // TODO(b/281044385): Are Intent Uris (new Intent(String,Uri)) relevant? return new Intent("action"); @@ -717,9 +738,12 @@ public class NotificationVisitUrisTest extends UiServiceTestCase { private static class Location { private static class Item { - @Nullable private final Class<?> mMaybeClass; - @Nullable private final Executable mMaybeMethod; - @Nullable private final String mExtra; + @Nullable + private final Class<?> mMaybeClass; + @Nullable + private final Executable mMaybeMethod; + @Nullable + private final String mExtra; Item(@NonNull Class<?> clazz) { mMaybeClass = checkNotNull(clazz); diff --git a/services/tests/uiservicestests/src/com/android/server/notification/ZenModeHelperTest.java b/services/tests/uiservicestests/src/com/android/server/notification/ZenModeHelperTest.java index 97b6b98a0b08..4d25eaab1f49 100644 --- a/services/tests/uiservicestests/src/com/android/server/notification/ZenModeHelperTest.java +++ b/services/tests/uiservicestests/src/com/android/server/notification/ZenModeHelperTest.java @@ -524,7 +524,7 @@ public class ZenModeHelperTest extends UiServiceTestCase { mZenModeHelper.mConsolidatedPolicy = new Policy(0, 0, 0, 0, 0, 0); mZenModeHelper.applyRestrictions(); - for (int usage : AudioAttributes.SDK_USAGES) { + for (int usage : AudioAttributes.getSdkUsages()) { if (usage == AudioAttributes.USAGE_ASSISTANCE_SONIFICATION) { // only mute audio, not vibrations verify(mAppOps, atLeastOnce()).setRestriction(eq(AppOpsManager.OP_PLAY_AUDIO), @@ -546,7 +546,7 @@ public class ZenModeHelperTest extends UiServiceTestCase { mZenModeHelper.mConsolidatedPolicy = new Policy(0, 0, 0, 0, 0, 0); mZenModeHelper.applyRestrictions(); - for (int usage : AudioAttributes.SDK_USAGES) { + for (int usage : AudioAttributes.getSdkUsages()) { verify(mAppOps).setRestriction( eq(AppOpsManager.OP_PLAY_AUDIO), eq(usage), anyInt(), eq(new String[]{PKG_O})); verify(mAppOps).setRestriction( @@ -561,7 +561,7 @@ public class ZenModeHelperTest extends UiServiceTestCase { mZenModeHelper.mConsolidatedPolicy = new Policy(0, 0, 0, 0, 0, 0); mZenModeHelper.applyRestrictions(); - for (int usage : AudioAttributes.SDK_USAGES) { + for (int usage : AudioAttributes.getSdkUsages()) { verify(mAppOps).setRestriction( eq(AppOpsManager.OP_PLAY_AUDIO), eq(usage), anyInt(), eq(null)); verify(mAppOps).setRestriction( @@ -576,7 +576,7 @@ public class ZenModeHelperTest extends UiServiceTestCase { mZenModeHelper.mConsolidatedPolicy = new Policy(0, 0, 0, 0, 0, 0); mZenModeHelper.applyRestrictions(); - for (int usage : AudioAttributes.SDK_USAGES) { + for (int usage : AudioAttributes.getSdkUsages()) { verify(mAppOps).setRestriction( eq(AppOpsManager.OP_PLAY_AUDIO), eq(usage), anyInt(), eq(null)); verify(mAppOps).setRestriction( @@ -1052,6 +1052,88 @@ public class ZenModeHelperTest extends UiServiceTestCase { } @Test + public void testProtoWithAutoRuleCustomPolicy_classic() throws Exception { + setupZenConfig(); + // clear any automatic rules just to make sure + mZenModeHelper.mConfig.automaticRules = new ArrayMap<>(); + + // Add an automatic rule with a custom policy + ZenRule rule = createCustomAutomaticRule(ZEN_MODE_IMPORTANT_INTERRUPTIONS, CUSTOM_RULE_ID); + rule.zenPolicy = new ZenPolicy.Builder() + .allowAlarms(true) + .allowRepeatCallers(false) + .allowCalls(PEOPLE_TYPE_STARRED) + .build(); + mZenModeHelper.mConfig.automaticRules.put(rule.id, rule); + List<StatsEvent> events = new LinkedList<>(); + mZenModeHelper.pullRules(events); + + boolean foundCustomEvent = false; + for (StatsEvent ev : events) { + AtomsProto.Atom atom = StatsEventTestUtils.convertToAtom(ev); + assertTrue(atom.hasDndModeRule()); + DNDModeProto cfg = atom.getDndModeRule(); + if (cfg.getUid() == CUSTOM_PKG_UID) { + foundCustomEvent = true; + // Check that the pieces of the policy are applied. + assertThat(cfg.hasPolicy()).isTrue(); + DNDPolicyProto policy = cfg.getPolicy(); + assertThat(policy.getAlarms().getNumber()).isEqualTo(DNDProtoEnums.STATE_ALLOW); + assertThat(policy.getRepeatCallers().getNumber()) + .isEqualTo(DNDProtoEnums.STATE_DISALLOW); + assertThat(policy.getCalls().getNumber()).isEqualTo(DNDProtoEnums.STATE_ALLOW); + assertThat(policy.getAllowCallsFrom().getNumber()) + .isEqualTo(DNDProtoEnums.PEOPLE_STARRED); + } + } + assertTrue("couldn't find custom rule", foundCustomEvent); + } + + @Test + public void testProtoWithAutoRuleCustomPolicy() throws Exception { + // allowChannels is only valid under modes_api. + mSetFlagsRule.enableFlags(Flags.FLAG_MODES_API); + + setupZenConfig(); + // clear any automatic rules just to make sure + mZenModeHelper.mConfig.automaticRules = new ArrayMap<>(); + + // Add an automatic rule with a custom policy + ZenRule rule = createCustomAutomaticRule(ZEN_MODE_IMPORTANT_INTERRUPTIONS, CUSTOM_RULE_ID); + rule.zenPolicy = new ZenPolicy.Builder() + .allowAlarms(true) + .allowRepeatCallers(false) + .allowCalls(PEOPLE_TYPE_STARRED) + .allowChannels(ZenPolicy.CHANNEL_TYPE_NONE) + .build(); + mZenModeHelper.mConfig.automaticRules.put(rule.id, rule); + List<StatsEvent> events = new LinkedList<>(); + mZenModeHelper.pullRules(events); + + boolean foundCustomEvent = false; + for (StatsEvent ev : events) { + AtomsProto.Atom atom = StatsEventTestUtils.convertToAtom(ev); + assertTrue(atom.hasDndModeRule()); + DNDModeProto cfg = atom.getDndModeRule(); + if (cfg.getUid() == CUSTOM_PKG_UID) { + foundCustomEvent = true; + // Check that the pieces of the policy are applied. + assertThat(cfg.hasPolicy()).isTrue(); + DNDPolicyProto policy = cfg.getPolicy(); + assertThat(policy.getAlarms().getNumber()).isEqualTo(DNDProtoEnums.STATE_ALLOW); + assertThat(policy.getRepeatCallers().getNumber()) + .isEqualTo(DNDProtoEnums.STATE_DISALLOW); + assertThat(policy.getCalls().getNumber()).isEqualTo(DNDProtoEnums.STATE_ALLOW); + assertThat(policy.getAllowCallsFrom().getNumber()) + .isEqualTo(DNDProtoEnums.PEOPLE_STARRED); + assertThat(policy.getAllowChannels().getNumber()) + .isEqualTo(DNDProtoEnums.CHANNEL_TYPE_NONE); + } + } + assertTrue("couldn't find custom rule", foundCustomEvent); + } + + @Test public void ruleUidsCached() throws Exception { setupZenConfig(); // one enabled automatic rule @@ -2722,6 +2804,55 @@ public class ZenModeHelperTest extends UiServiceTestCase { } @Test + public void testZenModeEventLog_policyAllowChannels() { + // when modes_api flag is on, ensure that any change in allow_channels gets logged, + // even when there are no other changes. + mTestFlagResolver.setFlagOverride(LOG_DND_STATE_EVENTS, true); + mSetFlagsRule.enableFlags(Flags.FLAG_MODES_API); + + // Default zen config has allow channels = priority (aka on) + setupZenConfig(); + + // First just turn zen mode on + mZenModeHelper.setManualZenMode(ZEN_MODE_IMPORTANT_INTERRUPTIONS, null, null, "", + Process.SYSTEM_UID, true); + + // Now change only the channels part of the policy; want to confirm that this'll be + // reflected in the logs + ZenModeConfig newConfig = mZenModeHelper.mConfig.copy(); + newConfig.allowPriorityChannels = false; + mZenModeHelper.setNotificationPolicy(newConfig.toNotificationPolicy(), Process.SYSTEM_UID, + true); + + // Total events: one for turning on, one for changing policy + assertThat(mZenModeEventLogger.numLoggedChanges()).isEqualTo(2); + + // The first event is just turning DND on; make sure the policy is what we expect there + // before it changes in the next stage + assertThat(mZenModeEventLogger.getEventId(0)) + .isEqualTo(ZenModeEventLogger.ZenStateChangedEvent.DND_TURNED_ON.getId()); + DNDPolicyProto origDndProto = mZenModeEventLogger.getPolicyProto(0); + checkDndProtoMatchesSetupZenConfig(origDndProto); + assertThat(origDndProto.getAllowChannels().getNumber()) + .isEqualTo(DNDProtoEnums.CHANNEL_TYPE_PRIORITY); + + // Second message where we change the policy: + // - DND_POLICY_CHANGED (indicates only the policy changed and nothing else) + // - rule type: unknown (it's a policy change, not a rule change) + // - user action (because it comes from a "system" uid) + // - change is in allow channels, and final policy + assertThat(mZenModeEventLogger.getEventId(1)) + .isEqualTo(ZenModeEventLogger.ZenStateChangedEvent.DND_POLICY_CHANGED.getId()); + assertThat(mZenModeEventLogger.getChangedRuleType(1)) + .isEqualTo(DNDProtoEnums.UNKNOWN_RULE); + assertThat(mZenModeEventLogger.getIsUserAction(1)).isTrue(); + assertThat(mZenModeEventLogger.getPackageUid(1)).isEqualTo(Process.SYSTEM_UID); + DNDPolicyProto dndProto = mZenModeEventLogger.getPolicyProto(1); + assertThat(dndProto.getAllowChannels().getNumber()) + .isEqualTo(DNDProtoEnums.CHANNEL_TYPE_NONE); + } + + @Test public void testUpdateConsolidatedPolicy_defaultRulesOnly() { setupZenConfig(); @@ -3416,6 +3547,7 @@ public class ZenModeHelperTest extends UiServiceTestCase { return rule; } + // TODO: b/310620812 - Update setup methods to include allowChannels() when MODES_API is inlined private void setupZenConfig() { mZenModeHelper.mZenMode = ZEN_MODE_OFF; mZenModeHelper.mConfig.allowAlarms = false; diff --git a/services/tests/wmtests/AndroidManifest.xml b/services/tests/wmtests/AndroidManifest.xml index c3074bb0fee8..a8d3fa110844 100644 --- a/services/tests/wmtests/AndroidManifest.xml +++ b/services/tests/wmtests/AndroidManifest.xml @@ -99,7 +99,7 @@ android:theme="@style/WhiteBackgroundTheme" android:exported="true"/> - <activity android:name="com.android.server.wm.TrustedPresentationCallbackTest$TestActivity" + <activity android:name="com.android.server.wm.TrustedPresentationListenerTest$TestActivity" android:exported="true" android:showWhenLocked="true" android:turnScreenOn="true" /> diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java index f2e54bc572ae..7aa46a62b0f1 100644 --- a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java @@ -3727,6 +3727,24 @@ public class ActivityRecordTests extends WindowTestsBase { verify(task).moveTaskToBack(any()); } + /** + * Verifies the {@link ActivityRecord#moveFocusableActivityToTop} returns {@code false} if + * there's a PIP task on top. + */ + @Test + public void testMoveFocusableActivityToTop() { + // Create a Task + final Task task = createTask(mDisplayContent); + final ActivityRecord ar = createActivityRecord(task); + + // Create a PIP Task on top + final Task pipTask = createTask(mDisplayContent); + doReturn(true).when(pipTask).inPinnedWindowingMode(); + + // Verifies that the Task is not moving-to-top. + assertFalse(ar.moveFocusableActivityToTop("test")); + } + private ICompatCameraControlCallback getCompatCameraControlCallback() { return new ICompatCameraControlCallback.Stub() { @Override diff --git a/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java b/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java index acce2e2633bd..71d2504e1746 100644 --- a/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java @@ -2086,15 +2086,17 @@ public class DisplayContentTests extends WindowTestsBase { @Test public void testShellTransitRotation() { - DisplayContent dc = createNewDisplay(); - dc.setLastHasContent(); + final DisplayContent dc = mDisplayContent; + // Create 2 visible activities to verify that they can both receive the new configuration. + final ActivityRecord activity1 = new ActivityBuilder(mAtm).setCreateTask(true).build(); + final ActivityRecord activity2 = new ActivityBuilder(mAtm).setCreateTask(true).build(); + doReturn(true).when(activity1).isSyncFinished(any()); + doReturn(true).when(activity2).isSyncFinished(any()); final TestTransitionPlayer testPlayer = registerTestTransitionPlayer(); final DisplayRotation dr = dc.getDisplayRotation(); - doCallRealMethod().when(dr).updateRotationUnchecked(anyBoolean()); - // Rotate 180 degree so the display doesn't have configuration change. This condition is - // used for the later verification of stop-freezing (without setting mWaitingForConfig). - doReturn((dr.getRotation() + 2) % 4).when(dr).rotationForOrientation(anyInt(), anyInt()); + spyOn(dr); + doReturn((dr.getRotation() + 1) % 4).when(dr).rotationForOrientation(anyInt(), anyInt()); mWm.mDisplayChangeController = new IDisplayChangeWindowController.Stub() { @Override @@ -2109,11 +2111,8 @@ public class DisplayContentTests extends WindowTestsBase { } }; - // kill any existing rotation animation (vestigial from test setup). - dc.setRotationAnimation(null); - final int origRot = dc.getConfiguration().windowConfiguration.getRotation(); - + dc.setLastHasContent(); mWm.updateRotation(true /* alwaysSendConfiguration */, false /* forceRelayout */); // Should create a transition request without performing rotation assertNotNull(testPlayer.mLastRequest); @@ -2122,6 +2121,10 @@ public class DisplayContentTests extends WindowTestsBase { // Once transition starts, rotation is applied and transition shows DC rotating. testPlayer.startTransition(); waitUntilHandlersIdle(); + verify(activity1).ensureActivityConfiguration(anyInt(), anyBoolean(), anyBoolean(), + anyBoolean()); + verify(activity2).ensureActivityConfiguration(anyInt(), anyBoolean(), anyBoolean(), + anyBoolean()); assertNotEquals(origRot, dc.getConfiguration().windowConfiguration.getRotation()); assertNotNull(testPlayer.mLastReady); assertTrue(testPlayer.mController.isPlaying()); diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskStackChangedListenerTest.java b/services/tests/wmtests/src/com/android/server/wm/TaskStackChangedListenerTest.java index 267bec9cccd2..c876663dd749 100644 --- a/services/tests/wmtests/src/com/android/server/wm/TaskStackChangedListenerTest.java +++ b/services/tests/wmtests/src/com/android/server/wm/TaskStackChangedListenerTest.java @@ -40,6 +40,7 @@ import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.content.pm.ActivityInfo; +import android.graphics.Color; import android.graphics.PixelFormat; import android.hardware.display.DisplayManager; import android.hardware.display.VirtualDisplay; @@ -167,7 +168,7 @@ public class TaskStackChangedListenerTest { @Presubmit public void testTaskDescriptionChanged() throws Exception { final Object[] params = new Object[2]; - final CountDownLatch latch = new CountDownLatch(1); + final CountDownLatch latch = new CountDownLatch(2); registerTaskStackChangedListener(new TaskStackListener() { int mTaskId = -1; @@ -510,6 +511,8 @@ public class TaskStackChangedListenerTest { protected void onPostResume() { super.onPostResume(); setTaskDescription(new TaskDescription("Test Label")); + // Sets the color of the status-bar should update the TaskDescription again. + getWindow().setStatusBarColor(Color.RED); synchronized (sLock) { // Hold the lock to ensure no one is trying to access fields of this Activity in // this test. diff --git a/services/tests/wmtests/src/com/android/server/wm/TrustedPresentationCallbackTest.java b/services/tests/wmtests/src/com/android/server/wm/TrustedPresentationCallbackTest.java deleted file mode 100644 index c5dd447b5b0c..000000000000 --- a/services/tests/wmtests/src/com/android/server/wm/TrustedPresentationCallbackTest.java +++ /dev/null @@ -1,154 +0,0 @@ -/* - * Copyright (C) 2023 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.wm; - -import static android.server.wm.ActivityManagerTestBase.createFullscreenActivityScenarioRule; -import static android.server.wm.BuildUtils.HW_TIMEOUT_MULTIPLIER; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -import android.app.Activity; -import android.platform.test.annotations.Presubmit; -import android.server.wm.CtsWindowInfoUtils; -import android.view.SurfaceControl; -import android.view.SurfaceControl.TrustedPresentationThresholds; - -import androidx.annotation.GuardedBy; -import androidx.test.ext.junit.rules.ActivityScenarioRule; - -import com.android.server.wm.utils.CommonUtils; - -import org.junit.After; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestName; - -import java.util.function.Consumer; - -/** - * TODO (b/287076178): Move these tests to - * {@link android.view.surfacecontrol.cts.TrustedPresentationCallbackTest} when API is made public - */ -@Presubmit -public class TrustedPresentationCallbackTest { - private static final String TAG = "TrustedPresentationCallbackTest"; - private static final int STABILITY_REQUIREMENT_MS = 500; - private static final long WAIT_TIME_MS = HW_TIMEOUT_MULTIPLIER * 2000L; - - private static final float FRACTION_VISIBLE = 0.1f; - - private final Object mResultsLock = new Object(); - @GuardedBy("mResultsLock") - private boolean mResult; - @GuardedBy("mResultsLock") - private boolean mReceivedResults; - - @Rule - public TestName mName = new TestName(); - - @Rule - public ActivityScenarioRule<TestActivity> mActivityRule = createFullscreenActivityScenarioRule( - TestActivity.class); - - private TestActivity mActivity; - - @Before - public void setup() { - mActivityRule.getScenario().onActivity(activity -> mActivity = activity); - } - - @After - public void tearDown() { - CommonUtils.waitUntilActivityRemoved(mActivity); - } - - @Test - public void testAddTrustedPresentationListenerOnWindow() throws InterruptedException { - TrustedPresentationThresholds thresholds = new TrustedPresentationThresholds( - 1 /* minAlpha */, FRACTION_VISIBLE, STABILITY_REQUIREMENT_MS); - SurfaceControl.Transaction t = new SurfaceControl.Transaction(); - mActivity.getWindow().getRootSurfaceControl().addTrustedPresentationCallback(t, thresholds, - Runnable::run, inTrustedPresentationState -> { - synchronized (mResultsLock) { - mResult = inTrustedPresentationState; - mReceivedResults = true; - mResultsLock.notify(); - } - }); - t.apply(); - synchronized (mResultsLock) { - assertResults(); - } - } - - @Test - public void testRemoveTrustedPresentationListenerOnWindow() throws InterruptedException { - TrustedPresentationThresholds thresholds = new TrustedPresentationThresholds( - 1 /* minAlpha */, FRACTION_VISIBLE, STABILITY_REQUIREMENT_MS); - Consumer<Boolean> trustedPresentationCallback = inTrustedPresentationState -> { - synchronized (mResultsLock) { - mResult = inTrustedPresentationState; - mReceivedResults = true; - mResultsLock.notify(); - } - }; - SurfaceControl.Transaction t = new SurfaceControl.Transaction(); - mActivity.getWindow().getRootSurfaceControl().addTrustedPresentationCallback(t, thresholds, - Runnable::run, trustedPresentationCallback); - t.apply(); - - synchronized (mResultsLock) { - if (!mReceivedResults) { - mResultsLock.wait(WAIT_TIME_MS); - } - assertResults(); - // reset the state - mReceivedResults = false; - } - - mActivity.getWindow().getRootSurfaceControl().removeTrustedPresentationCallback(t, - trustedPresentationCallback); - t.apply(); - - synchronized (mResultsLock) { - if (!mReceivedResults) { - mResultsLock.wait(WAIT_TIME_MS); - } - // Ensure we waited the full time and never received a notify on the result from the - // callback. - assertFalse("Should never have received a callback", mReceivedResults); - // results shouldn't have changed. - assertTrue(mResult); - } - } - - @GuardedBy("mResultsLock") - private void assertResults() throws InterruptedException { - mResultsLock.wait(WAIT_TIME_MS); - - if (!mReceivedResults) { - CtsWindowInfoUtils.dumpWindowsOnScreen(TAG, "test " + mName.getMethodName()); - } - // Make sure we received the results and not just timed out - assertTrue("Timed out waiting for results", mReceivedResults); - assertTrue(mResult); - } - - public static class TestActivity extends Activity { - } -} diff --git a/services/tests/wmtests/src/com/android/server/wm/TrustedPresentationListenerTest.java b/services/tests/wmtests/src/com/android/server/wm/TrustedPresentationListenerTest.java new file mode 100644 index 000000000000..96b66bfd3bc0 --- /dev/null +++ b/services/tests/wmtests/src/com/android/server/wm/TrustedPresentationListenerTest.java @@ -0,0 +1,267 @@ +/* + * Copyright (C) 2023 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.wm; + +import static android.server.wm.ActivityManagerTestBase.createFullscreenActivityScenarioRule; +import static android.server.wm.BuildUtils.HW_TIMEOUT_MULTIPLIER; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.fail; + +import android.app.Activity; +import android.os.SystemClock; +import android.platform.test.annotations.Presubmit; +import android.server.wm.CtsWindowInfoUtils; +import android.util.AndroidRuntimeException; +import android.util.Log; +import android.view.SurfaceControl; +import android.view.SurfaceControlViewHost; +import android.view.View; +import android.view.WindowManager; +import android.window.TrustedPresentationThresholds; + +import androidx.annotation.GuardedBy; +import androidx.annotation.NonNull; +import androidx.test.ext.junit.rules.ActivityScenarioRule; + +import com.android.server.wm.utils.CommonUtils; + +import junit.framework.Assert; + +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TestName; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import java.util.function.Consumer; + +/** + * TODO (b/287076178): Move these tests to + * {@link android.view.surfacecontrol.cts.TrustedPresentationListenerTest} when API is made public + */ +@Presubmit +public class TrustedPresentationListenerTest { + private static final String TAG = "TrustedPresentationListenerTest"; + private static final int STABILITY_REQUIREMENT_MS = 500; + private static final long WAIT_TIME_MS = HW_TIMEOUT_MULTIPLIER * 2000L; + + private static final float FRACTION_VISIBLE = 0.1f; + + private final List<Boolean> mResults = Collections.synchronizedList(new ArrayList<>()); + private CountDownLatch mReceivedResults = new CountDownLatch(1); + + private TrustedPresentationThresholds mThresholds = new TrustedPresentationThresholds( + 1 /* minAlpha */, FRACTION_VISIBLE, STABILITY_REQUIREMENT_MS); + + @Rule + public TestName mName = new TestName(); + + @Rule + public ActivityScenarioRule<TestActivity> mActivityRule = createFullscreenActivityScenarioRule( + TestActivity.class); + + private TestActivity mActivity; + + private SurfaceControlViewHost.SurfacePackage mSurfacePackage = null; + + @Before + public void setup() { + mActivityRule.getScenario().onActivity(activity -> mActivity = activity); + mDefaultListener = new Listener(mReceivedResults); + } + + @After + public void tearDown() { + if (mSurfacePackage != null) { + new SurfaceControl.Transaction().remove(mSurfacePackage.getSurfaceControl()).apply( + true); + mSurfacePackage.release(); + } + CommonUtils.waitUntilActivityRemoved(mActivity); + + } + + private class Listener implements Consumer<Boolean> { + final CountDownLatch mLatch; + + Listener(CountDownLatch latch) { + mLatch = latch; + } + + @Override + public void accept(Boolean inTrustedPresentationState) { + Log.d(TAG, "onTrustedPresentationChanged " + inTrustedPresentationState); + mResults.add(inTrustedPresentationState); + mLatch.countDown(); + } + } + + private Consumer<Boolean> mDefaultListener; + + @Test + public void testAddTrustedPresentationListenerOnWindow() { + WindowManager windowManager = mActivity.getSystemService(WindowManager.class); + windowManager.registerTrustedPresentationListener( + mActivity.getWindow().getDecorView().getWindowToken(), mThresholds, Runnable::run, + mDefaultListener); + assertResults(List.of(true)); + } + + @Test + public void testRemoveTrustedPresentationListenerOnWindow() throws InterruptedException { + WindowManager windowManager = mActivity.getSystemService(WindowManager.class); + windowManager.registerTrustedPresentationListener( + mActivity.getWindow().getDecorView().getWindowToken(), mThresholds, Runnable::run, + mDefaultListener); + assertResults(List.of(true)); + // reset the latch + mReceivedResults = new CountDownLatch(1); + + windowManager.unregisterTrustedPresentationListener(mDefaultListener); + mReceivedResults.await(WAIT_TIME_MS, TimeUnit.MILLISECONDS); + // Ensure we waited the full time and never received a notify on the result from the + // callback. + assertEquals("Should never have received a callback", mReceivedResults.getCount(), 1); + // results shouldn't have changed. + assertEquals(mResults, List.of(true)); + } + + @Test + public void testRemovingUnknownListenerIsANoop() { + WindowManager windowManager = mActivity.getSystemService(WindowManager.class); + assertNotNull(windowManager); + windowManager.unregisterTrustedPresentationListener(mDefaultListener); + } + + @Test + public void testAddDuplicateListenerThrowsException() { + WindowManager windowManager = mActivity.getSystemService(WindowManager.class); + assertNotNull(windowManager); + windowManager.registerTrustedPresentationListener( + mActivity.getWindow().getDecorView().getWindowToken(), mThresholds, + Runnable::run, mDefaultListener); + assertThrows(AndroidRuntimeException.class, + () -> windowManager.registerTrustedPresentationListener( + mActivity.getWindow().getDecorView().getWindowToken(), mThresholds, + Runnable::run, mDefaultListener)); + } + + @Test + public void testAddDuplicateThresholds() { + mReceivedResults = new CountDownLatch(2); + mDefaultListener = new Listener(mReceivedResults); + WindowManager windowManager = mActivity.getSystemService(WindowManager.class); + windowManager.registerTrustedPresentationListener( + mActivity.getWindow().getDecorView().getWindowToken(), mThresholds, + Runnable::run, mDefaultListener); + + Consumer<Boolean> mNewListener = new Listener(mReceivedResults); + + windowManager.registerTrustedPresentationListener( + mActivity.getWindow().getDecorView().getWindowToken(), mThresholds, + Runnable::run, mNewListener); + assertResults(List.of(true, true)); + } + + private void waitForViewAttach(View view) { + final CountDownLatch viewAttached = new CountDownLatch(1); + view.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() { + @Override + public void onViewAttachedToWindow(@NonNull View v) { + viewAttached.countDown(); + } + + @Override + public void onViewDetachedFromWindow(@NonNull View v) { + + } + }); + try { + viewAttached.await(2000, TimeUnit.MILLISECONDS); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + if (!wait(viewAttached, 2000 /* waitTimeMs */)) { + fail("Couldn't attach view=" + view); + } + } + + @Test + public void testAddListenerToScvh() { + WindowManager windowManager = mActivity.getSystemService(WindowManager.class); + + var embeddedView = new View(mActivity); + mActivityRule.getScenario().onActivity(activity -> { + var attachedSurfaceControl = + mActivity.getWindow().getDecorView().getRootSurfaceControl(); + var scvh = new SurfaceControlViewHost(mActivity, mActivity.getDisplay(), + attachedSurfaceControl.getHostToken()); + mSurfacePackage = scvh.getSurfacePackage(); + scvh.setView(embeddedView, mActivity.getWindow().getDecorView().getWidth(), + mActivity.getWindow().getDecorView().getHeight()); + attachedSurfaceControl.buildReparentTransaction( + mSurfacePackage.getSurfaceControl()); + }); + + waitForViewAttach(embeddedView); + windowManager.registerTrustedPresentationListener(embeddedView.getWindowToken(), + mThresholds, + Runnable::run, mDefaultListener); + + assertResults(List.of(true)); + } + + private boolean wait(CountDownLatch latch, long waitTimeMs) { + while (true) { + long now = SystemClock.uptimeMillis(); + try { + return latch.await(waitTimeMs, TimeUnit.MILLISECONDS); + } catch (InterruptedException e) { + long elapsedTime = SystemClock.uptimeMillis() - now; + waitTimeMs = Math.max(0, waitTimeMs - elapsedTime); + } + } + + } + + @GuardedBy("mResultsLock") + private void assertResults(List<Boolean> results) { + if (!wait(mReceivedResults, WAIT_TIME_MS)) { + try { + CtsWindowInfoUtils.dumpWindowsOnScreen(TAG, "test " + mName.getMethodName()); + } catch (InterruptedException e) { + Log.d(TAG, "Couldn't dump windows", e); + } + Assert.fail("Timed out waiting for results mReceivedResults.count=" + + mReceivedResults.getCount() + "mReceivedResults=" + mReceivedResults); + } + + // Make sure we received the results + assertEquals(results.toArray(), mResults.toArray()); + } + + public static class TestActivity extends Activity { + } +} diff --git a/tests/Internal/Android.bp b/tests/Internal/Android.bp index ddec8fa1d70a..a4877999ff6f 100644 --- a/tests/Internal/Android.bp +++ b/tests/Internal/Android.bp @@ -27,3 +27,16 @@ android_test { platform_apis: true, test_suites: ["device-tests"], } + +android_ravenwood_test { + name: "InternalTestsRavenwood", + static_libs: [ + "androidx.annotation_annotation", + "androidx.test.rules", + "platform-test-annotations", + ], + srcs: [ + "src/com/android/internal/util/ParcellingTests.java", + ], + auto_gen_config: true, +} diff --git a/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/Exceptions.kt b/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/Exceptions.kt index 207ba52685f8..910bf59b3d8d 100644 --- a/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/Exceptions.kt +++ b/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/Exceptions.kt @@ -46,3 +46,7 @@ class UnknownApiException(message: String) : Exception(message), UserErrorExcept */ class InvalidAnnotationException(message: String) : Exception(message), UserErrorException +/** + * We use this for general "user" errors. + */ +class HostStubGenUserErrorException(message: String) : Exception(message), UserErrorException diff --git a/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/HostStubGen.kt b/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/HostStubGen.kt index 4db583f109d2..97e09b817ef6 100644 --- a/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/HostStubGen.kt +++ b/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/HostStubGen.kt @@ -128,7 +128,7 @@ class HostStubGen(val options: HostStubGenOptions) { } val end = System.currentTimeMillis() - log.v("Done reading class structure in %.1f second(s).", (end - start) / 1000.0) + log.i("Done reading class structure in %.1f second(s).", (end - start) / 1000.0) return allClasses } diff --git a/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/HostStubGenErrors.kt b/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/HostStubGenErrors.kt index 9df04892ddbd..6b01d48b52b1 100644 --- a/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/HostStubGenErrors.kt +++ b/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/HostStubGenErrors.kt @@ -15,10 +15,10 @@ */ package com.android.hoststubgen -class HostStubGenErrors { - fun onErrorFound(message: String) { - // For now, we just throw as soon as any error is found, but eventually we should keep +open class HostStubGenErrors { + open fun onErrorFound(message: String) { + // TODO: For now, we just throw as soon as any error is found, but eventually we should keep // all errors and print them at the end. - throw RuntimeException(message) + throw HostStubGenUserErrorException(message) } }
\ No newline at end of file diff --git a/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/asm/AsmUtils.kt b/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/asm/AsmUtils.kt index 6262fa19141c..0579c2bb0525 100644 --- a/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/asm/AsmUtils.kt +++ b/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/asm/AsmUtils.kt @@ -196,6 +196,29 @@ fun isVisibilityPrivateOrPackagePrivate(access: Int): Boolean { } } +enum class Visibility { + PRIVATE, + PACKAGE_PRIVATE, + PROTECTED, + PUBLIC; + + companion object { + fun fromAccess(access: Int): Visibility { + if ((access and Opcodes.ACC_PUBLIC) != 0) { + return PUBLIC + } + if ((access and Opcodes.ACC_PROTECTED) != 0) { + return PROTECTED + } + if ((access and Opcodes.ACC_PRIVATE) != 0) { + return PRIVATE + } + + return PACKAGE_PRIVATE + } + } +} + fun ClassNode.isEnum(): Boolean { return (this.access and Opcodes.ACC_ENUM) != 0 } @@ -212,6 +235,10 @@ fun MethodNode.isSynthetic(): Boolean { return (this.access and Opcodes.ACC_SYNTHETIC) != 0 } +fun MethodNode.isStatic(): Boolean { + return (this.access and Opcodes.ACC_STATIC) != 0 +} + fun FieldNode.isEnum(): Boolean { return (this.access and Opcodes.ACC_ENUM) != 0 } @@ -220,6 +247,19 @@ fun FieldNode.isSynthetic(): Boolean { return (this.access and Opcodes.ACC_SYNTHETIC) != 0 } +fun ClassNode.getVisibility(): Visibility { + return Visibility.fromAccess(this.access) +} + +fun MethodNode.getVisibility(): Visibility { + return Visibility.fromAccess(this.access) +} + +fun FieldNode.getVisibility(): Visibility { + return Visibility.fromAccess(this.access) +} + + /* Dump of the members of TinyFrameworkEnumSimple: diff --git a/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/visitors/BaseAdapter.kt b/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/visitors/BaseAdapter.kt index 18dd4c25368a..21cfd4bcd0d8 100644 --- a/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/visitors/BaseAdapter.kt +++ b/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/visitors/BaseAdapter.kt @@ -17,8 +17,8 @@ package com.android.hoststubgen.visitors import com.android.hoststubgen.HostStubGenErrors import com.android.hoststubgen.LogLevel -import com.android.hoststubgen.asm.UnifiedVisitor import com.android.hoststubgen.asm.ClassNodes +import com.android.hoststubgen.asm.UnifiedVisitor import com.android.hoststubgen.asm.getPackageNameFromClassName import com.android.hoststubgen.asm.resolveClassName import com.android.hoststubgen.asm.toJvmClassName @@ -178,7 +178,9 @@ abstract class BaseAdapter ( log.d("visitMethod: %s%s [%x] [%s] Policy: %s", name, descriptor, access, signature, p) log.withIndent { - // If it's a substitute-to method, then skip. + // If it's a substitute-from method, then skip (== remove). + // Instead of this method, we rename the substitute-to method with the original + // name, in the "Maybe rename the method" part below. val policy = filter.getPolicyForMethod(currentClassName, name, descriptor) if (policy.policy.isSubstitute) { log.d("Skipping %s%s %s", name, descriptor, policy) @@ -191,9 +193,19 @@ abstract class BaseAdapter ( // Maybe rename the method. val newName: String - val substituteTo = filter.getRenameTo(currentClassName, name, descriptor) - if (substituteTo != null) { - newName = substituteTo + val renameTo = filter.getRenameTo(currentClassName, name, descriptor) + if (renameTo != null) { + newName = renameTo + + // It's confusing, but here, `newName` is the original method name + // (the one with the @substitute/replace annotation). + // `name` is the name of the method we're currently visiting, so it's usually a + // "...$ravewnwood" name. + if (!checkSubstitutionMethodCompatibility( + classes, currentClassName, newName, name, descriptor, options.errors)) { + return null + } + log.v("Emitting %s.%s%s as %s %s", currentClassName, name, descriptor, newName, policy) } else { @@ -203,12 +215,12 @@ abstract class BaseAdapter ( // Let subclass update the flag. // But note, we only use it when calling the super's method, - // but not for visitMethodInner(), beucase when subclass wants to change access, + // but not for visitMethodInner(), because when subclass wants to change access, // it can do so inside visitMethodInner(). val newAccess = updateAccessFlags(access, name, descriptor) val ret = visitMethodInner(access, newName, descriptor, signature, exceptions, policy, - substituteTo != null, + renameTo != null, super.visitMethod(newAccess, newName, descriptor, signature, exceptions)) ret?.let { diff --git a/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/visitors/Helper.kt b/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/visitors/Helper.kt new file mode 100644 index 000000000000..9d66c32e76ee --- /dev/null +++ b/tools/hoststubgen/hoststubgen/src/com/android/hoststubgen/visitors/Helper.kt @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2023 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.hoststubgen.visitors + +import com.android.hoststubgen.HostStubGenErrors +import com.android.hoststubgen.asm.ClassNodes +import com.android.hoststubgen.asm.getVisibility +import com.android.hoststubgen.asm.isStatic + +/** + * Make sure substitution from and to methods have matching definition. + * (static-ness, visibility.) + */ +fun checkSubstitutionMethodCompatibility( + classes: ClassNodes, + className: String, + fromMethodName: String, // the one with the annotation + toMethodName: String, // the one with either a "_host" or "$ravenwood" prefix. (typically) + descriptor: String, + errors: HostStubGenErrors, +): Boolean { + val from = classes.findMethod(className, fromMethodName, descriptor) + if (from == null) { + errors.onErrorFound( + "Substitution-from method not found: $className.$fromMethodName$descriptor") + return false + } + val to = classes.findMethod(className, toMethodName, descriptor) + if (to == null) { + // This shouldn't happen, because the visitor visited this method... + errors.onErrorFound( + "Substitution-to method not found: $className.$toMethodName$descriptor") + return false + } + + if (from.isStatic() != to.isStatic()) { + errors.onErrorFound( + "Substitution method must have matching static-ness: " + + "$className.$fromMethodName$descriptor") + return false + } + if (from.getVisibility().ordinal > to.getVisibility().ordinal) { + errors.onErrorFound( + "Substitution method cannot have smaller visibility than original: " + + "$className.$fromMethodName$descriptor") + return false + } + + return true +} diff --git a/tools/hoststubgen/hoststubgen/test/com/android/hoststubgen/utils/AsmUtilsTest.kt b/tools/hoststubgen/hoststubgen/test/com/android/hoststubgen/asm/AsmUtilsTest.kt index 66624d17ab54..6b46c84bd0bb 100644 --- a/tools/hoststubgen/hoststubgen/test/com/android/hoststubgen/utils/AsmUtilsTest.kt +++ b/tools/hoststubgen/hoststubgen/test/com/android/hoststubgen/asm/AsmUtilsTest.kt @@ -13,11 +13,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.android.hoststubgen.utils +package com.android.hoststubgen.asm -import com.android.hoststubgen.asm.getDirectOuterClassName import com.google.common.truth.Truth.assertThat import org.junit.Test +import org.objectweb.asm.Opcodes.ACC_PRIVATE +import org.objectweb.asm.Opcodes.ACC_PROTECTED +import org.objectweb.asm.Opcodes.ACC_PUBLIC +import org.objectweb.asm.Opcodes.ACC_STATIC class AsmUtilsTest { private fun checkGetDirectOuterClassName(input: String, expected: String?) { @@ -31,4 +34,16 @@ class AsmUtilsTest { checkGetDirectOuterClassName("a.b.c\$x", "a.b.c") checkGetDirectOuterClassName("a.b.c\$x\$y", "a.b.c\$x") } + + @Test + fun testVisibility() { + fun test(access: Int, expected: Visibility) { + assertThat(Visibility.fromAccess(access)).isEqualTo(expected) + } + + test(ACC_PUBLIC or ACC_STATIC, Visibility.PUBLIC) + test(ACC_PRIVATE or ACC_STATIC, Visibility.PRIVATE) + test(ACC_PROTECTED or ACC_STATIC, Visibility.PROTECTED) + test(ACC_STATIC, Visibility.PACKAGE_PRIVATE) + } }
\ No newline at end of file diff --git a/tools/hoststubgen/hoststubgen/test/com/android/hoststubgen/visitors/HelperTest.kt b/tools/hoststubgen/hoststubgen/test/com/android/hoststubgen/visitors/HelperTest.kt new file mode 100644 index 000000000000..0ea90ed2fbf0 --- /dev/null +++ b/tools/hoststubgen/hoststubgen/test/com/android/hoststubgen/visitors/HelperTest.kt @@ -0,0 +1,102 @@ +/* + * Copyright (C) 2023 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.hoststubgen.visitors + +import com.android.hoststubgen.HostStubGenErrors +import com.android.hoststubgen.asm.ClassNodes +import com.google.common.truth.Truth.assertThat +import org.junit.Test +import org.objectweb.asm.Opcodes +import org.objectweb.asm.tree.ClassNode +import org.objectweb.asm.tree.MethodNode + +class HelperTest { + @Test + fun testCheckSubstitutionMethodCompatibility() { + val errors = object : HostStubGenErrors() { + override fun onErrorFound(message: String) { + // Don't throw + } + } + + val cn = ClassNode().apply { + name = "ClassName" + methods = ArrayList() + } + + val descriptor = "()V" + + val staticPublic = MethodNode().apply { + name = "staticPublic" + access = Opcodes.ACC_STATIC or Opcodes.ACC_PUBLIC + desc = descriptor + cn.methods.add(this) + } + + val staticPrivate = MethodNode().apply { + name = "staticPrivate" + access = Opcodes.ACC_STATIC or Opcodes.ACC_PRIVATE + desc = descriptor + cn.methods.add(this) + } + + val nonStaticPublic = MethodNode().apply { + name = "nonStaticPublic" + access = Opcodes.ACC_PUBLIC + desc = descriptor + cn.methods.add(this) + } + + val nonStaticPProtected = MethodNode().apply { + name = "nonStaticPProtected" + access = 0 + desc = descriptor + cn.methods.add(this) + } + + val classes = ClassNodes().apply { + addClass(cn) + } + + fun check(from: MethodNode?, to: MethodNode?, expected: Boolean) { + assertThat(checkSubstitutionMethodCompatibility( + classes, + cn.name, + (from?.name ?: "**nonexistentmethodname**"), + (to?.name ?: "**nonexistentmethodname**"), + descriptor, + errors, + )).isEqualTo(expected) + } + + check(staticPublic, staticPublic, true) + check(staticPrivate, staticPrivate, true) + check(nonStaticPublic, nonStaticPublic, true) + check(nonStaticPProtected, nonStaticPProtected, true) + + check(staticPublic, null, false) + check(null, staticPublic, false) + + check(staticPublic, nonStaticPublic, false) + check(nonStaticPublic, staticPublic, false) + + check(staticPublic, staticPrivate, false) + check(staticPrivate, staticPublic, true) + + check(nonStaticPublic, nonStaticPProtected, false) + check(nonStaticPProtected, nonStaticPublic, true) + } +}
\ No newline at end of file |