Merge "Zen: Ringer mode integration fixes." into mnc-dev (e66ba473) · Commits · e / os / android_frameworks_base

media/java/android/media/AudioManagerInternal.java

+4 −0

Original line number	Diff line number	Diff line
		@@ -43,6 +43,8 @@ public abstract class AudioManagerInternal {

		public abstract int getVolumeControllerUid();

		public abstract void updateRingerModeAffectedStreamsInternal();

		public interface RingerModeDelegate {
		/** Called when external ringer mode is evaluated, returns the new internal ringer mode */
		int onSetRingerModeExternal(int ringerModeOld, int ringerModeNew, String caller,
		@@ -53,5 +55,7 @@ public abstract class AudioManagerInternal {
		int ringerModeExternal, VolumePolicy policy);

		boolean canVolumeDownEnterSilent();

		int getRingerModeAffectedStreams(int streams);
		}
		}

services/core/java/com/android/server/audio/AudioService.java

+63 −33

Original line number	Diff line number	Diff line
		@@ -43,7 +43,6 @@ import android.content.Intent;
		import android.content.IntentFilter;
		import android.content.pm.PackageInfo;
		import android.content.pm.PackageManager;
		import android.content.pm.ResolveInfo;
		import android.content.pm.UserInfo;
		import android.content.res.Configuration;
		import android.content.res.Resources;
		@@ -1106,7 +1105,8 @@ public class AudioService extends IAudioService.Stub {
		}
		// Check if the ringer mode handles this adjustment. If it does we don't
		// need to adjust the volume further.
		final int result = checkForRingerModeChange(aliasIndex, direction, step, streamState.mIsMuted);
		final int result = checkForRingerModeChange(aliasIndex, direction, step,
		streamState.mIsMuted);
		adjustVolume = (result & FLAG_ADJUST_VOLUME) != 0;
		// If suppressing a volume adjustment in silent mode, display the UI hint
		if ((result & AudioManager.FLAG_SHOW_SILENT_HINT) != 0) {
		@@ -1117,6 +1117,11 @@ public class AudioService extends IAudioService.Stub {
		flags \|= AudioManager.FLAG_SHOW_VIBRATE_HINT;
		}
		}
		// If the ringermode is suppressing media, prevent changes
		if (streamTypeAlias == AudioSystem.STREAM_MUSIC
		&& (mRingerModeMutedStreams & (1 << AudioSystem.STREAM_MUSIC)) != 0) {
		adjustVolume = false;
		}

		int oldIndex = mStreamStates[streamType].getIndex(device);

		@@ -1796,20 +1801,14 @@ public class AudioService extends IAudioService.Stub {
		broadcastRingerMode(AudioManager.RINGER_MODE_CHANGED_ACTION, ringerMode);
		}

		private void setRingerModeInt(int ringerMode, boolean persist) {
		final boolean change;
		synchronized(mSettingsLock) {
		change = mRingerMode != ringerMode;
		mRingerMode = ringerMode;
		}

		private void muteRingerModeStreams() {
		// Mute stream if not previously muted by ringer mode and ringer mode
		// is not RINGER_MODE_NORMAL and stream is affected by ringer mode.
		// Unmute stream if previously muted by ringer mode and ringer mode
		// is RINGER_MODE_NORMAL or stream is not affected by ringer mode.
		int numStreamTypes = AudioSystem.getNumStreamTypes();
		final boolean ringerModeMute = ringerMode == AudioManager.RINGER_MODE_VIBRATE
		\|\| ringerMode == AudioManager.RINGER_MODE_SILENT;
		final boolean ringerModeMute = mRingerMode == AudioManager.RINGER_MODE_VIBRATE
		\|\| mRingerMode == AudioManager.RINGER_MODE_SILENT;
		for (int streamType = numStreamTypes - 1; streamType >= 0; streamType--) {
		final boolean isMuted = isStreamMutedByRingerMode(streamType);
		final boolean shouldMute = ringerModeMute && isStreamAffectedByRingerMode(streamType);
		@@ -1846,6 +1845,16 @@ public class AudioService extends IAudioService.Stub {
		mRingerModeMutedStreams \|= (1 << streamType);
		}
		}
		}

		private void setRingerModeInt(int ringerMode, boolean persist) {
		final boolean change;
		synchronized(mSettingsLock) {
		change = mRingerMode != ringerMode;
		mRingerMode = ringerMode;
		}

		muteRingerModeStreams();

		// Post a persist ringer mode msg
		if (persist) {
		@@ -3084,30 +3093,19 @@ public class AudioService extends IAudioService.Stub {
		return (mRingerModeMutedStreams & (1 << streamType)) != 0;
		}

		boolean updateRingerModeAffectedStreams() {
		int ringerModeAffectedStreams;
		// make sure settings for ringer mode are consistent with device type: non voice capable
		// devices (tablets) include media stream in silent mode whereas phones don't.
		ringerModeAffectedStreams = Settings.System.getIntForUser(mContentResolver,
		private boolean updateRingerModeAffectedStreams() {
		int ringerModeAffectedStreams = Settings.System.getIntForUser(mContentResolver,
		Settings.System.MODE_RINGER_STREAMS_AFFECTED,
		((1 << AudioSystem.STREAM_RING)\|(1 << AudioSystem.STREAM_NOTIFICATION)\|
		(1 << AudioSystem.STREAM_SYSTEM)\|(1 << AudioSystem.STREAM_SYSTEM_ENFORCED)),
		UserHandle.USER_CURRENT);

		// ringtone, notification and system streams are always affected by ringer mode
		ringerModeAffectedStreams \|= (1 << AudioSystem.STREAM_RING)\|
		(1 << AudioSystem.STREAM_NOTIFICATION)\|
		(1 << AudioSystem.STREAM_SYSTEM);

		switch (mPlatformType) {
		case AudioSystem.PLATFORM_TELEVISION:
		if (mPlatformType == AudioSystem.PLATFORM_TELEVISION) {
		ringerModeAffectedStreams = 0;
		break;
		default:
		ringerModeAffectedStreams &= ~(1 << AudioSystem.STREAM_MUSIC);
		break;
		} else if (mRingerModeDelegate != null) {
		ringerModeAffectedStreams = mRingerModeDelegate
		.getRingerModeAffectedStreams(ringerModeAffectedStreams);
		}

		synchronized (mCameraSoundForced) {
		if (mCameraSoundForced) {
		ringerModeAffectedStreams &= ~(1 << AudioSystem.STREAM_SYSTEM_ENFORCED);
		@@ -5541,13 +5539,35 @@ public class AudioService extends IAudioService.Stub {
		pw.println("\nRinger mode: ");
		pw.println("- mode (internal) = " + RINGER_MODE_NAMES[mRingerMode]);
		pw.println("- mode (external) = " + RINGER_MODE_NAMES[mRingerModeExternal]);
		pw.print("- ringer mode affected streams = 0x");
		pw.println(Integer.toHexString(mRingerModeAffectedStreams));
		pw.print("- ringer mode muted streams = 0x");
		pw.println(Integer.toHexString(mRingerModeMutedStreams));
		dumpRingerModeStreams(pw, "affected", mRingerModeAffectedStreams);
		dumpRingerModeStreams(pw, "muted", mRingerModeMutedStreams);
		pw.print("- delegate = "); pw.println(mRingerModeDelegate);
		}

		private void dumpRingerModeStreams(PrintWriter pw, String type, int streams) {
		pw.print("- ringer mode "); pw.print(type); pw.print(" streams = 0x");
		pw.print(Integer.toHexString(streams));
		if (streams != 0) {
		pw.print(" (");
		boolean first = true;
		for (int i = 0; i < AudioSystem.STREAM_NAMES.length; i++) {
		final int stream = (1 << i);
		if ((streams & stream) != 0) {
		if (!first) pw.print(',');
		pw.print(AudioSystem.STREAM_NAMES[i]);
		streams &= ~stream;
		first = false;
		}
		}
		if (streams != 0) {
		if (!first) pw.print(',');
		pw.print(streams);
		}
		pw.print(')');
		}
		pw.println();
		}

		@Override
		protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
		mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DUMP, TAG);
		@@ -5780,6 +5800,7 @@ public class AudioService extends IAudioService.Stub {
		public void setRingerModeDelegate(RingerModeDelegate delegate) {
		mRingerModeDelegate = delegate;
		if (mRingerModeDelegate != null) {
		updateRingerModeAffectedStreams();
		setRingerModeInternal(getRingerModeInternal(), TAG + ".setRingerModeDelegate");
		}
		}
		@@ -5820,6 +5841,15 @@ public class AudioService extends IAudioService.Stub {
		public int getVolumeControllerUid() {
		return mControllerService.mUid;
		}

		@Override
		public void updateRingerModeAffectedStreamsInternal() {
		synchronized (mSettingsLock) {
		if (updateRingerModeAffectedStreams()) {
		setRingerModeInt(getRingerModeInternal(), false);
		}
		}
		}
		}

		//==========================================================================================

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

+27 −8

Original line number	Diff line number	Diff line
		@@ -16,8 +16,6 @@

		package com.android.server.notification;

		import static android.media.AudioAttributes.USAGE_ALARM;
		import static android.media.AudioAttributes.USAGE_MEDIA;
		import static android.media.AudioAttributes.USAGE_NOTIFICATION;
		import static android.media.AudioAttributes.USAGE_NOTIFICATION_RINGTONE;

		@@ -32,6 +30,7 @@ import android.content.res.XmlResourceParser;
		import android.database.ContentObserver;
		import android.media.AudioManager;
		import android.media.AudioManagerInternal;
		import android.media.AudioSystem;
		import android.media.VolumePolicy;
		import android.net.Uri;
		import android.os.Bundle;
		@@ -41,7 +40,6 @@ import android.os.Message;
		import android.os.UserHandle;
		import android.provider.Settings.Global;
		import android.service.notification.IConditionListener;
		import android.service.notification.NotificationListenerService;
		import android.service.notification.ZenModeConfig;
		import android.service.notification.ZenModeConfig.EventInfo;
		import android.service.notification.ZenModeConfig.ScheduleInfo;
		@@ -300,6 +298,7 @@ public class ZenModeHelper {
		if (zen == mZenMode) return false;
		ZenLog.traceSetZenMode(zen, reason);
		mZenMode = zen;
		updateRingerModeAffectedStreams();
		setZenModeSetting(mZenMode);
		if (setRingerMode) {
		applyZenToRingerMode();
		@@ -309,6 +308,12 @@ public class ZenModeHelper {
		return true;
		}

		private void updateRingerModeAffectedStreams() {
		if (mAudioManager != null) {
		mAudioManager.updateRingerModeAffectedStreamsInternal();
		}
		}

		private int computeZenMode(ArraySet<ZenRule> automaticRulesOut) {
		if (mConfig == null) return Global.ZEN_MODE_OFF;
		if (mConfig.manualRule != null) return mConfig.manualRule.zenMode;
		@@ -334,11 +339,6 @@ public class ZenModeHelper {
		final boolean muteCalls = zen && !mConfig.allowCalls && !mConfig.allowRepeatCallers
		\|\| mEffectsSuppressed;
		applyRestrictions(muteCalls, USAGE_NOTIFICATION_RINGTONE);

		// alarm/media restrictions
		final boolean zenNone = mZenMode == Global.ZEN_MODE_NO_INTERRUPTIONS;
		applyRestrictions(zenNone, USAGE_ALARM);
		applyRestrictions(zenNone, USAGE_MEDIA);
		}

		private void applyRestrictions(boolean mute, int usage) {
		@@ -523,6 +523,7 @@ public class ZenModeHelper {
		&& mZenMode != Global.ZEN_MODE_ALARMS) {
		newZen = Global.ZEN_MODE_ALARMS;
		}
		mPreviousRingerMode = ringerModeOld;
		}
		break;
		case AudioManager.RINGER_MODE_VIBRATE:
		@@ -587,6 +588,24 @@ public class ZenModeHelper {
		public boolean canVolumeDownEnterSilent() {
		return mZenMode == Global.ZEN_MODE_OFF;
		}

		@Override
		public int getRingerModeAffectedStreams(int streams) {
		// ringtone, notification and system streams are always affected by ringer mode
		streams \|= (1 << AudioSystem.STREAM_RING) \|
		(1 << AudioSystem.STREAM_NOTIFICATION) \|
		(1 << AudioSystem.STREAM_SYSTEM);

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

		private final class SettingsObserver extends ContentObserver {