class WidevineTest(UIATestBase):
"""
@summary: Test Widevine
"""
config = TestConfig()
def setUp(self):
"""
@summary: set up
@return: None
"""
super(WidevineTest, self).setUp()
self.d = g_common_obj.get_device()
self._test_name = __name__
self.video_button_widget_dict = {
"play": "android:id/pause",
"pause": "android:id/pause",
"volume_up": "volume_up",
"volume_down": "volume_down",
"back": "back"
}
print "[Setup]: %s" % self._test_name
def tearDown(self):
"""
@summary: tear tearDown
@return: None
"""
super(WidevineTest, self).tearDown()
print "[Teardown]: %s" % self._test_name
g_common_obj.stop_exp_handle()
def appPrepare(self, model=1):
self.cfg_file = os.path.join(os.environ.get('TEST_DATA_ROOT', ''), \
'tests.tablet.mum_auto_drm.conf')
self.cfg = self.config.read(self.cfg_file, self.case_name)
self.multimedia_handle = MultiMediaHandle()
self.multimedia_setting = MultiMediaSetting(self.cfg_file)
self.multimedia_drm_helper = MultiMediaDRMHelper()
self.multimedia_setting.install_apk(
"widevine_apk") #install widevine apk
self.widevine_package_name, self.widevine_activity_name = self.multimedia_setting.get_package_and_activity_name(
"widevine_apk")
if model == 1: # play local video mode
self.dst_path = self.cfg.get("dst_path")
self.clearResourcefolder()
self.dst_path = self.multimedia_setting.push_file_new(
self.cfg.get("src_path"),
self.dst_path) #push video file to device
elif model == 2: # play network video mode
self.src_path = self.cfg.get("src_path")
# g_common_obj.set_vertical_screen()
g_common_obj.stop_app_am(self.widevine_package_name)
g_common_obj.adb_cmd_capture_msg("input keyevent 82") #Unlock screen
def disableVerityDUT(self):
serial = self.d.server.adb.device_serial()
result = os.popen("adb -s %s disable-verity" % serial).read()
logger.debug("result=%s" % result)
assert "version" not in result and "error" not in result, "Please update sdk version!"
assert "fail" not in result and "error" not in result, "The DUT can't disable-verity, please reboot and check it"
def remountDUT(self):
serial = self.d.server.adb.device_serial()
os.system("adb -s %s remount" % serial)
time.sleep(3)
result = os.popen("adb -s %s remount" % serial).read()
logger.debug("result=%s" % result)
assert "fail" not in result and "error" not in result, "The DUT can't remount, please reboot and check it"
def getDeviceTypeMapCfg(self):
if "device_type_map" not in dir(self):
self.device_type_map_cfg = self.config.read(
self.cfg_file, "device_type_map")
return self.device_type_map_cfg
def executeCommandWithPopen(self, cmd):
logger.debug(cmd)
# return subprocess.Popen(cmd, shell=True)
return subprocess.Popen(cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
shell=True)
def clearResourcefolder(self):
g_common_obj.adb_cmd_capture_msg("rm -rf %s" %
os.path.split(self.dst_path)[0])
def launchWidevineApp(self):
SystemUI().unlock_screen()
# g_common_obj.stop_app_am(self.widevine_package_name)
g_common_obj.launch_app_am(self.widevine_package_name,
self.widevine_activity_name)
time.sleep(5)
for _ in range(5):
if self.d(textContains="Downloads").exists:
return
time.sleep(5)
assert self.d(
textContains="Downloads").exists, "launch Winevine App failed!"
def findVideoExistInWidevineApp(self, video_name):
logger.debug("findVideoExistInWidevineApp video_name=%s" % video_name)
time.sleep(5)
for _ in range(10):
if self.d(textContains=video_name).exists:
break
self.d(text=">>").click()
time.sleep(20)
assert self.d(textContains=video_name
).exists, "Video not exist! video_name=%s" % video_name
bounds = self.d(textContains=video_name).info["bounds"]
x = bounds["left"] + (bounds["right"] - bounds["left"]) / 2
y = bounds["top"] - (bounds["bottom"] - bounds["top"]) / 2
self.d.click(x, y)
def clear_edit_text_layout(self, layout):
while layout.text != "":
layout.clear_text()
def setContentPage(self, path):
self.d(text="Settings").click()
time.sleep(2)
edit_text_layout = self.d(
className="android.widget.EditText",
resourceId="com.widevine.demo:id/content_page")
if edit_text_layout.text != path:
self.clear_edit_text_layout(edit_text_layout)
edit_text_layout.set_text(path)
self.d.press.back()
time.sleep(1)
self.d(text="Update Button").click()
self.d(text="Ok").click()
def wait_boot_completed(self, timeout=1000):
''' wait Android boot_completed
args: timeout -- optional timeout in second, default 1000s
'''
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 widevineVideoPlayBack(self):
self.d(text="Downloads").click()
time.sleep(5)
dst_name = os.path.split(self.dst_path)[1]
assert self.d(
textContains=dst_name
).exists, "resource file not exist! file_name=%s" % dst_name
self.d(className="android.widget.ImageView", index="0").click()
time.sleep(5)
self.d(text="Acquire Rights").click()
time.sleep(3)
acquire_rights_value = -1
for _ in range(3):
widevine_value = self.getWidevineValue()
logger.debug("widevine_value=%s" % widevine_value)
if "acquireRights" in widevine_value and "Rights installed" in widevine_value:
acquire_rights_value = self.getWidevineValue_acquireRights()
logger.debug("acquire_rights_value=%s" %
str(acquire_rights_value))
break
time.sleep(3)
assert "error" not in widevine_value and "fail" not in widevine_value, "error widevine_value!! widevine_value=%s" % widevine_value
assert acquire_rights_value == 0, "error acquire_rights_value!!! acquire_rights_value=%d" % acquire_rights_value
self.d(text="Play").click()
def widevineStreamingVideoPlayBack(self):
self.d(text="Streaming").click()
time.sleep(5)
video_index = self.findVideoExistInWidevineApp(self.src_path)
self.d(className="android.widget.ImageView", index=video_index).click()
time.sleep(5)
self.d(text="Acquire Rights").click()
time.sleep(3)
acquire_rights_value = -1
for _ in range(10):
widevine_value = self.getWidevineValue()
logger.debug("widevine_value=%s" % widevine_value)
if "acquireRights" in widevine_value and "Rights installed" in widevine_value:
acquire_rights_value = self.getWidevineValue_acquireRights()
logger.debug("acquire_rights_value=%s" %
str(acquire_rights_value))
break
time.sleep(3)
assert "error" not in widevine_value and "fail" not in widevine_value, "error widevine_value!! widevine_value=%s" % widevine_value
assert acquire_rights_value == 0, "error acquire_rights_value!!! acquire_rights_value=%d" % acquire_rights_value
self.d(text="Play").click()
def getWidevineValue(self):
self.widevine_value_text = self.d(
className="android.widget.TextView").text
return self.widevine_value_text
def get_acquire_rights_pattern(self):
if "acquire_rights_pattern" not in dir(self):
GET_ACQUIRERIGHTS_PATTERN = ".*acquireRights = (.*)\n.*"
self.acquire_rights_pattern = re.compile(GET_ACQUIRERIGHTS_PATTERN)
return self.acquire_rights_pattern
def getWidevineValue_acquireRights(self):
try:
acquire_rights_pattern = self.get_acquire_rights_pattern()
widevine_value = self.getWidevineValue()
acquire_rights_value = acquire_rights_pattern.findall(
widevine_value)
acquire_rights_value = int(acquire_rights_value[0])
except Exception as e:
logger.debug("widevine_value=%s" % widevine_value)
logger.debug("acquire_rights_value=%s" % str(acquire_rights_value))
assert 0, e
return acquire_rights_value
def getPlatform(self):
cmd = "adb shell getprop ro.board.platform"
platform = os.popen(cmd).read()
platform = platform.replace("\n", "", 1)
return platform.strip()
def getDeviceTypeMapNum(self):
device_platform = self.getPlatform()
device_platform = device_platform.lower()
if "sofia_lte" in device_platform:
num = 2
else:
num = 1
# num = self.getDeviceTypeMapCfg().get(device_platform)
return num
def clickScreen(self):
self.multimedia_setting.clickScreen()
def click_widget(self, t_widget):
try:
t_widget.click()
self.s_t_text = 0
except Exception as e:
logger.debug("click_widget error:%s" % e)
self.s_t_text = -2
assert 0, "click_widget error:%s" % e
def get_widget(self, t_str):
logger.debug("get_widget---t_str=%s" % t_str)
assert t_str in self.video_button_widget_dict, "%s not in video_button_widget_dict!" % t_str
t_resource_id = self.video_button_widget_dict[t_str]
if t_resource_id == t_str:
return t_resource_id
else:
return self.d(resourceId=t_resource_id)
def widget_operation_with_thread(self, t_str, t_operation):
self.s_t_text = -1
t_widget = self.get_widget(t_str)
if t_operation == "click":
thread.start_new_thread(self.click_widget, (t_widget, ))
else:
assert 0, "Error operation!"
while self.s_t_text == -1:
if not t_widget.exists:
self.clickScreen()
time.sleep(1)
return self.s_t_text
def click_button(self, t_str):
logger.debug("click_button---t_str=%s" % t_str)
t_widget = self.video_button_widget_dict[t_str]
if t_str != t_widget:
result = self.widget_operation_with_thread(t_str, "click")
assert result == 0, "click failed! reselt=%d" % result
else:
getattr(self.d.press, t_widget)()
def checkVideoPlayBackWithWidevine(self):
self.launchWidevineApp() # launch widevine app
self.widevineVideoPlayBack() # play video file
time.sleep(10)
assert not self.d(
textContains="can't"
).exists, "video playback failed!" #check play status of video
time.sleep(140)
assert not self.d(
textContains="can't"
).exists, "video playback failed!" #check play status of video
def checkStreamingVideoPlayBackWithWidevine(self):
self.launchWidevineApp()
self.setContentPage(self.cfg.get("web_page"))
self.widevineStreamingVideoPlayBack()
time.sleep(10)
assert not self.d(
textContains="can't").exists, "video playback failed!"
time.sleep(140)
assert not self.d(
textContains="can't").exists, "video playback failed!"
def checkVideoPlayBackWithClickButton(self, click_list):
self.launchWidevineApp() # launch widevine app
self.widevineVideoPlayBack() # play video file
time.sleep(10)
assert not self.d(
textContains="can't"
).exists, "video playback failed!" #check play status of video
for t_str in click_list:
if t_str == "sleep":
time.sleep(5)
else:
self.click_button(t_str)
time.sleep(2)
time.sleep(60)
assert not self.d(
textContains="can't"
).exists, "video playback failed!" #check play status of video
def winevine_main_test(self, sub_func_name="", model=1, *arg, **keywords):
"""
This test used to test WinevineApp App
The test case spec is following:
1. Start record video
2. do sub_func()
3. Stop record video
"""
self.case_name = sys._getframe().f_back.f_code.co_name
if sub_func_name == "":
sub_func_name = "%s_sub_func" % self.case_name
logger.debug("case_name=%s" % self.case_name)
logger.debug("exoplayer_main_test---sub_func_name=%s" % sub_func_name)
self.appPrepare(model)
try:
self.multimedia_drm_helper.startRecord(
self.case_name) #start record
logger.debug("Arbitrary parameter is %s" % str(arg))
logger.debug("keywords parameter is %s" % str(keywords))
getattr(self, sub_func_name)(*arg, **keywords)
self.d.press.back()
self.d.press.back()
self.d.press.home()
if model == 1:
self.clearResourcefolder()
time.sleep(1)
self.multimedia_drm_helper.stopRecord() #stop record
except Exception as e:
self.multimedia_drm_helper.stopRecord()
assert 0, e
assert 0, "Playback complete! Please check video!"
logger.debug("Case %s is pass!" % self.case_name)
def test_video_playback_with_check_S0I3(self):
self.case_name = sys._getframe().f_back.f_code.co_name
self.appPrepare()
after_S0I3_str = self.multimedia_setting.getS0I3()
self.launchWidevineApp()
self.widevineVideoPlayBack()
time.sleep(10)
assert not self.d(
textContains="can't").exists, "video playback failed!"
self.d.press.power()
logger.debug("Step: sleep 800s, please wait...")
time.sleep(800)
logger.debug("Step: sleep 800s, complete!")
self.d.press.power()
SystemUI().unlock_screen()
self.d.press.back()
self.d.press.home()
before_S0I3_str = self.multimedia_setting.getS0I3()
assert after_S0I3_str != before_S0I3_str, "after_S0I3_str=%s, before_S0I3_str=%s" % (
after_S0I3_str, before_S0I3_str)
def checkVideoPlayBackWithWidevineWithReboot(self, t_time):
self.case_name = sys._getframe().f_back.f_code.co_name
self.appPrepare()
self.launchWidevineApp()
self.widevineVideoPlayBack()
time.sleep(20)
assert not self.d(
textContains="can't").exists, "video playback failed!"
for _ in range(t_time):
adb.reboot_device()
self.wait_boot_completed()
time.sleep(20)
self.launchWidevineApp()
self.widevineVideoPlayBack()
time.sleep(20)
assert not self.d(
textContains="can't").exists, "video playback failed!"
def checkProvision(self):
self.case_name = sys._getframe().f_back.f_code.co_name
logger.debug("case_name=%s" % self.case_name)
self.appPrepare(0)
if "false" == self.cfg.get("test"):
logger.debug("Case %s is skip auto test!" % self.case_name)
return
num = self.getDeviceTypeMapNum()
if num == 1:
g_common_obj.root_on_device()
self.disableVerityDUT()
adb.reboot_device()
self.wait_boot_completed()
g_common_obj.root_on_device()
self.remountDUT()
time.sleep(3)
bin_src_path = self.getDeviceTypeMapCfg().get("%s_bin_src_path" %
(num))
bin_dst_path = self.getDeviceTypeMapCfg().get("%s_bin_src_path" %
(num))
bin_src_path = self.multimedia_setting.download_file_to_host(
bin_src_path)
bin_src_folder = os.path.split(bin_src_path)[0]
bin_dst_filename = os.path.split(bin_dst_path)[1]
unzip_cmd = self.getDeviceTypeMapCfg().get("unzip_command")
self.executeCommandWithPopen(unzip_cmd %
(bin_src_path, bin_src_folder))
bin_src_path = os.path.join(bin_src_folder, bin_dst_filename)
bin_dst_path = self.multimedia_setting.push_file_to_dut(
bin_src_path, bin_dst_path)
tools_src_path = self.getDeviceTypeMapCfg().get("%s_tool_src_path" %
(num))
tools_dst_path = self.getDeviceTypeMapCfg().get("%s_tool_dst_path" %
(num))
tools_dst_path = self.multimedia_setting.push_file_new(
tools_src_path, tools_dst_path)
g_common_obj.adb_cmd_capture_msg("chmod 777 %s" % tools_dst_path)
time.sleep(5)
i = 1
while "%s_execute_command_%s" % (num, i) in self.getDeviceTypeMapCfg():
cmd = self.getDeviceTypeMapCfg().get("%s_execute_command_%s" %
(num, i))
fdp = self.executeCommandWithPopen(cmd)
time.sleep(3)
stdout_log = fdp.stdout.read()
assert "cannot" not in stdout_log and "error" not in stdout_log and "fail" not in stdout_log and "not found" not in stdout_log, "(%s) cmd error: %s" % (
cmd, stdout_log)
i += 1
logger.debug("Case %s is pass!" % self.case_name)
def testWVClassicPlayback_WVDemo_Local_720p(self):
self.winevine_main_test("checkVideoPlayBackWithWidevine")
def testWVClassic_WVDemo_Local_1080p(self):
self.winevine_main_test("checkVideoPlayBackWithWidevine")
def testWVClassic_WVDemo_Local_360(self):
self.winevine_main_test("checkVideoPlayBackWithWidevine")
def testWVClassic_WVDemo_SD(self):
self.winevine_main_test("checkVideoPlayBackWithWidevine")
def testWVClassic_WVDemo_Local_480p(self):
self.winevine_main_test("checkVideoPlayBackWithWidevine")
def testWVClassic_WVDemo_HD_Local(self):
self.winevine_main_test("checkVideoPlayBackWithWidevine")
def testWVClassic_WVDemo_WiFi_360p(self):
self.winevine_main_test("checkStreamingVideoPlayBackWithWidevine", 2)
def testWVClassic_WVDemo_WiFi_480P(self):
self.winevine_main_test("checkStreamingVideoPlayBackWithWidevine", 2)
def testWVClassic_WVDemo_WiFi_720p(self):
self.winevine_main_test("checkStreamingVideoPlayBackWithWidevine", 2)
def testWVClassic_WVDemo_WiFi_1080p(self):
self.winevine_main_test("checkStreamingVideoPlayBackWithWidevine", 2)
def testWVClassic_WVDemo_Menu_Interaction(self):
self.winevine_main_test("checkVideoPlayBackWithClickButton", 1,
["volume_up"] * 4 + ["sleep"] +
["volume_down"] * 4)
def testWVClassic_WVDemo_Volume_Adjustment_Paused(self):
self.winevine_main_test("checkVideoPlayBackWithClickButton", 1,
["pause"] + ["volume_up"] * 10 + ["sleep"] +
["volume_down"] * 10 + ["play"] +
["volume_down"] * 10 + ["pause"])
def testWVClassic_Reboot_Multi_Times(self):
self.checkVideoPlayBackWithWidevineWithReboot(20)
def testWVClassic_Resume_S0i3(self):
self.test_video_playback_with_check_S0I3()
def testProvisionKeyBox_Reboot(self):
self.checkProvision()
def testWVClassic_Provision(self):
self.checkProvision()
class CameraTest(CameraTestBase):
"""
@summary: This test used to test camera function
"""
config = TestConfig()
def setUp(self):
"""
@summary: set up
@return: None
"""
super(CameraTest, self).setUp()
self._test_name = __name__
self.logger.debug("[Setup]: %s" % self._test_name)
g_common_obj.root_on_device()
g_common_obj.remount_device()
self.camera_common = CameraCommon()
self.evs_vts_test_config = self.config.read(
self.camera_common.DEFAULT_CONFIG_FILE, "evs_vts_test_config")
self.multimedia_setting = MultiMediaSetting(
self.camera_common.DEFAULT_CONFIG_FILE)
adb32.adb_disable_verity()
self.prepare_env()
def tearDown(self):
"""
@summary: tearDown
@return: None
"""
super(CameraTest, self).tearDown()
self.logger.debug("[Teardown]: %s" % self._test_name)
g_common_obj.stop_exp_handle()
def prepare_env(self):
self.bit_32_file_src_path = self.evs_vts_test_config.get(
"32bit_file_src_path")
self.bit_32_file_dst_path = self.evs_vts_test_config.get(
"32bit_file_dst_path")
self.bit_64_file_src_path = self.evs_vts_test_config.get(
"64bit_file_src_path")
self.bit_64_file_dst_path = self.evs_vts_test_config.get(
"64bit_file_dst_path")
t_result = g_common_obj.adb_cmd_capture_msg("ls %s" %
self.bit_32_file_dst_path)
print t_result
if self.bit_32_file_dst_path not in t_result:
self.bit_32_file_dst_path = self.multimedia_setting.push_file_new(
self.bit_32_file_src_path, self.bit_32_file_dst_path)
g_common_obj.adb_cmd_capture_msg("chmod 777 %s" %
self.bit_32_file_dst_path)
t_result = g_common_obj.adb_cmd_capture_msg("ls %s" %
self.bit_64_file_dst_path)
if self.bit_64_file_dst_path not in t_result:
self.bit_64_file_dst_path = self.multimedia_setting.push_file_new(
self.bit_64_file_src_path, self.bit_64_file_dst_path)
g_common_obj.adb_cmd_capture_msg("chmod 777 %s" %
self.bit_64_file_dst_path)
def EVS_VTS_main_test(self):
self.case_name = sys._getframe().f_back.f_code.co_name
case_name_split_list = self.case_name.split("_")
check_case_name, check_bit = case_name_split_list[
-2], case_name_split_list[-1]
exec_file = self.bit_32_file_dst_path if "32" in check_bit else self.bit_64_file_dst_path
cmd = "shell %s" % exec_file
t_result = self.multimedia_setting.execute_adb_command(cmd)
self.logger.debug("t_result=%s" % t_result)
get_test_case_result_parttern = re.compile(r"\[(.*)\].*%s" %
check_case_name)
test_case_result_list = get_test_case_result_parttern.findall(t_result)
for test_case_result in test_case_result_list:
if "OK" in test_case_result:
self.logger.debug("%s passed! test_case_result_list=%s" %
(self.case_name, test_case_result_list))
return
assert 0, "%s failed! test_case_result_list=%s" % (
self.case_name, test_case_result_list)
def Test_Camera_EVS_VTS_CameraOpenAggressive_32bit(self):
self.EVS_VTS_main_test()
def Test_Camera_EVS_VTS_CameraOpenAggressive_64bit(self):
self.EVS_VTS_main_test()
def Test_Camera_EVS_VTS_CameraOpenClean_32bit(self):
self.EVS_VTS_main_test()
def Test_Camera_EVS_VTS_CameraOpenClean_64bit(self):
self.EVS_VTS_main_test()
def Test_Camera_EVS_VTS_CameraStreamBuffering_32bit(self):
self.EVS_VTS_main_test()
def Test_Camera_EVS_VTS_CameraStreamBuffering_64bit(self):
self.EVS_VTS_main_test()
def Test_Camera_EVS_VTS_CameraStreamPerformance_32bit(self):
self.EVS_VTS_main_test()
def Test_Camera_EVS_VTS_CameraStreamPerformance_64bit(self):
self.EVS_VTS_main_test()
def Test_Camera_EVS_VTS_CameraToDisplayRoundTrip_32bit(self):
self.EVS_VTS_main_test()
def Test_Camera_EVS_VTS_CameraToDisplayRoundTrip_64bit(self):
self.EVS_VTS_main_test()
def Test_Camera_EVS_VTS_DisplayOpen_32bit(self):
self.EVS_VTS_main_test()
def Test_Camera_EVS_VTS_DisplayOpen_64bit(self):
self.EVS_VTS_main_test()
def Test_Camera_EVS_VTS_DisplayStates_32bit(self):
self.EVS_VTS_main_test()
def Test_Camera_EVS_VTS_DisplayStates_64bit(self):
self.EVS_VTS_main_test()
class MultiMediaScaleTestHelper:
def __init__(self, host_path):
self.logger = Logger.getlogger()
self.host_path = host_path
self.camera_helper = MultiMediaSwitchCameraHelper(
skip_import_camera=True)
self.target_folder = os.path.join(self.host_path,
self.camera_helper.device,
self.camera_helper.android_version)
self.expect_folder = os.path.join(self.target_folder, "expect")
self.actual_folder = os.path.join(self.target_folder, "actual")
if not os.path.exists(self.expect_folder):
os.makedirs(self.expect_folder)
if not os.path.exists(self.actual_folder):
os.makedirs(self.actual_folder)
self.ffmpeg_cmd = "ffmpeg -i %s -ss 00:00.02 -y -q:v 2 -vframes 1 %s"
self.movies_folder_device_path = "/sdcard/Movies/"
self.scale_test_xml_value_dict = {1: 30, 2: 50, 3: 60}
self.play_result = -1
self.get_cfg_file_helper = GetConfigFileHelper(
"", "multimedia_scale_test_helper.conf")
self.scale_test_cfg = self.get_cfg_file_helper.get_section("config")
self.multimedia_setting = MultiMediaSetting(
self.get_cfg_file_helper.cfg_file)
self.generated_reference_library = int(
self.scale_test_cfg.get("generated_reference_library"))
self.reference_library_folder = self.scale_test_cfg.get(
"reference_library_folder")
self.reference_library_folder = os.path.join(
self.reference_library_folder, self.camera_helper.device,
self.camera_helper.android_version)
self.xml_file_dst_path = self.scale_test_cfg.get("xml_file_dst_path")
self.o_image_camera3_xml_file_dst_path = self.scale_test_cfg.get(
"o_image_camera3_xml_file_dst_path")
def __execute_command_with_popen(self, cmd, t_shell=False):
self.logger.debug("__execute_command_with_popen cmd=%s" % cmd)
if not t_shell:
cmd = cmd.split()
return subprocess.Popen(cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
shell=t_shell)
def remount_device(self):
if self.camera_helper.android_version == "o":
from testlib.graphics.common import adb32
adb32.adb_disable_verity()
else:
from testlib.common.common import g_common_obj2
self.serial = g_common_obj2.getSerialNumber()
os.system("adb -s %s root" % self.serial)
os.system("adb -s %s root" % self.serial)
os.system("adb -s %s disable-verity" % self.serial)
os.system("adb -s %s reboot" % self.serial)
time.sleep(60)
os.system("adb -s %s root" % self.serial)
time.sleep(30)
os.system("adb -s %s root" % self.serial)
result = 'remount succeeded'
remount_result = os.popen("adb -s %s remount" %
self.serial).read().strip()
print "[Info] --- remount result is %s" % remount_result
if result == remount_result:
print "[Info] --- remount successfull"
else:
assert False, "[Info] --- remount fail"
def backup_file(self, dst_path_string, backup_name_postfix="_backup"):
dst_path = self.scale_test_cfg.get(dst_path_string)
dst_path_root, dst_path_ext = os.path.splitext(dst_path)
backup_dst_path = "%s%s%s" % (dst_path_root, backup_name_postfix,
dst_path_ext)
self.logger.debug("backup_file backup_dst_path=%s" % backup_dst_path)
t_result = g_common_obj.adb_cmd_capture_msg("ls %s" % backup_dst_path)
if backup_dst_path not in t_result:
g_common_obj.adb_cmd_capture_msg("cp %s %s" %
(dst_path, backup_dst_path))
t_result = g_common_obj.adb_cmd_capture_msg("ls %s" %
backup_dst_path)
assert backup_dst_path in t_result, "cp failed! t_result=%s" % t_result
return (dst_path, backup_dst_path)
def restore_file(self, dst_path_string, backup_name_postfix="_backup"):
dst_path = self.scale_test_cfg.get(dst_path_string)
dst_path_root, dst_path_ext = os.path.splitext(dst_path)
backup_dst_path = "%s%s%s" % (dst_path_root, backup_name_postfix,
dst_path_ext)
t_result = g_common_obj.adb_cmd_capture_msg("ls %s" % backup_dst_path)
if backup_dst_path in t_result:
g_common_obj.adb_cmd_capture_msg("cp %s %s" %
(backup_dst_path, dst_path))
t_result = g_common_obj.adb_cmd_capture_msg("ls %s" % dst_path)
self.logger.debug("backup_file t_result=%s" % t_result)
return True
return False
def replace_file(self, src_path_string, dst_path_string):
src_path = self.scale_test_cfg.get(src_path_string)
dst_path = self.scale_test_cfg.get(dst_path_string)
g_common_obj.adb_cmd_capture_msg("rm -rf %s" % dst_path)
t_result = g_common_obj.adb_cmd_capture_msg("ls %s" % dst_path)
assert dst_path not in t_result, "rm failed! t_result=%s" % t_result
dst_path = self.multimedia_setting.push_file_new(src_path, dst_path)
t_result = g_common_obj.adb_cmd_capture_msg("ls %s" % dst_path)
assert dst_path in t_result, "push failed! t_result=%s" % t_result
return dst_path
def scale_test_o_image_prepare(self):
package_name, _ = self.multimedia_setting.get_package_and_activity_name(
"for_o_image_camera_preview_test_apk")
self.o_image_play_cmd = self.scale_test_cfg.get("o_image_play_cmd")
result = verify_apps(package_name)
self.remount_device()
self.backup_file("o_image_media_xml_file_dst_path")
self.o_image_media_xml_file_dst_path = self.replace_file(
"o_image_media_xml_file_src_path",
"o_image_media_xml_file_dst_path")
self.backup_file("o_image_libcamhal_xml_file_dst_path")
self.o_image_libcamhal_xml_file_dst_path = self.replace_file(
"o_image_libcamhal_xml_file_src_path",
"o_image_libcamhal_xml_file_dst_path")
self.o_image_camera3_xml_file_dst_path = self.backup_file(
"o_image_camera3_xml_file_dst_path")[0]
self.restore_file("o_image_camera3_xml_file_dst_path", "_hdmi")
if not result:
self.multimedia_setting.install_apk(
"for_o_image_camera_preview_test_apk")
return True
def scale_test_default_image_prepare(self, fps="60fps"):
self.sh_file_src_path = self.scale_test_cfg.get("sh_file_src_path")
self.sh_file_dst_path = self.scale_test_cfg.get("sh_file_dst_path")
self.backup_file("xml_file_dst_path")
package_name, _ = self.multimedia_setting.get_package_and_activity_name(
"camera_preview_test_apk")
result = verify_apps(package_name)
if not result:
self.remount_device()
g_common_obj.adb_cmd_capture_msg("rm -rf %s" %
self.sh_file_dst_path)
t_result = g_common_obj.adb_cmd_capture_msg("ls %s" %
self.sh_file_dst_path)
assert "No such file or directory" in t_result, "rm failed! t_result=%s" % t_result
self.sh_file_dst_path = self.multimedia_setting.push_file_new(
self.sh_file_src_path, self.sh_file_dst_path)
t_result = g_common_obj.adb_cmd_capture_msg("ls %s" %
self.sh_file_dst_path)
assert "No such file or directory" not in t_result, "push failed! t_result=%s" % t_result
g_common_obj.adb_cmd_capture_msg("chmod 777 %s" %
self.sh_file_dst_path)
self.multimedia_setting.install_apk("camera_preview_test_apk")
return not result
def scale_test_prepare(self, fps="60fps"):
self.logger.debug("scale_test_prepare")
if self.camera_helper.android_version == "o":
result = self.scale_test_o_image_prepare()
else:
result = self.scale_test_default_image_prepare(fps)
return result
def scale_test_o_image_teardown(self):
self.remount_device()
self.restore_file("o_image_media_xml_file_dst_path")
self.restore_file("o_image_libcamhal_xml_file_dst_path")
self.restore_file("o_image_camera3_xml_file_dst_path")
return 1
def scale_test_teardown(self):
self.logger.debug("scale_test_teardown")
self.remount_device()
if self.camera_helper.android_version == "o":
self.restore_file("o_image_media_xml_file_dst_path")
self.restore_file("o_image_libcamhal_xml_file_dst_path")
self.restore_file("o_image_camera3_xml_file_dst_path")
else:
self.restore_file("xml_file_dst_path")
return 1
def change_scale_test_xml(self, fps):
fps = str(fps)
self.logger.debug("change_scale_test_xml fps=%s" % fps)
if "fps" not in fps and "default" not in fps:
fps = fps + "fps"
self.remount_device()
xml_file_src_path = self.scale_test_cfg.get("%s_xml_file_src_path" %
fps)
xml_file_dst_path = self.scale_test_cfg.get("%s_xml_file_dst_path" %
fps)
g_common_obj.adb_cmd_capture_msg("rm -rf %s" % xml_file_dst_path)
t_result = g_common_obj.adb_cmd_capture_msg("ls %s" %
xml_file_dst_path)
assert "No such file or directory" in t_result, "rm failed! t_result=%s" % t_result
self.xml_file_dst_path = self.multimedia_setting.push_file_new(
xml_file_src_path, xml_file_dst_path)
t_result = g_common_obj.adb_cmd_capture_msg("ls %s" %
self.xml_file_dst_path)
assert self.xml_file_dst_path in t_result, "push failed! t_result=%s" % t_result
def change_scale_test_xml_param_handle(self, param, str1, str2):
return " -e 's#%s#%s#g' " % (param % str1, param % str2)
def change_scale_test_xml_for_o_image(self, dst_path, case_name):
self.logger.debug("change_scale_test_xml_for_o_image")
field, input_size, input_format, deinterlace_mode = self.analyze_case_name(
case_name)
main_param = ""
main_param += self.change_scale_test_xml_param_handle(
"intel.sensorprop.field\ value=\\\"%s\\\"", ".*", field)
main_param += self.change_scale_test_xml_param_handle(
"intel.sensorprop.inputSize\ value=\\\"%s\\\"", ".*", input_size)
main_param += self.change_scale_test_xml_param_handle(
"intel.sensorprop.inputFormat\ value=\\\"%s\\\"", ".*",
input_format)
main_param += self.change_scale_test_xml_param_handle(
"intel.sensorprop.deinterlaceMode\ value=\\\"%s\\\"", ".*",
deinterlace_mode)
cmd = "sed -i %s %s" % (main_param, dst_path)
self.logger.debug("change_scale_test_xml_for_o_image cmd=%s" % cmd)
g_common_obj.adb_cmd_capture_msg(cmd)
def change_libcamhal_xml_for_o_image(self, dst_path, case_name):
self.logger.debug("change_libcamhal_xml_for_o_image")
actual_fps = self.check_string_with_regular_expression(
case_name, r"_(\d*)[fps]{0,3}$", "")[1][0]
for t_key in self.scale_test_xml_value_dict.keys():
if actual_fps == str(self.scale_test_xml_value_dict[t_key]):
break
main_param = ""
main_param += self.change_scale_test_xml_param_handle(
"ctrlId=\\\"V4L2_CID_TEST_PATTERN\\\"\ value=\\\"%s\\\"\ ctrlName=",
".*", str(t_key))
cmd = "sed -i %s %s" % (main_param, dst_path)
self.logger.debug("change_libcamhal_xml_for_o_image cmd=%s" % cmd)
g_common_obj.adb_cmd_capture_msg(cmd)
def check_string_with_regular_expression(self, string, parttern,
expect_value):
get_value_parttern = re.compile(parttern)
value_list = get_value_parttern.findall(string)
assert len(
value_list) != 0, "Can't find parttern(%s) in string!" % parttern
actual_value = value_list[0]
self.logger.debug(
"check_string_with_regular_expression actual_value=%s, expect_value=%s"
% (actual_value, expect_value))
result = 0 if actual_value == expect_value else -1
return (result, value_list)
def analyze_case_name(self, case_name):
field = "ANY" if "progressive" in case_name.lower() else "ALTERNATE"
deinterlace_mode = "OFF" if "progressive" in case_name.lower(
) else "ON"
input_size = self.check_string_with_regular_expression(
case_name, r"_(\d*x\d*)", "")[1][0]
input_size = input_size.replace("x", ",")
input_format = "YUY2" if "YUYV" in case_name else "UYVY"
self.logger.debug(
"analyze_case_name field=%s, input_size=%s, input_format=%s, deinterlace_mode=%s"
% (field, input_size, input_format, deinterlace_mode))
return field, input_size, input_format, deinterlace_mode
def check_scale_test_xml_for_o_image(self, case_name):
self.logger.debug("check_scale_test_xml_for_o_image case_name=%s" %
case_name)
field, input_size, input_format, deinterlace_mode = self.analyze_case_name(
case_name)
check_scale_test_xml_cmd = "cat %s" % self.o_image_camera3_xml_file_dst_path
t_result = g_common_obj.adb_cmd_capture_msg(check_scale_test_xml_cmd)
result = 0
result += self.check_string_with_regular_expression(
t_result, r"<intel.sensorprop.field value=\"(.*)\" />", field)[0]
result += self.check_string_with_regular_expression(
t_result, r"<intel.sensorprop.inputSize value=\"(.*)\" />",
input_size)[0]
result += self.check_string_with_regular_expression(
t_result, r"<intel.sensorprop.inputFormat value=\"(.*)\" />",
input_format)[0]
result += self.check_string_with_regular_expression(
t_result, r"<intel.sensorprop.deinterlaceMode value=\"(.*)\" />",
deinterlace_mode)[0]
return True if result == 0 else False
def check_libcamhal_xml_for_o_image(self, case_name):
self.logger.debug("check_libcamhal_xml_for_o_image case_name=%s" %
case_name)
check_libcamhal_xml_cmd = "cat %s" % self.o_image_libcamhal_xml_file_dst_path
t_result = g_common_obj.adb_cmd_capture_msg(check_libcamhal_xml_cmd)
actual_fps = self.check_string_with_regular_expression(
case_name, r"_(\d*)[fps]{0,3}$", "")[1][0]
for t_key in self.scale_test_xml_value_dict.keys():
if actual_fps == str(self.scale_test_xml_value_dict[t_key]):
break
result = 0
result += self.check_string_with_regular_expression(
t_result,
r"ctrlId=\"V4L2_CID_TEST_PATTERN\" value=\"(.*)\" ctrlName=",
str(t_key))[0]
return True if result == 0 else False
def check_scale_test_xml_for_default_image(self,
expect_fps,
special_str=""):
expect_fps = str(expect_fps)
if special_str != "":
expect_fps = "default"
check_scale_test_xml_cmd = "cat %s" % self.xml_file_dst_path
t_result = g_common_obj.adb_cmd_capture_msg(check_scale_test_xml_cmd)
get_scale_xml_fps_value_parttern = re.compile(
r"<control name=\"adv7481-hdmi pixel array 0-00e0\".*value=\"(.)\".*/>"
)
fps_value_result_list = get_scale_xml_fps_value_parttern.findall(
t_result)
self.logger.debug("check_scale_test_xml fps_value_result_list=%s" %
fps_value_result_list)
if len(fps_value_result_list) == 0:
actual_fps = "default"
else:
fps_value_result = fps_value_result_list[0]
self.logger.debug("check_scale_test_xml fps_value_result=%s" %
fps_value_result)
actual_fps = str(self.scale_test_xml_value_dict[int(
fps_value_result[0])])
self.logger.debug("check_scale_test_xml actual_fps=%s, expect_fps=%s" %
(actual_fps, expect_fps))
if actual_fps != expect_fps:
self.change_scale_test_xml(expect_fps)
return True
else:
return False
def check_scale_test_xml(self, expect_fps, case_name=""):
if self.camera_helper.android_version == "o":
need_reboot = False
if "AVM737" in case_name:
need_reboot = True
self.o_image_libcamhal_xml_file_dst_path = self.replace_file(
"o_image_avm737_libcamhal_xml_file_src_path",
"o_image_avm737_libcamhal_xml_file_dst_path")
elif "fps" in case_name.lower():
result = self.check_libcamhal_xml_for_o_image(case_name)
if not result:
need_reboot = True
self.change_libcamhal_xml_for_o_image(
self.o_image_libcamhal_xml_file_dst_path, case_name)
assert self.check_libcamhal_xml_for_o_image(
case_name), "Fail change libcamhal xml!"
result = self.check_scale_test_xml_for_o_image(case_name)
if not result:
need_reboot = True
self.change_scale_test_xml_for_o_image(
self.o_image_camera3_xml_file_dst_path, case_name)
assert self.check_scale_test_xml_for_o_image(
case_name), "Fail change scale test xml!"
return need_reboot
else:
special_str = "AVM737" if "AVM737" in case_name else ""
result = self.check_scale_test_xml_for_default_image(
expect_fps, special_str)
return result
def download_reference_library_file(self, file_path):
file_name = os.path.split(file_path)[1]
t_file_path = self.multimedia_setting.download_file_to_host(
os.path.join(self.reference_library_folder, file_name))
shutil.copyfile(t_file_path, file_path)
return file_path
def pull_video_file_to_host(self):
movies_file_name = g_common_obj.adb_cmd_capture_msg(
"ls %s" % self.movies_folder_device_path)
self.logger.debug(
"play_and_record_video_with_instrument movies_file_device_path=%s"
% movies_file_name)
g_common_obj.adb_cmd_common(
"pull %s/%s %s/%s" %
(self.movies_folder_device_path, movies_file_name, self.host_path,
movies_file_name))
movies_file_host_path = os.path.join(self.host_path, movies_file_name)
return movies_file_host_path
def play_and_record_video_with_instrument(self, cmd_arguments, case_name):
duration = 12
self.play_result = -1
if self.camera_helper.android_version == "o":
self.logger.debug(
"play_and_record_video_with_instrument case_name=%s" %
case_name)
if "fps" in case_name.lower():
cmd_arguments_list = cmd_arguments.split(" ")
width, height = cmd_arguments_list[4], cmd_arguments_list[5]
else:
output_size = self.check_string_with_regular_expression(
case_name, r"_(\d*x\d*)", "")[1][1]
width, height = output_size.split("x")
t_format = "NV21" if "NV21" in case_name else "NV21" #need extend
cmd_result = g_common_obj.adb_cmd_capture_msg(
self.o_image_play_cmd % (width, height, t_format, duration))
else:
self.logger.debug(
"play_and_record_video_with_instrument cmd=%s %s" %
(self.sh_file_dst_path, cmd_arguments))
cmd_result = g_common_obj.adb_cmd_capture_msg(
"%s %s" % (self.sh_file_dst_path, cmd_arguments))
self.logger.debug(
"play_and_record_video_with_instrument cmd_result = %s" %
cmd_result)
if "OK" not in cmd_result:
self.play_result = 0
else:
self.play_result = 1
def get_jpg_from_video(self,
video_file_path,
output_file_name="output.jpg",
output_folder=""):
if output_folder == "":
if self.generated_reference_library == 1:
output_folder = self.expect_folder
else:
output_folder = self.actual_folder
output_file_path = os.path.join(output_folder, output_file_name)
t_ffmpeg_cmd = self.ffmpeg_cmd % (video_file_path, output_file_path)
self.logger.debug("t_ffmpeg_cmd = %s" % t_ffmpeg_cmd)
result = self.__execute_command_with_popen(t_ffmpeg_cmd).stdout.read()
assert "Invalid" not in result and "error" not in result, "Generate jpg failed! result=%s" % result
return output_file_path