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