1 /*
2  * Copyright (C) 2008 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.mediaplayback;
18 
19 import com.android.mediaframeworktest.MediaFrameworkTest;
20 import com.android.mediaframeworktest.MediaNames;
21 import com.android.mediaframeworktest.MediaProfileReader;
22 import com.android.mediaframeworktest.functional.CodecTest;
23 
24 import android.content.Context;
25 import android.test.ActivityInstrumentationTestCase2;
26 import android.util.Log;
27 import android.test.suitebuilder.annotation.LargeTest;
28 import android.test.suitebuilder.annotation.MediumTest;
29 import android.test.suitebuilder.annotation.Suppress;
30 
31 import java.io.File;
32 
33 /**
34  * Junit / Instrumentation test case for the media player api
35  */
36 public class MediaPlayerApiTest extends  ActivityInstrumentationTestCase2<MediaFrameworkTest> {
37     private boolean duratoinWithinTolerence = false;
38     private String TAG = "MediaPlayerApiTest";
39     private boolean isWMAEnable = false;
40     private boolean isWMVEnable = false;
41 
42     Context mContext;
43 
MediaPlayerApiTest()44     public MediaPlayerApiTest() {
45        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
46        isWMAEnable = MediaProfileReader.getWMAEnable();
47        isWMVEnable = MediaProfileReader.getWMVEnable();
48     }
49 
setUp()50     protected void setUp() throws Exception {
51        //Insert a 2 second before launching the test activity. This is
52        //the workaround for the race condition of requesting the updated surface.
53        Thread.sleep(2000);
54        getActivity();
55        super.setUp();
56     }
57 
verifyDuration(int duration, int expectedDuration)58     public boolean verifyDuration(int duration, int expectedDuration){
59       if ((duration > expectedDuration * 1.1) || (duration < expectedDuration * 0.9))
60          return false;
61       else
62         return true;
63     }
64 
65 
66 
67     //Audio
68     //Wait for PV bugs for MP3 duration
69     @MediumTest
testMP3CBRGetDuration()70     public void testMP3CBRGetDuration() throws Exception {
71       int duration = CodecTest.getDuration(MediaNames.MP3CBR);
72       duratoinWithinTolerence = verifyDuration(duration, MediaNames.MP3CBR_LENGTH);
73       assertTrue("MP3CBR getDuration", duratoinWithinTolerence);
74     }
75 
76     @MediumTest
testMP3VBRGetDuration()77     public void testMP3VBRGetDuration() throws Exception {
78       int duration = CodecTest.getDuration(MediaNames.MP3VBR);
79       Log.v(TAG, "getDuration");
80       duratoinWithinTolerence = verifyDuration(duration, MediaNames.MP3VBR_LENGTH);
81       assertTrue("MP3VBR getDuration", duratoinWithinTolerence);
82     }
83 
84     @MediumTest
testMIDIGetDuration()85     public void testMIDIGetDuration() throws Exception {
86       int duration = CodecTest.getDuration(MediaNames.MIDI);
87       duratoinWithinTolerence = verifyDuration(duration, MediaNames.MIDI_LENGTH);
88       assertTrue("MIDI getDuration", duratoinWithinTolerence);
89     }
90 
91     @MediumTest
testAMRGetDuration()92     public void testAMRGetDuration() throws Exception {
93       int duration = CodecTest.getDuration(MediaNames.AMR);
94       duratoinWithinTolerence = verifyDuration(duration, MediaNames.AMR_LENGTH);
95       assertTrue("AMR getDuration", duratoinWithinTolerence);
96     }
97 
98     /*
99     public void testOGGGetDuration() throws Exception {
100       int duration = CodecTest.getDuration(MediaNames.OGG);
101       duratoinWithinTolerence = verifyDuration(duration, MediaNames.OGG_LENGTH);
102       assertTrue("OGG getDuration", duratoinWithinTolerence);
103     }*/
104 
105 
106     //Test cases for GetCurrentPosition
107     @LargeTest
testMP3CBRGetCurrentPosition()108     public void testMP3CBRGetCurrentPosition() throws Exception {
109       boolean currentPosition = CodecTest.getCurrentPosition(MediaNames.MP3CBR);
110       assertTrue("MP3CBR GetCurrentPosition", currentPosition);
111     }
112 
113     @LargeTest
testMP3VBRGetCurrentPosition()114     public void testMP3VBRGetCurrentPosition() throws Exception {
115       boolean currentPosition = CodecTest.getCurrentPosition(MediaNames.MP3VBR);
116       assertTrue("MP3VBR GetCurrentPosition", currentPosition);
117     }
118 
119     @LargeTest
testMIDIGetCurrentPosition()120     public void testMIDIGetCurrentPosition() throws Exception {
121       boolean currentPosition = CodecTest.getCurrentPosition(MediaNames.MIDI);
122       assertTrue("MIDI GetCurrentPosition", currentPosition);
123     }
124 
125     @LargeTest
testAMRGetCurrentPosition()126     public void testAMRGetCurrentPosition() throws Exception {
127       boolean currentPosition = CodecTest.getCurrentPosition(MediaNames.AMR);
128       assertTrue("AMR GetCurrentPosition", currentPosition);
129     }
130 
131     /*
132     public void testOGGGetCurrentPosition() throws Exception {
133       boolean currentPosition = CodecTest.getCurrentPosition(MediaNames.OGG);
134       assertTrue("OGG GetCurrentPosition", currentPosition);
135      */
136 
137     //Test cases for pause
138     @LargeTest
testMP3CBRPause()139     public void testMP3CBRPause() throws Exception {
140       boolean isPaused = CodecTest.pause(MediaNames.MP3CBR);
141       assertTrue("MP3CBR Pause", isPaused);
142     }
143 
144     @LargeTest
testMP3VBRPause()145     public void testMP3VBRPause() throws Exception {
146       boolean isPaused = CodecTest.pause(MediaNames.MP3VBR);
147       assertTrue("MP3VBR Pause", isPaused);
148     }
149 
150     @LargeTest
testMIDIPause()151     public void testMIDIPause() throws Exception {
152       boolean isPaused = CodecTest.pause(MediaNames.MIDI);
153       assertTrue("MIDI Pause", isPaused);
154     }
155 
156     @LargeTest
testAMRPause()157     public void testAMRPause() throws Exception {
158       boolean isPaused = CodecTest.pause(MediaNames.AMR);
159       assertTrue("AMR Pause", isPaused);
160     }
161 
162     /*
163     public void testOGGPause() throws Exception {
164       boolean isPaused = CodecTest.pause(MediaNames.OGG);
165       assertTrue("OGG Pause", isPaused);
166     }*/
167 
168     @MediumTest
testMP3CBRPrepareStopRelease()169     public void testMP3CBRPrepareStopRelease() throws Exception {
170       CodecTest.prepareStopRelease(MediaNames.MP3CBR);
171       assertTrue("MP3CBR prepareStopRelease", true);
172     }
173 
174     @MediumTest
testMIDIPrepareStopRelease()175     public void testMIDIPrepareStopRelease() throws Exception {
176       CodecTest.prepareStopRelease(MediaNames.MIDI);
177       assertTrue("MIDI prepareStopRelease", true);
178     }
179 
180     //One test case for seek before start
181     @MediumTest
testMP3CBRSeekBeforeStart()182     public void testMP3CBRSeekBeforeStart() throws Exception {
183       boolean seekBeforePlay = CodecTest.seektoBeforeStart(MediaNames.MP3CBR);
184       assertTrue("MP3CBR SeekBeforePlay", seekBeforePlay);
185     }
186 
187     //Skip test - Bug# 1120249
188     /*
189     public void testMP3CBRpreparePauseRelease() throws Exception {
190       CodecTest.preparePauseRelease(MediaNames.MP3CBR);
191       assertTrue("MP3CBR preparePauseRelease", true);
192     }
193 
194     public void testMIDIpreparePauseRelease() throws Exception {
195       CodecTest.preparePauseRelease(MediaNames.MIDI);
196       assertTrue("MIDI preparePauseRelease", true);
197     }
198     */
199 
200 
201     //Test cases for setLooping
202     @LargeTest
testMP3CBRSetLooping()203     public void testMP3CBRSetLooping() throws Exception {
204       boolean isLoop = CodecTest.setLooping(MediaNames.MP3CBR);
205       assertTrue("MP3CBR setLooping", isLoop);
206     }
207 
208     @LargeTest
testMP3VBRSetLooping()209     public void testMP3VBRSetLooping() throws Exception {
210       boolean isLoop = CodecTest.setLooping(MediaNames.MP3VBR);
211       Log.v(TAG, "setLooping");
212       assertTrue("MP3VBR setLooping", isLoop);
213     }
214 
215     @LargeTest
testMIDISetLooping()216     public void testMIDISetLooping() throws Exception {
217       boolean isLoop = CodecTest.setLooping(MediaNames.MIDI);
218       assertTrue("MIDI setLooping", isLoop);
219     }
220 
221     @LargeTest
testAMRSetLooping()222     public void testAMRSetLooping() throws Exception {
223       boolean isLoop = CodecTest.setLooping(MediaNames.AMR);
224       assertTrue("AMR setLooping", isLoop);
225     }
226 
227     /*
228     public void testOGGSetLooping() throws Exception {
229       boolean isLoop = CodecTest.setLooping(MediaNames.OGG);
230       assertTrue("OGG setLooping", isLoop);
231     } */
232 
233     //Test cases for seekTo
234     @LargeTest
testMP3CBRSeekTo()235     public void testMP3CBRSeekTo() throws Exception {
236       boolean isLoop = CodecTest.seekTo(MediaNames.MP3CBR);
237       assertTrue("MP3CBR seekTo", isLoop);
238     }
239 
240     @LargeTest
testMP3VBRSeekTo()241     public void testMP3VBRSeekTo() throws Exception {
242       boolean isLoop = CodecTest.seekTo(MediaNames.MP3VBR);
243       Log.v(TAG, "seekTo");
244       assertTrue("MP3VBR seekTo", isLoop);
245     }
246 
247     @LargeTest
testMIDISeekTo()248     public void testMIDISeekTo() throws Exception {
249       boolean isLoop = CodecTest.seekTo(MediaNames.MIDI);
250       assertTrue("MIDI seekTo", isLoop);
251     }
252 
253     @LargeTest
testAMRSeekTo()254     public void testAMRSeekTo() throws Exception {
255       boolean isLoop = CodecTest.seekTo(MediaNames.AMR);
256       assertTrue("AMR seekTo", isLoop);
257     }
258 
259     /*
260     public void testOGGSeekTo() throws Exception {
261       boolean isLoop = CodecTest.seekTo(MediaNames.OGG);
262       assertTrue("OGG seekTo", isLoop);
263     }*/
264 
265 
266     //Jump to the end of the files
267     @LargeTest
testMP3CBRSeekToEnd()268     public void testMP3CBRSeekToEnd() throws Exception {
269       boolean isEnd = CodecTest.seekToEnd(MediaNames.MP3CBR);
270       assertTrue("MP3CBR seekToEnd", isEnd);
271     }
272 
273     @LargeTest
testMP3VBRSeekToEnd()274     public void testMP3VBRSeekToEnd() throws Exception {
275       boolean isEnd = CodecTest.seekToEnd(MediaNames.MP3VBR);
276       Log.v(TAG, "seekTo");
277       assertTrue("MP3VBR seekToEnd", isEnd);
278     }
279 
280     @LargeTest
testMIDISeekToEnd()281     public void testMIDISeekToEnd() throws Exception {
282       boolean isEnd = CodecTest.seekToEnd(MediaNames.MIDI);
283       assertTrue("MIDI seekToEnd", isEnd);
284     }
285 
286     @LargeTest
testAMRSeekToEnd()287     public void testAMRSeekToEnd() throws Exception {
288       boolean isEnd = CodecTest.seekToEnd(MediaNames.AMR);
289       assertTrue("AMR seekToEnd", isEnd);
290     }
291 
292     /*
293     public void testOGGSeekToEnd() throws Exception {
294       boolean isEnd = CodecTest.seekToEnd(MediaNames.OGG);
295       assertTrue("OGG seekToEnd", isEnd);
296     }*/
297 
298     @LargeTest
testWAVSeekToEnd()299     public void testWAVSeekToEnd() throws Exception {
300         boolean isEnd = CodecTest.seekToEnd(MediaNames.WAV);
301         assertTrue("WAV seekToEnd", isEnd);
302     }
303 
304     @MediumTest
testLargeVideoHeigth()305     public void testLargeVideoHeigth() throws Exception {
306       int height = 0;
307       height = CodecTest.videoHeight(MediaNames.VIDEO_LARGE_SIZE_3GP);
308       Log.v(TAG, "Video height = " +  height);
309       assertEquals("streaming video height", 240, height);
310     }
311 
312     @MediumTest
testLargeVideoWidth()313     public void testLargeVideoWidth() throws Exception {
314       int width = 0;
315       width = CodecTest.videoWidth(MediaNames.VIDEO_LARGE_SIZE_3GP);
316       Log.v(TAG, "Video width = " +  width);
317       assertEquals("streaming video width", 320, width);
318     }
319 
320     @LargeTest
testVideoMP4SeekTo()321     public void testVideoMP4SeekTo() throws Exception {
322       boolean isSeek = CodecTest.videoSeekTo(MediaNames.VIDEO_MP4);
323       assertTrue("Local MP4 SeekTo", isSeek);
324     }
325 
326     @LargeTest
testVideoH263AACSeekTo()327     public void testVideoH263AACSeekTo() throws Exception {
328       boolean isSeek = CodecTest.videoSeekTo(MediaNames.VIDEO_H263_AAC);
329       assertTrue("H263AAC SeekTo", isSeek);
330     }
331 
332     @LargeTest
testVideoH263AMRSeekTo()333     public void testVideoH263AMRSeekTo() throws Exception {
334       boolean isSeek = CodecTest.videoSeekTo(MediaNames.VIDEO_H263_AMR);
335       assertTrue("H263AMR SeekTo", isSeek);
336     }
337 
338     @LargeTest
testVideoH264AACSeekTo()339     public void testVideoH264AACSeekTo() throws Exception {
340       boolean isSeek = CodecTest.videoSeekTo(MediaNames.VIDEO_H264_AAC);
341       assertTrue("H264AAC SeekTo", isSeek);
342     }
343 
344     @LargeTest
testVideoH264AMRSeekTo()345     public void testVideoH264AMRSeekTo() throws Exception {
346       boolean isSeek = CodecTest.videoSeekTo(MediaNames.VIDEO_H264_AMR);
347       assertTrue("H264AMR SeekTo", isSeek);
348     }
349 
350     @LargeTest
testVideoWebmSeekTo()351     public void testVideoWebmSeekTo() throws Exception {
352       boolean isSeek = CodecTest.videoSeekTo(MediaNames.VIDEO_WEBM);
353       assertTrue("WEBM SeekTo", isSeek);
354     }
355 
356     @LargeTest
testSoundRecord()357     public void testSoundRecord() throws Exception {
358       boolean isRecordered = CodecTest.mediaRecorderRecord(MediaNames.RECORDER_OUTPUT);
359       assertTrue("Recorder", isRecordered);
360     }
361 
362     @LargeTest
testGetThumbnail()363     public void testGetThumbnail() throws Exception {
364       boolean getThumbnail = CodecTest.getThumbnail(MediaNames.VIDEO_H264_AAC, MediaNames.GOLDEN_THUMBNAIL_OUTPUT);
365       assertTrue("Get Thumbnail", getThumbnail);
366     }
367 
368     //Play a mid file which the duration is around 210 seconds
369     @LargeTest
testMidiResources()370     public void testMidiResources() throws Exception {
371       boolean midiResources = CodecTest.resourcesPlayback(MediaFrameworkTest.midiafd,16000);
372       assertTrue("Play midi from resources", midiResources);
373     }
374 
375     @LargeTest
testMp3Resources()376     public void testMp3Resources() throws Exception {
377       boolean mp3Resources = CodecTest.resourcesPlayback(MediaFrameworkTest.mp3afd,25000);
378       assertTrue("Play mp3 from resources", mp3Resources);
379     }
380 
381     @MediumTest
testPrepareAsyncReset()382     public void testPrepareAsyncReset() throws Exception {
383       //assertTrue(MediaFrameworkTest.checkStreamingServer());
384       boolean isReset = CodecTest.prepareAsyncReset(MediaNames.STREAM_MP3);
385       assertTrue("PrepareAsync Reset", isReset);
386     }
387 
388     @MediumTest
testIsLooping()389     public void testIsLooping() throws Exception {
390         boolean isLooping = CodecTest.isLooping(MediaNames.AMR);
391         assertTrue("isLooping", isLooping);
392     }
393 
394     @MediumTest
testIsLoopingAfterReset()395     public void testIsLoopingAfterReset() throws Exception {
396         boolean isLooping = CodecTest.isLoopingAfterReset(MediaNames.AMR);
397         assertTrue("isLooping after reset", isLooping);
398     }
399 
400     @LargeTest
testLocalMp3PrepareAsyncCallback()401     public void testLocalMp3PrepareAsyncCallback() throws Exception {
402         boolean onPrepareSuccess =
403             CodecTest.prepareAsyncCallback(MediaNames.MP3CBR, false);
404         assertTrue("LocalMp3prepareAsyncCallback", onPrepareSuccess);
405     }
406 
407     @LargeTest
testLocalH263AMRPrepareAsyncCallback()408     public void testLocalH263AMRPrepareAsyncCallback() throws Exception {
409         boolean onPrepareSuccess =
410             CodecTest.prepareAsyncCallback(MediaNames.VIDEO_H263_AMR, false);
411         assertTrue("testLocalH263AMRPrepareAsyncCallback", onPrepareSuccess);
412     }
413 
414     @LargeTest
testStreamPrepareAsyncCallback()415     public void testStreamPrepareAsyncCallback() throws Exception {
416         //assertTrue(MediaFrameworkTest.checkStreamingServer());
417         boolean onPrepareSuccess =
418             CodecTest.prepareAsyncCallback(MediaNames.STREAM_H264_480_360_1411k, false);
419         assertTrue("StreamH264PrepareAsyncCallback", onPrepareSuccess);
420     }
421 
422     @LargeTest
testStreamPrepareAsyncCallbackReset()423     public void testStreamPrepareAsyncCallbackReset() throws Exception {
424         //assertTrue(MediaFrameworkTest.checkStreamingServer());
425         boolean onPrepareSuccess =
426             CodecTest.prepareAsyncCallback(MediaNames.STREAM_H264_480_360_1411k, true);
427         assertTrue("StreamH264PrepareAsyncCallback", onPrepareSuccess);
428     }
429 }
430