示例#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)
示例#2
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")
示例#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")
示例#4
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")
示例#5
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')
示例#6
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")