Java Code Examples for android.provider.Settings.Global#ZEN_MODE_NO_INTERRUPTIONS

The following examples show how to use android.provider.Settings.Global#ZEN_MODE_NO_INTERRUPTIONS . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source File: ZenModeFiltering.java    From android_9.0.0_r45 with Apache License 2.0 6 votes vote down vote up
/**
 * @param extras extras of the notification with EXTRA_PEOPLE populated
 * @param contactsTimeoutMs timeout in milliseconds to wait for contacts response
 * @param timeoutAffinity affinity to return when the timeout specified via
 *                        <code>contactsTimeoutMs</code> is hit
 */
public static boolean matchesCallFilter(Context context, int zen, ZenModeConfig config,
        UserHandle userHandle, Bundle extras, ValidateNotificationPeople validator,
        int contactsTimeoutMs, float timeoutAffinity) {
    if (zen == Global.ZEN_MODE_NO_INTERRUPTIONS) return false; // nothing gets through
    if (zen == Global.ZEN_MODE_ALARMS) return false; // not an alarm
    if (zen == Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS) {
        if (config.allowRepeatCallers && REPEAT_CALLERS.isRepeat(context, extras)) {
            return true;
        }
        if (!config.allowCalls) return false; // no other calls get through
        if (validator != null) {
            final float contactAffinity = validator.getContactAffinity(userHandle, extras,
                    contactsTimeoutMs, timeoutAffinity);
            return audienceMatches(config.allowCallsFrom, contactAffinity);
        }
    }
    return true;
}
 
Example 2
Source File: ZenLog.java    From android_9.0.0_r45 with Apache License 2.0 5 votes vote down vote up
private static String zenModeToString(int zenMode) {
    switch (zenMode) {
        case Global.ZEN_MODE_OFF: return "off";
        case Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS: return "important_interruptions";
        case Global.ZEN_MODE_ALARMS: return "alarms";
        case Global.ZEN_MODE_NO_INTERRUPTIONS: return "no_interruptions";
        default: return "unknown";
    }
}
 
Example 3
Source File: ZenModeHelper.java    From android_9.0.0_r45 with Apache License 2.0 5 votes vote down vote up
@VisibleForTesting
protected void applyZenToRingerMode() {
    if (mAudioManager == null) return;
    // force the ringer mode into compliance
    final int ringerModeInternal = mAudioManager.getRingerModeInternal();
    int newRingerModeInternal = ringerModeInternal;
    switch (mZenMode) {
        case Global.ZEN_MODE_NO_INTERRUPTIONS:
        case Global.ZEN_MODE_ALARMS:
            if (ringerModeInternal != AudioManager.RINGER_MODE_SILENT) {
                setPreviousRingerModeSetting(ringerModeInternal);
                newRingerModeInternal = AudioManager.RINGER_MODE_SILENT;
            }
            break;
        case Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS:
            // do not apply zen to ringer, streams zen muted in AudioService
            break;
        case Global.ZEN_MODE_OFF:
            if (ringerModeInternal == AudioManager.RINGER_MODE_SILENT) {
                newRingerModeInternal = getPreviousRingerModeSetting();
                setPreviousRingerModeSetting(null);
            }
            break;
    }
    if (newRingerModeInternal != -1) {
        mAudioManager.setRingerModeInternal(newRingerModeInternal, TAG);
    }
}
 
Example 4
Source File: ZenModeHelper.java    From android_9.0.0_r45 with Apache License 2.0 5 votes vote down vote up
private static int zenSeverity(int zen) {
    switch (zen) {
        case Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS: return 1;
        case Global.ZEN_MODE_ALARMS: return 2;
        case Global.ZEN_MODE_NO_INTERRUPTIONS: return 3;
        default: return 0;
    }
}
 
Example 5
Source File: ZenModeHelper.java    From android_9.0.0_r45 with Apache License 2.0 5 votes vote down vote up
@Override
public int getRingerModeAffectedStreams(int streams) {
    // ringtone and notification streams are always affected by ringer mode
    // system stream is affected by ringer mode when not in priority-only
    streams |= (1 << AudioSystem.STREAM_RING) |
            (1 << AudioSystem.STREAM_NOTIFICATION) |
            (1 << AudioSystem.STREAM_SYSTEM);

    if (mZenMode == Global.ZEN_MODE_NO_INTERRUPTIONS) {
        // alarm and music streams affected by ringer mode when in total silence
        streams |= (1 << AudioSystem.STREAM_ALARM) |
                (1 << AudioSystem.STREAM_MUSIC);
    } else {
        streams &= ~((1 << AudioSystem.STREAM_ALARM) |
                (1 << AudioSystem.STREAM_MUSIC));
    }

    if (mZenMode == Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS
            && ZenModeConfig.areAllPriorityOnlyNotificationZenSoundsMuted(mConfig)) {
        // system stream is not affected by ringer mode in priority only when the ringer
        // is zen muted (all other notification categories are muted)
        streams &= ~(1 << AudioSystem.STREAM_SYSTEM);
    } else {
        streams |= (1 << AudioSystem.STREAM_SYSTEM);
    }
    return streams;
}
 
Example 6
Source File: NotificationManager.java    From android_9.0.0_r45 with Apache License 2.0 5 votes vote down vote up
/** @hide */
public static int zenModeToInterruptionFilter(int zen) {
    switch (zen) {
        case Global.ZEN_MODE_OFF: return INTERRUPTION_FILTER_ALL;
        case Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS: return INTERRUPTION_FILTER_PRIORITY;
        case Global.ZEN_MODE_ALARMS: return INTERRUPTION_FILTER_ALARMS;
        case Global.ZEN_MODE_NO_INTERRUPTIONS: return INTERRUPTION_FILTER_NONE;
        default: return INTERRUPTION_FILTER_UNKNOWN;
    }
}
 
Example 7
Source File: NotificationManager.java    From android_9.0.0_r45 with Apache License 2.0 5 votes vote down vote up
/** @hide */
public static int zenModeFromInterruptionFilter(int interruptionFilter, int defValue) {
    switch (interruptionFilter) {
        case INTERRUPTION_FILTER_ALL: return Global.ZEN_MODE_OFF;
        case INTERRUPTION_FILTER_PRIORITY: return Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS;
        case INTERRUPTION_FILTER_ALARMS: return Global.ZEN_MODE_ALARMS;
        case INTERRUPTION_FILTER_NONE:  return Global.ZEN_MODE_NO_INTERRUPTIONS;
        default: return defValue;
    }
}
 
Example 8
Source File: ZenModeConfig.java    From android_9.0.0_r45 with Apache License 2.0 5 votes vote down vote up
/**
 * Determines if DND is currently overriding the ringer
 */
public static boolean isZenOverridingRinger(int zen, ZenModeConfig zenConfig) {
    return zen == Global.ZEN_MODE_NO_INTERRUPTIONS
            || zen == Global.ZEN_MODE_ALARMS
            || (zen == Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS
            && ZenModeConfig.areAllPriorityOnlyNotificationZenSoundsMuted(zenConfig));
}
 
Example 9
Source File: SeekBarVolumizer.java    From android_9.0.0_r45 with Apache License 2.0 5 votes vote down vote up
private boolean isZenMuted() {
    return mNotificationOrRing && mZenMode == Global.ZEN_MODE_ALARMS
            || mZenMode == Global.ZEN_MODE_NO_INTERRUPTIONS
            || (mZenMode == Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS
                && ((!mAllowAlarms && isAlarmsStream(mStreamType))
                    || (!mAllowMedia && isMediaStream(mStreamType))
                    || (!mAllowRinger && isNotificationOrRing(mStreamType))));
}
 
Example 10
Source File: ZenModeFiltering.java    From android_9.0.0_r45 with Apache License 2.0 4 votes vote down vote up
public boolean shouldIntercept(int zen, ZenModeConfig config, NotificationRecord record) {
    if (zen == ZEN_MODE_OFF) {
        return false;
    }
    // Make an exception to policy for the notification saying that policy has changed
    if (NotificationManager.Policy.areAllVisualEffectsSuppressed(config.suppressedVisualEffects)
            && "android".equals(record.sbn.getPackageName())
            && SystemMessageProto.SystemMessage.NOTE_ZEN_UPGRADE == record.sbn.getId()) {
        ZenLog.traceNotIntercepted(record, "systemDndChangedNotification");
        return false;
    }
    switch (zen) {
        case Global.ZEN_MODE_NO_INTERRUPTIONS:
            // #notevenalarms
            ZenLog.traceIntercepted(record, "none");
            return true;
        case Global.ZEN_MODE_ALARMS:
            if (isAlarm(record)) {
                // Alarms only
                return false;
            }
            ZenLog.traceIntercepted(record, "alarmsOnly");
            return true;
        case Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS:
            // allow user-prioritized packages through in priority mode
            if (record.getPackagePriority() == Notification.PRIORITY_MAX) {
                ZenLog.traceNotIntercepted(record, "priorityApp");
                return false;
            }

            if (isAlarm(record)) {
                if (!config.allowAlarms) {
                    ZenLog.traceIntercepted(record, "!allowAlarms");
                    return true;
                }
                return false;
            }
            if (isCall(record)) {
                if (config.allowRepeatCallers
                        && REPEAT_CALLERS.isRepeat(mContext, extras(record))) {
                    ZenLog.traceNotIntercepted(record, "repeatCaller");
                    return false;
                }
                if (!config.allowCalls) {
                    ZenLog.traceIntercepted(record, "!allowCalls");
                    return true;
                }
                return shouldInterceptAudience(config.allowCallsFrom, record);
            }
            if (isMessage(record)) {
                if (!config.allowMessages) {
                    ZenLog.traceIntercepted(record, "!allowMessages");
                    return true;
                }
                return shouldInterceptAudience(config.allowMessagesFrom, record);
            }
            if (isEvent(record)) {
                if (!config.allowEvents) {
                    ZenLog.traceIntercepted(record, "!allowEvents");
                    return true;
                }
                return false;
            }
            if (isReminder(record)) {
                if (!config.allowReminders) {
                    ZenLog.traceIntercepted(record, "!allowReminders");
                    return true;
                }
                return false;
            }
            if (isMedia(record)) {
                if (!config.allowMedia) {
                    ZenLog.traceIntercepted(record, "!allowMedia");
                    return true;
                }
                return false;
            }
            if (isSystem(record)) {
                if (!config.allowSystem) {
                    ZenLog.traceIntercepted(record, "!allowSystem");
                    return true;
                }
                return false;
            }
            ZenLog.traceIntercepted(record, "!priority");
            return true;
        default:
            return false;
    }
}
 
Example 11
Source File: ZenModeHelper.java    From android_9.0.0_r45 with Apache License 2.0 4 votes vote down vote up
@VisibleForTesting
protected void applyRestrictions() {
    final boolean zenPriorityOnly = mZenMode == Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS;
    final boolean zenSilence = mZenMode == Global.ZEN_MODE_NO_INTERRUPTIONS;
    final boolean zenAlarmsOnly = mZenMode == Global.ZEN_MODE_ALARMS;

    // notification restrictions
    final boolean muteNotifications =
            (mSuppressedEffects & SUPPRESSED_EFFECT_NOTIFICATIONS) != 0;
    // call restrictions
    final boolean muteCalls = zenAlarmsOnly
            || (zenPriorityOnly && !mConfig.allowCalls && !mConfig.allowRepeatCallers)
            || (mSuppressedEffects & SUPPRESSED_EFFECT_CALLS) != 0;
    // alarm restrictions
    final boolean muteAlarms = zenPriorityOnly && !mConfig.allowAlarms;
    // media restrictions
    final boolean muteMedia = zenPriorityOnly && !mConfig.allowMedia;
    // system restrictions
    final boolean muteSystem = zenAlarmsOnly || (zenPriorityOnly && !mConfig.allowSystem);
    // total silence restrictions
    final boolean muteEverything = zenSilence
            || (zenPriorityOnly && ZenModeConfig.areAllZenBehaviorSoundsMuted(mConfig));

    for (int usage : AudioAttributes.SDK_USAGES) {
        final int suppressionBehavior = AudioAttributes.SUPPRESSIBLE_USAGES.get(usage);
        if (suppressionBehavior == AudioAttributes.SUPPRESSIBLE_NEVER) {
            applyRestrictions(false /*mute*/, usage);
        } else if (suppressionBehavior == AudioAttributes.SUPPRESSIBLE_NOTIFICATION) {
            applyRestrictions(muteNotifications || muteEverything, usage);
        } else if (suppressionBehavior == AudioAttributes.SUPPRESSIBLE_CALL) {
            applyRestrictions(muteCalls || muteEverything, usage);
        } else if (suppressionBehavior == AudioAttributes.SUPPRESSIBLE_ALARM) {
            applyRestrictions(muteAlarms || muteEverything, usage);
        } else if (suppressionBehavior == AudioAttributes.SUPPRESSIBLE_MEDIA) {
            applyRestrictions(muteMedia || muteEverything, usage);
        } else if (suppressionBehavior == AudioAttributes.SUPPRESSIBLE_SYSTEM) {
            if (usage == AudioAttributes.USAGE_ASSISTANCE_SONIFICATION) {
                // normally DND will only restrict touch sounds, not haptic feedback/vibrations
                applyRestrictions(muteSystem || muteEverything, usage,
                        AppOpsManager.OP_PLAY_AUDIO);
                applyRestrictions(false, usage, AppOpsManager.OP_VIBRATE);
            } else {
                applyRestrictions(muteSystem || muteEverything, usage);
            }
        } else {
            applyRestrictions(muteEverything, usage);
        }
    }
}
 
Example 12
Source File: ZenModeHelper.java    From android_9.0.0_r45 with Apache License 2.0 4 votes vote down vote up
@Override
public int onSetRingerModeInternal(int ringerModeOld, int ringerModeNew, String caller,
        int ringerModeExternal, VolumePolicy policy) {
    final boolean isChange = ringerModeOld != ringerModeNew;

    int ringerModeExternalOut = ringerModeNew;

    if (mZenMode == Global.ZEN_MODE_OFF
            || (mZenMode == Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS
            && !ZenModeConfig.areAllPriorityOnlyNotificationZenSoundsMuted(mConfig))) {
        // in priority only with ringer not muted, save ringer mode changes
        // in dnd off, save ringer mode changes
        setPreviousRingerModeSetting(ringerModeNew);
    }
    int newZen = -1;
    switch (ringerModeNew) {
        case AudioManager.RINGER_MODE_SILENT:
            if (isChange && policy.doNotDisturbWhenSilent) {
                if (mZenMode == Global.ZEN_MODE_OFF) {
                    newZen = Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS;
                }
                setPreviousRingerModeSetting(ringerModeOld);
            }
            break;
        case AudioManager.RINGER_MODE_VIBRATE:
        case AudioManager.RINGER_MODE_NORMAL:
            if (isChange && ringerModeOld == AudioManager.RINGER_MODE_SILENT
                    && (mZenMode == Global.ZEN_MODE_NO_INTERRUPTIONS
                    || mZenMode == Global.ZEN_MODE_ALARMS
                    || (mZenMode == Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS
                    && ZenModeConfig.areAllPriorityOnlyNotificationZenSoundsMuted(
                    mConfig)))) {
                newZen = Global.ZEN_MODE_OFF;
            } else if (mZenMode != Global.ZEN_MODE_OFF) {
                ringerModeExternalOut = AudioManager.RINGER_MODE_SILENT;
            }
            break;
    }

    if (newZen != -1) {
        setManualZenMode(newZen, null, "ringerModeInternal", null,
                false /*setRingerMode*/);
    }
    if (isChange || newZen != -1 || ringerModeExternal != ringerModeExternalOut) {
        ZenLog.traceSetRingerModeInternal(ringerModeOld, ringerModeNew, caller,
                ringerModeExternal, ringerModeExternalOut);
    }
    return ringerModeExternalOut;
}