PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Introduce ZenModesBackend and ZenMode

Browse Source 
Test: atest ZenModesBackendTest ZenModeTest
Bug: 327419222
Change-Id: Ic2871a6124b2df4b77275b54a940f7b47666991c
This commit is contained in:
Matías Hernández
2024-04-08 18:50:32 +02:00
parent c365d864a5
commit 59c6a66f5c
4 changed files with 720 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

209
src/com/android/settings/notification/modes/ZenMode.java Normal file
View File

@@ -0,0 +1,209 @@
/*
* Copyright (C) 2024 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.settings.notification.modes;
import static android.app.NotificationManager.INTERRUPTION_FILTER_PRIORITY;
import static java.util.Objects.requireNonNull;
import android.app.AutomaticZenRule;
import android.app.NotificationManager;
import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.drawable.Drawable;
import android.service.notification.SystemZenRules;
import android.service.notification.ZenPolicy;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.content.res.AppCompatResources;
import com.android.settings.R;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Objects;
/**
* Represents either an {@link AutomaticZenRule} or the manual DND rule in a unified way.
*
* <p>It also adapts other rule features that we don't want to expose in the UI, such as
* interruption filters other than {@code PRIORITY}, rules without specific icons, etc.
*/
class ZenMode {
private static final String TAG = "ZenMode";
static final String MANUAL_DND_MODE_ID = "manual_dnd";
private static final ZenPolicy POLICY_INTERRUPTION_FILTER_ALL =
// TODO: b/331267485 - Support "allow all channels"!
new ZenPolicy.Builder().allowAllSounds().showAllVisualEffects().build();
// Must match com.android.server.notification.ZenModeHelper#applyCustomPolicy.
private static final ZenPolicy POLICY_INTERRUPTION_FILTER_ALARMS =
new ZenPolicy.Builder()
.disallowAllSounds()
.allowAlarms(true)
.allowMedia(true)
.allowPriorityChannels(false)
.build();
// Must match com.android.server.notification.ZenModeHelper#applyCustomPolicy.
private static final ZenPolicy POLICY_INTERRUPTION_FILTER_NONE =
new ZenPolicy.Builder()
.disallowAllSounds()
.hideAllVisualEffects()
.allowPriorityChannels(false)
.build();
private final String mId;
private final AutomaticZenRule mRule;
private final boolean mIsManualDnd;
ZenMode(String id, AutomaticZenRule rule) {
this(id, rule, false);
}
private ZenMode(String id, AutomaticZenRule rule, boolean isManualDnd) {
mId = id;
mRule = rule;
mIsManualDnd = isManualDnd;
}
static ZenMode manualDndMode(AutomaticZenRule dndPolicyAsRule) {
return new ZenMode(MANUAL_DND_MODE_ID, dndPolicyAsRule, true);
}
@NonNull
public String getId() {
return mId;
}
@NonNull
public AutomaticZenRule getRule() {
return mRule;
}
@NonNull
public ListenableFuture<Drawable> getIcon(@NonNull Context context) {
// TODO: b/333528586 - Load the icons asynchronously, and cache them
if (mIsManualDnd) {
return Futures.immediateFuture(
requireNonNull(context.getDrawable(R.drawable.ic_do_not_disturb_on_24dp)));
}
int iconResId = mRule.getIconResId();
Drawable customIcon = null;
if (iconResId != 0) {
if (SystemZenRules.PACKAGE_ANDROID.equals(mRule.getPackageName())) {
customIcon = context.getDrawable(mRule.getIconResId());
} else {
try {
Context appContext = context.createPackageContext(mRule.getPackageName(), 0);
customIcon = AppCompatResources.getDrawable(appContext, mRule.getIconResId());
} catch (PackageManager.NameNotFoundException e) {
Log.wtf(TAG,
"Package " + mRule.getPackageName() + " used in rule " + mId
+ " not found?", e);
// Continue down to use a default icon.
}
}
}
if (customIcon != null) {
return Futures.immediateFuture(customIcon);
}
// Derive a default icon from the rule type.
// TODO: b/333528437 - Use correct icons
int iconResIdFromType = switch (mRule.getType()) {
case AutomaticZenRule.TYPE_UNKNOWN -> R.drawable.ic_do_not_disturb_on_24dp;
case AutomaticZenRule.TYPE_OTHER -> R.drawable.ic_do_not_disturb_on_24dp;
case AutomaticZenRule.TYPE_SCHEDULE_TIME -> R.drawable.ic_do_not_disturb_on_24dp;
case AutomaticZenRule.TYPE_SCHEDULE_CALENDAR -> R.drawable.ic_do_not_disturb_on_24dp;
case AutomaticZenRule.TYPE_BEDTIME -> R.drawable.ic_do_not_disturb_on_24dp;
case AutomaticZenRule.TYPE_DRIVING -> R.drawable.ic_do_not_disturb_on_24dp;
case AutomaticZenRule.TYPE_IMMERSIVE -> R.drawable.ic_do_not_disturb_on_24dp;
case AutomaticZenRule.TYPE_THEATER -> R.drawable.ic_do_not_disturb_on_24dp;
case AutomaticZenRule.TYPE_MANAGED -> R.drawable.ic_do_not_disturb_on_24dp;
default -> R.drawable.ic_do_not_disturb_on_24dp;
};
return Futures.immediateFuture(requireNonNull(context.getDrawable(iconResIdFromType)));
}
@NonNull
public ZenPolicy getPolicy() {
switch (mRule.getInterruptionFilter()) {
case INTERRUPTION_FILTER_PRIORITY:
return requireNonNull(mRule.getZenPolicy());
case NotificationManager.INTERRUPTION_FILTER_ALL:
return POLICY_INTERRUPTION_FILTER_ALL;
case NotificationManager.INTERRUPTION_FILTER_ALARMS:
return POLICY_INTERRUPTION_FILTER_ALARMS;
case NotificationManager.INTERRUPTION_FILTER_NONE:
return POLICY_INTERRUPTION_FILTER_NONE;
case NotificationManager.INTERRUPTION_FILTER_UNKNOWN:
default:
Log.wtf(TAG, "Rule " + mId + " with unexpected interruptionFilter "
+ mRule.getInterruptionFilter());
return requireNonNull(mRule.getZenPolicy());
}
}
public void setZenPolicy(@NonNull ZenPolicy policy) {
// TODO: b/331267485 - A policy with apps=ALL should be mapped to INTERRUPTION_FILTER_ALL.
if (mRule.getInterruptionFilter() != INTERRUPTION_FILTER_PRIORITY) {
ZenPolicy currentPolicy = getPolicy();
if (!currentPolicy.equals(policy)) {
// If policy is customized from any of the "special" ones, make the rule PRIORITY.
mRule.setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY);
}
}
mRule.setZenPolicy(policy);
}
public boolean canBeDeleted() {
return !mIsManualDnd;
}
public boolean isManualDnd() {
return mIsManualDnd;
}
@Override
public boolean equals(@Nullable Object obj) {
return obj instanceof ZenMode other
&& mId.equals(other.mId)
&& mRule.equals(other.mRule);
}
@Override
public int hashCode() {
return Objects.hash(mId, mRule);
}
@Override
public String toString() {
return mId + " -> " + mRule;
}
}

161
src/com/android/settings/notification/modes/ZenModesBackend.java Normal file
View File

@@ -0,0 +1,161 @@
/*
* Copyright (C) 2024 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.settings.notification.modes;
import static java.util.Objects.requireNonNull;
import android.annotation.Nullable;
import android.app.ActivityManager;
import android.app.AutomaticZenRule;
import android.app.NotificationManager;
import android.content.Context;
import android.net.Uri;
import android.provider.Settings;
import android.service.notification.Condition;
import android.service.notification.ZenAdapters;
import android.service.notification.ZenModeConfig;
import com.android.settings.R;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* Class used for Settings-NMS interactions related to Mode management.
*
* <p>This class converts {@link AutomaticZenRule} instances, as well as the manual zen mode,
* into the unified {@link ZenMode} format.
*/
class ZenModesBackend {
private static final String TAG = "ZenModeBackend";
@Nullable // Until first usage
private static ZenModesBackend sInstance;
private final NotificationManager mNotificationManager;
private final Context mContext;
static ZenModesBackend getInstance(Context context) {
if (sInstance == null) {
sInstance = new ZenModesBackend(context.getApplicationContext());
}
return sInstance;
}
ZenModesBackend(Context context) {
mContext = context;
mNotificationManager = context.getSystemService(NotificationManager.class);
}
List<ZenMode> getModes() {
ArrayList<ZenMode> modes = new ArrayList<>();
modes.add(getManualDndMode());
Map<String, AutomaticZenRule> zenRules = mNotificationManager.getAutomaticZenRules();
for (Map.Entry<String, AutomaticZenRule> zenRuleEntry : zenRules.entrySet()) {
modes.add(new ZenMode(zenRuleEntry.getKey(), zenRuleEntry.getValue()));
}
// TODO: b/331429435 - Sort modes.
return modes;
}
@Nullable
ZenMode getMode(String id) {
if (ZenMode.MANUAL_DND_MODE_ID.equals(id)) {
return getManualDndMode();
} else {
AutomaticZenRule rule = mNotificationManager.getAutomaticZenRule(id);
return rule != null ? new ZenMode(id, rule) : null;
}
}
private ZenMode getManualDndMode() {
// TODO: b/333530553 - Read ZenDeviceEffects of manual DND.
// TODO: b/333682392 - Replace with final strings for name & trigger description
AutomaticZenRule manualDndRule = new AutomaticZenRule.Builder(
mContext.getString(R.string.zen_mode_settings_title), Uri.EMPTY)
.setType(AutomaticZenRule.TYPE_OTHER)
.setZenPolicy(ZenAdapters.notificationPolicyToZenPolicy(
mNotificationManager.getNotificationPolicy()))
.setDeviceEffects(null)
.setTriggerDescription(mContext.getString(R.string.zen_mode_settings_summary))
.setManualInvocationAllowed(true)
.setConfigurationActivity(null) // No further settings
.setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_PRIORITY)
.build();
return ZenMode.manualDndMode(manualDndRule);
}
void updateMode(ZenMode mode) {
if (mode.isManualDnd()) {
NotificationManager.Policy dndPolicy =
new ZenModeConfig().toNotificationPolicy(requireNonNull(mode.getPolicy()));
mNotificationManager.setNotificationPolicy(dndPolicy, /* fromUser= */ true);
// TODO: b/333530553 - Update ZenDeviceEffects of the manual DND too.
} else {
mNotificationManager.updateAutomaticZenRule(mode.getId(), mode.getRule(),
/* fromUser= */ true);
}
}
void activateMode(ZenMode mode, @Nullable Duration forDuration) {
if (mode.isManualDnd()) {
Uri durationConditionId = null;
if (forDuration != null) {
durationConditionId = ZenModeConfig.toTimeCondition(mContext,
(int) forDuration.toMinutes(), ActivityManager.getCurrentUser(), true).id;
}
mNotificationManager.setZenMode(Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS,
durationConditionId, TAG, /* fromUser= */ true);
} else {
if (forDuration != null) {
throw new IllegalArgumentException(
"Only the manual DND mode can be activated for a specific duration");
}
mNotificationManager.setAutomaticZenRuleState(mode.getId(),
new Condition(mode.getRule().getConditionId(), "", Condition.STATE_TRUE,
Condition.SOURCE_USER_ACTION));
}
}
void deactivateMode(ZenMode mode) {
if (mode.isManualDnd()) {
// TODO: b/326061620 - This shouldn't snooze any rules that are active.
mNotificationManager.setZenMode(Settings.Global.ZEN_MODE_OFF, null, TAG,
/* fromUser= */ true);
} else {
// TODO: b/333527800 - This should (potentially) snooze the rule if it was active.
mNotificationManager.setAutomaticZenRuleState(mode.getId(),
new Condition(mode.getRule().getConditionId(), "", Condition.STATE_FALSE,
Condition.SOURCE_USER_ACTION));
}
}
void removeMode(ZenMode mode) {
if (!mode.canBeDeleted()) {
throw new IllegalArgumentException("Mode " + mode + " cannot be deleted!");
}
mNotificationManager.removeAutomaticZenRule(mode.getId(), /* fromUser= */ true);
}
}