src.com.android.systemui.volume.ZenModePanel Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-all Show documentation
Show all versions of android-all Show documentation
A library jar that provides APIs for Applications written for the Google Android Platform.
/**
* Copyright (C) 2014 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.volume;
import android.animation.LayoutTransition;
import android.animation.LayoutTransition.TransitionListener;
import android.app.ActivityManager;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.content.res.Configuration;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.provider.Settings;
import android.provider.Settings.Global;
import android.service.notification.Condition;
import android.service.notification.ZenModeConfig;
import android.service.notification.ZenModeConfig.ZenRule;
import android.text.TextUtils;
import android.text.format.DateFormat;
import android.text.format.DateUtils;
import android.util.ArraySet;
import android.util.AttributeSet;
import android.util.Log;
import android.util.MathUtils;
import android.util.Slog;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CompoundButton;
import android.widget.CompoundButton.OnCheckedChangeListener;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RadioButton;
import android.widget.RadioGroup;
import android.widget.TextView;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.logging.MetricsLogger;
import com.android.internal.logging.UiEventLogger;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.systemui.Prefs;
import com.android.systemui.R;
import com.android.systemui.qs.QSDndEvent;
import com.android.systemui.qs.QSEvents;
import com.android.systemui.statusbar.policy.ZenModeController;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.Objects;
public class ZenModePanel extends FrameLayout {
private static final String TAG = "ZenModePanel";
private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
public static final int STATE_MODIFY = 0;
public static final int STATE_AUTO_RULE = 1;
public static final int STATE_OFF = 2;
private static final int SECONDS_MS = 1000;
private static final int MINUTES_MS = 60 * SECONDS_MS;
private static final int[] MINUTE_BUCKETS = ZenModeConfig.MINUTE_BUCKETS;
private static final int MIN_BUCKET_MINUTES = MINUTE_BUCKETS[0];
private static final int MAX_BUCKET_MINUTES = MINUTE_BUCKETS[MINUTE_BUCKETS.length - 1];
private static final int DEFAULT_BUCKET_INDEX = Arrays.binarySearch(MINUTE_BUCKETS, 60);
private static final int FOREVER_CONDITION_INDEX = 0;
private static final int COUNTDOWN_CONDITION_INDEX = 1;
private static final int COUNTDOWN_ALARM_CONDITION_INDEX = 2;
private static final int COUNTDOWN_CONDITION_COUNT = 2;
public static final Intent ZEN_SETTINGS
= new Intent(Settings.ACTION_ZEN_MODE_SETTINGS);
public static final Intent ZEN_PRIORITY_SETTINGS
= new Intent(Settings.ACTION_ZEN_MODE_PRIORITY_SETTINGS);
private static final long TRANSITION_DURATION = 300;
private final Context mContext;
protected final LayoutInflater mInflater;
private final H mHandler = new H();
private final ZenPrefs mPrefs;
private final TransitionHelper mTransitionHelper = new TransitionHelper();
private final Uri mForeverId;
private final ConfigurableTexts mConfigurableTexts;
private final UiEventLogger mUiEventLogger = QSEvents.INSTANCE.getQsUiEventsLogger();
private String mTag = TAG + "/" + Integer.toHexString(System.identityHashCode(this));
protected SegmentedButtons mZenButtons;
private View mZenIntroduction;
private TextView mZenIntroductionMessage;
private View mZenIntroductionConfirm;
private TextView mZenIntroductionCustomize;
protected LinearLayout mZenConditions;
private TextView mZenAlarmWarning;
private RadioGroup mZenRadioGroup;
private LinearLayout mZenRadioGroupContent;
private Callback mCallback;
private ZenModeController mController;
private Condition mExitCondition;
private int mBucketIndex = -1;
private boolean mExpanded;
private boolean mHidden;
private int mSessionZen;
private int mAttachedZen;
private boolean mAttached;
private Condition mSessionExitCondition;
private boolean mVoiceCapable;
protected int mZenModeConditionLayoutId;
protected int mZenModeButtonLayoutId;
private View mEmpty;
private TextView mEmptyText;
private ImageView mEmptyIcon;
private View mAutoRule;
private TextView mAutoTitle;
private int mState = STATE_MODIFY;
private ViewGroup mEdit;
public ZenModePanel(Context context, AttributeSet attrs) {
super(context, attrs);
mContext = context;
mPrefs = new ZenPrefs();
mInflater = LayoutInflater.from(mContext);
mForeverId = Condition.newId(mContext).appendPath("forever").build();
mConfigurableTexts = new ConfigurableTexts(mContext);
mVoiceCapable = Util.isVoiceCapable(mContext);
mZenModeConditionLayoutId = R.layout.zen_mode_condition;
mZenModeButtonLayoutId = R.layout.zen_mode_button;
if (DEBUG) Log.d(mTag, "new ZenModePanel");
}
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
pw.println("ZenModePanel state:");
pw.print(" mAttached="); pw.println(mAttached);
pw.print(" mHidden="); pw.println(mHidden);
pw.print(" mExpanded="); pw.println(mExpanded);
pw.print(" mSessionZen="); pw.println(mSessionZen);
pw.print(" mAttachedZen="); pw.println(mAttachedZen);
pw.print(" mConfirmedPriorityIntroduction=");
pw.println(mPrefs.mConfirmedPriorityIntroduction);
pw.print(" mConfirmedSilenceIntroduction=");
pw.println(mPrefs.mConfirmedSilenceIntroduction);
pw.print(" mVoiceCapable="); pw.println(mVoiceCapable);
mTransitionHelper.dump(fd, pw, args);
}
protected void createZenButtons() {
mZenButtons = findViewById(R.id.zen_buttons);
mZenButtons.addButton(R.string.interruption_level_none_twoline,
R.string.interruption_level_none_with_warning,
Global.ZEN_MODE_NO_INTERRUPTIONS);
mZenButtons.addButton(R.string.interruption_level_alarms_twoline,
R.string.interruption_level_alarms,
Global.ZEN_MODE_ALARMS);
mZenButtons.addButton(R.string.interruption_level_priority_twoline,
R.string.interruption_level_priority,
Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS);
mZenButtons.setCallback(mZenButtonsCallback);
}
@Override
protected void onFinishInflate() {
super.onFinishInflate();
createZenButtons();
mZenIntroduction = findViewById(R.id.zen_introduction);
mZenIntroductionMessage = findViewById(R.id.zen_introduction_message);
mZenIntroductionConfirm = findViewById(R.id.zen_introduction_confirm);
mZenIntroductionConfirm.setOnClickListener(v -> confirmZenIntroduction());
mZenIntroductionCustomize = findViewById(R.id.zen_introduction_customize);
mZenIntroductionCustomize.setOnClickListener(v -> {
confirmZenIntroduction();
if (mCallback != null) {
mCallback.onPrioritySettings();
}
});
mConfigurableTexts.add(mZenIntroductionCustomize, R.string.zen_priority_customize_button);
mZenConditions = findViewById(R.id.zen_conditions);
mZenAlarmWarning = findViewById(R.id.zen_alarm_warning);
mZenRadioGroup = findViewById(R.id.zen_radio_buttons);
mZenRadioGroupContent = findViewById(R.id.zen_radio_buttons_content);
mEdit = findViewById(R.id.edit_container);
mEmpty = findViewById(android.R.id.empty);
mEmpty.setVisibility(INVISIBLE);
mEmptyText = mEmpty.findViewById(android.R.id.title);
mEmptyIcon = mEmpty.findViewById(android.R.id.icon);
mAutoRule = findViewById(R.id.auto_rule);
mAutoTitle = mAutoRule.findViewById(android.R.id.title);
mAutoRule.setVisibility(INVISIBLE);
}
public void setEmptyState(int icon, int text) {
mEmptyIcon.post(() -> {
mEmptyIcon.setImageResource(icon);
mEmptyText.setText(text);
});
}
public void setAutoText(CharSequence text) {
mAutoTitle.post(() -> mAutoTitle.setText(text));
}
public void setState(int state) {
if (mState == state) return;
transitionFrom(getView(mState), getView(state));
mState = state;
}
private void transitionFrom(View from, View to) {
from.post(() -> {
// TODO: Better transitions
to.setAlpha(0);
to.setVisibility(VISIBLE);
to.bringToFront();
to.animate().cancel();
to.animate().alpha(1)
.setDuration(TRANSITION_DURATION)
.withEndAction(() -> from.setVisibility(INVISIBLE))
.start();
});
}
private View getView(int state) {
switch (state) {
case STATE_AUTO_RULE:
return mAutoRule;
case STATE_OFF:
return mEmpty;
default:
return mEdit;
}
}
@Override
protected void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
mConfigurableTexts.update();
if (mZenButtons != null) {
mZenButtons.update();
}
}
private void confirmZenIntroduction() {
final String prefKey = prefKeyForConfirmation(getSelectedZen(Global.ZEN_MODE_OFF));
if (prefKey == null) return;
if (DEBUG) Log.d(TAG, "confirmZenIntroduction " + prefKey);
Prefs.putBoolean(mContext, prefKey, true);
mHandler.sendEmptyMessage(H.UPDATE_WIDGETS);
}
private static String prefKeyForConfirmation(int zen) {
switch (zen) {
case Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS:
return Prefs.Key.DND_CONFIRMED_PRIORITY_INTRODUCTION;
case Global.ZEN_MODE_NO_INTERRUPTIONS:
return Prefs.Key.DND_CONFIRMED_SILENCE_INTRODUCTION;
case Global.ZEN_MODE_ALARMS:
return Prefs.Key.DND_CONFIRMED_ALARM_INTRODUCTION;
default:
return null;
}
}
private void onAttach() {
setExpanded(true);
mAttachedZen = mController.getZen();
ZenRule manualRule = mController.getManualRule();
mExitCondition = manualRule != null ? manualRule.condition : null;
if (DEBUG) Log.d(mTag, "onAttach " + mAttachedZen + " " + manualRule);
handleUpdateManualRule(manualRule);
mZenButtons.setSelectedValue(mAttachedZen, false);
mSessionZen = mAttachedZen;
mTransitionHelper.clear();
mController.addCallback(mZenCallback);
setSessionExitCondition(copy(mExitCondition));
updateWidgets();
setAttached(true);
}
private void onDetach() {
if (DEBUG) Log.d(mTag, "onDetach");
setExpanded(false);
checkForAttachedZenChange();
setAttached(false);
mAttachedZen = -1;
mSessionZen = -1;
mController.removeCallback(mZenCallback);
setSessionExitCondition(null);
mTransitionHelper.clear();
}
@VisibleForTesting
void setAttached(boolean attached) {
mAttached = attached;
}
@Override
public void onVisibilityAggregated(boolean isVisible) {
super.onVisibilityAggregated(isVisible);
if (isVisible == mAttached) return;
if (isVisible) {
onAttach();
} else {
onDetach();
}
}
private void setSessionExitCondition(Condition condition) {
if (Objects.equals(condition, mSessionExitCondition)) return;
if (DEBUG) Log.d(mTag, "mSessionExitCondition=" + getConditionId(condition));
mSessionExitCondition = condition;
}
public void setHidden(boolean hidden) {
if (mHidden == hidden) return;
if (DEBUG) Log.d(mTag, "hidden=" + hidden);
mHidden = hidden;
updateWidgets();
}
private void checkForAttachedZenChange() {
final int selectedZen = getSelectedZen(-1);
if (DEBUG) Log.d(mTag, "selectedZen=" + selectedZen);
if (selectedZen != mAttachedZen) {
if (DEBUG) Log.d(mTag, "attachedZen: " + mAttachedZen + " -> " + selectedZen);
if (selectedZen == Global.ZEN_MODE_NO_INTERRUPTIONS) {
mPrefs.trackNoneSelected();
}
}
}
private void setExpanded(boolean expanded) {
if (expanded == mExpanded) return;
if (DEBUG) Log.d(mTag, "setExpanded " + expanded);
mExpanded = expanded;
updateWidgets();
fireExpanded();
}
protected void addZenConditions(int count) {
for (int i = 0; i < count; i++) {
final View rb = mInflater.inflate(mZenModeButtonLayoutId, mEdit, false);
rb.setId(i);
mZenRadioGroup.addView(rb);
final View rbc = mInflater.inflate(mZenModeConditionLayoutId, mEdit, false);
rbc.setId(i + count);
mZenRadioGroupContent.addView(rbc);
}
}
public void init(ZenModeController controller) {
mController = controller;
final int minConditions = 1 /*forever*/ + COUNTDOWN_CONDITION_COUNT;
addZenConditions(minConditions);
mSessionZen = getSelectedZen(-1);
handleUpdateManualRule(mController.getManualRule());
if (DEBUG) Log.d(mTag, "init mExitCondition=" + mExitCondition);
hideAllConditions();
}
private void setExitCondition(Condition exitCondition) {
if (Objects.equals(mExitCondition, exitCondition)) return;
mExitCondition = exitCondition;
if (DEBUG) Log.d(mTag, "mExitCondition=" + getConditionId(mExitCondition));
updateWidgets();
}
private static Uri getConditionId(Condition condition) {
return condition != null ? condition.id : null;
}
private Uri getRealConditionId(Condition condition) {
return isForever(condition) ? null : getConditionId(condition);
}
private static Condition copy(Condition condition) {
return condition == null ? null : condition.copy();
}
public void setCallback(Callback callback) {
mCallback = callback;
}
@VisibleForTesting
void handleUpdateManualRule(ZenRule rule) {
final int zen = rule != null ? rule.zenMode : Global.ZEN_MODE_OFF;
handleUpdateZen(zen);
final Condition c = rule == null ? null
: rule.condition != null ? rule.condition
: createCondition(rule.conditionId);
handleUpdateConditions(c);
setExitCondition(c);
}
private Condition createCondition(Uri conditionId) {
if (ZenModeConfig.isValidCountdownToAlarmConditionId(conditionId)) {
long time = ZenModeConfig.tryParseCountdownConditionId(conditionId);
Condition c = ZenModeConfig.toNextAlarmCondition(
mContext, time, ActivityManager.getCurrentUser());
return c;
} else if (ZenModeConfig.isValidCountdownConditionId(conditionId)) {
long time = ZenModeConfig.tryParseCountdownConditionId(conditionId);
int mins = (int) ((time - System.currentTimeMillis() + DateUtils.MINUTE_IN_MILLIS / 2)
/ DateUtils.MINUTE_IN_MILLIS);
Condition c = ZenModeConfig.toTimeCondition(mContext, time, mins,
ActivityManager.getCurrentUser(), false);
return c;
}
// If there is a manual rule, but it has no condition listed then it is forever.
return forever();
}
private void handleUpdateZen(int zen) {
if (mSessionZen != -1 && mSessionZen != zen) {
mSessionZen = zen;
}
mZenButtons.setSelectedValue(zen, false /* fromClick */);
updateWidgets();
}
@VisibleForTesting
int getSelectedZen(int defValue) {
final Object zen = mZenButtons.getSelectedValue();
return zen != null ? (Integer) zen : defValue;
}
private void updateWidgets() {
if (mTransitionHelper.isTransitioning()) {
mTransitionHelper.pendingUpdateWidgets();
return;
}
final int zen = getSelectedZen(Global.ZEN_MODE_OFF);
final boolean zenImportant = zen == Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS;
final boolean zenNone = zen == Global.ZEN_MODE_NO_INTERRUPTIONS;
final boolean zenAlarm = zen == Global.ZEN_MODE_ALARMS;
final boolean introduction = (zenImportant && !mPrefs.mConfirmedPriorityIntroduction
|| zenNone && !mPrefs.mConfirmedSilenceIntroduction
|| zenAlarm && !mPrefs.mConfirmedAlarmIntroduction);
mZenButtons.setVisibility(mHidden ? GONE : VISIBLE);
mZenIntroduction.setVisibility(introduction ? VISIBLE : GONE);
if (introduction) {
int message = zenImportant
? R.string.zen_priority_introduction
: zenAlarm
? R.string.zen_alarms_introduction
: mVoiceCapable
? R.string.zen_silence_introduction_voice
: R.string.zen_silence_introduction;
mConfigurableTexts.add(mZenIntroductionMessage, message);
mConfigurableTexts.update();
mZenIntroductionCustomize.setVisibility(zenImportant ? VISIBLE : GONE);
}
final String warning = computeAlarmWarningText(zenNone);
mZenAlarmWarning.setVisibility(warning != null ? VISIBLE : GONE);
mZenAlarmWarning.setText(warning);
}
private String computeAlarmWarningText(boolean zenNone) {
if (!zenNone) {
return null;
}
final long now = System.currentTimeMillis();
final long nextAlarm = mController.getNextAlarm();
if (nextAlarm < now) {
return null;
}
int warningRes = 0;
if (mSessionExitCondition == null || isForever(mSessionExitCondition)) {
warningRes = R.string.zen_alarm_warning_indef;
} else {
final long time = ZenModeConfig.tryParseCountdownConditionId(mSessionExitCondition.id);
if (time > now && nextAlarm < time) {
warningRes = R.string.zen_alarm_warning;
}
}
if (warningRes == 0) {
return null;
}
final boolean soon = (nextAlarm - now) < 24 * 60 * 60 * 1000;
final boolean is24 = DateFormat.is24HourFormat(mContext, ActivityManager.getCurrentUser());
final String skeleton = soon ? (is24 ? "Hm" : "hma") : (is24 ? "EEEHm" : "EEEhma");
final String pattern = DateFormat.getBestDateTimePattern(Locale.getDefault(), skeleton);
final CharSequence formattedTime = DateFormat.format(pattern, nextAlarm);
final int templateRes = soon ? R.string.alarm_template : R.string.alarm_template_far;
final String template = getResources().getString(templateRes, formattedTime);
return getResources().getString(warningRes, template);
}
@VisibleForTesting
void handleUpdateConditions(Condition c) {
if (mTransitionHelper.isTransitioning()) {
return;
}
// forever
bind(forever(), mZenRadioGroupContent.getChildAt(FOREVER_CONDITION_INDEX),
FOREVER_CONDITION_INDEX);
if (c == null) {
bindGenericCountdown();
bindNextAlarm(getTimeUntilNextAlarmCondition());
} else if (isForever(c)) {
getConditionTagAt(FOREVER_CONDITION_INDEX).rb.setChecked(true);
bindGenericCountdown();
bindNextAlarm(getTimeUntilNextAlarmCondition());
} else {
if (isAlarm(c)) {
bindGenericCountdown();
bindNextAlarm(c);
getConditionTagAt(COUNTDOWN_ALARM_CONDITION_INDEX).rb.setChecked(true);
} else if (isCountdown(c)) {
bindNextAlarm(getTimeUntilNextAlarmCondition());
bind(c, mZenRadioGroupContent.getChildAt(COUNTDOWN_CONDITION_INDEX),
COUNTDOWN_CONDITION_INDEX);
getConditionTagAt(COUNTDOWN_CONDITION_INDEX).rb.setChecked(true);
} else {
Slog.wtf(TAG, "Invalid manual condition: " + c);
}
}
mZenConditions.setVisibility(mSessionZen != Global.ZEN_MODE_OFF ? View.VISIBLE : View.GONE);
}
private void bindGenericCountdown() {
mBucketIndex = DEFAULT_BUCKET_INDEX;
Condition countdown = ZenModeConfig.toTimeCondition(mContext,
MINUTE_BUCKETS[mBucketIndex], ActivityManager.getCurrentUser());
// don't change the hour condition while the user is viewing the panel
if (!mAttached || getConditionTagAt(COUNTDOWN_CONDITION_INDEX).condition == null) {
bind(countdown, mZenRadioGroupContent.getChildAt(COUNTDOWN_CONDITION_INDEX),
COUNTDOWN_CONDITION_INDEX);
}
}
private void bindNextAlarm(Condition c) {
View alarmContent = mZenRadioGroupContent.getChildAt(COUNTDOWN_ALARM_CONDITION_INDEX);
ConditionTag tag = (ConditionTag) alarmContent.getTag();
// Don't change the alarm condition while the user is viewing the panel
if (c != null && (!mAttached || tag == null || tag.condition == null)) {
bind(c, alarmContent, COUNTDOWN_ALARM_CONDITION_INDEX);
}
tag = (ConditionTag) alarmContent.getTag();
boolean showAlarm = tag != null && tag.condition != null;
mZenRadioGroup.getChildAt(COUNTDOWN_ALARM_CONDITION_INDEX).setVisibility(
showAlarm ? View.VISIBLE : View.INVISIBLE);
alarmContent.setVisibility(showAlarm ? View.VISIBLE : View.INVISIBLE);
}
private Condition forever() {
return new Condition(mForeverId, foreverSummary(mContext), "", "", 0 /*icon*/,
Condition.STATE_TRUE, 0 /*flags*/);
}
private static String foreverSummary(Context context) {
return context.getString(com.android.internal.R.string.zen_mode_forever);
}
// Returns a time condition if the next alarm is within the next week.
private Condition getTimeUntilNextAlarmCondition() {
GregorianCalendar weekRange = new GregorianCalendar();
setToMidnight(weekRange);
weekRange.add(Calendar.DATE, 6);
final long nextAlarmMs = mController.getNextAlarm();
if (nextAlarmMs > 0) {
GregorianCalendar nextAlarm = new GregorianCalendar();
nextAlarm.setTimeInMillis(nextAlarmMs);
setToMidnight(nextAlarm);
if (weekRange.compareTo(nextAlarm) >= 0) {
return ZenModeConfig.toNextAlarmCondition(mContext, nextAlarmMs,
ActivityManager.getCurrentUser());
}
}
return null;
}
private void setToMidnight(Calendar calendar) {
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
}
@VisibleForTesting
ConditionTag getConditionTagAt(int index) {
return (ConditionTag) mZenRadioGroupContent.getChildAt(index).getTag();
}
@VisibleForTesting
int getVisibleConditions() {
int rt = 0;
final int N = mZenRadioGroupContent.getChildCount();
for (int i = 0; i < N; i++) {
rt += mZenRadioGroupContent.getChildAt(i).getVisibility() == VISIBLE ? 1 : 0;
}
return rt;
}
private void hideAllConditions() {
final int N = mZenRadioGroupContent.getChildCount();
for (int i = 0; i < N; i++) {
mZenRadioGroupContent.getChildAt(i).setVisibility(GONE);
}
}
private static boolean isAlarm(Condition c) {
return c != null && ZenModeConfig.isValidCountdownToAlarmConditionId(c.id);
}
private static boolean isCountdown(Condition c) {
return c != null && ZenModeConfig.isValidCountdownConditionId(c.id);
}
private boolean isForever(Condition c) {
return c != null && mForeverId.equals(c.id);
}
private void bind(final Condition condition, final View row, final int rowId) {
if (condition == null) throw new IllegalArgumentException("condition must not be null");
final boolean enabled = condition.state == Condition.STATE_TRUE;
final ConditionTag tag =
row.getTag() != null ? (ConditionTag) row.getTag() : new ConditionTag();
row.setTag(tag);
final boolean first = tag.rb == null;
if (tag.rb == null) {
tag.rb = (RadioButton) mZenRadioGroup.getChildAt(rowId);
}
tag.condition = condition;
final Uri conditionId = getConditionId(tag.condition);
if (DEBUG) Log.d(mTag, "bind i=" + mZenRadioGroupContent.indexOfChild(row) + " first="
+ first + " condition=" + conditionId);
tag.rb.setEnabled(enabled);
tag.rb.setOnCheckedChangeListener(new OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
if (mExpanded && isChecked) {
tag.rb.setChecked(true);
if (DEBUG) Log.d(mTag, "onCheckedChanged " + conditionId);
MetricsLogger.action(mContext, MetricsEvent.QS_DND_CONDITION_SELECT);
mUiEventLogger.log(QSDndEvent.QS_DND_CONDITION_SELECT);
select(tag.condition);
announceConditionSelection(tag);
}
}
});
if (tag.lines == null) {
tag.lines = row.findViewById(android.R.id.content);
}
if (tag.line1 == null) {
tag.line1 = (TextView) row.findViewById(android.R.id.text1);
mConfigurableTexts.add(tag.line1);
}
if (tag.line2 == null) {
tag.line2 = (TextView) row.findViewById(android.R.id.text2);
mConfigurableTexts.add(tag.line2);
}
final String line1 = !TextUtils.isEmpty(condition.line1) ? condition.line1
: condition.summary;
final String line2 = condition.line2;
tag.line1.setText(line1);
if (TextUtils.isEmpty(line2)) {
tag.line2.setVisibility(GONE);
} else {
tag.line2.setVisibility(VISIBLE);
tag.line2.setText(line2);
}
tag.lines.setEnabled(enabled);
tag.lines.setAlpha(enabled ? 1 : .4f);
final ImageView button1 = (ImageView) row.findViewById(android.R.id.button1);
button1.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
onClickTimeButton(row, tag, false /*down*/, rowId);
}
});
final ImageView button2 = (ImageView) row.findViewById(android.R.id.button2);
button2.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
onClickTimeButton(row, tag, true /*up*/, rowId);
}
});
tag.lines.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
tag.rb.setChecked(true);
}
});
final long time = ZenModeConfig.tryParseCountdownConditionId(conditionId);
if (rowId != COUNTDOWN_ALARM_CONDITION_INDEX && time > 0) {
button1.setVisibility(VISIBLE);
button2.setVisibility(VISIBLE);
if (mBucketIndex > -1) {
button1.setEnabled(mBucketIndex > 0);
button2.setEnabled(mBucketIndex < MINUTE_BUCKETS.length - 1);
} else {
final long span = time - System.currentTimeMillis();
button1.setEnabled(span > MIN_BUCKET_MINUTES * MINUTES_MS);
final Condition maxCondition = ZenModeConfig.toTimeCondition(mContext,
MAX_BUCKET_MINUTES, ActivityManager.getCurrentUser());
button2.setEnabled(!Objects.equals(condition.summary, maxCondition.summary));
}
button1.setAlpha(button1.isEnabled() ? 1f : .5f);
button2.setAlpha(button2.isEnabled() ? 1f : .5f);
} else {
button1.setVisibility(GONE);
button2.setVisibility(GONE);
}
// wire up interaction callbacks for newly-added condition rows
if (first) {
Interaction.register(tag.rb, mInteractionCallback);
Interaction.register(tag.lines, mInteractionCallback);
Interaction.register(button1, mInteractionCallback);
Interaction.register(button2, mInteractionCallback);
}
row.setVisibility(VISIBLE);
}
private void announceConditionSelection(ConditionTag tag) {
final int zen = getSelectedZen(Global.ZEN_MODE_OFF);
String modeText;
switch(zen) {
case Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS:
modeText = mContext.getString(R.string.interruption_level_priority);
break;
case Global.ZEN_MODE_NO_INTERRUPTIONS:
modeText = mContext.getString(R.string.interruption_level_none);
break;
case Global.ZEN_MODE_ALARMS:
modeText = mContext.getString(R.string.interruption_level_alarms);
break;
default:
return;
}
announceForAccessibility(mContext.getString(R.string.zen_mode_and_condition, modeText,
tag.line1.getText()));
}
private void onClickTimeButton(View row, ConditionTag tag, boolean up, int rowId) {
MetricsLogger.action(mContext, MetricsEvent.QS_DND_TIME, up);
mUiEventLogger.log(up ? QSDndEvent.QS_DND_TIME_UP : QSDndEvent.QS_DND_TIME_DOWN);
Condition newCondition = null;
final int N = MINUTE_BUCKETS.length;
if (mBucketIndex == -1) {
// not on a known index, search for the next or prev bucket by time
final Uri conditionId = getConditionId(tag.condition);
final long time = ZenModeConfig.tryParseCountdownConditionId(conditionId);
final long now = System.currentTimeMillis();
for (int i = 0; i < N; i++) {
int j = up ? i : N - 1 - i;
final int bucketMinutes = MINUTE_BUCKETS[j];
final long bucketTime = now + bucketMinutes * MINUTES_MS;
if (up && bucketTime > time || !up && bucketTime < time) {
mBucketIndex = j;
newCondition = ZenModeConfig.toTimeCondition(mContext,
bucketTime, bucketMinutes, ActivityManager.getCurrentUser(),
false /*shortVersion*/);
break;
}
}
if (newCondition == null) {
mBucketIndex = DEFAULT_BUCKET_INDEX;
newCondition = ZenModeConfig.toTimeCondition(mContext,
MINUTE_BUCKETS[mBucketIndex], ActivityManager.getCurrentUser());
}
} else {
// on a known index, simply increment or decrement
mBucketIndex = Math.max(0, Math.min(N - 1, mBucketIndex + (up ? 1 : -1)));
newCondition = ZenModeConfig.toTimeCondition(mContext,
MINUTE_BUCKETS[mBucketIndex], ActivityManager.getCurrentUser());
}
bind(newCondition, row, rowId);
tag.rb.setChecked(true);
select(newCondition);
announceConditionSelection(tag);
}
private void select(final Condition condition) {
if (DEBUG) Log.d(mTag, "select " + condition);
if (mSessionZen == -1 || mSessionZen == Global.ZEN_MODE_OFF) {
if (DEBUG) Log.d(mTag, "Ignoring condition selection outside of manual zen");
return;
}
final Uri realConditionId = getRealConditionId(condition);
if (mController != null) {
AsyncTask.execute(new Runnable() {
@Override
public void run() {
mController.setZen(mSessionZen, realConditionId, TAG + ".selectCondition");
}
});
}
setExitCondition(condition);
if (realConditionId == null) {
mPrefs.setMinuteIndex(-1);
} else if ((isAlarm(condition) || isCountdown(condition)) && mBucketIndex != -1) {
mPrefs.setMinuteIndex(mBucketIndex);
}
setSessionExitCondition(copy(condition));
}
private void fireInteraction() {
if (mCallback != null) {
mCallback.onInteraction();
}
}
private void fireExpanded() {
if (mCallback != null) {
mCallback.onExpanded(mExpanded);
}
}
private final ZenModeController.Callback mZenCallback = new ZenModeController.Callback() {
@Override
public void onManualRuleChanged(ZenRule rule) {
mHandler.obtainMessage(H.MANUAL_RULE_CHANGED, rule).sendToTarget();
}
};
private final class H extends Handler {
private static final int MANUAL_RULE_CHANGED = 2;
private static final int UPDATE_WIDGETS = 3;
private H() {
super(Looper.getMainLooper());
}
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MANUAL_RULE_CHANGED: handleUpdateManualRule((ZenRule) msg.obj); break;
case UPDATE_WIDGETS: updateWidgets(); break;
}
}
}
public interface Callback {
void onPrioritySettings();
void onInteraction();
void onExpanded(boolean expanded);
}
// used as the view tag on condition rows
@VisibleForTesting
static class ConditionTag {
RadioButton rb;
View lines;
TextView line1;
TextView line2;
Condition condition;
}
private final class ZenPrefs implements OnSharedPreferenceChangeListener {
private final int mNoneDangerousThreshold;
private int mMinuteIndex;
private int mNoneSelected;
private boolean mConfirmedPriorityIntroduction;
private boolean mConfirmedSilenceIntroduction;
private boolean mConfirmedAlarmIntroduction;
private ZenPrefs() {
mNoneDangerousThreshold = mContext.getResources()
.getInteger(R.integer.zen_mode_alarm_warning_threshold);
Prefs.registerListener(mContext, this);
updateMinuteIndex();
updateNoneSelected();
updateConfirmedPriorityIntroduction();
updateConfirmedSilenceIntroduction();
updateConfirmedAlarmIntroduction();
}
public void trackNoneSelected() {
mNoneSelected = clampNoneSelected(mNoneSelected + 1);
if (DEBUG) Log.d(mTag, "Setting none selected: " + mNoneSelected + " threshold="
+ mNoneDangerousThreshold);
Prefs.putInt(mContext, Prefs.Key.DND_NONE_SELECTED, mNoneSelected);
}
public int getMinuteIndex() {
return mMinuteIndex;
}
public void setMinuteIndex(int minuteIndex) {
minuteIndex = clampIndex(minuteIndex);
if (minuteIndex == mMinuteIndex) return;
mMinuteIndex = clampIndex(minuteIndex);
if (DEBUG) Log.d(mTag, "Setting favorite minute index: " + mMinuteIndex);
Prefs.putInt(mContext, Prefs.Key.DND_FAVORITE_BUCKET_INDEX, mMinuteIndex);
}
@Override
public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
updateMinuteIndex();
updateNoneSelected();
updateConfirmedPriorityIntroduction();
updateConfirmedSilenceIntroduction();
updateConfirmedAlarmIntroduction();
}
private void updateMinuteIndex() {
mMinuteIndex = clampIndex(Prefs.getInt(mContext,
Prefs.Key.DND_FAVORITE_BUCKET_INDEX, DEFAULT_BUCKET_INDEX));
if (DEBUG) Log.d(mTag, "Favorite minute index: " + mMinuteIndex);
}
private int clampIndex(int index) {
return MathUtils.constrain(index, -1, MINUTE_BUCKETS.length - 1);
}
private void updateNoneSelected() {
mNoneSelected = clampNoneSelected(Prefs.getInt(mContext,
Prefs.Key.DND_NONE_SELECTED, 0));
if (DEBUG) Log.d(mTag, "None selected: " + mNoneSelected);
}
private int clampNoneSelected(int noneSelected) {
return MathUtils.constrain(noneSelected, 0, Integer.MAX_VALUE);
}
private void updateConfirmedPriorityIntroduction() {
final boolean confirmed = Prefs.getBoolean(mContext,
Prefs.Key.DND_CONFIRMED_PRIORITY_INTRODUCTION, false);
if (confirmed == mConfirmedPriorityIntroduction) return;
mConfirmedPriorityIntroduction = confirmed;
if (DEBUG) Log.d(mTag, "Confirmed priority introduction: "
+ mConfirmedPriorityIntroduction);
}
private void updateConfirmedSilenceIntroduction() {
final boolean confirmed = Prefs.getBoolean(mContext,
Prefs.Key.DND_CONFIRMED_SILENCE_INTRODUCTION, false);
if (confirmed == mConfirmedSilenceIntroduction) return;
mConfirmedSilenceIntroduction = confirmed;
if (DEBUG) Log.d(mTag, "Confirmed silence introduction: "
+ mConfirmedSilenceIntroduction);
}
private void updateConfirmedAlarmIntroduction() {
final boolean confirmed = Prefs.getBoolean(mContext,
Prefs.Key.DND_CONFIRMED_ALARM_INTRODUCTION, false);
if (confirmed == mConfirmedAlarmIntroduction) return;
mConfirmedAlarmIntroduction = confirmed;
if (DEBUG) Log.d(mTag, "Confirmed alarm introduction: "
+ mConfirmedAlarmIntroduction);
}
}
protected final SegmentedButtons.Callback mZenButtonsCallback = new SegmentedButtons.Callback() {
@Override
public void onSelected(final Object value, boolean fromClick) {
if (value != null && mZenButtons.isShown() && isAttachedToWindow()) {
final int zen = (Integer) value;
if (fromClick) {
MetricsLogger.action(mContext, MetricsEvent.QS_DND_ZEN_SELECT, zen);
}
if (DEBUG) Log.d(mTag, "mZenButtonsCallback selected=" + zen);
final Uri realConditionId = getRealConditionId(mSessionExitCondition);
AsyncTask.execute(new Runnable() {
@Override
public void run() {
mController.setZen(zen, realConditionId, TAG + ".selectZen");
if (zen != Global.ZEN_MODE_OFF) {
Prefs.putInt(mContext, Prefs.Key.DND_FAVORITE_ZEN, zen);
}
}
});
}
}
@Override
public void onInteraction() {
fireInteraction();
}
};
private final Interaction.Callback mInteractionCallback = new Interaction.Callback() {
@Override
public void onInteraction() {
fireInteraction();
}
};
private final class TransitionHelper implements TransitionListener, Runnable {
private final ArraySet mTransitioningViews = new ArraySet();
private boolean mTransitioning;
private boolean mPendingUpdateWidgets;
public void clear() {
mTransitioningViews.clear();
mPendingUpdateWidgets = false;
}
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
pw.println(" TransitionHelper state:");
pw.print(" mPendingUpdateWidgets="); pw.println(mPendingUpdateWidgets);
pw.print(" mTransitioning="); pw.println(mTransitioning);
pw.print(" mTransitioningViews="); pw.println(mTransitioningViews);
}
public void pendingUpdateWidgets() {
mPendingUpdateWidgets = true;
}
public boolean isTransitioning() {
return !mTransitioningViews.isEmpty();
}
@Override
public void startTransition(LayoutTransition transition,
ViewGroup container, View view, int transitionType) {
mTransitioningViews.add(view);
updateTransitioning();
}
@Override
public void endTransition(LayoutTransition transition,
ViewGroup container, View view, int transitionType) {
mTransitioningViews.remove(view);
updateTransitioning();
}
@Override
public void run() {
if (DEBUG) Log.d(mTag, "TransitionHelper run"
+ " mPendingUpdateWidgets=" + mPendingUpdateWidgets);
if (mPendingUpdateWidgets) {
updateWidgets();
}
mPendingUpdateWidgets = false;
}
private void updateTransitioning() {
final boolean transitioning = isTransitioning();
if (mTransitioning == transitioning) return;
mTransitioning = transitioning;
if (DEBUG) Log.d(mTag, "TransitionHelper mTransitioning=" + mTransitioning);
if (!mTransitioning) {
if (mPendingUpdateWidgets) {
mHandler.post(this);
} else {
mPendingUpdateWidgets = false;
}
}
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy