| # |
| # Copyright (C) 2016 The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| |
| import json |
| import logging |
| import os |
| import socket |
| import time |
| |
| from vts.proto import AndroidSystemControlMessage_pb2 as SysMsg_pb2 |
| from vts.proto import ComponentSpecificationMessage_pb2 as CompSpecMsg_pb2 |
| from vts.proto import VtsResourceControllerMessage_pb2 as ResControlMsg_pb2 |
| from vts.runners.host import const |
| from vts.runners.host import errors |
| from vts.utils.python.mirror import mirror_object |
| |
| from google.protobuf import text_format |
| |
| TARGET_IP = os.environ.get("TARGET_IP", None) |
| TARGET_PORT = os.environ.get("TARGET_PORT", None) |
| _DEFAULT_SOCKET_TIMEOUT_SECS = 1800 |
| _SOCKET_CONN_TIMEOUT_SECS = 60 |
| _SOCKET_CONN_RETRY_NUMBER = 5 |
| COMMAND_TYPE_NAME = { |
| 1: "LIST_HALS", |
| 2: "SET_HOST_INFO", |
| 101: "CHECK_DRIVER_SERVICE", |
| 102: "LAUNCH_DRIVER_SERVICE", |
| 103: "VTS_AGENT_COMMAND_READ_SPECIFICATION", |
| 201: "LIST_APIS", |
| 202: "CALL_API", |
| 203: "VTS_AGENT_COMMAND_GET_ATTRIBUTE", |
| 301: "VTS_AGENT_COMMAND_EXECUTE_SHELL_COMMAND", |
| 401: "VTS_FMQ_COMMAND", |
| 402: "VTS_HIDL_MEMORY_COMMAND", |
| 403: "VTS_HIDL_HANDLE_COMMAND" |
| } |
| |
| |
| class VtsTcpClient(object): |
| """VTS TCP Client class. |
| |
| Attribute: |
| NO_RESPONSE_MSG: string, error message when there is no response |
| from device. |
| FAIL_RESPONSE_MSG: string, error message when the device sends back |
| a failure message. |
| connection: a TCP socket instance. |
| channel: a file to write and read data. |
| error: string, ongoing tcp connection error. None means no error. |
| _mode: the connection mode (adb_forwarding or ssh_tunnel) |
| timeout: tcp connection timeout. |
| """ |
| |
| NO_RESPONSE_MSG = "Framework error: TCP client did not receive response from device." |
| FAIL_RESPONSE_MSG = "Framework error: TCP client received unsuccessful response code." |
| |
| def __init__(self, |
| mode="adb_forwarding", |
| timeout=_DEFAULT_SOCKET_TIMEOUT_SECS): |
| self.connection = None |
| self.channel = None |
| self._mode = mode |
| self.timeout = timeout |
| self.error = None |
| |
| @property |
| def timeout(self): |
| """Get TCP connection timeout. |
| |
| This function assumes timeout property setter is in __init__before |
| any getter calls. |
| |
| Returns: |
| int, timeout |
| """ |
| return self._timeout |
| |
| @timeout.setter |
| def timeout(self, timeout): |
| """Set TCP connection timeout. |
| |
| Args: |
| timeout: int, TCP connection timeout in seconds. |
| """ |
| self._timeout = timeout |
| |
| def Heal(self): |
| """Performs a self healing. |
| |
| Includes self diagnosis that looks for any framework errors. |
| |
| Returns: |
| bool, True if everything is ok; False otherwise. |
| """ |
| res = self.error is None |
| |
| if not res: |
| logging.error('Self diagnosis found problems in TCP client: %s', self.error) |
| |
| return res |
| |
| def Connect(self, |
| ip=TARGET_IP, |
| command_port=TARGET_PORT, |
| callback_port=None, |
| retry=_SOCKET_CONN_RETRY_NUMBER, |
| timeout=None): |
| """Connects to a target device. |
| |
| Args: |
| ip: string, the IP address of a target device. |
| command_port: int, the TCP port which can be used to connect to |
| a target device. |
| callback_port: int, the TCP port number of a host-side callback |
| server. |
| retry: int, the number of times to retry connecting before giving |
| up. |
| timeout: tcp connection timeout. |
| |
| Returns: |
| True if success, False otherwise |
| |
| Raises: |
| socket.error when the connection fails. |
| """ |
| if not command_port: |
| logging.error("ip %s, command_port %s, callback_port %s invalid", |
| ip, command_port, callback_port) |
| return False |
| |
| for i in xrange(retry): |
| connection_timeout = self._timeout if timeout is None else timeout |
| try: |
| self.connection = socket.create_connection( |
| (ip, command_port), timeout=connection_timeout) |
| break |
| except socket.error as e: |
| # Wait a bit and retry. |
| logging.exception("Connect failed %s", e) |
| time.sleep(1) |
| if i + 1 == retry: |
| raise errors.VtsTcpClientCreationError( |
| "Couldn't connect to %s:%s" % (ip, command_port)) |
| self.channel = self.connection.makefile(mode="brw") |
| |
| if callback_port is not None: |
| self.SendCommand( |
| SysMsg_pb2.SET_HOST_INFO, callback_port=callback_port) |
| resp = self.RecvResponse() |
| if (resp.response_code != SysMsg_pb2.SUCCESS): |
| return False |
| return True |
| |
| def Disconnect(self): |
| """Disconnects from the target device. |
| |
| TODO(yim): Send a msg to the target side to teardown handler session |
| and release memory before closing the socket. |
| """ |
| if self.connection is not None: |
| self.channel = None |
| self.connection.close() |
| self.connection = None |
| |
| def ListHals(self, base_paths): |
| """RPC to LIST_HALS.""" |
| self.SendCommand(SysMsg_pb2.LIST_HALS, paths=base_paths) |
| resp = self.RecvResponse() |
| if (resp.response_code == SysMsg_pb2.SUCCESS): |
| return resp.file_names |
| return None |
| |
| def CheckDriverService(self, service_name): |
| """RPC to CHECK_DRIVER_SERVICE.""" |
| self.SendCommand( |
| SysMsg_pb2.CHECK_DRIVER_SERVICE, service_name=service_name) |
| resp = self.RecvResponse() |
| return (resp.response_code == SysMsg_pb2.SUCCESS) |
| |
| def LaunchDriverService(self, |
| driver_type, |
| service_name, |
| bits, |
| file_path=None, |
| target_class=None, |
| target_type=None, |
| target_version_major=None, |
| target_version_minor=None, |
| target_package=None, |
| target_component_name=None, |
| hw_binder_service_name=None, |
| is_test_hal=None): |
| """RPC to LAUNCH_DRIVER_SERVICE. |
| |
| Args: |
| driver_type: enum, type of the driver (shared lib, shell). |
| service_name: string, binder service name. |
| bits: int, whether a target driver binary is 64-bits or 32-bits. |
| file_path: string, the name of a target. |
| target_class: int, target class. |
| target_type: int, target type. |
| target_version_major: int, HAL major version, e.g. 1.0 -> 1. |
| target_version_minor: int, HAL minor version, e.g. 1.0 -> 0. |
| target_package: string, package name of a HIDL HAL. |
| target_component_name: string, name of a target component. |
| hw_binder_service_name: name of a HW Binder service to use. |
| is_test_hal: bool, whether the HAL service is a test HAL |
| (e.g. msgq). |
| |
| Returns: |
| response code, -1 or 0 on failure, other values on success. |
| """ |
| logging.debug("service_name: %s", service_name) |
| logging.debug("file_path: %s", file_path) |
| logging.debug("bits: %s", bits) |
| logging.debug("driver_type: %s", driver_type) |
| self.SendCommand( |
| SysMsg_pb2.LAUNCH_DRIVER_SERVICE, |
| driver_type=driver_type, |
| service_name=service_name, |
| bits=bits, |
| file_path=file_path, |
| target_class=target_class, |
| target_type=target_type, |
| target_version_major=target_version_major, |
| target_version_minor=target_version_minor, |
| target_package=target_package, |
| target_component_name=target_component_name, |
| hw_binder_service_name=hw_binder_service_name, |
| is_test_hal=is_test_hal) |
| resp = self.RecvResponse() |
| logging.debug("resp for LAUNCH_DRIVER_SERVICE: %s", resp) |
| if driver_type == SysMsg_pb2.VTS_DRIVER_TYPE_HAL_HIDL \ |
| or driver_type == SysMsg_pb2.VTS_DRIVER_TYPE_HAL_CONVENTIONAL \ |
| or driver_type == SysMsg_pb2.VTS_DRIVER_TYPE_HAL_LEGACY: |
| if resp.response_code == SysMsg_pb2.SUCCESS: |
| return int(resp.result) |
| else: |
| return -1 |
| else: |
| return (resp.response_code == SysMsg_pb2.SUCCESS) |
| |
| def ListApis(self): |
| """RPC to LIST_APIS.""" |
| self.SendCommand(SysMsg_pb2.LIST_APIS) |
| resp = self.RecvResponse() |
| logging.debug("resp for LIST_APIS: %s", resp) |
| if (resp.response_code == SysMsg_pb2.SUCCESS): |
| return resp.spec |
| return None |
| |
| def GetPythonDataOfVariableSpecMsg(self, var_spec_msg): |
| """Returns the python native data structure for a given message. |
| |
| Args: |
| var_spec_msg: VariableSpecificationMessage |
| |
| Returns: |
| python native data structure (e.g., string, integer, list). |
| |
| Raises: |
| VtsUnsupportedTypeError if unsupported type is specified. |
| VtsMalformedProtoStringError if StringDataValueMessage is |
| not populated. |
| """ |
| if var_spec_msg.type == CompSpecMsg_pb2.TYPE_SCALAR: |
| scalar_type = getattr(var_spec_msg, "scalar_type", "") |
| if scalar_type: |
| return getattr(var_spec_msg.scalar_value, scalar_type) |
| elif var_spec_msg.type == CompSpecMsg_pb2.TYPE_ENUM: |
| scalar_type = getattr(var_spec_msg, "scalar_type", "") |
| if scalar_type: |
| return getattr(var_spec_msg.scalar_value, scalar_type) |
| else: |
| return var_spec_msg.scalar_value.int32_t |
| elif var_spec_msg.type == CompSpecMsg_pb2.TYPE_STRING: |
| if hasattr(var_spec_msg, "string_value"): |
| return getattr(var_spec_msg.string_value, "message", "") |
| raise errors.VtsMalformedProtoStringError() |
| elif var_spec_msg.type == CompSpecMsg_pb2.TYPE_STRUCT: |
| result = {} |
| index = 1 |
| for struct_value in var_spec_msg.struct_value: |
| if len(struct_value.name) > 0: |
| result[struct_value. |
| name] = self.GetPythonDataOfVariableSpecMsg( |
| struct_value) |
| else: |
| result["attribute%d" % |
| index] = self.GetPythonDataOfVariableSpecMsg( |
| struct_value) |
| index += 1 |
| return result |
| elif var_spec_msg.type == CompSpecMsg_pb2.TYPE_UNION: |
| result = {} |
| index = 1 |
| for union_value in var_spec_msg.union_value: |
| if len(union_value.name) > 0: |
| result[union_value. |
| name] = self.GetPythonDataOfVariableSpecMsg( |
| union_value) |
| else: |
| result["attribute%d" % |
| index] = self.GetPythonDataOfVariableSpecMsg( |
| union_value) |
| index += 1 |
| return result |
| elif (var_spec_msg.type == CompSpecMsg_pb2.TYPE_VECTOR |
| or var_spec_msg.type == CompSpecMsg_pb2.TYPE_ARRAY): |
| result = [] |
| for vector_value in var_spec_msg.vector_value: |
| result.append( |
| self.GetPythonDataOfVariableSpecMsg(vector_value)) |
| return result |
| elif (var_spec_msg.type == CompSpecMsg_pb2.TYPE_HIDL_INTERFACE |
| or var_spec_msg.type == CompSpecMsg_pb2.TYPE_FMQ_SYNC |
| or var_spec_msg.type == CompSpecMsg_pb2.TYPE_FMQ_UNSYNC |
| or var_spec_msg.type == CompSpecMsg_pb2.TYPE_HIDL_MEMORY |
| or var_spec_msg.type == CompSpecMsg_pb2.TYPE_HANDLE): |
| logging.debug("var_spec_msg: %s", var_spec_msg) |
| return var_spec_msg |
| |
| raise errors.VtsUnsupportedTypeError( |
| "unsupported type %s" % var_spec_msg.type) |
| |
| def CallApi(self, arg, caller_uid=None): |
| """RPC to CALL_API.""" |
| self.SendCommand(SysMsg_pb2.CALL_API, arg=arg, caller_uid=caller_uid) |
| resp = self.RecvResponse() |
| resp_code = resp.response_code |
| if (resp_code == SysMsg_pb2.SUCCESS): |
| result = CompSpecMsg_pb2.FunctionSpecificationMessage() |
| if resp.result == "error": |
| raise errors.VtsTcpCommunicationError( |
| "API call error by the VTS driver.") |
| try: |
| text_format.Merge(resp.result, result) |
| except text_format.ParseError as e: |
| logging.exception(e) |
| logging.error("Paring error\n%s", resp.result) |
| if result.return_type.type == CompSpecMsg_pb2.TYPE_SUBMODULE: |
| logging.debug("returned a submodule spec") |
| logging.debug("spec: %s", result.return_type_submodule_spec) |
| return mirror_object.MirrorObject( |
| self, result.return_type_submodule_spec, None) |
| |
| if result.HasField("return_type"): # For non-HIDL return value |
| result_value = result |
| else: |
| result_value = [] |
| for return_type_hidl in result.return_type_hidl: |
| result_value.append( |
| self.GetPythonDataOfVariableSpecMsg(return_type_hidl)) |
| |
| if len(result.raw_coverage_data) > 0: |
| return result_value, {"coverage": result.raw_coverage_data} |
| else: |
| return result_value |
| |
| logging.error("NOTICE - Likely a crash discovery!") |
| logging.error("SysMsg_pb2.SUCCESS is %s", SysMsg_pb2.SUCCESS) |
| raise errors.VtsTcpCommunicationError( |
| "RPC Error, response code for %s is %s" % (arg, resp_code)) |
| |
| def GetAttribute(self, arg): |
| """RPC to VTS_AGENT_COMMAND_GET_ATTRIBUTE.""" |
| self.SendCommand(SysMsg_pb2.VTS_AGENT_COMMAND_GET_ATTRIBUTE, arg=arg) |
| resp = self.RecvResponse() |
| resp_code = resp.response_code |
| if (resp_code == SysMsg_pb2.SUCCESS): |
| result = CompSpecMsg_pb2.FunctionSpecificationMessage() |
| if resp.result == "error": |
| raise errors.VtsTcpCommunicationError( |
| "Get attribute request failed on target.") |
| try: |
| text_format.Merge(resp.result, result) |
| except text_format.ParseError as e: |
| logging.exception(e) |
| logging.error("Paring error\n%s", resp.result) |
| if result.return_type.type == CompSpecMsg_pb2.TYPE_SUBMODULE: |
| logging.debug("returned a submodule spec") |
| logging.debug("spec: %s", result.return_type_submodule_spec) |
| return mirror_object.MirrorObject( |
| self, result.return_type_submodule_spec, None) |
| elif result.return_type.type == CompSpecMsg_pb2.TYPE_SCALAR: |
| return getattr(result.return_type.scalar_value, |
| result.return_type.scalar_type) |
| return result |
| logging.error("NOTICE - Likely a crash discovery!") |
| logging.error("SysMsg_pb2.SUCCESS is %s", SysMsg_pb2.SUCCESS) |
| raise errors.VtsTcpCommunicationError( |
| "RPC Error, response code for %s is %s" % (arg, resp_code)) |
| |
| def ExecuteShellCommand(self, command, no_except=False): |
| """RPC to VTS_AGENT_COMMAND_EXECUTE_SHELL_COMMAND. |
| |
| Args: |
| command: string or list or tuple, command to execute on device |
| no_except: bool, whether to throw exceptions. If set to True, |
| when exception happens, return code will be -1 and |
| str(err) will be in stderr. Result will maintain the |
| same length as with input command. |
| |
| Returns: |
| dictionary of list, command results that contains stdout, |
| stderr, and exit_code. |
| """ |
| try: |
| return self.__ExecuteShellCommand(command) |
| except Exception as e: |
| self.error = e |
| if not no_except: |
| raise e |
| logging.exception(e) |
| return { |
| const.STDOUT: [""] * len(command), |
| const.STDERR: [str(e)] * len(command), |
| const.EXIT_CODE: [-1] * len(command) |
| } |
| |
| def __ExecuteShellCommand(self, command): |
| """RPC to VTS_AGENT_COMMAND_EXECUTE_SHELL_COMMAND. |
| |
| Args: |
| command: string or list of string, command to execute on device |
| |
| Returns: |
| dictionary of list, command results that contains stdout, |
| stderr, and exit_code. |
| """ |
| self.SendCommand( |
| SysMsg_pb2.VTS_AGENT_COMMAND_EXECUTE_SHELL_COMMAND, |
| shell_command=command) |
| resp = self.RecvResponse(retries=2) |
| logging.debug("resp for VTS_AGENT_COMMAND_EXECUTE_SHELL_COMMAND: %s", |
| resp) |
| |
| stdout = [] |
| stderr = [] |
| exit_code = -1 |
| |
| if not resp: |
| logging.error(self.NO_RESPONSE_MSG) |
| stderr = [self.NO_RESPONSE_MSG] |
| self.error = self.NO_RESPONSE_MSG |
| elif resp.response_code != SysMsg_pb2.SUCCESS: |
| logging.error(self.FAIL_RESPONSE_MSG) |
| stderr = [self.FAIL_RESPONSE_MSG] |
| self.error = self.FAIL_RESPONSE_MSG |
| else: |
| stdout = resp.stdout_str |
| stderr = resp.stderr_str |
| exit_code = resp.exit_code |
| self.error = None |
| |
| return { |
| const.STDOUT: stdout, |
| const.STDERR: stderr, |
| const.EXIT_CODE: exit_code |
| } |
| |
| def SendFmqRequest(self, message): |
| """Sends a command to the FMQ driver and receives the response. |
| |
| Args: |
| message: FmqRequestMessage, message that contains the arguments |
| in the FMQ request. |
| |
| Returns: |
| FmqResponseMessage, which includes all possible return value types, |
| including int, bool, and data read from the queue. |
| """ |
| self.SendCommand(SysMsg_pb2.VTS_FMQ_COMMAND, fmq_request=message) |
| resp = self.RecvResponse() |
| logging.debug("resp for VTS_FMQ_COMMAND: %s", resp) |
| return self.CheckResourceCommandResponse( |
| resp, getattr(resp, "fmq_response", None)) |
| |
| def SendHidlMemoryRequest(self, message): |
| """Sends a command to the hidl_memory driver and receives the response. |
| |
| Args: |
| message: HidlMemoryRequestMessage, message that contains the arguments |
| in the hidl_memory request. |
| |
| Returns: |
| HidlMemoryResponseMessage, return values needed by the host-side caller. |
| """ |
| self.SendCommand( |
| SysMsg_pb2.VTS_HIDL_MEMORY_COMMAND, hidl_memory_request=message) |
| resp = self.RecvResponse() |
| logging.debug("resp for VTS_HIDL_MEMORY_COMMAND: %s", resp) |
| return self.CheckResourceCommandResponse( |
| resp, getattr(resp, "hidl_memory_response", None)) |
| |
| def SendHidlHandleRequest(self, message): |
| """Sends a command to the hidl_handle driver and receives the response. |
| |
| Args: |
| message: HidlHandleRequestMessage, message that contains the arguments |
| in the hidl_handle request. |
| |
| Returns: |
| HidlHandleResponseMessage, return values needed by the host-side caller. |
| """ |
| self.SendCommand( |
| SysMsg_pb2.VTS_HIDL_HANDLE_COMMAND, hidl_handle_request=message) |
| resp = self.RecvResponse() |
| logging.debug("resp for VTS_HIDL_HANDLE_COMMAND: %s", resp) |
| return self.CheckResourceCommandResponse( |
| resp, getattr(resp, "hidl_handle_response", None)) |
| |
| @staticmethod |
| def CheckResourceCommandResponse(agent_response, resource_response): |
| """Checks the response from a VTS resource command. |
| |
| This function checks and logs framework errors such as not receiving |
| a response, receving a failure response. Then it checks the response |
| for the resource type is not None, and logs error if needed. |
| |
| Args: |
| agent_response: AndroidSystemControlResponseMessage, |
| response from agent. |
| resource_response: FmqResponseMessage, HidlMemoryResponseMessage, |
| or HidlHandleResponseMessage, the response for |
| one of fmq, hidl_memory, and hidl_handle. |
| |
| Returns: |
| resource_response that is passed in. |
| """ |
| if agent_response is None: |
| logging.error(VtsTcpClient.NO_RESPONSE_MSG) |
| elif agent_response.response_code != SysMsg_pb2.SUCCESS: |
| logging.error(VtsTcpClient.FAIL_RESPONSE_MSG) |
| elif resource_response is None: |
| logging.error("TCP client did not receive a response for " + |
| "the resource command.") |
| return resource_response |
| |
| def Ping(self): |
| """RPC to send a PING request. |
| |
| Returns: |
| True if the agent is alive, False otherwise. |
| """ |
| self.SendCommand(SysMsg_pb2.PING) |
| resp = self.RecvResponse() |
| logging.debug("resp for PING: %s", resp) |
| if resp is not None and resp.response_code == SysMsg_pb2.SUCCESS: |
| return True |
| return False |
| |
| def ReadSpecification(self, |
| interface_name, |
| target_class, |
| target_type, |
| target_version_major, |
| target_version_minor, |
| target_package, |
| recursive=False): |
| """RPC to VTS_AGENT_COMMAND_READ_SPECIFICATION. |
| |
| Args: |
| other args: see SendCommand |
| recursive: boolean, set to recursively read the imported |
| specification(s) and return the merged one. |
| """ |
| self.SendCommand( |
| SysMsg_pb2.VTS_AGENT_COMMAND_READ_SPECIFICATION, |
| service_name=interface_name, |
| target_class=target_class, |
| target_type=target_type, |
| target_version_major=target_version_major, |
| target_version_minor=target_version_minor, |
| target_package=target_package) |
| resp = self.RecvResponse(retries=2) |
| logging.debug("resp for VTS_AGENT_COMMAND_EXECUTE_READ_INTERFACE: %s", |
| resp) |
| logging.debug("proto: %s", resp.result) |
| result = CompSpecMsg_pb2.ComponentSpecificationMessage() |
| if resp.result == "error": |
| raise errors.VtsTcpCommunicationError( |
| "API call error by the VTS driver.") |
| try: |
| text_format.Merge(resp.result, result) |
| except text_format.ParseError as e: |
| logging.exception(e) |
| logging.error("Paring error\n%s", resp.result) |
| |
| if recursive and hasattr(result, "import"): |
| for imported_interface in getattr(result, "import"): |
| if imported_interface == "android.hidl.base@1.0::types": |
| logging.warn("import android.hidl.base@1.0::types skipped") |
| continue |
| [package, version_str] = imported_interface.split("@") |
| [version_major, |
| version_minor] = (version_str.split("::")[0]).split(".") |
| imported_result = self.ReadSpecification( |
| imported_interface.split("::")[1], |
| # TODO(yim): derive target_class and |
| # target_type from package path or remove them |
| msg.component_class |
| if target_class is None else target_class, |
| msg.component_type if target_type is None else target_type, |
| int(version_major), |
| int(version_minor), |
| package) |
| # Merge the attributes from imported interface. |
| for attribute in imported_result.attribute: |
| imported_attribute = result.attribute.add() |
| imported_attribute.CopyFrom(attribute) |
| |
| return result |
| |
| def SendCommand(self, |
| command_type, |
| paths=None, |
| file_path=None, |
| bits=None, |
| target_class=None, |
| target_type=None, |
| target_version_major=None, |
| target_version_minor=None, |
| target_package=None, |
| target_component_name=None, |
| hw_binder_service_name=None, |
| is_test_hal=None, |
| module_name=None, |
| service_name=None, |
| callback_port=None, |
| driver_type=None, |
| shell_command=None, |
| caller_uid=None, |
| arg=None, |
| fmq_request=None, |
| hidl_memory_request=None, |
| hidl_handle_request=None): |
| """Sends a command. |
| |
| Args: |
| command_type: integer, the command type. |
| each of the other args are to fill in a field in |
| AndroidSystemControlCommandMessage. |
| """ |
| if not self.channel: |
| raise errors.VtsTcpCommunicationError( |
| "channel is None, unable to send command.") |
| |
| command_msg = SysMsg_pb2.AndroidSystemControlCommandMessage() |
| command_msg.command_type = command_type |
| logging.debug("sending a command (type %s)", |
| COMMAND_TYPE_NAME[command_type]) |
| if command_type == 202: |
| logging.debug("target API: %s", arg) |
| |
| if target_class is not None: |
| command_msg.target_class = target_class |
| |
| if target_type is not None: |
| command_msg.target_type = target_type |
| |
| if target_version_major is not None: |
| command_msg.target_version_major = target_version_major |
| |
| if target_version_minor is not None: |
| command_msg.target_version_minor = target_version_minor |
| |
| if target_package is not None: |
| command_msg.target_package = target_package |
| |
| if target_component_name is not None: |
| command_msg.target_component_name = target_component_name |
| |
| if hw_binder_service_name is not None: |
| command_msg.hw_binder_service_name = hw_binder_service_name |
| |
| if is_test_hal is not None: |
| command_msg.is_test_hal = is_test_hal |
| |
| if module_name is not None: |
| command_msg.module_name = module_name |
| |
| if service_name is not None: |
| command_msg.service_name = service_name |
| |
| if driver_type is not None: |
| command_msg.driver_type = driver_type |
| |
| if paths is not None: |
| command_msg.paths.extend(paths) |
| |
| if file_path is not None: |
| command_msg.file_path = file_path |
| |
| if bits is not None: |
| command_msg.bits = bits |
| |
| if callback_port is not None: |
| command_msg.callback_port = callback_port |
| |
| if caller_uid is not None: |
| command_msg.driver_caller_uid = caller_uid |
| |
| if arg is not None: |
| command_msg.arg = arg |
| |
| if shell_command is not None: |
| if isinstance(shell_command, (list, tuple)): |
| command_msg.shell_command.extend(shell_command) |
| else: |
| command_msg.shell_command.append(shell_command) |
| |
| if fmq_request is not None: |
| command_msg.fmq_request.CopyFrom(fmq_request) |
| |
| if hidl_memory_request is not None: |
| command_msg.hidl_memory_request.CopyFrom(hidl_memory_request) |
| |
| if hidl_handle_request is not None: |
| command_msg.hidl_handle_request.CopyFrom(hidl_handle_request) |
| |
| logging.debug("command %s" % command_msg) |
| message = command_msg.SerializeToString() |
| message_len = len(message) |
| logging.debug("sending %d bytes", message_len) |
| self.channel.write(str(message_len) + b'\n') |
| self.channel.write(message) |
| self.channel.flush() |
| |
| def RecvResponse(self, retries=0): |
| """Receives and parses the response, and returns the relevant ResponseMessage. |
| |
| Args: |
| retries: an integer indicating the max number of retries in case of |
| session timeout error. |
| """ |
| for index in xrange(1 + retries): |
| try: |
| if index != 0: |
| logging.info("retrying...") |
| header = self.channel.readline().strip("\n") |
| length = int(header) if header else 0 |
| logging.debug("resp %d bytes", length) |
| data = self.channel.read(length) |
| response_msg = SysMsg_pb2.AndroidSystemControlResponseMessage() |
| response_msg.ParseFromString(data) |
| logging.debug( |
| "Response %s", "success" |
| if response_msg.response_code == SysMsg_pb2.SUCCESS else |
| "fail") |
| return response_msg |
| except socket.timeout as e: |
| logging.exception(e) |
| return None |
