| # Copyright 2018 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LISENCE file. |
| |
| import logging |
| import re |
| import os |
| import time |
| |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.server import test |
| |
| CEC_COMMAND = "sudo -u chronos dbus-send --system --print-reply \ |
| --type=method_call --dest=org.chromium.CecService \ |
| /org/chromium/CecService org.chromium.CecService." |
| CEC_CMD_STANDBY = "SendStandByToAllDevices" |
| CEC_CMD_IMAGEON = "SendWakeUpToAllDevices" |
| CEC_CMD_DISP_STATUS = "GetTvsPowerStatus" |
| |
| CHAMELEON_ROOT = '/home/root/' |
| |
| STATUS_ERROR = 0 |
| STATUS_ON = 3 |
| STATUS_OFF = 4 |
| STATUS_TO_ON = 5 |
| STATUS_TO_OFF = 6 |
| |
| class enterprise_CFM_CEC(test.test): |
| """ |
| Test CEC feature for display power control. |
| """ |
| |
| version = 1 |
| # TODO: how to get whether it connects to chameleon board |
| chameleon_mode = True |
| |
| def initialize(self): |
| """ initialize is a stub function.""" |
| pass |
| |
| # Simply run a command in machine and return result messages. |
| def _shcmd(self, cmd): |
| """ A simple wrapper for remote shell command execution. |
| @param cmd: shell command for Fizz |
| """ |
| logging.info('CMD: [%s]', cmd) |
| try: |
| result = self._client.run(cmd) |
| if result is None: |
| return result |
| if result.stderr: |
| logging.info('CMD ERR:\n' + result.stderr) |
| logging.info('CMD OUT:\n' + result.stdout) |
| return result |
| except Exception as e: |
| logging.info('run command failed. ' + str(e)) |
| |
| def run_once(self, host=None): |
| """ |
| Test scenario: |
| |
| If system does not support cec port, we simply throw an exception. |
| |
| Generally we are using the build-in cecservice for this test. This |
| service supports multiple features including turning TV(display) |
| power on/off and monitor its power status. |
| |
| Following is test plan: |
| 0.0 Copy two python files to chameleon |
| 0.1 enable chameleon as hdmi mode |
| 0.2 run cec service on chameleon |
| |
| 0.3 Make sure chrome box is running cecservice |
| 0.4 Make sure chrome box's /dev/cecX is open |
| 0.5 Run TV power status to check configuration correct |
| (end of step 0) |
| |
| |
| 1.0 Send TV turn-off command |
| 1.1 Check TV power status to check whether it is off. |
| (end of step 1) |
| |
| 2.0 Send TV turn-on command |
| 2.1 Check TV power status to check whether it is on. |
| (end of step 2) |
| At every end of step, we have to decide whether we stop this test |
| right now or continue next ones. |
| Note that we could turn on TV first and then turn off it, |
| according to its initial power status. |
| |
| 3.0 Stop cec service on chameleon |
| 3.1 Remove python files from chameleon |
| |
| @param host: host object machine. |
| """ |
| |
| self._client = host |
| self.chameleon = host.chameleon |
| |
| ## TODO check same port |
| #Step 0.0 - 0.2 |
| self.copy_cecservice() |
| self.cec_service_init() |
| |
| |
| # Step 0.3 - 0.5 |
| if not self.is_cecservice_running(): |
| self.cec_cleanup() |
| raise error.TestFail("CEC service is not running.") |
| if not self.is_cec_available(): |
| self.cec_cleanup() |
| raise error.TestFail("/dev/cecX port is not open.") |
| status = self.check_display_status() |
| if STATUS_ERROR == status: |
| self.cec_cleanup() |
| raise error.TestFail("CEC communication is not good.") |
| |
| # Step 1 & 2 |
| if STATUS_ON == status: |
| self.test_turn_off() |
| if not self.chameleon_mode: |
| time.sleep(5) |
| self.test_turn_on() |
| else: |
| self.test_turn_on() |
| if not self.chameleon_mode: |
| time.sleep(5) |
| self.test_turn_off() |
| |
| # Step 3 |
| self.cec_cleanup() |
| |
| # Chameleon |
| def copy_cecservice(self): |
| """ copy python files under ./chameleon_cecservice to chameleon. |
| In that folder, we have two files for cecservice. |
| """ |
| current_dir = os.path.dirname(os.path.realpath(__file__)) |
| base_dir = current_dir + '/chameleon_cecservice/' |
| self.chameleon.host.send_file(base_dir + 'cec_service', CHAMELEON_ROOT) |
| self.chameleon.host.send_file(base_dir + 'it6803.py', CHAMELEON_ROOT) |
| |
| def cec_service_init(self): |
| """ Setup chameleon board as a hdmi mode. |
| Run cec service on chameleon |
| """ |
| self.chameleon.host.run('/home/root/setup hdmi') |
| self.chameleon.host.run('(/home/root/cec_service start) '\ |
| '</dev/null >/dev/null 2>&1 & echo -n $!') |
| |
| def cec_cleanup(self): |
| """ Stop cec service on chameleon. |
| Delete files new coming on chameleon. |
| """ |
| if self.chameleon_mode: |
| stop_cmd = 'kill $(ps | grep \'cec_service\' | awk \'{print $1}\')' |
| self.chameleon.host.run(stop_cmd) |
| cleanup_cmd = 'rm /home/root/cec_service /home/root/it6803*' |
| self.chameleon.host.run(cleanup_cmd) |
| |
| # Fizz |
| def is_cecservice_running(self): |
| """ try to confirm that current box is running cecservice. |
| @return: whether cecservice is running in Fizz. |
| """ |
| cmd = 'initctl list | grep cecservice' |
| result = self._shcmd(cmd) |
| if result is None: |
| return False; |
| if "running" not in result.stdout: |
| return False; |
| return True; |
| |
| def is_cec_available(self): |
| """ try to get whether the system makes /dev/cecX open. |
| @return: whether /dev/cecX is open in Fizz |
| """ |
| cmd = "ls /dev/cec*" |
| result = self._shcmd(cmd) |
| if result is None: |
| return False; |
| return True; |
| |
| def check_display_status(self): |
| """ try to confirm that current box connected to a display |
| which supports cec feature. |
| @return: current display power status |
| """ |
| cmd = CEC_COMMAND + CEC_CMD_DISP_STATUS |
| result = self._shcmd(cmd).stdout |
| status = re.findall('int32 \\d', result) |
| for s in status: |
| code = int(s[-1]); |
| if code == STATUS_ON or code == STATUS_TO_ON: |
| return STATUS_ON |
| if code == STATUS_OFF or code == STATUS_TO_OFF: |
| return STATUS_OFF |
| return STATUS_ERROR |
| |
| def display_on(self): |
| """ send a power turn on cec message """ |
| self._shcmd(CEC_COMMAND + CEC_CMD_IMAGEON) |
| |
| def display_off(self): |
| """ send a power turn off cec message""" |
| self._shcmd(CEC_COMMAND + CEC_CMD_STANDBY) |
| |
| def test_turn_on(self): |
| """ test sending turn_on cec message process. """ |
| self.display_on() |
| if not self.chameleon_mode: |
| time.sleep(10) |
| status = self.check_display_status() |
| if STATUS_ON != status: |
| self.cec_cleanup() |
| raise error.TestFail("CEC display image on does not work.") |
| |
| def test_turn_off(self): |
| """ test sending turn_off cec message process. """ |
| self.display_off() |
| if not self.chameleon_mode: |
| time.sleep(1) |
| status = self.check_display_status() |
| if STATUS_OFF != status: |
| self.cec_cleanup() |
| raise error.TestFail("CEC display standby does not work.") |
