android_emulator/generated/

android.emulation.control.rs

// This file is @generated by prost-build.
/// A Run State that describes the state of the Virtual Machine.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VmRunState {
    #[prost(enumeration = "vm_run_state::RunState", tag = "1")]
    pub state: i32,
}
/// Nested message and enum types in `VmRunState`.
pub mod vm_run_state {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RunState {
        /// The emulator is in an unknown state. You cannot transition to this
        /// state.
        Unknown = 0,
        /// Guest is actively running. You can transition to this state from the
        /// paused state.
        Running = 1,
        /// Guest is paused to load a snapshot. You cannot transition to this
        /// state.
        RestoreVm = 2,
        /// Guest has been paused. Transitioning to this state will pause the
        /// emulator the guest will not be consuming any cpu cycles.
        Paused = 3,
        /// Guest is paused to take or export a snapshot. You cannot
        /// transition to this state.
        SaveVm = 4,
        /// System shutdown, note that it is similar to power off. It tries to
        /// set the system status and notify guest. The system is likely going to
        /// disappear soon and do proper cleanup of resources, possibly taking
        /// a snapshot. This is the same behavior as closing the emulator by
        /// clicking the X (close) in the user interface.
        Shutdown = 5,
        /// Immediately terminate the emulator. No resource cleanup will take
        /// place. There is a good change to corrupt the system.
        Terminate = 7,
        /// Will cause the emulator to reset. This is not a state you can
        /// observe.
        Reset = 9,
        /// Guest experienced some error state, you cannot transition to this
        /// state.
        InternalError = 10,
        /// Completely restart the emulator.
        Restart = 11,
        /// Resume a stopped emulator
        Start = 12,
        /// Stop (pause) a running emulator
        Stop = 13,
    }
    impl RunState {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unknown => "UNKNOWN",
                Self::Running => "RUNNING",
                Self::RestoreVm => "RESTORE_VM",
                Self::Paused => "PAUSED",
                Self::SaveVm => "SAVE_VM",
                Self::Shutdown => "SHUTDOWN",
                Self::Terminate => "TERMINATE",
                Self::Reset => "RESET",
                Self::InternalError => "INTERNAL_ERROR",
                Self::Restart => "RESTART",
                Self::Start => "START",
                Self::Stop => "STOP",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "UNKNOWN" => Some(Self::Unknown),
                "RUNNING" => Some(Self::Running),
                "RESTORE_VM" => Some(Self::RestoreVm),
                "PAUSED" => Some(Self::Paused),
                "SAVE_VM" => Some(Self::SaveVm),
                "SHUTDOWN" => Some(Self::Shutdown),
                "TERMINATE" => Some(Self::Terminate),
                "RESET" => Some(Self::Reset),
                "INTERNAL_ERROR" => Some(Self::InternalError),
                "RESTART" => Some(Self::Restart),
                "START" => Some(Self::Start),
                "STOP" => Some(Self::Stop),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ParameterValue {
    #[prost(float, repeated, tag = "1")]
    pub data: ::prost::alloc::vec::Vec<f32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PhysicalModelValue {
    #[prost(enumeration = "physical_model_value::PhysicalType", tag = "1")]
    pub target: i32,
    /// \[Output Only\]
    #[prost(enumeration = "physical_model_value::State", tag = "2")]
    pub status: i32,
    /// Value interpretation depends on sensor.
    #[prost(message, optional, tag = "3")]
    pub value: ::core::option::Option<ParameterValue>,
}
/// Nested message and enum types in `PhysicalModelValue`.
pub mod physical_model_value {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        Ok = 0,
        /// qemud service is not available/initiated.
        NoService = -3,
        /// Sensor is disabled.
        Disabled = -2,
        /// Unknown sensor (should not happen)
        Unknown = -1,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Ok => "OK",
                Self::NoService => "NO_SERVICE",
                Self::Disabled => "DISABLED",
                Self::Unknown => "UNKNOWN",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "OK" => Some(Self::Ok),
                "NO_SERVICE" => Some(Self::NoService),
                "DISABLED" => Some(Self::Disabled),
                "UNKNOWN" => Some(Self::Unknown),
                _ => None,
            }
        }
    }
    /// Details on the sensors documentation can be found here:
    /// <https://developer.android.com/reference/android/hardware/Sensor.html#TYPE\_>
    /// The types must follow the order defined in
    /// "external/qemu/android/hw-sensors.h"
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum PhysicalType {
        Position = 0,
        /// All values are angles in degrees.
        /// values = \[x,y,z\]
        Rotation = 1,
        MagneticField = 2,
        /// Temperature in °C
        Temperature = 3,
        /// Proximity sensor distance measured in centimeters
        Proximity = 4,
        /// Ambient light level in SI lux units
        Light = 5,
        /// Atmospheric pressure in hPa (millibar)
        Pressure = 6,
        /// Relative ambient air humidity in percent
        Humidity = 7,
        Velocity = 8,
        AmbientMotion = 9,
        /// Describing a hinge angle sensor in degrees.
        HingeAngle0 = 10,
        HingeAngle1 = 11,
        HingeAngle2 = 12,
        Rollable0 = 13,
        Rollable1 = 14,
        Rollable2 = 15,
        /// Describing the device posture; the value should be an enum defined
        /// in Posture::PostureValue.
        Posture = 16,
        /// Heart rate in bpm
        HeartRate = 17,
        /// Ambient RGBC light intensity. Values are in order (Red, Green, Blue,
        /// Clear).
        RgbcLight = 18,
        /// Wrist tilt gesture (1 = gaze, 0 = ungaze)
        WristTilt = 19,
    }
    impl PhysicalType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Position => "POSITION",
                Self::Rotation => "ROTATION",
                Self::MagneticField => "MAGNETIC_FIELD",
                Self::Temperature => "TEMPERATURE",
                Self::Proximity => "PROXIMITY",
                Self::Light => "LIGHT",
                Self::Pressure => "PRESSURE",
                Self::Humidity => "HUMIDITY",
                Self::Velocity => "VELOCITY",
                Self::AmbientMotion => "AMBIENT_MOTION",
                Self::HingeAngle0 => "HINGE_ANGLE0",
                Self::HingeAngle1 => "HINGE_ANGLE1",
                Self::HingeAngle2 => "HINGE_ANGLE2",
                Self::Rollable0 => "ROLLABLE0",
                Self::Rollable1 => "ROLLABLE1",
                Self::Rollable2 => "ROLLABLE2",
                Self::Posture => "POSTURE",
                Self::HeartRate => "HEART_RATE",
                Self::RgbcLight => "RGBC_LIGHT",
                Self::WristTilt => "WRIST_TILT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "POSITION" => Some(Self::Position),
                "ROTATION" => Some(Self::Rotation),
                "MAGNETIC_FIELD" => Some(Self::MagneticField),
                "TEMPERATURE" => Some(Self::Temperature),
                "PROXIMITY" => Some(Self::Proximity),
                "LIGHT" => Some(Self::Light),
                "PRESSURE" => Some(Self::Pressure),
                "HUMIDITY" => Some(Self::Humidity),
                "VELOCITY" => Some(Self::Velocity),
                "AMBIENT_MOTION" => Some(Self::AmbientMotion),
                "HINGE_ANGLE0" => Some(Self::HingeAngle0),
                "HINGE_ANGLE1" => Some(Self::HingeAngle1),
                "HINGE_ANGLE2" => Some(Self::HingeAngle2),
                "ROLLABLE0" => Some(Self::Rollable0),
                "ROLLABLE1" => Some(Self::Rollable1),
                "ROLLABLE2" => Some(Self::Rollable2),
                "POSTURE" => Some(Self::Posture),
                "HEART_RATE" => Some(Self::HeartRate),
                "RGBC_LIGHT" => Some(Self::RgbcLight),
                "WRIST_TILT" => Some(Self::WristTilt),
                _ => None,
            }
        }
    }
}
/// A single sensor value.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SensorValue {
    /// Type of sensor
    #[prost(enumeration = "sensor_value::SensorType", tag = "1")]
    pub target: i32,
    /// \[Output Only\]
    #[prost(enumeration = "sensor_value::State", tag = "2")]
    pub status: i32,
    /// Value interpretation depends on sensor enum.
    #[prost(message, optional, tag = "3")]
    pub value: ::core::option::Option<ParameterValue>,
}
/// Nested message and enum types in `SensorValue`.
pub mod sensor_value {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        Ok = 0,
        /// qemud service is not available/initiated.
        NoService = -3,
        /// Sensor is disabled.
        Disabled = -2,
        /// Unknown sensor (should not happen)
        Unknown = -1,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Ok => "OK",
                Self::NoService => "NO_SERVICE",
                Self::Disabled => "DISABLED",
                Self::Unknown => "UNKNOWN",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "OK" => Some(Self::Ok),
                "NO_SERVICE" => Some(Self::NoService),
                "DISABLED" => Some(Self::Disabled),
                "UNKNOWN" => Some(Self::Unknown),
                _ => None,
            }
        }
    }
    /// These are the various sensors that can be available in an emulated
    /// devices.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SensorType {
        /// Measures the acceleration force in m/s2 that is applied to a device
        /// on all three physical axes (x, y, and z), including the force of
        /// gravity.
        Acceleration = 0,
        /// Measures a device's rate of rotation in rad/s around each of the
        /// three physical axes (x, y, and z).
        Gyroscope = 1,
        /// Measures the ambient geomagnetic field for all three physical axes
        /// (x, y, z) in μT.
        MagneticField = 2,
        /// Measures degrees of rotation that a device makes around all three
        /// physical axes (x, y, z)
        Orientation = 3,
        /// Measures the temperature of the device in degrees Celsius (°C).
        Temperature = 4,
        /// Measures the proximity of an object in cm relative to the view screen
        /// of a device. This sensor is typically used to determine whether a
        /// handset is being held up to a person's ear.
        Proximity = 5,
        /// Measures the ambient light level (illumination) in lx.
        Light = 6,
        /// Measures the ambient air pressure in hPa or mbar.
        Pressure = 7,
        /// Measures the relative ambient humidity in percent (%).
        Humidity = 8,
        MagneticFieldUncalibrated = 9,
        GyroscopeUncalibrated = 10,
        /// Measures the heart rate in bpm.
        HeartRate = 14,
        /// Measures the ambient RGBC light intensity.
        /// Values are in order (Red, Green, Blue, Clear).
        RgbcLight = 15,
        /// WIRST_TILT (16) is skipped; clients should use get/setPhysicalModel()
        /// instead.
        /// Measures acceleration force and provides bias data.
        AccelerationUncalibrated = 17,
    }
    impl SensorType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Acceleration => "ACCELERATION",
                Self::Gyroscope => "GYROSCOPE",
                Self::MagneticField => "MAGNETIC_FIELD",
                Self::Orientation => "ORIENTATION",
                Self::Temperature => "TEMPERATURE",
                Self::Proximity => "PROXIMITY",
                Self::Light => "LIGHT",
                Self::Pressure => "PRESSURE",
                Self::Humidity => "HUMIDITY",
                Self::MagneticFieldUncalibrated => "MAGNETIC_FIELD_UNCALIBRATED",
                Self::GyroscopeUncalibrated => "GYROSCOPE_UNCALIBRATED",
                Self::HeartRate => "HEART_RATE",
                Self::RgbcLight => "RGBC_LIGHT",
                Self::AccelerationUncalibrated => "ACCELERATION_UNCALIBRATED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ACCELERATION" => Some(Self::Acceleration),
                "GYROSCOPE" => Some(Self::Gyroscope),
                "MAGNETIC_FIELD" => Some(Self::MagneticField),
                "ORIENTATION" => Some(Self::Orientation),
                "TEMPERATURE" => Some(Self::Temperature),
                "PROXIMITY" => Some(Self::Proximity),
                "LIGHT" => Some(Self::Light),
                "PRESSURE" => Some(Self::Pressure),
                "HUMIDITY" => Some(Self::Humidity),
                "MAGNETIC_FIELD_UNCALIBRATED" => Some(Self::MagneticFieldUncalibrated),
                "GYROSCOPE_UNCALIBRATED" => Some(Self::GyroscopeUncalibrated),
                "HEART_RATE" => Some(Self::HeartRate),
                "RGBC_LIGHT" => Some(Self::RgbcLight),
                "ACCELERATION_UNCALIBRATED" => Some(Self::AccelerationUncalibrated),
                _ => None,
            }
        }
    }
}
/// A single backlight brightness value.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BrightnessValue {
    /// Type of light
    #[prost(enumeration = "brightness_value::LightType", tag = "1")]
    pub target: i32,
    /// Light intensity, ranges from 0-255.
    #[prost(uint32, tag = "2")]
    pub value: u32,
}
/// Nested message and enum types in `BrightnessValue`.
pub mod brightness_value {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum LightType {
        /// Display backlight. This will affect all displays.
        Lcd = 0,
        Keyboard = 1,
        Button = 2,
    }
    impl LightType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Lcd => "LCD",
                Self::Keyboard => "KEYBOARD",
                Self::Button => "BUTTON",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "LCD" => Some(Self::Lcd),
                "KEYBOARD" => Some(Self::Keyboard),
                "BUTTON" => Some(Self::Button),
                _ => None,
            }
        }
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DisplayMode {
    #[prost(enumeration = "DisplayModeValue", tag = "1")]
    pub value: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogMessage {
    /// \[Output Only\] The contents of the log output.
    #[prost(string, tag = "1")]
    pub contents: ::prost::alloc::string::String,
    /// The starting byte position of the output that was returned. This
    /// should match the start parameter sent with the request. If the serial
    /// console output exceeds the size of the buffer, older output will be
    /// overwritten by newer content and the start values will be mismatched.
    #[deprecated]
    #[prost(int64, tag = "2")]
    pub start: i64,
    /// \[Output Only\] The position of the next byte of content from the serial
    /// console output. Use this value in the next request as the start
    /// parameter.
    #[deprecated]
    #[prost(int64, tag = "3")]
    pub next: i64,
    /// Set the sort of response you are interested it in.
    /// It the type is "Parsed" the entries field will contain the parsed
    /// results. otherwise the contents field will be set.
    #[prost(enumeration = "log_message::LogType", tag = "4")]
    pub sort: i32,
    /// \[Output Only\] The parsed logcat entries so far. Only set if sort is
    /// set to Parsed
    #[prost(message, repeated, tag = "5")]
    pub entries: ::prost::alloc::vec::Vec<LogcatEntry>,
}
/// Nested message and enum types in `LogMessage`.
pub mod log_message {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum LogType {
        Text = 0,
        Parsed = 1,
    }
    impl LogType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Text => "Text",
                Self::Parsed => "Parsed",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "Text" => Some(Self::Text),
                "Parsed" => Some(Self::Parsed),
                _ => None,
            }
        }
    }
}
/// A parsed logcat entry.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LogcatEntry {
    /// A Unix timestamps in  milliseconds (The number of milliseconds that
    /// have elapsed since January 1, 1970 (midnight UTC/GMT), not counting
    /// leap seconds)
    #[prost(uint64, tag = "1")]
    pub timestamp: u64,
    /// Process id.
    #[prost(uint32, tag = "2")]
    pub pid: u32,
    /// Thread id.
    #[prost(uint32, tag = "3")]
    pub tid: u32,
    #[prost(enumeration = "logcat_entry::LogLevel", tag = "4")]
    pub level: i32,
    #[prost(string, tag = "5")]
    pub tag: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub msg: ::prost::alloc::string::String,
}
/// Nested message and enum types in `LogcatEntry`.
pub mod logcat_entry {
    /// The possible log levels.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum LogLevel {
        Unknown = 0,
        Default = 1,
        Verbose = 2,
        Debug = 3,
        Info = 4,
        Warn = 5,
        Err = 6,
        Fatal = 7,
        Silent = 8,
    }
    impl LogLevel {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unknown => "UNKNOWN",
                Self::Default => "DEFAULT",
                Self::Verbose => "VERBOSE",
                Self::Debug => "DEBUG",
                Self::Info => "INFO",
                Self::Warn => "WARN",
                Self::Err => "ERR",
                Self::Fatal => "FATAL",
                Self::Silent => "SILENT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "UNKNOWN" => Some(Self::Unknown),
                "DEFAULT" => Some(Self::Default),
                "VERBOSE" => Some(Self::Verbose),
                "DEBUG" => Some(Self::Debug),
                "INFO" => Some(Self::Info),
                "WARN" => Some(Self::Warn),
                "ERR" => Some(Self::Err),
                "FATAL" => Some(Self::Fatal),
                "SILENT" => Some(Self::Silent),
                _ => None,
            }
        }
    }
}
/// Information about the hypervisor that is currently in use.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VmConfiguration {
    #[prost(enumeration = "vm_configuration::VmHypervisorType", tag = "1")]
    pub hypervisor_type: i32,
    #[prost(int32, tag = "2")]
    pub number_of_cpu_cores: i32,
    #[prost(int64, tag = "3")]
    pub ram_size_bytes: i64,
}
/// Nested message and enum types in `VmConfiguration`.
pub mod vm_configuration {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum VmHypervisorType {
        /// An unknown hypervisor
        Unknown = 0,
        /// No hypervisor is in use. This usually means that the guest is
        /// running on a different CPU than the host, or you are using a
        /// platform where no hypervisor is available.
        None = 1,
        /// The Kernel based Virtual Machine
        /// (<https://www.linux-kvm.org/page/Main_Page>)
        Kvm = 2,
        /// Intel® Hardware Accelerated Execution Manager (Intel® HAXM)
        /// <https://github.com/intel/haxm>
        Haxm = 3,
        /// Hypervisor Framework.
        /// <https://developer.apple.com/documentation/hypervisor>
        Hvf = 4,
        /// Window Hypervisor Platform
        /// <https://docs.microsoft.com/en-us/virtualization/api/>
        Whpx = 5,
        Aehd = 6,
    }
    impl VmHypervisorType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unknown => "UNKNOWN",
                Self::None => "NONE",
                Self::Kvm => "KVM",
                Self::Haxm => "HAXM",
                Self::Hvf => "HVF",
                Self::Whpx => "WHPX",
                Self::Aehd => "AEHD",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "UNKNOWN" => Some(Self::Unknown),
                "NONE" => Some(Self::None),
                "KVM" => Some(Self::Kvm),
                "HAXM" => Some(Self::Haxm),
                "HVF" => Some(Self::Hvf),
                "WHPX" => Some(Self::Whpx),
                "AEHD" => Some(Self::Aehd),
                _ => None,
            }
        }
    }
}
/// Representation of a clipped data object on the clipboard.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ClipData {
    /// UTF-8 Encoded text.
    #[prost(string, tag = "1")]
    pub text: ::prost::alloc::string::String,
}
/// The Touch interface represents a single contact point on a
/// touch-sensitive device. The contact point is commonly a finger or stylus
/// and the device may be a touchscreen or trackpad.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Touch {
    /// The horizontal coordinate. This is the physical location on the
    /// screen For example 0 indicates the leftmost coordinate.
    #[prost(int32, tag = "1")]
    pub x: i32,
    /// The vertical coordinate. This is the physical location on the screen
    /// For example 0 indicates the top left coordinate.
    #[prost(int32, tag = "2")]
    pub y: i32,
    /// The identifier is an arbitrary non-negative integer that is used to
    /// identify and track each tool independently when multiple tools are
    /// active. For example, when multiple fingers are touching the device,
    /// each finger should be assigned a distinct tracking id that is used as
    /// long as the finger remains in contact. Tracking ids may be reused
    /// when their associated tools move out of range.
    ///
    /// The emulator currently supports up to 10 concurrent touch events. The
    /// identifier can be any uninque value and will be mapped to the next
    /// available internal identifier.
    #[prost(int32, tag = "3")]
    pub identifier: i32,
    /// Reports the physical pressure applied to the tip of the tool or the
    /// signal strength of the touch contact.
    ///
    /// The values reported must be non-zero when the tool is touching the
    /// device and zero otherwise to indicate that the touch event is
    /// completed.
    ///
    /// Make sure to deliver a pressure of 0 for the given identifier when
    /// the touch event is completed, otherwise the touch identifier will not
    /// be unregistered!
    #[prost(int32, tag = "4")]
    pub pressure: i32,
    /// Optionally reports the cross-sectional area of the touch contact, or
    /// the length of the longer dimension of the touch contact.
    #[prost(int32, tag = "5")]
    pub touch_major: i32,
    /// Optionally reports the length of the shorter dimension of the touch
    /// contact. This axis will be ignored if touch_major is reporting an
    /// area measurement greater than 0.
    #[prost(int32, tag = "6")]
    pub touch_minor: i32,
    #[prost(enumeration = "touch::EventExpiration", tag = "7")]
    pub expiration: i32,
    /// The orientation of the contact, if any.
    #[prost(int32, tag = "8")]
    pub orientation: i32,
}
/// Nested message and enum types in `Touch`.
pub mod touch {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum EventExpiration {
        /// The system will use the default time of 120s to track
        /// the touch event with the given identifier. If no update happens
        /// within this timeframe the identifier is considered expired
        /// and can be made available for re-use. This means that a touch event
        /// with pressure 0 for this identifier will be send to the emulator.
        Unspecified = 0,
        /// Never expire the given slot. You must *ALWAYS* close the identifier
        /// by sending a touch event with 0 pressure.
        NeverExpire = 1,
    }
    impl EventExpiration {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "EVENT_EXPIRATION_UNSPECIFIED",
                Self::NeverExpire => "NEVER_EXPIRE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "EVENT_EXPIRATION_UNSPECIFIED" => Some(Self::Unspecified),
                "NEVER_EXPIRE" => Some(Self::NeverExpire),
                _ => None,
            }
        }
    }
}
/// A Pen is similar to a touch, with the addition
/// of button and rubber information.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Pen {
    #[prost(message, optional, tag = "1")]
    pub location: ::core::option::Option<Touch>,
    /// True if the button is pressed or not
    #[prost(bool, tag = "2")]
    pub button_pressed: bool,
    /// True if it is a rubber pointer.
    #[prost(bool, tag = "3")]
    pub rubber_pointer: bool,
}
/// A TouchEvent contains a list of Touch objects that are in contact with
/// the touch surface.
///
/// Touch events are delivered in sequence as specified in the touchList.
///
/// TouchEvents are delivered to the emulated devices using ["Protocol
/// B"](<https://www.kernel.org/doc/Documentation/input/multi-touch-protocol.txt>)
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TouchEvent {
    /// The list of Touch objects, note that these do not need to be unique
    #[prost(message, repeated, tag = "1")]
    pub touches: ::prost::alloc::vec::Vec<Touch>,
    /// The display device where the touch event occurred.
    /// Omitting or using the value 0 indicates the main display.
    #[prost(int32, tag = "2")]
    pub display: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PenEvent {
    /// The list of Pen objects, note that these do not need to be unique
    #[prost(message, repeated, tag = "1")]
    pub events: ::prost::alloc::vec::Vec<Pen>,
    /// The display device where the pen event occurred.
    /// Omitting or using the value 0 indicates the main display.
    #[prost(int32, tag = "2")]
    pub display: i32,
}
/// The MouseEvent interface represents events that occur due to the user
/// interacting with a pointing device (such as a mouse).
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MouseEvent {
    /// The horizontal coordinate. This is the physical location on the
    /// screen For example 0 indicates the leftmost coordinate.
    #[prost(int32, tag = "1")]
    pub x: i32,
    /// The vertical coordinate. This is the physical location on the screen
    /// For example 0 indicates the top left coordinate.
    #[prost(int32, tag = "2")]
    pub y: i32,
    /// Indicates which buttons are pressed.
    /// 0: No button was pressed
    /// 1: Primary button (left)
    /// 2: Secondary button (right)
    #[prost(int32, tag = "3")]
    pub buttons: i32,
    /// The display device where the mouse event occurred.
    /// Omitting or using the value 0 indicates the main display.
    #[prost(int32, tag = "4")]
    pub display: i32,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WheelEvent {
    /// The value indicating how much the mouse wheel is rotated. Scaled so that
    /// 120 equals to 1 wheel click. (120 is chosen as a multiplier often used to
    /// represent wheel movements less than 1 wheel click. e.g.
    /// <https://doc.qt.io/qt-5/qwheelevent.html#angleDelta>) Positive delta value
    /// is assigned to dx when the top of wheel is moved to left. Similarly
    /// positive delta value is assigned to dy when the top of wheel is moved
    /// away from the user.
    #[prost(int32, tag = "1")]
    pub dx: i32,
    #[prost(int32, tag = "2")]
    pub dy: i32,
    /// The display device where the mouse event occurred.
    /// Omitting or using the value 0 indicates the main display.
    #[prost(int32, tag = "3")]
    pub display: i32,
}
/// KeyboardEvent objects describe a user interaction with the keyboard; each
/// event describes a single interaction between the user and a key (or
/// combination of a key with modifier keys) on the keyboard.
/// This follows the pattern as set by
/// (javascript)\[<https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent\]>
///
/// Note: that only keyCode, key, or text can be set and that the semantics
/// will slightly vary.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct KeyboardEvent {
    /// Type of keycode contained in the keyCode field.
    #[prost(enumeration = "keyboard_event::KeyCodeType", tag = "1")]
    pub code_type: i32,
    /// The type of keyboard event that should be sent to the emulator
    #[prost(enumeration = "keyboard_event::KeyEventType", tag = "2")]
    pub event_type: i32,
    /// This property represents a physical key on the keyboard (as opposed
    /// to the character generated by pressing the key). In other words, this
    /// property is a value which isn't altered by keyboard layout or the
    /// state of the modifier keys. This value will be interpreted by the
    /// emulator depending on the KeyCodeType. The incoming key code will be
    /// translated to an evdev code type and send to the emulator.
    /// The values in key and text will be ignored.
    #[prost(int32, tag = "3")]
    pub key_code: i32,
    /// The value of the key pressed by the user, taking into consideration
    /// the state of modifier keys such as Shift as well as the keyboard
    /// locale and layout. This follows the w3c standard used in browsers.
    /// You can find an accurate description of valid values
    /// [here](<https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values>)
    ///
    /// Note that some keys can result in multiple evdev events that are
    /// delivered to the emulator. for example the Key "A" will result in a
    /// sequence:
    /// \["Shift", "a"\] -> \[0x2a, 0x1e\] whereas "a" results in \["a"\] -> \[0x1e\].
    ///
    /// Not all documented keys are understood by android, and only printable
    /// ASCII \[32-127) characters are properly translated.
    ///
    /// Keep in mind that there are a set of key values that result in android
    /// specific behavior
    /// [see](<https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values#Phone_keys>):
    ///
    /// * "AppSwitch": Behaves as the "Overview" button in android.
    /// * "GoBack": The Back button.
    /// * "GoHome": The Home button, which takes the user to the phone's main
    ///   screen (usually an application launcher).
    /// * "Power":  The Power button.
    #[prost(string, tag = "4")]
    pub key: ::prost::alloc::string::String,
    /// Series of utf8 encoded characters to send to the emulator. An attempt
    /// will be made to translate every character will an EvDev event type and
    /// send to the emulator as a keypress event. The values in keyCode,
    /// eventType, codeType and key will be ignored.
    ///
    /// Note that most printable ASCII characters (range \[32-127) can be send
    /// individually with the "key" param. Do not expect arbitrary UTF symbols to
    /// arrive in the emulator (most will be ignored).
    ///
    /// Note that it is possible to overrun the keyboard buffer by slamming this
    /// endpoint with large quantities of text (>1kb). The clipboard api is
    /// better suited for transferring large quantities of text.
    #[prost(string, tag = "5")]
    pub text: ::prost::alloc::string::String,
}
/// Nested message and enum types in `KeyboardEvent`.
pub mod keyboard_event {
    /// Code types that the emulator can receive. Note that the emulator
    /// will do its best to translate the code to an evdev value that
    /// will be send to the emulator. This translation is based on
    /// the chromium translation tables. See
    /// (this)\[<https://android.googlesource.com/platform/external/qemu/+/refs/heads/emu-master-dev/android/android-grpc/android/emulation/control/keyboard/keycode_converter_data.inc\]>
    /// for details on the translation.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum KeyCodeType {
        Usb = 0,
        Evdev = 1,
        Xkb = 2,
        Win = 3,
        Mac = 4,
    }
    impl KeyCodeType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Usb => "Usb",
                Self::Evdev => "Evdev",
                Self::Xkb => "XKB",
                Self::Win => "Win",
                Self::Mac => "Mac",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "Usb" => Some(Self::Usb),
                "Evdev" => Some(Self::Evdev),
                "XKB" => Some(Self::Xkb),
                "Win" => Some(Self::Win),
                "Mac" => Some(Self::Mac),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum KeyEventType {
        /// Indicates that this keyevent should be send to the emulator
        /// as a key down event. Meaning that the key event will be
        /// translated to an EvDev event type and bit 11 (0x400) will be
        /// set before it is sent to the emulator.
        Keydown = 0,
        /// Indicates that the keyevent should be send to the emulator
        /// as a key up event. Meaning that the key event will be
        /// translated to an EvDev event type and
        /// sent to the emulator.
        Keyup = 1,
        /// Indicates that the keyevent will be send to the emulator
        /// as e key down event and immediately followed by a keyup event.
        Keypress = 2,
    }
    impl KeyEventType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Keydown => "keydown",
                Self::Keyup => "keyup",
                Self::Keypress => "keypress",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "keydown" => Some(Self::Keydown),
                "keyup" => Some(Self::Keyup),
                "keypress" => Some(Self::Keypress),
                _ => None,
            }
        }
    }
}
/// An input event that can be delivered to the emulator.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InputEvent {
    #[prost(oneof = "input_event::Type", tags = "1, 2, 3, 4, 5, 6")]
    pub r#type: ::core::option::Option<input_event::Type>,
}
/// Nested message and enum types in `InputEvent`.
pub mod input_event {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        #[prost(message, tag = "1")]
        KeyEvent(super::KeyboardEvent),
        #[prost(message, tag = "2")]
        TouchEvent(super::TouchEvent),
        #[prost(message, tag = "3")]
        MouseEvent(super::MouseEvent),
        #[prost(message, tag = "4")]
        AndroidEvent(super::AndroidEvent),
        #[prost(message, tag = "5")]
        PenEvent(super::PenEvent),
        #[prost(message, tag = "6")]
        WheelEvent(super::WheelEvent),
    }
}
/// The android input event system is a framework for handling input from a
/// variety of devices by generating events that describe changes in the
/// state of the devices and forwarding them to user space applications.
///
/// An AndroidEvents will be delivered directly to the kernel as is.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AndroidEvent {
    /// The type of the event. The types of the event are specified
    /// by the android kernel. Some examples are:
    /// EV_SYN, EV_KEY, EV_SW, etc..
    /// The exact definitions can be found in the input.h header file.
    #[prost(int32, tag = "1")]
    pub r#type: i32,
    /// The actual code to be send to the kernel. The actual meaning
    /// of the code depends on the type definition.
    #[prost(int32, tag = "2")]
    pub code: i32,
    /// The actual value of the event.
    #[prost(int32, tag = "3")]
    pub value: i32,
    /// The display id associated with this input event.
    #[prost(int32, tag = "4")]
    pub display: i32,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Fingerprint {
    /// True when the fingprint is touched.
    #[prost(bool, tag = "1")]
    pub is_touching: bool,
    /// The identifier of the registered fingerprint.
    #[prost(int32, tag = "2")]
    pub touch_id: i32,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GpsState {
    /// Setting this to false will disable auto updating  from the LocationUI,
    /// otherwise the location UI will override the location at a frequency of
    /// 1hz.
    ///
    /// * This is unused if the emulator is launched with -no-window, or when he
    ///   location ui is disabled.
    /// * This will BREAK the location ui experience if it is set to false. For
    ///   example routing will no longer function.
    #[prost(bool, tag = "1")]
    pub passive_update: bool,
    /// The latitude, in degrees.
    #[prost(double, tag = "2")]
    pub latitude: f64,
    /// The longitude, in degrees.
    #[prost(double, tag = "3")]
    pub longitude: f64,
    /// The speed if it is available, in meters/second over ground
    #[prost(double, tag = "4")]
    pub speed: f64,
    /// gets the horizontal direction of travel of this device, and is not
    /// related to the device orientation. It is guaranteed to be in the
    /// range \[0.0, 360.0\] if the device has a bearing. 0=North, 90=East,
    /// 180=South, etc..
    #[prost(double, tag = "5")]
    pub bearing: f64,
    /// The altitude if available, in meters above the WGS 84 reference
    /// ellipsoid.
    #[prost(double, tag = "6")]
    pub altitude: f64,
    /// The number of satellites used to derive the fix
    #[prost(int32, tag = "7")]
    pub satellites: i32,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BatteryState {
    #[prost(bool, tag = "1")]
    pub has_battery: bool,
    #[prost(bool, tag = "2")]
    pub is_present: bool,
    #[prost(enumeration = "battery_state::BatteryCharger", tag = "3")]
    pub charger: i32,
    #[prost(int32, tag = "4")]
    pub charge_level: i32,
    #[prost(enumeration = "battery_state::BatteryHealth", tag = "5")]
    pub health: i32,
    #[prost(enumeration = "battery_state::BatteryStatus", tag = "6")]
    pub status: i32,
}
/// Nested message and enum types in `BatteryState`.
pub mod battery_state {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum BatteryStatus {
        Unknown = 0,
        Charging = 1,
        Discharging = 2,
        NotCharging = 3,
        Full = 4,
    }
    impl BatteryStatus {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unknown => "UNKNOWN",
                Self::Charging => "CHARGING",
                Self::Discharging => "DISCHARGING",
                Self::NotCharging => "NOT_CHARGING",
                Self::Full => "FULL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "UNKNOWN" => Some(Self::Unknown),
                "CHARGING" => Some(Self::Charging),
                "DISCHARGING" => Some(Self::Discharging),
                "NOT_CHARGING" => Some(Self::NotCharging),
                "FULL" => Some(Self::Full),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum BatteryCharger {
        None = 0,
        Ac = 1,
        Usb = 2,
        Wireless = 3,
    }
    impl BatteryCharger {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::None => "NONE",
                Self::Ac => "AC",
                Self::Usb => "USB",
                Self::Wireless => "WIRELESS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "NONE" => Some(Self::None),
                "AC" => Some(Self::Ac),
                "USB" => Some(Self::Usb),
                "WIRELESS" => Some(Self::Wireless),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum BatteryHealth {
        Good = 0,
        Failed = 1,
        Dead = 2,
        Overvoltage = 3,
        Overheated = 4,
    }
    impl BatteryHealth {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Good => "GOOD",
                Self::Failed => "FAILED",
                Self::Dead => "DEAD",
                Self::Overvoltage => "OVERVOLTAGE",
                Self::Overheated => "OVERHEATED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "GOOD" => Some(Self::Good),
                "FAILED" => Some(Self::Failed),
                "DEAD" => Some(Self::Dead),
                "OVERVOLTAGE" => Some(Self::Overvoltage),
                "OVERHEATED" => Some(Self::Overheated),
                _ => None,
            }
        }
    }
}
/// An ImageTransport allows for specifying a side channel for
/// delivering image frames versus using the standard bytes array that is
/// returned with the gRPC request.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImageTransport {
    /// The desired transport channel used for delivering image frames. Only
    /// relevant when streaming screenshots.
    #[prost(enumeration = "image_transport::TransportChannel", tag = "1")]
    pub channel: i32,
    /// Handle used for writing image frames if transport is mmap. The client
    /// sets and owns this handle. It can be either a shm region, or a mmap. A
    /// mmap should be a url that starts with `file:///` Note: the mmap can
    /// result in tearing.
    #[prost(string, tag = "2")]
    pub handle: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ImageTransport`.
pub mod image_transport {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum TransportChannel {
        /// Return full frames over the gRPC transport
        Unspecified = 0,
        /// Write images to the a file/shared memory handle.
        Mmap = 1,
    }
    impl TransportChannel {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "TRANSPORT_CHANNEL_UNSPECIFIED",
                Self::Mmap => "MMAP",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TRANSPORT_CHANNEL_UNSPECIFIED" => Some(Self::Unspecified),
                "MMAP" => Some(Self::Mmap),
                _ => None,
            }
        }
    }
}
/// The aspect ratio (width/height) will be different from the one
/// where the device is unfolded.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FoldedDisplay {
    #[prost(uint32, tag = "1")]
    pub width: u32,
    #[prost(uint32, tag = "2")]
    pub height: u32,
    /// It is possible for the screen to be folded in different ways depending
    /// on which surface is shown to the user. So xOffset and yOffset indicate
    /// the top left corner of the folded screen within the original unfolded
    /// screen.
    #[prost(uint32, tag = "3")]
    pub x_offset: u32,
    #[prost(uint32, tag = "4")]
    pub y_offset: u32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImageFormat {
    /// The (desired) format of the resulting bytes.
    #[prost(enumeration = "image_format::ImgFormat", tag = "1")]
    pub format: i32,
    /// \[Output Only\] The rotation of the image. The image will be rotated
    /// based upon the coarse grained orientation of the device.
    #[prost(message, optional, tag = "2")]
    pub rotation: ::core::option::Option<Rotation>,
    /// The (desired) width of the image. When passed as input
    /// the image will be scaled to match the given
    /// width, while maintaining the aspect ratio of the device.
    /// The returned image will never exceed the given width, but can be less.
    /// Omitting this value (or passing in 0) will result in no scaling,
    /// and the width of the actual device will be used.
    #[prost(uint32, tag = "3")]
    pub width: u32,
    /// The (desired) height of the image.  When passed as input
    /// the image will be scaled to match the given
    /// height, while maintaining the aspect ratio of the device.
    /// The returned image will never exceed the given height, but can be less.
    /// Omitting this value (or passing in 0) will result in no scaling,
    /// and the height of the actual device will be used.
    #[prost(uint32, tag = "4")]
    pub height: u32,
    /// The (desired) display id of the device. Setting this to 0 (or omitting)
    /// indicates the main display.
    #[prost(uint32, tag = "5")]
    pub display: u32,
    /// Set this if you wish to use a different transport channel to deliver
    /// image frames.
    #[prost(message, optional, tag = "6")]
    pub transport: ::core::option::Option<ImageTransport>,
    /// \[Output Only\] Display configuration when screen is folded. The value is
    /// the original configuration before scaling.
    #[prost(message, optional, tag = "7")]
    pub folded_display: ::core::option::Option<FoldedDisplay>,
    /// \[Output Only\] Display mode when AVD is resizable.
    #[prost(enumeration = "DisplayModeValue", tag = "8")]
    pub display_mode: i32,
}
/// Nested message and enum types in `ImageFormat`.
pub mod image_format {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ImgFormat {
        /// Portable Network Graphics format
        /// (<https://en.wikipedia.org/wiki/Portable_Network_Graphics>)
        Png = 0,
        /// Three-channel RGB color model supplemented with a fourth alpha
        /// channel. <https://en.wikipedia.org/wiki/RGBA_color_model>
        /// Each pixel consists of 4 bytes.
        Rgba8888 = 1,
        /// Three-channel RGB color model, each pixel consists of 3 bytes
        Rgb888 = 2,
    }
    impl ImgFormat {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Png => "PNG",
                Self::Rgba8888 => "RGBA8888",
                Self::Rgb888 => "RGB888",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PNG" => Some(Self::Png),
                "RGBA8888" => Some(Self::Rgba8888),
                "RGB888" => Some(Self::Rgb888),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Image {
    #[prost(message, optional, tag = "1")]
    pub format: ::core::option::Option<ImageFormat>,
    /// width is contained in format.
    #[deprecated]
    #[prost(uint32, tag = "2")]
    pub width: u32,
    /// height is contained in format.
    #[deprecated]
    #[prost(uint32, tag = "3")]
    pub height: u32,
    /// The organization of the pixels in the image buffer is from left to
    /// right and bottom up. This will be empty if an alternative image transport
    /// is requested in the image format. In that case the side channel should
    /// be used to obtain the image data.
    #[prost(bytes = "vec", tag = "4")]
    pub image: ::prost::alloc::vec::Vec<u8>,
    /// \[Output Only\] Monotonically increasing sequence number in a stream of
    /// screenshots. The first screenshot will have a sequence of 0. A single
    /// screenshot will always have a sequence number of 0. The sequence is not
    /// necessarily contiguous, and can be used to detect how many frames were
    /// dropped. An example sequence could be: \[0, 3, 5, 7, 9, 11\].
    #[prost(uint32, tag = "5")]
    pub seq: u32,
    /// \[Output Only\] Unix timestamp in microseconds when the emulator estimates
    /// the frame was generated. The timestamp is before the actual frame is
    /// copied and transformed. This can be used to calculate variance between
    /// frame production time, and frame depiction time.
    #[prost(uint64, tag = "6")]
    pub timestamp_us: u64,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct Rotation {
    /// The rotation of the device, derived from the sensor state
    /// of the emulator. The derivation reflects how android observes
    /// the rotation state.
    #[prost(enumeration = "rotation::SkinRotation", tag = "1")]
    pub rotation: i32,
    /// Specifies the angle of rotation, in degrees \[-180, 180\]
    #[prost(double, tag = "2")]
    pub x_axis: f64,
    #[prost(double, tag = "3")]
    pub y_axis: f64,
    #[prost(double, tag = "4")]
    pub z_axis: f64,
}
/// Nested message and enum types in `Rotation`.
pub mod rotation {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SkinRotation {
        /// 0 degrees
        Portrait = 0,
        /// 90 degrees
        Landscape = 1,
        /// -180 degrees
        ReversePortrait = 2,
        /// -90 degrees
        ReverseLandscape = 3,
    }
    impl SkinRotation {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Portrait => "PORTRAIT",
                Self::Landscape => "LANDSCAPE",
                Self::ReversePortrait => "REVERSE_PORTRAIT",
                Self::ReverseLandscape => "REVERSE_LANDSCAPE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PORTRAIT" => Some(Self::Portrait),
                "LANDSCAPE" => Some(Self::Landscape),
                "REVERSE_PORTRAIT" => Some(Self::ReversePortrait),
                "REVERSE_LANDSCAPE" => Some(Self::ReverseLandscape),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PhoneCall {
    #[prost(enumeration = "phone_call::Operation", tag = "1")]
    pub operation: i32,
    #[prost(string, tag = "2")]
    pub number: ::prost::alloc::string::String,
}
/// Nested message and enum types in `PhoneCall`.
pub mod phone_call {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Operation {
        InitCall = 0,
        AcceptCall = 1,
        RejectCallExplicit = 2,
        RejectCallBusy = 3,
        DisconnectCall = 4,
        PlaceCallOnHold = 5,
        TakeCallOffHold = 6,
    }
    impl Operation {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::InitCall => "InitCall",
                Self::AcceptCall => "AcceptCall",
                Self::RejectCallExplicit => "RejectCallExplicit",
                Self::RejectCallBusy => "RejectCallBusy",
                Self::DisconnectCall => "DisconnectCall",
                Self::PlaceCallOnHold => "PlaceCallOnHold",
                Self::TakeCallOffHold => "TakeCallOffHold",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "InitCall" => Some(Self::InitCall),
                "AcceptCall" => Some(Self::AcceptCall),
                "RejectCallExplicit" => Some(Self::RejectCallExplicit),
                "RejectCallBusy" => Some(Self::RejectCallBusy),
                "DisconnectCall" => Some(Self::DisconnectCall),
                "PlaceCallOnHold" => Some(Self::PlaceCallOnHold),
                "TakeCallOffHold" => Some(Self::TakeCallOffHold),
                _ => None,
            }
        }
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PhoneResponse {
    #[prost(enumeration = "phone_response::Response", tag = "1")]
    pub response: i32,
}
/// Nested message and enum types in `PhoneResponse`.
pub mod phone_response {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Response {
        Ok = 0,
        /// Enum out of range
        BadOperation = 1,
        /// Mal-formed telephone number
        BadNumber = 2,
        /// E.g., disconnect when no call is in progress
        InvalidAction = 3,
        /// Internal error
        ActionFailed = 4,
        /// Radio power off
        RadioOff = 5,
    }
    impl Response {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Ok => "OK",
                Self::BadOperation => "BadOperation",
                Self::BadNumber => "BadNumber",
                Self::InvalidAction => "InvalidAction",
                Self::ActionFailed => "ActionFailed",
                Self::RadioOff => "RadioOff",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "OK" => Some(Self::Ok),
                "BadOperation" => Some(Self::BadOperation),
                "BadNumber" => Some(Self::BadNumber),
                "InvalidAction" => Some(Self::InvalidAction),
                "ActionFailed" => Some(Self::ActionFailed),
                "RadioOff" => Some(Self::RadioOff),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Entry {
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub value: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EntryList {
    #[prost(message, repeated, tag = "1")]
    pub entry: ::prost::alloc::vec::Vec<Entry>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EmulatorStatus {
    /// The emulator version string.
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
    /// The time the emulator has been active in .ms
    #[prost(uint64, tag = "2")]
    pub uptime: u64,
    /// True if the device has completed booting.
    /// For P and later this information will accurate,
    /// for older images we rely on adb.
    #[prost(bool, tag = "3")]
    pub booted: bool,
    /// The current vm configuration
    #[prost(message, optional, tag = "4")]
    pub vm_config: ::core::option::Option<VmConfiguration>,
    /// The hardware configuration of the running emulator as
    /// key valure pairs.
    #[prost(message, optional, tag = "5")]
    pub hardware_config: ::core::option::Option<EntryList>,
    /// Some guests will produce a heart beat, that can be used to
    /// detect if the guest is active.
    /// This is a monotonically increasing number that gets incremented
    /// around once a second.
    #[prost(uint64, tag = "6")]
    pub heartbeat: u64,
    /// The configuration of services in the guest, this map
    /// contains key value pairs that are specific to the image
    /// used by the guest.
    #[prost(map = "string, string", tag = "7")]
    pub guest_config: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AudioFormat {
    /// Sampling rate to use, defaulting to 44100 if this is not set.
    /// Note, that android devices typically will not use a sampling
    /// rate higher than 48kHz. See
    /// <https://developer.android.com/ndk/guides/audio.>
    #[prost(uint64, tag = "1")]
    pub sampling_rate: u64,
    #[prost(enumeration = "audio_format::Channels", tag = "2")]
    pub channels: i32,
    #[prost(enumeration = "audio_format::SampleFormat", tag = "3")]
    pub format: i32,
    /// \[Input Only\]
    /// The mode used when delivering audio packets.
    #[prost(enumeration = "audio_format::DeliveryMode", tag = "4")]
    pub mode: i32,
}
/// Nested message and enum types in `AudioFormat`.
pub mod audio_format {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SampleFormat {
        /// Unsigned 8 bit
        AudFmtU8 = 0,
        /// Signed 16 bit (little endian)
        AudFmtS16 = 1,
    }
    impl SampleFormat {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::AudFmtU8 => "AUD_FMT_U8",
                Self::AudFmtS16 => "AUD_FMT_S16",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "AUD_FMT_U8" => Some(Self::AudFmtU8),
                "AUD_FMT_S16" => Some(Self::AudFmtS16),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Channels {
        Mono = 0,
        Stereo = 1,
    }
    impl Channels {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Mono => "Mono",
                Self::Stereo => "Stereo",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "Mono" => Some(Self::Mono),
                "Stereo" => Some(Self::Stereo),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DeliveryMode {
        /// The audio queue will block and wait until the emulator requests
        /// packets. The client does not have to throttle and can push packets at
        /// will. This can result in the client falling behind.
        ModeUnspecified = 0,
        /// Audio packets will be delivered in real time (when possible). The
        /// audio queue will be overwritten with incoming data if data is made
        /// available. This means the client needs to control timing properly, or
        /// packets will get overwritten.
        ModeRealTime = 1,
    }
    impl DeliveryMode {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::ModeUnspecified => "MODE_UNSPECIFIED",
                Self::ModeRealTime => "MODE_REAL_TIME",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MODE_UNSPECIFIED" => Some(Self::ModeUnspecified),
                "MODE_REAL_TIME" => Some(Self::ModeRealTime),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AudioPacket {
    #[prost(message, optional, tag = "1")]
    pub format: ::core::option::Option<AudioFormat>,
    /// Unix epoch in us when this frame was captured.
    #[prost(uint64, tag = "2")]
    pub timestamp: u64,
    /// Contains a sample in the given audio format.
    #[prost(bytes = "vec", tag = "3")]
    pub audio: ::prost::alloc::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SmsMessage {
    /// The source address where this message came from.
    ///
    /// The address should be a valid GSM-formatted address as specified by
    /// 3GPP 23.040 Sec 9.1.2.5.
    ///
    /// For example: +3106225412 or (650) 555-1221
    #[prost(string, tag = "1")]
    pub src_address: ::prost::alloc::string::String,
    /// A utf8 encoded text message that should be delivered.
    #[prost(string, tag = "2")]
    pub text: ::prost::alloc::string::String,
}
/// A DisplayConfiguration describes a primary or secondary
/// display available to the emulator. The screen aspect ratio
/// cannot be longer (or wider) than 21:9 (or 9:21). Screen sizes
/// larger than 4k will be rejected.
///
/// Common configurations (w x h) are:
///
/// * 480p  (480x720)   142 dpi
/// * 720p  (720x1280)  213 dpi
/// * 1080p (1080x1920) 320 dpi
/// * 4K  (2160x3840) 320 dpi
/// * 4K  (2160x3840) 640 dpi (upscaled)
///
/// The behavior of the virtual display depends on the flags that are provided to
/// this method. By default, virtual displays are created to be private,
/// non-presentation and unsecure.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DisplayConfiguration {
    /// The width of the display, restricted to:
    /// 320 * (dpi / 160) \<= width
    #[prost(uint32, tag = "1")]
    pub width: u32,
    /// The heigh of the display, restricted to:
    ///
    /// * 320 * (dpi / 160) \<= height
    #[prost(uint32, tag = "2")]
    pub height: u32,
    /// The pixel density (dpi).
    /// See <https://developer.android.com/training/multiscreen/screendensities>
    /// for details. This value should be in the range \[120, ..., 640\]
    #[prost(uint32, tag = "3")]
    pub dpi: u32,
    /// A combination of virtual display flags. These flags can be constructed
    /// by combining the DisplayFlags enum described above.
    ///
    /// The behavior of the virtual display depends on the flags. By default
    /// virtual displays are created to be private, non-presentation and
    /// unsecure.
    #[prost(uint32, tag = "4")]
    pub flags: u32,
    /// The id of the display.
    /// The primary (default) display has the display ID of 0.
    /// A secondary display has a display ID not 0.
    ///
    /// A display with the id in the range \[1, userConfigurable\]
    /// can be modified. See DisplayConfigurations below for details.
    ///
    /// The id can be used to get or stream a screenshot.
    #[prost(uint32, tag = "5")]
    pub display: u32,
}
/// Nested message and enum types in `DisplayConfiguration`.
pub mod display_configuration {
    /// These are the set of known android flags and their respective values.
    /// you can combine the int values to (de)construct the flags field below.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DisplayFlags {
        DisplayflagsUnspecified = 0,
        /// When this flag is set, the virtual display is public.
        /// A public virtual display behaves just like most any other display
        /// that is connected to the system such as an external or wireless
        /// display. Applications can open windows on the display and the system
        /// may mirror the contents of other displays onto it. see:
        /// <https://developer.android.com/reference/android/hardware/display/DisplayManager#VIRTUAL_DISPLAY_FLAG_PUBLIC>
        VirtualDisplayFlagPublic = 1,
        /// When this flag is set, the virtual display is registered as a
        /// presentation display in the presentation display category.
        /// Applications may automatically project their content to presentation
        /// displays to provide richer second screen experiences.
        /// <https://developer.android.com/reference/android/hardware/display/DisplayManager#VIRTUAL_DISPLAY_FLAG_PRESENTATION>
        VirtualDisplayFlagPresentation = 2,
        /// When this flag is set, the virtual display is considered secure as
        /// defined by the Display#FLAG_SECURE display flag. The caller promises
        /// to take reasonable measures, such as over-the-air encryption, to
        /// prevent the contents of the display from being intercepted or
        /// recorded on a persistent medium.
        /// see:
        /// <https://developer.android.com/reference/android/hardware/display/DisplayManager#VIRTUAL_DISPLAY_FLAG_SECURE>
        VirtualDisplayFlagSecure = 4,
        /// This flag is used in conjunction with VIRTUAL_DISPLAY_FLAG_PUBLIC.
        /// Ordinarily public virtual displays will automatically mirror the
        /// content of the default display if they have no windows of their own.
        /// When this flag is specified, the virtual display will only ever show
        /// its own content and will be blanked instead if it has no windows. See
        /// <https://developer.android.com/reference/android/hardware/display/DisplayManager#VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY>
        VirtualDisplayFlagOwnContentOnly = 8,
        /// Allows content to be mirrored on private displays when no content is
        /// being shown.
        /// This flag is mutually exclusive with
        /// VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY. If both flags are specified
        /// then the own-content only behavior will be applied.
        /// see:
        /// <https://developer.android.com/reference/android/hardware/display/DisplayManager#VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR>)
        VirtualDisplayFlagAutoMirror = 16,
    }
    impl DisplayFlags {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::DisplayflagsUnspecified => "DISPLAYFLAGS_UNSPECIFIED",
                Self::VirtualDisplayFlagPublic => "VIRTUAL_DISPLAY_FLAG_PUBLIC",
                Self::VirtualDisplayFlagPresentation => {
                    "VIRTUAL_DISPLAY_FLAG_PRESENTATION"
                }
                Self::VirtualDisplayFlagSecure => "VIRTUAL_DISPLAY_FLAG_SECURE",
                Self::VirtualDisplayFlagOwnContentOnly => {
                    "VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY"
                }
                Self::VirtualDisplayFlagAutoMirror => "VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DISPLAYFLAGS_UNSPECIFIED" => Some(Self::DisplayflagsUnspecified),
                "VIRTUAL_DISPLAY_FLAG_PUBLIC" => Some(Self::VirtualDisplayFlagPublic),
                "VIRTUAL_DISPLAY_FLAG_PRESENTATION" => {
                    Some(Self::VirtualDisplayFlagPresentation)
                }
                "VIRTUAL_DISPLAY_FLAG_SECURE" => Some(Self::VirtualDisplayFlagSecure),
                "VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY" => {
                    Some(Self::VirtualDisplayFlagOwnContentOnly)
                }
                "VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR" => {
                    Some(Self::VirtualDisplayFlagAutoMirror)
                }
                _ => None,
            }
        }
    }
}
/// Provides information about all the displays that can be attached
/// to the emulator. The emulator will always have at least one display.
///
/// The emulator usually has the following display configurations:
/// 0:      The default display.
/// 1 - 3:  User configurable displays. These can be added/removed.
/// For example the standalone emulator allows you to modify these
/// in the extended controls.
/// 6 - 11: Fixed external displays. For example Android Auto uses fixed
/// displays in this range.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DisplayConfigurations {
    #[prost(message, repeated, tag = "1")]
    pub displays: ::prost::alloc::vec::Vec<DisplayConfiguration>,
    /// Display configurations with id \[1, userConfigurable\] are
    /// user configurable, that is they can be added, removed or
    /// updated.
    #[prost(uint32, tag = "2")]
    pub user_configurable: u32,
    /// The maximum number of attached displays this emulator supports.
    /// This is the total number of displays that can be attached to
    /// the emulator.
    ///
    /// Note: A display with an id that is larger than userConfigurable cannot
    /// be modified.
    #[prost(uint32, tag = "3")]
    pub max_displays: u32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Notification {
    /// Deprecated, use the type below to get detailed information
    /// regarding the event.
    #[deprecated]
    #[prost(enumeration = "notification::EventType", tag = "1")]
    pub event: i32,
    /// Detailed notification information.
    #[prost(oneof = "notification::Type", tags = "2, 3, 4, 5, 6")]
    pub r#type: ::core::option::Option<notification::Type>,
}
/// Nested message and enum types in `Notification`.
pub mod notification {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum EventType {
        VirtualSceneCameraInactive = 0,
        VirtualSceneCameraActive = 1,
        /// Fired when an update to a display event has been fired through
        /// the extended ui. This does not fire events when the display
        /// is changed through the console or gRPC endpoint.
        DisplayConfigurationsChangedUi = 2,
    }
    impl EventType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::VirtualSceneCameraInactive => "VIRTUAL_SCENE_CAMERA_INACTIVE",
                Self::VirtualSceneCameraActive => "VIRTUAL_SCENE_CAMERA_ACTIVE",
                Self::DisplayConfigurationsChangedUi => {
                    "DISPLAY_CONFIGURATIONS_CHANGED_UI"
                }
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "VIRTUAL_SCENE_CAMERA_INACTIVE" => Some(Self::VirtualSceneCameraInactive),
                "VIRTUAL_SCENE_CAMERA_ACTIVE" => Some(Self::VirtualSceneCameraActive),
                "DISPLAY_CONFIGURATIONS_CHANGED_UI" => {
                    Some(Self::DisplayConfigurationsChangedUi)
                }
                _ => None,
            }
        }
    }
    /// Detailed notification information.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        #[prost(message, tag = "2")]
        CameraNotification(super::CameraNotification),
        #[prost(message, tag = "3")]
        DisplayConfigurationsChangedNotification(
            super::DisplayConfigurationsChangedNotification,
        ),
        #[prost(message, tag = "4")]
        Posture(super::Posture),
        #[prost(message, tag = "5")]
        Booted(super::BootCompletedNotification),
        #[prost(message, tag = "6")]
        Brightness(super::BrightnessValue),
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BootCompletedNotification {
    /// The time in milliseconds it took for the boot to complete.
    /// Note that this value can be 0 when you are loading from a snapshot.
    #[prost(int32, tag = "1")]
    pub time: i32,
}
/// Fired when the virtual scene camera is activated or deactivated and also in
/// response to the streamNotification call.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CameraNotification {
    /// Indicates whether the camera app was activated or deactivated.
    #[prost(bool, tag = "1")]
    pub active: bool,
    /// The display the camera app is associated with.
    #[prost(int32, tag = "2")]
    pub display: i32,
}
/// Fired when an update to a display event has been fired through the extended
/// ui. This does not fire events when the display is changed through the console
/// or the gRPC endpoint.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DisplayConfigurationsChangedNotification {
    #[prost(message, optional, tag = "1")]
    pub display_configurations: ::core::option::Option<DisplayConfigurations>,
}
/// Rotation angles are relative to the current orientation.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct RotationRadian {
    /// Angle of rotation around the x axis in right-handed direction.
    #[prost(float, tag = "1")]
    pub x: f32,
    /// Angle of rotation around the y axis in right-handed direction.
    #[prost(float, tag = "2")]
    pub y: f32,
    /// Angle of rotation around the z axis in right-handed direction.
    #[prost(float, tag = "3")]
    pub z: f32,
}
/// Velocity is measured in meters per second.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct Velocity {
    #[prost(float, tag = "1")]
    pub x: f32,
    #[prost(float, tag = "2")]
    pub y: f32,
    #[prost(float, tag = "3")]
    pub z: f32,
}
/// Must follow the definition in "external/qemu/android/hw-sensors.h"
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Posture {
    #[prost(enumeration = "posture::PostureValue", tag = "3")]
    pub value: i32,
}
/// Nested message and enum types in `Posture`.
pub mod posture {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum PostureValue {
        PostureUnknown = 0,
        PostureClosed = 1,
        PostureHalfOpened = 2,
        PostureOpened = 3,
        PostureFlipped = 4,
        PostureTent = 5,
        PostureMax = 6,
    }
    impl PostureValue {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::PostureUnknown => "POSTURE_UNKNOWN",
                Self::PostureClosed => "POSTURE_CLOSED",
                Self::PostureHalfOpened => "POSTURE_HALF_OPENED",
                Self::PostureOpened => "POSTURE_OPENED",
                Self::PostureFlipped => "POSTURE_FLIPPED",
                Self::PostureTent => "POSTURE_TENT",
                Self::PostureMax => "POSTURE_MAX",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "POSTURE_UNKNOWN" => Some(Self::PostureUnknown),
                "POSTURE_CLOSED" => Some(Self::PostureClosed),
                "POSTURE_HALF_OPENED" => Some(Self::PostureHalfOpened),
                "POSTURE_OPENED" => Some(Self::PostureOpened),
                "POSTURE_FLIPPED" => Some(Self::PostureFlipped),
                "POSTURE_TENT" => Some(Self::PostureTent),
                "POSTURE_MAX" => Some(Self::PostureMax),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PhoneNumber {
    /// The phone number should be a valid GSM-formatted number as specified by
    /// 3GPP 23.040 Sec 9.1.2.5.
    ///
    /// For example: +3106225412 or (650) 555-1221
    #[prost(string, tag = "1")]
    pub number: ::prost::alloc::string::String,
}
/// in line with android/emulation/resizable_display_config.h
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DisplayModeValue {
    Phone = 0,
    Foldable = 1,
    Tablet = 2,
    Desktop = 3,
}
impl DisplayModeValue {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Phone => "PHONE",
            Self::Foldable => "FOLDABLE",
            Self::Tablet => "TABLET",
            Self::Desktop => "DESKTOP",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PHONE" => Some(Self::Phone),
            "FOLDABLE" => Some(Self::Foldable),
            "TABLET" => Some(Self::Tablet),
            "DESKTOP" => Some(Self::Desktop),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod emulator_controller_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// An EmulatorController service lets you control the emulator.
    /// Note that this is currently an experimental feature, and that the
    /// service definition might change without notice. Use at your own risk!
    ///
    /// We use the following rough conventions:
    ///
    /// streamXXX --> streams values XXX (usually for emulator lifetime). Values
    /// are updated as soon as they become available.
    /// getXXX    --> gets a single value XXX
    /// setXXX    --> sets a single value XXX, does not returning state, these
    /// usually have an observable lasting side effect.
    /// sendXXX   --> send a single event XXX, possibly returning state information.
    /// android usually responds to these events.
    #[derive(Debug, Clone)]
    pub struct EmulatorControllerClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl EmulatorControllerClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> EmulatorControllerClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> EmulatorControllerClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            EmulatorControllerClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// set/get/stream the sensor data
        pub async fn stream_sensor(
            &mut self,
            request: impl tonic::IntoRequest<super::SensorValue>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::SensorValue>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/streamSensor",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "streamSensor",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        pub async fn get_sensor(
            &mut self,
            request: impl tonic::IntoRequest<super::SensorValue>,
        ) -> std::result::Result<tonic::Response<super::SensorValue>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/getSensor",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "getSensor",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_sensor(
            &mut self,
            request: impl tonic::IntoRequest<super::SensorValue>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/setSensor",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "setSensor",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// set/get/stream the physical model, this is likely the one you are
        /// looking for when you wish to modify the device state.
        pub async fn set_physical_model(
            &mut self,
            request: impl tonic::IntoRequest<super::PhysicalModelValue>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/setPhysicalModel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "setPhysicalModel",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_physical_model(
            &mut self,
            request: impl tonic::IntoRequest<super::PhysicalModelValue>,
        ) -> std::result::Result<
            tonic::Response<super::PhysicalModelValue>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/getPhysicalModel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "getPhysicalModel",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn stream_physical_model(
            &mut self,
            request: impl tonic::IntoRequest<super::PhysicalModelValue>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::PhysicalModelValue>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/streamPhysicalModel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "streamPhysicalModel",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        /// Atomically set/get the current primary clipboard data.
        /// Note that a call to setClipboard will result in an immediate
        /// event for those who made a call to streamClipboard and are
        /// on a different channel than the one used to set the clipboard.
        pub async fn set_clipboard(
            &mut self,
            request: impl tonic::IntoRequest<super::ClipData>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/setClipboard",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "setClipboard",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_clipboard(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::ClipData>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/getClipboard",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "getClipboard",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Streams the current data on the clipboard. This will immediately produce
        /// a result with the current state of the clipboard after which the stream
        /// will block and wait until a new clip event is available from the guest.
        /// Calling the setClipboard method above will not result in generating a
        /// clip event. It is possible to lose clipboard events if the clipboard
        /// updates very rapidly.
        pub async fn stream_clipboard(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::ClipData>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/streamClipboard",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "streamClipboard",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        /// Set/get the battery to the given state.
        pub async fn set_battery(
            &mut self,
            request: impl tonic::IntoRequest<super::BatteryState>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/setBattery",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "setBattery",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_battery(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::BatteryState>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/getBattery",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "getBattery",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Set the state of the gps.
        /// Note: Setting the gps position will not be reflected in the user
        /// interface. Keep in mind that android usually only samples the gps at 1
        /// hz.
        pub async fn set_gps(
            &mut self,
            request: impl tonic::IntoRequest<super::GpsState>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/setGps",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "setGps",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the latest gps state as delivered by the setGps call, or location ui
        /// if active.
        ///
        /// Note: this is not necessarily the actual gps coordinate visible at the
        /// time, due to gps sample frequency (usually 1hz).
        pub async fn get_gps(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::GpsState>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/getGps",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "getGps",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Simulate a touch event on the finger print sensor.
        pub async fn send_fingerprint(
            &mut self,
            request: impl tonic::IntoRequest<super::Fingerprint>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/sendFingerprint",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "sendFingerprint",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Send a keyboard event. Translating the event.
        pub async fn send_key(
            &mut self,
            request: impl tonic::IntoRequest<super::KeyboardEvent>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/sendKey",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "sendKey",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Send touch/mouse events. Note that mouse events can be simulated
        /// by touch events.
        pub async fn send_touch(
            &mut self,
            request: impl tonic::IntoRequest<super::TouchEvent>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/sendTouch",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "sendTouch",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn send_mouse(
            &mut self,
            request: impl tonic::IntoRequest<super::MouseEvent>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/sendMouse",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "sendMouse",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn inject_wheel(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::WheelEvent>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/injectWheel",
            );
            let mut req = request.into_streaming_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "injectWheel",
                    ),
                );
            self.inner.client_streaming(req, path, codec).await
        }
        /// Stream a series of input events to the emulator, the events will
        /// arrive in order.
        pub async fn stream_input_event(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::InputEvent>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/streamInputEvent",
            );
            let mut req = request.into_streaming_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "streamInputEvent",
                    ),
                );
            self.inner.client_streaming(req, path, codec).await
        }
        /// Make a phone call.
        pub async fn send_phone(
            &mut self,
            request: impl tonic::IntoRequest<super::PhoneCall>,
        ) -> std::result::Result<tonic::Response<super::PhoneResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/sendPhone",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "sendPhone",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sends an sms message to the emulator.
        pub async fn send_sms(
            &mut self,
            request: impl tonic::IntoRequest<super::SmsMessage>,
        ) -> std::result::Result<tonic::Response<super::PhoneResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/sendSms",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "sendSms",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sends an sms message to the emulator.
        pub async fn set_phone_number(
            &mut self,
            request: impl tonic::IntoRequest<super::PhoneNumber>,
        ) -> std::result::Result<tonic::Response<super::PhoneResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/setPhoneNumber",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "setPhoneNumber",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieve the status of the emulator. This will contain general
        /// hardware information, and whether the device has booted or not.
        pub async fn get_status(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::EmulatorStatus>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/getStatus",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "getStatus",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets an individual screenshot in the desired format.
        ///
        /// The image will be scaled to the desired ImageFormat, while maintaining
        /// the aspect ratio. The returned image will never exceed resolution of the
        /// device display. Not setting the width or height (i.e. they are 0) will
        /// result in using the display width and height.
        ///
        /// The resulting image will be properly oriented and can be displayed
        /// directly without post processing. For example, if the device has a
        /// 1080x1920 screen and is in landscape mode and called with no width or
        /// height parameter, it will return a 1920x1080 image.
        ///
        /// The dimensions of the returned image will never exceed the corresponding
        /// display dimensions. For example, this method will return a 1920x1080
        /// screenshot, if the display resolution is 1080x1920 and a screenshot of
        /// 2048x2048 is requested when the device is in landscape mode.
        ///
        /// This method will return an empty image if the display is not visible.
        pub async fn get_screenshot(
            &mut self,
            request: impl tonic::IntoRequest<super::ImageFormat>,
        ) -> std::result::Result<tonic::Response<super::Image>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/getScreenshot",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "getScreenshot",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Streams a series of screenshots in the desired format.
        ///
        /// A new frame will be delivered whenever the device produces a new frame.
        /// Beware that this can produce a significant amount of data and that
        /// certain translations can be very costly. For example, streaming a series
        /// of png images is very cpu intensive.
        ///
        /// Images are produced according to the getScreenshot API described above.
        ///
        /// If the display is inactive, or becomes inactive, an empty image will be
        /// delivered. Images will be delived again if the display becomes active and
        /// new frames are produced.
        pub async fn stream_screenshot(
            &mut self,
            request: impl tonic::IntoRequest<super::ImageFormat>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::Image>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/streamScreenshot",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "streamScreenshot",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        /// Streams a series of audio packets in the desired format.
        /// A new frame will be delivered whenever the emulated device
        /// produces a new audio frame. You can expect packets to be
        /// delivered in intervals of 20-30ms.
        ///
        /// Be aware that this can block when the emulator does not
        /// produce any audio whatsoever!
        pub async fn stream_audio(
            &mut self,
            request: impl tonic::IntoRequest<super::AudioFormat>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::AudioPacket>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/streamAudio",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "streamAudio",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        /// Injects a series of audio packets to the android microphone.
        /// A new frame will be delivered whenever the emulated device
        /// requests a new audio frame. Audio is usually delivered at a rate
        /// that the emulator is requesting frames. Audio will be stored in a
        /// temporary buffer that can hold 300ms of audio.
        ///
        /// Notes:
        ///
        /// * Only the first audio format packet that is delivered will be
        ///  honored. There is no need to send the audio format multiple times.
        ///
        /// * Real time audio currently immediately overrides the buffer. This
        ///  means you must provide a constant rate of audio packets. The real
        ///  time mode is experimental. Timestamps of audio packets might be
        ///  used in the future to improve synchronization.
        ///
        /// * INVALID_ARGUMENT (code 3) The sampling rate was too high/low
        ///
        /// * INVALID_ARGUMENT (code 3) The audio packet was too large to handle.
        ///
        /// * FAILED_PRECONDITION (code 9) If there was a microphone registered
        ///  already.
        pub async fn inject_audio(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::AudioPacket>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/injectAudio",
            );
            let mut req = request.into_streaming_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "injectAudio",
                    ),
                );
            self.inner.client_streaming(req, path, codec).await
        }
        /// Deprecated, please use the streamLogcat method instead.
        #[deprecated]
        pub async fn get_logcat(
            &mut self,
            request: impl tonic::IntoRequest<super::LogMessage>,
        ) -> std::result::Result<tonic::Response<super::LogMessage>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/getLogcat",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "getLogcat",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Streams the logcat output from the emulator.
        /// Note that parsed logcat messages are only available after L (Api >23)
        pub async fn stream_logcat(
            &mut self,
            request: impl tonic::IntoRequest<super::LogMessage>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::LogMessage>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/streamLogcat",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "streamLogcat",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        /// Transition the virtual machine to the desired state. Note that
        /// some states are only observable. For example you cannot transition
        /// to the error state.
        pub async fn set_vm_state(
            &mut self,
            request: impl tonic::IntoRequest<super::VmRunState>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/setVmState",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "setVmState",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the state of the virtual machine.
        pub async fn get_vm_state(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::VmRunState>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/getVmState",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "getVmState",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Atomically changes the current multi-display configuration.
        /// After this call the given display configurations will be activated. You
        /// can only update secondary displays. Displays with id 0 will be ignored.
        ///
        /// This call can result in the removal or addition of secondary displays,
        /// the final display state can be observed by the returned configuration.
        ///
        /// The following gRPC error codes can be returned:
        ///
        /// * FAILED_PRECONDITION (code 9) if the AVD does not support a
        ///  configurable
        ///  secondary display.
        /// * INVALID_ARGUMENT (code 3) if:
        ///  * The same display id is defined multiple times.
        ///  * The display configurations are outside valid ranges.
        ///    See DisplayConfiguration for details on valid ranges.
        /// * INTERNAL (code 13) if there was an internal emulator failure.
        pub async fn set_display_configurations(
            &mut self,
            request: impl tonic::IntoRequest<super::DisplayConfigurations>,
        ) -> std::result::Result<
            tonic::Response<super::DisplayConfigurations>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/setDisplayConfigurations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "setDisplayConfigurations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns all currently valid logical displays.
        ///
        /// The gRPC error code FAILED_PRECONDITION (code 9) is returned if the AVD
        /// does not support a configurable secondary display.
        pub async fn get_display_configurations(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<super::DisplayConfigurations>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/getDisplayConfigurations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "getDisplayConfigurations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Notifies client of the following changes:
        ///
        /// * Virtual scene camera status change.
        /// * Display configuration changes from extended ui. This will only be fired
        ///  if the user makes modifications the extended displays through the
        ///  extended control tab.
        ///
        /// Note that this method will send the initial virtual scene state
        /// immediately.
        pub async fn stream_notification(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::Notification>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/streamNotification",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "streamNotification",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        /// Rotation angles are relative to the camera's current orientation.
        /// The coordinate system is right-handed and is defined as follows:
        /// x axis is pointing right
        /// y axis is pointing up
        /// z axis is pointing towards the viewer
        /// The z component of rotation is not used when calling this method.
        pub async fn rotate_virtual_scene_camera(
            &mut self,
            request: impl tonic::IntoRequest<super::RotationRadian>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/rotateVirtualSceneCamera",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "rotateVirtualSceneCamera",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Velocity is absolute and is measured in meters per second.
        /// The coordinate system is right-handed and is defined as follows:
        /// x axis is pointing right
        /// y axis is pointing up
        /// z axis is pointing towards the viewer
        pub async fn set_virtual_scene_camera_velocity(
            &mut self,
            request: impl tonic::IntoRequest<super::Velocity>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/setVirtualSceneCameraVelocity",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "setVirtualSceneCameraVelocity",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Set foldable posture
        pub async fn set_posture(
            &mut self,
            request: impl tonic::IntoRequest<super::Posture>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/setPosture",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "setPosture",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get the backlight brightness.
        /// The following gRPC error codes can be returned:
        ///
        /// * FAILED_PRECONDITION (code 9) if the AVD does not support hw-control.
        pub async fn get_brightness(
            &mut self,
            request: impl tonic::IntoRequest<super::BrightnessValue>,
        ) -> std::result::Result<
            tonic::Response<super::BrightnessValue>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/getBrightness",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "getBrightness",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Set the backlight brightness.
        /// The following gRPC error codes can be returned:
        ///
        /// * FAILED_PRECONDITION (code 9) if the AVD does not support hw-control.
        /// * INVALID_ARGUMENT (code 3) The brightness exceeds the valid range.
        pub async fn set_brightness(
            &mut self,
            request: impl tonic::IntoRequest<super::BrightnessValue>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/setBrightness",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "setBrightness",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the current mode of the primary display of a resizable AVD.
        /// The following gRPC error codes can be returned:
        ///
        /// * FAILED_PRECONDITION (code 9) if the AVD is not resizable.
        pub async fn get_display_mode(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::DisplayMode>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/getDisplayMode",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "getDisplayMode",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sets the size of the primary display of a resizable AVD. Fails if the AVD
        /// is not resizable. The following gRPC error codes can be returned:
        ///
        /// * FAILED_PRECONDITION (code 9) if the AVD is not resizable.
        pub async fn set_display_mode(
            &mut self,
            request: impl tonic::IntoRequest<super::DisplayMode>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/android.emulation.control.EmulatorController/setDisplayMode",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "android.emulation.control.EmulatorController",
                        "setDisplayMode",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}