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_ACCESSIBILITY; 30 import static android.media.AudioManager.STREAM_MUSIC; 31 import static android.media.AudioManager.STREAM_RING; 32 import static android.media.AudioManager.USE_DEFAULT_STREAM_TYPE; 33 import static android.media.AudioManager.VIBRATE_SETTING_OFF; 34 import static android.media.AudioManager.VIBRATE_SETTING_ON; 35 import static android.media.AudioManager.VIBRATE_SETTING_ONLY_SILENT; 36 import static android.media.AudioManager.VIBRATE_TYPE_NOTIFICATION; 37 import static android.media.AudioManager.VIBRATE_TYPE_RINGER; 38 import static android.provider.Settings.System.SOUND_EFFECTS_ENABLED; 39 40 import android.app.ActivityManager; 41 import android.app.NotificationChannel; 42 import android.app.NotificationManager; 43 import android.content.BroadcastReceiver; 44 import android.content.Context; 45 import android.content.Intent; 46 import android.content.IntentFilter; 47 import android.content.pm.PackageManager; 48 import android.content.res.Resources; 49 import android.media.AudioAttributes; 50 import android.media.AudioDeviceInfo; 51 import android.media.AudioManager; 52 import android.media.MediaPlayer; 53 import android.media.MicrophoneInfo; 54 import android.os.Vibrator; 55 import android.platform.test.annotations.AppModeFull; 56 import android.provider.Settings; 57 import android.provider.Settings.System; 58 import android.test.InstrumentationTestCase; 59 import android.text.TextUtils; 60 import android.util.Log; 61 import android.view.SoundEffectConstants; 62 63 import com.android.compatibility.common.util.CddTest; 64 import com.android.internal.annotations.GuardedBy; 65 66 import java.util.HashMap; 67 import java.util.List; 68 import java.util.Map; 69 70 public class AudioManagerTest extends InstrumentationTestCase { 71 private final static String TAG = "AudioManagerTest"; 72 73 private final static long ASYNC_TIMING_TOLERANCE_MS = 50; 74 private final static int MP3_TO_PLAY = R.raw.testmp3; 75 private final static long TIME_TO_PLAY = 2000; 76 private final static String APPOPS_OP_STR = "android:write_settings"; 77 private AudioManager mAudioManager; 78 private NotificationManager mNm; 79 private boolean mHasVibrator; 80 private boolean mUseFixedVolume; 81 private boolean mIsTelevision; 82 private boolean mIsSingleVolume; 83 private boolean mSkipRingerTests; 84 // From N onwards, ringer mode adjustments that toggle DND are not allowed unless 85 // package has DND access. Many tests in this package toggle DND access in order 86 // to get device out of the DND state for the test to proceed correctly. 87 // But DND access is disabled completely on low ram devices, 88 // so completely skip those tests here. 89 // These tests are migrated to CTS verifier tests to ensure test coverage. 90 private boolean mSupportNotificationPolicyAccess; 91 private Context mContext; 92 private int mOriginalRingerMode; 93 private Map<Integer, Integer> mOriginalStreamVolumes = new HashMap<>(); 94 private NotificationManager.Policy mOriginalNotificationPolicy; 95 private int mOriginalZen; 96 97 @Override 98 protected void setUp() throws Exception { 99 super.setUp(); 100 mContext = getInstrumentation().getContext(); 101 Utils.enableAppOps(mContext.getPackageName(), APPOPS_OP_STR, getInstrumentation()); 102 mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE); 103 Vibrator vibrator = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE); 104 mNm = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE); 105 mHasVibrator = (vibrator != null) && vibrator.hasVibrator(); 106 mUseFixedVolume = mContext.getResources().getBoolean( 107 Resources.getSystem().getIdentifier("config_useFixedVolume", "bool", "android")); 108 PackageManager packageManager = mContext.getPackageManager(); 109 mIsTelevision = packageManager != null 110 && (packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK) 111 || packageManager.hasSystemFeature(PackageManager.FEATURE_TELEVISION)); 112 mIsSingleVolume = mContext.getResources().getBoolean( 113 Resources.getSystem().getIdentifier("config_single_volume", "bool", "android")); 114 mSkipRingerTests = mUseFixedVolume || mIsTelevision || mIsSingleVolume; 115 ActivityManager am = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE); 116 mSupportNotificationPolicyAccess = !am.isLowRamDevice(); 117 118 // Store the original volumes that that they can be recovered in tearDown(). 119 final int[] streamTypes = { 120 AudioManager.STREAM_VOICE_CALL, 121 AudioManager.STREAM_SYSTEM, 122 AudioManager.STREAM_RING, 123 AudioManager.STREAM_MUSIC, 124 AudioManager.STREAM_ALARM, 125 AudioManager.STREAM_NOTIFICATION, 126 AudioManager.STREAM_DTMF, 127 AudioManager.STREAM_ACCESSIBILITY, 128 }; 129 mOriginalRingerMode = mAudioManager.getRingerMode(); 130 for (int streamType : streamTypes) { 131 mOriginalStreamVolumes.put(streamType, mAudioManager.getStreamVolume(streamType)); 132 } 133 134 if (mSupportNotificationPolicyAccess) { 135 try { 136 Utils.toggleNotificationPolicyAccess( 137 mContext.getPackageName(), getInstrumentation(), true); 138 mOriginalNotificationPolicy = mNm.getNotificationPolicy(); 139 mOriginalZen = mNm.getCurrentInterruptionFilter(); 140 } finally { 141 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 142 Utils.toggleNotificationPolicyAccess( 143 mContext.getPackageName(), getInstrumentation(), false); 144 } 145 } 146 } 147 148 @Override 149 protected void tearDown() throws Exception { 150 if (!mSupportNotificationPolicyAccess) { 151 return; 152 } 153 try { 154 Utils.toggleNotificationPolicyAccess( 155 mContext.getPackageName(), getInstrumentation(), true); 156 mNm.setNotificationPolicy(mOriginalNotificationPolicy); 157 setInterruptionFilter(mOriginalZen); 158 159 // Recover the volume and the ringer mode that the test may have overwritten. 160 for (Map.Entry<Integer, Integer> e : mOriginalStreamVolumes.entrySet()) { 161 mAudioManager.setStreamVolume(e.getKey(), e.getValue(), 162 AudioManager.FLAG_ALLOW_RINGER_MODES); 163 } 164 mAudioManager.setRingerMode(mOriginalRingerMode); 165 } finally { 166 Utils.toggleNotificationPolicyAccess( 167 mContext.getPackageName(), getInstrumentation(), false); 168 } 169 } 170 171 @AppModeFull(reason = "Instant apps cannot hold android.permission.MODIFY_AUDIO_SETTINGS") 172 public void testMicrophoneMute() throws Exception { 173 mAudioManager.setMicrophoneMute(true); 174 assertTrue(mAudioManager.isMicrophoneMute()); 175 mAudioManager.setMicrophoneMute(false); 176 assertFalse(mAudioManager.isMicrophoneMute()); 177 } 178 179 @AppModeFull(reason = "Instant apps cannot hold android.permission.MODIFY_AUDIO_SETTINGS") 180 public void testMicrophoneMuteIntent() throws Exception { 181 // Skip this test for automotive. 182 // This tests listens for ACTION_MICROPHONE_MUTE_CHANGED which AudioService only broadcasts 183 // to system user. Automotive devices, which runs in secondary user, will fail this test. 184 if (mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE)) { 185 return; 186 } 187 188 final MyBlockingIntentReceiver receiver = new MyBlockingIntentReceiver( 189 AudioManager.ACTION_MICROPHONE_MUTE_CHANGED); 190 final boolean initialMicMute = mAudioManager.isMicrophoneMute(); 191 try { 192 mContext.registerReceiver(receiver, 193 new IntentFilter(AudioManager.ACTION_MICROPHONE_MUTE_CHANGED)); 194 // change the mic mute state 195 mAudioManager.setMicrophoneMute(!initialMicMute); 196 // verify a change was reported 197 final boolean intentFired = receiver.waitForExpectedAction(500/*ms*/); 198 assertTrue("ACTION_MICROPHONE_MUTE_CHANGED wasn't fired", intentFired); 199 // verify the mic mute state is expected 200 final boolean newMicMute = mAudioManager.isMicrophoneMute(); 201 assertTrue("new mic mute state not as expected (" + !initialMicMute + ")", 202 newMicMute == !initialMicMute); 203 } finally { 204 mContext.unregisterReceiver(receiver); 205 mAudioManager.setMicrophoneMute(initialMicMute); 206 } 207 } 208 209 @AppModeFull(reason = "Instant apps cannot hold android.permission.MODIFY_AUDIO_SETTINGS") 210 public void testSpeakerphoneIntent() throws Exception { 211 final MyBlockingIntentReceiver receiver = new MyBlockingIntentReceiver( 212 AudioManager.ACTION_SPEAKERPHONE_STATE_CHANGED); 213 final boolean initialSpeakerphoneState = mAudioManager.isSpeakerphoneOn(); 214 try { 215 mContext.registerReceiver(receiver, 216 new IntentFilter(AudioManager.ACTION_SPEAKERPHONE_STATE_CHANGED)); 217 // change the speakerphone state 218 mAudioManager.setSpeakerphoneOn(!initialSpeakerphoneState); 219 // verify a change was reported 220 final boolean intentFired = receiver.waitForExpectedAction(500/*ms*/); 221 assertTrue("ACTION_SPEAKERPHONE_STATE_CHANGED wasn't fired", intentFired); 222 // verify the speakerphon state is expected 223 final boolean newSpeakerphoneState = mAudioManager.isSpeakerphoneOn(); 224 assertTrue("new mic mute state not as expected (" 225 + !initialSpeakerphoneState + ")", 226 newSpeakerphoneState == !initialSpeakerphoneState); 227 } finally { 228 mContext.unregisterReceiver(receiver); 229 mAudioManager.setSpeakerphoneOn(initialSpeakerphoneState); 230 } 231 } 232 233 private static final class MyBlockingIntentReceiver extends BroadcastReceiver { 234 private final SafeWaitObject mLock = new SafeWaitObject(); 235 // the action for the intent to check 236 private final String mAction; 237 @GuardedBy("mLock") 238 private boolean mIntentReceived = false; 239 240 MyBlockingIntentReceiver(String action) { 241 mAction = action; 242 } 243 244 @Override 245 public void onReceive(Context context, Intent intent) { 246 if (!TextUtils.equals(intent.getAction(), mAction)) { 247 // move along, this is not the action we're looking for 248 return; 249 } 250 synchronized (mLock) { 251 mIntentReceived = true; 252 mLock.safeNotify(); 253 } 254 } 255 256 public boolean waitForExpectedAction(long timeOutMs) { 257 synchronized (mLock) { 258 try { 259 mLock.safeWait(timeOutMs); 260 } catch (InterruptedException e) { } 261 return mIntentReceived; 262 } 263 } 264 } 265 266 public void testSoundEffects() throws Exception { 267 Settings.System.putInt(mContext.getContentResolver(), SOUND_EFFECTS_ENABLED, 1); 268 269 // should hear sound after loadSoundEffects() called. 270 mAudioManager.loadSoundEffects(); 271 Thread.sleep(TIME_TO_PLAY); 272 float volume = 13; 273 mAudioManager.playSoundEffect(SoundEffectConstants.CLICK); 274 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_UP); 275 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_DOWN); 276 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_LEFT); 277 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_RIGHT); 278 279 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_UP, volume); 280 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_DOWN, volume); 281 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_LEFT, volume); 282 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_RIGHT, volume); 283 284 // won't hear sound after unloadSoundEffects() called(); 285 mAudioManager.unloadSoundEffects(); 286 mAudioManager.playSoundEffect(AudioManager.FX_KEY_CLICK); 287 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_UP); 288 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_DOWN); 289 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_LEFT); 290 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_RIGHT); 291 292 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_UP, volume); 293 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_DOWN, volume); 294 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_LEFT, volume); 295 mAudioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_RIGHT, volume); 296 } 297 298 public void testCheckingZenModeBlockDoesNotRequireNotificationPolicyAccess() throws Exception { 299 if (!mSupportNotificationPolicyAccess) { 300 return; 301 } 302 try { 303 // set zen mode to priority only, so playSoundEffect will check notification policy 304 Utils.toggleNotificationPolicyAccess(mContext.getPackageName(), getInstrumentation(), 305 true); 306 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_PRIORITY); 307 Settings.System.putInt(mContext.getContentResolver(), SOUND_EFFECTS_ENABLED, 1); 308 309 // take away write-notification policy access from the package 310 Utils.toggleNotificationPolicyAccess(mContext.getPackageName(), getInstrumentation(), 311 false); 312 313 // playSoundEffect should NOT throw a security exception; all apps have read-access 314 mAudioManager.playSoundEffect(SoundEffectConstants.CLICK); 315 } finally { 316 Utils.toggleNotificationPolicyAccess(mContext.getPackageName(), getInstrumentation(), 317 true); 318 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 319 Utils.toggleNotificationPolicyAccess(mContext.getPackageName(), getInstrumentation(), 320 false); 321 } 322 } 323 324 public void testMusicActive() throws Exception { 325 if (mAudioManager.isMusicActive()) { 326 return; 327 } 328 MediaPlayer mp = MediaPlayer.create(mContext, MP3_TO_PLAY); 329 assertNotNull(mp); 330 mp.setAudioStreamType(AudioManager.STREAM_MUSIC); 331 mp.start(); 332 Thread.sleep(TIME_TO_PLAY); 333 assertTrue(mAudioManager.isMusicActive()); 334 Thread.sleep(TIME_TO_PLAY); 335 mp.stop(); 336 mp.release(); 337 Thread.sleep(TIME_TO_PLAY); 338 assertFalse(mAudioManager.isMusicActive()); 339 } 340 341 @AppModeFull(reason = "Instant apps cannot hold android.permission.MODIFY_AUDIO_SETTINGS") 342 public void testAccessMode() throws Exception { 343 mAudioManager.setMode(MODE_RINGTONE); 344 assertEquals(MODE_RINGTONE, mAudioManager.getMode()); 345 mAudioManager.setMode(MODE_IN_COMMUNICATION); 346 assertEquals(MODE_IN_COMMUNICATION, mAudioManager.getMode()); 347 mAudioManager.setMode(MODE_NORMAL); 348 assertEquals(MODE_NORMAL, mAudioManager.getMode()); 349 } 350 351 @SuppressWarnings("deprecation") 352 @AppModeFull(reason = "Instant apps cannot hold android.permission.MODIFY_AUDIO_SETTINGS") 353 public void testRouting() throws Exception { 354 // setBluetoothA2dpOn is a no-op, and getRouting should always return -1 355 // AudioManager.MODE_CURRENT 356 boolean oldA2DP = mAudioManager.isBluetoothA2dpOn(); 357 mAudioManager.setBluetoothA2dpOn(true); 358 assertEquals(oldA2DP , mAudioManager.isBluetoothA2dpOn()); 359 mAudioManager.setBluetoothA2dpOn(false); 360 assertEquals(oldA2DP , mAudioManager.isBluetoothA2dpOn()); 361 362 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_RINGTONE)); 363 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_NORMAL)); 364 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_CALL)); 365 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_COMMUNICATION)); 366 367 mAudioManager.setBluetoothScoOn(true); 368 assertTrue(mAudioManager.isBluetoothScoOn()); 369 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_RINGTONE)); 370 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_NORMAL)); 371 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_CALL)); 372 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_COMMUNICATION)); 373 374 mAudioManager.setBluetoothScoOn(false); 375 assertFalse(mAudioManager.isBluetoothScoOn()); 376 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_RINGTONE)); 377 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_NORMAL)); 378 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_CALL)); 379 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_COMMUNICATION)); 380 381 mAudioManager.setSpeakerphoneOn(true); 382 assertTrue(mAudioManager.isSpeakerphoneOn()); 383 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_CALL)); 384 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_COMMUNICATION)); 385 mAudioManager.setSpeakerphoneOn(false); 386 assertFalse(mAudioManager.isSpeakerphoneOn()); 387 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_CALL)); 388 assertEquals(AudioManager.MODE_CURRENT, mAudioManager.getRouting(MODE_IN_COMMUNICATION)); 389 } 390 391 public void testVibrateNotification() throws Exception { 392 if (mUseFixedVolume || !mHasVibrator || !mSupportNotificationPolicyAccess) { 393 return; 394 } 395 Utils.toggleNotificationPolicyAccess( 396 mContext.getPackageName(), getInstrumentation(), true); 397 // VIBRATE_SETTING_ON 398 mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_ON); 399 assertEquals(mHasVibrator ? VIBRATE_SETTING_ON : VIBRATE_SETTING_OFF, 400 mAudioManager.getVibrateSetting(VIBRATE_TYPE_NOTIFICATION)); 401 mAudioManager.setRingerMode(RINGER_MODE_NORMAL); 402 assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION)); 403 404 mAudioManager.setRingerMode(RINGER_MODE_SILENT); 405 assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION)); 406 407 mAudioManager.setRingerMode(RINGER_MODE_VIBRATE); 408 assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT, 409 mAudioManager.getRingerMode()); 410 assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION)); 411 412 // VIBRATE_SETTING_OFF 413 mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_OFF); 414 assertEquals(VIBRATE_SETTING_OFF, 415 mAudioManager.getVibrateSetting(VIBRATE_TYPE_NOTIFICATION)); 416 mAudioManager.setRingerMode(RINGER_MODE_NORMAL); 417 assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION)); 418 419 mAudioManager.setRingerMode(RINGER_MODE_SILENT); 420 assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION)); 421 422 mAudioManager.setRingerMode(RINGER_MODE_VIBRATE); 423 assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT, 424 mAudioManager.getRingerMode()); 425 assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION)); 426 427 // VIBRATE_SETTING_ONLY_SILENT 428 mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_ONLY_SILENT); 429 assertEquals(mHasVibrator ? VIBRATE_SETTING_ONLY_SILENT : VIBRATE_SETTING_OFF, 430 mAudioManager.getVibrateSetting(VIBRATE_TYPE_NOTIFICATION)); 431 mAudioManager.setRingerMode(RINGER_MODE_NORMAL); 432 assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION)); 433 434 mAudioManager.setRingerMode(RINGER_MODE_SILENT); 435 assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION)); 436 437 mAudioManager.setRingerMode(RINGER_MODE_VIBRATE); 438 assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT, 439 mAudioManager.getRingerMode()); 440 assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION)); 441 442 // VIBRATE_TYPE_NOTIFICATION 443 mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_ON); 444 assertEquals(mHasVibrator ? VIBRATE_SETTING_ON : VIBRATE_SETTING_OFF, 445 mAudioManager.getVibrateSetting(VIBRATE_TYPE_NOTIFICATION)); 446 mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_OFF); 447 assertEquals(VIBRATE_SETTING_OFF, mAudioManager 448 .getVibrateSetting(VIBRATE_TYPE_NOTIFICATION)); 449 mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_ONLY_SILENT); 450 assertEquals(mHasVibrator ? VIBRATE_SETTING_ONLY_SILENT : VIBRATE_SETTING_OFF, 451 mAudioManager.getVibrateSetting(VIBRATE_TYPE_NOTIFICATION)); 452 } 453 454 public void testVibrateRinger() throws Exception { 455 if (mUseFixedVolume || !mHasVibrator || !mSupportNotificationPolicyAccess) { 456 return; 457 } 458 Utils.toggleNotificationPolicyAccess( 459 mContext.getPackageName(), getInstrumentation(), true); 460 // VIBRATE_TYPE_RINGER 461 mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_ON); 462 assertEquals(mHasVibrator ? VIBRATE_SETTING_ON : VIBRATE_SETTING_OFF, 463 mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER)); 464 mAudioManager.setRingerMode(RINGER_MODE_NORMAL); 465 assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER)); 466 467 mAudioManager.setRingerMode(RINGER_MODE_SILENT); 468 assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER)); 469 470 mAudioManager.setRingerMode(RINGER_MODE_VIBRATE); 471 assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT, 472 mAudioManager.getRingerMode()); 473 assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER)); 474 475 // VIBRATE_SETTING_OFF 476 mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_OFF); 477 assertEquals(VIBRATE_SETTING_OFF, mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER)); 478 mAudioManager.setRingerMode(RINGER_MODE_NORMAL); 479 assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER)); 480 481 mAudioManager.setRingerMode(RINGER_MODE_SILENT); 482 assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER)); 483 484 mAudioManager.setRingerMode(RINGER_MODE_VIBRATE); 485 assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT, 486 mAudioManager.getRingerMode()); 487 // Note: as of Froyo, if VIBRATE_TYPE_RINGER is set to OFF, it will 488 // not vibrate, even in RINGER_MODE_VIBRATE. This allows users to 489 // disable the vibration for incoming calls only. 490 assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER)); 491 492 // VIBRATE_SETTING_ONLY_SILENT 493 mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_ONLY_SILENT); 494 assertEquals(mHasVibrator ? VIBRATE_SETTING_ONLY_SILENT : VIBRATE_SETTING_OFF, 495 mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER)); 496 mAudioManager.setRingerMode(RINGER_MODE_NORMAL); 497 assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER)); 498 499 mAudioManager.setRingerMode(RINGER_MODE_SILENT); 500 assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER)); 501 502 mAudioManager.setRingerMode(RINGER_MODE_VIBRATE); 503 assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT, 504 mAudioManager.getRingerMode()); 505 assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER)); 506 507 // VIBRATE_TYPE_NOTIFICATION 508 mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_ON); 509 assertEquals(mHasVibrator ? VIBRATE_SETTING_ON : VIBRATE_SETTING_OFF, 510 mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER)); 511 mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_OFF); 512 assertEquals(VIBRATE_SETTING_OFF, mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER)); 513 mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_ONLY_SILENT); 514 assertEquals(mHasVibrator ? VIBRATE_SETTING_ONLY_SILENT : VIBRATE_SETTING_OFF, 515 mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER)); 516 } 517 518 public void testAccessRingMode() throws Exception { 519 if (!mSupportNotificationPolicyAccess) { 520 return; 521 } 522 Utils.toggleNotificationPolicyAccess( 523 mContext.getPackageName(), getInstrumentation(), true); 524 mAudioManager.setRingerMode(RINGER_MODE_NORMAL); 525 assertEquals(RINGER_MODE_NORMAL, mAudioManager.getRingerMode()); 526 527 mAudioManager.setRingerMode(RINGER_MODE_SILENT); 528 // AudioService#setRingerMode() has: 529 // if (isTelevision) return; 530 if (mSkipRingerTests) { 531 assertEquals(RINGER_MODE_NORMAL, mAudioManager.getRingerMode()); 532 } else { 533 assertEquals(RINGER_MODE_SILENT, mAudioManager.getRingerMode()); 534 } 535 536 mAudioManager.setRingerMode(RINGER_MODE_VIBRATE); 537 if (mSkipRingerTests) { 538 assertEquals(RINGER_MODE_NORMAL, mAudioManager.getRingerMode()); 539 } else { 540 assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT, 541 mAudioManager.getRingerMode()); 542 } 543 } 544 545 public void testSetRingerModePolicyAccess() throws Exception { 546 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 547 return; 548 } 549 // Apps without policy access cannot change silent -> normal or silent -> vibrate. 550 Utils.toggleNotificationPolicyAccess( 551 mContext.getPackageName(), getInstrumentation(), true); 552 mAudioManager.setRingerMode(RINGER_MODE_SILENT); 553 assertEquals(RINGER_MODE_SILENT, mAudioManager.getRingerMode()); 554 Utils.toggleNotificationPolicyAccess( 555 mContext.getPackageName(), getInstrumentation(), false); 556 557 try { 558 mAudioManager.setRingerMode(RINGER_MODE_NORMAL); 559 fail("Apps without notification policy access cannot change ringer mode"); 560 } catch (SecurityException e) { 561 } 562 563 try { 564 mAudioManager.setRingerMode(RINGER_MODE_VIBRATE); 565 fail("Apps without notification policy access cannot change ringer mode"); 566 } catch (SecurityException e) { 567 } 568 569 // Apps without policy access cannot change normal -> silent. 570 Utils.toggleNotificationPolicyAccess( 571 mContext.getPackageName(), getInstrumentation(), true); 572 mAudioManager.setRingerMode(RINGER_MODE_NORMAL); 573 assertEquals(RINGER_MODE_NORMAL, mAudioManager.getRingerMode()); 574 Utils.toggleNotificationPolicyAccess( 575 mContext.getPackageName(), getInstrumentation(), false); 576 577 try { 578 mAudioManager.setRingerMode(RINGER_MODE_SILENT); 579 fail("Apps without notification policy access cannot change ringer mode"); 580 } catch (SecurityException e) { 581 } 582 assertEquals(RINGER_MODE_NORMAL, mAudioManager.getRingerMode()); 583 584 if (mHasVibrator) { 585 // Apps without policy access cannot change vibrate -> silent. 586 Utils.toggleNotificationPolicyAccess( 587 mContext.getPackageName(), getInstrumentation(), true); 588 mAudioManager.setRingerMode(RINGER_MODE_VIBRATE); 589 assertEquals(RINGER_MODE_VIBRATE, mAudioManager.getRingerMode()); 590 Utils.toggleNotificationPolicyAccess( 591 mContext.getPackageName(), getInstrumentation(), false); 592 593 try { 594 mAudioManager.setRingerMode(RINGER_MODE_SILENT); 595 fail("Apps without notification policy access cannot change ringer mode"); 596 } catch (SecurityException e) { 597 } 598 599 // Apps without policy access can change vibrate -> normal and vice versa. 600 assertEquals(RINGER_MODE_VIBRATE, mAudioManager.getRingerMode()); 601 mAudioManager.setRingerMode(RINGER_MODE_NORMAL); 602 assertEquals(RINGER_MODE_NORMAL, mAudioManager.getRingerMode()); 603 mAudioManager.setRingerMode(RINGER_MODE_VIBRATE); 604 assertEquals(RINGER_MODE_VIBRATE, mAudioManager.getRingerMode()); 605 } 606 } 607 608 public void testVolume() throws Exception { 609 if (!mSupportNotificationPolicyAccess) { 610 return; 611 } 612 Utils.toggleNotificationPolicyAccess( 613 mContext.getPackageName(), getInstrumentation(), true); 614 int volume, volumeDelta; 615 int[] streams = {AudioManager.STREAM_ALARM, 616 AudioManager.STREAM_MUSIC, 617 AudioManager.STREAM_VOICE_CALL, 618 AudioManager.STREAM_RING}; 619 620 mAudioManager.adjustVolume(ADJUST_RAISE, 0); 621 // adjusting volume is aynchronous, wait before other volume checks 622 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 623 mAudioManager.adjustSuggestedStreamVolume( 624 ADJUST_LOWER, USE_DEFAULT_STREAM_TYPE, 0); 625 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 626 int maxMusicVolume = mAudioManager.getStreamMaxVolume(STREAM_MUSIC); 627 628 for (int stream : streams) { 629 // set ringer mode to back normal to not interfere with volume tests 630 mAudioManager.setRingerMode(RINGER_MODE_NORMAL); 631 632 int maxVolume = mAudioManager.getStreamMaxVolume(stream); 633 int minVolume = mAudioManager.getStreamMinVolume(stream); 634 635 // validate min 636 assertTrue(String.format("minVolume(%d) must be >= 0", minVolume), minVolume >= 0); 637 assertTrue(String.format("minVolume(%d) must be < maxVolume(%d)", minVolume, 638 maxVolume), 639 minVolume < maxVolume); 640 641 mAudioManager.setStreamVolume(stream, 1, 0); 642 if (mUseFixedVolume) { 643 assertEquals(maxVolume, mAudioManager.getStreamVolume(stream)); 644 continue; 645 } 646 assertEquals(String.format("stream=%d", stream), 647 1, mAudioManager.getStreamVolume(stream)); 648 649 if (stream == AudioManager.STREAM_MUSIC && mAudioManager.isWiredHeadsetOn()) { 650 // due to new regulations, music sent over a wired headset may be volume limited 651 // until the user explicitly increases the limit, so we can't rely on being able 652 // to set the volume to getStreamMaxVolume(). Instead, determine the current limit 653 // by increasing the volume until it won't go any higher, then use that volume as 654 // the maximum for the purposes of this test 655 int curvol = 0; 656 int prevvol = 0; 657 do { 658 prevvol = curvol; 659 mAudioManager.adjustStreamVolume(stream, ADJUST_RAISE, 0); 660 curvol = mAudioManager.getStreamVolume(stream); 661 } while (curvol != prevvol); 662 maxVolume = maxMusicVolume = curvol; 663 } 664 mAudioManager.setStreamVolume(stream, maxVolume, 0); 665 mAudioManager.adjustStreamVolume(stream, ADJUST_RAISE, 0); 666 assertEquals(maxVolume, mAudioManager.getStreamVolume(stream)); 667 668 volumeDelta = getVolumeDelta(mAudioManager.getStreamVolume(stream)); 669 mAudioManager.adjustSuggestedStreamVolume(ADJUST_LOWER, stream, 0); 670 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 671 assertEquals(maxVolume - volumeDelta, mAudioManager.getStreamVolume(stream)); 672 673 // volume lower 674 mAudioManager.setStreamVolume(stream, maxVolume, 0); 675 volume = mAudioManager.getStreamVolume(stream); 676 while (volume > minVolume) { 677 volumeDelta = getVolumeDelta(mAudioManager.getStreamVolume(stream)); 678 mAudioManager.adjustStreamVolume(stream, ADJUST_LOWER, 0); 679 assertEquals(Math.max(0, volume - volumeDelta), 680 mAudioManager.getStreamVolume(stream)); 681 volume = mAudioManager.getStreamVolume(stream); 682 } 683 684 mAudioManager.adjustStreamVolume(stream, ADJUST_SAME, 0); 685 686 // volume raise 687 mAudioManager.setStreamVolume(stream, 1, 0); 688 volume = mAudioManager.getStreamVolume(stream); 689 while (volume < maxVolume) { 690 volumeDelta = getVolumeDelta(mAudioManager.getStreamVolume(stream)); 691 mAudioManager.adjustStreamVolume(stream, ADJUST_RAISE, 0); 692 assertEquals(Math.min(volume + volumeDelta, maxVolume), 693 mAudioManager.getStreamVolume(stream)); 694 volume = mAudioManager.getStreamVolume(stream); 695 } 696 697 // volume same 698 mAudioManager.setStreamVolume(stream, maxVolume, 0); 699 for (int k = 0; k < maxVolume; k++) { 700 mAudioManager.adjustStreamVolume(stream, ADJUST_SAME, 0); 701 assertEquals(maxVolume, mAudioManager.getStreamVolume(stream)); 702 } 703 704 mAudioManager.setStreamVolume(stream, maxVolume, 0); 705 } 706 707 if (mUseFixedVolume) { 708 return; 709 } 710 711 // adjust volume 712 mAudioManager.adjustVolume(ADJUST_RAISE, 0); 713 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 714 715 boolean isMusicPlayingBeforeTest = false; 716 if (mAudioManager.isMusicActive()) { 717 isMusicPlayingBeforeTest = true; 718 } 719 720 MediaPlayer mp = MediaPlayer.create(mContext, MP3_TO_PLAY); 721 assertNotNull(mp); 722 mp.setAudioStreamType(STREAM_MUSIC); 723 mp.setLooping(true); 724 mp.start(); 725 Thread.sleep(TIME_TO_PLAY); 726 assertTrue(mAudioManager.isMusicActive()); 727 728 // adjust volume as ADJUST_SAME 729 for (int k = 0; k < maxMusicVolume; k++) { 730 mAudioManager.adjustVolume(ADJUST_SAME, 0); 731 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 732 assertEquals(maxMusicVolume, mAudioManager.getStreamVolume(STREAM_MUSIC)); 733 } 734 735 // adjust volume as ADJUST_RAISE 736 mAudioManager.setStreamVolume(STREAM_MUSIC, 0, 0); 737 volumeDelta = getVolumeDelta(mAudioManager.getStreamVolume(STREAM_MUSIC)); 738 mAudioManager.adjustVolume(ADJUST_RAISE, 0); 739 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 740 assertEquals(Math.min(volumeDelta, maxMusicVolume), 741 mAudioManager.getStreamVolume(STREAM_MUSIC)); 742 743 // adjust volume as ADJUST_LOWER 744 mAudioManager.setStreamVolume(STREAM_MUSIC, maxMusicVolume, 0); 745 maxMusicVolume = mAudioManager.getStreamVolume(STREAM_MUSIC); 746 volumeDelta = getVolumeDelta(mAudioManager.getStreamVolume(STREAM_MUSIC)); 747 mAudioManager.adjustVolume(ADJUST_LOWER, 0); 748 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 749 assertEquals(Math.max(0, maxMusicVolume - volumeDelta), 750 mAudioManager.getStreamVolume(STREAM_MUSIC)); 751 752 mp.stop(); 753 mp.release(); 754 Thread.sleep(TIME_TO_PLAY); 755 if (!isMusicPlayingBeforeTest) { 756 assertFalse(mAudioManager.isMusicActive()); 757 } 758 } 759 760 public void testAccessibilityVolume() throws Exception { 761 if (mUseFixedVolume) { 762 Log.i("AudioManagerTest", "testAccessibilityVolume() skipped: fixed volume"); 763 return; 764 } 765 final int maxA11yVol = mAudioManager.getStreamMaxVolume(STREAM_ACCESSIBILITY); 766 assertTrue("Max a11yVol not strictly positive", maxA11yVol > 0); 767 int currentVol = mAudioManager.getStreamVolume(STREAM_ACCESSIBILITY); 768 769 // changing STREAM_ACCESSIBILITY is subject to permission, shouldn't be able to change it 770 // test setStreamVolume 771 final int testSetVol; 772 if (currentVol != maxA11yVol) { 773 testSetVol = maxA11yVol; 774 } else { 775 testSetVol = maxA11yVol - 1; 776 } 777 mAudioManager.setStreamVolume(STREAM_ACCESSIBILITY, testSetVol, 0); 778 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 779 currentVol = mAudioManager.getStreamVolume(STREAM_ACCESSIBILITY); 780 assertTrue("Should not be able to change A11y vol", currentVol != testSetVol); 781 782 // test adjustStreamVolume 783 // LOWER 784 currentVol = mAudioManager.getStreamVolume(STREAM_ACCESSIBILITY); 785 if (currentVol > 0) { 786 mAudioManager.adjustStreamVolume(STREAM_ACCESSIBILITY, ADJUST_LOWER, 0); 787 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 788 int newVol = mAudioManager.getStreamVolume(STREAM_ACCESSIBILITY); 789 assertTrue("Should not be able to lower A11y vol", currentVol == newVol); 790 } 791 // RAISE 792 currentVol = mAudioManager.getStreamVolume(STREAM_ACCESSIBILITY); 793 if (currentVol < maxA11yVol) { 794 mAudioManager.adjustStreamVolume(STREAM_ACCESSIBILITY, ADJUST_RAISE, 0); 795 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 796 int newVol = mAudioManager.getStreamVolume(STREAM_ACCESSIBILITY); 797 assertTrue("Should not be able to raise A11y vol", currentVol == newVol); 798 } 799 } 800 801 public void testSetVoiceCallVolumeToZeroPermission() { 802 // Verify that only apps with MODIFY_PHONE_STATE can set VOICE_CALL_STREAM to 0 803 mAudioManager.setStreamVolume(AudioManager.STREAM_VOICE_CALL, 0, 0); 804 assertTrue("MODIFY_PHONE_STATE is required in order to set voice call volume to 0", 805 mAudioManager.getStreamVolume(AudioManager.STREAM_VOICE_CALL) != 0); 806 } 807 808 public void testMuteFixedVolume() throws Exception { 809 int[] streams = { 810 AudioManager.STREAM_VOICE_CALL, 811 AudioManager.STREAM_MUSIC, 812 AudioManager.STREAM_RING, 813 AudioManager.STREAM_ALARM, 814 AudioManager.STREAM_NOTIFICATION, 815 AudioManager.STREAM_SYSTEM}; 816 if (mUseFixedVolume) { 817 for (int stream : streams) { 818 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_MUTE, 0); 819 assertFalse("Muting should not affect a fixed volume device.", 820 mAudioManager.isStreamMute(stream)); 821 822 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_TOGGLE_MUTE, 0); 823 assertFalse("Toggling mute should not affect a fixed volume device.", 824 mAudioManager.isStreamMute(stream)); 825 826 mAudioManager.setStreamMute(stream, true); 827 assertFalse("Muting should not affect a fixed volume device.", 828 mAudioManager.isStreamMute(stream)); 829 } 830 } 831 } 832 833 public void testMuteDndAffectedStreams() throws Exception { 834 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 835 return; 836 } 837 int[] streams = { AudioManager.STREAM_RING }; 838 // Mute streams 839 Utils.toggleNotificationPolicyAccess( 840 mContext.getPackageName(), getInstrumentation(), true); 841 mAudioManager.setRingerMode(RINGER_MODE_SILENT); 842 Utils.toggleNotificationPolicyAccess( 843 mContext.getPackageName(), getInstrumentation(), false); 844 // Verify streams cannot be unmuted without policy access. 845 for (int stream : streams) { 846 try { 847 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_UNMUTE, 0); 848 assertEquals("Apps without Notification policy access can't change ringer mode", 849 RINGER_MODE_SILENT, mAudioManager.getRingerMode()); 850 } catch (SecurityException e) { 851 } 852 853 try { 854 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_TOGGLE_MUTE, 855 0); 856 assertEquals("Apps without Notification policy access can't change ringer mode", 857 RINGER_MODE_SILENT, mAudioManager.getRingerMode()); 858 } catch (SecurityException e) { 859 } 860 861 try { 862 mAudioManager.setStreamMute(stream, false); 863 assertEquals("Apps without Notification policy access can't change ringer mode", 864 RINGER_MODE_SILENT, mAudioManager.getRingerMode()); 865 } catch (SecurityException e) { 866 } 867 } 868 869 // This ensures we're out of vibrate or silent modes. 870 Utils.toggleNotificationPolicyAccess( 871 mContext.getPackageName(), getInstrumentation(), true); 872 mAudioManager.setRingerMode(RINGER_MODE_NORMAL); 873 for (int stream : streams) { 874 // ensure each stream is on and turned up. 875 mAudioManager.setStreamVolume(stream, 876 mAudioManager.getStreamMaxVolume(stream), 877 0); 878 879 Utils.toggleNotificationPolicyAccess( 880 mContext.getPackageName(), getInstrumentation(), false); 881 try { 882 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_MUTE, 0); 883 assertEquals("Apps without Notification policy access can't change ringer mode", 884 RINGER_MODE_NORMAL, mAudioManager.getRingerMode()); 885 } catch (SecurityException e) { 886 } 887 try { 888 mAudioManager.adjustStreamVolume( 889 stream, AudioManager.ADJUST_TOGGLE_MUTE, 0); 890 assertEquals("Apps without Notification policy access can't change ringer mode", 891 RINGER_MODE_NORMAL, mAudioManager.getRingerMode()); 892 } catch (SecurityException e) { 893 } 894 895 try { 896 mAudioManager.setStreamMute(stream, true); 897 assertEquals("Apps without Notification policy access can't change ringer mode", 898 RINGER_MODE_NORMAL, mAudioManager.getRingerMode()); 899 } catch (SecurityException e) { 900 } 901 Utils.toggleNotificationPolicyAccess( 902 mContext.getPackageName(), getInstrumentation(), true); 903 testStreamMuting(stream); 904 } 905 } 906 907 public void testMuteDndUnaffectedStreams() throws Exception { 908 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 909 return; 910 } 911 int[] streams = { 912 AudioManager.STREAM_VOICE_CALL, 913 AudioManager.STREAM_MUSIC, 914 AudioManager.STREAM_ALARM 915 }; 916 917 int muteAffectedStreams = System.getInt(mContext.getContentResolver(), 918 System.MUTE_STREAMS_AFFECTED, 919 // same defaults as in AudioService. Should be kept in sync. 920 (1 << STREAM_MUSIC) | 921 (1 << AudioManager.STREAM_RING) | 922 (1 << AudioManager.STREAM_NOTIFICATION) | 923 (1 << AudioManager.STREAM_SYSTEM) | 924 (1 << AudioManager.STREAM_VOICE_CALL)); 925 926 Utils.toggleNotificationPolicyAccess( 927 mContext.getPackageName(), getInstrumentation(), true); 928 // This ensures we're out of vibrate or silent modes. 929 mAudioManager.setRingerMode(RINGER_MODE_NORMAL); 930 Utils.toggleNotificationPolicyAccess( 931 mContext.getPackageName(), getInstrumentation(), false); 932 for (int stream : streams) { 933 // ensure each stream is on and turned up. 934 mAudioManager.setStreamVolume(stream, 935 mAudioManager.getStreamMaxVolume(stream), 936 0); 937 if (((1 << stream) & muteAffectedStreams) == 0) { 938 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_MUTE, 0); 939 assertFalse("Stream " + stream + " should not be affected by mute.", 940 mAudioManager.isStreamMute(stream)); 941 mAudioManager.setStreamMute(stream, true); 942 assertFalse("Stream " + stream + " should not be affected by mute.", 943 mAudioManager.isStreamMute(stream)); 944 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_TOGGLE_MUTE, 945 0); 946 assertFalse("Stream " + stream + " should not be affected by mute.", 947 mAudioManager.isStreamMute(stream)); 948 continue; 949 } 950 testStreamMuting(stream); 951 } 952 } 953 954 private void testStreamMuting(int stream) { 955 // Voice call requires MODIFY_PHONE_STATE, so we should not be able to mute 956 if (stream == AudioManager.STREAM_VOICE_CALL) { 957 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_MUTE, 0); 958 assertFalse("Muting voice call stream (" + stream + ") should require " 959 + "MODIFY_PHONE_STATE.", mAudioManager.isStreamMute(stream)); 960 } else { 961 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_MUTE, 0); 962 assertTrue("Muting stream " + stream + " failed.", 963 mAudioManager.isStreamMute(stream)); 964 965 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_UNMUTE, 0); 966 assertFalse("Unmuting stream " + stream + " failed.", 967 mAudioManager.isStreamMute(stream)); 968 969 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_TOGGLE_MUTE, 0); 970 assertTrue("Toggling mute on stream " + stream + " failed.", 971 mAudioManager.isStreamMute(stream)); 972 973 mAudioManager.adjustStreamVolume(stream, AudioManager.ADJUST_TOGGLE_MUTE, 0); 974 assertFalse("Toggling mute on stream " + stream + " failed.", 975 mAudioManager.isStreamMute(stream)); 976 977 mAudioManager.setStreamMute(stream, true); 978 assertTrue("Muting stream " + stream + " using setStreamMute failed", 979 mAudioManager.isStreamMute(stream)); 980 981 // mute it three more times to verify the ref counting is gone. 982 mAudioManager.setStreamMute(stream, true); 983 mAudioManager.setStreamMute(stream, true); 984 mAudioManager.setStreamMute(stream, true); 985 986 mAudioManager.setStreamMute(stream, false); 987 assertFalse("Unmuting stream " + stream + " using setStreamMute failed.", 988 mAudioManager.isStreamMute(stream)); 989 } 990 } 991 992 public void testSetInvalidRingerMode() { 993 int ringerMode = mAudioManager.getRingerMode(); 994 mAudioManager.setRingerMode(-1337); 995 assertEquals(ringerMode, mAudioManager.getRingerMode()); 996 997 mAudioManager.setRingerMode(-3007); 998 assertEquals(ringerMode, mAudioManager.getRingerMode()); 999 } 1000 1001 public void testAdjustVolumeInTotalSilenceMode() throws Exception { 1002 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 1003 return; 1004 } 1005 try { 1006 Utils.toggleNotificationPolicyAccess( 1007 mContext.getPackageName(), getInstrumentation(), true); 1008 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0); 1009 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_NONE); 1010 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 1011 int musicVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC); 1012 mAudioManager.adjustStreamVolume( 1013 AudioManager.STREAM_MUSIC, AudioManager.ADJUST_RAISE, 0); 1014 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 1015 assertEquals(musicVolume, mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC)); 1016 1017 } finally { 1018 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1019 } 1020 } 1021 1022 public void testAdjustVolumeInAlarmsOnlyMode() throws Exception { 1023 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 1024 return; 1025 } 1026 try { 1027 Utils.toggleNotificationPolicyAccess( 1028 mContext.getPackageName(), getInstrumentation(), true); 1029 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0); 1030 1031 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALARMS); 1032 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 1033 int musicVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC); 1034 mAudioManager.adjustStreamVolume( 1035 AudioManager.STREAM_MUSIC, AudioManager.ADJUST_RAISE, 0); 1036 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 1037 int volumeDelta = 1038 getVolumeDelta(mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC)); 1039 assertEquals(musicVolume + volumeDelta, 1040 mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC)); 1041 1042 } finally { 1043 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1044 } 1045 } 1046 1047 public void testSetStreamVolumeInTotalSilenceMode() throws Exception { 1048 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 1049 return; 1050 } 1051 try { 1052 Utils.toggleNotificationPolicyAccess( 1053 mContext.getPackageName(), getInstrumentation(), true); 1054 mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 1, 0); 1055 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0); 1056 1057 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_NONE); 1058 // delay for streams to get into correct volume states 1059 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 1060 1061 int musicVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC); 1062 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 7, 0); 1063 assertEquals(musicVolume, mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC)); 1064 mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 7, 0); 1065 assertEquals(7, mAudioManager.getStreamVolume(AudioManager.STREAM_RING)); 1066 } finally { 1067 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1068 } 1069 } 1070 1071 public void testSetStreamVolumeInAlarmsOnlyMode() throws Exception { 1072 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 1073 return; 1074 } 1075 try { 1076 Utils.toggleNotificationPolicyAccess( 1077 mContext.getPackageName(), getInstrumentation(), true); 1078 mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 1, 0); 1079 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0); 1080 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALARMS); 1081 // delay for streams to get into correct volume states 1082 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 1083 1084 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 3, 0); 1085 assertEquals(3, mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC)); 1086 mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 7, 0); 1087 assertEquals(7, mAudioManager.getStreamVolume(AudioManager.STREAM_RING)); 1088 } finally { 1089 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1090 } 1091 } 1092 1093 public void testSetStreamVolumeInPriorityOnlyMode() throws Exception { 1094 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 1095 return; 1096 } 1097 Utils.toggleNotificationPolicyAccess( 1098 mContext.getPackageName(), getInstrumentation(), true); 1099 1100 try { 1101 // turn off zen, set stream volumes to check for later 1102 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1103 1104 final int testRingerVol = getTestRingerVol(); 1105 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0); 1106 mAudioManager.setStreamVolume(AudioManager.STREAM_ALARM, 1, 0); 1107 int musicVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC); 1108 int alarmVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_ALARM); 1109 1110 // disallow all sounds in priority only, turn on priority only DND, try to change volume 1111 mNm.setNotificationPolicy(new NotificationManager.Policy(0, 0 , 0)); 1112 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_PRIORITY); 1113 // delay for streams to get into correct volume states 1114 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 1115 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 3, 0); 1116 mAudioManager.setStreamVolume(AudioManager.STREAM_ALARM, 5, 0); 1117 mAudioManager.setStreamVolume(AudioManager.STREAM_RING, testRingerVol, 0); 1118 1119 // Turn off zen and make sure stream levels are still the same prior to zen 1120 // aside from ringer since ringer can exit dnd 1121 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1122 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); // delay for streams to get into correct states 1123 assertEquals(musicVolume, mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC)); 1124 assertEquals(alarmVolume, mAudioManager.getStreamVolume(AudioManager.STREAM_ALARM)); 1125 assertEquals(testRingerVol, mAudioManager.getStreamVolume(AudioManager.STREAM_RING)); 1126 } finally { 1127 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1128 } 1129 } 1130 1131 public void testAdjustVolumeInPriorityOnly() throws Exception { 1132 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 1133 return; 1134 } 1135 1136 Utils.toggleNotificationPolicyAccess( 1137 mContext.getPackageName(), getInstrumentation(), true); 1138 try { 1139 // turn off zen, set stream volumes to check for later 1140 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1141 mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 1, 0); 1142 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0); 1143 mAudioManager.setStreamVolume(AudioManager.STREAM_ALARM, 1, 0); 1144 int ringVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_RING); 1145 int musicVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC); 1146 int alarmVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_ALARM); 1147 1148 // disallow all sounds in priority only, turn on priority only DND, try to change volume 1149 mNm.setNotificationPolicy(new NotificationManager.Policy(0, 0, 0)); 1150 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_PRIORITY); 1151 // delay for streams to get into correct mute states 1152 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 1153 mAudioManager.adjustStreamVolume( 1154 AudioManager.STREAM_RING, AudioManager.ADJUST_RAISE, 0); 1155 mAudioManager.adjustStreamVolume( 1156 AudioManager.STREAM_MUSIC, AudioManager.ADJUST_RAISE, 0); 1157 mAudioManager.adjustStreamVolume( 1158 AudioManager.STREAM_ALARM, AudioManager.ADJUST_RAISE, 0); 1159 1160 // Turn off zen and make sure stream levels are still the same prior to zen 1161 // aside from ringer since ringer can exit dnd 1162 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1163 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); // delay for streams to get into correct states 1164 assertEquals(musicVolume, mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC)); 1165 assertEquals(alarmVolume, mAudioManager.getStreamVolume(AudioManager.STREAM_ALARM)); 1166 1167 int volumeDelta = 1168 getVolumeDelta(mAudioManager.getStreamVolume(AudioManager.STREAM_RING)); 1169 assertEquals(ringVolume + volumeDelta, 1170 mAudioManager.getStreamVolume(AudioManager.STREAM_RING)); 1171 } finally { 1172 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1173 } 1174 } 1175 1176 public void testPriorityOnlyMuteAll() throws Exception { 1177 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 1178 return; 1179 } 1180 1181 Utils.toggleNotificationPolicyAccess( 1182 mContext.getPackageName(), getInstrumentation(), true); 1183 try { 1184 // ensure volume is not muted/0 to start test 1185 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0); 1186 mAudioManager.setStreamVolume(AudioManager.STREAM_ALARM, 1, 0); 1187 mAudioManager.setStreamVolume(AudioManager.STREAM_SYSTEM, 1, 0); 1188 mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 1, 0); 1189 1190 // disallow all sounds in priority only, turn on priority only DND 1191 mNm.setNotificationPolicy(new NotificationManager.Policy(0, 0, 0)); 1192 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_PRIORITY); 1193 // delay for streams to get into correct mute states 1194 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 1195 1196 assertTrue("Music (media) stream should be muted", 1197 mAudioManager.isStreamMute(AudioManager.STREAM_MUSIC)); 1198 assertTrue("System stream should be muted", 1199 mAudioManager.isStreamMute(AudioManager.STREAM_SYSTEM)); 1200 assertTrue("Alarm stream should be muted", 1201 mAudioManager.isStreamMute(AudioManager.STREAM_ALARM)); 1202 1203 // Test requires that the phone's default state has no channels that can bypass dnd 1204 assertTrue("Ringer stream should be muted", 1205 mAudioManager.isStreamMute(AudioManager.STREAM_RING)); 1206 } finally { 1207 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1208 } 1209 } 1210 1211 public void testPriorityOnlyMediaAllowed() throws Exception { 1212 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 1213 return; 1214 } 1215 Utils.toggleNotificationPolicyAccess( 1216 mContext.getPackageName(), getInstrumentation(), true); 1217 try { 1218 // ensure volume is not muted/0 to start test 1219 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0); 1220 mAudioManager.setStreamVolume(AudioManager.STREAM_ALARM, 1, 0); 1221 mAudioManager.setStreamVolume(AudioManager.STREAM_SYSTEM, 1, 0); 1222 mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 1, 0); 1223 1224 // allow only media in priority only 1225 mNm.setNotificationPolicy(new NotificationManager.Policy( 1226 NotificationManager.Policy.PRIORITY_CATEGORY_MEDIA, 0, 0)); 1227 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_PRIORITY); 1228 // delay for streams to get into correct mute states 1229 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 1230 1231 assertFalse("Music (media) stream should not be muted", 1232 mAudioManager.isStreamMute(AudioManager.STREAM_MUSIC)); 1233 assertTrue("System stream should be muted", 1234 mAudioManager.isStreamMute(AudioManager.STREAM_SYSTEM)); 1235 assertTrue("Alarm stream should be muted", 1236 mAudioManager.isStreamMute(AudioManager.STREAM_ALARM)); 1237 1238 // Test requires that the phone's default state has no channels that can bypass dnd 1239 assertTrue("Ringer stream should be muted", 1240 mAudioManager.isStreamMute(AudioManager.STREAM_RING)); 1241 } finally { 1242 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1243 } 1244 } 1245 1246 public void testPriorityOnlySystemAllowed() throws Exception { 1247 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 1248 return; 1249 } 1250 1251 Utils.toggleNotificationPolicyAccess( 1252 mContext.getPackageName(), getInstrumentation(), true); 1253 try { 1254 // ensure volume is not muted/0 to start test 1255 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0); 1256 mAudioManager.setStreamVolume(AudioManager.STREAM_ALARM, 1, 0); 1257 mAudioManager.setStreamVolume(AudioManager.STREAM_SYSTEM, 1, 0); 1258 mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 1, 0); 1259 1260 // allow only system in priority only 1261 mNm.setNotificationPolicy(new NotificationManager.Policy( 1262 NotificationManager.Policy.PRIORITY_CATEGORY_SYSTEM, 0, 0)); 1263 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_PRIORITY); 1264 // delay for streams to get into correct mute states 1265 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 1266 1267 assertTrue("Music (media) stream should be muted", 1268 mAudioManager.isStreamMute(AudioManager.STREAM_MUSIC)); 1269 assertFalse("System stream should not be muted", 1270 mAudioManager.isStreamMute(AudioManager.STREAM_SYSTEM)); 1271 assertTrue("Alarm stream should be muted", 1272 mAudioManager.isStreamMute(AudioManager.STREAM_ALARM)); 1273 1274 // Test requires that the phone's default state has no channels that can bypass dnd 1275 assertTrue("Ringer stream should be muted", 1276 mAudioManager.isStreamMute(AudioManager.STREAM_RING)); 1277 } finally { 1278 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1279 } 1280 } 1281 1282 public void testPriorityOnlyAlarmsAllowed() throws Exception { 1283 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 1284 return; 1285 } 1286 1287 Utils.toggleNotificationPolicyAccess( 1288 mContext.getPackageName(), getInstrumentation(), true); 1289 try { 1290 // ensure volume is not muted/0 to start test 1291 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0); 1292 mAudioManager.setStreamVolume(AudioManager.STREAM_ALARM, 1, 0); 1293 mAudioManager.setStreamVolume(AudioManager.STREAM_SYSTEM, 1, 0); 1294 mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 1, 0); 1295 1296 // allow only alarms in priority only 1297 mNm.setNotificationPolicy(new NotificationManager.Policy( 1298 NotificationManager.Policy.PRIORITY_CATEGORY_ALARMS, 0, 0)); 1299 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_PRIORITY); 1300 // delay for streams to get into correct mute states 1301 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 1302 1303 assertTrue("Music (media) stream should be muted", 1304 mAudioManager.isStreamMute(AudioManager.STREAM_MUSIC)); 1305 assertTrue("System stream should be muted", 1306 mAudioManager.isStreamMute(AudioManager.STREAM_SYSTEM)); 1307 assertFalse("Alarm stream should not be muted", 1308 mAudioManager.isStreamMute(AudioManager.STREAM_ALARM)); 1309 1310 // Test requires that the phone's default state has no channels that can bypass dnd 1311 assertTrue("Ringer stream should be muted", 1312 mAudioManager.isStreamMute(AudioManager.STREAM_RING)); 1313 } finally { 1314 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1315 } 1316 } 1317 1318 public void testPriorityOnlyRingerAllowed() throws Exception { 1319 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 1320 return; 1321 } 1322 1323 Utils.toggleNotificationPolicyAccess( 1324 mContext.getPackageName(), getInstrumentation(), true); 1325 try { 1326 // ensure volume is not muted/0 to start test 1327 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0); 1328 mAudioManager.setStreamVolume(AudioManager.STREAM_ALARM, 1, 0); 1329 mAudioManager.setStreamVolume(AudioManager.STREAM_SYSTEM, 1, 0); 1330 mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 1, 0); 1331 1332 // allow only reminders in priority only 1333 mNm.setNotificationPolicy(new NotificationManager.Policy( 1334 NotificationManager.Policy.PRIORITY_CATEGORY_REMINDERS, 0, 0)); 1335 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_PRIORITY); 1336 // delay for streams to get into correct mute states 1337 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 1338 1339 assertTrue("Music (media) stream should be muted", 1340 mAudioManager.isStreamMute(AudioManager.STREAM_MUSIC)); 1341 assertTrue("System stream should be muted", 1342 mAudioManager.isStreamMute(AudioManager.STREAM_SYSTEM)); 1343 assertTrue("Alarm stream should be muted", 1344 mAudioManager.isStreamMute(AudioManager.STREAM_ALARM)); 1345 assertFalse("Ringer stream should not be muted", 1346 mAudioManager.isStreamMute(AudioManager.STREAM_RING)); 1347 1348 } finally { 1349 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1350 } 1351 } 1352 1353 public void testPriorityOnlyChannelsCanBypassDnd() throws Exception { 1354 final String NOTIFICATION_CHANNEL_ID = "test_id"; 1355 if (mSkipRingerTests || !mSupportNotificationPolicyAccess) { 1356 return; 1357 } 1358 1359 Utils.toggleNotificationPolicyAccess( 1360 mContext.getPackageName(), getInstrumentation(), true); 1361 NotificationChannel channel = new NotificationChannel(NOTIFICATION_CHANNEL_ID, "TEST", 1362 NotificationManager.IMPORTANCE_DEFAULT); 1363 try { 1364 // ensure volume is not muted/0 to start test 1365 mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 1, 0); 1366 mAudioManager.setStreamVolume(AudioManager.STREAM_ALARM, 1, 0); 1367 mAudioManager.setStreamVolume(AudioManager.STREAM_SYSTEM, 1, 0); 1368 mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 1, 0); 1369 1370 // create a channel that can bypass dnd 1371 channel.setBypassDnd(true); 1372 mNm.createNotificationChannel(channel); 1373 1374 // allow nothing 1375 mNm.setNotificationPolicy(new NotificationManager.Policy(0,0, 0)); 1376 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_PRIORITY); 1377 // delay for streams to get into correct mute states 1378 Thread.sleep(ASYNC_TIMING_TOLERANCE_MS); 1379 1380 assertTrue("Music (media) stream should be muted", 1381 mAudioManager.isStreamMute(AudioManager.STREAM_MUSIC)); 1382 assertTrue("System stream should be muted", 1383 mAudioManager.isStreamMute(AudioManager.STREAM_SYSTEM)); 1384 assertTrue("Alarm stream should be muted", 1385 mAudioManager.isStreamMute(AudioManager.STREAM_ALARM)); 1386 assertFalse("Ringer stream should not be muted", 1387 mAudioManager.isStreamMute(AudioManager.STREAM_RING)); 1388 1389 } finally { 1390 setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_ALL); 1391 mNm.deleteNotificationChannel(NOTIFICATION_CHANNEL_ID); 1392 Utils.toggleNotificationPolicyAccess(mContext.getPackageName(), getInstrumentation(), 1393 false); 1394 1395 } 1396 } 1397 1398 public void testAdjustVolumeWithIllegalDirection() throws Exception { 1399 // Call the method with illegal direction. System should not reboot. 1400 mAudioManager.adjustVolume(37, 0); 1401 } 1402 1403 private final int[] PUBLIC_STREAM_TYPES = { AudioManager.STREAM_VOICE_CALL, 1404 AudioManager.STREAM_SYSTEM, AudioManager.STREAM_RING, AudioManager.STREAM_MUSIC, 1405 AudioManager.STREAM_ALARM, AudioManager.STREAM_NOTIFICATION, 1406 AudioManager.STREAM_DTMF, AudioManager.STREAM_ACCESSIBILITY }; 1407 1408 public void testGetStreamVolumeDbWithIllegalArguments() throws Exception { 1409 Exception ex = null; 1410 // invalid stream type 1411 try { 1412 float gain = mAudioManager.getStreamVolumeDb(-100 /*streamType*/, 0, 1413 AudioDeviceInfo.TYPE_BUILTIN_SPEAKER); 1414 } catch (Exception e) { 1415 ex = e; // expected 1416 } 1417 assertNotNull("No exception was thrown for an invalid stream type", ex); 1418 assertEquals("Wrong exception thrown for invalid stream type", 1419 ex.getClass(), IllegalArgumentException.class); 1420 1421 // invalid volume index 1422 ex = null; 1423 try { 1424 float gain = mAudioManager.getStreamVolumeDb(AudioManager.STREAM_MUSIC, -101 /*volume*/, 1425 AudioDeviceInfo.TYPE_BUILTIN_SPEAKER); 1426 } catch (Exception e) { 1427 ex = e; // expected 1428 } 1429 assertNotNull("No exception was thrown for an invalid volume index", ex); 1430 assertEquals("Wrong exception thrown for invalid volume index", 1431 ex.getClass(), IllegalArgumentException.class); 1432 1433 // invalid out of range volume index 1434 ex = null; 1435 try { 1436 final int maxVol = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC); 1437 float gain = mAudioManager.getStreamVolumeDb(AudioManager.STREAM_MUSIC, maxVol + 1, 1438 AudioDeviceInfo.TYPE_BUILTIN_SPEAKER); 1439 } catch (Exception e) { 1440 ex = e; // expected 1441 } 1442 assertNotNull("No exception was thrown for an invalid out of range volume index", ex); 1443 assertEquals("Wrong exception thrown for invalid out of range volume index", 1444 ex.getClass(), IllegalArgumentException.class); 1445 1446 // invalid device type 1447 ex = null; 1448 try { 1449 float gain = mAudioManager.getStreamVolumeDb(AudioManager.STREAM_MUSIC, 0, 1450 -102 /*deviceType*/); 1451 } catch (Exception e) { 1452 ex = e; // expected 1453 } 1454 assertNotNull("No exception was thrown for an invalid device type", ex); 1455 assertEquals("Wrong exception thrown for invalid device type", 1456 ex.getClass(), IllegalArgumentException.class); 1457 1458 // invalid input device type 1459 ex = null; 1460 try { 1461 float gain = mAudioManager.getStreamVolumeDb(AudioManager.STREAM_MUSIC, 0, 1462 AudioDeviceInfo.TYPE_BUILTIN_MIC); 1463 } catch (Exception e) { 1464 ex = e; // expected 1465 } 1466 assertNotNull("No exception was thrown for an invalid input device type", ex); 1467 assertEquals("Wrong exception thrown for invalid input device type", 1468 ex.getClass(), IllegalArgumentException.class); 1469 } 1470 1471 public void testGetStreamVolumeDb() throws Exception { 1472 for (int streamType : PUBLIC_STREAM_TYPES) { 1473 // verify mininum index is strictly inferior to maximum index 1474 final int minIndex = mAudioManager.getStreamMinVolume(streamType); 1475 final int maxIndex = mAudioManager.getStreamMaxVolume(streamType); 1476 assertTrue("Min vol index (" + minIndex + ") for stream " + streamType + " not inferior" 1477 + " to max vol index (" + maxIndex + ")", minIndex <= maxIndex); 1478 float prevGain = Float.NEGATIVE_INFINITY; 1479 // verify gain increases with the volume indices 1480 for (int idx = minIndex ; idx <= maxIndex ; idx++) { 1481 float gain = mAudioManager.getStreamVolumeDb(streamType, idx, 1482 AudioDeviceInfo.TYPE_BUILTIN_SPEAKER); 1483 assertTrue("Non-monotonically increasing gain at index " + idx + " for stream" 1484 + streamType, prevGain <= gain); 1485 prevGain = gain; 1486 } 1487 } 1488 } 1489 1490 public void testAdjustSuggestedStreamVolumeWithIllegalArguments() throws Exception { 1491 // Call the method with illegal direction. System should not reboot. 1492 mAudioManager.adjustSuggestedStreamVolume(37, AudioManager.STREAM_MUSIC, 0); 1493 1494 // Call the method with illegal stream. System should not reboot. 1495 mAudioManager.adjustSuggestedStreamVolume(AudioManager.ADJUST_RAISE, 66747, 0); 1496 } 1497 1498 @CddTest(requirement="5.4.4/C-4-1") 1499 public void testGetMicrophones() throws Exception { 1500 if (!mContext.getPackageManager().hasSystemFeature( 1501 PackageManager.FEATURE_MICROPHONE)) { 1502 return; 1503 } 1504 List<MicrophoneInfo> microphones = mAudioManager.getMicrophones(); 1505 assertTrue(microphones.size() > 0); 1506 for (int i = 0; i < microphones.size(); i++) { 1507 MicrophoneInfo microphone = microphones.get(i); 1508 Log.i(TAG, "deviceId:" + microphone.getDescription()); 1509 Log.i(TAG, "portId:" + microphone.getId()); 1510 Log.i(TAG, "type:" + microphone.getType()); 1511 Log.i(TAG, "address:" + microphone.getAddress()); 1512 Log.i(TAG, "deviceLocation:" + microphone.getLocation()); 1513 Log.i(TAG, "deviceGroup:" + microphone.getGroup() 1514 + " index:" + microphone.getIndexInTheGroup()); 1515 MicrophoneInfo.Coordinate3F position = microphone.getPosition(); 1516 Log.i(TAG, "position:" + position.x + " " + position.y + " " + position.z); 1517 MicrophoneInfo.Coordinate3F orientation = microphone.getOrientation(); 1518 Log.i(TAG, "orientation:" + orientation.x + " " 1519 + orientation.y + " " + orientation.z); 1520 Log.i(TAG, "frequencyResponse:" + microphone.getFrequencyResponse()); 1521 Log.i(TAG, "channelMapping:" + microphone.getChannelMapping()); 1522 Log.i(TAG, "sensitivity:" + microphone.getSensitivity()); 1523 Log.i(TAG, "max spl:" + microphone.getMaxSpl()); 1524 Log.i(TAG, "min spl:" + microphone.getMinSpl()); 1525 Log.i(TAG, "directionality:" + microphone.getDirectionality()); 1526 Log.i(TAG, "--------------"); 1527 } 1528 } 1529 1530 public void testIsHapticPlaybackSupported() throws Exception { 1531 // Calling the API to make sure it doesn't crash. 1532 Log.i(TAG, "isHapticPlaybackSupported: " + AudioManager.isHapticPlaybackSupported()); 1533 } 1534 1535 private void setInterruptionFilter(int filter) throws Exception { 1536 mNm.setInterruptionFilter(filter); 1537 for (int i = 0; i < 5; i++) { 1538 if (mNm.getCurrentInterruptionFilter() == filter) { 1539 break; 1540 } 1541 Thread.sleep(1000); 1542 } 1543 } 1544 1545 private int getVolumeDelta(int volume) { 1546 return 1; 1547 } 1548 1549 private int getTestRingerVol() { 1550 final int currentRingVol = mAudioManager.getStreamVolume(STREAM_RING); 1551 final int maxRingVol = mAudioManager.getStreamMaxVolume(STREAM_RING); 1552 if (currentRingVol != maxRingVol) { 1553 return maxRingVol; 1554 } else { 1555 return maxRingVol - 1; 1556 } 1557 } 1558 1559 public void testAllowedCapturePolicy() throws Exception { 1560 final int policy = mAudioManager.getAllowedCapturePolicy(); 1561 assertEquals("Wrong default capture policy", AudioAttributes.ALLOW_CAPTURE_BY_ALL, policy); 1562 1563 for (int setPolicy : new int[] { AudioAttributes.ALLOW_CAPTURE_BY_NONE, 1564 AudioAttributes.ALLOW_CAPTURE_BY_SYSTEM, 1565 AudioAttributes.ALLOW_CAPTURE_BY_ALL}) { 1566 mAudioManager.setAllowedCapturePolicy(setPolicy); 1567 final int getPolicy = mAudioManager.getAllowedCapturePolicy(); 1568 assertEquals("Allowed capture policy doesn't match", setPolicy, getPolicy); 1569 } 1570 } 1571 } 1572
