Home | History | Annotate | Download | only in cts
      1 /*
      2  * Copyright (C) 2009 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package android.media.cts;
     18 
     19 import com.android.cts.media.R;
     20 
     21 
     22 import android.content.res.AssetFileDescriptor;
     23 import android.media.JetPlayer;
     24 import android.media.JetPlayer.OnJetEventListener;
     25 import android.os.Environment;
     26 import android.os.Handler;
     27 import android.os.Looper;
     28 import android.test.AndroidTestCase;
     29 
     30 import java.io.File;
     31 import java.io.FileOutputStream;
     32 import java.io.IOException;
     33 import java.io.InputStream;
     34 import java.io.OutputStream;
     35 
     36 public class JetPlayerTest extends AndroidTestCase {
     37     private OnJetEventListener mOnJetEventListener;
     38     private boolean mOnJetUserIdUpdateCalled;
     39     private boolean mOnJetPauseUpdateCalled;
     40     private boolean mOnJetNumQueuedSegmentUpdateCalled;
     41     private boolean mOnJetEventCalled;
     42     private String mJetFile;
     43     /* JetPlayer and Handler will be on the Main Looper */
     44     private Handler mHandler = new Handler(Looper.getMainLooper());
     45     private final JetPlayer mJetPlayer = JetPlayer.getJetPlayer();
     46 
     47     @Override
     48     protected void setUp() throws Exception {
     49         super.setUp();
     50         mOnJetEventListener  = new MockOnJetEventListener();
     51         mJetFile =
     52             new File(Environment.getExternalStorageDirectory(), "test.jet").getAbsolutePath();
     53         assertTrue(JetPlayer.getMaxTracks() > 0);
     54     }
     55 
     56     @Override
     57     protected void tearDown() throws Exception {
     58         File jetFile = new File(mJetFile);
     59         if (jetFile.exists()) {
     60             jetFile.delete();
     61         }
     62         super.tearDown();
     63     }
     64 
     65     public void testLoadJetFromPath() throws Throwable {
     66         mJetPlayer.clearQueue();
     67         prepareFile();
     68         mJetPlayer.setEventListener(mOnJetEventListener);
     69         mJetPlayer.loadJetFile(mJetFile);
     70         runJet();
     71     }
     72 
     73     public void testLoadJetFromFd() throws Throwable {
     74         mJetPlayer.clearQueue();
     75         mJetPlayer.setEventListener(mOnJetEventListener, mHandler);
     76         mJetPlayer.loadJetFile(mContext.getResources().openRawResourceFd(R.raw.test_jet));
     77         runJet();
     78     }
     79 
     80     public void testQueueJetSegmentMuteArray() throws Throwable {
     81         mJetPlayer.clearQueue();
     82         mJetPlayer.setEventListener(mOnJetEventListener, mHandler);
     83         mJetPlayer.loadJetFile(mContext.getResources().openRawResourceFd(R.raw.test_jet));
     84         byte userID = 0;
     85         int segmentNum = 3;
     86         int libNum = -1;
     87         int repeatCount = 0;
     88         int transpose = 0;
     89         boolean[] muteFlags = new boolean[32];
     90         assertTrue(mJetPlayer.queueJetSegmentMuteArray(segmentNum, libNum, repeatCount, transpose,
     91                 muteFlags, userID));
     92         assertTrue(mJetPlayer.play());
     93         for (int i = 0; i < muteFlags.length; i++) {
     94             muteFlags[i] = true;
     95         }
     96         muteFlags[8] = false;
     97         muteFlags[9] = false;
     98         muteFlags[10] = false;
     99         assertTrue(mJetPlayer.queueJetSegmentMuteArray(segmentNum, libNum, repeatCount, transpose,
    100                 muteFlags, userID));
    101         Thread.sleep(20000);
    102         assertTrue(mJetPlayer.pause());
    103         assertTrue(mJetPlayer.clearQueue());
    104         assertFalse(mJetPlayer.play());
    105         assertTrue(mJetPlayer.closeJetFile());
    106     }
    107 
    108     private void runJet() throws Throwable {
    109         byte userID = 0;
    110         int segmentNum = 3;
    111         int libNum = -1;
    112         int repeatCount = 1;
    113         int transpose = 0;
    114         int muteFlags = 0;
    115         mJetPlayer.queueJetSegment(segmentNum, libNum, repeatCount, transpose, muteFlags, userID);
    116 
    117         segmentNum = 6;
    118         repeatCount = 1;
    119         transpose = -1;
    120         mJetPlayer.queueJetSegment(segmentNum, libNum, repeatCount, transpose, muteFlags, userID);
    121 
    122         segmentNum = 7;
    123         transpose = 0;
    124         mJetPlayer.queueJetSegment(segmentNum, libNum, repeatCount, transpose, muteFlags, userID);
    125 
    126         for (int i = 0; i < 7; i++) {
    127             assertTrue(mJetPlayer.triggerClip(i));
    128         }
    129         assertTrue(mJetPlayer.play());
    130         Thread.sleep(10000);
    131         assertTrue(mJetPlayer.pause());
    132         assertFalse(mJetPlayer.setMuteArray(new boolean[40], false));
    133         boolean[] muteArray = new boolean[32];
    134         for (int i = 0; i < muteArray.length; i++) {
    135             muteArray[i] = true;
    136         }
    137         muteArray[8] = false;
    138         muteArray[9] = false;
    139         muteArray[10] = false;
    140         assertTrue(mJetPlayer.setMuteArray(muteArray, true));
    141         Thread.sleep(1000);
    142         assertTrue(mJetPlayer.play());
    143         Thread.sleep(1000);
    144         assertTrue(mJetPlayer.setMuteFlag(9, true, true));
    145         Thread.sleep(1000);
    146         assertTrue(mJetPlayer.setMuteFlags(0, false));
    147         Thread.sleep(1000);
    148         assertTrue(mJetPlayer.setMuteFlags(0xffffffff, false));
    149         Thread.sleep(1000);
    150         assertTrue(mJetPlayer.setMuteFlags(0, false));
    151         Thread.sleep(30000);
    152         assertTrue(mJetPlayer.pause());
    153         assertTrue(mJetPlayer.closeJetFile());
    154         assertTrue(mOnJetEventCalled);
    155         assertTrue(mOnJetPauseUpdateCalled);
    156         assertTrue(mOnJetNumQueuedSegmentUpdateCalled);
    157         assertTrue(mOnJetUserIdUpdateCalled);
    158     }
    159 
    160     public void testClone() throws Exception {
    161         try {
    162             mJetPlayer.clone();
    163             fail("should throw CloneNotSupportedException");
    164         } catch (CloneNotSupportedException e) {
    165             // expect here
    166         }
    167     }
    168 
    169     private void prepareFile() throws IOException {
    170         InputStream source = null;
    171         OutputStream target = null;
    172         try {
    173             source = mContext.getResources().openRawResource(R.raw.test_jet);
    174             target = new FileOutputStream(mJetFile);
    175             byte[] buffer = new byte[1024];
    176             int length;
    177             while ((length = source.read(buffer)) != -1) {
    178                 target.write(buffer, 0, length);
    179             }
    180         } finally {
    181             if (source != null) {
    182                 source.close();
    183             }
    184             if (target != null) {
    185                 target.close();
    186             }
    187         }
    188     }
    189 
    190     private class MockOnJetEventListener implements OnJetEventListener {
    191 
    192         public void onJetEvent(JetPlayer player, short segment, byte track, byte channel,
    193                 byte controller, byte value) {
    194             mOnJetEventCalled = true;
    195         }
    196 
    197         public void onJetNumQueuedSegmentUpdate(JetPlayer player, int nbSegments) {
    198             mOnJetNumQueuedSegmentUpdateCalled = true;
    199         }
    200 
    201         public void onJetPauseUpdate(JetPlayer player, int paused) {
    202             mOnJetPauseUpdateCalled = true;
    203         }
    204 
    205         public void onJetUserIdUpdate(JetPlayer player, int userId, int repeatCount) {
    206             mOnJetUserIdUpdateCalled = true;
    207         }
    208     }
    209 }
    210