| # Copyright (c) 2014 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 LICENSE file. |
| |
| import os |
| import tempfile |
| |
| from PIL import Image |
| |
| from autotest_lib.client.cros.multimedia.display_helper import DisplayInfo |
| |
| |
| class DisplayClient(object): |
| """DisplayClient is a layer to control display logic over a remote DUT. |
| |
| The Autotest host object representing the remote DUT, passed to this |
| class on initialization, can be accessed from its _client property. |
| |
| """ |
| def __init__(self, host, multimedia_client_connection): |
| """Construct a DisplayClient. |
| |
| @param host: Host object representing a remote host. |
| @param multimedia_client_connection: MultimediaClientConnection object. |
| """ |
| self._client = host |
| self._connection = multimedia_client_connection |
| |
| |
| @property |
| def _display_proxy(self): |
| """Gets the proxy to DUT display utility. |
| |
| @return XML RPC proxy to DUT display utility. |
| """ |
| return self._connection.xmlrpc_proxy.display |
| |
| |
| def connect(self): |
| """Connects the XML-RPC proxy on the client again.""" |
| # TODO(waihong): Move this method to a better place. |
| self._connection.connect() |
| |
| |
| def get_external_connector_name(self): |
| """Gets the name of the external output connector. |
| |
| @return The external output connector name as a string; None if nothing |
| is connected. |
| """ |
| result = self._display_proxy.get_external_connector_name() |
| return result if result else None |
| |
| |
| def get_internal_connector_name(self): |
| """Gets the name of the internal output connector. |
| |
| @return The internal output connector name as a string. |
| """ |
| return self._display_proxy.get_internal_connector_name() |
| |
| |
| def load_calibration_image(self, resolution): |
| """Load a full screen calibration image from the HTTP server. |
| |
| @param resolution: A tuple (width, height) of resolution. |
| """ |
| self._display_proxy.load_calibration_image(resolution) |
| |
| |
| def close_tab(self, index=-1): |
| """Closes the tab of the given index. |
| |
| @param index: The tab index to close. Defaults to the last tab. |
| """ |
| return self._display_proxy.close_tab(index) |
| |
| |
| def is_mirrored_enabled(self): |
| """Checks the mirrored state. |
| |
| @return True if mirrored mode is enabled. |
| """ |
| return self._display_proxy.is_mirrored_enabled() |
| |
| |
| def set_mirrored(self, is_mirrored): |
| """Sets mirrored mode. |
| |
| @param is_mirrored: True or False to indicate mirrored state. |
| """ |
| return self._display_proxy.set_mirrored(is_mirrored) |
| |
| |
| def suspend_resume(self, suspend_time=10): |
| """Suspends the DUT for a given time in second. |
| |
| @param suspend_time: Suspend time in second, default: 10s. |
| """ |
| # TODO(waihong): Use other general API instead of this RPC. |
| return self._display_proxy.suspend_resume(suspend_time) |
| |
| |
| def suspend_resume_bg(self, suspend_time=10): |
| """Suspends the DUT for a given time in second in the background. |
| |
| @param suspend_time: Suspend time in second, default: 10s. |
| """ |
| # TODO(waihong): Use other general API instead of this RPC. |
| return self._display_proxy.suspend_resume_bg(suspend_time) |
| |
| |
| def wait_for_output(self, output): |
| """Waits for the specified output to be connected. |
| |
| @param output: The output name as a string. |
| """ |
| self._display_proxy.wait_output_connected(output) |
| |
| |
| def hide_cursor(self): |
| """Hides mouse cursor by sending a keystroke.""" |
| self._display_proxy.press_key('Up') |
| |
| |
| def _read_root_window_rect(self, w, h, x, y): |
| """Reads the given rectangle from the X root window. |
| |
| @param w: The width of the rectangle to read. |
| @param h: The height of the rectangle to read. |
| @param x: The x coordinate. |
| @param y: The y coordinate. |
| |
| @return: An Image object. |
| """ |
| with tempfile.NamedTemporaryFile(suffix='.rgb') as f: |
| basename = os.path.basename(f.name) |
| remote_path = os.path.join('/tmp', basename) |
| box = (x, y, x + w, y + h) |
| self._display_proxy.take_screenshot_crop(remote_path, box) |
| self._client.get_file(remote_path, f.name) |
| return Image.fromstring('RGB', (w, h), open(f.name).read()) |
| |
| |
| def get_internal_display_resolution(self): |
| """Gets the resolution of internal display on framebuffer. |
| |
| @return The resolution tuple (width, height). None if any error. |
| """ |
| connector = self.get_internal_connector_name() |
| if not connector: |
| return None |
| w, h, _, _ = self._display_proxy.get_resolution(connector) |
| return (w, h) |
| |
| |
| def capture_internal_screen(self): |
| """Captures the internal screen framebuffer. |
| |
| @return: An Image object. None if any error. |
| """ |
| connector = self.get_internal_connector_name() |
| if not connector: |
| return None |
| return self._read_root_window_rect( |
| *self._display_proxy.get_resolution(connector)) |
| |
| |
| def capture_external_screen(self): |
| """Captures the external screen framebuffer. |
| |
| @return: An Image object. |
| """ |
| output = self.get_external_connector_name() |
| w, h, x, y = self._display_proxy.get_resolution(output) |
| return self._read_root_window_rect(w, h, x, y) |
| |
| |
| def get_resolution(self, connector=None): |
| """Gets the resolution of the specified screen. |
| |
| @param connector: name of the connector of the target screen; if not |
| specified, get_external_connector_name() is used. |
| @return The resolution tuple (width, height) |
| """ |
| if not connector: |
| connector = self.get_external_connector_name() |
| width, height, _, _ = self._display_proxy.get_resolution(connector) |
| return (width, height) |
| |
| |
| def set_resolution(self, display_index, width, height): |
| """Sets the resolution on the specified display. |
| |
| @param display_index: index of the display to set resolutions for. |
| @param width: width of the resolution |
| @param height: height of the resolution |
| """ |
| self._display_proxy.set_resolution( |
| display_index, width, height) |
| |
| |
| def get_display_info(self): |
| """Gets the information of all the displays that are connected to the |
| DUT. |
| |
| @return: list of object DisplayInfo for display informtion |
| """ |
| return map(DisplayInfo, self._display_proxy.get_display_info()) |
| |
| |
| def get_display_modes(self, display_index): |
| """Gets the display modes of the specified display. |
| |
| @param display_index: index of the display to get modes from; the index |
| is from the DisplayInfo list obtained by get_display_info(). |
| |
| @return: list of DisplayMode dicts. |
| """ |
| return self._display_proxy.get_display_modes(display_index) |
| |
| |
| def get_available_resolutions(self, display_index): |
| """Gets the resolutions from the specified display. |
| |
| @return a list of (width, height) tuples. |
| """ |
| # Start from M38 (refer to http://codereview.chromium.org/417113012), |
| # a DisplayMode dict contains 'originalWidth'/'originalHeight' |
| # in addition to 'width'/'height'. |
| # OriginalWidth/originalHeight is what is supported by the display |
| # while width/height is what is shown to users in the display setting. |
| modes = self.get_display_modes(display_index) |
| if modes: |
| if 'originalWidth' in modes[0]: |
| # M38 or newer |
| # TODO(tingyuan): fix loading image for cases where original |
| # width/height is different from width/height. |
| return list(set([(mode['originalWidth'], mode['originalHeight']) |
| for mode in modes])) |
| |
| # pre-M38 |
| return [(mode['width'], mode['height']) for mode in modes |
| if 'scale' not in mode] |
