1 /*
2  * Copyright (C) 2009 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.media.cts;
18 
19 import static android.media.AudioManager.ADJUST_LOWER;
20 import static android.media.AudioManager.ADJUST_RAISE;
21 import static android.media.AudioManager.ADJUST_SAME;
22 import static android.media.AudioManager.MODE_IN_CALL;
23 import static android.media.AudioManager.MODE_IN_COMMUNICATION;
24 import static android.media.AudioManager.MODE_NORMAL;
25 import static android.media.AudioManager.MODE_RINGTONE;
26 import static android.media.AudioManager.RINGER_MODE_NORMAL;
27 import static android.media.AudioManager.RINGER_MODE_SILENT;
28 import static android.media.AudioManager.RINGER_MODE_VIBRATE;
29 import static android.media.AudioManager.STREAM_MUSIC;
30 import static android.media.AudioManager.STREAM_ACCESSIBILITY;
31 import static android.media.AudioManager.USE_DEFAULT_STREAM_TYPE;
32 import static android.media.AudioManager.VIBRATE_SETTING_OFF;
33 import static android.media.AudioManager.VIBRATE_SETTING_ON;
34 import static android.media.AudioManager.VIBRATE_SETTING_ONLY_SILENT;
35 import static android.media.AudioManager.VIBRATE_TYPE_NOTIFICATION;
36 import static android.media.AudioManager.VIBRATE_TYPE_RINGER;
37 import static android.provider.Settings.System.SOUND_EFFECTS_ENABLED;
38 
39 import android.app.NotificationManager;
40 import android.content.Context;
41 import android.content.res.Resources;
42 import android.media.AudioManager;
43 import android.content.pm.PackageManager;
44 import android.media.MediaPlayer;
45 import android.os.Vibrator;
46 import android.provider.Settings;
47 import android.provider.Settings.System;
48 import android.test.InstrumentationTestCase;
49 import android.util.Log;
50 import android.view.SoundEffectConstants;
51 
52 public class AudioManagerTest extends InstrumentationTestCase {
53 
54     private final static int MP3_TO_PLAY = R.raw.testmp3;
55     private final static long TIME_TO_PLAY = 2000;
56     private final static String APPOPS_OP_STR = "android:write_settings";
57     private AudioManager mAudioManager;
58     private NotificationManager mNm;
59     private boolean mHasVibrator;
60     private boolean mUseFixedVolume;
61     private boolean mIsTelevision;
62     private Context mContext;
63     private final static int ASYNC_TIMING_TOLERANCE_MS = 50;
64 
65     @Override
setUp()66     protected void setUp() throws Exception {
67         super.setUp();
68         mContext = getInstrumentation().getContext();
69         Utils.enableAppOps(mContext.getPackageName(), APPOPS_OP_STR, getInstrumentation());
70         mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
71         Vibrator vibrator = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE);
72         mNm = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
73         mHasVibrator = (vibrator != null) && vibrator.hasVibrator();
74         mUseFixedVolume = mContext.getResources().getBoolean(
75                 Resources.getSystem().getIdentifier("config_useFixedVolume", "bool", "android"));
76         PackageManager packageManager = mContext.getPackageManager();
77         mIsTelevision = packageManager != null
78                 && (packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
79                         || packageManager.hasSystemFeature(PackageManager.FEATURE_TELEVISION));
80     }
81     @Override
tearDown()82     protected void tearDown() throws Exception {
83         Utils.toggleNotificationPolicyAccess(
84                 mContext.getPackageName(), getInstrumentation(), false);
85     }
86 
testMicrophoneMute()87     public void testMicrophoneMute() throws Exception {
88         mAudioManager.setMicrophoneMute(true);
89         assertTrue(mAudioManager.isMicrophoneMute());
90         mAudioManager.setMicrophoneMute(false);
91         assertFalse(mAudioManager.isMicrophoneMute());
92     }
93 
testSoundEffects()94     public void testSoundEffects() throws Exception {
95         try {
96             Utils.toggleNotificationPolicyAccess(
97                     mContext.getPackageName(), getInstrumentation(), true);
98             // set relative setting
99             mAudioManager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
100         } finally {
101             Utils.toggleNotificationPolicyAccess(
102                     mContext.getPackageName(), getInstrumentation(), false);
103         }
104         Settings.System.putInt(mContext.getContentResolver(), SOUND_EFFECTS_ENABLED, 1);
105 
106         // should hear sound after loadSoundEffects() called.
107         mAudioManager.loadSoundEffects();
108         Thread.sleep(TIME_TO_PLAY);
109         float volume = 13;
110         mAudioManager.playSoundEffect(SoundEffectConstants.CLICK);
111         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_UP);
112         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_DOWN);
113         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_LEFT);
114         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_RIGHT);
115 
116         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_UP, volume);
117         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_DOWN, volume);
118         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_LEFT, volume);
119         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_RIGHT, volume);
120 
121         // won't hear sound after unloadSoundEffects() called();
122         mAudioManager.unloadSoundEffects();
123         mAudioManager.playSoundEffect(AudioManager.FX_KEY_CLICK);
124         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_UP);
125         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_DOWN);
126         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_LEFT);
127         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_RIGHT);
128 
129         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_UP, volume);
130         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_DOWN, volume);
131         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_LEFT, volume);
132         mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_RIGHT, volume);
133     }
134 
testMusicActive()135     public void testMusicActive() throws Exception {
136         MediaPlayer mp = MediaPlayer.create(mContext, MP3_TO_PLAY);
137         assertNotNull(mp);
138         mp.setAudioStreamType(AudioManager.STREAM_MUSIC);
139         mp.start();
140         Thread.sleep(TIME_TO_PLAY);
141         assertTrue(mAudioManager.isMusicActive());
142         Thread.sleep(TIME_TO_PLAY);
143         mp.stop();
144         mp.release();
145         Thread.sleep(TIME_TO_PLAY);
146         assertFalse(mAudioManager.isMusicActive());
147     }
148 
testAccessMode()149     public void testAccessMode() throws Exception {
150         mAudioManager.setMode(MODE_RINGTONE);
151         assertEquals(MODE_RINGTONE, mAudioManager.getMode());
152         mAudioManager.setMode(MODE_IN_COMMUNICATION);
153         assertEquals(MODE_IN_COMMUNICATION, mAudioManager.getMode());
154         mAudioManager.setMode(MODE_NORMAL);
155         assertEquals(MODE_NORMAL, mAudioManager.getMode());
156     }
157 
158     @SuppressWarnings("deprecation")
testRouting()159     public void testRouting() throws Exception {
160         // setBluetoothA2dpOn is a no-op, and getRouting should always return -1
161         // AudioManager.MODE_CURRENT
162         boolean oldA2DP = mAudioManager.isBluetoothA2dpOn();
163         mAudioManager.setBluetoothA2dpOn(true);
164         assertEquals(oldA2DP , mAudioManager.isBluetoothA2dpOn());
165         mAudioManager.setBluetoothA2dpOn(false);
166         assertEquals(oldA2DP , mAudioManager.isBluetoothA2dpOn());
167 
168         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_RINGTONE));
169         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_NORMAL));
170         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_CALL));
171         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_COMMUNICATION));
172 
173         mAudioManager.setBluetoothScoOn(true);
174         assertTrue(mAudioManager.isBluetoothScoOn());
175         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_RINGTONE));
176         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_NORMAL));
177         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_CALL));
178         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_COMMUNICATION));
179 
180         mAudioManager.setBluetoothScoOn(false);
181         assertFalse(mAudioManager.isBluetoothScoOn());
182         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_RINGTONE));
183         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_NORMAL));
184         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_CALL));
185         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_COMMUNICATION));
186 
187         mAudioManager.setSpeakerphoneOn(true);
188         assertTrue(mAudioManager.isSpeakerphoneOn());
189         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_CALL));
190         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_COMMUNICATION));
191         mAudioManager.setSpeakerphoneOn(false);
192         assertFalse(mAudioManager.isSpeakerphoneOn());
193         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_CALL));
194         assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_COMMUNICATION));
195     }
196 
testVibrateNotification()197     public void testVibrateNotification() throws Exception {
198         if (mUseFixedVolume || !mHasVibrator) {
199             return;
200         }
201         Utils.toggleNotificationPolicyAccess(
202                 mContext.getPackageName(), getInstrumentation(), true);
203         // VIBRATE_SETTING_ON
204         mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_ON);
205         assertEquals(mHasVibrator ? VIBRATE_SETTING_ON : VIBRATE_SETTING_OFF,
206                 mAudioManager.getVibrateSetting(VIBRATE_TYPE_NOTIFICATION));
207         mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
208         assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
209 
210         mAudioManager.setRingerMode(RINGER_MODE_SILENT);
211         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
212 
213         mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
214         assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT,
215                 mAudioManager.getRingerMode());
216         assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
217 
218         // VIBRATE_SETTING_OFF
219         mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_OFF);
220         assertEquals(VIBRATE_SETTING_OFF,
221                 mAudioManager.getVibrateSetting(VIBRATE_TYPE_NOTIFICATION));
222         mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
223         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
224 
225         mAudioManager.setRingerMode(RINGER_MODE_SILENT);
226         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
227 
228         mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
229         assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT,
230                 mAudioManager.getRingerMode());
231         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
232 
233         // VIBRATE_SETTING_ONLY_SILENT
234         mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_ONLY_SILENT);
235         assertEquals(mHasVibrator ? VIBRATE_SETTING_ONLY_SILENT : VIBRATE_SETTING_OFF,
236                 mAudioManager.getVibrateSetting(VIBRATE_TYPE_NOTIFICATION));
237         mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
238         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
239 
240         mAudioManager.setRingerMode(RINGER_MODE_SILENT);
241         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
242 
243         mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
244         assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT,
245                 mAudioManager.getRingerMode());
246         assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
247 
248         // VIBRATE_TYPE_NOTIFICATION
249         mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_ON);
250         assertEquals(mHasVibrator ? VIBRATE_SETTING_ON : VIBRATE_SETTING_OFF,
251                 mAudioManager.getVibrateSetting(VIBRATE_TYPE_NOTIFICATION));
252         mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_OFF);
253         assertEquals(VIBRATE_SETTING_OFF, mAudioManager
254                 .getVibrateSetting(VIBRATE_TYPE_NOTIFICATION));
255         mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_ONLY_SILENT);
256         assertEquals(mHasVibrator ? VIBRATE_SETTING_ONLY_SILENT : VIBRATE_SETTING_OFF,
257                 mAudioManager.getVibrateSetting(VIBRATE_TYPE_NOTIFICATION));
258     }
259 
testVibrateRinger()260     public void testVibrateRinger() throws Exception {
261         if (mUseFixedVolume || !mHasVibrator) {
262             return;
263         }
264         Utils.toggleNotificationPolicyAccess(
265                 mContext.getPackageName(), getInstrumentation(), true);
266         // VIBRATE_TYPE_RINGER
267         mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_ON);
268         assertEquals(mHasVibrator ? VIBRATE_SETTING_ON : VIBRATE_SETTING_OFF,
269                 mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER));
270         mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
271         assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
272 
273         mAudioManager.setRingerMode(RINGER_MODE_SILENT);
274         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
275 
276         mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
277         assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT,
278                 mAudioManager.getRingerMode());
279         assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
280 
281         // VIBRATE_SETTING_OFF
282         mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_OFF);
283         assertEquals(VIBRATE_SETTING_OFF, mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER));
284         mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
285         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
286 
287         mAudioManager.setRingerMode(RINGER_MODE_SILENT);
288         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
289 
290         mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
291         assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT,
292                 mAudioManager.getRingerMode());
293         // Note: as of Froyo, if VIBRATE_TYPE_RINGER is set to OFF, it will
294         // not vibrate, even in RINGER_MODE_VIBRATE. This allows users to
295         // disable the vibration for incoming calls only.
296         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
297 
298         // VIBRATE_SETTING_ONLY_SILENT
299         mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_ONLY_SILENT);
300         assertEquals(mHasVibrator ? VIBRATE_SETTING_ONLY_SILENT : VIBRATE_SETTING_OFF,
301                 mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER));
302         mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
303         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
304 
305         mAudioManager.setRingerMode(RINGER_MODE_SILENT);
306         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
307 
308         mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
309         assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT,
310                 mAudioManager.getRingerMode());
311         assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
312 
313         // VIBRATE_TYPE_NOTIFICATION
314         mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_ON);
315         assertEquals(mHasVibrator ? VIBRATE_SETTING_ON : VIBRATE_SETTING_OFF,
316                 mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER));
317         mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_OFF);
318         assertEquals(VIBRATE_SETTING_OFF, mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER));
319         mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_ONLY_SILENT);
320         assertEquals(mHasVibrator ? VIBRATE_SETTING_ONLY_SILENT : VIBRATE_SETTING_OFF,
321                 mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER));
322     }
323 
testAccessRingMode()324     public void testAccessRingMode() throws Exception {
325         Utils.toggleNotificationPolicyAccess(
326                 mContext.getPackageName(), getInstrumentation(), true);
327         mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
328         assertEquals(RINGER_MODE_NORMAL, mAudioManager.getRingerMode());
329 
330         mAudioManager.setRingerMode(RINGER_MODE_SILENT);
331         // AudioService#setRingerMode() has:
332         // if (isTelevision) return;
333         if (mUseFixedVolume || mIsTelevision) {
334             assertEquals(RINGER_MODE_NORMAL, mAudioManager.getRingerMode());
335         } else {
336             assertEquals(RINGER_MODE_SILENT, mAudioManager.getRingerMode());
337         }
338 
339         mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
340         if (mUseFixedVolume || mIsTelevision) {
341             assertEquals(RINGER_MODE_NORMAL, mAudioManager.getRingerMode());
342         } else {
343             assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT,
344                     mAudioManager.getRingerMode());
345         }
346     }
347 
testSetRingerModePolicyAccess()348     public void testSetRingerModePolicyAccess() throws Exception {
349         if (mUseFixedVolume || mIsTelevision) {
350             return;
351         }
352         // Apps without policy access cannot change silent -> normal or silent -> vibrate.
353         Utils.toggleNotificationPolicyAccess(
354                 mContext.getPackageName(), getInstrumentation(), true);
355         mAudioManager.setRingerMode(RINGER_MODE_SILENT);
356         assertEquals(RINGER_MODE_SILENT, mAudioManager.getRingerMode());
357         Utils.toggleNotificationPolicyAccess(
358                 mContext.getPackageName(), getInstrumentation(), false);
359 
360         try {
361             mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
362             fail("Apps without notification policy access cannot change ringer mode");
363         } catch (SecurityException e) {
364         }
365 
366         try {
367             mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
368             fail("Apps without notification policy access cannot change ringer mode");
369         } catch (SecurityException e) {
370         }
371 
372         // Apps without policy access cannot change normal -> silent.
373         Utils.toggleNotificationPolicyAccess(
374                 mContext.getPackageName(), getInstrumentation(), true);
375         mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
376         assertEquals(RINGER_MODE_NORMAL, mAudioManager.getRingerMode());
377         Utils.toggleNotificationPolicyAccess(
378                 mContext.getPackageName(), getInstrumentation(), false);
379 
380         try {
381             mAudioManager.setRingerMode(RINGER_MODE_SILENT);
382             fail("Apps without notification policy access cannot change ringer mode");
383         } catch (SecurityException e) {
384         }
385         assertEquals(RINGER_MODE_NORMAL, mAudioManager.getRingerMode());
386 
387         if (mHasVibrator) {
388             // Apps without policy access cannot change vibrate -> silent.
389             Utils.toggleNotificationPolicyAccess(
390                     mContext.getPackageName(), getInstrumentation(), true);
391             mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
392             assertEquals(RINGER_MODE_VIBRATE, mAudioManager.getRingerMode());
393             Utils.toggleNotificationPolicyAccess(
394                     mContext.getPackageName(), getInstrumentation(), false);
395 
396             try {
397                 mAudioManager.setRingerMode(RINGER_MODE_SILENT);
398                 fail("Apps without notification policy access cannot change ringer mode");
399             } catch (SecurityException e) {
400             }
401 
402             // Apps without policy access can change vibrate -> normal and vice versa.
403             assertEquals(RINGER_MODE_VIBRATE, mAudioManager.getRingerMode());
404             mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
405             assertEquals(RINGER_MODE_NORMAL, mAudioManager.getRingerMode());
406             mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
407             assertEquals(RINGER_MODE_VIBRATE, mAudioManager.getRingerMode());
408         }
409     }
410 
testVolumeDndAffectedStream()411     public void testVolumeDndAffectedStream() throws Exception {
412         if (mUseFixedVolume || mHasVibrator || mIsTelevision) {
413             return;
414         }
415         Utils.toggleNotificationPolicyAccess(
416                 mContext.getPackageName(), getInstrumentation(), true);
417         mAudioManager.setStreamVolume(
418                 AudioManager.STREAM_SYSTEM, 7, AudioManager.FLAG_ALLOW_RINGER_MODES);
419         mAudioManager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
420         Utils.toggleNotificationPolicyAccess(
421                 mContext.getPackageName(), getInstrumentation(), false);
422         // 7 to 0, fail.
423         try {
424             mAudioManager.setStreamVolume(
425                     AudioManager.STREAM_SYSTEM, 0, AudioManager.FLAG_ALLOW_RINGER_MODES);
426             fail("Apps without notification policy access cannot change ringer mode");
427         } catch (SecurityException e) {}
428 
429         // 7 to 1: success
430         mAudioManager.setStreamVolume(
431                 AudioManager.STREAM_SYSTEM, 1, AudioManager.FLAG_ALLOW_RINGER_MODES);
432         assertEquals("setStreamVolume did not change volume",
433                 1, mAudioManager.getStreamVolume(AudioManager.STREAM_SYSTEM));
434 
435         // 0 to non-zero: fail.
436         Utils.toggleNotificationPolicyAccess(
437                 mContext.getPackageName(), getInstrumentation(), true);
438         mAudioManager.setRingerMode(AudioManager.RINGER_MODE_SILENT);
439         mAudioManager.setStreamVolume(
440                 AudioManager.STREAM_SYSTEM, 0, AudioManager.FLAG_ALLOW_RINGER_MODES);
441         Utils.toggleNotificationPolicyAccess(
442                 mContext.getPackageName(), getInstrumentation(), false);
443 
444         try {
445             mAudioManager.setStreamVolume(
446                     AudioManager.STREAM_SYSTEM, 6, AudioManager.FLAG_ALLOW_RINGER_MODES);
447             fail("Apps without notification policy access cannot change ringer mode");
448         } catch (SecurityException e) {}
449     }
450 
testVolume()451     public void testVolume() throws Exception {
452         Utils.toggleNotificationPolicyAccess(
453                 mContext.getPackageName(), getInstrumentation(), true);
454         int volume, volumeDelta;
455         int[] streams = {AudioManager.STREAM_ALARM,
456                 AudioManager.STREAM_MUSIC,
457                 AudioManager.STREAM_VOICE_CALL,
458                 AudioManager.STREAM_RING};
459 
460         mAudioManager.adjustVolume(ADJUST_RAISE, 0);
461         // adjusting volume is aynchronous, wait before other volume checks
462         Thread.sleep(ASYNC_TIMING_TOLERANCE_MS);
463         mAudioManager.adjustSuggestedStreamVolume(
464                 ADJUST_LOWER, USE_DEFAULT_STREAM_TYPE, 0);
465         Thread.sleep(ASYNC_TIMING_TOLERANCE_MS);
466         int maxMusicVolume = mAudioManager.getStreamMaxVolume(STREAM_MUSIC);
467 
468         for (int stream : streams) {
469             // set ringer mode to back normal to not interfere with volume tests
470             mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
471 
472             int maxVolume = mAudioManager.getStreamMaxVolume(stream);
473             int minVolume = mAudioManager.getStreamMinVolume(stream);
474 
475             // validate min
476             assertTrue(String.format("minVolume(%d) must be >= 0", minVolume), minVolume >= 0);
477             assertTrue(String.format("minVolume(%d) must be < maxVolume(%d)", minVolume,
478                     maxVolume),
479                     minVolume < maxVolume);
480 
481             mAudioManager.setStreamVolume(stream, 1, 0);
482             if (mUseFixedVolume) {
483                 assertEquals(maxVolume, mAudioManager.getStreamVolume(stream));
484                 continue;
485             }
486             assertEquals(String.format("stream=%d", stream),
487                     1, mAudioManager.getStreamVolume(stream));
488 
489             if (stream == AudioManager.STREAM_MUSIC && mAudioManager.isWiredHeadsetOn()) {
490                 // due to new regulations, music sent over a wired headset may be volume limited
491                 // until the user explicitly increases the limit, so we can't rely on being able
492                 // to set the volume to getStreamMaxVolume(). Instead, determine the current limit
493                 // by increasing the volume until it won't go any higher, then use that volume as
494                 // the maximum for the purposes of this test
495                 int curvol = 0;
496                 int prevvol = 0;
497                 do {
498                     prevvol = curvol;
499                     mAudioManager.adjustStreamVolume(stream, ADJUST_RAISE, 0);
500                     curvol = mAudioManager.getStreamVolume(stream);
501                 } while (curvol != prevvol);
502                 maxVolume = maxMusicVolume = curvol;
503             }
504             mAudioManager.setStreamVolume(stream, maxVolume, 0);
505             mAudioManager.adjustStreamVolume(stream, ADJUST_RAISE, 0);
506             assertEquals(maxVolume, mAudioManager.getStreamVolume(stream));
507 
508             volumeDelta = getVolumeDelta(mAudioManager.getStreamVolume(stream));
509             mAudioManager.adjustSuggestedStreamVolume(ADJUST_LOWER, stream, 0);
510             Thread.sleep(ASYNC_TIMING_TOLERANCE_MS);
511             assertEquals(maxVolume - volumeDelta, mAudioManager.getStreamVolume(stream));
512 
513             // volume lower
514             mAudioManager.setStreamVolume(stream, maxVolume, 0);
515             volume = mAudioManager.getStreamVolume(stream);
516             while (volume > minVolume) {
517                 volumeDelta = getVolumeDelta(mAudioManager.getStreamVolume(stream));
518                 mAudioManager.adjustStreamVolume(stream, ADJUST_LOWER, 0);
519                 assertEquals(Math.max(0, volume - volumeDelta),
520                         mAudioManager.getStreamVolume(stream));
521                 volume = mAudioManager.getStreamVolume(stream);
522             }
523 
524             mAudioManager.adjustStreamVolume(stream, ADJUST_SAME, 0);
525 
526             // volume raise
527             mAudioManager.setStreamVolume(stream, 1, 0);
528             volume = mAudioManager.getStreamVolume(stream);
529             while (volume < maxVolume) {
530                 volumeDelta = getVolumeDelta(mAudioManager.getStreamVolume(stream));
531                 mAudioManager.adjustStreamVolume(stream, ADJUST_RAISE, 0);
532                 assertEquals(Math.min(volume + volumeDelta, maxVolume),
533                         mAudioManager.getStreamVolume(stream));
534                 volume = mAudioManager.getStreamVolume(stream);
535             }
536 
537             // volume same
538             mAudioManager.setStreamVolume(stream, maxVolume, 0);
539             for (int k = 0; k < maxVolume; k++) {
540                 mAudioManager.adjustStreamVolume(stream, ADJUST_SAME, 0);
541                 assertEquals(maxVolume, mAudioManager.getStreamVolume(stream));
542             }
543 
544             mAudioManager.setStreamVolume(stream, maxVolume, 0);
545         }
546 
547         if (mUseFixedVolume) {
548             return;
549         }
550 
551         // adjust volume
552         mAudioManager.adjustVolume(ADJUST_RAISE, 0);
553         Thread.sleep(ASYNC_TIMING_TOLERANCE_MS);
554 
555         MediaPlayer mp = MediaPlayer.create(mContext, MP3_TO_PLAY);
556         assertNotNull(mp);
557         mp.setAudioStreamType(STREAM_MUSIC);
558         mp.setLooping(true);
559         mp.start();
560         Thread.sleep(TIME_TO_PLAY);
561         assertTrue(mAudioManager.isMusicActive());
562 
563         // adjust volume as ADJUST_SAME
564         for (int k = 0; k < maxMusicVolume; k++) {
565             mAudioManager.adjustVolume(ADJUST_SAME, 0);
566             Thread.sleep(ASYNC_TIMING_TOLERANCE_MS);
567             assertEquals(maxMusicVolume, mAudioManager.getStreamVolume(STREAM_MUSIC));
568         }
569 
570         // adjust volume as ADJUST_RAISE
571         mAudioManager.setStreamVolume(STREAM_MUSIC, 0, 0);
572         volumeDelta = getVolumeDelta(mAudioManager.getStreamVolume(STREAM_MUSIC));
573         mAudioManager.adjustVolume(ADJUST_RAISE, 0);
574         Thread.sleep(ASYNC_TIMING_TOLERANCE_MS);
575         assertEquals(Math.min(volumeDelta, maxMusicVolume),
576                 mAudioManager.getStreamVolume(STREAM_MUSIC));
577 
578         // adjust volume as ADJUST_LOWER
579         mAudioManager.setStreamVolume(STREAM_MUSIC, maxMusicVolume, 0);
580         maxMusicVolume = mAudioManager.getStreamVolume(STREAM_MUSIC);
581         volumeDelta = getVolumeDelta(mAudioManager.getStreamVolume(STREAM_MUSIC));
582         mAudioManager.adjustVolume(ADJUST_LOWER, 0);
583         Thread.sleep(ASYNC_TIMING_TOLERANCE_MS);
584         assertEquals(Math.max(0, maxMusicVolume - volumeDelta),
585                 mAudioManager.getStreamVolume(STREAM_MUSIC));
586 
587         mp.stop();
588         mp.release();
589         Thread.sleep(TIME_TO_PLAY);
590         assertFalse(mAudioManager.isMusicActive());
591     }
592 
testAccessibilityVolume()593     public void testAccessibilityVolume() throws Exception {
594         if (mUseFixedVolume) {
595             Log.i("AudioManagerTest", "testAccessibilityVolume() skipped: fixed volume");
596             return;
597         }
598         final int maxA11yVol = mAudioManager.getStreamMaxVolume(STREAM_ACCESSIBILITY);
599         assertTrue("Max a11yVol not strictly positive", maxA11yVol > 0);
600         int currentVol = mAudioManager.getStreamVolume(STREAM_ACCESSIBILITY);
601 
602         // changing STREAM_ACCESSIBILITY is subject to permission, shouldn't be able to change it
603         // test setStreamVolume
604         final int testSetVol;
605         if (currentVol != maxA11yVol) {
606             testSetVol = maxA11yVol;
607         } else {
608             testSetVol = maxA11yVol - 1;
609         }
610         mAudioManager.setStreamVolume(STREAM_ACCESSIBILITY, testSetVol, 0);
611         Thread.sleep(ASYNC_TIMING_TOLERANCE_MS);
612         currentVol = mAudioManager.getStreamVolume(STREAM_ACCESSIBILITY);
613         assertTrue("Should not be able to change A11y vol", currentVol != testSetVol);
614 
615         // test adjustStreamVolume
616         //        LOWER
617         currentVol = mAudioManager.getStreamVolume(STREAM_ACCESSIBILITY);
618         if (currentVol > 0) {
619             mAudioManager.adjustStreamVolume(STREAM_ACCESSIBILITY, ADJUST_LOWER, 0);
620             Thread.sleep(ASYNC_TIMING_TOLERANCE_MS);
621             int newVol = mAudioManager.getStreamVolume(STREAM_ACCESSIBILITY);
622             assertTrue("Should not be able to lower A11y vol", currentVol == newVol);
623         }
624         //        RAISE
625         currentVol = mAudioManager.getStreamVolume(STREAM_ACCESSIBILITY);
626         if (currentVol < maxA11yVol) {
627             mAudioManager.adjustStreamVolume(STREAM_ACCESSIBILITY, ADJUST_RAISE, 0);
628             Thread.sleep(ASYNC_TIMING_TOLERANCE_MS);
629             int newVol = mAudioManager.getStreamVolume(STREAM_ACCESSIBILITY);
630             assertTrue("Should not be able to raise A11y vol", currentVol == newVol);
631         }
632     }
633 
testMuteFixedVolume()634     public void testMuteFixedVolume() throws Exception {
635         int[] streams = {
636                 AudioManager.STREAM_VOICE_CALL,
637                 AudioManager.STREAM_MUSIC,
638                 AudioManager.STREAM_RING,
639                 AudioManager.STREAM_ALARM,
640                 AudioManager.STREAM_NOTIFICATION,
641                 AudioManager.STREAM_SYSTEM};
642         if (mUseFixedVolume) {
643             for (int stream : streams) {
644                 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_MUTE, 0);
645                 assertFalse("Muting should not affect a fixed volume device.",
646                         mAudioManager.isStreamMute(stream));
647 
648                 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_TOGGLE_MUTE, 0);
649                 assertFalse("Toggling mute should not affect a fixed volume device.",
650                         mAudioManager.isStreamMute(stream));
651 
652                 mAudioManager.setStreamMute(stream, true);
653                 assertFalse("Muting should not affect a fixed volume device.",
654                         mAudioManager.isStreamMute(stream));
655             }
656         }
657     }
658 
testMuteDndAffectedStreams()659     public void testMuteDndAffectedStreams() throws Exception {
660         if (mUseFixedVolume || mIsTelevision) {
661             return;
662         }
663         int[] streams = { AudioManager.STREAM_RING };
664         // Mute streams
665         Utils.toggleNotificationPolicyAccess(
666                 mContext.getPackageName(), getInstrumentation(), true);
667         mAudioManager.setRingerMode(RINGER_MODE_SILENT);
668         Utils.toggleNotificationPolicyAccess(
669                 mContext.getPackageName(), getInstrumentation(), false);
670         // Verify streams cannot be unmuted without policy access.
671         for (int stream : streams) {
672             try {
673                 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_UNMUTE, 0);
674                 assertEquals("Apps without Notification policy access can't change ringer mode",
675                         RINGER_MODE_SILENT, mAudioManager.getRingerMode());
676             } catch (SecurityException e) {
677             }
678 
679             try {
680                 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_TOGGLE_MUTE,
681                         0);
682                 assertEquals("Apps without Notification policy access can't change ringer mode",
683                         RINGER_MODE_SILENT, mAudioManager.getRingerMode());
684             } catch (SecurityException e) {
685             }
686 
687             try {
688                 mAudioManager.setStreamMute(stream, false);
689                 assertEquals("Apps without Notification policy access can't change ringer mode",
690                         RINGER_MODE_SILENT, mAudioManager.getRingerMode());
691             } catch (SecurityException e) {
692             }
693         }
694 
695         // This ensures we're out of vibrate or silent modes.
696         Utils.toggleNotificationPolicyAccess(
697                 mContext.getPackageName(), getInstrumentation(), true);
698         mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
699         for (int stream : streams) {
700             // ensure each stream is on and turned up.
701             mAudioManager.setStreamVolume(stream,
702                     mAudioManager.getStreamMaxVolume(stream),
703                     0);
704 
705             Utils.toggleNotificationPolicyAccess(
706                     mContext.getPackageName(), getInstrumentation(), false);
707             try {
708                 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_MUTE, 0);
709                 assertEquals("Apps without Notification policy access can't change ringer mode",
710                         RINGER_MODE_NORMAL, mAudioManager.getRingerMode());
711             } catch (SecurityException e) {
712             }
713             try {
714                 mAudioManager.adjustStreamVolume(
715                         stream, AudioManager.ADJUST_TOGGLE_MUTE, 0);
716                 assertEquals("Apps without Notification policy access can't change ringer mode",
717                         RINGER_MODE_NORMAL, mAudioManager.getRingerMode());
718             } catch (SecurityException e) {
719             }
720 
721             try {
722                 mAudioManager.setStreamMute(stream, true);
723                 assertEquals("Apps without Notification policy access can't change ringer mode",
724                         RINGER_MODE_NORMAL, mAudioManager.getRingerMode());
725             } catch (SecurityException e) {
726             }
727             Utils.toggleNotificationPolicyAccess(
728                     mContext.getPackageName(), getInstrumentation(), true);
729             testStreamMuting(stream);
730         }
731     }
732 
testMuteDndUnaffectedStreams()733     public void testMuteDndUnaffectedStreams() throws Exception {
734         if (mUseFixedVolume  || mIsTelevision) {
735             return;
736         }
737         int[] streams = {
738                 AudioManager.STREAM_VOICE_CALL,
739                 AudioManager.STREAM_MUSIC,
740                 AudioManager.STREAM_ALARM
741         };
742 
743         int muteAffectedStreams = System.getInt(mContext.getContentResolver(),
744                 System.MUTE_STREAMS_AFFECTED,
745                 // Same defaults as in AudioService. Should be kept in
746                 // sync.
747                 ((1 << AudioManager.STREAM_MUSIC) |
748                         (1 << AudioManager.STREAM_RING) |
749                         (1 << AudioManager.STREAM_NOTIFICATION) |
750                         (1 << AudioManager.STREAM_SYSTEM)));
751         Utils.toggleNotificationPolicyAccess(
752                 mContext.getPackageName(), getInstrumentation(), true);
753         // This ensures we're out of vibrate or silent modes.
754         mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
755         Utils.toggleNotificationPolicyAccess(
756                 mContext.getPackageName(), getInstrumentation(), false);
757         for (int stream : streams) {
758             // ensure each stream is on and turned up.
759             mAudioManager.setStreamVolume(stream,
760                     mAudioManager.getStreamMaxVolume(stream),
761                     0);
762             if (((1 << stream) & muteAffectedStreams) == 0) {
763                 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_MUTE, 0);
764                 assertFalse("Stream " + stream + " should not be affected by mute.",
765                         mAudioManager.isStreamMute(stream));
766                 mAudioManager.setStreamMute(stream, true);
767                 assertFalse("Stream " + stream + " should not be affected by mute.",
768                         mAudioManager.isStreamMute(stream));
769                 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_TOGGLE_MUTE,
770                         0);
771                 assertFalse("Stream " + stream + " should not be affected by mute.",
772                         mAudioManager.isStreamMute(stream));
773                 continue;
774             }
775             testStreamMuting(stream);
776         }
777     }
778 
testStreamMuting(int stream)779     private void testStreamMuting(int stream) {
780         mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_MUTE, 0);
781         assertTrue("Muting stream " + stream + " failed.",
782                 mAudioManager.isStreamMute(stream));
783 
784         mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_UNMUTE, 0);
785         assertFalse("Unmuting stream " + stream + " failed.",
786                 mAudioManager.isStreamMute(stream));
787 
788         mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_TOGGLE_MUTE, 0);
789         assertTrue("Toggling mute on stream " + stream + " failed.",
790                 mAudioManager.isStreamMute(stream));
791 
792         mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_TOGGLE_MUTE, 0);
793         assertFalse("Toggling mute on stream " + stream + " failed.",
794                 mAudioManager.isStreamMute(stream));
795 
796         mAudioManager.setStreamMute(stream, true);
797         assertTrue("Muting stream " + stream + " using setStreamMute failed",
798                 mAudioManager.isStreamMute(stream));
799 
800         // mute it three more times to verify the ref counting is gone.
801         mAudioManager.setStreamMute(stream, true);
802         mAudioManager.setStreamMute(stream, true);
803         mAudioManager.setStreamMute(stream, true);
804 
805         mAudioManager.setStreamMute(stream, false);
806         assertFalse("Unmuting stream " + stream + " using setStreamMute failed.",
807                 mAudioManager.isStreamMute(stream));
808     }
809 
testSetInvalidRingerMode()810     public void testSetInvalidRingerMode() {
811         int ringerMode = mAudioManager.getRingerMode();
812         mAudioManager.setRingerMode(-1337);
813         assertEquals(ringerMode, mAudioManager.getRingerMode());
814 
815         mAudioManager.setRingerMode(-3007);
816         assertEquals(ringerMode, mAudioManager.getRingerMode());
817     }
818 
testAdjustVolumeInTotalSilenceMode()819     public void testAdjustVolumeInTotalSilenceMode() throws Exception {
820         if (mUseFixedVolume || mIsTelevision) {
821             return;
822         }
823         try {
824             Utils.toggleNotificationPolicyAccess(
825                     mContext.getPackageName(), getInstrumentation(), true);
826             mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0);
827             setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_NONE);
828 
829             int musicVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
830             mAudioManager.adjustStreamVolume(
831                     AudioManager.STREAM_MUSIC, AudioManager.ADJUST_RAISE, 0);
832             assertEquals(musicVolume, mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC));
833 
834         } finally {
835             setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL);
836         }
837     }
838 
testAdjustVolumeInAlarmsOnlyMode()839     public void testAdjustVolumeInAlarmsOnlyMode() throws Exception {
840         if (mUseFixedVolume || mIsTelevision) {
841             return;
842         }
843         try {
844             Utils.toggleNotificationPolicyAccess(
845                     mContext.getPackageName(), getInstrumentation(), true);
846             mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0);
847             setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALARMS);
848 
849             int musicVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
850             mAudioManager.adjustStreamVolume(
851                     AudioManager.STREAM_MUSIC, AudioManager.ADJUST_RAISE, 0);
852             int volumeDelta =
853                     getVolumeDelta(mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC));
854             assertEquals(musicVolume + volumeDelta,
855                     mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC));
856 
857         } finally {
858             setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL);
859         }
860     }
861 
testSetStreamVolumeInTotalSilenceMode()862     public void testSetStreamVolumeInTotalSilenceMode() throws Exception {
863         if (mUseFixedVolume || mIsTelevision) {
864             return;
865         }
866         try {
867             Utils.toggleNotificationPolicyAccess(
868                     mContext.getPackageName(), getInstrumentation(), true);
869             mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 1, 0);
870             mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0);
871             setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_NONE);
872 
873             int musicVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
874             mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 7, 0);
875             assertEquals(musicVolume, mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC));
876 
877             mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 7, 0);
878             assertEquals(7, mAudioManager.getStreamVolume(AudioManager.STREAM_RING));
879         } finally {
880             setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL);
881         }
882     }
883 
testSetStreamVolumeInAlarmsOnlyMode()884     public void testSetStreamVolumeInAlarmsOnlyMode() throws Exception {
885         if (mUseFixedVolume || mIsTelevision) {
886             return;
887         }
888         try {
889             Utils.toggleNotificationPolicyAccess(
890                     mContext.getPackageName(), getInstrumentation(), true);
891             mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 1, 0);
892             mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0);
893             setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALARMS);
894 
895             mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 3, 0);
896             assertEquals(3, mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC));
897 
898             mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 7, 0);
899             assertEquals(7, mAudioManager.getStreamVolume(AudioManager.STREAM_RING));
900         } finally {
901             setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL);
902         }
903     }
904 
setInterruptionFilter(int filter)905     private void setInterruptionFilter(int filter) throws Exception {
906         mNm.setInterruptionFilter(filter);
907         for (int i = 0; i < 5; i++) {
908             if (mNm.getCurrentInterruptionFilter() == filter) {
909                 break;
910             }
911             Thread.sleep(1000);
912         }
913     }
914 
getVolumeDelta(int volume)915     private int getVolumeDelta(int volume) {
916         return 1;
917     }
918 
919 }
920