Example #1
0
class VideoPlayBack(TestCaseBase):
    """
    @summary: Test Video PlayBack
    """
    def setUp(self):
        """
        @summary: set up
        @return: None
        """
        super(VideoPlayBack, self).setUp()
        self.d = g_common_obj.get_device()
        self._test_name = __name__
        self.x = self.d.info["displayWidth"]
        self.y = self.d.info["displayHeight"]
        print "[Setup]: %s" % self._test_name
        g_common_obj.stop_app_am(
            "videoplayer.app.instrument.otc.intel.com.otcvideoplayer")
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def tearDown(self):
        """
        @summary: tear tearDown
        @return: None
        """
        super(VideoPlayBack, self).tearDown()
        print "[Teardown]: %s" % self._test_name
        g_common_obj.stop_exp_handle()
        time.sleep(3)
        g_common_obj.stop_app_am(
            "videoplayer.app.instrument.otc.intel.com.otcvideoplayer")
        time.sleep(3)

    def appPrepare(self, case_name, model=1):
        self.cfg_file = os.path.join(os.environ.get('TEST_DATA_ROOT', ''), \
            'tests.tablet.mum_auto_video.conf')
        self.video = PhotosImpl(\
            self.config.read(self.cfg_file, case_name))
        g_common_obj.adb_cmd_capture_msg(" rm -rf /sdcard/DCIM/Camera/*")

        self.multimedia_handle = MultiMediaHandle()
        self.multimedia_setting = MultiMediaSetting(self.cfg_file)
        self.multimedia_setting.clearFolder(self.video.cfg.get("remove_video"))
        time.sleep(2)
        if model == 1:
            self.push_path = self.multimedia_setting.push_file(
                self.video.cfg.get("push_video"),
                self.video.cfg.get("datapath"))

        self.multimedia_setting.install_apk("video_apk")
        self.multimedia_setting.install_apk("alarm_apk")

        self.video.set_orientation_n()
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def getNormalWifi(self):
        conf = self.config.read('tests.tablet.dut_init.conf', 'wifisetting')
        ssid = conf.get("ssid")
        passwd = conf.get("passwd")
        security = conf.get("security")
        print ssid, passwd, security
        return ssid, passwd, security

    def getRTPWifi(self):
        rtp_wifisetting = PhotosImpl(
            self.config.read(self.cfg_file, "rtp_wifisetting"))
        ssid = rtp_wifisetting.cfg.get("ssid")
        passwd = rtp_wifisetting.cfg.get("passwd")
        security = rtp_wifisetting.cfg.get("security")
        print ssid, passwd, security
        return ssid, passwd, security

    def launchRecordAPP(self):
        SystemUI().unlock_screen()
        for _ in range(3):
            g_common_obj.launch_app_am("com.intel.vpg.tool", \
                                   "com.intel.vpg.tool.ConfActivity")
            time.sleep(3)
            if self.d(textContains="Vpg Media Tool").exists:
                return
        assert self.d(
            textContains="Vpg Media Tool").exists, "launch record app failed!"

    def wait_boot_completed(self, timeout=1000):
        ''' wait Android boot_completed
    
        args: timeout -- optional timeout in second, default 180s
        '''
        count = 0
        sleep_time = 5
        while count < timeout:
            prop_val = adb.adb_cmd_capture_msg('getprop sys.boot_completed')
            if '1' in prop_val:
                print 'boot_completed'
                return
            count += sleep_time
            time.sleep(sleep_time)
        raise Exception('%ds timeout waiting for boot_completed' % timeout)

    def clickRecordButton(self):
        self.d(className="android.widget.Button").click()

    def deleteCameraRecordFile(self):
        cmd = "shell rm /storage/emulated/legacy/Android/data/com.example.android.camera2video/files/video.mp4"
        g_common_obj.adb_cmd_common(cmd)

    def checkCameraRecordFile(self, flag=1):
        cmd = "shell ls /storage/emulated/legacy/Android/data/com.example.android.camera2video/files/video.mp4"
        result = g_common_obj.adb_cmd_common(cmd)
        assert ("No such file or directory" not in result.stdout.read()
                ) == flag, "Record file status error! Flag=%s" % (flag)

    def enterBrowseVideo(self, path):
        self.d(className="android.widget.ImageButton").click()
        time.sleep(1)
        self.d(text="Browse Video").click()
        for _ in range(10):
            if self.d(textContains="Open").exists:
                break
            time.sleep(1)
        time.sleep(3)
        self.d.press.back()
        time.sleep(1)
        if self.multimedia_setting.getcheckIputMethod() != '':
            self.d.press.back()
        self.d(className="android.widget.EditText").set_text(path)
        time.sleep(1)
        if self.multimedia_setting.getcheckIputMethod() != '':
            self.d.press.back()
        self.d(text="OK").click()
        for _ in range(5):
            if self.d(text=path).exists:
                break
            time.sleep(5)
        assert self.d(text=path).exists, "can't enter path:%s" % path

    def setTimeToSec(self, time):
        time = time.split(":")
        i = 1
        temp = 0
        for s in time[::-1]:
            temp += int(s) * i
            i *= 60
        return int(temp)

    def setRotation(self, mode):
        self.d(className="android.widget.ImageButton").click()
        time.sleep(1)
        self.d(text=mode).click()
        time.sleep(1)

    def videoPlayBack(self, push_path=""):
        if push_path == "":
            push_path = self.push_path
        return self.multimedia_handle.videoPlayBack(push_path)

    def streamingVideoPlayBack(self, path="", flag=1):
        if path == "":
            path = self.video.cfg.get("video_path")
        return self.multimedia_handle.streamingVideoPlayBack(path, flag)

    def checkVideoPlayBack(self, s=60):
        return self.multimedia_handle.checkVideoPlayBack(s)

    def checkVideoPlayBackWithComparePicture(self,
                                             stoptime,
                                             bigfileskiptime=0):
        return self.multimedia_handle.checkVideoPlayBackWithComparePicture(
            stoptime, bigfileskiptime)

    def checkVideoPlayBackComplete(self, s=900):
        return self.multimedia_handle.checkVideoPlayBackComplete(s)

    def checkVideoFileExist(self, file_name):
        assert self.d(text=file_name).exists, file_name + "file not find!"

    def deleteVideoFile(self, file_name):
        assert self.d(text=file_name).exists, file_name + "file not find!"
        self.d(text=file_name).long_click()
        time.sleep(1)
        self.d(text="Delete").click()
        time.sleep(1)
        self.d(text="Yes").click()
        time.sleep(1)
        assert not self.d(
            text=file_name).exists, file_name + "file delete failed!"

    def checkVideoDetail(self, file_name):
        assert self.d(text=file_name).exists, file_name + "file not find!"
        self.d(text=file_name).long_click()
        time.sleep(1)
        self.d(text="Detail").click()
        time.sleep(1)
        assert self.d(
            textContains=file_name).exists, file_name + "check detail failed!"

    def renameVideoFile(self, file_name, new_name):
        assert self.d(text=file_name).exists, file_name + "file not find!"
        self.d(text=file_name).long_click()
        time.sleep(1)
        self.d(text="Rename").click()
        for _ in range(10):
            if self.d(textContains="Open").exists:
                break
            time.sleep(1)
        time.sleep(3)
        if self.multimedia_setting.getcheckIputMethod() != '':
            self.d.press.back()
        self.d(className="android.widget.EditText").set_text(new_name)
        time.sleep(1)
        if self.multimedia_setting.getcheckIputMethod() != '':
            self.d.press.back()
        self.d(text="OK").click()
        time.sleep(1)
        assert self.d(
            textContains=new_name).exists, file_name + "check detail failed!"

    def interuptionVideoPlayBack(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.videoPlayBack()
        self.checkVideoPlayBack()
        time.sleep(1)
        hardware = self.multimedia_setting.get_paltform_hardware()
        if 'bxtp_abl' or 'gordon_peak' in hardware:
            #  For BXT use relay card press power to sleep
            self.multimedia_setting.pressPowerKey()
            time.sleep(10)
            self.multimedia_setting.pressPowerKey()
        # elif 'gordon_peak' in hardware:
        #     self.logger.error("Case failed due OAM-48191: adb lost in host when resume from S3")
        #     assert False, "case " + str(case_name) + " is Fail"
        else:
            self.d.press.power()
            time.sleep(2)
            self.d.press.power()
        self.lock = SystemUI()
        self.lock.unlock_screen()
        time.sleep(1)
        self.checkVideoPlayBack()
        print "case " + str(case_name) + " is pass"

    def interuptionStreamingVideoPlayBack(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name, 2)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.streamingVideoPlayBack()
        self.checkVideoPlayBack()
        time.sleep(1)
        hardware = self.multimedia_setting.get_paltform_hardware()
        if 'bxtp_abl' or 'gordon_peak' in hardware:
            #  For BXT use relay card press power to sleep
            self.multimedia_setting.pressPowerKey()
            time.sleep(10)
            self.multimedia_setting.pressPowerKey()
        # elif 'gordon_peak' in hardware:
        #     self.logger.error("Case failed due OAM-48191: adb lost in host when resume from S3")
        #     assert False, "case " + str(case_name) + " is Fail"
        else:
            self.d.press.power()
            time.sleep(2)
            self.d.press.power()
        self.lock = SystemUI()
        self.lock.unlock_screen()
        time.sleep(1)
        self.checkVideoPlayBack()
        print "case " + str(case_name) + " is pass"

    def testVideoPlayBack(self, case_name):
        MultiMediaBasicTestCase().testVideoPlayBack(case_name)

    def testStreamingVideoPlayBack(self, case_name):
        MultiMediaBasicTestCase().testStreamingVideoPlayBack(case_name)

    def testRTPStreamingVideoPlayBack(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name, 2)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.streamingVideoPlayBack()
        self.checkVideoPlayBack()
        print "case " + str(case_name) + " is pass"

    def testStreamingVideoPlayBackWithPowerOff(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name, 2)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.streamingVideoPlayBack()
        self.checkVideoPlayBack()
        adb.reboot_device()
        self.wait_boot_completed()
        time.sleep(20)
        self.lock = SystemUI()
        self.lock.unlock_screen()
        print "case " + str(case_name) + " is pass"

    def streamingVideoPlayControlProcess(self, case_name):
        MultiMediaBasicTestCase().streamingVideoPlayControlProcessLong(
            case_name)

    def lowAndHighFramestreamingVideoPlayControlProcess(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name, 2)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.streamingVideoPlayBack()
        time.sleep(10)
        self.checkVideoPlayBack()
        self.d.press.volume_up()
        self.checkVideoPlayBack()
        self.d.press.volume_down()
        self.checkVideoPlayBack()
        self.multimedia_setting.set_play_time(0.5)
        self.checkVideoPlayBack()
        self.d(resourceId="android:id/rew").click()
        self.checkVideoPlayBack()
        #         self.d(resourceId="android:id/ffwd").click()
        #         self.checkVideoPlayBack()
        self.d(resourceId="android:id/pause").click()
        self.checkVideoPlayBack()
        self.d.press.home()
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.streamingVideoPlayBack(self.video.cfg.get("video_path_2"))
        time.sleep(10)
        self.checkVideoPlayBack()
        self.d.press.volume_up()
        self.checkVideoPlayBack()
        self.d.press.volume_down()
        self.checkVideoPlayBack()
        self.multimedia_setting.set_play_time(0.5)
        self.checkVideoPlayBack()
        self.d(resourceId="android:id/rew").click()
        self.checkVideoPlayBack()
        #         self.d(resourceId="android:id/ffwd").click()
        #         self.checkVideoPlayBack()
        self.d(resourceId="android:id/pause").click()
        self.checkVideoPlayBack()
        print "case " + str(case_name) + " is pass"

    def testVideoDurationThumbnail(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.enterBrowseVideo(os.path.split(self.push_path)[0])
        time.sleep(2)
        file_name = os.path.split(
            self.video.cfg.get("push_video"))[1].strip("\"")
        self.checkVideoFileExist(file_name)
        self.d(text=file_name).click()
        time.sleep(1)
        self.checkVideoPlayBack()
        self.d.press.back()
        if not self.d(text=os.path.split(self.push_path)[0]).exists:
            self.d.press.back()
        time.sleep(1)
        self.checkVideoFileExist(file_name)
        print "case " + str(case_name) + " is pass"

    def testStreamingVideoDurationThumbnail(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name, 2)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.streamingVideoPlayBack()
        self.checkVideoPlayBack()
        self.d.press.back()
        assert self.d(text="OtcVideoPlayer").exists, "launch video app failed!"
        print "case " + str(case_name) + " is pass"

    def interuptionVideoPlayBackSwitchHome(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.videoPlayBack()
        self.checkVideoPlayBack()
        time.sleep(1)
        self.d.press.home()
        self.multimedia_setting.click_recent_app("OtcVideoPlayer")
        time.sleep(1)
        self.checkVideoPlayBack()
        print "case " + str(case_name) + " is pass"

    def interuptionStreamingVideoPlayBackSwitchHome(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name, 2)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.streamingVideoPlayBack()
        self.checkVideoPlayBack()
        time.sleep(1)
        self.d.press.home()
        self.multimedia_setting.click_recent_app("OtcVideoPlayer")
        time.sleep(1)
        self.checkVideoPlayBack()
        print "case " + str(case_name) + " is pass"

    def deleteVideoFileCase(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_setting.push_file(self.video.cfg.get("push_video_2"),
                                          self.video.cfg.get("datapath_2"))
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.enterBrowseVideo(os.path.split(self.push_path)[0])
        time.sleep(2)
        self.deleteVideoFile(
            os.path.split(self.video.cfg.get("push_video"))[1].strip("\""))
        self.deleteVideoFile(
            os.path.split(self.video.cfg.get("push_video_2"))[1].strip("\""))
        print "case " + str(case_name) + " is pass"

    def CheckVideoFileInThumbnail(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_setting.push_file(self.video.cfg.get("push_video_2"),
                                          self.video.cfg.get("datapath"))
        self.multimedia_setting.push_file(self.video.cfg.get("push_video_3"),
                                          self.video.cfg.get("datapath"))
        self.multimedia_setting.push_file(self.video.cfg.get("push_video_4"),
                                          self.video.cfg.get("datapath"))
        self.multimedia_setting.push_file(self.video.cfg.get("push_video_5"),
                                          self.video.cfg.get("datapath"))
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.enterBrowseVideo(os.path.split(self.push_path)[0])
        time.sleep(2)
        self.checkVideoFileExist(
            os.path.split(self.video.cfg.get("push_video"))[1].strip("\""))
        self.checkVideoFileExist(
            os.path.split(self.video.cfg.get("push_video_2"))[1].strip("\""))
        self.checkVideoFileExist(
            os.path.split(self.video.cfg.get("push_video_3"))[1].strip("\""))
        self.checkVideoFileExist(
            os.path.split(self.video.cfg.get("push_video_4"))[1].strip("\""))
        self.checkVideoFileExist(
            os.path.split(self.video.cfg.get("push_video_5"))[1].strip("\""))
        print "case " + str(case_name) + " is pass"

    def CheckVideoFileInformationInThumbnail(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.enterBrowseVideo(os.path.split(self.push_path)[0])
        time.sleep(2)
        self.checkVideoDetail(
            os.path.split(self.video.cfg.get("push_video"))[1].strip("\""))
        print "case " + str(case_name) + " is pass"

    def RenameVideoFileInThumbnail(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.enterBrowseVideo(os.path.split(self.push_path)[0])
        time.sleep(2)
        self.renameVideoFile(
            os.path.split(self.video.cfg.get("push_video"))[1].strip("\""),
            self.video.cfg.get("new_name"))
        print "case " + str(case_name) + " is pass"

    def videoPlayBackWithAlarm(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_setting.launchAlarmAPP()
        self.multimedia_setting.setAlarmTime(40)
        self.multimedia_handle.launchVideoApp()
        time.sleep(1)
        self.videoPlayBack()
        self.checkVideoPlayBack()
        time.sleep(1)
        self.multimedia_setting.waitAlarmTriiggered(60, "Snooze")
        self.multimedia_setting.setAlarmTime(30)
        self.multimedia_setting.click_recent_app("OtcVideoPlayer")
        self.checkVideoPlayBack()
        self.multimedia_setting.waitAlarmTriiggered(50, "Dismiss")
        self.multimedia_setting.click_recent_app("OtcVideoPlayer")
        self.checkVideoPlayBack()
        print "case " + str(case_name) + " is pass"

    def streamingVideoPlayBackWithAlarm(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name, 2)
        self.multimedia_setting.launchAlarmAPP()
        self.multimedia_setting.setAlarmTime(60)
        self.multimedia_handle.launchVideoApp()
        time.sleep(1)
        self.streamingVideoPlayBack()
        self.checkVideoPlayBack()
        time.sleep(1)
        self.multimedia_setting.waitAlarmTriiggered(80, "Snooze")
        self.multimedia_setting.setAlarmTime(60)
        self.multimedia_setting.click_recent_app("OtcVideoPlayer")
        self.checkVideoPlayBack()
        self.multimedia_setting.waitAlarmTriiggered(80, "Dismiss")
        self.multimedia_setting.click_recent_app("OtcVideoPlayer")
        self.checkVideoPlayBack()
        print "case " + str(case_name) + " is pass"

    def testVideoPlaybackRotation(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.videoPlayBack()
        self.checkVideoPlayBack()
        self.d.click(self.x / 2, self.y / 2)
        self.setRotation("Landscape View")
        self.checkVideoPlayBack()
        self.d.click(self.x / 2, self.y / 2)
        self.setRotation("Portrait View")
        self.checkVideoPlayBack()
        print "case " + str(case_name) + " is pass"

    def testStreamingVideoPlaybackRotation(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name, 2)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.streamingVideoPlayBack()
        self.checkVideoPlayBack()
        self.d.click(self.x / 2, self.y / 2)
        self.setRotation("Landscape View")
        self.checkVideoPlayBack()
        self.d.click(self.x / 2, self.y / 2)
        self.setRotation("Portrait View")
        self.checkVideoPlayBack()
        print "case " + str(case_name) + " is pass"

    def testStreamingVideoPlayBackWithDownloadFile(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name, 2)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.streamingVideoPlayBack()
        self.checkVideoPlayBack()
        self.push_path = self.multimedia_setting.push_file(
            self.video.cfg.get("push_video"), self.video.cfg.get("datapath"))
        time.sleep(3)
        self.checkVideoPlayBack()
        self.d.press.home()
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.videoPlayBack()
        self.checkVideoPlayBack()
        print "case " + str(case_name) + " is pass"

    def cameraRecordWithAlarm(self, case_name):
        print "run case is " + str(case_name)
        self.deleteCameraRecordFile()
        self.checkCameraRecordFile(0)
        self.multimedia_setting.launchAlarmAPP()
        self.multimedia_setting.setAlarmTime(30)
        self.launchRecordAPP()
        time.sleep(1)
        self.clickRecordButton()
        self.multimedia_setting.waitAlarmTriiggered(50, "Dismiss")
        self.multimedia_setting.click_recent_app("Camera2Video")
        time.sleep(1)
        self.clickRecordButton()
        self.checkCameraRecordFile()
        print "case " + str(case_name) + " is pass"

    def videoPlayBackLonglasting(self, case_name, bigfileskiptime=0):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        lasting_time = int(self.video.cfg.get("lasting_time"))
        push_folder = os.path.split(os.path.split(self.push_path)[0])[-1]
        self.video.launchPhotos(push_folder)
        time.sleep(2)
        self.multimedia_handle.checkVideoPlayBackWithPhotoApp(
            lasting_time, bigfileskiptime, 1)
        print "case " + str(case_name) + " is pass"

    def testPlaying_streaming_Music_Back(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        3. Press back
        """
        self.testStreamingVideoDurationThumbnail("test_API_video_playback_012")

    def testSHALL_support_H264_video_stream_no_frame_rate_limitation(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        3. Start/Stop
        """
        self.lowAndHighFramestreamingVideoPlayControlProcess(
            "test_API_video_playback_026")

    def testHTML5_video_playback_MP4_H264_BP(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.streamingVideoPlayControlProcess("test_API_video_playback_028")

    def testPFT_7098_VPG_HW_acceleratiof_HTML5_video_tag_H264(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testStreamingVideoPlayBack("test_API_video_playback_029")

    def testHTML5_video_playback_MP4_H264_HP(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.streamingVideoPlayControlProcess("test_API_video_playback_037")

    def testLongTime_HTML5_video_playback_MP4_H264(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.streamingVideoPlayControlProcess("test_API_video_playback_042")

    def testPseudo_streaming_clock_alarm(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        3. Alarm expired
        4. Snooze the alarm
        5. Dismiss the alarm
        """
        self.streamingVideoPlayBackWithAlarm("test_API_video_playback_047")

    def testPseudo_streaming_HTTP_H264_640x480_60fps_NoAudio_mkv(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testStreamingVideoPlayBack("test_API_video_playback_048")

    def testPseudo_streaming_HTTP_H264_L4_0_HP_720x576_30fps_AAC_160kbps_48KHz(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testStreamingVideoPlayBack("test_API_video_playback_049")

    def testPseudo_streaming_HTTP_VP8_176x144_15fps_334Kbps_NoAudio_webm(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testStreamingVideoPlayBack("test_API_video_playback_050")

    def testPlaying_streaming_Music_Power_Off(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testStreamingVideoPlayBackWithPowerOff(
            "test_API_video_playback_051")

    def testSHALL_support_H264_video_stream_with_no_size_limitation(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        3. Start/Stop
        """
        self.lowAndHighFramestreamingVideoPlayControlProcess(
            "test_API_video_playback_055")

    def testPFT_7102_Network_streaming_protocols_HTTP_S_Live_Streaming(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testStreamingVideoPlayBack("test_API_video_playback_086")

    def testVideo_MPEG4_ASP_L1_720p_30fps_AAC_128kb_48KHz_RTP_streaming(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testStreamingVideoPlayBack("test_API_video_playback_089")

    def testVideo_H263_CIF_30FPS_AAC_44KHz_127Kbps_RTP_streaming(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testStreamingVideoPlayBack("test_API_video_playback_090")

    def testVideo_H264_f4v_MP_L3_1_640x480_30fps_AAC_44_1KHz_128kbps_over_WLAN(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testStreamingVideoPlayBack("test_API_video_playback_091")

    def testVideo_H264_L2_1_BP_CIF_30fps_AAC_Multimedia_56kb_48KHz_RTP_streaming(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testStreamingVideoPlayBack("test_API_video_playback_092")

    def testPseudo_streaming_HTTP_H264_MP_320x240_15fps_211Kbps_NoAudio_3gp(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testStreamingVideoPlayBack("test_API_video_playback_093")

    def testPseudo_streaming_HTTP_VP8_CIF_25fps_Vorbis_44_1KHz_128kbps_webm_rotate_sleep_resume(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.streamingVideoPlayControlProcess("test_API_video_playback_094")

    def testPseudo_streaming_file_downloading_in_background(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testStreamingVideoPlayBackWithDownloadFile(
            "test_API_video_playback_103")

    def testPFT_7100_Network_streaming_protocols_RTSP_RTP_SDP(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testRTPStreamingVideoPlayBack("test_API_video_playback_109")

    def testLongTime_video_playback_H264_HP_L4_1_1080P_30fps_4_5Mbps_noAudio_mp4(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('Long-time Video playback: H264_HP_L4.1_1080P_30fps_4.5Mbps_na.mp4 (10 hours)')
        3. Former name: test_video_playback_long_lasting_mum_007
        """
        self.videoPlayBackLonglasting(
            "mum_test_video_playback_long_lasting_007", 20)

    def testLongTime_video_playback_VP8_VGA_20fps_2Mbps_Vorbis_48KHz_128kbps_webm(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('Long-time Video playback: VP8_VGA_20fps_2Mbps_Vorbis_48KHz_128kbps.webm (10 hours)')
        3. Former name: test_video_playback_long_lasting_mum_008
        """
        self.videoPlayBackLonglasting(
            "mum_test_video_playback_long_lasting_008", 20)
class VideoPlayBackIteration(TestCaseBase):
    """
    @summary: Test Video PlayBack
    """

    def setUp(self):
        """
        @summary: set up
        @return: None
        """
        super(VideoPlayBackIteration, self).setUp()
        self._test_name = __name__
        print "[Setup]: %s" % self._test_name
        g_common_obj.stop_app_am("com.google.android.apps.plus")
        g_common_obj.stop_app_am("com.google.android.apps.photos")
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def tearDown(self):
        """
        @summary: tear tearDown
        @return: None
        """
        super(VideoPlayBackIteration, self).tearDown()
        print "[Teardown]: %s" % self._test_name
        g_common_obj.stop_exp_handle()
        time.sleep(3)

    def appPrepare(self, case_name):
        cfg_file = os.path.join(os.environ.get('TEST_DATA_ROOT', ''), \
            'tests.tablet.mum_auto_video.conf')
        self.video = PhotosImpl(\
            self.config.read(cfg_file, case_name))
        self.setting = SettingImpl(\
            self.config.read(cfg_file, case_name))
        g_common_obj.adb_cmd_capture_msg(" rm -rf /sdcard/DCIM/Camera/*")
        
        self.multimedia_handle = MultiMediaHandle()
        self.multimedia_setting = MultiMediaSetting(cfg_file)
        self.multimedia_setting.clearFolder(self.video.cfg.get("remove_video"))
        self.multimedia_setting.install_apk("video_apk")
        time.sleep(2)
        self.push_path = self.multimedia_setting.push_file(self.video.cfg.get("push_video"), self.video.cfg.get("datapath"))
        
        g_common_obj.adb_cmd_capture_msg(self.video.cfg.get("refresh_sd"))
        self.video.set_orientation_n()
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def videoPlayBackIteration(self, case_name, bigfileskiptime=0):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        push_folder = os.path.split(os.path.split(self.push_path)[0])[-1]
        for iteration in range(int(self.video.cfg.get("iteration_times"))):
            logger.info("Playback video iteration: {0} ".format(iteration + 1))
            if self.multimedia_setting.get_android_version() == "O":
                self.multimedia_handle.launchVideoApp()
                self.multimedia_handle.videoPlayBack(self.push_path)
                assert self.multimedia_handle.checkVideoPlayBackWithComparePicture(60), 'video play failed'
            else:
                self.video.launchPhotos(push_folder)
                time.sleep(2)
                self.multimedia_handle.checkVideoPlayBackWithPhotoApp(int(self.video.cfg.get("iteration_last_time")), bigfileskiptime)
                self.setting.recent_app()
                self.setting.remove_recent_app("OtcVideoPlayer")
        print "case " + str(case_name) + " is pass"

    def testVideoPlayback_Iteration_3GP_H263_20cycles(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('H263 for 3GP continuouly play 20 times')
        3. Former name: test_video_playback_iteration_mum_001
        """
        self.videoPlayBackIteration("mum_test_video_playback_iteration_001")

    def testVideoPlayback_Iteration_MP4_H264_HP_1080P_30fps_50Mbps_AAC_LC_48KHz_320Kbps(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('H263 for 3GP continuouly play 20 times')
        3. Former name: test_video_playback_iteration_mum_002
        """
        self.videoPlayBackIteration("mum_test_video_playback_iteration_002")

    def testVideoPlayback_Iteration_MP4_H264_HP_1080P_30fps_25Mbps_AAC_ELD_48KHz_192kbps(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('Iterative Video playback: H264_HP_1080P_30fps_25Mbps_AAC_ELD_48KHz_192kbps.mp4, iteratively')
        3. Former name: test_video_playback_iteration_mum_003
        """
        self.videoPlayBackIteration("mum_test_video_playback_iteration_003", 20)

    def test_video_playback_iteration_mum_004(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('H263 for 3GP continuouly play 20 times')
        """
        self.videoPlayBackIteration("mum_test_video_playback_iteration_004")

    def test_video_playback_iteration_mum_005(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('MPEG4 part 2 SP (Simple Profile) and (Advanced Simple Profile) play 20 times continuoously')
        """
        self.videoPlayBackIteration("mum_test_video_playback_iteration_005")

    def testVideoPlayback_Iteration_3GP_H264_Part2v4_20cycles(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('H264 Part 2 For .3GPv4 continuouly play 20 times')
        3. Former name: test_video_playback_iteration_mum_006
        """
        self.videoPlayBackIteration("mum_test_video_playback_iteration_006")

    def testVideoPlayback_Iteration_H264_L3_0_L4_0_HP_20cycles(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('Video Playback H.264 Level 3.0, 4.0 High Profile play contnuously 20 times')
        3. Former name: test_video_playback_iteration_mum_007
        """
        self.videoPlayBackIteration("mum_test_video_playback_iteration_007")

    def testVideoPlayback_Iteration_H264_L1_0_L2_0_BP_20cycles(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('Video Playback H.264 Level 1.0, 2.0 Baseline Profile play continuously 20 times')
        3. Former name: test_video_playback_iteration_mum_008
        """
        self.videoPlayBackIteration("mum_test_video_playback_iteration_008")

    def testVideoPlayback_Iteration_MP4_H263_20cycles(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('Video Codec : H263 For .Mp4 play 20 times')
        3. Former name: test_video_playback_iteration_mum_009
        """
        self.videoPlayBackIteration("mum_test_video_playback_iteration_009")

    def testVideoPlayback_Iteration_3GP_MPEG4_Part2_3GPv5_20cycles(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('MPEG4 Part 2 For .3GPv5 continuouly play 20 times')
        3. Former name: test_video_playback_iteration_mum_010
        """
        self.videoPlayBackIteration("mum_test_video_playback_iteration_010")

    def test_video_playback_iteration_mum_011(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('MPEG4 Part 2 For .3GPv5 continuouly play 20 times')
        """
        self.videoPlayBackIteration("mum_test_video_playback_iteration_011")

    def test_video_playback_iteration_mum_012(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('MPEG4 Part 2 For .3GPv5 continuouly play 20 times')
        """
        self.videoPlayBackIteration("mum_test_video_playback_iteration_012")

    def test_video_playback_iteration_mum_013(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('MPEG4 Part 2 For .3GPv5 continuouly play 20 times')
        """
        self.videoPlayBackIteration("mum_test_video_playback_iteration_013")

    def test_video_playback_iteration_001(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('H263 Decoder, H263_720x450_30fps_no_audio')
        """
        self.videoPlayBackIteration("test_video_playback_iteration_001")

    def test_video_playback_iteration_004(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_004")

    def test_video_playback_iteration_005(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_005")

    def test_video_playback_iteration_006(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_006")

    def test_video_playback_iteration_007(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_007")

    def test_video_playback_iteration_008(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_008")

    def test_video_playback_iteration_010(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_010")

    def test_video_playback_iteration_011(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_011")

    def test_video_playback_iteration_012(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_012")

    def test_video_playback_iteration_013(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_013")

    def test_video_playback_iteration_014(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_014")

    def test_video_playback_iteration_015(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_015")

    def test_video_playback_iteration_017(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_017")

    def test_video_playback_iteration_018(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_018")

    def test_video_playback_iteration_019(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_019")

    def test_video_playback_iteration_021(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_021")

    def test_video_playback_iteration_022(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_022")

    def test_video_playback_iteration_024(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_024")

    def test_video_playback_iteration_025(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_025")

    def test_video_playback_iteration_026(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_026")

    def test_video_playback_iteration_027(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_027")

    def test_video_playback_iteration_028(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_028")

    def test_video_playback_iteration_029(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_029")

    def test_video_playback_iteration_030(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_030")

    def test_video_playback_iteration_031(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_031")

    def test_video_playback_iteration_032(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_032")

    def test_video_playback_iteration_033(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_033")

    def test_video_playback_iteration_034(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_034")

    def test_video_playback_iteration_035(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_035")

    def test_video_playback_iteration_036(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_036")

    def test_video_playback_iteration_037(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_037")

    def test_video_playback_iteration_038(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_038")

    def test_video_playback_iteration_039(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_039")

    def test_video_playback_iteration_040(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_040")

    def test_video_playback_iteration_041(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_041")

    def test_video_playback_iteration_042(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_042")

    def test_video_playback_iteration_043(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_043")

    def test_video_playback_iteration_044(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_044")

    def test_video_playback_iteration_045(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_045")

    def test_video_playback_iteration_046(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBackIteration("test_video_playback_iteration_046")
Example #3
0
class VideoEncode(TestCaseBase):
    """
    @summary: Test Video encode
    """

    def setUp(self):
        """
        @summary: set up
        @return: None
        """
        super(VideoEncode, self).setUp()
        self.d = g_common_obj.get_device()
        self.x = self.d.info["displayWidth"]
        self.y = self.d.info["displayHeight"]
        self._test_name = __name__
        self.tag = "[Video Encode] "
        logger.debug(self.tag + 'run case name is ' + sys._getframe().f_back.f_code.co_name)
        logger.debug(self.tag + '[Setup]: ' + self._test_name)
        g_common_obj.stop_app_am("com.google.android.GoogleCamera")
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def tearDown(self):
        """
        @summary: tearDown
        @return: None
        """
        super(VideoEncode, self).tearDown()
        print "[Teardown]: %s" % self._test_name
        g_common_obj.stop_exp_handle()
        time.sleep(3)
        g_common_obj.stop_app_am("com.google.android.GoogleCamera")
        time.sleep(3)
        g_common_obj.adb_cmd_capture_msg(" rm -rf /sdcard/DCIM/Camera/*")
        time.sleep(10)
        g_common_obj.adb_cmd_capture_msg(self.video.cfg.get("refresh_sd"))

    def appPrepare(self, case_name):
        cfg_file = os.path.join(os.environ.get('TEST_DATA_ROOT', ''), \
            'tests.tablet.mum_auto_video.conf')
        self.video = PhotosImpl(\
            self.config.read(cfg_file, case_name))
        self.camera = CameraImpl(\
            self.config.read(cfg_file, case_name))
        self.multimedia_handle = MultiMediaHandle()
        g_common_obj.adb_cmd_capture_msg(" rm -rf /sdcard/DCIM/Camera/*")
        g_common_obj.adb_cmd_capture_msg(self.video.cfg.get("refresh_sd"))
        
        self.multimedia_setting = MultiMediaSetting(cfg_file)
        self.multimedia_setting.install_apk("video_apk")
        self.multimedia_setting.install_apk("alarm_apk")
        self.multimedia_setting.install_apk("ffmpegCLI_apk")
        self.multimedia_setting.install_apk("EncodeAndMux_4K_Encode_apk")
        self.video.set_orientation_n()
        self.camera.clean_up_camera_data()
        if self.video.cfg.get("push_video") != None:
            self.multimedia_setting.clearFolder(self.video.cfg.get("remove_video"))
            self.push_path = self.multimedia_setting.push_file(self.video.cfg.get("push_video"), self.video.cfg.get("datapath"))

    def launchRecordAPP(self):
        SystemUI().unlock_screen()
        for _ in range(3):
            g_common_obj.launch_app_am("com.intel.vpg.tool", \
                                   "com.intel.vpg.tool.ConfActivity")
            time.sleep(3)
            if self.d(textContains="Vpg Media Tool").exists:
                return
        assert self.d(textContains="Vpg Media Tool").exists, "launch record app failed!"

    def launchVideoRecTestAPP(self):
        logger.debug(self.tag + "Start to launch VideoRecTest")
        for _ in range(3):
            g_common_obj.launch_app_am("com.intel.mchen33.videorectest", \
                                       ".MainActivity")
            time.sleep(3)
            if self.d(resourceId="com.intel.mchen33.videorectest:id/surfaceViewPreview").exists:
                return
        assert self.d(resourceId="com.intel.mchen33.videorectest:id/surfaceViewPreview").exists, "launch VideoRecTest app failed!"

    def videoRectTestRecod(self, encode_type='ST_VIDEO_REC_ENCODE_001'):
        for _ in range(3):
            self.d(resourceId="android:id/text1").click()
            self.d(scrollable=True).scroll.to(text=encode_type)
            self.d(text=encode_type).click()
            if self.d(text=encode_type).exists:
                logger.debug(self.tag + "set the encode type to %s" % encode_type)
                break
        try:
            self.d(text="Start").click()
            self.multimedia_setting.getScreenshotToHost("Video_Rec_Encode.png", g_common_obj.get_user_log_dir())
            time.sleep(2)
            assert not self.d(text="Failed").exists, "Cannot recoder this video"
            logger.debug(self.tag + "Start to record 15 seconds")
            time.sleep(15)
            self.d(text="Stop").click()
        except Exception as e:
            logger.error(self.tag + "Record fail, Exception:%s" % e)
            return False
        logger.debug(self.tag + "Record success")
        return True

    def checkVideoRecTestfile(self, encode_type='ST_VIDEO_REC_ENCODE_001', flag=True):
        import re
        size_pattern = re.compile("sdcard_rw(.*)20")
        file_path = '/sdcard/' + encode_type + '*'
        cmd = "shell ls -l %s" % (file_path)
        # result = g_common_obj.adb_cmd_capture_msg(cmd)
        result = self.multimedia_setting.execute_adb_command(cmd)
        size = re.findall(size_pattern, result)
        assert ("No such file or directory" not in result) == flag, "Record file status error! result=%s" % (result)
        if size != []:
            assert str(0) != size[0], "Record file size is zero, error!"
        g_common_obj.pull_file(g_common_obj.get_user_log_dir(), file_path)
        logger.debug(self.tag + "record file:" + result)
        logger.debug(self.tag + "record file exist")
        return True


    def clickRecordButton(self, record_file_name, record_type):
        self.d(className="android.widget.Spinner").click()
        self.d(textContains="VIDEO RECORDER").click()
        self.d(className="android.widget.EditText").set_text(record_file_name)
        self.d(className="android.widget.ScrollView").scroll.to(textContains="Use MediaCodec Encoder")
        self.d(textContains="Use MediaCodec Encoder").click()
        self.d(className="android.widget.ScrollView").scroll.to(textContains="APPLY")
        self.d(textContains="video/").click()
        self.d(text=record_type).click()
        self.d(className="android.widget.ScrollView").scroll.to(textContains="APPLY")
        self.d(textContains="APPLY").click()
        time.sleep(2)
        self.d.click(self.x/2,self.y/2)

    def deleteCameraRecordFile(self, file_name):
        cmd = "shell rm /sdcard/Pictures/VpgMediaTool/%s" % (file_name)
        g_common_obj.adb_cmd_common(cmd)

    def checkCameraRecordFile(self, file_name, flag=True):
        cmd = "shell ls /sdcard/Pictures/VpgMediaTool/%s" % (file_name)
        #result = g_common_obj.adb_cmd_capture_msg(cmd)
        result = self.multimedia_setting.execute_adb_command(cmd)
        logger.debug("camera file:" + result)
        assert ("No such file or directory" not in result) == flag, "Record file status error! result=%s" % (result)

    def changeCameraTypeStr(self, camera_type):
        if "Back" in camera_type:
            return "Back"
        return "Front"
            

    def videoEncodeThenPlayback(self, case_name):
        """
        This test used to test video encode then playback
        The test case spec is following:
        1. Launch camera
        2. record video
        3. playback
        """
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_camera_helper = MultiMediaCameraHelper()
        self.multimedia_camera_helper.camera.startCameraApp()
        self.multimedia_camera_helper.camera.selectMode("Video")
        camera_type = self.changeCameraTypeStr(self.video.cfg.get("camera_type"))
        self.multimedia_camera_helper.camera.switchRearOrFront(camera_type)
        self.multimedia_camera_helper.camera.clickRecordBtn()
        time.sleep(int(self.video.cfg.get("record_time")))
        self.multimedia_camera_helper.camera.clickRecordBtn()
        time.sleep(5)
        self.multimedia_camera_helper.camera.reviewPhotoAndVideo()
        print "case " + str(case_name) + " is pass"

    def recordingWithVPGTool(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_setting.install_apk("vpg_apk")
        file_name = self.video.cfg.get("file_name")
        record_type = self.video.cfg.get("record_type")
        self.deleteCameraRecordFile(file_name)
        self.checkCameraRecordFile(file_name, False)
        self.launchRecordAPP()
        self.clickRecordButton(file_name.split(".")[0], record_type)
        time.sleep(2)
        assert not self.d(text="Unfortunately, Vpg Media Tool has stopped.").exists, "Vpg app error!!!"
        time.sleep(10)
        self.d.click(self.x/2,self.y/2)
        time.sleep(3)
        self.checkCameraRecordFile(file_name)
        print "case " + str(case_name) + " is pass"

    def recordingWithVideoRectest(self, case_name):
        logger.debug(self.tag + 'run case name is ' + sys._getframe().f_back.f_code.co_name)
        self.appPrepare(case_name)
        self.multimedia_setting.install_apk("rec_apk")
        encode_type = self.video.cfg.get("encode_type")
        g_common_obj.adb_cmd_capture_msg(self.video.cfg.get("remove_video"))
        #file_name = self.video.cfg.get("file_name")
        self.launchVideoRecTestAPP()
        assert self.videoRectTestRecod(encode_type) , "Record failed"
        assert self.checkVideoRecTestfile(encode_type), "Record file not exist"
        logger.debug(self.tag + 'run %s is pass '%sys._getframe().f_back.f_code.co_name)


    def videoEncodeSettingResolutionThenPlayback(self, case_name):
        """
        This test used to test video encode then playback
        The test case spec is following:
        1. Launch camera
        2. set resolution
        3. record video
        4. playback
        """
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_camera_helper = MultiMediaCameraHelper()
        self.multimedia_camera_helper.camera.startCameraApp()
        self.multimedia_camera_helper.camera.selectMode("Video")
        camera_type = self.changeCameraTypeStr(self.video.cfg.get("camera_type"))
        print camera_type
        if "bxtp" in self.multimedia_setting.get_paltform_hardware():
            logger.debug("For BXT, do not switch Rear/Front")
        else:
            self.multimedia_camera_helper.camera.switchRearOrFront(camera_type)
        resolution = self.multimedia_camera_helper.changeResolution(self.camera.cfg.get("resolution"))
        self.multimedia_camera_helper.camera.setVideoResolution(resolution, camera_type)
        self.multimedia_camera_helper.camera.recordVideo(1, int(self.video.cfg.get("record_time")))
        self.multimedia_camera_helper.camera.reviewPhotoAndVideo()
        print "case " + str(case_name) + " is pass"

    def videoEncodeSettingResolution(self, case_name):
        """
        This test used to test video encode then playback
        The test case spec is following:
        1. Launch camera
        2. set resolution
        3. record video
        4. playback
        """
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.camera.enter_camera_from_home()
        self.camera.switch_module_in_camera()
        self.camera.change_front_back_camera(self.video.cfg.get("camera_type"))
        self.camera.click_camera_menu_setting_vert()
        self.camera.enter_camera_setting_video_quality()
        self.camera.set_camera_setting_video_quality(self.video.cfg.get("resolution"),self.video.cfg.get("camera_type"))
        self.camera.press_back()
        self.camera.press_back()
        self.camera.capture_video_camera_initial_page(recordTime=self.video.cfg.get("record_time"))
        print "case " + str(case_name) + " is pass"

    def videoEncodeCapturePauseMultipleTimes(self, case_name):
        """
        This test used to test video encode then playback
        The test case spec is following:
        1. Launch camera
        2. set resolution
        3. Start/stop capturing video for multiple times quickly
        """
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.camera.enter_camera_from_home()
        self.camera.switch_module_in_camera()
        self.camera.change_front_back_camera(self.video.cfg.get("camera_type"))
        self.camera.click_camera_menu_setting_vert()
        self.camera.enter_camera_setting_video_quality()
        self.camera.set_camera_setting_video_quality(self.video.cfg.get("resolution"),self.video.cfg.get("camera_type"))
        self.camera.press_back()
        self.camera.press_back()
        self.camera.camera_video_capture_pause(self.video.cfg.get("click_times"))
        print "case " + str(case_name) + " is pass"

    def videoEncodeLongLasting(self, case_name):
        """
        This test used to test video encode then playback
        The test case spec is following:
        1. Launch camera
        2. record video
        """
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.camera.enter_camera_from_home()
        self.camera.switch_module_in_camera()
        self.camera.change_front_back_camera(self.camera.cfg.get("camera_type"))
        self.camera.click_camera_menu_setting_vert()
        self.camera.enter_camera_setting_video_quality()
        self.camera.set_camera_setting_video_quality(self.camera.cfg.get("resolution"),self.camera.cfg.get("camera_type"))
        self.camera.press_back()
        self.camera.press_back()
        start_time = time.time()
        record_time = int(self.camera.cfg.get("record_time"))
        while record_time > 0:
            record_time = record_time - (time.time() - start_time)
            total, used, free = self.multimedia_setting.get_sdcard_memory()
            if free < (total/30):
                g_common_obj.adb_cmd_capture_msg(" rm -rf /sdcard/DCIM/Camera/*")
                g_common_obj.adb_cmd_capture_msg(self.camera.cfg.get("refresh_sd"))
            self.camera.capture_video_camera_initial_page(record_time)
            print "case " + str(case_name) + " is pass"
 
    def videoEncodeIteration(self, case_name):
        """
        This test used to test video encode then playback
        The test case spec is following:
        1. Launch camera
        2. record video
        3. playback
        """
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_camera_helper = MultiMediaCameraHelper()
        self.multimedia_camera_helper.camera.startCameraApp()
        self.multimedia_camera_helper.camera.selectMode("Video")
        camera_type = self.changeCameraTypeStr(self.video.cfg.get("camera_type"))
        if "bxtp" in self.multimedia_setting.get_paltform_hardware():
            logger.debug("For BXT, do not switch Rear/Front")
        else:
            self.multimedia_camera_helper.camera.switchRearOrFront(camera_type)
        resolution = self.multimedia_camera_helper.changeResolution(self.camera.cfg.get("resolution"))
        self.multimedia_camera_helper.camera.setVideoResolution(resolution, camera_type)
        record_times = int(self.camera.cfg.get("record_times"))
        record_time = int(self.camera.cfg.get("record_time"))
        for index in range(record_times):
            print "record_times is ", index
            total, used, free = self.multimedia_setting.get_sdcard_memory()
            if free < (total/30):
                g_common_obj.adb_cmd_capture_msg(" rm -rf /sdcard/DCIM/Camera/*")
                g_common_obj.adb_cmd_capture_msg(self.camera.cfg.get("refresh_sd"))
                break
            self.multimedia_camera_helper.camera.recordVideo(1, record_time)
        print "case " + str(case_name) + " is pass"

    def videoEncodeTillFull(self, case_name):
        """
        This test used to test video encode then playback
        The test case spec is following:
        1. Launch camera
        2. record video till memory full
        3. playback
        """
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_camera_helper = MultiMediaCameraHelper()
        self.multimedia_camera_helper.camera.startCameraApp()
        self.multimedia_camera_helper.camera.selectMode("Video")
        camera_type = self.changeCameraTypeStr(self.video.cfg.get("camera_type"))
        if "bxtp" in self.multimedia_setting.get_paltform_hardware():
            logger.debug("For BXT, do not switch Rear/Front")
        else:
            self.multimedia_camera_helper.camera.switchRearOrFront(camera_type)
        resolution = self.multimedia_camera_helper.changeResolution(self.camera.cfg.get("resolution"))
        self.multimedia_camera_helper.camera.setVideoResolution(resolution, camera_type)
        self.multimedia_camera_helper.camera.clickRecordBtn()
        time.sleep(5)
        record_time= int(self.video.cfg.get("lasting_time"))
        startTime=time.time()
        while True:
            if time.time() - startTime < record_time:
                if not self.multimedia_camera_helper.camera.isRecordTimeExists():
                    break
            else:
                self.multimedia_camera_helper.camera.clickRecordBtn()
                break
            time.sleep(10)
        time.sleep(5)
        self.multimedia_camera_helper.camera.reviewPhotoAndVideo()
        print "case " + str(case_name) + " is pass"

    def launchFFmpeg(self):
        SystemUI().unlock_screen()
        for _ in range(3):
            g_common_obj.launch_app_am("com.silentlexx.ffmpeggui", ".Gui")
            time.sleep(2)
            if self.d(textContains="Allow FFmpeg Media Encoder to access photo").exists:
                self.d(resourceId="com.android.packageinstaller:id/permission_allow_button").click()
            if self.d(text="FFmpeg Media Encoder").exists:
                return
        assert self.d(text="FFmpeg Media Encoder").exists, "launch FFmpeg app failed!"

    def encodevideo(self, in_file_path='', e_resolution='1080x720', e_type='3gp' ):
        input_file= self.d(resourceId='com.silentlexx.ffmpeggui:id/in_file')
        if input_file.exists and (in_file_path != input_file.text):
            input_file.click()
            while input_file.text != '':

                g_common_obj.adb_cmd_common("shell input keyevent DEL")
            g_common_obj.adb_cmd_common("shell input text %s" % in_file_path)

        output_type = self.d(resourceId='com.silentlexx.ffmpeggui:id/sp_ext').child(resourceId='android:id/text1')
        output_type.click()
        try:
            self.d(scrollable=True).scroll.to(text=e_type).click()
        except:
            self.d(text=e_type).click()

        encode_type = self.d(resourceId='com.silentlexx.ffmpeggui:id/preset').child(resourceId='android:id/text1')
        encode_type.click()
        try:
            self.d(scrollable=True).scroll.to(text="Video 3gp (h263/aac/qcif)").click()
        except:
            self.d(text='Video 3gp (h263/aac/qcif)').click()

        enable_setres = self.d(resourceId='com.silentlexx.ffmpeggui:id/setres')
        input_x = self.d(resourceId='com.silentlexx.ffmpeggui:id/rx')
        input_y = self.d(resourceId='com.silentlexx.ffmpeggui:id/ry')
        if input_x.exists and not input_file.click():
            enable_setres.click()

        iter_x = 5
        iter_y = 5
        if input_x.text !=  e_resolution.split('x')[0]:
            while input_x.text != '' and iter_x > 0:

                g_common_obj.adb_cmd_common("shell input keyevent DEL")
                iter_y -= 1
            input_x.click()
            g_common_obj.adb_cmd_common("shell input text %s" % e_resolution.split('x')[0])

        if input_y.text !=  e_resolution.split('y')[0]:
            while input_y.text != '' and iter_y > 0:
                g_common_obj.adb_cmd_common("shell input keyevent DEL")
                iter_y -= 1
            input_y.click()
            g_common_obj.adb_cmd_common("shell input text %s" % e_resolution.split('x')[1])

        self.d(resourceId='com.silentlexx.ffmpeggui:id/run').click()

    def recordingWithWithFFmpeg(self, casename=''):
        self.appPrepare(casename)
        self.launchFFmpeg()
        self.encodevideo(self.video.cfg.get("push_video").split('"')[-2], self.video.cfg.get("resolution"), \
                         self.video.cfg.get("encode_type"))

    def launchFFmpegCLI(self):
        SystemUI().unlock_screen()
        for _ in range(3):
            g_common_obj.launch_app_am("org.magiclen.ffmpeg.cli", ".activities.CommandActivity")
            time.sleep(2)
            if self.d(textContains="Allow FFmpeg CLI to access").exists:
                self.d(resourceId="com.android.packageinstaller:id/permission_allow_button").click()
            if self.d(text="FFmpeg CLI").exists:
                logger.debug(self.tag + "launch FFmpeg CLI app success!")
                return
        assert self.d(text="FFmpeg CLI").exists, "launch FFmpeg CLI app failed!"

    def encodevideoViaFFmpegCLI(self, encode_cmd=''):
        logger.debug(self.tag + "start to encode video via FFmpeg CLI APP!")
        encode_cmd_box= self.d(resourceId='org.magiclen.ffmpeg.cli:id/etCLI')
        if encode_cmd_box.exists :
            encode_cmd_box.click()
            if ("Input FFmpeg's parameters here." != encode_cmd_box.text):
                while encode_cmd_box.text != '':
                    g_common_obj.adb_cmd_common("shell input keyevent DEL")
            g_common_obj.adb_cmd_common("shell input text %s" % encode_cmd)

        try:
            self.d(resourceId='org.magiclen.ffmpeg.cli:id/bCLI').click()
        except Exception as e:
            logger.error(self.tag + "Click Run button failed ,Excetpion:%s" % e)

        out_screen = self.d(resourceId='org.magiclen.ffmpeg.cli:id/tvScreen')
        for _ in range(15):
            time.sleep(3)
            if "Qavg: 0.00" in out_screen.text:
                logger.debug(self.tag + "encode done")
                return True
        return False

    def checkEncodeVideo(self, play_file='', check_hang=True):
        if g_common_obj.adb_cmd_common("shell getprop ro.hardware") in ['gordon_peak']:
            assert self.multimedia_handle.playVideoviaOGallery(play_file), 'launch encode video failed'
            if check_hang:
                return self.multimedia_handle.checkVideoPlayHang()
            else:
                return True
        else:
            self.multimedia_handle.launchVideoApp()
            self.multimedia_handle.videoPlayBack(play_file)
            return self.multimedia_handle.checkVideoPlayBack()

    def recordingWithWithFFmpegCLI(self, casename=''):
        self.appPrepare(casename)
        self.launchFFmpegCLI()
        assert self.encodevideoViaFFmpegCLI(self.video.cfg.get("encode_cmd")), 'encode video failed'
        assert self.checkEncodeVideo(self.video.cfg.get("output_file")), "check encode video failed"


    def recordingWithWith4KEncode(self, casename=''):
        self.appPrepare(casename)
        self.launch4KEncode()
        self.encodevideoVia4KEncode(Encode_type=self.video.cfg.get("encode_type"))
        assert self.checkEncodeVideo(self.video.cfg.get("output_file"),check_hang=False), "check encode video failed"

    def launch4KEncode(self):
        """
        A method to launch testEncodeAndMux_4K_Encode.apk
        :return: True, launch success.
        """
        SystemUI().unlock_screen()
        for _ in range(3):
            g_common_obj.launch_app_am("com.intel.mchen33.testencodeandmux", ".MainActivity")
            time.sleep(1)
            if self.d(text="testEncodeAndMux").exists:
                logger.debug(self.tag + "launch testEncodeAndMux_4K_Encode app success!")
                return True
        assert self.d(text="testEncodeAndMux").exists, "launch testEncodeAndMux_4K_Encode app failed!"

    def encodevideoVia4KEncode(self,Encode_type='GO VP8 3840x2160 30fps'):
        """
        A method to encode via testEncodeAndMux_4K_Encode.apk
        :return: True, Encode finished.
        """
        if Encode_type=='VP8':
            if self.d(text='GO H.264 3840x2160 30fps').exists:
                logger.debug(self.tag + "try to encode GO H.264 3840x2160 30fps" )
                self.d(text='GO VP8 3840x2160 30fps').click()
        else:
            if self.d(text='GO H.264 3840x2160 30fps').exists:
                logger.debug(self.tag + "try to encode GO H.264 3840x2160 30fps " )
                self.d(text='GO VP8 3840x2160 30fps').click()

        for _ in range(40):
            time.sleep(1)
            if not self.d(text="testEncodeAndMux").exists:
                logger.debug(self.tag + "launch testEncodeAndMux_4K_Encode app success!")
                return True
        return False

    def testVideoEncode_Longlasting_FrontCamera_480p_30mins(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_001
        """
        self.videoEncodeSettingResolutionThenPlayback('mum_test_video_encode_playback_001')

    def testVideoEncode_Longlasting_RearCamera_480p_30mins(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_002
        """
        self.videoEncodeSettingResolutionThenPlayback('mum_test_video_encode_playback_002')

    def testVideoEncode_Longlasting_RearCamera_720p_1280x720_30mins(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_003
        """
        self.videoEncodeSettingResolutionThenPlayback('mum_test_video_encode_playback_003')

    def testVideoEncode_Longlasting_RearCamera_1080p_1920x1080_30mins(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_004
        """
        self.videoEncodeSettingResolutionThenPlayback('mum_test_video_encode_playback_004')

    def test_video_encode_playback_mum_005(self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        """
        self.videoEncodeLongLasting('mum_test_video_encode_playback_005')

    def testVideoEncode_Longlasting_FrontCamera_480p_60mins(self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_006
        """
        self.videoEncodeSettingResolutionThenPlayback('mum_test_video_encode_playback_006')

    def test_video_encode_playback_mum_007(self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        """
        self.videoEncodeCapturePauseMultipleTimes('mum_test_video_encode_playback_007')

    def testVideoEncode_Longlasting_RearCamera_720p_PlaybackCheck(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_008
        """
        self.videoEncodeSettingResolutionThenPlayback('mum_test_video_encode_playback_008')

    def test_video_encode_playback_mum_009(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        """
        self.videoEncodeSettingResolutionThenPlayback('mum_test_video_encode_playback_009')

    def test_video_encode_playback_mum_010(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        """
        self.videoEncodeSettingResolutionThenPlayback('mum_test_video_encode_playback_010')

    def testVideoEncode_Longlasting_RearCamera_720p_PlaybackInParallel(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_011
        """
        self.videoEncodeSettingResolutionThenPlayback('mum_test_video_encode_playback_011')

    def testVideoEncode_Longlasting_RearCamera_720p_30mins(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_012
        """
        self.videoEncodeSettingResolutionThenPlayback('mum_test_video_encode_playback_012')

    def test_video_encode_playback_mum_013(self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        """
        self.videoEncodeCapturePauseMultipleTimes('mum_test_video_encode_playback_013')

    def test_video_encode_playback_mum_014(self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        """
        self.videoEncodeIteration('mum_test_video_encode_playback_014')

    def test_video_encode_playback_mum_015(self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        """
        self.videoEncodeTillFull('mum_test_video_encode_playback_015')

    def testVideoEncode_Longlasting_FrontCamera_480p_Storagefull_PlaybackCheck(self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_016
        """
        self.videoEncodeTillFull('mum_test_video_encode_playback_016')

    def testVideoEncode_Longlasting_RearCamera_720p_Storagefull_PlaybackCheck(self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_017
        """
        self.videoEncodeTillFull('mum_test_video_encode_playback_017')

    def testVideoEncode_Longlasting_RearCamera_480p_Storagefull_PlaybackCheck(self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_018
        """
        self.videoEncodeTillFull('mum_test_video_encode_playback_018')

    def testVideoEncode_Iteration_FrontCamera_RecordStartStop_AudibleTones(self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_019
        """
        self.videoEncodeIteration('mum_test_video_encode_playback_019')

    def testVideoEncode_Longlasting_RearCamera_1080p_10mins_PlaybackCheck(self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_020
        """
        self.videoEncodeSettingResolutionThenPlayback('mum_test_video_encode_playback_020')

    def testVideoEncode_Longlasting_FrontCamera_480p_10mins_PlaybackCheck(self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_021
        """
        self.videoEncodeSettingResolutionThenPlayback('mum_test_video_encode_playback_021')

    def testAudible_tones_are_heard_video_record_start_and_stop_default_settings_rear_camera(self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        1. Former name: test_API_video_playback_060
        """
        self.videoEncodeThenPlayback('test_API_video_playback_060')

    def testSimultaneous_encode_2way_video_H264(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch recording app
        3. Recording
        """
        self.recordingWithVPGTool("test_API_video_playback_085")

    def testSimultaneous_encode_2way_video_H263(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch recording app
        3. Recording
        """
        self.recordingWithVPGTool("test_API_video_playback_097")

    def testSimultaneous_encode_2way_video_VP8(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch recording app
        3. Recording
        """
        self.recordingWithVPGTool("test_API_video_playback_098")

    def testVideo_Encode_H264_1920x1080_30fps_mp4(self):
        """
            This test used to encode with videoRectest app
            The test case spec is following:
            1. Launch recording app
            3. Recording
        """
        self.recordingWithVideoRectest("test_API_video_playback_133")

    def testVideo_Encode_H264_320x240_30fps_mp4(self):
        """
            This test used to encode with videoRectest app
            The test case spec is following:
            1. Launch recording app
            3. Recording
        """
        self.recordingWithVideoRectest("test_API_video_playback_134")

    def testVideo_Encode_H264_352x288_30fps_mp4(self):
        """
            This test used to encode with videoRectest app
            The test case spec is following:
            1. Launch recording app
            3. Recording
        """
        self.recordingWithVideoRectest("test_API_video_playback_135")

    def testVideo_Encode_H264_1280x720_30fps_mp4(self):
        """
            This test used to encode with videoRectest app
            The test case spec is following:
            1. Launch recording app
            3. Recording
        """
        self.recordingWithVideoRectest("test_API_video_playback_136")

    def testVideo_Encode_H264_720x480_30fps_3gp(self):
        """
            This test used to encode with videoRectest app
            The test case spec is following:
            1. Launch recording app
            3. Recording
        """
        self.recordingWithVideoRectest("test_API_video_playback_137")

    def testVideo_Rec_Encode_VP8_1920x1080_30fps_webm(self):
        """
            This test used to encode with videoRectest app
            The test case spec is following:
            1. Launch recording app
            3. Recording
        """
        self.recordingWithVideoRectest("test_API_video_playback_138")

    def testVideo_Rec_Encode_VP8_720x480_30fps_webm(self):
        """
            This test used to encode with videoRectest app
            The test case spec is following:
            1. Launch recording app
            3. Recording
        """
        self.recordingWithVideoRectest("test_API_video_playback_139")

    def testEncode_H264_3gp(self):
        """
            This test used to encode with videoRectest app
            The test case spec is following:
            1. Launch recording app
            3. Recording
        """
        self.recordingWithVideoRectest("mum_test_video_encode_playback_025")

    def testVideo_Encode_H263_128x96_30fps_3gp(self):
        """
            This test used to encode with FFmpeg CLI app
            The test case spec is following:
            1. Launch recording app
            3. Recording
        """
        self.recordingWithWithFFmpegCLI("mum_test_video_encode_playback_022")

    def testVideo_Encode_H263_352x288_30fps_3gp(self):
        """
            This test used to encode with FFmpeg CLI app
            The test case spec is following:
            1. Launch recording app
            3. Recording
        """
        self.recordingWithWithFFmpegCLI("mum_test_video_encode_playback_023")

    def testVideo_Encode_H263_176x144_30fps_3gp(self):
        """
            This test used to encode with FFmpeg CLI app
            The test case spec is following:
            1. Launch recording app
            3. Recording
        """
        self.recordingWithWithFFmpegCLI("mum_test_video_encode_playback_024")

    def testVP8_HW_4K_Encode(self):
        """
            This test used to encode with 4k Encode app
            The test case spec is following:
            1. Launch recording app
            3. Recording
        """
        self.recordingWithWith4KEncode("mum_test_video_encode_playback_026")
Example #4
0
class ImageAPITest(TestCaseBase):
    """
    @summary: Test Video PlayBack
    """
    def setUp(self):
        """
        @summary: set up
        @return: None
        """
        super(ImageAPITest, self).setUp()
        self.d = g_common_obj.get_device()
        self._test_name = __name__
        self.x = self.d.info["displayWidth"]
        self.y = self.d.info["displayHeight"]
        self.dpx = self.d.info["displaySizeDpX"]
        self.dpy = self.d.info["displaySizeDpY"]
        self.tag = "[Image Decode image_api_test] "
        self.serial = self.d.server.adb.device_serial()
        logger.debug(self.tag + "[Setup]: %s" % self._test_name)
        g_common_obj.stop_app_am("com.intel.otc.instrument.otcphotos")
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def tearDown(self):
        """
        @summary: tear tearDown
        @return: None
        """
        super(ImageAPITest, self).tearDown()
        print "[Teardown]: %s" % self._test_name
        g_common_obj.stop_exp_handle()
        time.sleep(3)
        g_common_obj.stop_app_am("com.intel.otc.instrument.otcphotos")
        time.sleep(1)
        g_common_obj.adb_cmd_capture_msg(self.video.cfg.get("remove_video"))

    def setTimeToSec(self, time):
        time = time.split(":")
        i = 1
        temp = 0
        for s in time[::-1]:
            temp += int(s) * i
            i *= 60
        return int(temp)

    def getOrientation(self):
        d = self.get_device()
        width = d.info["displayWidth"]
        height = d.info["displayHeight"]
        if width > height:
            return 1
        else:
            return 0

    def appPrepare(self, case_name, model=1):
        cfg_file = os.path.join(os.environ.get('TEST_DATA_ROOT', ''), \
            'tests.tablet.mum_auto_image.conf')
        self.video = PhotosImpl(\
            self.config.read(cfg_file, case_name))

        self.multimedia_handle = MultiMediaHandle()
        self.multimedia_setting = MultiMediaSetting(cfg_file)
        self.multimedia_setting.install_apk("photo_apk")
        self.multimedia_setting.install_apk("alarm_apk")
        self.video.set_orientation_n()
        if self.video.cfg.get("push_picture") is not None:
            self.multimedia_setting.push_file(
                self.video.cfg.get("push_picture"),
                self.video.cfg.get("datapath"))
        refresh_sd_cmd = self.config.read(cfg_file, 'common_cmd')['refresh_sd']
        g_common_obj.adb_cmd_capture_msg(refresh_sd_cmd)
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def launchPhotoAPP(self):
        logger.debug(self.tag + "launch otcphotos app")
        SystemUI().unlock_screen()
        for _ in range(3):
            g_common_obj.launch_app_am("com.intel.otc.instrument.otcphotos", \
                                   "com.intel.otc.instrument.otcphotos.MainActivity")
            time.sleep(3)
            if self.d(textContains="/").exists:
                return
        assert self.d(textContains="/").exists, "launch photo app failed!"

    def checkPhotosBackupAndHandle(self):
        """
        check 'back up & sync' exist and handle it
        :return:
        """
        for _ in range(3):
            if self.d(textContains="Update Google Photos").exists:
                logger.debug("Ignore update google photos")
                self.d(textMatches="NOT NOW").click()
            time.sleep(1)
            if self.d(resourceId=
                      'com.android.packageinstaller:id/permission_allow_button'
                      ).exists:
                self.d(
                    resourceId=
                    'com.android.packageinstaller:id/permission_allow_button'
                ).click()
                time.sleep(1)
            if self.d(textContains='Google Photos uses face').exists and \
                    self.d(textMatches='[O|o][N|n]').exists:
                logger.debug("back up & sync display, try to init photos")
                x = self.d.info['displayHeight'] / 2
                y = self.d.info['displayWidth'] / 2
                self.d.click(x, y)
            if self.d(textContains="Keep backup off").exists:
                self.d(textMatches="Keep off|KEEP OFF").click()
            if self.d(textStartsWith="Never show").exists:
                self.d(textStartsWith="Never show").click()
            if self.d(textMatches="SKIP|Skip").exists:
                self.d(textMatches="SKIP|Skip").click()
            if self.d(textMatches="CANCEL|Cancel").exists:
                self.d(textMatches="CANCEL|Cancel").click()
            if self.d(description="Photos, selected, tab, 2 of 3").exists or\
                                self.d(resourceId="com.google.android.apps.photos:id/toolbar").exists:
                logger.debug("init completed")
                break

    def launchPhotoAPPWithShortCut(self):
        logger.debug(self.tag + "Launch Photos")
        self.d.press.home()
        if self.get_android_version() == "7.1.1":
            logger.debug("DUT android version is 7.1.1")
            self.d(description="Apps list").click()
        elif self.get_android_version() < "7.1.1":
            logger.debug("DUT android version is beloww 7.1.1")
            if self.d(text="GOT IT").exists:
                self.d(text="GOT IT").click()
            self.d(description="Apps").click()
        elif self.multimedia_setting.get_paltform_hardware() == 'androidia_64':
            logger.debug("For AIA, Photos in Google folder")
            self.d(description="Folder: Google").click()
            self.d(description="Photos").click()
            self.checkPhotosBackupAndHandle()
            assert self.d(
                resourceId="com.google.android.apps.photos:id/toolbar"
            ).exists, "launch photo app failed!"
            return True
        #for N build,firstly go into apps list,skip the tips
        for _ in range(3):
            if self.d(textContains="Choose some apps").exists:
                self.d(text="OK").click()
        assert not self.d(text="OK").exists, "skip the tips failed!"
        while not self.d(text="otcphoto-app").exists:
            self.d(className="android.view.View").swipe.left()
        self.d(text="otcphoto-app").click()
        time.sleep(3)
        assert self.d(textContains="/").exists, "launch photo app failed!"

    def launchGalleryAPPWithShortCut(self):
        # for bxtp o car, launch Gallery
        self.d.press.home()
        app_list_cmd = "adb -s %s shell input tap '%d' '%d'" % (
            self.serial, int(self.dpx * 0.78), int(self.dpy * 0.97))
        print app_list_cmd
        for _ in range(3):
            os.system(app_list_cmd)
            if self.d(resourceId=
                      "com.android.support.car.lenspicker:id/dismiss_area"
                      ).wait.exists(timeout=3000):
                try:
                    self.d(resourceId=
                           "com.android.support.car.lenspicker:id/dismiss_area"
                           ).scroll.vert.to(text='Gallery')
                except:
                    self.d.swipe(self.x / 2, self.y * 0.75, self.x / 2,
                                 self.y * 0.25)
                self.d(text="Gallery").click()
                if self.d(resourceId="com.android.gallery3d:id/gl_root_view"
                          ).wait.exists(timeout=3000):
                    logger.debug("Launch Gallery success!")
                    return True
        logger.debug("Launch Gallery Failed!")
        return False

    def get_android_version(self):

        prop = "ro.build.version.release"
        buf = g_common_obj.adb_cmd_capture_msg("getprop " + prop)
        v_str = buf.strip()
        return v_str

    def wait_boot_completed(self, timeout=1000):
        ''' wait Android boot_completed
    
        args: timeout -- optional timeout in second, default 180s
        '''
        count = 0
        sleep_time = 5
        while count < timeout:
            prop_val = adb.adb_cmd_capture_msg('getprop sys.boot_completed')
            if '1' in prop_val:
                print 'boot_completed'
                return
            count += sleep_time
            time.sleep(sleep_time)
        raise Exception('%ds timeout waiting for boot_completed' % timeout)

    def enterPhotoPath(self, path):
        logger.debug(self.tag + "enter picture path :" + path)
        push_str = path.strip("\"").split("/")
        if push_str[0] == "" and push_str[1] == "sdcard":
            push_str = push_str[2:]
        for t_str in push_str:
            logger.debug(self.tag + "try to click %s" % t_str)
            if t_str != "":
                self.d(text=t_str).click()
                time.sleep(2)

    def checkPictureExist(self, file_name):
        logger.debug(self.tag + "check picture exist, filename:" + file_name)
        if self.d(text=file_name).exists:
            logger.debug(self.tag + file_name + " found!")
            return True
        else:
            logger.debug(self.tag + file_name + " not find!")
            return False

    def openPictureWithGallery(self, file):
        print file
        open_picture_cmd = "shell am start -a android.intent.action.VIEW -d file://%s " \
                   " -t image/* -n com.android.gallery3d/.app.GalleryActivity" % (file)
        for _ in range(3):
            g_common_obj.adb_cmd_common(open_picture_cmd)
            time.sleep(1)
            if self.d(resourceId=
                      "com.android.gallery3d:id/photopage_bottom_controls"):
                return True
        logger.debug(self.tag + "open %s failed" % file)
        return False

    def openPictureWithPhotosCmd(self, file):
        logger.debug("Try to open %s with command" % file)
        open_picture_cmd = "shell am start -a android.intent.action.VIEW -d file://%s " \
                           " -t image/* -n com.google.android.apps.photos/.pager.HostPhotoPagerActivity" % (file)
        for _ in range(3):
            g_common_obj.adb_cmd_common(open_picture_cmd)
            time.sleep(1)
            if self.d(
                    resourceId=
                    "com.google.android.apps.photos:id/video_player_controller_fragment_container"
            ):
                logger.debug(self.tag + 'Open picture success.')
                return True
        logger.debug(self.tag + "open %s failed" % file)
        return False

    def getPictureSize(self):
        scaleLabel = self.d(
            resourceId="com.intel.otc.instrument.otcphotos:id/scaleLabel"
        ).info["text"]
        return int(scaleLabel.strip("%"))

    def checkVideoPlayBack(self, s=60):
        return self.multimedia_handle.checkVideoPlayBack(s)

    def imageViewRotatePicture(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        self.checkPictureExist(os.path.split(path)[1])
        self.d.orientation = "n"
        time.sleep(2)
        self.checkPictureExist(os.path.split(path)[1])
        self.video.set_orientation_n()
        time.sleep(2)
        self.checkPictureExist(os.path.split(path)[1])
        print "case " + str(case_name) + " is pass"

    def imageViewRotatePictureManyTimes(self, case_name, count):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        self.checkPictureExist(os.path.split(path)[1])
        for _ in range(count):
            self.d.orientation = "n"
            time.sleep(2)
            self.checkPictureExist(os.path.split(path)[1])
            self.video.set_orientation_n()
            time.sleep(2)
            self.checkPictureExist(os.path.split(path)[1])
        print "case " + str(case_name) + " is pass"

    def imageViewCheck(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        self.checkPictureExist(os.path.split(path)[1])
        print "case " + str(case_name) + " is pass"

    def imageViewCheckAfterDeleteFile(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        file_name = os.path.split(path)[1]
        self.checkPictureExist(file_name)
        self.multimedia_setting.clearFolder(self.video.cfg.get("remove_video"))
        time.sleep(2)
        self.d.press.back()
        self.d(text=file_name).click()
        assert not self.d(
            resourceId='com.intel.otc.instrument.otcphotos:id/sizeLabel'
        ).exists, "no warning messsage pop up"
        for _ in range(3):
            self.d.press.back()
        print "case " + str(case_name) + " is pass"

    def imageViewCheckWithUnlock(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        self.checkPictureExist(os.path.split(path)[1])
        if 'bxtp_abl' in self.multimedia_setting.get_paltform_hardware():
            #  For BXT use relay card press power to sleep
            self.multimedia_setting.pressPowerKey()
            time.sleep(10)
            self.multimedia_setting.pressPowerKey()
        else:
            self.d.press.power()
            time.sleep(2)
            self.d.press.power()
        self.lock = SystemUI()
        self.lock.unlock_screen()
        time.sleep(1)
        self.checkPictureExist(os.path.split(path)[1])
        print "case " + str(case_name) + " is pass"

    def imageViewCheckWithRotation(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        self.launchPhotoAPP()
        self.d.orientation = "n"
        self.d.press.home()
        self.multimedia_setting.click_recent_app("otcphoto-app")
        time.sleep(1)
        assert self.d(textContains="/").exists, "launch photo app failed!"
        self.multimedia_setting.launchAlarmAPP()
        self.video.set_orientation_n()
        self.multimedia_setting.click_recent_app("otcphoto-app")
        time.sleep(1)
        assert self.d(textContains="/").exists, "launch photo app failed!"
        self.enterPhotoPath(path)
        self.checkPictureExist(os.path.split(path)[1])
        print "case " + str(case_name) + " is pass"

    def imageViewCheckWithInstallApp(self, case_name, flag=1):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        if flag != 1:
            self.multimedia_setting.push_file(
                self.video.cfg.get("push_picture_2"),
                self.video.cfg.get("datapath"))
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        self.multimedia_setting.install_apk("video_apk")
        self.checkPictureExist(os.path.split(path)[1])
        if flag != 1:
            self.d(className="android.widget.ImageView").swipe.left()
            path_2 = self.video.cfg.get("push_picture_2").split(" ")[-1].strip(
                "\"")
            self.checkPictureExist(os.path.split(path_2)[1])
        self.push_path = self.multimedia_setting.push_file(
            self.video.cfg.get("push_video_2"),
            self.video.cfg.get("datapath_2"))
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.multimedia_handle.videoPlayBack(self.push_path)
        self.multimedia_setting.install_apk("vpg_apk")
        self.checkVideoPlayBack(30)
        adb.adb_cmd_common(
            'uninstall videoplayer.app.instrument.otc.intel.com.otcvideoplayer'
        )
        adb.adb_cmd_common('uninstall com.intel.vpg.tool')
        print "case " + str(case_name) + " is pass"

    def imageViewCheckWithShortCut(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        if "androidia_64" in self.multimedia_setting.get_paltform_hardware():
            self.launchPhotoAPPWithShortCut()
            assert self.openPictureWithPhotosCmd(path), "Picture not exists!"
        elif self.multimedia_setting.get_android_version() == "O":
            self.launchGalleryAPPWithShortCut()
            assert self.openPictureWithGallery(path), "Picture not exists!"
        else:
            self.launchPhotoAPPWithShortCut()
            self.enterPhotoPath(path)
            assert self.checkPictureExist(
                os.path.split(path)[1]), "Picture not exists!"
        print "case " + str(case_name) + " is pass"

    def imageViewCheckFolder(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        path_2 = self.video.cfg.get("push_picture_2").split(" ")[-1].strip(
            "\"")
        print path, path_2
        self.multimedia_setting.push_file(self.video.cfg.get("push_picture_2"),
                                          self.video.cfg.get("datapath"))
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        file_name = os.path.split(path)[1]
        file_name_2 = os.path.split(path_2)[1]
        self.checkPictureExist(file_name)
        self.d.press.back()
        self.checkPictureExist(file_name)
        self.checkPictureExist(file_name_2)
        print "case " + str(case_name) + " is pass"

    def imageViewCheckSlideShow(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        path_2 = self.video.cfg.get("push_picture_2").split(" ")[-1].strip(
            "\"")
        print path, path_2
        self.multimedia_setting.push_file(self.video.cfg.get("push_picture_2"),
                                          self.video.cfg.get("datapath"))
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        file_name = os.path.split(path)[1]
        file_name_2 = os.path.split(path_2)[1]
        self.checkPictureExist(file_name)
        self.d(className="android.widget.ImageView").swipe.left()
        self.checkPictureExist(file_name_2)
        print "case " + str(case_name) + " is pass"

    def imageViewTenTimes(self, case_name, t_time=10):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        file_name = os.path.split(path)[1]
        self.checkPictureExist(file_name)
        for _ in range(10):
            self.d.press.back()
            self.d(text=file_name).click()
            self.checkPictureExist(file_name)
        print "case " + str(case_name) + " is pass"

    def getCpuConsumption(self):
        cmd = "shell top -m 1 -n 1"
        t_pattern = re.compile("User (.*)%, System (.*)%, IOW.*")
        result = g_common_obj.adb_cmd_common(cmd)
        print result
        if t_pattern.findall(result) != []:
            (t_user, t_system) = t_pattern.findall(result)[0]
            return int(t_user) + int(t_system)
        else:
            return 0

    def imageViewWithManyTimes(self, case_name, times):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        cpu_1 = self.getCpuConsumption()
        for iteration in range(times):
            logger.debug("Execute {0} times, total {1} times".format(
                iteration + 1, times))
            self.launchPhotoAPP()
            time.sleep(5)
            g_common_obj.stop_app_am("com.intel.otc.instrument.otcphotos")
            time.sleep(4)
        time.sleep(10)
        cpu_2 = self.getCpuConsumption()
        logger.info("cpu_1={0}, cpu_2={1}".format(cpu_1, cpu_2))
        assert cpu_1 + 10 >= cpu_2, "Cpu Consumption error! cpu_1=%s, cpu_2=%s" % (
            cpu_1, cpu_2)
        print "case " + str(case_name) + " is pass"

    def imageViewBackHome(self, case_name, flag=1):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        if flag != 1:
            self.multimedia_setting.push_file(
                self.video.cfg.get("push_picture_2"),
                self.video.cfg.get("datapath"))
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        self.checkPictureExist(os.path.split(path)[1])
        self.d.press.home()
        self.multimedia_setting.click_recent_app("otcphoto-app")
        time.sleep(1)
        self.checkPictureExist(os.path.split(path)[1])
        if flag != 1:
            self.d(className="android.widget.ImageView").swipe.left()
            path_2 = self.video.cfg.get("push_picture_2").split(" ")[-1].strip(
                "\"")
            self.checkPictureExist(os.path.split(path_2)[1])
        print "case " + str(case_name) + " is pass"

    def imageViewWithAlarm(self, case_name, flag=1):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        if flag != 1:
            self.multimedia_setting.push_file(
                self.video.cfg.get("push_picture_2"),
                self.video.cfg.get("datapath"))
        self.multimedia_setting.launchAlarmAPP()
        self.multimedia_setting.setAlarmTime(30)
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        self.checkPictureExist(os.path.split(path)[1])
        self.multimedia_setting.waitAlarmTriiggered(50, "Snooze")
        self.multimedia_setting.setAlarmTime(30)
        self.multimedia_setting.click_recent_app("otcphoto-app")
        time.sleep(1)
        self.checkPictureExist(os.path.split(path)[1])
        self.multimedia_setting.waitAlarmTriiggered(50, "Dismiss")
        self.multimedia_setting.click_recent_app("otcphoto-app")
        time.sleep(1)
        self.checkPictureExist(os.path.split(path)[1])
        if flag != 1:
            self.d(className="android.widget.ImageView").swipe.left()
            path_2 = self.video.cfg.get("push_picture_2").split(" ")[-1].strip(
                "\"")
            self.checkPictureExist(os.path.split(path_2)[1])
        print "case " + str(case_name) + " is pass"

    def imageViewWithReboot(self, case_name, flag=1):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        logger.debug(self.tag + "path:" + path)
        if flag != 1:
            self.multimedia_setting.push_file(
                self.video.cfg.get("push_picture_2"),
                self.video.cfg.get("datapath"))
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        self.checkPictureExist(os.path.split(path)[1])
        adb.reboot_device()
        self.wait_boot_completed()
        time.sleep(20)
        if self.d(textContains="Drive safely").exists:
            logger.debug(self.tag + "Drive saftely exist , click owner")
            self.d(text="Owner").click()
            time.sleep(3)
        self.lock = SystemUI()
        self.lock.unlock_screen()
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        self.checkPictureExist(os.path.split(path)[1])
        if flag != 1:
            self.d(className="android.widget.ImageView").swipe.left()
            path_2 = self.video.cfg.get("push_picture_2").split(" ")[-1].strip(
                "\"")
            self.checkPictureExist(os.path.split(path_2)[1])
        print "case " + str(case_name) + " is pass"

    def imageViewWithInvalidFile(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        logger.debug(self.tag + "test file patch:%s" % path)
        self.launchPhotoAPP()
        self.enterPhotoPath(os.path.split(path)[0])
        assert not self.d(text=os.path.split(path)[1]).exists, os.path.split(
            path)[1] + "Invalid file can be find! error!"
        print "case " + str(case_name) + " is pass"

    def imageViewZoomIn_ZoomOut(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        self.checkPictureExist(os.path.split(path)[1])
        self.d(className="android.widget.ImageView").gesture(
            (self.x / 2, self.y / 2 - 20), (self.x / 2, self.y / 2)).to(
                (self.x / 2, self.y / 4), (self.x / 2, self.y * 3 / 4))
        self.checkPictureExist(os.path.split(path)[1])
        x1 = self.getPictureSize()
        assert x1 > 100, "ZoomIn error"
        time.sleep(2)
        self.d(className="android.widget.ImageView").gesture(
            (self.x / 2, self.y / 4), (self.x / 2, self.y * 3 / 4)).to(
                (self.x / 2, self.y / 2 - 20), (self.x / 2, self.y / 2))
        self.checkPictureExist(os.path.split(path)[1])
        x2 = self.getPictureSize()
        assert x1 > x2, "ZoomOut error"
        print "case " + str(case_name) + " is pass"

    def testImage_View_RotatePicture(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        2. Rotate picture to landscape mode
        3. Rotate picture to Portrait mode
        """
        self.imageViewRotatePicture("test_API_image_001")

    def testMultiMedia_Gallery_SlideShow_Continue_Idle(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        2. Press home
        """
        self.imageViewBackHome("test_API_image_002", 2)

    def testMultiMedia_Gallery3D_GIF_87a_ZoomIn_ZoomOut(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        2. Press home
        """
        self.imageViewZoomIn_ZoomOut("test_API_image_004")

    def testMultiMedia_Gallery3D_GIF_89a_ZoomIn_ZoomOut(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        2. Press home
        """
        self.imageViewZoomIn_ZoomOut("test_API_image_005")

    def testImage_ViewMode_Full_And_non_FullScreen_Switch(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewTenTimes("test_API_image_006", 10)

    def testMultiMedia_Gallery3D_SlideShow_AlarmReminder(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewWithAlarm("test_API_image_007", 2)

    def testImage_View_InvalidFile(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewWithInvalidFile("test_API_image_008")

    def testMultiMedia_Gallery_Format_UnSupportPicture(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewWithInvalidFile("test_API_image_009")

    def testMultiMedia_Gallery_SlideShow_Then_PowerOff_ON(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewWithReboot("test_API_image_010", 2)

    def testMultiMedia_Gallery_Format_ErrorPicture(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewWithInvalidFile("test_API_image_011")

    def testMultiMedia_Gallery3D_SlideShow_Multiple_Events(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewWithAlarm("test_API_image_012", 2)

    def testMultiMedia_MediaFramework_Display_Picture(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewWithInvalidFile("test_API_image_013")

    def testMultiMedia_Gallery3D_ViewImage_Larger_Than_5_or_8_MB(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheck("test_API_image_014")

    def test_Calendar_Alarm_EmailNote_When_SlideShow(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewWithAlarm("test_API_image_015", 2)

    def testMultiMedia_Gallery3D_Launch_Exit_30_Times(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewWithManyTimes("test_API_image_016", 30)

    def testMultiMedia_Gallery_Launch_Exit_100_Times(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewWithManyTimes("test_API_image_017", 100)

    def testImage_Number_Indicator(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckFolder("test_API_image_018")

    def testCalendar_Interact_When_View_Picture(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewWithAlarm("test_API_image_019")

    def testMultiMedia_Gallery_SlideShow_Long_Time(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckSlideShow("test_API_image_020")

    def testMultiMedia_Gallery_DifferentResolutions_3072x2304(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheck("test_API_image_021")

    def testMultiMedia_MediaFramework_Display_BigSize_Picture(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheck("test_API_image_022")

    def testMultiMedia_MediaFramework_Display_LittleSize_Picture(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheck("test_API_image_023")

    def testMultiMedia_Gallery_Enter_By_ShortCut(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckWithShortCut("test_API_image_024")

    def testJPEG_HW_Decode(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheck("test_API_image_025")

    def testMultiMedia_Gallery3D_Unsupported_Images_Videos(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewWithInvalidFile("test_API_image_026")

    def testMultiMedia_Gallery3D_Gesturing_Screen(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckSlideShow("test_API_image_027")

    def testMultiMedia_Gallery_Panning_Single(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        2. Press home
        """
        self.imageViewZoomIn_ZoomOut("test_API_image_028")

    def testApp_Install_When_View_Picture_Video_SlideShow(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckWithInstallApp("test_API_image_029", 2)

    def testMultiMedia_Gallery_Rotation_Background(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckWithRotation("test_API_image_030")

    def testMultiMedia_Gallery_Image_Review_SD_USB(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheck("test_API_image_031")

    def testImage_View_RotatePicture_ManyTimes(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewRotatePictureManyTimes("test_API_image_043", 20)

    def testVideo_NonExist(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckAfterDeleteFile("test_API_image_044")
Example #5
0
class VideoHeadsetTest(TestCaseBase):
    """
    @summary: Test Video PlayBack
    """

    def setUp(self):
        """
        @summary: set up
        @return: None
        """
        super(VideoHeadsetTest, self).setUp()
        self.d = g_common_obj.get_device()
        self._test_name = __name__
        print "[Setup]: %s" % self._test_name
        g_common_obj.stop_app_am("videoplayer.app.instrument.otc.intel.com.otcvideoplayer")
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")
        
        self.hs = Headset("/dev/ttyUSB0")
        self.hs.reset()

    def tearDown(self):
        """
        @summary: tear tearDown
        @return: None
        """
        super(VideoHeadsetTest, self).tearDown()
        print "[Teardown]: %s" % self._test_name
        g_common_obj.stop_exp_handle()
        time.sleep(3)
        g_common_obj.stop_app_am("videoplayer.app.instrument.otc.intel.com.otcvideoplayer")
        time.sleep(3)
        
        self.hs.reset()

    def appPrepare(self, case_name, model=1):
        self.cfg_file = os.path.join(os.environ.get('TEST_DATA_ROOT', ''), \
            'tests.tablet.mum_auto_video.conf')
        self.video = PhotosImpl(\
            self.config.read(self.cfg_file, case_name))
        g_common_obj.adb_cmd_capture_msg(" rm -rf /sdcard/DCIM/Camera/*")
        
        self.multimedia_handle = MultiMediaHandle()
        self.multimedia_setting = MultiMediaSetting(self.cfg_file)
        self.multimedia_setting.clearFolder(self.video.cfg.get("remove_video"))
        time.sleep(2)
        if model == 1:
            self.push_path = self.multimedia_setting.push_file(self.video.cfg.get("push_video"), self.video.cfg.get("datapath"))
            
        self.multimedia_setting.install_apk("video_apk")
        self.video.set_orientation_n()
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def videoPlayBack(self, push_path=""):
        if push_path == "":
            push_path = self.push_path
        return self.multimedia_handle.videoPlayBack(push_path)

    def checkVideoPlayBack(self, s=60):
        return self.multimedia_handle.checkVideoPlayBack(s)
    
    def checkVideoPlayBackWithComparePicture(self, stoptime, bigfileskiptime=0):
        return self.multimedia_handle.checkVideoPlayBackWithComparePicture(stoptime, bigfileskiptime)

    def checkVideoPlayBackWithHeadset(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        
        self.hs.plug_in()
        time.sleep(2)
        
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.videoPlayBack()
        self.checkVideoPlayBack()
        time.sleep(1)
        
        assert self.rpc.isStreamActive("music", 500), "music not active when headset plug in"
        print "case " + str(case_name) + " is pass"

    def testVideo_Playback_1080P_Check_Audio_HS(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        3. Check headset
        """
        self.checkVideoPlayBackWithHeadset("test_API_video_playback_with_headset_001")

    def testVideo_Playback_720P_Check_Audio_HS(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        3. Check headset
        """
        self.checkVideoPlayBackWithHeadset("test_API_video_playback_with_headset_002")
Example #6
0
class ImageAPITest(UIATestBase):
    """
    @summary: Test Video PlayBack
    """

    def setUp(self):
        """
        @summary: set up
        @return: None
        """
        super(ImageAPITest, self).setUp()
        self.d = g_common_obj.get_device()
        self._test_name = __name__
        self.x = self.d.info["displayWidth"]
        self.y = self.d.info["displayHeight"]
        print "[Setup]: %s" % self._test_name
        g_common_obj.stop_app_am("com.intel.otc.instrument.otcphotos")
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def tearDown(self):
        """
        @summary: tear tearDown
        @return: None
        """
        super(ImageAPITest, self).tearDown()
        print "[Teardown]: %s" % self._test_name
        g_common_obj.stop_exp_handle()
        time.sleep(3)
        g_common_obj.stop_app_am("com.intel.otc.instrument.otcphotos")
        time.sleep(1)
        g_common_obj.adb_cmd_capture_msg(self.video.cfg.get("remove_video"))

    def setTimeToSec(self, time):
        time = time.split(":")
        i = 1
        temp = 0
        for s in time[::-1]:
            temp += int(s) * i
            i *= 60
        return int(temp)

    def getOrientation(self):
        d = self.get_device()
        width = d.info["displayWidth"]
        height = d.info["displayHeight"]
        if width > height:
            return 1
        else:
            return 0

    def appPrepare(self, case_name, model=1):
        cfg_file = os.path.join(os.environ.get('TEST_DATA_ROOT', ''), \
            'tests.tablet.mum_auto_image.conf')
        self.video = PhotosImpl(\
            self.config.read(cfg_file, case_name))
        self.camera = CameraImpl(\
            self.config.read(cfg_file, case_name))
        
        self.multimedia_setting = MultiMediaSetting(cfg_file)
        self.multimedia_setting.install_apk("photo_apk")
        self.multimedia_setting.install_apk("alarm_apk")
        self.video.set_orientation_n()
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def launchPhotoAPP(self):
        SystemUI().unlock_screen()
        for _ in range(3):
            g_common_obj.launch_app_am("com.intel.otc.instrument.otcphotos", \
                                   "com.intel.otc.instrument.otcphotos.MainActivity")
            time.sleep(3)
            if self.d(textContains="/").exists:
                return
        assert self.d(textContains="/").exists, "launch photo app failed!"

    def launchPhotoAPPWithShortCut(self):
        self.d.press.home()
        self.d(description="Apps").click()
        for _ in range(3):
            if self.d(textContains="Choose some apps").exists:
                self.d(text="OK").click()
        assert not self.d(text="OK").exists, "skip the tips failed!"
        while not self.d(text="otcphoto-app").exists:
            self.d(className="android.view.View").swipe.left()
        self.d(text="otcphoto-app").click()
        time.sleep(3)
        assert self.d(textContains="/").exists, "launch photo app failed!"

    def wait_boot_completed(self, timeout=1000):
        ''' wait Android boot_completed
    
        args: timeout -- optional timeout in second, default 180s
        '''
        count = 0
        sleep_time = 5
        while count < timeout:
            prop_val = adb.adb_cmd_capture_msg('getprop sys.boot_completed')
            if '1' in prop_val:
                print 'boot_completed'
                return
            count += sleep_time
            time.sleep(sleep_time)
        raise Exception('%ds timeout waiting for boot_completed' % timeout)

    def enterPhotoPath(self, path):
        push_str = path.strip("\"").split("/")
        if push_str[0] == "" and push_str[1] == "sdcard":
            push_str = push_str[2:]
        print push_str
        for t_str in push_str:
            if t_str != "":
                self.d(text=t_str).click()
                time.sleep(2)

    def checkPictureExist(self, file_name):
        assert self.d(text=file_name).exists, file_name + " not find!"

    def getPictureSize(self):
        scaleLabel = self.d(resourceId="com.intel.otc.instrument.otcphotos:id/scaleLabel").info["text"]
        return int(scaleLabel.strip("%"))

    def imageViewCheckWithWallpaper(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        self.multimedia_setting.push_file(self.video.cfg.get("push_picture"), self.video.cfg.get("datapath"))
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        file_name = os.path.split(path)[1]
        self.checkPictureExist(file_name)
        self.d.press.back()
        self.d(text=file_name).long_click()
        self.d(text="Wallpaper").click()
        time.sleep(5)
        assert self.d(text="WallPaper is updated.").exists, "Set wallpaper failed!"
        print "case " + str(case_name) + " is pass"

    def imageViewCheckWithDelete(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        self.multimedia_setting.push_file(self.video.cfg.get("push_picture"), self.video.cfg.get("datapath"))
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        file_name = os.path.split(path)[1]
        self.checkPictureExist(file_name)
        g_common_obj.adb_cmd_capture_msg(self.video.cfg.get("remove_video"))
        self.d.press.home()
        self.launchPhotoAPP()
        self.enterPhotoPath(os.path.split(path)[0])
        assert not self.d(text=file_name).exists, "%s file exist!" % file_name
        print "case " + str(case_name) + " is pass"

    def imageViewCheckWithMonoryFull(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        g_common_obj.adb_cmd_capture_msg("rm -rf /storage/sdcard0/DCIM/Camera/*")
        self.camera.clean_up_camera_data()
        make_big_file.fill_no_space_except(int(self.camera.cfg.get("device_storage_limited")))
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        self.multimedia_setting.push_file(self.video.cfg.get("push_picture"), self.video.cfg.get("datapath"))
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        file_name = os.path.split(path)[1]
        self.checkPictureExist(file_name)
        g_common_obj.adb_cmd_capture_msg("rm -rf /mnt/sdcard/bigfile")
        print "case " + str(case_name) + " is pass"

    def imageViewCheckWithUnlock(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        self.multimedia_setting.push_file(self.video.cfg.get("push_picture"), self.video.cfg.get("datapath"))
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        self.checkPictureExist(os.path.split(path)[1])
        if 'bxtp_abl' in self.multimedia_setting.get_paltform_hardware():
            #  For BXT use relay card press power to sleep
            self.multimedia_setting.pressPowerKey()
            time.sleep(10)
            self.multimedia_setting.pressPowerKey()
        else:
            self.d.press.power()
            time.sleep(2)
            self.d.press.power()
        self.lock = SystemUI()
        self.lock.unlock_screen()
        time.sleep(1)
        self.checkPictureExist(os.path.split(path)[1])
        print "case " + str(case_name) + " is pass"

    def imageViewTenTimes(self, case_name, t_time=10):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        path = self.video.cfg.get("push_picture").split(" ")[-1].strip("\"")
        print path
        self.multimedia_setting.push_file(self.video.cfg.get("push_picture"), self.video.cfg.get("datapath"))
        self.launchPhotoAPP()
        self.enterPhotoPath(path)
        file_name = os.path.split(path)[1]
        self.checkPictureExist(file_name)
        for _ in range(10):
            self.d.press.back()
            self.d(text=file_name).click()
            self.checkPictureExist(file_name)
        print "case " + str(case_name) + " is pass"

    def testMultiMedia_Gallery_CropPicture_LockScreen(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckWithUnlock("test_API_image_032")

    def testMultiMedia_Gallery3D_Select_Unselected_Items_20_Times(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewTenTimes("test_API_image_033", 20)

    def testImage_View_Edit_GIF(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckWithWallpaper("test_API_image_034")

    def testImage_View_Edit_JPG(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckWithWallpaper("test_API_image_035")

    def testImage_View_Edit_BMP(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckWithWallpaper("test_API_image_036")

    def testImage_View_Edit_WBMP(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckWithWallpaper("test_API_image_037")

    def testImage_Edit_Save_With_Memory_Full(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckWithMonoryFull("test_API_image_039")

    def testImage_View_Edit_WEBP(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckWithWallpaper("test_API_image_040")

    def testImage_View_Edit_PNG(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckWithWallpaper("test_API_image_041")

    def test_Album_Delete(self):
        """
        This test used to test Image Decode
        The test case spec is following:
        1. Open a picture
        """
        self.imageViewCheckWithDelete("test_API_image_042")
Example #7
0
class VideoPlayBackLonglasting(TestCaseBase):
    """
    @summary: Test Video PlayBack
    """
    def setUp(self):
        """
        @summary: set up
        @return: None
        """
        super(VideoPlayBackLonglasting, self).setUp()
        self._test_name = __name__
        print "[Setup]: %s" % self._test_name
        g_common_obj.stop_app_am("com.google.android.apps.plus")
        g_common_obj.stop_app_am("com.google.android.apps.photos")
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def tearDown(self):
        """
        @summary: tear tearDown
        @return: None
        """
        super(VideoPlayBackLonglasting, self).tearDown()
        print "[Teardown]: %s" % self._test_name
        g_common_obj.stop_exp_handle()
        time.sleep(3)

    def appPrepare(self, case_name):
        cfg_file = os.path.join(os.environ.get('TEST_DATA_ROOT', ''), \
            'tests.tablet.mum_auto_video.conf')
        self.video = PhotosImpl(\
            self.config.read(cfg_file, case_name))
        self.setting = SettingImpl(\
            self.config.read(cfg_file, case_name))
        g_common_obj.adb_cmd_capture_msg(" rm -rf /sdcard/DCIM/Camera/*")

        self.multimedia_handle = MultiMediaHandle()
        self.multimedia_setting = MultiMediaSetting(cfg_file)
        self.check_photo_app = CheckPhotoApp(cfg_file)
        self.multimedia_setting.clearFolder(self.video.cfg.get("remove_video"))
        time.sleep(2)
        self.push_path = self.multimedia_setting.push_file(
            self.video.cfg.get("push_video"), self.video.cfg.get("datapath"))

        g_common_obj.adb_cmd_capture_msg(self.video.cfg.get("refresh_sd"))
        self.video.set_orientation_n()
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def videoPlayBackLonglasting(self, case_name, bigfileskiptime=0):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        lasting_time = int(self.video.cfg.get("lasting_time"))
        push_folder = os.path.split(os.path.split(self.push_path)[0])[-1]
        self.check_photo_app.check_photo_app()
        self.video.launchPhotos(push_folder)
        time.sleep(2)
        self.multimedia_handle.checkVideoPlayBackWithPhotoApp(
            lasting_time, bigfileskiptime)
        print "case " + str(case_name) + " is pass"

    def videoPlayBackLonglastingNoTime(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        lasting_time = int(self.video.cfg.get("lasting_time"))
        push_folder = os.path.split(os.path.split(self.push_path)[0])[-1]
        self.video.launchPhotos(push_folder)
        time.sleep(2)
        #         self.multimedia_handle.launchVideoApp()
        #         self.multimedia_handle.videoPlayBack(self.push_path)
        self.multimedia_handle.checkVideoPlayBackWithPhotoApp(
            stoptime=lasting_time)
        #         start_time = time.time()
        #         while lasting_time > 0:
        #             self.video.playback_video_un_QR_code_photoplus(playTime=self.video.cfg.get("wait_time"), stoptime=self.video.cfg.get("stop_time"), flag=True)
        #             playback_time = time.time() - start_time
        #             print "play back time is "
        #             lasting_time = lasting_time - playback_time
        #             print "lasting_time is ", lasting_time
        print "case " + str(case_name) + " is pass"

    def test_video_playback_long_lasting_mum_001(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('Verify that user can play 3D video file for 30 minutes')
        """
        self.videoPlayBackLonglastingNoTime(
            "mum_test_video_playback_long_lasting_001")

    def testVideoPlayback_Longlasting_MP4_H264_L4_0_MP_720x424_25fps_AAC(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('Playback of very long duration video files (2+ hours)')
        3. Former name: test_video_playback_long_lasting_mum_002
        """
        self.videoPlayBackLonglasting(
            "mum_test_video_playback_long_lasting_002", 20)

    def testVideoPlayback_Longlasting_WEBM_VP8_VGA_20fps_2Mbps_Vorbis_48KHz_128kbps(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('Long-time Video playback: VP8_VGA_20fps_2Mbps_Vorbis_48KHz_128kbps.webm (3 hours)')
        3. Former name: test_video_playback_long_lasting_mum_003
        """
        self.videoPlayBackLonglasting(
            "mum_test_video_playback_long_lasting_003", 20)

    def testVideoPlayback_Longlasting_MKV_H264_HP_L4_1_720P_25fps_1_9Mbps_NA(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('Long-time Video playback: H264_HP_L4.1_720P_25fps_1.9Mbps_na.mkv (5 hours)')
        3. Former name: test_video_playback_long_lasting_mum_004
        """
        self.videoPlayBackLonglasting(
            "mum_test_video_playback_long_lasting_004", 20)

    def testVideoPlayback_Longlasting_TS_H264_HP_L3_2_720P_60fps_4Mbps_NA(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('Long-time Video playback: H264_HP_L3.2_720P_60fps_4Mbps_na.ts (2 hours)')
        3. Former name: test_video_playback_long_lasting_mum_005
        """
        self.videoPlayBackLonglasting(
            "mum_test_video_playback_long_lasting_005", 20)

    def testVideoPlayback_Longlasting_MP4_H264_HP_L4_1_1080P_30fps_4_5Mbps_NA(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('Long-time Video playback: H264_HP_L4.1_1080P_30fps_4.5Mbps_na.mp4 (2 hours)')
        3. Former name: test_video_playback_long_lasting_mum_006
        """
        self.videoPlayBackLonglasting(
            "mum_test_video_playback_long_lasting_006", 20)
Example #8
0
    def testVOIPCall_PlaybackMusic(self):
        """
        Verify that music playback well during VOIP call
        1. Play a video
        2. Accept a VOIP call, Video playback paused.
        3. End VOIP call
        4. Start Music playback by GMS music
        5. Accept VOIP call, music should paused.
        6. End VOIP call, music can be resumed
        """
        from testlib.photos.mum_photos_impl import PhotosImpl
        VIDEO = self.config.getConfValue(file_src=self.CONFIG_FILE,
                                         section='media_contents',
                                         key="file_2")
        AUDIO = self.config.getConfValue(file_src=self.CONFIG_FILE,
                                         section='media_contents',
                                         key="file_1")
        DUT_PATH = "/sdcard/otctest/"
        DUT_FOLDER = "otctest"
        APP_ACTIVITY = ("com.google.android.apps.photos",
                        "com.google.android.apps.photos.home.HomeActivity")
        photos = PhotosImpl()
        try:
            self.download_push_content(self.d, VIDEO, DUT_PATH)
            self.download_push_content(self.d, AUDIO, DUT_PATH)
            #self.download_install_app(self.d, app)
            self.d.refresh_storage()
            #self.d.launch_app_am(*APP_ACTIVITY)
            photos.set_orientation_n()
            photos.launchPhotos(DUT_FOLDER)
            time.sleep(3)
            uia_d = self.d.get_device()
            # uia_d(className="android.widget.ImageView").click()
            # time.sleep(2)
            # for i in range(3):#Retry 3 times
            #     if uia_d(resourceId = "com.google.android.apps.photos:id/video_current_time").exists:
            #         break
            #     uia_d(resourceId = "com.google.android.apps.photos:id/photo_view").click.wait()
            #     time.sleep(.5)
            for _ in range(3):  # Try 3 times
                if uia_d(descriptionContains="Video").exists:
                    uia_d(descriptionContains="Video").click.wait()
                    time.sleep(2)
                    break
            self.d.skip_use_hints(
            )  # For skipping full screen operation hints.
            assert self.d.rpc.isStreamActive("music", 0), "Video not playing!"

            self.mt_call("voice")
            time.sleep(2)
            assert not self.d.rpc.isStreamActive(
                "music", 0), "Video still playing while in VOIP call"
            self.d.hangouts.end_call()
            time.sleep(3)
            assert uia_d.info.get("currentPackageName") == APP_ACTIVITY[0],\
                    "Back to video playback failed"

            playing = False
            for i in range(4):  #Retry 4 times
                time.sleep(1)
                if self.d.rpc.isStreamActive("music", 0):
                    playing = True
                    break
                elif uia_d(description='Play video').exists:
                    uia_d(description='Play video').click.wait()
                    continue
                else:
                    uia_d(
                        resourceId=
                        "com.google.android.apps.photos:id/photo_hashtag_fragment_container"
                    ).click.wait()
                    continue
            time.sleep(1)
            assert playing, "Resume Video playback failed"

            self.d.stop_app_am(APP_ACTIVITY[0])
            time.sleep(.5)
            self.d.gmusic.launch_music_am()
            self.d.gmusic.enterSongsPage()
            self.d.gmusic.playMusic(AUDIO.split(".")[0])
            self.d.gmusic.setRepeat(2)
            assert self.d.rpc.isStreamActive("music",
                                             0), "Audio playback failed"
            self.mt_call("voice")
            assert not self.d.rpc.isStreamActive(
                "music", 0), "Audio playback not paused while VOIP call"
            self.d.hangouts.end_call()
            time.sleep(1)
            assert self.d.rpc.isStreamActive(
                "music", 0), "Audio not resume after end VOIP call"

        finally:
            self.d.stop_app_am(APP_ACTIVITY[0])
            self.d.gmusic.cleanUpData()
Example #9
0
class VideoPlayBack(TestCaseBase):
    """
    @summary: Test Video PlayBack
    """
    def setUp(self):
        """
        @summary: set up
        @return: None
        """
        super(VideoPlayBack, self).setUp()
        self.d = g_common_obj.get_device()
        self._test_name = __name__
        print "[Setup]: %s" % self._test_name
        g_common_obj.stop_app_am("com.google.android.apps.plus")
        g_common_obj.stop_app_am("com.google.android.apps.photos")
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def tearDown(self):
        """
        @summary: tear tearDown
        @return: None
        """
        super(VideoPlayBack, self).tearDown()
        print "[Teardown]: %s" % self._test_name
        g_common_obj.stop_exp_handle()
        time.sleep(3)

    def appPrepare(self, case_name):
        cfg_file = os.path.join(os.environ.get('TEST_DATA_ROOT', ''), \
            'tests.tablet.mum_auto_video.conf')
        self.video = PhotosImpl(\
            self.config.read(cfg_file, case_name))
        self.file_name = self.video.cfg.get("push_video").split(
            "/")[-1].replace("\"", "")
        self.push_path = self.video.cfg.get("push_video").split(
            "\" \"")[1].replace("\"", "")

        self.multimedia_handle = MultiMediaHandle()
        self.multimedia_setting = MultiMediaSetting(cfg_file)
        self.multimedia_setting.clearFolder(self.video.cfg.get("remove_video"))
        time.sleep(2)
        self.multimedia_setting.push_file(self.video.cfg.get("push_video"),
                                          self.video.cfg.get("datapath"))
        self.video.set_orientation_n()
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg(self.video.cfg.get("refresh_sd"))
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def appPrepare2(self, case_name, model=1):
        cfg_file = os.path.join(os.environ.get('TEST_DATA_ROOT', ''), \
            'tests.tablet.mum_auto_video.conf')
        self.video = PhotosImpl(\
            self.config.read(cfg_file, case_name))

        self.multimedia_handle = MultiMediaHandle()
        self.multimedia_setting = MultiMediaSetting(cfg_file)
        self.multimedia_setting.clearFolder(self.video.cfg.get("remove_video"))
        time.sleep(2)
        if model == 1:
            self.push_path = self.multimedia_setting.push_file(
                self.video.cfg.get("push_video"),
                self.video.cfg.get("datapath"))

        self.multimedia_setting.install_apk("video_apk")
        self.multimedia_setting.install_apk("alarm_apk")
        self.video.set_orientation_n()
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg(self.video.cfg.get("refresh_sd"))
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def videoPlayBack(self, case_name, t_bigfileskiptime=0):
        print "run case is " + str(case_name)
        self.appPrepare2(case_name)
        push_folder = os.path.split(os.path.split(self.push_path)[0])[-1]
        if self.multimedia_setting.get_android_version() == "O":
            self.multimedia_handle.launchVideoApp()
            self.multimedia_handle.videoPlayBack(self.push_path)
            assert self.multimedia_handle.checkVideoPlayBack(
            ), 'video play failed'
        else:
            self.video.launchPhotos(push_folder)
            time.sleep(2)
            self.multimedia_handle.checkVideoPlayBackWithPhotoApp(
                stoptime=self.video.cfg.get("stop_time"),
                bigfileskiptime=t_bigfileskiptime)
        print "case " + str(case_name) + " is pass"

    def testVideoPlayBack(self, case_name):
        MultiMediaBasicTestCase().testVideoPlayBack(case_name)

    def checkVideoPlayBack(self, s=60):
        return self.multimedia_handle.checkVideoPlayBack(s)

    def checkVideoPlayBackWithComparePicture(self,
                                             stoptime,
                                             bigfileskiptime=0):
        return self.multimedia_handle.checkVideoPlayBackWithComparePicture(
            stoptime, bigfileskiptime)

    def checkVideoPlayBackComplete(self, s=900):
        tt = -1
        for _ in range(s / 10):
            time.sleep(10)
            if self.d(textContains="Completed").exists:
                return
            else:
                try:
                    if tt == -1:
                        for _ in range(10):
                            if self.d(resourceId="android:id/time").exists:
                                break
                            self.d.click(self.x / 2, self.y / 2)
                        tt = self.d(resourceId="android:id/time").text
                        tt = self.setTimeToSec(tt)
                    for _ in range(10):
                        if self.d(resourceId="android:id/time_current").exists:
                            break
                        self.d.click(self.x / 2, self.y / 2)
                    ct = self.d(resourceId="android:id/time_current").text
                    ct = self.setTimeToSec(ct)
                except Exception as e:
                    if self.d(textContains="Completed").exists:
                        return
                    else:
                        assert False, e
                if ct == tt:
                    assert not self.d(
                        textContains="error").exists or not self.d(
                            textContains="fail"
                        ).exists, "Play back error! please check it."
                    return

    def setTimeToSec(self, time):
        time = time.split(":")
        i = 1
        temp = 0
        for s in time[::-1]:
            temp += int(s) * i
            i *= 60
        return int(temp)

    def videoPlayBackNoTime(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare2(case_name)
        push_folder = os.path.split(os.path.split(self.push_path)[0])[-1]
        self.video.launchPhotos(push_folder)
        time.sleep(2)
        #         self.multimedia_handle.launchVideoApp()
        #         self.multimedia_handle.videoPlayBack(self.push_path)
        self.multimedia_handle.checkVideoPlayBackWithPhotoApp(
            stoptime=self.video.cfg.get("stop_time"))
        #         self.video.playback_video_un_QR_code_photoplus(playTime=self.video.cfg.get("wait_time"), stoptime=self.video.cfg.get("stop_time"), flag=True)
        print "case " + str(case_name) + " is pass"

    def testVideoPlayback_3GP_H263_720x450_30fps_no_audio(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video('H263 Decoder, H263_720x450_30fps_no_audio')
        3. Former name: testVideoPlayBack_001
        """
        self.videoPlayBack("test_video_playback_001")

    def testVideoPlayback_3GP_H264_128_94_25fps_145kbps_AAC_LC_22_05kHz_48kbps_Stereo(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_002
        """
        self.videoPlayBack("test_video_playback_002")

    def testVideoPlayback_MP4_H264_176_144_12_5fps_627kbps_ALAC_44_1kHz_352kbps_Stereo(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_003
        """
        self.videoPlayBack("test_video_playback_003")

    def testVideoPlayBack_004(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_004")

    def testVideoPlayBack_005(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_005")

    def testVideoPlayBack_006(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_006")

    def testVideoPlayBack_007(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_007")

    def testVideoPlayBack_008(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_008")

    def testVideoPlayback_MP4_H264_320_240_25fps_3566kbps_AAC_Main_48kHz_165kbps_Stereo(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_009
        """
        self.videoPlayBack("test_video_playback_009")

    def testVideoPlayBack_010(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_010")

    def testVideoPlayBack_011(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_011")

    def testVideoPlayBack_012(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_012")

    def testVideoPlayback_MP4_H264_800_600_30fps_1641kbps_AAC_LC_Stereo_44_1kHz_152kbps_Stereo(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_013
        """
        self.videoPlayBack("test_video_playback_013")

    def testVideoPlayback_MP4_L1_0_SP_QCIF_15fps_AACplus_112kbp_32KHz(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_014
        """
        self.videoPlayBack("test_video_playback_014")

    def testVideoPlayback_MP4_L2_0_SP_QVGA_15fps_eAACplus_96kbp_48KHz(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_015
        """
        self.videoPlayBack("test_video_playback_015")

    def testVideoPlayBack_016(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_016")

    def testVideoPlayback_3GP_MPEG4_SP_480P_30fps_AAC_ELD_48KHz_192kbps(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_017
        """
        self.videoPlayBack("test_video_playback_017")

    def testVideoPlayback_3GP_MPEG4_SP_720x480_30fps_AMR_NB_8KHz_12_2kbps(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_018
        """
        self.videoPlayBack("test_video_playback_018")

    def testVideoPlayback_MP4_MPEG4_SP_L1_1080_30fps_AACplus_160kbps_48KHz(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_019
        """
        self.videoPlayBack("test_video_playback_019")

    def testVideoPlayBack_020(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_020")

    def testVideoPlayback_MP4_H264_L1_3_HP_CIF_30fps_eAACplus_128kb_44KHz(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_021
        """
        self.videoPlayBack("test_video_playback_021")

    def testVideoPlayback_MP4_H264_L3_1_BP_720p_30fps_AAC_96kb_32KHz(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_022
        """
        self.videoPlayBack("test_video_playback_022")

    def testVideoPlayback_MP4_H264_852_480_30fps_7763kbps_ALAC_44_1kHz_352kbps_Stereo(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_023
        """
        self.videoPlayBack("test_video_playback_023", 20)

    def testVideoPlayBack_024(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_024")

    def testVideoPlayback_MP4_H264_L1_0_BP_QCIF_10fps_AAC_64kb_32KHz(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_025
        """
        self.videoPlayBack("test_video_playback_025")

    def testVideoPlayback_MP4_H264_L2_2_MP_VGA_15fps_AAC_112kb_48K(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_026
        """
        self.videoPlayBack("test_video_playback_026")

    def testVideoPlayback_MP4_H264_L3_0_HP_D1SD_30fps_eAACplus_128kb_48KHz(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_027
        """
        self.videoPlayBack("test_video_playback_027")

    def testVideoPlayBack_028(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_028")

    def testVideoPlayback_TS_H264_BP_720x576_25fps_AACplus_128kbps_22_05KHz(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_029
        """
        self.videoPlayBack("test_video_playback_029")

    def testVideoPlayback_TS_H264_HP_1280x960_51fps_AACplus_192kbps_44_1KHz(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_030
        """
        self.videoPlayBack("test_video_playback_030")

    def testVideoPlayback_TS_H264_HP_1408x1152_38fps_eAACplus_128kbps_48KHz(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_031
        """
        self.videoPlayBack("test_video_playback_031")

    def testVideoPlayback_3GP_H264_HP_L3_2_720P_60fps_AAC_LC_48KHz_320kbps(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_032
        """
        self.videoPlayBack("test_video_playback_032")

    def testVideoPlayback_MKV_VP8_30fps_852_480_AAC_LC_44_1kHz(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_033
        """
        self.videoPlayBack("test_video_playback_033")

    def testVideoPlayback_MKV_VP8_640x360_25fps_Vorbis_44KHz_128Kbps(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_034
        """
        self.videoPlayBack("test_video_playback_034")

    def testVideoPlayback_MP4_H264_1920x1080_30fps_24_7Mbps_AAC_352_8Kbps_44_1KHz(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_035
        """
        self.videoPlayBack("test_video_playback_035")

    def testVideoPlayBack_036(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_036")

    def testVideoPlayBack_037(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_037")

    def testVideoPlayBack_038(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_038")

    def testVideoPlayBack_039(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_039")

    def testVideoPlayback_MP4_MPEG4_800_600_30fps_2075kbps_AAC_LC_48kHz_165kbps_Stereo(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_040
        """
        self.videoPlayBack("test_video_playback_040")

    def testVideoPlayBack_041(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_041")

    def testVideoPlayback_WEBM_VP8_QCIF_25fps_Vorbis_44_1KHz_128kbps(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_042
        """
        self.videoPlayBack("test_video_playback_042")

    def testVideoPlayBack_043(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_043")

    def testVideoPlayBack_044(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_044")

    def testVideoPlayBack_045(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_045")

    def testVideoPlayback_WEBM_VP9_936Kbps_640x360_30fps_vorbis_224kbps_48khz_2channel(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_046
        """
        self.videoPlayBack("test_video_playback_046")

    def testVideoPlayback_MP4_H264_BP_1080P_24fps_25Mbps_AAC_ELD_48KHz_192kbps(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_047
        """
        self.videoPlayBack("test_video_playback_047")

    def testVideoPlayBack_048(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_048")

    def testVideoPlayBack_049(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_049")

    def testVideoPlayback_MP4_H264_L3_1_HP_720p_30fps_AAC_160kb_48KHz(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_050
        """
        self.videoPlayBack("test_video_playback_050")

    def testVideoPlayback_3GP_H263_Decoder_Level_30_CIF_352_288_30fps_384_Kbs(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_051
        """
        self.videoPlayBack("test_video_playback_051")

    def testVideoPlayback_3GP_H263_Level_40_0_None_352_288_30_0fps_2048kbps_aac_stereo_48khz_192kbps(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_052
        """
        self.videoPlayBack("test_video_playback_052")

    def testVideoPlayback_WEBM_VP8_CIF_25fps_Vorbis_44_1KHz_128kbps(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_053
        """
        self.videoPlayBack("test_video_playback_053")

    def testVideoPlayback_MP4_H264_L4_1_HP_720p_30fps_eAACplus_128kb_48KHz(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_054
        """
        self.videoPlayBack("test_video_playback_054")

    def testVideoPlayBack_055(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_055")

    def testVideoPlayBack_056(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_056")

    def testVideoPlayback_MP4_H264_Primary_Output_Video_Playback_Content_QVGA_15_fps(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        3. Former name: testVideoPlayBack_057
        """
        self.videoPlayBack("test_video_playback_057")

    def testVideoPlayBack_058(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_058")

    def testVideoPlayBack_059(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_059")

    def testVideoPlayBack_060(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_060")

    def testVideoPlayBack_061(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_061")

    def testVideoPlayBack_062(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_062")

    def testVideoPlayBack_063(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_063")

    def testVideoPlayBack_064(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_064")

    def testVideoPlayBack_065(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_065")

    def testVideoPlayBack_066(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_066")

    def testVideoPlayBack_067(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_067")

    def testVideoPlayBack_068(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_068")

    def testVideoPlayBack_069(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_069")

    def testVideoPlayBack_070(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_070")

    def testVideoPlayBack_071(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_071")

    def testVideoPlayBack_072(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_072")

    def testVideoPlayBack_073(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_073")

    def testVideoPlayBack_074(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_074")

    def testVideoPlayBack_075(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_075")

    def testVideoPlayBack_076(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_076")

    def testVideoPlayBack_077(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_077")

    def testVideoPlayBack_078(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_078")

    def testVideoPlayBack_079(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_079")

    def testVideoPlayBack_080(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_080")

    def testVideoPlayBack_081(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_081")

    def testVideoPlayBack_082(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_082")

    def testVideoPlayBack_083(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_083")

    def testVideoPlayBack_084(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_084")

    def testVideoPlayBack_085(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_085")

    def testVideoPlayBack_086(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_086")

    def testVideoPlayBack_087(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_087")

    def testVideoPlayBack_088(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_088")

    def testVideoPlayBack_089(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_089")

    def testVideoPlayBack_090(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_090")

    def testVideoPlayBack_091(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_091")

    def testVideoPlayBack_092(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_092")

    def testVideoPlayBack_093(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_093")

    def testVideoPlayBack_094(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_094")

    def testVideoPlayBack_095(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_095")

    def testVideoPlayBack_096(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_096")

    def testVideoPlayBack_097(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_097")

    def testVideoPlayBack_098(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_098")

    def testVideoPlayBack_099(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_099")

    def testVideoPlayBack_100(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_100")

    def testVideoPlayBack_101(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_101")

    def testVideoPlayBack_102(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_102")

    def testVideoPlayBack_103(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_103")

    def testVideoPlayBack_104(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_104")

    def testVideoPlayBack_105(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_105")

    def testVideoPlayBack_106(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_106")

    def testVideoPlayBack_107(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_107")

    def testVideoPlayBack_108(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_108")

    def testVideoPlayBack_109(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("test_video_playback_109")

    def testVideoPlayback_MKV_MPEG4_ASP_720P_30fps_4_5Mbps_AAC_128kbps_32KHz(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch photos
        2. Play video
        """
        self.videoPlayBack("mum_test_video_playback_047")

    def testMPEG4_352_288_24fps_144kbps_aaclc_22_05kHz_38kbps_Mono_3GP(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_008")

    def testMPEG4_part_2_SP_Simple_Profile_Level3_CIF_352x288_30fps_NO_audio(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_009")

    def testVideo_Playback_Mp3_Mkv(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_video_playback_110")

    def testVideo_Playback_HEAAC_V2_Mp4(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_video_playback_111")
Example #10
0
class VideoEncode(TestCaseBase):
    """
    @summary: Test Video encode
    """
    def setUp(self):
        """
        @summary: set up
        @return: None
        """
        super(VideoEncode, self).setUp()
        self._test_name = __name__
        print "[Setup]: %s" % self._test_name
        g_common_obj.stop_app_am("com.google.android.GoogleCamera")
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def tearDown(self):
        """
        @summary: tearDown
        @return: None
        """
        super(VideoEncode, self).tearDown()
        print "[Teardown]: %s" % self._test_name
        g_common_obj.stop_exp_handle()
        time.sleep(3)
        g_common_obj.stop_app_am("com.google.android.GoogleCamera")
        time.sleep(3)
        g_common_obj.adb_cmd_capture_msg(" rm -rf /sdcard/DCIM/Camera/*")
        time.sleep(10)
        g_common_obj.adb_cmd_capture_msg(self.video.cfg.get("refresh_sd"))

    def appPrepare(self, case_name):
        cfg_file = os.path.join(os.environ.get('TEST_DATA_ROOT', ''), \
            'tests.tablet.mum_auto_video.conf')
        self.video = PhotosImpl(\
            self.config.read(cfg_file, case_name))
        self.camera = CameraImpl(\
            self.config.read(cfg_file, case_name))
        self.multimedia_setting = MultiMediaSetting(cfg_file)
        g_common_obj.adb_cmd_capture_msg(" rm -rf /sdcard/DCIM/Camera/*")
        g_common_obj.adb_cmd_capture_msg(self.video.cfg.get("refresh_sd"))
        self.video.set_orientation_n()
        self.camera.clean_up_camera_data()

    def changeCameraTypeStr(self, camera_type):
        if "Back" in camera_type:
            return "Back"
        return "Front"

    def videoEncodeSettingResolutionThenPlayback(self, case_name):
        """
        This test used to test video encode then playback
        The test case spec is following:
        1. Launch camera
        2. set resolution
        3. record video
        4. playback
        """
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_camera_helper = MultiMediaCameraHelper()
        self.multimedia_camera_helper.camera.startCameraApp()
        self.multimedia_camera_helper.camera.selectMode("Video")
        camera_type = self.changeCameraTypeStr(
            self.video.cfg.get("camera_type"))
        if "bxtp" in self.multimedia_setting.get_paltform_hardware():
            logger.debug("For BXT, do not switch Rear/Front")
        else:
            self.multimedia_camera_helper.camera.switchRearOrFront(camera_type)
        resolution = self.multimedia_camera_helper.changeResolution(
            self.camera.cfg.get("resolution"))
        self.multimedia_camera_helper.camera.setVideoResolution(
            resolution, camera_type)
        self.multimedia_camera_helper.camera.recordVideo(
            1, int(self.video.cfg.get("record_time")))
        self.multimedia_camera_helper.camera.reviewPhotoAndVideo()
        print "case " + str(case_name) + " is pass"

    def testVideoEncode_Longlasting_RearCamera_480p_30mins(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_002
        """
        self.videoEncodeSettingResolutionThenPlayback(
            'mum_test_video_encode_playback_002')

    def testVideoEncode_Longlasting_RearCamera_720p_1280x720_30mins(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_003
        """
        self.videoEncodeSettingResolutionThenPlayback(
            'mum_test_video_encode_playback_003')

    def testVideoEncode_Longlasting_RearCamera_1080p_1920x1080_30mins(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_004
        """
        self.videoEncodeSettingResolutionThenPlayback(
            'mum_test_video_encode_playback_004')

    def testVideoEncode_Longlasting_RearCamera_720p_PlaybackCheck(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_008
        """
        self.videoEncodeSettingResolutionThenPlayback(
            'mum_test_video_encode_playback_008')

    def test_video_encode_playback_mum_009(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        """
        self.videoEncodeSettingResolutionThenPlayback(
            'mum_test_video_encode_playback_009')

    def test_video_encode_playback_mum_010(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        """
        self.videoEncodeSettingResolutionThenPlayback(
            'mum_test_video_encode_playback_010')

    def testVideoEncode_Longlasting_RearCamera_720p_PlaybackInParallel(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_011
        """
        self.videoEncodeSettingResolutionThenPlayback(
            'mum_test_video_encode_playback_011')

    def testVideoEncode_Longlasting_RearCamera_720p_30mins(self):
        """
        This test used to test video record and playback
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_012
        """
        self.videoEncodeSettingResolutionThenPlayback(
            'mum_test_video_encode_playback_012')

    def testVideoEncode_Longlasting_RearCamera_1080p_10mins_PlaybackCheck(
            self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_020
        """
        self.videoEncodeSettingResolutionThenPlayback(
            'mum_test_video_encode_playback_020')

    def testVideoEncode_Longlasting_FrontCamera_480p_10mins_PlaybackCheck(
            self):
        """
        This test used to test video record long lasting
        The test case spec is following:
        1. Former name: test_video_encode_playback_mum_021
        """
        self.videoEncodeSettingResolutionThenPlayback(
            'mum_test_video_encode_playback_021')
Example #11
0
class VideoAPITest(TestCaseBase):
    """
    @summary: Test Video PlayBack
    """
    def setUp(self):
        """
        @summary: set up
        @return: None
        """
        super(VideoAPITest, self).setUp()
        self.d = g_common_obj.get_device()
        self._test_name = __name__
        self.x = self.d.info["displayWidth"]
        self.y = self.d.info["displayHeight"]
        print "[Setup]: %s" % self._test_name
        g_common_obj.stop_app_am(
            "videoplayer.app.instrument.otc.intel.com.otcvideoplayer")
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")
        self.cfg_file = os.path.join(os.environ.get('TEST_DATA_ROOT', ''), \
                                'tests.tablet.mum_auto_video.conf')

        self.multimedia_setting = MultiMediaSetting(self.cfg_file)
        self.hardware = self.multimedia_setting.get_paltform_hardware()
        self.tag = "[Decode API] "

    def tearDown(self):
        """
        @summary: tear tearDown
        @return: None
        """
        super(VideoAPITest, self).tearDown()
        print "[Teardown]: %s" % self._test_name
        g_common_obj.stop_exp_handle()
        time.sleep(3)
        g_common_obj.stop_app_am(
            "videoplayer.app.instrument.otc.intel.com.otcvideoplayer")
        time.sleep(3)

    def appPrepare(self, case_name, model=1):
        # cfg_file = os.path.join(os.environ.get('TEST_DATA_ROOT', ''), \
        #     'tests.tablet.mum_auto_video.conf')
        self.video = PhotosImpl(\
            self.config.read(self.cfg_file, case_name))
        g_common_obj.adb_cmd_capture_msg(" rm -rf /sdcard/DCIM/Camera/*")

        self.multimedia_handle = MultiMediaHandle()
        # self.multimedia_setting = MultiMediaSetting(cfg_file)
        self.multimedia_setting.clearFolder(self.video.cfg.get("remove_video"))
        time.sleep(2)
        if model == 1:
            self.push_path = self.multimedia_setting.push_file(
                self.video.cfg.get("push_video"),
                self.video.cfg.get("datapath"))

        self.multimedia_setting.install_apk("video_apk")
        self.multimedia_setting.install_apk("alarm_apk")

        self.video.set_orientation_n()
        # Unlock screen
        g_common_obj.adb_cmd_capture_msg("input keyevent 82")

    def setTimeToSec(self, time):
        time = time.split(":")
        i = 1
        temp = 0
        for s in time[::-1]:
            temp += int(s) * i
            i *= 60
        return int(temp)

    def setRotation(self, mode):
        self.d(className="android.widget.ImageButton").click()
        time.sleep(1)
        self.d(text=mode).click()
        time.sleep(1)

    def videoPlayBack(self, push_path=""):
        if push_path == "":
            push_path = self.push_path
        return self.multimedia_handle.videoPlayBack(push_path)

    def streamingVideoPlayBack(self, path="", flag=1):
        if path == "":
            path = self.video.cfg.get("video_path")
        return self.multimedia_handle.streamingVideoPlayBack(path, flag)

    def checkVideoPlayBack(self, s=30):
        return self.multimedia_handle.checkVideoPlayBack(s)

    def checkVideoPlayBackWithComparePicture(self,
                                             stoptime,
                                             bigfileskiptime=0):
        return self.multimedia_handle.checkVideoPlayBackWithComparePicture(
            stoptime, bigfileskiptime)

    def checkVideoPlayBackComplete(self, s=900):
        tt = -1
        for _ in range(s / 10):
            time.sleep(10)
            if self.d(textContains="Completed").exists:
                return
            else:
                try:
                    if tt == -1:
                        for _ in range(10):
                            if self.d(resourceId="android:id/time").exists:
                                break
                            self.d.click(self.x / 2, self.y / 2)
                        tt = self.d(resourceId="android:id/time").text
                        tt = self.setTimeToSec(tt)
                    for _ in range(10):
                        if self.d(resourceId="android:id/time_current").exists:
                            break
                        self.d.click(self.x / 2, self.y / 2)
                    ct = self.d(resourceId="android:id/time_current").text
                    ct = self.setTimeToSec(ct)
                except Exception as e:
                    if self.d(textContains="Completed").exists:
                        return
                    else:
                        assert False, e
                if ct == tt:
                    assert not self.d(
                        textContains="error").exists or not self.d(
                            textContains="fail"
                        ).exists, "Play back error! please check it."
                    return

    def checkVideoNotSupport(self, s=60):
        for _ in range(s):
            if self.d(text="Can't play this video.").exists:
                return
            assert not self.d(
                resourceId="android:id/time_current").exists and not self.d(
                    resourceId="android:id/time").exists, "error!can play it!"
            time.sleep(1)
            self.d.click(self.x / 2, self.y / 2)

    def testVideoPlayBack(self, case_name):
        assert MultiMediaBasicTestCase().testVideoPlayBack(
            case_name), 'video play failed'

    def testVideoPlayBackAudio(self, case_name):
        assert MultiMediaBasicTestCase().testVideoPlayBack(
            case_name, check_hang=False), 'video play failed'

    def testVideoPlayBackViaVLC(self, case_name, change_file_flag=False):
        MultiMediaBasicTestCase().testVideoPlayBackViaVLC(
            case_name, change_file_flag)

    def testVideoPlayBackViaGallery(self, case_name):
        MultiMediaBasicTestCase().testVideoPlayBackViaGallery(case_name)

    def testVideoPlayBackLongIteration(self, case_name):
        MultiMediaBasicTestCase().testVideoPlayBackLongIterationTimes(
            case_name)

    def testVideoPlayBackWithManyTimes(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_handle.launchVideoApp()
        assert self.checkVideoPlayBack(), 'video play failed'
        time.sleep(2)
        for _ in range(100):
            self.videoPlayBack()
            self.checkVideoPlayBack()
            self.d.press("back")
            time.sleep(2)
        print "case " + str(case_name) + " is pass"

    def testVideoPlayBackWithManyTimes_ASP_file(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        for _ in range(20):
            self.videoPlayBack()
            assert self.checkVideoPlayBack(), "video play failed"
            self.d.press("back")
            self.d.press("back")
            time.sleep(2)
            if not self.d(textContains="OtcVideoPlayer").exists:
                self.multimedia_handle.launchVideoApp()
        self.push_path = self.multimedia_setting.push_file(
            self.video.cfg.get("push_video_2"), self.video.cfg.get("datapath"))
        for _ in range(20):
            self.videoPlayBack()
            assert self.checkVideoPlayBack(), "video play failed"
            self.d.press("back")
            self.d.press("back")
            time.sleep(2)
            if not self.d(textContains="OtcVideoPlayer").exists:
                self.multimedia_handle.launchVideoApp()
        print "case " + str(case_name) + " is pass"

    def interuptionVideoPlayBackSwitchHome(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.videoPlayBack()
        self.checkVideoPlayBack()
        time.sleep(1)
        self.d.press.home()
        self.multimedia_setting.click_recent_app("OtcVideoPlayer")
        time.sleep(1)
        self.checkVideoPlayBack()
        print "case " + str(case_name) + " is pass"

    def testStreamingVideoPlayBack(self, case_name):
        MultiMediaBasicTestCase().testStreamingVideoPlayBack(case_name)

    def interuptionStreamingVideoPlayBackSwitchHome(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name, 2)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.streamingVideoPlayBack()
        assert self.checkVideoPlayBack(), "Video play failed"
        time.sleep(1)
        self.d.press.home()
        self.multimedia_setting.click_recent_app("OtcVideoPlayer")
        time.sleep(1)
        self.checkVideoPlayBack()
        print "case " + str(case_name) + " is pass"

    def videoPlayControlProcess(self, case_name):
        logger.debug(self.tag + 'run case name is ' +
                     sys._getframe().f_back.f_code.co_name)
        MultiMediaBasicTestCase().videoPlayControlProcess(case_name)

    def videoPlayVP8CodecProcess(self, case_name):
        logger.debug(self.tag + 'run case name is ' +
                     sys._getframe().f_back.f_code.co_name)
        MultiMediaBasicTestCase().videoPlayCodecProcess(case_name,
                                                        msg='OMX.*.vp8')

    def videoPlayControlProcess_complte_pasue(self, case_name):
        assert MultiMediaBasicTestCase(
        ).videoPlayControlProcess_Complete_pasue(case_name)

    def videoPlayControlProcessWithVolume(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.videoPlayBack()
        assert self.checkVideoPlayBack(), "video play failed"
        self.multimedia_setting.set_play_time(0.5)
        assert self.checkVideoPlayBack(), "video play failed"
        self.multimedia_handle.clickOtcVideoPlayer_Control(
            resourceId="android:id/rew")
        self.multimedia_handle.clickOtcVideoPlayer_Control(
            resourceId="android:id/ffwd")
        self.multimedia_setting.set_play_time_with_swipe(0.2)
        assert self.checkVideoPlayBack(), "video play failed"
        self.multimedia_handle.clickOtcVideoPlayer_Control(
            resourceId="android:id/pause")
        self.d.press.volume_up()
        self.checkVideoPlayBack()
        self.d.press.volume_down()
        assert self.checkVideoPlayBack(), "video play failed"
        print "case " + str(case_name) + " is pass"

    def videoDecodeSecondDisplay(self, case_name):
        logger.debug(self.tag + 'run case name is ' +
                     sys._getframe().f_back.f_code.co_name)
        self.appPrepare(case_name)
        g_common_obj.adb_cmd_capture_msg('am force-stop com.android.gallery3d')
        assert self.checkSecondDisplay(
        ), 'Cannot find the second display screen'
        assert self.playVideoSecondDisplay(
            self.push_path), 'cannot launch the video'
        g_common_obj.adb_cmd_capture_msg('am force-stop com.android.gallery3d')
        assert self.playVideoMainDisplay(
            self.push_path), 'cannot launch the video'
        logger.debug(self.tag + 'run case ' +
                     sys._getframe().f_back.f_code.co_name + ' is pass')

    def checkSecondDisplay(self):
        """
        check the DUT has two display screen
        :return: True, has two display screen
        """
        display2_out = g_common_obj.adb_cmd_capture_msg(
            "dumpsys |grep mExternalTouchViewport")
        if 'valid=false' in display2_out:
            logger.warning(self.tag +
                           "Cannot find the second display screen:%s" %
                           display2_out)
            return False
        else:
            logger.debug(self.tag + "The second display screen exits.")
            return True

    def playVideoSecondDisplay(self, file_path):
        """
        Play the video using the second display in Gallery
        :return: True, launch success
        """
        g_common_obj.adb_cmd_common("logcat -c")
        play_cmd = 'am start --display 1 -a android.intent.action.VIEW -d "file://%s" -t "video/*" -n com.android.gallery3d/.app.MovieActivity' % file_path
        g_common_obj.adb_cmd_capture_msg(play_cmd)
        time.sleep(5)
        gallery_play_act = 'com.android.gallery3d/com.android.gallery3d.app.MovieActivity'
        display1_surface = g_common_obj.adb_cmd_capture_msg(
            "dumpsys SurfaceFlinger|grep  -A10 'Display 0 HWC layers' ")
        display2_surface = g_common_obj.adb_cmd_capture_msg(
            "dumpsys SurfaceFlinger|grep  -A10 'Display 1 HWC layers' ")
        logger.debug(
            self.tag +
            "Video play failed, display1_surface:\n {0},\ndisplay2_surface:\n{1}"
            .format(display1_surface, display2_surface))
        if gallery_play_act not in display1_surface and gallery_play_act in display2_surface:
            logger.debug(self.tag + "Video play in the second display")
        else:
            logger.debug(self.tag + "Video play failed")
            return False
        # check video play
        return self.checkVideoInfoFromLogcat()

    def playVideoMainDisplay(self, file_path):
        """
        Play the video using the second display in Gallery
        :return: True, launch success
        """
        g_common_obj.adb_cmd_common("logcat -c")
        play_cmd = 'am start --display 0 -a android.intent.action.VIEW -d "file://%s" -t "video/*" -n com.android.gallery3d/.app.MovieActivity' % file_path
        g_common_obj.adb_cmd_capture_msg(play_cmd)
        time.sleep(6)
        gallery_play_act = 'com.android.gallery3d/com.android.gallery3d.app.MovieActivity'
        display1_surface = g_common_obj.adb_cmd_capture_msg(
            "dumpsys SurfaceFlinger|grep  -A10 'Display 0 HWC layers' ")
        display2_surface = g_common_obj.adb_cmd_capture_msg(
            "dumpsys SurfaceFlinger|grep  -A10 'Display 1 HWC layers' ")
        logger.debug(
            self.tag +
            "Video play failed, display1_surface:\n {0} \ndisplay2_surface:\n{1}"
            .format(display1_surface, display2_surface))
        if gallery_play_act in display1_surface and gallery_play_act in display2_surface:
            logger.debug(self.tag + "Video play in the main display")
        else:
            logger.debug(self.tag + "Video play failed")
            return False
        return self.checkVideoInfoFromLogcat()

    def checkVideoInfoFromLogcat(self):
        hardware_decode_msg = g_common_obj.adb_cmd_capture_msg(
            "logcat -d |grep 'I libva'")
        ur_decode_msg = g_common_obj.adb_cmd_capture_msg(
            "logcat -d |grep 'OMXMaster: makeComponentInstance'")
        logger.debug(
            self.tag +
            "Video play failed, hardware_decode_msg:\n {0},\nur_decode_msg:\n{1}"
            .format(hardware_decode_msg, ur_decode_msg))
        if not hardware_decode_msg and not ur_decode_msg:
            logger.debug(
                self.tag +
                "cannot find the libva or OMXMaster, video play abnormal")
            return False
        else:
            return True

    def testVideoNotSupport(self, case_name):
        print "run case is " + str(case_name)
        self.appPrepare(case_name, 2)
        self.multimedia_handle.launchVideoApp()
        time.sleep(2)
        self.streamingVideoPlayBack(flag=2)
        self.checkVideoNotSupport()
        print "case " + str(case_name) + " is pass"

    def testPlayback_VP8_640x480_20fps_Vorbis_48KHz_192Kbps_mkv_check_pause_resume_seek_rotate_sleep(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.videoPlayControlProcess("test_API_video_playback_033")

    def testPlayback_H264_MP_1080P_60fps_50Mbps_AAC_LC_48KHz_320Kbps_mp4_check_pause_resume_seek_rotate_sleep(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.videoPlayControlProcess("test_API_video_playback_034")

    def testPlayback_H264_HP_1080P_60fps_50Mbps_AAC_LC_48KHz_320Kbps_mp4_check_pause_resume_seek_rotate_sleep(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.videoPlayControlProcess("test_API_video_playback_035")

    def testPlayback_H264_BP_1080P_60fps_50Mbps_AAC_LC_48KHz_320Kbps_mp4_check_pause_resume_seek_rotate_sleep(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.videoPlayControlProcess("test_API_video_playback_036")

    def testh265_HEVC_With_10Bit_2160P_30Fps(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.videoPlayControlProcess_complte_pasue(
            "test_API_video_playback_128")

    def testh265_HEVC_With_10Bit_1080p_30Fps_8Mbps(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.videoPlayControlProcess_complte_pasue(
            "test_API_video_playback_129")

    def testh265_HEVC_With_10Bit_2160P_30Fps_60Mbps(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.videoPlayControlProcess_complte_pasue(
            "test_API_video_playback_130")

    def testCheck_SeparateCard_for_each_apps_with_multi_tasking(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Switch to Home, then back from Home
        """
        self.interuptionVideoPlayBackSwitchHome("test_API_video_playback_038")

    def testPlay_H263_MP4_container(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_043")

    def testSHALL_support_m4v_extension_MP4_video_file(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.videoPlayControlProcessWithVolume("test_API_video_playback_045")

    def testPlaying_streaming_Music_Home(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Switch to Home, then back from Home
        """
        self.interuptionStreamingVideoPlayBackSwitchHome(
            "test_API_video_playback_058")

    def testSupport_native_display_resolution_FWVGA_854x480_30fps(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_074")

    def testPlayback_H263_3GPv5_L1_0_BP_QCIF_15fps_AMR_WB_256kb_16KHz(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_075")

    def testPlayback_H264_Level1_0_Main_Profile_QCIF_176x144_10fps_AAC_Multimedia_96kb_48KHz(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_076")

    def testIterative_video_playback_H264_HP_1080P_60fps_50Mbps_AAC_LC_48KHz_320Kbps_mp4_iteratively(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBackLongIteration("test_API_video_playback_077")

    def testPlayback_H264_Level4_0_Main_Profile_HD_1920x1080_30fps_AAC_Multimedia_128kb_48KHz_and_pause_resume(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_078")

    def testH263_352_288_30fps_858kbps_No_Audio_mp4(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_079")

    def testH263_Level20_Sub_QCIF_30fps_128_KbS(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_080")

    def testPlay_H263_20F_QQVGA_AMRNB_12_2k(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_131")

    def testPlayback_VP8_CIF_25fps_Vorbis_44_1KHz_128kbps_webm_iteratively(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBackLongIteration("test_API_video_playback_081")

    def testVideo_H264_29_970fps_5mn29s_640x480_MP4_RTP_streaming(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testStreamingVideoPlayBack("test_API_video_playback_088")

    def testPlayback_MP4_h264_HiP_4_0_1080p_30FPS_25Mbps_AAC_LC_48KHz_256Kbps_1Min_179MB_BBB_mp4(
            self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.videoPlayControlProcessWithVolume("test_API_video_playback_101")

    def testPlayback_MPEG4_ASP_1080P_30fps_6Mbps_AAC_LC_48KHz_128Kbps(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_111")

    def testPlayback_MPEG4_ASP_Lv5_720X480_30fps_AAC_ST_160kbp_48KHZ(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_112")

    def testPlayback_MPEG4_SP_and_MEPG4_ASP_Continuously(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBackWithManyTimes_ASP_file(
            "test_API_video_playback_114")

    def testCorrupt_File_Playback(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoNotSupport("test_API_video_playback_115")

    def testPlayback_MPEG4_ASP_Lv0_176X144_30fps_AAC_Plus_ST_64kbp_32KHz(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_116")

    def testH264_480X320_Playback(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_118")

    def testH264_854x480_Playback(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_119")

    def testH265_480X320_Playback(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_120")

    def testH265_854x480_Playback(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_121")

    def testh265_simple_10bit_lowbitrat_mkv(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Launch VLC app
            2. Play video
            """
        self.testVideoPlayBackViaVLC("test_API_video_playback_140")

    def testh265_HEVC_With_10Bit_medium_mp4(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Launch VLC app
            2. Play video
            """
        self.testVideoPlayBackViaVLC("test_API_video_playback_141")

    def testVideo_Playback_MPEG4_SPL0_QCIF_176x144_15Fps(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Launch VLC app
            2. Play video
            """
        if self.hardware == "gordon_peak":
            self.testVideoPlayBackViaGallery("test_API_video_playback_142")
        elif self.hardware in ["androidia_64", "r2_cht_mrd"]:
            self.testVideoPlayBack("test_API_video_playback_142")
        else:
            self.testVideoPlayBackViaVLC("test_API_video_playback_142")

    def testPlayback_H264_4K_External_Storage(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Launch VLC app
            2. Play video
            """
        if self.hardware in ["androidia_64", "r2_cht_mrd"]:
            self.testVideoPlayBack("test_API_video_playback_143")
        else:
            self.testVideoPlayBackViaVLC("test_API_video_playback_143",
                                         change_file_flag=True)

    def testVideo_Playback_DIVX5_720p_30Fps(self):
        """
        This test used to test DIVX Video playback
        he test case spec is following:
        1. Launch VLC app
        2. Play video
        """
        self.testVideoPlayBackViaVLC("test_API_video_playback_144")

    def testVideo_Playback_DIVX6_1080p_23Fps(self):
        """
        This test used to test DIVX Video playback
        he test case spec is following:
        1. Launch VLC app
        2. Play video
        """
        self.testVideoPlayBackViaVLC("test_API_video_playback_145")

    def testVideo_Playback_Xvid_960x720_30Fps(self):
        """
        This test used to test DIVX Video playback
        he test case spec is following:
        1. Launch VLC app
        2. Play video
        """
        self.testVideoPlayBackViaVLC("test_API_video_playback_153")

    def testVP8_480X320_Playback(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_122")

    def testVP8_854x480_Playback(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_123")

    def testVP8_HW_4K_Decode(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.videoPlayVP8CodecProcess("test_API_video_playback_151")

    def testVP9_480X320_Playback(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_124")

    def testVP9_854x480_Playback(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_125")

    def testMPEG4_480X320_Playback(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_126")

    def testMPEG4_854x480_Playback(self):
        """
        This test used to test Video playback
        The test case spec is following:
        1. Launch play video app
        2. Play video
        """
        self.testVideoPlayBack("test_API_video_playback_127")

    def testVideo_Playback_H264_HP_1408x1152_Ts_Pause_Resume_Rotate_Sleep(
            self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Launch play video app
            2. Play video and check
            3. rotate screen and press power key to suspeng/resume
        """
        self.videoPlayControlProcess("test_video_playback_031")

    def testVideo_Playback_H264_1080P_Ts_Pause_Resume_Rotate_Sleep(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Launch play video app
            2. Play video and check
            3. rotate screen and press power key to suspeng/resume
        """
        self.videoPlayControlProcess("test_API_video_playback_146")

    def testVideo_Playback_H264_1080_Mkv_Local(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Launch play video app
            2. Play video and check
            3. rotate screen and press power key to suspeng/resume
        """
        self.videoPlayControlProcess("test_API_video_playback_154")

    def testVideo_Playback_HEAAC_V2_Mp4(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Launch play video app
            2. Play video and check
        """
        self.testVideoPlayBackAudio("test_API_video_playback_152")

    def testVideo_Playback_Mp3_Mkv(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Launch play video app
            2. Play video and check
        """
        self.testVideoPlayBackAudio("test_video_playback_110")

    def testVideo_Playback_MPEG4_SPL2_QVGA_15Fps(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Launch play video app
            2. Play video and check
            3. rotate screen and press power key to suspeng/resume
        """
        self.videoPlayControlProcess("test_video_playback_015")

    def testVideo_Playback_MPEG4_SP_VGA_30Fps(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Launch play video app
            2. Play video and check
            3. rotate screen and press power key to suspeng/resume
        """
        self.videoPlayControlProcess("test_video_playback_098")

    def testVideo_Playback_MPEG4_SP2_CIF_3gp(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Launch play video app
            2. Play video and check
            3. rotate screen and press power key to suspeng/resume
        """
        self.videoPlayControlProcess("test_video_playback_101")

    def testVideo_Playback_MPEG4_SP1_CIF(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Launch play video app
            2. Play video and check
            3. rotate screen and press power key to suspeng/resume
        """
        self.videoPlayControlProcess("test_API_video_playback_132")

    def testVideo_Decode_Second_Display_H264_1080P(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Connect two screen.
            2. Play video on the second screen.
        """
        self.videoDecodeSecondDisplay("test_API_video_playback_147")

    def testVideo_Decode_Second_Display_VP8_720P(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Connect two screen.
            2. Play video on the second screen.
        """
        self.videoDecodeSecondDisplay("test_API_video_playback_148")

    def testVideo_Decode_Second_Display_MPEG4_480P(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Connect two screen.
            2. Play video on the second screen.
        """
        self.videoDecodeSecondDisplay("test_video_playback_017")

    def testVideo_Decode_Second_Display_H264_720P_60fps(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Connect two screen.
            2. Play video on the second screen.
        """
        self.videoDecodeSecondDisplay("test_API_video_playback_149")

    def testVideo_Decode_Second_Display_H265_480x360(self):
        """
            This test used to test Video playback
            The test case spec is following:
            1. Connect two screen.
            2. Play video on the second screen.
        """
        self.videoDecodeSecondDisplay("test_API_video_playback_150")