1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not 5 * use this file except in compliance with the License. You may obtain a copy of 6 * 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, WITHOUT 12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 13 * License for the specific language governing permissions and limitations under 14 * the License. 15 */ 16 17 package com.android.mediaframeworktest.functional.audio; 18 19 import com.android.mediaframeworktest.MediaFrameworkTest; 20 import android.content.Context; 21 import android.media.AudioManager; 22 import android.media.MediaPlayer; 23 import android.media.AudioManager.OnAudioFocusChangeListener; 24 import android.os.Looper; 25 import android.test.ActivityInstrumentationTestCase2; 26 import android.test.suitebuilder.annotation.MediumTest; 27 import android.test.suitebuilder.annotation.LargeTest; 28 import android.util.Log; 29 30 /** 31 * Junit / Instrumentation test case for the media AudioManager api 32 */ 33 34 public class MediaAudioManagerTest extends ActivityInstrumentationTestCase2<MediaFrameworkTest> { 35 36 private final static String TAG = "MediaAudioManagerTest"; 37 // the AudioManager used throughout the test 38 private AudioManager mAudioManager; 39 // keep track of looper for AudioManager so we can terminate it 40 private Looper mAudioManagerLooper; 41 private final Object mLooperLock = new Object(); 42 private final static int WAIT_FOR_LOOPER_TO_INITIALIZE_MS = 60000; // 60s 43 private int[] ringtoneMode = {AudioManager.RINGER_MODE_NORMAL, 44 AudioManager.RINGER_MODE_SILENT, AudioManager.RINGER_MODE_VIBRATE}; 45 private boolean mUseFixedVolume; 46 47 public MediaAudioManagerTest() { 48 super("com.android.mediaframeworktest", MediaFrameworkTest.class); 49 } 50 51 private void initializeAudioManagerWithLooper() { 52 new Thread() { 53 @Override 54 public void run() { 55 Looper.prepare(); 56 mAudioManagerLooper = Looper.myLooper(); 57 mAudioManager = (AudioManager)getActivity().getSystemService(Context.AUDIO_SERVICE); 58 synchronized (mLooperLock) { 59 mLooperLock.notify(); 60 } 61 Looper.loop(); 62 } 63 }.start(); 64 } 65 66 @Override 67 protected void setUp() throws Exception { 68 super.setUp(); 69 70 mUseFixedVolume = getActivity().getResources().getBoolean( 71 com.android.internal.R.bool.config_useFixedVolume); 72 73 synchronized(mLooperLock) { 74 initializeAudioManagerWithLooper(); 75 try { 76 mLooperLock.wait(WAIT_FOR_LOOPER_TO_INITIALIZE_MS); 77 } catch (Exception e) { 78 assertTrue("initializeAudioManagerWithLooper() failed to complete in time", false); 79 } 80 } 81 } 82 83 @Override 84 protected void tearDown() throws Exception { 85 super.tearDown(); 86 synchronized(mLooperLock) { 87 if (mAudioManagerLooper != null) { 88 mAudioManagerLooper.quit(); 89 } 90 } 91 } 92 93 //----------------------------------------------------------------- 94 // Ringer Mode 95 //---------------------------------- 96 97 public boolean validateSetRingTone(int i) { 98 int getRingtone = mAudioManager.getRingerMode(); 99 100 if (mUseFixedVolume) { 101 return (getRingtone == AudioManager.RINGER_MODE_NORMAL); 102 } else { 103 return (getRingtone == i); 104 } 105 } 106 107 // Test case 1: Simple test case to validate the set ringtone mode 108 @MediumTest 109 public void testSetRingtoneMode() throws Exception { 110 boolean result = false; 111 112 for (int i = 0; i < ringtoneMode.length; i++) { 113 mAudioManager.setRingerMode(ringtoneMode[i]); 114 result = validateSetRingTone(ringtoneMode[i]); 115 assertTrue("SetRingtoneMode : " + ringtoneMode[i], result); 116 } 117 } 118 119 //----------------------------------------------------------------- 120 // AudioFocus 121 //---------------------------------- 122 123 private static AudioFocusListener mAudioFocusListener; 124 private final static int INVALID_FOCUS = -80; // initialized to magic invalid focus change type 125 private final static int WAIT_FOR_AUDIOFOCUS_LOSS_MS = 10; 126 127 private static class AudioFocusListener implements OnAudioFocusChangeListener { 128 public int mLastFocusChange = INVALID_FOCUS; 129 public int mFocusChangeCounter = 0; 130 public AudioFocusListener() { 131 } 132 public void onAudioFocusChange(int focusChange) { 133 mLastFocusChange = focusChange; 134 mFocusChangeCounter++; 135 } 136 } 137 138 /** 139 * Fails the test if expectedFocusLossMode != mAudioFocusListener.mLastFocusChange 140 */ 141 private void verifyAudioFocusLoss(int focusGainMode, int expectedFocusLossMode) 142 throws Exception { 143 // request AudioFocus so we can test that mAudioFocusListener loses it when another 144 // request comes in 145 int result = mAudioManager.requestAudioFocus(mAudioFocusListener, 146 AudioManager.STREAM_MUSIC, 147 AudioManager.AUDIOFOCUS_GAIN); 148 assertTrue("requestAudioFocus returned " + result, 149 result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED); 150 // cause mAudioFocusListener to lose AudioFocus 151 result = mAudioManager.requestAudioFocus(null, AudioManager.STREAM_MUSIC, 152 focusGainMode); 153 assertTrue("requestAudioFocus returned " + result, 154 result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED); 155 // the audio focus request is async, so wait a bit to verify it had the expected effect 156 java.lang.Thread.sleep(WAIT_FOR_AUDIOFOCUS_LOSS_MS); 157 // test successful if the expected focus loss was recorded 158 assertEquals("listener lost focus", 159 mAudioFocusListener.mLastFocusChange, expectedFocusLossMode); 160 } 161 162 private void setupAudioFocusListener() { 163 mAudioFocusListener = new AudioFocusListener(); 164 } 165 166 private void cleanupAudioFocusListener() { 167 // clean up 168 mAudioManager.abandonAudioFocus(mAudioFocusListener); 169 } 170 171 //---------------------------------- 172 173 //Test case 1: test audio focus listener loses audio focus: 174 // AUDIOFOCUS_GAIN causes AUDIOFOCUS_LOSS 175 @MediumTest 176 public void testAudioFocusLoss() throws Exception { 177 setupAudioFocusListener(); 178 179 verifyAudioFocusLoss(AudioManager.AUDIOFOCUS_GAIN, AudioManager.AUDIOFOCUS_LOSS); 180 181 cleanupAudioFocusListener(); 182 } 183 184 //Test case 2: test audio focus listener loses audio focus: 185 // AUDIOFOCUS_GAIN_TRANSIENT causes AUDIOFOCUS_LOSS_TRANSIENT 186 @MediumTest 187 public void testAudioFocusLossTransient() throws Exception { 188 setupAudioFocusListener(); 189 190 verifyAudioFocusLoss(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT, 191 AudioManager.AUDIOFOCUS_LOSS_TRANSIENT); 192 193 cleanupAudioFocusListener(); 194 } 195 196 //Test case 3: test audio focus listener loses audio focus: 197 // AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK causes AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK 198 @MediumTest 199 public void testAudioFocusLossTransientDuck() throws Exception { 200 setupAudioFocusListener(); 201 202 verifyAudioFocusLoss(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK, 203 AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK); 204 205 cleanupAudioFocusListener(); 206 } 207 208 //Test case 4: test audio focus registering and use over 3000 iterations 209 @LargeTest 210 public void testAudioFocusStressListenerRequestAbandon() throws Exception { 211 final int ITERATIONS = 3000; 212 // here we only test the life cycle of a focus listener, and make sure we don't crash 213 // when doing it many times without waiting 214 for (int i = 0 ; i < ITERATIONS ; i++) { 215 setupAudioFocusListener(); 216 int result = mAudioManager.requestAudioFocus(mAudioFocusListener, 217 AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN); 218 assertTrue("audio focus request was not granted", 219 result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED); 220 cleanupAudioFocusListener(); 221 } 222 assertTrue("testAudioFocusListenerLifeCycle : tested" + ITERATIONS +" iterations", true); 223 } 224 225 //Test case 5: test audio focus use without listener 226 @LargeTest 227 public void testAudioFocusStressNoListenerRequestAbandon() throws Exception { 228 final int ITERATIONS = 1000; 229 // make sure we have a listener in the stack 230 setupAudioFocusListener(); 231 mAudioManager.requestAudioFocus(mAudioFocusListener, AudioManager.STREAM_MUSIC, 232 AudioManager.AUDIOFOCUS_GAIN); 233 // keep making the current owner lose and gain audio focus repeatedly 234 for (int i = 0 ; i < ITERATIONS ; i++) { 235 mAudioManager.requestAudioFocus(null, AudioManager.STREAM_MUSIC, 236 AudioManager.AUDIOFOCUS_GAIN_TRANSIENT); 237 mAudioManager.abandonAudioFocus(null); 238 // the audio focus request is async, so wait a bit to verify it had the expected effect 239 java.lang.Thread.sleep(WAIT_FOR_AUDIOFOCUS_LOSS_MS); 240 } 241 // verify there were 2 audio focus changes per iteration (one loss + one gain) 242 assertTrue("testAudioFocusListenerLifeCycle : observed " + 243 mAudioFocusListener.mFocusChangeCounter + " AudioFocus changes", 244 mAudioFocusListener.mFocusChangeCounter == ITERATIONS * 2); 245 mAudioManager.abandonAudioFocus(mAudioFocusListener); 246 } 247 } 248