class IVICameraO(IVICamera):
HOME_PACKAGE_NAME = "com.android.car.mapsplaceholder"
HOME_ACTIVITY_NAME = ".MapsPlaceholderActivity"
CAMERA_CANBOX_0_SENDID = "000"
CAMERA_CANBOX_0_SENDMESSAGE = "%s#00" % CAMERA_CANBOX_0_SENDID
CAMERA_CANBOX_C_SENDID = "00C"
CAMERA_CANBOX_C_SENDMESSAGE = "%s#00" % CAMERA_CANBOX_C_SENDID
def __init__(self, cfg=None):
super(IVICameraO, self).__init__(cfg)
self.camera_common = CameraCommon()
self.host_path = self.camera_common.getTmpDir()
self.multimedia_canbox_helper = MultiMediaCanboxHelper()
self.multimedia_checkiq_helper = MultiMediaCheckiqHelper(
self.host_path)
user_log_dir = g_common_obj.get_user_log_dir()
self.before_screen_0_file_path = os.path.join(
user_log_dir, "before_enter_camera_0_screenshot.png")
self.after_screen_0_file_path = os.path.join(
user_log_dir, "after_enter_camera_0_screenshot.png")
self.before_screen_c_file_path = os.path.join(
user_log_dir, "before_enter_camera_c_screenshot.png")
self.after_screen_c_file_path = os.path.join(
user_log_dir, "after_enter_camera_c_screenshot.png")
self.now_camera_0_event = 0
self.camera_0_event_array = [("GEAR_NEUTRAL", 0), ("GEAR_DRIVE", 0),
("GEAR_REVERSE", 1), ("GEAR_PARK", 2),
("GEAR_LOW", 0)]
self.now_camera_c_event = 0
self.camera_c_event_array = [("NONE", 0), ("EMERGENCY", 0),
("RIGHT", 1), ("LEFT", 1)]
self.init_camera_with_canbox()
class IVICameraWidget:
def __init__(self):
self.d = g_common_obj.get_device()
def homeLayout(self):
'''
layout capture
'''
return self.d(packageName="com.android.car.dialer")
def homeLayout_2(self):
'''
layout capture
'''
return self.d(packageName="com.android.car.overview")
def homeLayout_3(self):
'''
layout capture
'''
return self.d(packageName="com.android.car.mapsplaceholder")
def lockLayout(self):
'''
layout capture
'''
return self.d(packageName="com.google.android.apps.maps")
def cameraLayout(self):
'''
layout capture
'''
return self.d(packageName="com.intel.rvc")
def isHomeLayoutExists(self):
if self.d(text="Got it").exists:
self.d(text="Got it").click.wait()
self.skipAccountLoginLyout()
t_result = self.camera_common.isWidgetExists(
self.IVICameraWidget().homeLayout())
if not t_result:
t_result = self.camera_common.isWidgetExists(
self.IVICameraWidget().homeLayout_2())
if not t_result:
t_result = self.camera_common.isWidgetExists(
self.IVICameraWidget().homeLayout_3())
return t_result
def isLockLayoutExists(self):
return self.camera_common.isWidgetExists(
self.IVICameraWidget().lockLayout())
def change_canbox_0_event(self):
self.now_camera_0_event += 1
if self.now_camera_0_event >= len(self.camera_0_event_array):
self.now_camera_0_event = 0
self.multimedia_canbox_helper.cansend(
IVICameraO.CAMERA_CANBOX_0_SENDMESSAGE)
def change_canbox_c_event(self):
self.now_camera_c_event += 1
if self.now_camera_c_event >= len(self.camera_c_event_array):
self.now_camera_c_event = 0
self.multimedia_canbox_helper.cansend(
IVICameraO.CAMERA_CANBOX_C_SENDMESSAGE)
def get_screenshot(self, file_path):
time.sleep(1)
file_folder, file_name = os.path.split(file_path)
self.camera_common.getScreenshotAndPullToHost(file_name, file_folder)
def get_screenshot_and_compare_picture_similarity(self,
expect_file_path,
actual_file_path,
expect_percent=0.8):
self.get_screenshot(actual_file_path)
t_percent = self.multimedia_checkiq_helper.compare_picture_similarity(
expect_file_path, actual_file_path)
self.logger.debug(
"get_screenshot_and_compare_picture_similarity t_percent=%s" %
str(t_percent))
return t_percent > expect_percent
def reboot_device(self):
self.pressPowerKey(10)
time.sleep(5)
self.pressPowerKey(2)
time.sleep(40)
g_common_obj.root_on_device()
g_common_obj.remount_device()
os.system("adb shell uiautomator dump /data/local/tmp/uidump.xml"
) #get layout, 20170822 has bug, can't find layout!
g_common_obj.adb_cmd("setprop evs.state 0")
self.backHome()
self.check_home_or_lock_layout()
def init_camera_with_canbox(self):
self.logger.debug("init_camera_with_canbox start")
self.reboot_device()
# self.init_camera_c_with_canbox()
# self.get_screenshot(self.before_screen_file_path)
# self.camera_event_array[-1]
# for i in range(self.camera_event_count):
# self.change_canbox_0_event()
# time.sleep(1)
# t_result = self.get_screenshot_and_compare_picture_similarity(self.before_screen_file_path, self.after_screen_file_path)
# self.camera_event_array[self.now_camera_event] = (0 if t_result else 1)
# self.logger.debug("camera_event_array=%s" % str(self.camera_event_array))
# if sum(self.camera_event_array) > self.camera_event_count / 2:
# for i in range(self.camera_event_count):
# self.camera_event_array[i] = (0 if self.camera_event_array[i]==1 else 1)
# self.logger.debug("camera_event_array=%s" % str(self.camera_event_array))
# assert sum(self.camera_event_array) <= 2, "fail init_camera_with_canbox!"
def init_camera_c_with_canbox(self):
self.logger.debug("init_camera_c_with_canbox start")
cmd_list = [
"stop evs_app", "stop evs_manager", "stop evs-hal-1-0",
"start evs-hal-1-0", "start evs_manager", "start evs_app"
]
for cmd in cmd_list:
g_common_obj.adb_cmd(cmd)
time.sleep(0.5)
def change_camera_0_status(self, need_camera_0_status, check_success=1):
self.logger.debug("change_camera_0_status need_camera_0_status=%s" %
need_camera_0_status)
if check_success == 1:
before_screen_0_status = self.camera_0_event_array[
self.now_camera_0_event][1]
self.get_screenshot(self.before_screen_0_file_path)
i = 0
while need_camera_0_status != self.camera_0_event_array[
self.now_camera_0_event][0]:
i += 1
if i >= len(self.camera_0_event_array):
break
self.change_canbox_0_event()
time.sleep(1)
if i == 0:
self.logger.debug("skip change camera 0 status!")
if check_success == 1:
time.sleep(1)
after_screen_0_status = self.camera_0_event_array[
self.now_camera_0_event][1]
need_status = 1 if before_screen_0_status == after_screen_0_status else 0
t_result = self.get_screenshot_and_compare_picture_similarity(
self.before_screen_0_file_path, self.after_screen_0_file_path)
assert t_result == need_status, "change_camera_0_status failed!"
def change_camera_c_status(self, need_camera_c_status, check_success=1):
self.logger.debug("change_camera_c_status need_camera_c_status=%s" %
need_camera_c_status)
if check_success == 1:
before_screen_c_status = self.camera_c_event_array[
self.now_camera_c_event][1]
self.get_screenshot(self.before_screen_c_file_path)
i = 0
while need_camera_c_status != self.camera_c_event_array[
self.now_camera_c_event][0]:
i += 1
if i >= len(self.camera_c_event_array):
break
self.change_canbox_c_event()
time.sleep(1)
if i == 0:
self.logger.debug("skip change camera c status!")
if check_success == 1:
time.sleep(1)
after_screen_c_status = self.camera_c_event_array[
self.now_camera_c_event][1]
need_status = 1 if before_screen_c_status == after_screen_c_status else 0
t_result = self.get_screenshot_and_compare_picture_similarity(
self.before_screen_c_file_path, self.after_screen_c_file_path)
assert t_result == need_status, "change_camera_c_status failed!"
def startCameraApp(self, check_success=1):
"""
Used to start the camera application
"""
self.logger.debug("launch ivi camera start")
self.change_camera_0_status("GEAR_REVERSE", check_success)
if check_success == 1:
self.logger.debug("launch ivi camera successfully")
else:
self.logger.debug("launch ivi camera, skip check function")
def stopCameraApp(self):
"""
Used to stop the camera application
"""
self.change_camera_0_status("GEAR_NEUTRAL")
self.logger.debug("stop ivi camera app successfully")
def skipAccountLoginLyout(self):
if self.d(textContains="Drive safely").exists:
self.d(text="Owner").click()
time.sleep(3)
def check_home_or_lock_layout(self, check_exist=True):
assert self.isHomeLayoutExists() or self.isLockLayoutExists(
), "Home or Lock layout not exist!"
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)
self.case_result = -1
g_common_obj.root_on_device()
g_common_obj.remount_device()
self.camera_common = CameraCommon()
self.multimedia_setting = MultiMediaSetting(self.camera_common.DEFAULT_CONFIG_FILE)
self.host_path = self.camera_common.getTmpDir()
self.multimedia_scale_test_helper = MultiMediaScaleTestHelper(self.host_path)
self.multimedia_checkiq_helper = MultiMediaCheckiqHelper(self.host_path)
self.android_version = MultiMediaSwitchCameraHelper(skip_import_camera=True).android_version.lower()
self.multimedia_scale_test_helper.scale_test_prepare()
self.camera_common.removeDeivceFile()
self.camera_common.removeDeivceFile(self.multimedia_scale_test_helper.movies_folder_device_path + "*")
self.camera_common.removeFile(self.host_path + "/*.mp4")
self.camera_common.unlockScreen()
self.d = g_common_obj.get_device()
self.skipAccountLoginLyout()
g_common_obj.back_home()
if self.d(text="Got it").exists:
self.d(text="Got it").click.wait()
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()
self.camera_common.removeDeivceFile()
self.camera_common.removeDeivceFile(self.multimedia_scale_test_helper.movies_folder_device_path + "*")
if self.multimedia_scale_test_helper.scale_test_teardown() == 1 or self.case_result == 0:
self.reboot_device()
time.sleep(3)
g_common_obj.back_home()
def skipAccountLoginLyout(self):
if self.d(textContains="Drive safely").exists:
self.d(text="Owner").click()
time.sleep(3)
def reboot_device(self):
adb32._adb_reboot()
# self.skipAccountLoginLyout()
time.sleep(15)
def check_logcat_data(self, data_list, expect_fps):
self.logger.debug("check_logcat_data data_list=%s" % data_list)
if len(data_list) == 0:
return False, -1
i = 0
for t_fps in data_list:
i += 1
t_fps = float(t_fps)
if expect_fps * 0.95 > t_fps or t_fps > expect_fps * 1.05:
if i <= 3:
continue
return False, t_fps
return True, 1
def check_scale_TP_with_similarity(self, cmd_arguments_list, expect_percent=1, generated_jpg_file_rule="screenshot"):
self.case_result = 0
self.case_name = sys._getframe().f_back.f_code.co_name
expect_fps = cmd_arguments_list[0].split(" ")[-1]
self.multimedia_scale_test_helper.check_scale_test_xml(expect_fps, case_name=self.case_name)
self.reboot_device()
if len(cmd_arguments_list) == 1:
cmd_arguments_list *= 4
t_actual_num = 0
t_expect_num = 0
prev_cmd_arguments = ""
t_percent_list = []
for cmd_arguments in cmd_arguments_list:
t_actual_num += 1
expect_fps = cmd_arguments.split(" ")[-1]
# cmd_arguments = cmd_arguments.replace(" " + expect_fps, " 0.0")
self.logger.debug("------loop %s------%s" % (str(t_actual_num), cmd_arguments))
if prev_cmd_arguments == cmd_arguments and self.multimedia_scale_test_helper.generated_reference_library == 1:
continue
if prev_cmd_arguments != cmd_arguments:
t_expect_num += 1
prev_cmd_arguments = cmd_arguments
if self.multimedia_scale_test_helper.generated_reference_library != 1:
jpg_file_name = "%s_%d.jpg" % (self.case_name, t_actual_num)
else:
jpg_file_name = "%s_%d.jpg" % (self.case_name, t_expect_num)
expect_jpg_file_name = "%s_%d.jpg" % (self.case_name, t_expect_num)
if self.multimedia_scale_test_helper.generated_reference_library != 1:
generated_jpg_file_folder = self.multimedia_scale_test_helper.actual_folder
else:
generated_jpg_file_folder = self.multimedia_scale_test_helper.expect_folder
thread_1 = threading.Thread(target=self.multimedia_scale_test_helper.play_and_record_video_with_instrument, args=(cmd_arguments, self.case_name))
thread_1.start()
#self.multimedia_scale_test_helper.play_and_record_video_with_instrument(cmd_arguments)
if generated_jpg_file_rule == "screenshot":
time.sleep(8)
jpg_file_name = jpg_file_name.replace(".jpg", ".png")
expect_jpg_file_name = expect_jpg_file_name.replace(".jpg", ".png")
self.camera_common.getScreenshotAndPullToHost(jpg_file_name, generated_jpg_file_folder)
generated_jpg_file_path = os.path.join(generated_jpg_file_folder, jpg_file_name)
while self.multimedia_scale_test_helper.play_result == -1:
time.sleep(1)
if self.multimedia_scale_test_helper.play_result != 1:
t_percent_list.append((0, generated_jpg_file_path, "play error! play_result=%s" % self.multimedia_scale_test_helper.play_result))
continue
else:
thread_1.join()
if self.multimedia_scale_test_helper.play_result != 1:
t_percent_list.append((0, "play error!", "play_result=%s" % self.multimedia_scale_test_helper.play_result))
continue
movies_file_host_path = self.multimedia_scale_test_helper.pull_video_file_to_host()
generated_jpg_file_path = self.multimedia_scale_test_helper.get_jpg_from_video(movies_file_host_path, jpg_file_name)
self.multimedia_scale_test_helper.play_result = -1
self.logger.debug("check_scale_TP_with_similarity jpg_file_path=%s" % generated_jpg_file_path)
if self.multimedia_scale_test_helper.generated_reference_library != 1:
if "AVM737" in self.case_name:
t_percent_list.append((1, generated_jpg_file_path, "AVM737 playback no crash!"))
continue
if "o" in self.android_version:
t_region=CheckIQ.Region(0, 0, 1900, 1024)
else:
t_region=CheckIQ.Region(max=True)
expect_jpg_file_path = os.path.join(self.multimedia_scale_test_helper.expect_folder, expect_jpg_file_name)
if not os.path.exists(expect_jpg_file_path):
self.multimedia_scale_test_helper.download_reference_library_file(expect_jpg_file_path)
assert os.path.exists(expect_jpg_file_path), "Can't find reference library(%s)! please check it." % expect_jpg_file_path
t_percent = self.multimedia_checkiq_helper.compare_picture_similarity(generated_jpg_file_path, expect_jpg_file_path, t_region)
t_percent_list.append((t_percent, generated_jpg_file_path, expect_jpg_file_path))
if self.multimedia_scale_test_helper.generated_reference_library != 1:
self.logger.debug("check_scale_TP_with_similarity t_percent_list=%s" % str(t_percent_list))
pass_num = 0
t_sum = 0
user_log_dir = g_common_obj.get_user_log_dir()
self.logger.debug("check_scale_TP_with_similarity user_log_dir=%s" % str(user_log_dir))
for t_actual_percent, generated_jpg_file_path, _ in t_percent_list:
t_sum += 1
if t_actual_percent >= expect_percent:
pass_num += 1
elif "!" not in generated_jpg_file_path:
shutil.copy(generated_jpg_file_path, user_log_dir)
case_message_info = "Similarity failed! pass_rate=%.2f%%, t_percent_list=%s" % (pass_num/(t_sum*1.0)*100, t_percent_list)
if "640x480_Progressive" in self.case_name or "720x576_Progressive" in self.case_name:#OAM issue don't need fixed,so ignore it.(sync with sunxue)
pass_num = t_sum if pass_num >= 1 else pass_num
assert pass_num == t_sum, case_message_info
else:
self.logger.debug("case_name generated reference library complete!")
self.case_result = 1
def check_scale_TP_with_fps(self, cmd_arguments_list):
self.case_result = 0
self.case_name = sys._getframe().f_back.f_code.co_name
# assert "o" not in self.android_version, "Feature not merge in BxtP_O"
expect_fps = cmd_arguments_list[0].split(" ")[-1]
self.multimedia_scale_test_helper.check_scale_test_xml(expect_fps, case_name=self.case_name)
self.reboot_device()
g_common_obj.adb_cmd_capture_msg("setprop camera.hal.perf 3")
t_percent_list = []
if "o" in self.android_version:
self.multimedia_logcat_helper = MultiMediaLogcatHelper("adb logcat Camera3HWI:D *:S")
else:
self.multimedia_logcat_helper = MultiMediaLogcatHelper("adb logcat CameraHardwareSoc:D *:S")
for cmd_arguments in cmd_arguments_list:
if "3840 2160" in cmd_arguments:
continue
self.multimedia_logcat_helper.get_logcat_data_start()
self.multimedia_scale_test_helper.play_result = -1
expect_fps = cmd_arguments.split(" ")[-1]
cmd_arguments = cmd_arguments.replace(" " + expect_fps, " 0.0")
thread_1 = threading.Thread(target=self.multimedia_scale_test_helper.play_and_record_video_with_instrument, args=(cmd_arguments, self.case_name))
thread_1.start()
while self.multimedia_scale_test_helper.play_result == -1:
time.sleep(1)
if "o" in self.android_version:
result_list = self.multimedia_logcat_helper.get_logcat_data_end("FPS=(.*) buffcount")
else:
result_list = self.multimedia_logcat_helper.get_logcat_data_end("total fps is (.*),")
if self.multimedia_scale_test_helper.play_result != 1:
t_percent_list.append((0, "cmd=%s, play error!" % cmd_arguments, "play_result=%s" % self.multimedia_scale_test_helper.play_result))
elif len(result_list) == 0:
t_percent_list.append((-1, "find error!", "can't find fps in logcat! cmd_arguments=%s" % cmd_arguments))
else:
expect_fps = float(expect_fps)
check_logcat_data_result, error_fps = self.check_logcat_data(result_list, expect_fps)
if check_logcat_data_result:
t_percent_list.append((1, "cmd=%s, pass!" % cmd_arguments, "expect_fps=%s, result_list=%s" % (expect_fps, result_list)))
else:
t_percent_list.append((-2, "cmd=%s, fps error!" % cmd_arguments, "error_fps=%s, expect_fps=%s, result_list=%s" % (error_fps, expect_fps, result_list)))
self.logger.debug("check_scale_TP_with_fps t_percent_list=%s" % str(t_percent_list))
pass_num = 0
t_sum = 0
for t_result, _, _ in t_percent_list:
t_sum += 1
if t_result == 1:
pass_num += 1
case_message_info = "check fps failed! pass_rate=%.2f%%, t_percent_list=%s" % (pass_num/(t_sum*1.0)*100, t_percent_list)
assert pass_num == t_sum, case_message_info
self.case_result = 1
class CameraBenchTest(CameraTestBase):
"""
@summary: This test used to test camera function
"""
def setUp(self):
"""
@summary: set up
@return: None
"""
super(CameraBenchTest, self).setUp()
self._test_name = __name__
print "[Setup]: %s" % self._test_name
def tearDown(self):
"""
@summary: tearDown
@return: None
"""
super(CameraBenchTest, self).tearDown()
print "[Teardown]: %s" % self._test_name
g_common_obj.stop_exp_handle()
time.sleep(3)
def appPrepare(self):
self.camera = CameraCommon().switchPlatform(None, False, True, False,
True)
# self.camera = RefCam2Camera()
self.common = CameraCommon()
self.multimedia_setting = MultiMediaSetting(
CameraCommon.DEFAULT_CONFIG_FILE)
# self.camera = self.common.switchPlatform()
self.checkImage = CheckImage()
self.video = CheckVideo()
# self.checkIQ = CheckIQ()
self.host_path = self.common.getTmpDir()
self.makefileTime = self.common.makefileTime
self.camera_dir = self.common.camera_dir
self.common.removeDeivceFile()
self.common.removeFile(self.host_path + "/*")
self.camera.cleanMediaFiles()
# self.common.setOrientationToVertical()
self.logger.debug("app prepare successfully")
self.device = self.common.initDevice()
self.common.resetDevice(self.device)
def checkFileCorrupt(self, mediaFileCount=1):
return self.common.checkFileCorrupt(mediaFileCount)
def cameraExtendPanoramaRearLeft2RightAutoStopTest(self):
try:
self.appPrepare()
# self.common.controlLightBox(1)
# self.common.controlLightBox(6)
# device = self.common.initDevice()
self.camera.startCameraApp()
self.camera.switchRearOrFront("Back")
self.camera.setCaptureMode("Panorama")
self.camera.capturePhoto(1, False)
time.sleep(3)
self.common.rotateDevice(self.device, -180)
self.common.resetDevice(self.device)
self.checkFileCorrupt()
# self.common.controlLightBox(6)
# self.common.controlLightBox(1)
except Exception as e:
self.common.resetDevice(self.device)
self.common.checkCameraCrash()
self.assertTrue(False, e)
def cameraFaceTrackTurnOnAndOffTest(self, lens):
try:
self.appPrepare()
self.camera.startCameraApp()
self.camera.switchRearOrFront(lens)
if lens == "Back":
self.common.rotateDevice(self.device, -90)
else:
self.common.rotateDevice(self.device, 90)
self.camera.faceDetectionOnAndOff()
time.sleep(5)
self.common.clickScreenCenter()
self.common.getScreenshotAndPullToHost("sc_enable_ft1.png",
self.host_path)
self.camera.faceDetectionOnAndOff()
time.sleep(5)
self.common.clickScreenCenter()
self.common.pressBack(2)
self.camera.startCameraApp()
self.common.getScreenshotAndPullToHost("sc_disable_ft2.png",
self.host_path)
self.camera.faceDetectionOnAndOff()
time.sleep(5)
self.common.clickScreenCenter()
self.common.getScreenshotAndPullToHost("sc_enable_ft2.png",
self.host_path)
self.common.resetDevice(self.device)
remotejarFile = self.multimedia_setting.download_file_to_host(
"Multimedia_Camera/apk/IQCheck")
print remotejarFile
iqcheckDir = self.host_path + os.sep + "IQCheck"
print iqcheckDir
if os.path.exists(iqcheckDir) == False:
os.system("cp " + remotejarFile + " " + iqcheckDir)
os.system("chmod 777 " + iqcheckDir)
checkIQ = CheckIQ("", self.host_path)
l = self.camera.getFOVRegion()
region = CheckIQ.Region(l[0], l[1], l[2], l[3], False)
enable_number1 = checkIQ.detectRect(
self.host_path + "/sc_enable_ft1.png", region)
disable_number = checkIQ.detectRect(
self.host_path + "/sc_disable_ft2.png", region)
enable_number2 = checkIQ.detectRect(
self.host_path + "/sc_enable_ft2.png", region)
if enable_number1 > disable_number:
self.logger.debug("face detect success")
else:
os.system("cp " + self.host_path + "/sc_enable_ft1.png " +
g_common_obj.get_user_log_dir())
os.system("cp " + self.host_path + "/sc_disable_ft2.png " +
g_common_obj.get_user_log_dir())
self.logger.debug("enable_number1=" + str(enable_number1))
self.logger.debug("disable_number=" + str(disable_number))
self.assertTrue(False, "face detect failure")
if enable_number2 > disable_number:
self.logger.debug("face detect success")
else:
os.system("cp " + self.host_path + "/sc_enable_ft1.png " +
g_common_obj.get_user_log_dir())
os.system("cp " + self.host_path + "/sc_disable_ft2.png " +
g_common_obj.get_user_log_dir())
self.logger.debug("enable_number2=" + str(enable_number2))
self.logger.debug("disable_number=" + str(disable_number))
self.assertTrue(False, "face detect failure")
# print self.checkIQ.detectRect("/tmp/logs/sc_disable_ft2.png",self.checkIQ.Region(self.camera.getFOVRegion(),False))
# print self.checkIQ.detectRect("/tmp/logs/sc_enable_ft2.png", self.checkIQ.Region(self.camera.getFOVRegion(), False))
except Exception as e:
self.common.resetDevice(self.device)
self.common.checkCameraCrash()
self.assertTrue(False, e)
def cameraSceneDetectPortraitCaptureTest(self):
try:
self.appPrepare()
self.camera.startCameraApp()
self.camera.switchRearOrFront("Back")
self.camera.capturePhoto()
info = self.checkFileCorrupt()[0]
value = info.get("Scene Capture Type")
if None != value:
if value != "Standard":
self.assertTrue(False,
"scene capture type is not standard")
else:
self.assertTrue(False, "scene capture type info is none")
self.common.removeDeivceFile()
self.camera.setCaptureMode("Smart")
self.common.clickScreenCenter()
self.camera.capturePhoto()
info = self.checkFileCorrupt()[0]
value = info.get("Scene Capture Type")
if None != value:
if value != "Portrait":
self.assertTrue(False,
"scene capture type is not portrait")
else:
self.logger.debug(
"check scene capture type is portrait success")
else:
self.assertTrue(False, "scene capture type info is none")
self.camera.switchRearOrFront("Front")
self.camera.capturePhoto()
info = self.checkFileCorrupt()[0]
value = info.get("Scene Capture Type")
if None != value:
# print "=====================front value3=" + value
if value != "Standard":
self.assertTrue(False,
"scene capture type is not standard")
else:
self.assertTrue(False, "scene capture type info is none")
self.common.removeDeivceFile()
self.camera.setCaptureMode("Smart")
self.common.clickScreenCenter()
self.camera.capturePhoto()
info = self.checkFileCorrupt()[0]
value = info.get("Scene Capture Type")
if None != value:
# print "====================front value4=" + value
if value != "Portrait":
self.assertTrue(False,
"scene capture type is not portrait")
else:
self.logger.debug(
"check scene capture type is portrait success")
else:
self.assertTrue(False, "scene capture type info is none")
self.common.resetDevice(self.device)
except Exception as e:
self.common.resetDevice(self.device)
self.common.checkCameraCrash()
self.assertTrue(False, e)
def cameraSmileShotSmileDetectTest(self, lens):
try:
self.appPrepare()
self.camera.startCameraApp()
self.camera.switchRearOrFront(lens)
if lens == "Back":
self.common.rotateDevice(self.device, -90)
else:
self.common.rotateDevice(self.device, 90)
self.camera.setCaptureMode("Smile")
time.sleep(10)
if self.common.checkDeviceFile():
self.assertTrue(False, "file exists, check file failed")
self.camera.capturePhoto()
self.checkFileCorrupt()
self.common.removeDeivceFile()
if lens == "Back":
self.common.rotateDevice(self.device, 90)
else:
self.common.rotateDevice(self.device, 90)
if not self.common.checkDeviceFile():
self.assertTrue(False, "file not exists, check file failed")
self.checkFileCorrupt()
self.common.resetDevice(self.device)
except Exception as e:
self.common.resetDevice(self.device)
self.common.checkCameraCrash()
self.assertTrue(False, e)
def test_Camera_ExtendPanorama_Rear_Left2Right_AutoStop(self):
self.cameraExtendPanoramaRearLeft2RightAutoStopTest()
def test_Camera_FaceTrack_Front_TurnOnAndOff(self):
self.cameraFaceTrackTurnOnAndOffTest("Front")
def test_Camera_FaceTrack_Rear_TurnOnAndOff(self):
self.cameraFaceTrackTurnOnAndOffTest("Back")
def test_Camera_SceneDetect_Portrait_Capture(self):
self.cameraSceneDetectPortraitCaptureTest()
def test_Camera_SmileShot_Front_SmileDetect(self):
self.cameraSmileShotSmileDetectTest("Front")
def test_Camera_SmileShot_Rear_SmileDetect(self):
self.cameraSmileShotSmileDetectTest("Back")
