Merge "Store last deactivation & manual deactivation timestamps in ZenRule as well" into main (52f8f787) · Commits · e / os / android_frameworks_base

core/java/android/service/notification/ZenModeConfig.java

+48 −3

Original line number	Diff line number	Diff line
		@@ -312,6 +312,8 @@ public class ZenModeConfig implements Parcelable {
		private static final String RULE_ATT_CONDITION_OVERRIDE = "conditionOverride";
		private static final String RULE_ATT_LAST_ACTIVATION = "lastActivation";
		private static final String RULE_ATT_LAST_MANUAL_ACTIVATION = "lastManualActivation";
		private static final String RULE_ATT_LAST_DEACTIVATION = "lastDeactivation";
		private static final String RULE_ATT_LAST_MANUAL_DEACTIVATION = "lastManualDeactivation";

		private static final String DEVICE_EFFECT_DISPLAY_GRAYSCALE = "zdeDisplayGrayscale";
		private static final String DEVICE_EFFECT_SUPPRESS_AMBIENT_DISPLAY =
		@@ -1212,6 +1214,9 @@ public class ZenModeConfig implements Parcelable {
		if (Flags.modesUiTileReactivatesLast()) {
		rt.lastManualActivation = safeInstant(parser, RULE_ATT_LAST_MANUAL_ACTIVATION,
		null);
		rt.lastDeactivation = safeInstant(parser, RULE_ATT_LAST_DEACTIVATION, null);
		rt.lastManualDeactivation = safeInstant(parser, RULE_ATT_LAST_MANUAL_DEACTIVATION,
		null);
		}
		}

		@@ -1277,6 +1282,10 @@ public class ZenModeConfig implements Parcelable {
		if (Flags.modesUiTileReactivatesLast()) {
		writeXmlAttributeInstant(out, RULE_ATT_LAST_MANUAL_ACTIVATION,
		rule.lastManualActivation);
		writeXmlAttributeInstant(out, RULE_ATT_LAST_DEACTIVATION,
		rule.lastDeactivation);
		writeXmlAttributeInstant(out, RULE_ATT_LAST_MANUAL_DEACTIVATION,
		rule.lastManualDeactivation);
		}
		}
		}
		@@ -2660,6 +2669,28 @@ public class ZenModeConfig implements Parcelable {
		@Nullable
		public Instant lastManualActivation;

		/**
		* Last time at which the rule was deactivated (for any reason, including overrides).
		* If {@code null}, the rule has never been deactivated since its creation.
		*
		* <p>Note that this was previously untracked, so it will also be {@code null} for rules
		* created before we started tracking and never deactivated since.
		*/
		@Nullable
		public Instant lastDeactivation;

		/**
		* Last time at which the rule was manually deactivated (whether as a user action in
		* Settings or SystemUI, or from the owner package with
		* {@link Condition#SOURCE_USER_ACTION}). If {@code null}, the rule has never been manually
		* deactivated since its creation.
		*
		* <p>Note that this was previously untracked, so it will also be {@code null} for rules
		* created before we started tracking and never deactivated since.
		*/
		@Nullable
		public Instant lastManualDeactivation;

		public ZenRule() { }

		public ZenRule(Parcel source) {
		@@ -2706,6 +2737,12 @@ public class ZenModeConfig implements Parcelable {
		if (source.readInt() == 1) {
		lastManualActivation = Instant.ofEpochMilli(source.readLong());
		}
		if (source.readInt() == 1) {
		lastDeactivation = Instant.ofEpochMilli(source.readLong());
		}
		if (source.readInt() == 1) {
		lastManualDeactivation = Instant.ofEpochMilli(source.readLong());
		}
		}
		}
		}
		@@ -2780,6 +2817,8 @@ public class ZenModeConfig implements Parcelable {
		}
		if (Flags.modesUiTileReactivatesLast()) {
		writeInstantToParcel(dest, lastManualActivation);
		writeInstantToParcel(dest, lastDeactivation);
		writeInstantToParcel(dest, lastManualDeactivation);
		}
		}
		}
		@@ -2847,6 +2886,8 @@ public class ZenModeConfig implements Parcelable {
		}
		if (Flags.modesUiTileReactivatesLast()) {
		sb.append(",lastManualActivation=").append(lastManualActivation);
		sb.append(",lastDeactivation=").append(lastDeactivation);
		sb.append(",lastManualDeactivation=").append(lastManualDeactivation);
		}
		}

		@@ -2932,7 +2973,9 @@ public class ZenModeConfig implements Parcelable {
		}
		if (Flags.modesUiTileReactivatesLast()) {
		finalEquals = finalEquals
		&& Objects.equals(other.lastManualActivation, lastManualActivation);
		&& Objects.equals(other.lastManualActivation, lastManualActivation)
		&& Objects.equals(other.lastDeactivation, lastDeactivation)
		&& Objects.equals(other.lastManualDeactivation, lastManualDeactivation);
		}
		}

		@@ -2949,7 +2992,8 @@ public class ZenModeConfig implements Parcelable {
		triggerDescription, type, userModifiedFields,
		zenPolicyUserModifiedFields, zenDeviceEffectsUserModifiedFields,
		deletionInstant, disabledOrigin, legacySuppressedEffects,
		conditionOverride, lastActivation, lastManualActivation);
		conditionOverride, lastActivation, lastManualActivation,
		lastDeactivation, lastManualDeactivation);
		} else if (Flags.modesCleanupImplicit() && !Flags.modesUiTileReactivatesLast()) {
		return Objects.hash(enabled, snoozing, name, zenMode, conditionId, condition,
		component, configurationActivity, pkg, id, enabler, zenPolicy,
		@@ -2965,7 +3009,8 @@ public class ZenModeConfig implements Parcelable {
		triggerDescription, type, userModifiedFields,
		zenPolicyUserModifiedFields, zenDeviceEffectsUserModifiedFields,
		deletionInstant, disabledOrigin, legacySuppressedEffects,
		conditionOverride, lastManualActivation);
		conditionOverride, lastManualActivation, lastDeactivation,
		lastManualDeactivation);
		} else {
		return Objects.hash(enabled, snoozing, name, zenMode, conditionId, condition,
		component, configurationActivity, pkg, id, enabler, zenPolicy,

services/core/java/com/android/server/notification/ZenModeHelper.java

+16 −2

Original line number	Diff line number	Diff line
		@@ -2116,8 +2116,7 @@ public class ZenModeHelper {
		boolean isManualOrigin =
		origin == ORIGIN_USER_IN_SYSTEMUI \|\| origin == ORIGIN_USER_IN_APP;
		if (Flags.modesUi()
		&& (Flags.modesCleanupImplicit()
		\|\| (Flags.modesUiTileReactivatesLast() && isManualOrigin))) {
		&& (Flags.modesCleanupImplicit() \|\| Flags.modesUiTileReactivatesLast())) {
		if (!mConfig.isManualActive() && config.isManualActive()) {
		if (Flags.modesCleanupImplicit()) {
		config.manualRule.lastActivation = now;
		@@ -2125,6 +2124,13 @@ public class ZenModeHelper {
		if (Flags.modesUiTileReactivatesLast() && isManualOrigin) {
		config.manualRule.lastManualActivation = now;
		}
		} else if (mConfig.isManualActive() && !config.isManualActive()) {
		if (Flags.modesUiTileReactivatesLast()) {
		config.manualRule.lastDeactivation = now;
		if (isManualOrigin) {
		config.manualRule.lastManualDeactivation = now;
		}
		}
		}
		for (ZenRule rule : config.automaticRules.values()) {
		ZenRule previousRule = mConfig.automaticRules.get(rule.id);
		@@ -2135,6 +2141,14 @@ public class ZenModeHelper {
		if (Flags.modesUiTileReactivatesLast() && isManualOrigin) {
		rule.lastManualActivation = now;
		}
		} else if (!rule.isActive() && previousRule != null
		&& previousRule.isActive()) {
		if (Flags.modesUiTileReactivatesLast()) {
		rule.lastDeactivation = now;
		if (isManualOrigin) {
		rule.lastManualDeactivation = now;
		}
		}
		}
		}
		}

services/tests/uiservicestests/src/com/android/server/notification/ZenModeConfigTest.java

+12 −0

Original line number	Diff line number	Diff line
		@@ -568,6 +568,8 @@ public class ZenModeConfigTest extends UiServiceTestCase {
		}
		if (Flags.modesUiTileReactivatesLast()) {
		rule.lastManualActivation = Instant.ofEpochMilli(789);
		rule.lastDeactivation = Instant.ofEpochMilli(876);
		rule.lastManualDeactivation = Instant.ofEpochMilli(543);
		}
		}
		config.automaticRules.put(rule.id, rule);
		@@ -611,6 +613,8 @@ public class ZenModeConfigTest extends UiServiceTestCase {
		}
		if (Flags.modesUiTileReactivatesLast()) {
		assertEquals(rule.lastManualActivation, ruleActual.lastManualActivation);
		assertEquals(rule.lastDeactivation, ruleActual.lastDeactivation);
		assertEquals(rule.lastManualDeactivation, ruleActual.lastManualDeactivation);
		}
		}
		if (Flags.backupRestoreLogging()) {
		@@ -650,6 +654,8 @@ public class ZenModeConfigTest extends UiServiceTestCase {
		}
		if (Flags.modesUiTileReactivatesLast()) {
		rule.lastManualActivation = Instant.ofEpochMilli(123);
		rule.lastDeactivation = Instant.ofEpochMilli(296);
		rule.lastManualDeactivation = Instant.ofEpochMilli(481);
		}
		}

		@@ -687,6 +693,8 @@ public class ZenModeConfigTest extends UiServiceTestCase {
		}
		if (Flags.modesUiTileReactivatesLast()) {
		assertEquals(rule.lastManualActivation, parceled.lastManualActivation);
		assertEquals(rule.lastDeactivation, parceled.lastDeactivation);
		assertEquals(rule.lastManualDeactivation, parceled.lastManualDeactivation);
		}
		}

		@@ -775,6 +783,8 @@ public class ZenModeConfigTest extends UiServiceTestCase {
		}
		if (Flags.modesUiTileReactivatesLast()) {
		rule.lastManualActivation = Instant.ofEpochMilli(456);
		rule.lastDeactivation = Instant.ofEpochMilli(285);
		rule.lastManualDeactivation = Instant.ofEpochMilli(301);
		}
		}

		@@ -816,6 +826,8 @@ public class ZenModeConfigTest extends UiServiceTestCase {
		}
		if (Flags.modesUiTileReactivatesLast()) {
		assertEquals(rule.lastManualActivation, fromXml.lastManualActivation);
		assertEquals(rule.lastDeactivation, fromXml.lastDeactivation);
		assertEquals(rule.lastManualDeactivation, fromXml.lastManualDeactivation);
		}
		}
		}

services/tests/uiservicestests/src/com/android/server/notification/ZenModeDiffTest.java

+2 −1

Original line number	Diff line number	Diff line
		@@ -476,7 +476,8 @@ public class ZenModeDiffTest extends UiServiceTestCase {
		Set<String> exemptFields = new LinkedHashSet<>(
		Set.of("userModifiedFields", "zenPolicyUserModifiedFields",
		"zenDeviceEffectsUserModifiedFields", "deletionInstant", "disabledOrigin",
		"lastActivation", "lastManualActivation"));
		"lastActivation", "lastManualActivation", "lastDeactivation",
		"lastManualDeactivation"));
		// Flagged fields are only compared if their flag is on.
		if (Flags.modesUi()) {
		exemptFields.add(RuleDiff.FIELD_SNOOZING); // Obsolete.

services/tests/uiservicestests/src/com/android/server/notification/ZenModeHelperTest.java

+101 −15

Original line number	Diff line number	Diff line
		@@ -7379,7 +7379,6 @@ public class ZenModeHelperTest extends UiServiceTestCase {
		ORIGIN_APP, "reason", CUSTOM_PKG_UID);

		assertThat(getZenRule(ruleOne).lastActivation).isNull();
		assertThat(getZenRule(ruleTwo).lastActivation).isNull();

		// Activate automatically from app
		Instant firstActivation = Instant.ofEpochMilli(100);
		@@ -7389,18 +7388,19 @@ public class ZenModeHelperTest extends UiServiceTestCase {

		assertThat(getZenRule(ruleOne).lastActivation).isEqualTo(firstActivation);
		assertThat(getZenRule(ruleOne).lastManualActivation).isNull();
		assertThat(getZenRule(ruleTwo).lastActivation).isNull();
		assertThat(getZenRule(ruleTwo).lastManualActivation).isNull();
		assertThat(getZenRule(ruleOne).lastDeactivation).isNull();
		assertThat(getZenRule(ruleOne).lastManualDeactivation).isNull();

		// Deactivate automatically
		mTestClock.setNow(Instant.ofEpochMilli(200));
		Instant firstDeactivation = Instant.ofEpochMilli(200);
		mTestClock.setNow(firstDeactivation);
		mZenModeHelper.setAutomaticZenRuleState(UserHandle.CURRENT, ruleOne, CONDITION_FALSE,
		ORIGIN_APP, CUSTOM_PKG_UID);

		assertThat(getZenRule(ruleOne).lastActivation).isEqualTo(firstActivation);
		assertThat(getZenRule(ruleOne).lastManualActivation).isNull();
		assertThat(getZenRule(ruleTwo).lastActivation).isNull();
		assertThat(getZenRule(ruleTwo).lastManualActivation).isNull();
		assertThat(getZenRule(ruleOne).lastDeactivation).isEqualTo(firstDeactivation);
		assertThat(getZenRule(ruleOne).lastManualDeactivation).isNull();

		// Activate manually from SystemUI
		Instant firstManualActivation = Instant.ofEpochMilli(300);
		@@ -7410,18 +7410,19 @@ public class ZenModeHelperTest extends UiServiceTestCase {

		assertThat(getZenRule(ruleOne).lastActivation).isEqualTo(firstManualActivation);
		assertThat(getZenRule(ruleOne).lastManualActivation).isEqualTo(firstManualActivation);
		assertThat(getZenRule(ruleTwo).lastActivation).isNull();
		assertThat(getZenRule(ruleTwo).lastManualActivation).isNull();
		assertThat(getZenRule(ruleOne).lastDeactivation).isEqualTo(firstDeactivation);
		assertThat(getZenRule(ruleOne).lastManualDeactivation).isNull();

		// Deactivate manually from SystemUI
		mTestClock.setNow(Instant.ofEpochMilli(400));
		Instant firstManualDeactivation = Instant.ofEpochMilli(400);
		mTestClock.setNow(firstManualDeactivation);
		mZenModeHelper.setAutomaticZenRuleState(UserHandle.CURRENT, ruleOne, CONDITION_FALSE,
		ORIGIN_USER_IN_SYSTEMUI, CUSTOM_PKG_UID);

		assertThat(getZenRule(ruleOne).lastActivation).isEqualTo(firstManualActivation);
		assertThat(getZenRule(ruleOne).lastManualActivation).isEqualTo(firstManualActivation);
		assertThat(getZenRule(ruleTwo).lastActivation).isNull();
		assertThat(getZenRule(ruleTwo).lastManualActivation).isNull();
		assertThat(getZenRule(ruleOne).lastDeactivation).isEqualTo(firstManualDeactivation);
		assertThat(getZenRule(ruleOne).lastManualDeactivation).isEqualTo(firstManualDeactivation);

		// Second activation, automatic from app again
		Instant secondActivation = Instant.ofEpochMilli(500);
		@@ -7431,22 +7432,101 @@ public class ZenModeHelperTest extends UiServiceTestCase {

		assertThat(getZenRule(ruleOne).lastActivation).isEqualTo(secondActivation);
		assertThat(getZenRule(ruleOne).lastManualActivation).isEqualTo(firstManualActivation);
		assertThat(getZenRule(ruleOne).lastDeactivation).isEqualTo(firstManualDeactivation);
		assertThat(getZenRule(ruleOne).lastManualDeactivation).isEqualTo(firstManualDeactivation);

		// Second deactivation, automatic from app again
		Instant secondDeactivation = Instant.ofEpochMilli(600);
		mTestClock.setNow(secondDeactivation);
		mZenModeHelper.setAutomaticZenRuleState(UserHandle.CURRENT, ruleOne, CONDITION_FALSE,
		ORIGIN_APP, CUSTOM_PKG_UID);

		assertThat(getZenRule(ruleOne).lastActivation).isEqualTo(secondActivation);
		assertThat(getZenRule(ruleOne).lastManualActivation).isEqualTo(firstManualActivation);
		assertThat(getZenRule(ruleOne).lastDeactivation).isEqualTo(secondDeactivation);
		assertThat(getZenRule(ruleOne).lastManualDeactivation).isEqualTo(firstManualDeactivation);

		// Unrelated rules are not affected
		assertThat(getZenRule(ruleTwo).lastActivation).isNull();
		assertThat(getZenRule(ruleTwo).lastManualActivation).isNull();
		assertThat(getZenRule(ruleTwo).lastDeactivation).isNull();
		assertThat(getZenRule(ruleTwo).lastManualDeactivation).isNull();
		}

		@Test
		@EnableFlags({FLAG_MODES_UI, FLAG_MODES_CLEANUP_IMPLICIT, FLAG_MODES_UI_TILE_REACTIVATES_LAST})
		public void setAutomaticZenRuleState_manualFromApp_updatesLastManualActivation() {
		String rule = mZenModeHelper.addAutomaticZenRule(UserHandle.CURRENT, mPkg,
		new AutomaticZenRule.Builder("rule", CONDITION_ID)
		.setConfigurationActivity(new ComponentName(mPkg, "cls"))
		.setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
		.build(),
		ORIGIN_APP, "reason", CUSTOM_PKG_UID);

		assertThat(getZenRule(rule).lastManualActivation).isNull();
		assertThat(getZenRule(rule).lastManualDeactivation).isNull();

		Instant manualOn = Instant.ofEpochMilli(100);
		mTestClock.setNow(manualOn);
		mZenModeHelper.setAutomaticZenRuleState(UserHandle.CURRENT, rule,
		new Condition(CONDITION_ID, "on", STATE_TRUE, SOURCE_USER_ACTION),
		ORIGIN_USER_IN_APP, CUSTOM_PKG_UID);

		assertThat(getZenRule(rule).lastManualActivation).isEqualTo(manualOn);
		assertThat(getZenRule(rule).lastManualDeactivation).isNull();

		Instant manualOff = Instant.ofEpochMilli(200);
		mTestClock.setNow(manualOff);
		mZenModeHelper.setAutomaticZenRuleState(UserHandle.CURRENT, rule,
		new Condition(CONDITION_ID, "off", STATE_FALSE, SOURCE_USER_ACTION),
		ORIGIN_USER_IN_APP, CUSTOM_PKG_UID);

		assertThat(getZenRule(rule).lastManualActivation).isEqualTo(manualOn);
		assertThat(getZenRule(rule).lastManualDeactivation).isEqualTo(manualOff);

		Instant autoOn = Instant.ofEpochMilli(300);
		mTestClock.setNow(autoOn);
		mZenModeHelper.setAutomaticZenRuleState(UserHandle.CURRENT, rule,
		new Condition(CONDITION_ID, "auto on", STATE_TRUE, SOURCE_CONTEXT),
		ORIGIN_APP, CUSTOM_PKG_UID);
		Instant autoOff = Instant.ofEpochMilli(400);
		mTestClock.setNow(autoOff);
		mZenModeHelper.setAutomaticZenRuleState(UserHandle.CURRENT, rule,
		new Condition(CONDITION_ID, "auto off", STATE_FALSE, SOURCE_CONTEXT),
		ORIGIN_APP, CUSTOM_PKG_UID);

		assertThat(getZenRule(rule).lastManualActivation).isEqualTo(manualOn);
		assertThat(getZenRule(rule).lastManualDeactivation).isEqualTo(manualOff);

		assertThat(getZenRule(rule).lastActivation).isEqualTo(autoOn);
		assertThat(getZenRule(rule).lastDeactivation).isEqualTo(autoOff);
		}

		@Test
		@EnableFlags({FLAG_MODES_UI, FLAG_MODES_CLEANUP_IMPLICIT, FLAG_MODES_UI_TILE_REACTIVATES_LAST})
		public void setManualZenMode_updatesLastActivation() {
		assertThat(mZenModeHelper.mConfig.manualRule.lastActivation).isNull();
		Instant instant = Instant.ofEpochMilli(100);
		mTestClock.setNow(instant);
		assertThat(mZenModeHelper.mConfig.manualRule.lastDeactivation).isNull();

		Instant nowOn = Instant.ofEpochMilli(100);
		mTestClock.setNow(nowOn);
		mZenModeHelper.setManualZenMode(UserHandle.CURRENT, ZEN_MODE_ALARMS, null,
		ORIGIN_USER_IN_SYSTEMUI, "reason", "systemui", SYSTEM_UID);

		assertThat(mZenModeHelper.mConfig.manualRule.lastActivation).isEqualTo(instant);
		assertThat(mZenModeHelper.mConfig.manualRule.lastManualActivation).isEqualTo(instant);
		assertThat(mZenModeHelper.mConfig.manualRule.lastActivation).isEqualTo(nowOn);
		assertThat(mZenModeHelper.mConfig.manualRule.lastManualActivation).isEqualTo(nowOn);
		assertThat(mZenModeHelper.mConfig.manualRule.lastDeactivation).isNull();
		assertThat(mZenModeHelper.mConfig.manualRule.lastManualDeactivation).isNull();

		Instant nowOff = Instant.ofEpochMilli(100);
		mTestClock.setNow(nowOff);
		mZenModeHelper.setManualZenMode(UserHandle.CURRENT, ZEN_MODE_OFF, null,
		ORIGIN_USER_IN_SYSTEMUI, "reason", "systemui", SYSTEM_UID);

		assertThat(mZenModeHelper.mConfig.manualRule.lastActivation).isEqualTo(nowOn);
		assertThat(mZenModeHelper.mConfig.manualRule.lastManualActivation).isEqualTo(nowOn);
		assertThat(mZenModeHelper.mConfig.manualRule.lastDeactivation).isEqualTo(nowOff);
		assertThat(mZenModeHelper.mConfig.manualRule.lastManualDeactivation).isEqualTo(nowOff);
		}

		@Test
		@@ -7507,6 +7587,8 @@ public class ZenModeHelperTest extends UiServiceTestCase {

		assertThat(getZenRule(ruleId).lastActivation).isNull();
		assertThat(getZenRule(ruleId).lastManualActivation).isNull();
		assertThat(getZenRule(ruleId).lastDeactivation).isNull();
		assertThat(getZenRule(ruleId).lastManualDeactivation).isNull();

		mZenModeHelper.updateAutomaticZenRule(UserHandle.CURRENT, ruleId,
		new AutomaticZenRule.Builder(azr).setName("New name").build(), ORIGIN_APP, "reason",
		@@ -7514,6 +7596,8 @@ public class ZenModeHelperTest extends UiServiceTestCase {

		assertThat(getZenRule(ruleId).lastActivation).isNull();
		assertThat(getZenRule(ruleId).lastManualActivation).isNull();
		assertThat(getZenRule(ruleId).lastDeactivation).isNull();
		assertThat(getZenRule(ruleId).lastManualDeactivation).isNull();
		}

		private static void addZenRule(ZenModeConfig config, String id, String ownerPkg, int zenMode,
		@@ -7550,6 +7634,8 @@ public class ZenModeHelperTest extends UiServiceTestCase {
		copy.zenDeviceEffectsUserModifiedFields = 0;
		copy.lastActivation = null;
		copy.lastManualActivation = null;
		copy.lastDeactivation = null;
		copy.lastManualDeactivation = null;
		return copy;
		} finally {
		p.recycle();