1/* 2 * Copyright (C) 2010 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 17package com.android.mediaframeworktest.functional.audio; 18 19import com.android.mediaframeworktest.MediaFrameworkTest; 20import com.android.mediaframeworktest.MediaNames; 21import android.content.res.AssetFileDescriptor; 22import android.media.audiofx.AudioEffect; 23import android.media.AudioFormat; 24import android.media.AudioManager; 25import android.media.AudioTrack; 26import android.media.AudioRecord; 27import android.media.audiofx.EnvironmentalReverb; 28import android.media.audiofx.Equalizer; 29import android.media.MediaPlayer; 30import android.media.MediaRecorder; 31 32import android.os.Looper; 33import android.test.suitebuilder.annotation.LargeTest; 34import android.test.suitebuilder.annotation.MediumTest; 35import android.test.suitebuilder.annotation.Suppress; 36import android.test.ActivityInstrumentationTestCase2; 37import android.util.Log; 38 39import java.nio.ByteOrder; 40import java.nio.ByteBuffer; 41import java.util.UUID; 42 43/** 44 * Junit / Instrumentation test case for the media AudioTrack api 45 46 */ 47public class MediaAudioEffectTest extends ActivityInstrumentationTestCase2<MediaFrameworkTest> { 48 private String TAG = "MediaAudioEffectTest"; 49 50 private AudioEffect mEffect = null; 51 private boolean mHasControl = false; 52 private boolean mIsEnabled = false; 53 private int mParameterChanged = -1; 54 private MediaPlayer mMediaPlayer = null; 55 private boolean mInitialized = false; 56 private Looper mLooper = null; 57 private int mError = 0; 58 private final Object lock = new Object(); 59 private final static int SAMPLING_RATE = 44100; 60 61 public MediaAudioEffectTest() { 62 super("com.android.mediaframeworktest", MediaFrameworkTest.class); 63 } 64 65 @Override 66 protected void setUp() throws Exception { 67 super.setUp(); 68 } 69 70 @Override 71 protected void tearDown() throws Exception { 72 super.tearDown(); 73 } 74 75 private static void assumeTrue(String message, boolean cond) { 76 assertTrue("(assume)"+message, cond); 77 } 78 79 private void log(String testName, String message) { 80 Log.v(TAG, "["+testName+"] "+message); 81 } 82 83 private void loge(String testName, String message) { 84 Log.e(TAG, "["+testName+"] "+message); 85 } 86 87 //----------------------------------------------------------------- 88 // AUDIOEFFECT TESTS: 89 //---------------------------------- 90 91 //----------------------------------------------------------------- 92 // 0 - static methods 93 //---------------------------------- 94 95 //Test case 0.0: test queryEffects() and available effects 96 @LargeTest 97 public void test0_0QueryEffects() throws Exception { 98 99 AudioEffect.Descriptor[] desc = AudioEffect.queryEffects(); 100 101 assertTrue("test0_0QueryEffects: number of effects < 4: "+desc.length, (desc.length >= 4)); 102 103 boolean hasEQ = false; 104 boolean hasBassBoost = false; 105 boolean hasVirtualizer = false; 106 boolean hasEnvReverb = false; 107 108 for (int i = 0; i < desc.length; i++) { 109 if (desc[i].type.equals(AudioEffect.EFFECT_TYPE_EQUALIZER)) { 110 hasEQ = true; 111 } if (desc[i].type.equals(AudioEffect.EFFECT_TYPE_BASS_BOOST)) { 112 hasBassBoost = true; 113 } else if (desc[i].type.equals(AudioEffect.EFFECT_TYPE_VIRTUALIZER)) { 114 hasVirtualizer = true; 115 } 116 else if (desc[i].type.equals(AudioEffect.EFFECT_TYPE_ENV_REVERB)) { 117 hasEnvReverb = true; 118 } 119 } 120 assertTrue("test0_0QueryEffects: equalizer not found", hasEQ); 121 assertTrue("test0_0QueryEffects: bass boost not found", hasBassBoost); 122 assertTrue("test0_0QueryEffects: virtualizer not found", hasVirtualizer); 123 assertTrue("test0_0QueryEffects: environmental reverb not found", hasEnvReverb); 124 } 125 126 //----------------------------------------------------------------- 127 // 1 - constructor 128 //---------------------------------- 129 130 private AudioRecord getAudioRecord() { 131 AudioRecord ar = null; 132 try { 133 ar = new AudioRecord(MediaRecorder.AudioSource.DEFAULT, 134 SAMPLING_RATE, 135 AudioFormat.CHANNEL_CONFIGURATION_MONO, 136 AudioFormat.ENCODING_PCM_16BIT, 137 AudioRecord.getMinBufferSize(SAMPLING_RATE, 138 AudioFormat.CHANNEL_CONFIGURATION_MONO, 139 AudioFormat.ENCODING_PCM_16BIT) * 10); 140 assertNotNull("Could not create AudioRecord", ar); 141 assertEquals("AudioRecord not initialized", 142 AudioRecord.STATE_INITIALIZED, ar.getState()); 143 } catch (IllegalArgumentException e) { 144 fail("AudioRecord invalid parameter"); 145 } 146 return ar; 147 } 148 149 //Test case 1.0: test constructor from effect type and get effect ID 150 @LargeTest 151 public void test1_0ConstructorFromType() throws Exception { 152 boolean result = true; 153 String msg = "test1_0ConstructorFromType()"; 154 AudioEffect.Descriptor[] desc = AudioEffect.queryEffects(); 155 assertTrue(msg+": no effects found", (desc.length != 0)); 156 try { 157 int sessionId; 158 AudioRecord ar = null; 159 if (AudioEffect.EFFECT_PRE_PROCESSING.equals(desc[0].connectMode)) { 160 ar = getAudioRecord(); 161 sessionId = ar.getAudioSessionId(); 162 } else { 163 sessionId = 0; 164 } 165 166 AudioEffect effect = new AudioEffect(desc[0].type, 167 AudioEffect.EFFECT_TYPE_NULL, 168 0, 169 sessionId); 170 assertNotNull(msg + ": could not create AudioEffect", effect); 171 try { 172 assertTrue(msg +": invalid effect ID", (effect.getId() != 0)); 173 } catch (IllegalStateException e) { 174 msg = msg.concat(": AudioEffect not initialized"); 175 result = false; 176 } finally { 177 effect.release(); 178 if (ar != null) { 179 ar.release(); 180 } 181 } 182 } catch (IllegalArgumentException e) { 183 msg = msg.concat(": Effect not found: "+desc[0].name); 184 result = false; 185 } catch (UnsupportedOperationException e) { 186 msg = msg.concat(": Effect library not loaded"); 187 result = false; 188 } 189 assertTrue(msg, result); 190 } 191 192 //Test case 1.1: test constructor from effect uuid 193 @LargeTest 194 public void test1_1ConstructorFromUuid() throws Exception { 195 boolean result = true; 196 String msg = "test1_1ConstructorFromUuid()"; 197 AudioEffect.Descriptor[] desc = AudioEffect.queryEffects(); 198 assertTrue(msg+"no effects found", (desc.length != 0)); 199 try { 200 int sessionId; 201 AudioRecord ar = null; 202 if (AudioEffect.EFFECT_PRE_PROCESSING.equals(desc[0].connectMode)) { 203 ar = getAudioRecord(); 204 sessionId = ar.getAudioSessionId(); 205 } else { 206 sessionId = 0; 207 } 208 AudioEffect effect = new AudioEffect(AudioEffect.EFFECT_TYPE_NULL, 209 desc[0].uuid, 210 0, 211 sessionId); 212 assertNotNull(msg + ": could not create AudioEffect", effect); 213 effect.release(); 214 if (ar != null) { 215 ar.release(); 216 } 217 } catch (IllegalArgumentException e) { 218 msg = msg.concat(": Effect not found: "+desc[0].name); 219 result = false; 220 } catch (UnsupportedOperationException e) { 221 msg = msg.concat(": Effect library not loaded"); 222 result = false; 223 } 224 assertTrue(msg, result); 225 } 226 227 //Test case 1.2: test constructor failure from unknown type 228 @LargeTest 229 public void test1_2ConstructorUnknownType() throws Exception { 230 boolean result = false; 231 String msg = "test1_2ConstructorUnknownType()"; 232 233 try { 234 AudioEffect effect = new AudioEffect(UUID.randomUUID(), 235 AudioEffect.EFFECT_TYPE_NULL, 236 0, 237 0); 238 msg = msg.concat(": could create random AudioEffect"); 239 if (effect != null) { 240 effect.release(); 241 } 242 } catch (IllegalArgumentException e) { 243 result = true; 244 } catch (UnsupportedOperationException e) { 245 msg = msg.concat(": Effect library not loaded"); 246 } 247 assertTrue(msg, result); 248 } 249 250 //Test case 1.3: test getEnabled() failure when called on released effect 251 @LargeTest 252 public void test1_3GetEnabledAfterRelease() throws Exception { 253 boolean result = false; 254 String msg = "test1_3GetEnabledAfterRelease()"; 255 256 try { 257 AudioEffect effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 258 AudioEffect.EFFECT_TYPE_NULL, 259 0, 260 0); 261 assertNotNull(msg + ": could not create AudioEffect", effect); 262 effect.release(); 263 try { 264 effect.getEnabled(); 265 } catch (IllegalStateException e) { 266 result = true; 267 } 268 } catch (IllegalArgumentException e) { 269 msg = msg.concat(": Equalizer not found"); 270 } catch (UnsupportedOperationException e) { 271 msg = msg.concat(": Effect library not loaded"); 272 } 273 assertTrue(msg, result); 274 } 275 276 //Test case 1.4: test contructor on mediaPlayer audio session 277 @LargeTest 278 public void test1_4InsertOnMediaPlayer() throws Exception { 279 boolean result = false; 280 String msg = "test1_4InsertOnMediaPlayer()"; 281 282 try { 283 MediaPlayer mp = new MediaPlayer(); 284 mp.setDataSource(MediaNames.SHORTMP3); 285 286 AudioEffect effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 287 AudioEffect.EFFECT_TYPE_NULL, 288 0, 289 mp.getAudioSessionId()); 290 assertNotNull(msg + ": could not create AudioEffect", effect); 291 try { 292 loge(msg, ": effect.setEnabled"); 293 effect.setEnabled(true); 294 } catch (IllegalStateException e) { 295 msg = msg.concat(": AudioEffect not initialized"); 296 } 297 298 result = true; 299 effect.release(); 300 mp.release(); 301 } catch (IllegalArgumentException e) { 302 msg = msg.concat(": Equalizer not found"); 303 loge(msg, ": Equalizer not found"); 304 } catch (UnsupportedOperationException e) { 305 msg = msg.concat(": Effect library not loaded"); 306 loge(msg, ": Effect library not loaded"); 307 } catch (Exception e){ 308 loge(msg, "Could not create media player:" + e); 309 } 310 assertTrue(msg, result); 311 } 312 313 //Test case 1.5: test auxiliary effect attachement on MediaPlayer 314 @LargeTest 315 public void test1_5AuxiliaryOnMediaPlayer() throws Exception { 316 boolean result = false; 317 String msg = "test1_5AuxiliaryOnMediaPlayer()"; 318 319 try { 320 MediaPlayer mp = new MediaPlayer(); 321 mp.setDataSource(MediaNames.SHORTMP3); 322 323 AudioEffect effect = new AudioEffect(AudioEffect.EFFECT_TYPE_ENV_REVERB, 324 AudioEffect.EFFECT_TYPE_NULL, 325 0, 326 0); 327 assertNotNull(msg + ": could not create AudioEffect", effect); 328 mp.attachAuxEffect(effect.getId()); 329 mp.setAuxEffectSendLevel(1.0f); 330 result = true; 331 effect.release(); 332 mp.release(); 333 } catch (IllegalArgumentException e) { 334 msg = msg.concat(": Equalizer not found"); 335 loge(msg, ": Equalizer not found"); 336 } catch (UnsupportedOperationException e) { 337 msg = msg.concat(": Effect library not loaded"); 338 loge(msg, ": Effect library not loaded"); 339 } catch (Exception e){ 340 loge(msg, "Could not create media player:" + e); 341 } 342 assertTrue(msg, result); 343 } 344 345 //Test case 1.6: test auxiliary effect attachement failure before setDatasource 346 @LargeTest 347 public void test1_6AuxiliaryOnMediaPlayerFailure() throws Exception { 348 boolean result = false; 349 String msg = "test1_6AuxiliaryOnMediaPlayerFailure()"; 350 351 try { 352 createMediaPlayerLooper(); 353 synchronized(lock) { 354 try { 355 lock.wait(1000); 356 } catch(Exception e) { 357 Log.e(TAG, "Looper creation: wait was interrupted."); 358 } 359 } 360 assertTrue(mInitialized); // mMediaPlayer has been initialized? 361 mError = 0; 362 363 AudioEffect effect = new AudioEffect(AudioEffect.EFFECT_TYPE_ENV_REVERB, 364 AudioEffect.EFFECT_TYPE_NULL, 365 0, 366 0); 367 assertNotNull(msg + ": could not create AudioEffect", effect); 368 synchronized(lock) { 369 try { 370 mMediaPlayer.attachAuxEffect(effect.getId()); 371 lock.wait(1000); 372 } catch(Exception e) { 373 Log.e(TAG, "Attach effect: wait was interrupted."); 374 } 375 } 376 assertTrue(msg + ": no error on attachAuxEffect", mError != 0); 377 result = true; 378 effect.release(); 379 terminateMediaPlayerLooper(); 380 } catch (IllegalArgumentException e) { 381 msg = msg.concat(": Equalizer not found"); 382 loge(msg, ": Equalizer not found"); 383 } catch (UnsupportedOperationException e) { 384 msg = msg.concat(": Effect library not loaded"); 385 loge(msg, ": Effect library not loaded"); 386 } catch (Exception e){ 387 loge(msg, "Could not create media player:" + e); 388 } 389 assertTrue(msg, result); 390 } 391 392 393 //Test case 1.7: test auxiliary effect attachement on AudioTrack 394 @LargeTest 395 public void test1_7AuxiliaryOnAudioTrack() throws Exception { 396 boolean result = false; 397 String msg = "test1_7AuxiliaryOnAudioTrack()"; 398 399 try { 400 AudioTrack track = new AudioTrack( 401 AudioManager.STREAM_MUSIC, 402 44100, 403 AudioFormat.CHANNEL_OUT_MONO, 404 AudioFormat.ENCODING_PCM_16BIT, 405 AudioTrack.getMinBufferSize(44100, 406 AudioFormat.CHANNEL_OUT_MONO, 407 AudioFormat.ENCODING_PCM_16BIT), 408 AudioTrack.MODE_STREAM); 409 assertNotNull(msg + ": could not create AudioTrack", track); 410 AudioEffect effect = new AudioEffect(AudioEffect.EFFECT_TYPE_ENV_REVERB, 411 AudioEffect.EFFECT_TYPE_NULL, 412 0, 413 0); 414 415 track.attachAuxEffect(effect.getId()); 416 track.setAuxEffectSendLevel(1.0f); 417 result = true; 418 effect.release(); 419 track.release(); 420 } catch (IllegalArgumentException e) { 421 msg = msg.concat(": Equalizer not found"); 422 loge(msg, ": Equalizer not found"); 423 } catch (UnsupportedOperationException e) { 424 msg = msg.concat(": Effect library not loaded"); 425 loge(msg, ": Effect library not loaded"); 426 } 427 assertTrue(msg, result); 428 } 429 430 //----------------------------------------------------------------- 431 // 2 - enable/ disable 432 //---------------------------------- 433 434 435 //Test case 2.0: test setEnabled() and getEnabled() in valid state 436 @LargeTest 437 public void test2_0SetEnabledGetEnabled() throws Exception { 438 boolean result = false; 439 String msg = "test2_0SetEnabledGetEnabled()"; 440 441 try { 442 AudioEffect effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 443 AudioEffect.EFFECT_TYPE_NULL, 444 0, 445 0); 446 assertNotNull(msg + ": could not create AudioEffect", effect); 447 try { 448 effect.setEnabled(true); 449 assertTrue(msg + ": invalid state from getEnabled", effect.getEnabled()); 450 effect.setEnabled(false); 451 assertFalse(msg + ": invalid state to getEnabled", effect.getEnabled()); 452 result = true; 453 } catch (IllegalStateException e) { 454 msg = msg.concat(": setEnabled() in wrong state"); 455 } finally { 456 effect.release(); 457 } 458 } catch (IllegalArgumentException e) { 459 msg = msg.concat(": Equalizer not found"); 460 loge(msg, ": Equalizer not found"); 461 } catch (UnsupportedOperationException e) { 462 msg = msg.concat(": Effect library not loaded"); 463 loge(msg, ": Effect library not loaded"); 464 } 465 assertTrue(msg, result); 466 } 467 468 //Test case 2.1: test setEnabled() throws exception after release 469 @LargeTest 470 public void test2_1SetEnabledAfterRelease() throws Exception { 471 boolean result = false; 472 String msg = "test2_1SetEnabledAfterRelease()"; 473 474 try { 475 AudioEffect effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 476 AudioEffect.EFFECT_TYPE_NULL, 477 0, 478 0); 479 assertNotNull(msg + ": could not create AudioEffect", effect); 480 effect.release(); 481 try { 482 effect.setEnabled(true); 483 } catch (IllegalStateException e) { 484 result = true; 485 } 486 } catch (IllegalArgumentException e) { 487 msg = msg.concat(": Equalizer not found"); 488 loge(msg, ": Equalizer not found"); 489 } catch (UnsupportedOperationException e) { 490 msg = msg.concat(": Effect library not loaded"); 491 loge(msg, ": Effect library not loaded"); 492 } 493 assertTrue(msg, result); 494 } 495 496 //----------------------------------------------------------------- 497 // 3 - set parameters 498 //---------------------------------- 499 500 //Test case 3.0: test setParameter(byte[], byte[]) 501 @LargeTest 502 public void test3_0SetParameterByteArrayByteArray() throws Exception { 503 boolean result = false; 504 String msg = "test3_0SetParameterByteArrayByteArray()"; 505 AudioEffect effect = null; 506 try { 507 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 508 AudioEffect.EFFECT_TYPE_NULL, 509 0, 510 0); 511 assertNotNull(msg + ": could not create AudioEffect", effect); 512 byte[] param = intToByteArray(Equalizer.PARAM_CURRENT_PRESET); 513 byte[] value = shortToByteArray((short)0); 514 if (effect.setParameter(param, value) == AudioEffect.SUCCESS) { 515 result = true; 516 } 517 } catch (IllegalArgumentException e) { 518 msg = msg.concat(": Bad parameter value"); 519 loge(msg, "Bad parameter value"); 520 } catch (UnsupportedOperationException e) { 521 msg = msg.concat(": setParameter() rejected"); 522 loge(msg, "setParameter() rejected"); 523 } catch (IllegalStateException e) { 524 msg = msg.concat("setParameter() called in wrong state"); 525 loge(msg, "setParameter() called in wrong state"); 526 } finally { 527 if (effect != null) { 528 effect.release(); 529 } 530 } 531 assertTrue(msg, result); 532 } 533 534 //Test case 3.1: test setParameter(int, int) 535 @LargeTest 536 public void test3_1SetParameterIntInt() throws Exception { 537 boolean result = false; 538 String msg = "test3_1SetParameterIntInt()"; 539 AudioEffect effect = null; 540 try { 541 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_ENV_REVERB, 542 AudioEffect.EFFECT_TYPE_NULL, 543 0, 544 0); 545 assertNotNull(msg + ": could not create AudioEffect", effect); 546 if (effect.setParameter(EnvironmentalReverb.PARAM_DECAY_TIME, 0) 547 == AudioEffect.SUCCESS) { 548 result = true; 549 } 550 } catch (IllegalArgumentException e) { 551 msg = msg.concat(": Bad parameter value"); 552 loge(msg, "Bad parameter value"); 553 } catch (UnsupportedOperationException e) { 554 msg = msg.concat(": setParameter() rejected"); 555 loge(msg, "setParameter() rejected"); 556 } catch (IllegalStateException e) { 557 msg = msg.concat("setParameter() called in wrong state"); 558 loge(msg, "setParameter() called in wrong state"); 559 } finally { 560 if (effect != null) { 561 effect.release(); 562 } 563 } 564 assertTrue(msg, result); 565 } 566 567 //Test case 3.2: test setParameter(int, short) 568 @LargeTest 569 public void test3_2SetParameterIntShort() throws Exception { 570 boolean result = false; 571 String msg = "test3_2SetParameterIntShort()"; 572 AudioEffect effect = null; 573 try { 574 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 575 AudioEffect.EFFECT_TYPE_NULL, 576 0, 577 0); 578 assertNotNull(msg + ": could not create AudioEffect", effect); 579 if (effect.setParameter(Equalizer.PARAM_CURRENT_PRESET, (short)0) 580 == AudioEffect.SUCCESS) { 581 result = true; 582 } 583 } catch (IllegalArgumentException e) { 584 msg = msg.concat(": Bad parameter value"); 585 loge(msg, "Bad parameter value"); 586 } catch (UnsupportedOperationException e) { 587 msg = msg.concat(": setParameter() rejected"); 588 loge(msg, "setParameter() rejected"); 589 } catch (IllegalStateException e) { 590 msg = msg.concat("setParameter() called in wrong state"); 591 loge(msg, "setParameter() called in wrong state"); 592 } finally { 593 if (effect != null) { 594 effect.release(); 595 } 596 } 597 assertTrue(msg, result); 598 } 599 600 //Test case 3.3: test setParameter(int, byte[]) 601 @LargeTest 602 public void test3_3SetParameterIntByteArray() throws Exception { 603 boolean result = false; 604 String msg = "test3_3SetParameterIntByteArray()"; 605 AudioEffect effect = null; 606 try { 607 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 608 AudioEffect.EFFECT_TYPE_NULL, 609 0, 610 0); 611 assertNotNull(msg + ": could not create AudioEffect", effect); 612 byte[] value = shortToByteArray((short)0); 613 if (effect.setParameter(Equalizer.PARAM_CURRENT_PRESET, value) 614 == AudioEffect.SUCCESS) { 615 result = true; 616 } 617 } catch (IllegalArgumentException e) { 618 msg = msg.concat(": Bad parameter value"); 619 loge(msg, "Bad parameter value"); 620 } catch (UnsupportedOperationException e) { 621 msg = msg.concat(": setParameter() rejected"); 622 loge(msg, "setParameter() rejected"); 623 } catch (IllegalStateException e) { 624 msg = msg.concat("setParameter() called in wrong state"); 625 loge(msg, "setParameter() called in wrong state"); 626 } finally { 627 if (effect != null) { 628 effect.release(); 629 } 630 } 631 assertTrue(msg, result); 632 } 633 634 //Test case 3.4: test setParameter(int[], int[]) 635 @LargeTest 636 public void test3_4SetParameterIntArrayIntArray() throws Exception { 637 boolean result = false; 638 String msg = "test3_4SetParameterIntArrayIntArray()"; 639 AudioEffect effect = null; 640 try { 641 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_ENV_REVERB, 642 AudioEffect.EFFECT_TYPE_NULL, 643 0, 644 0); 645 assertNotNull(msg + ": could not create AudioEffect", effect); 646 int[] param = new int[1]; 647 int[] value = new int[1]; 648 param[0] = EnvironmentalReverb.PARAM_DECAY_TIME; 649 value[0] = 0; 650 if (effect.setParameter(param, value) 651 == AudioEffect.SUCCESS) { 652 result = true; 653 } 654 } catch (IllegalArgumentException e) { 655 msg = msg.concat(": Bad parameter value"); 656 loge(msg, "Bad parameter value"); 657 } catch (UnsupportedOperationException e) { 658 msg = msg.concat(": setParameter() rejected"); 659 loge(msg, "setParameter() rejected"); 660 } catch (IllegalStateException e) { 661 msg = msg.concat("setParameter() called in wrong state"); 662 loge(msg, "setParameter() called in wrong state"); 663 } finally { 664 if (effect != null) { 665 effect.release(); 666 } 667 } 668 assertTrue(msg, result); 669 } 670 671 //Test case 3.5: test setParameter(int[], short[]) 672 @LargeTest 673 public void test3_5SetParameterIntArrayShortArray() throws Exception { 674 boolean result = false; 675 String msg = "test3_5SetParameterIntArrayShortArray()"; 676 AudioEffect effect = null; 677 try { 678 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 679 AudioEffect.EFFECT_TYPE_NULL, 680 0, 681 0); 682 assertNotNull(msg + ": could not create AudioEffect", effect); 683 int[] param = new int[1]; 684 short[] value = new short[1]; 685 param[0] = Equalizer.PARAM_CURRENT_PRESET; 686 value[0] = (short)0; 687 if (effect.setParameter(param, value) 688 == AudioEffect.SUCCESS) { 689 result = true; 690 } 691 } catch (IllegalArgumentException e) { 692 msg = msg.concat(": Bad parameter value"); 693 loge(msg, "Bad parameter value"); 694 } catch (UnsupportedOperationException e) { 695 msg = msg.concat(": setParameter() rejected"); 696 loge(msg, "setParameter() rejected"); 697 } catch (IllegalStateException e) { 698 msg = msg.concat("setParameter() called in wrong state"); 699 loge(msg, "setParameter() called in wrong state"); 700 } finally { 701 if (effect != null) { 702 effect.release(); 703 } 704 } 705 assertTrue(msg, result); 706 } 707 708 //Test case 3.6: test setParameter(int[], byte[]) 709 @LargeTest 710 public void test3_6SetParameterIntArrayByteArray() throws Exception { 711 boolean result = false; 712 String msg = "test3_6SetParameterIntArrayByteArray()"; 713 AudioEffect effect = null; 714 try { 715 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 716 AudioEffect.EFFECT_TYPE_NULL, 717 0, 718 0); 719 assertNotNull(msg + ": could not create AudioEffect", effect); 720 int[] param = new int[1]; 721 byte[] value = shortToByteArray((short)0); 722 param[0] = Equalizer.PARAM_CURRENT_PRESET; 723 if (effect.setParameter(param, value) 724 == AudioEffect.SUCCESS) { 725 result = true; 726 } 727 } catch (IllegalArgumentException e) { 728 msg = msg.concat(": Bad parameter value"); 729 loge(msg, "Bad parameter value"); 730 } catch (UnsupportedOperationException e) { 731 msg = msg.concat(": setParameter() rejected"); 732 loge(msg, "setParameter() rejected"); 733 } catch (IllegalStateException e) { 734 msg = msg.concat("setParameter() called in wrong state"); 735 loge(msg, "setParameter() called in wrong state"); 736 } finally { 737 if (effect != null) { 738 effect.release(); 739 } 740 } 741 assertTrue(msg, result); 742 } 743 744 //Test case 3.7: test setParameter() throws exception after release() 745 @LargeTest 746 public void test3_7SetParameterAfterRelease() throws Exception { 747 boolean result = false; 748 String msg = "test3_7SetParameterAfterRelease()"; 749 AudioEffect effect = null; 750 try { 751 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 752 AudioEffect.EFFECT_TYPE_NULL, 753 0, 754 0); 755 assertNotNull(msg + ": could not create AudioEffect", effect); 756 effect.release(); 757 effect.setParameter(Equalizer.PARAM_CURRENT_PRESET, (short)0); 758 } catch (IllegalArgumentException e) { 759 msg = msg.concat(": Bad parameter value"); 760 loge(msg, "Bad parameter value"); 761 } catch (UnsupportedOperationException e) { 762 msg = msg.concat(": setParameter() rejected"); 763 loge(msg, "setParameter() rejected"); 764 } catch (IllegalStateException e) { 765 result = true; 766 } finally { 767 if (effect != null) { 768 effect.release(); 769 } 770 } 771 assertTrue(msg, result); 772 } 773 774 //----------------------------------------------------------------- 775 // 4 - get parameters 776 //---------------------------------- 777 778 //Test case 4.0: test getParameter(byte[], byte[]) 779 @LargeTest 780 public void test4_0GetParameterByteArrayByteArray() throws Exception { 781 boolean result = false; 782 String msg = "test4_0GetParameterByteArrayByteArray()"; 783 AudioEffect effect = null; 784 try { 785 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 786 AudioEffect.EFFECT_TYPE_NULL, 787 0, 788 0); 789 assertNotNull(msg + ": could not create AudioEffect", effect); 790 byte[] param = intToByteArray(Equalizer.PARAM_CURRENT_PRESET); 791 byte[] value = new byte[2]; 792 if (!AudioEffect.isError(effect.getParameter(param, value))) { 793 result = true; 794 } 795 } catch (IllegalArgumentException e) { 796 msg = msg.concat(": Bad parameter value"); 797 loge(msg, "Bad parameter value"); 798 } catch (UnsupportedOperationException e) { 799 msg = msg.concat(": getParameter() rejected"); 800 loge(msg, "getParameter() rejected"); 801 } catch (IllegalStateException e) { 802 msg = msg.concat("getParameter() called in wrong state"); 803 loge(msg, "getParameter() called in wrong state"); 804 } finally { 805 if (effect != null) { 806 effect.release(); 807 } 808 } 809 assertTrue(msg, result); 810 } 811 812 //Test case 4.1: test getParameter(int, int[]) 813 @LargeTest 814 public void test4_1GetParameterIntIntArray() throws Exception { 815 boolean result = false; 816 String msg = "test4_1GetParameterIntIntArray()"; 817 AudioEffect effect = null; 818 try { 819 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_ENV_REVERB, 820 AudioEffect.EFFECT_TYPE_NULL, 821 0, 822 0); 823 assertNotNull(msg + ": could not create AudioEffect", effect); 824 int[] value = new int[1]; 825 if (!AudioEffect.isError( 826 effect.getParameter(EnvironmentalReverb.PARAM_DECAY_TIME, value))) { 827 result = true; 828 } 829 } catch (IllegalArgumentException e) { 830 msg = msg.concat(": Bad parameter value"); 831 loge(msg, "Bad parameter value"); 832 } catch (UnsupportedOperationException e) { 833 msg = msg.concat(": getParameter() rejected"); 834 loge(msg, "getParameter() rejected"); 835 } catch (IllegalStateException e) { 836 msg = msg.concat("getParameter() called in wrong state"); 837 loge(msg, "getParameter() called in wrong state"); 838 } finally { 839 if (effect != null) { 840 effect.release(); 841 } 842 } 843 assertTrue(msg, result); 844 } 845 846 //Test case 4.2: test getParameter(int, short[]) 847 @LargeTest 848 public void test4_2GetParameterIntShortArray() throws Exception { 849 boolean result = false; 850 String msg = "test4_2GetParameterIntShortArray()"; 851 AudioEffect effect = null; 852 try { 853 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 854 AudioEffect.EFFECT_TYPE_NULL, 855 0, 856 0); 857 assertNotNull(msg + ": could not create AudioEffect", effect); 858 short[] value = new short[1]; 859 if (!AudioEffect.isError(effect.getParameter(Equalizer.PARAM_CURRENT_PRESET, value))) { 860 result = true; 861 } 862 } catch (IllegalArgumentException e) { 863 msg = msg.concat(": Bad parameter value"); 864 loge(msg, "Bad parameter value"); 865 } catch (UnsupportedOperationException e) { 866 msg = msg.concat(": getParameter() rejected"); 867 loge(msg, "getParameter() rejected"); 868 } catch (IllegalStateException e) { 869 msg = msg.concat("getParameter() called in wrong state"); 870 loge(msg, "getParameter() called in wrong state"); 871 } finally { 872 if (effect != null) { 873 effect.release(); 874 } 875 } 876 assertTrue(msg, result); 877 } 878 879 //Test case 4.3: test getParameter(int, byte[]) 880 @LargeTest 881 public void test4_3GetParameterIntByteArray() throws Exception { 882 boolean result = false; 883 String msg = "test4_3GetParameterIntByteArray()"; 884 AudioEffect effect = null; 885 try { 886 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 887 AudioEffect.EFFECT_TYPE_NULL, 888 0, 889 0); 890 assertNotNull(msg + ": could not create AudioEffect", effect); 891 byte[] value = new byte[2]; 892 if (!AudioEffect.isError(effect.getParameter(Equalizer.PARAM_CURRENT_PRESET, value))) { 893 result = true; 894 } 895 } catch (IllegalArgumentException e) { 896 msg = msg.concat(": Bad parameter value"); 897 loge(msg, "Bad parameter value"); 898 } catch (UnsupportedOperationException e) { 899 msg = msg.concat(": getParameter() rejected"); 900 loge(msg, "getParameter() rejected"); 901 } catch (IllegalStateException e) { 902 msg = msg.concat("getParameter() called in wrong state"); 903 loge(msg, "getParameter() called in wrong state"); 904 } finally { 905 if (effect != null) { 906 effect.release(); 907 } 908 } 909 assertTrue(msg, result); 910 } 911 912 //Test case 4.4: test getParameter(int[], int[]) 913 @LargeTest 914 public void test4_4GetParameterIntArrayIntArray() throws Exception { 915 boolean result = false; 916 String msg = "test4_4GetParameterIntArrayIntArray()"; 917 AudioEffect effect = null; 918 try { 919 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_ENV_REVERB, 920 AudioEffect.EFFECT_TYPE_NULL, 921 0, 922 0); 923 assertNotNull(msg + ": could not create AudioEffect", effect); 924 int[] param = new int[1]; 925 int[] value = new int[1]; 926 param[0] = EnvironmentalReverb.PARAM_DECAY_TIME; 927 if (!AudioEffect.isError(effect.getParameter(param, value))) { 928 result = true; 929 } 930 } catch (IllegalArgumentException e) { 931 msg = msg.concat(": Bad parameter value"); 932 loge(msg, "Bad parameter value"); 933 } catch (UnsupportedOperationException e) { 934 msg = msg.concat(": getParameter() rejected"); 935 loge(msg, "getParameter() rejected"); 936 } catch (IllegalStateException e) { 937 msg = msg.concat("getParameter() called in wrong state"); 938 loge(msg, "getParameter() called in wrong state"); 939 } finally { 940 if (effect != null) { 941 effect.release(); 942 } 943 } 944 assertTrue(msg, result); 945 } 946 947 //Test case 4.5: test getParameter(int[], short[]) 948 @LargeTest 949 public void test4_5GetParameterIntArrayShortArray() throws Exception { 950 boolean result = false; 951 String msg = "test4_5GetParameterIntArrayShortArray()"; 952 AudioEffect effect = null; 953 try { 954 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 955 AudioEffect.EFFECT_TYPE_NULL, 956 0, 957 0); 958 assertNotNull(msg + ": could not create AudioEffect", effect); 959 int[] param = new int[1]; 960 short[] value = new short[1]; 961 param[0] = Equalizer.PARAM_CURRENT_PRESET; 962 if (!AudioEffect.isError(effect.getParameter(param, value))) { 963 result = true; 964 } 965 } catch (IllegalArgumentException e) { 966 msg = msg.concat(": Bad parameter value"); 967 loge(msg, "Bad parameter value"); 968 } catch (UnsupportedOperationException e) { 969 msg = msg.concat(": getParameter() rejected"); 970 loge(msg, "getParameter() rejected"); 971 } catch (IllegalStateException e) { 972 msg = msg.concat("getParameter() called in wrong state"); 973 loge(msg, "getParameter() called in wrong state"); 974 } finally { 975 if (effect != null) { 976 effect.release(); 977 } 978 } 979 assertTrue(msg, result); 980 } 981 982 //Test case 4.6: test getParameter(int[], byte[]) 983 @LargeTest 984 public void test4_6GetParameterIntArrayByteArray() throws Exception { 985 boolean result = false; 986 String msg = "test4_6GetParameterIntArrayByteArray()"; 987 AudioEffect effect = null; 988 try { 989 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 990 AudioEffect.EFFECT_TYPE_NULL, 991 0, 992 0); 993 assertNotNull(msg + ": could not create AudioEffect", effect); 994 int[] param = new int[1]; 995 byte[] value = new byte[2]; 996 param[0] = Equalizer.PARAM_CURRENT_PRESET; 997 if (!AudioEffect.isError(effect.getParameter(param, value))) { 998 result = true; 999 } 1000 } catch (IllegalArgumentException e) { 1001 msg = msg.concat(": Bad parameter value"); 1002 loge(msg, "Bad parameter value"); 1003 } catch (UnsupportedOperationException e) { 1004 msg = msg.concat(": getParameter() rejected"); 1005 loge(msg, "getParameter() rejected"); 1006 } catch (IllegalStateException e) { 1007 msg = msg.concat("getParameter() called in wrong state"); 1008 loge(msg, "getParameter() called in wrong state"); 1009 } finally { 1010 if (effect != null) { 1011 effect.release(); 1012 } 1013 } 1014 assertTrue(msg, result); 1015 } 1016 1017 //Test case 4.7: test getParameter() throws exception after release() 1018 @LargeTest 1019 public void test4_7GetParameterAfterRelease() throws Exception { 1020 boolean result = false; 1021 String msg = "test4_7GetParameterAfterRelease()"; 1022 AudioEffect effect = null; 1023 try { 1024 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 1025 AudioEffect.EFFECT_TYPE_NULL, 1026 0, 1027 0); 1028 assertNotNull(msg + ": could not create AudioEffect", effect); 1029 effect.release(); 1030 short[] value = new short[1]; 1031 effect.getParameter(Equalizer.PARAM_CURRENT_PRESET, value); 1032 } catch (IllegalArgumentException e) { 1033 msg = msg.concat(": Bad parameter value"); 1034 loge(msg, "Bad parameter value"); 1035 } catch (UnsupportedOperationException e) { 1036 msg = msg.concat(": getParameter() rejected"); 1037 loge(msg, "getParameter() rejected"); 1038 } catch (IllegalStateException e) { 1039 result = true; 1040 } finally { 1041 if (effect != null) { 1042 effect.release(); 1043 } 1044 } 1045 assertTrue(msg, result); 1046 } 1047 1048 //----------------------------------------------------------------- 1049 // 5 priority and listeners 1050 //---------------------------------- 1051 1052 //Test case 5.0: test control passed to higher priority client 1053 @LargeTest 1054 public void test5_0setEnabledLowerPriority() throws Exception { 1055 boolean result = false; 1056 String msg = "test5_0setEnabledLowerPriority()"; 1057 AudioEffect effect1 = null; 1058 AudioEffect effect2 = null; 1059 try { 1060 effect1 = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 1061 AudioEffect.EFFECT_TYPE_NULL, 1062 0, 1063 0); 1064 effect2 = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 1065 AudioEffect.EFFECT_TYPE_NULL, 1066 1, 1067 0); 1068 1069 assertNotNull(msg + ": could not create AudioEffect", effect1); 1070 assertNotNull(msg + ": could not create AudioEffect", effect2); 1071 1072 assertTrue(msg + ": Effect2 does not have control", effect2.hasControl()); 1073 assertFalse(msg + ": Effect1 has control", effect1.hasControl()); 1074 assertTrue(msg + ": Effect1 can enable", 1075 effect1.setEnabled(true) == AudioEffect.ERROR_INVALID_OPERATION); 1076 assertFalse(msg + ": Effect1 has enabled", effect2.getEnabled()); 1077 result = true; 1078 } catch (IllegalArgumentException e) { 1079 msg = msg.concat(": Effect not found"); 1080 result = false; 1081 } catch (UnsupportedOperationException e) { 1082 msg = msg.concat(": Effect library not loaded"); 1083 result = false; 1084 } finally { 1085 if (effect1 != null) { 1086 effect1.release(); 1087 } 1088 if (effect2 != null) { 1089 effect2.release(); 1090 } 1091 } 1092 assertTrue(msg, result); 1093 } 1094 1095 //Test case 5.1: test control passed to higher priority client 1096 @LargeTest 1097 public void test5_1setParameterLowerPriority() throws Exception { 1098 boolean result = false; 1099 String msg = "test5_1setParameterLowerPriority()"; 1100 AudioEffect effect1 = null; 1101 AudioEffect effect2 = null; 1102 try { 1103 effect1 = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 1104 AudioEffect.EFFECT_TYPE_NULL, 1105 0, 1106 0); 1107 effect2 = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 1108 AudioEffect.EFFECT_TYPE_NULL, 1109 1, 1110 0); 1111 1112 assertNotNull(msg + ": could not create AudioEffect", effect1); 1113 assertNotNull(msg + ": could not create AudioEffect", effect2); 1114 1115 int status = effect2.setParameter(Equalizer.PARAM_CURRENT_PRESET, (short)0); 1116 assertEquals(msg + ": Effect2 setParameter failed", 1117 AudioEffect.SUCCESS, status); 1118 1119 status = effect1.setParameter(Equalizer.PARAM_CURRENT_PRESET, (short)1); 1120 assertEquals(msg + ": Effect1 setParameter did not fail", 1121 AudioEffect.ERROR_INVALID_OPERATION, status); 1122 1123 short[] value = new short[1]; 1124 status = effect2.getParameter(Equalizer.PARAM_CURRENT_PRESET, value); 1125 assertFalse(msg + ": Effect2 getParameter failed", 1126 AudioEffect.isError(status)); 1127 assertEquals(msg + ": Effect1 changed parameter", 1128 (short)0, value[0]); 1129 1130 result = true; 1131 } catch (IllegalArgumentException e) { 1132 msg = msg.concat(": Effect not found"); 1133 result = false; 1134 } catch (UnsupportedOperationException e) { 1135 msg = msg.concat(": Effect library not loaded"); 1136 result = false; 1137 } finally { 1138 if (effect1 != null) { 1139 effect1.release(); 1140 } 1141 if (effect2 != null) { 1142 effect2.release(); 1143 } 1144 } 1145 assertTrue(msg, result); 1146 } 1147 1148 //Test case 5.2: test control status listener 1149 @LargeTest 1150 public void test5_2ControlStatusListener() throws Exception { 1151 boolean result = false; 1152 String msg = "test5_2ControlStatusListener()"; 1153 mEffect = null; 1154 AudioEffect effect2 = null; 1155 try { 1156 mHasControl = true; 1157 createListenerLooper(true, false, false); 1158 synchronized(lock) { 1159 try { 1160 lock.wait(1000); 1161 } catch(Exception e) { 1162 Log.e(TAG, "Looper creation: wait was interrupted."); 1163 } 1164 } 1165 assertTrue(mInitialized); 1166 synchronized(lock) { 1167 try { 1168 effect2 = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 1169 AudioEffect.EFFECT_TYPE_NULL, 1170 1, 1171 0); 1172 assertNotNull(msg + ": could not create AudioEffect", effect2); 1173 lock.wait(1000); 1174 } catch(Exception e) { 1175 Log.e(TAG, "Create second effect: wait was interrupted."); 1176 } 1177 } 1178 assertFalse(msg + ": effect control not lost by effect1", mHasControl); 1179 result = true; 1180 } catch (IllegalArgumentException e) { 1181 msg = msg.concat(": Equalizer not found"); 1182 loge(msg, ": Equalizer not found"); 1183 } catch (UnsupportedOperationException e) { 1184 msg = msg.concat(": Effect library not loaded"); 1185 loge(msg, ": Effect library not loaded"); 1186 } catch (Exception e){ 1187 loge(msg, "Could not create media player:" + e); 1188 } finally { 1189 terminateListenerLooper(); 1190 if (effect2 != null) { 1191 effect2.release(); 1192 } 1193 } 1194 assertTrue(msg, result); 1195 } 1196 1197 //Test case 5.3: test enable status listener 1198 @LargeTest 1199 public void test5_3EnableStatusListener() throws Exception { 1200 boolean result = false; 1201 String msg = "test5_3EnableStatusListener()"; 1202 mEffect = null; 1203 AudioEffect effect2 = null; 1204 try { 1205 createListenerLooper(false, true, false); 1206 synchronized(lock) { 1207 try { 1208 lock.wait(1000); 1209 } catch(Exception e) { 1210 Log.e(TAG, "Looper creation: wait was interrupted."); 1211 } 1212 } 1213 assertTrue(mInitialized); 1214 mEffect.setEnabled(true); 1215 mIsEnabled = true; 1216 effect2 = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 1217 AudioEffect.EFFECT_TYPE_NULL, 1218 1, 1219 0); 1220 assertNotNull(msg + ": could not create AudioEffect", effect2); 1221 assertTrue(msg + ": effect not enabled", effect2.getEnabled()); 1222 synchronized(lock) { 1223 try { 1224 effect2.setEnabled(false); 1225 lock.wait(1000); 1226 } catch(Exception e) { 1227 Log.e(TAG, "Create second effect: wait was interrupted."); 1228 } 1229 } 1230 assertFalse(msg + ": enable status not updated", mIsEnabled); 1231 result = true; 1232 } catch (IllegalArgumentException e) { 1233 msg = msg.concat(": Equalizer not found"); 1234 loge(msg, ": Equalizer not found"); 1235 } catch (UnsupportedOperationException e) { 1236 msg = msg.concat(": Effect library not loaded"); 1237 loge(msg, ": Effect library not loaded"); 1238 } catch (Exception e){ 1239 loge(msg, "Could not create media player:" + e); 1240 } finally { 1241 terminateListenerLooper(); 1242 if (effect2 != null) { 1243 effect2.release(); 1244 } 1245 } 1246 assertTrue(msg, result); 1247 } 1248 1249 //Test case 5.4: test parameter changed listener 1250 @LargeTest 1251 public void test5_4ParameterChangedListener() throws Exception { 1252 boolean result = false; 1253 String msg = "test5_4ParameterChangedListener()"; 1254 mEffect = null; 1255 AudioEffect effect2 = null; 1256 try { 1257 createListenerLooper(false, false, true); 1258 synchronized(lock) { 1259 try { 1260 lock.wait(1000); 1261 } catch(Exception e) { 1262 Log.e(TAG, "Looper creation: wait was interrupted."); 1263 } 1264 } 1265 assertTrue(mInitialized); 1266 effect2 = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 1267 AudioEffect.EFFECT_TYPE_NULL, 1268 1, 1269 0); 1270 assertNotNull(msg + ": could not create AudioEffect", effect2); 1271 synchronized(lock) { 1272 try { 1273 mParameterChanged = -1; 1274 effect2.setParameter(Equalizer.PARAM_CURRENT_PRESET, (short)0); 1275 lock.wait(1000); 1276 } catch(Exception e) { 1277 Log.e(TAG, "Create second effect: wait was interrupted."); 1278 } 1279 } 1280 assertEquals(msg + ": parameter change not received", 1281 Equalizer.PARAM_CURRENT_PRESET, mParameterChanged); 1282 result = true; 1283 } catch (IllegalArgumentException e) { 1284 msg = msg.concat(": Equalizer not found"); 1285 loge(msg, ": Equalizer not found"); 1286 } catch (UnsupportedOperationException e) { 1287 msg = msg.concat(": Effect library not loaded"); 1288 loge(msg, ": Effect library not loaded"); 1289 } catch (Exception e){ 1290 loge(msg, "Could not create media player:" + e); 1291 } finally { 1292 terminateListenerLooper(); 1293 if (effect2 != null) { 1294 effect2.release(); 1295 } 1296 } 1297 assertTrue(msg, result); 1298 } 1299 1300 //----------------------------------------------------------------- 1301 // 6 command method 1302 //---------------------------------- 1303 1304 1305 //Test case 6.0: test command method 1306 @LargeTest 1307 public void test6_0Command() throws Exception { 1308 boolean result = false; 1309 String msg = "test6_0Command()"; 1310 AudioEffect effect = null; 1311 try { 1312 effect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 1313 AudioEffect.EFFECT_TYPE_NULL, 1314 0, 1315 0); 1316 assertNotNull(msg + ": could not create AudioEffect", effect); 1317 try { 1318 byte[] cmd = new byte[0]; 1319 byte[] reply = new byte[4]; 1320 int status = effect.command(3, cmd, reply); 1321 assertFalse(msg + ": command failed", AudioEffect.isError(status)); 1322 assertTrue(msg + ": effect not enabled", effect.getEnabled()); 1323 result = true; 1324 } catch (IllegalStateException e) { 1325 msg = msg.concat(": command in illegal state"); 1326 } 1327 } catch (IllegalArgumentException e) { 1328 msg = msg.concat(": Equalizer not found"); 1329 loge(msg, ": Equalizer not found"); 1330 } catch (UnsupportedOperationException e) { 1331 msg = msg.concat(": Effect library not loaded"); 1332 loge(msg, ": Effect library not loaded"); 1333 } catch (Exception e){ 1334 loge(msg, "Could not create media player:" + e); 1335 } finally { 1336 if (effect != null) { 1337 effect.release(); 1338 } 1339 } 1340 assertTrue(msg, result); 1341 } 1342 1343 //----------------------------------------------------------------- 1344 // private methods 1345 //---------------------------------- 1346 1347 /* 1348 * Initializes the message looper so that the MediaPlayer object can 1349 * receive the callback messages. 1350 */ 1351 private void createMediaPlayerLooper() { 1352 new Thread() { 1353 @Override 1354 public void run() { 1355 // Set up a looper to be used by mMediaPlayer. 1356 Looper.prepare(); 1357 1358 // Save the looper so that we can terminate this thread 1359 // after we are done with it. 1360 mLooper = Looper.myLooper(); 1361 1362 mMediaPlayer = new MediaPlayer(); 1363 mMediaPlayer.setOnErrorListener(new MediaPlayer.OnErrorListener() { 1364 public boolean onError(MediaPlayer player, int what, int extra) { 1365 synchronized(lock) { 1366 mError = what; 1367 lock.notify(); 1368 } 1369 return true; 1370 } 1371 }); 1372 mMediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() { 1373 public void onCompletion(MediaPlayer player) { 1374 synchronized(lock) { 1375 lock.notify(); 1376 } 1377 } 1378 }); 1379 synchronized(lock) { 1380 mInitialized = true; 1381 lock.notify(); 1382 } 1383 Looper.loop(); // Blocks forever until Looper.quit() is called. 1384 } 1385 }.start(); 1386 } 1387 /* 1388 * Terminates the message looper thread. 1389 */ 1390 private void terminateMediaPlayerLooper() { 1391 if (mLooper != null) { 1392 mLooper.quit(); 1393 mLooper = null; 1394 } 1395 if (mMediaPlayer != null) { 1396 mMediaPlayer.release(); 1397 } 1398 } 1399 1400 /* 1401 * Initializes the message looper fro effect listener 1402 */ 1403 class ListenerThread extends Thread { 1404 boolean mControl; 1405 boolean mEnable; 1406 boolean mParameter; 1407 1408 public ListenerThread(boolean control, boolean enable, boolean parameter) { 1409 super(); 1410 mControl = control; 1411 mEnable = enable; 1412 mParameter = parameter; 1413 } 1414 } 1415 private void createListenerLooper(boolean control, boolean enable, boolean parameter) { 1416 1417 new ListenerThread(control, enable, parameter) { 1418 @Override 1419 public void run() { 1420 // Set up a looper to be used by mEffect. 1421 Looper.prepare(); 1422 1423 // Save the looper so that we can terminate this thread 1424 // after we are done with it. 1425 mLooper = Looper.myLooper(); 1426 1427 mEffect = new AudioEffect(AudioEffect.EFFECT_TYPE_EQUALIZER, 1428 AudioEffect.EFFECT_TYPE_NULL, 1429 0, 1430 0); 1431 assertNotNull("could not create AudioEffect", mEffect); 1432 1433 if (mControl) { 1434 mEffect.setControlStatusListener(new AudioEffect.OnControlStatusChangeListener() { 1435 public void onControlStatusChange(AudioEffect effect, boolean controlGranted) { 1436 synchronized(lock) { 1437 if (effect == mEffect) { 1438 mHasControl = controlGranted; 1439 lock.notify(); 1440 } 1441 } 1442 } 1443 }); 1444 } 1445 if (mEnable) { 1446 mEffect.setEnableStatusListener(new AudioEffect.OnEnableStatusChangeListener() { 1447 public void onEnableStatusChange(AudioEffect effect, boolean enabled) { 1448 synchronized(lock) { 1449 if (effect == mEffect) { 1450 mIsEnabled = enabled; 1451 lock.notify(); 1452 } 1453 } 1454 } 1455 }); 1456 } 1457 if (mParameter) { 1458 mEffect.setParameterListener(new AudioEffect.OnParameterChangeListener() { 1459 public void onParameterChange(AudioEffect effect, int status, byte[] param, 1460 byte[] value) { 1461 synchronized(lock) { 1462 if (effect == mEffect) { 1463 mParameterChanged = byteArrayToInt(param); 1464 lock.notify(); 1465 } 1466 } 1467 } 1468 }); 1469 } 1470 1471 synchronized(lock) { 1472 mInitialized = true; 1473 lock.notify(); 1474 } 1475 Looper.loop(); // Blocks forever until Looper.quit() is called. 1476 } 1477 }.start(); 1478 } 1479 /* 1480 * Terminates the listener looper thread. 1481 */ 1482 private void terminateListenerLooper() { 1483 if (mEffect != null) { 1484 mEffect.release(); 1485 mEffect = null; 1486 } 1487 if (mLooper != null) { 1488 mLooper.quit(); 1489 mLooper = null; 1490 } 1491 } 1492 1493 protected int byteArrayToInt(byte[] valueBuf) { 1494 return byteArrayToInt(valueBuf, 0); 1495 1496 } 1497 1498 protected int byteArrayToInt(byte[] valueBuf, int offset) { 1499 ByteBuffer converter = ByteBuffer.wrap(valueBuf); 1500 converter.order(ByteOrder.nativeOrder()); 1501 return converter.getInt(offset); 1502 1503 } 1504 1505 protected byte[] intToByteArray(int value) { 1506 ByteBuffer converter = ByteBuffer.allocate(4); 1507 converter.order(ByteOrder.nativeOrder()); 1508 converter.putInt(value); 1509 return converter.array(); 1510 } 1511 1512 protected short byteArrayToShort(byte[] valueBuf) { 1513 return byteArrayToShort(valueBuf, 0); 1514 } 1515 1516 protected short byteArrayToShort(byte[] valueBuf, int offset) { 1517 ByteBuffer converter = ByteBuffer.wrap(valueBuf); 1518 converter.order(ByteOrder.nativeOrder()); 1519 return converter.getShort(offset); 1520 1521 } 1522 1523 protected byte[] shortToByteArray(short value) { 1524 ByteBuffer converter = ByteBuffer.allocate(2); 1525 converter.order(ByteOrder.nativeOrder()); 1526 short sValue = (short) value; 1527 converter.putShort(sValue); 1528 return converter.array(); 1529 } 1530 1531} 1532