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