# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""

import grpc
from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2

from . import emulator_controller_pb2 as emulator__controller__pb2

GRPC_GENERATED_VERSION = "1.78.0"
GRPC_VERSION = grpc.__version__
_version_not_supported = False

try:
    from grpc._utilities import first_version_is_lower

    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
    _version_not_supported = True

if _version_not_supported:
    raise RuntimeError(
        f"The grpc package installed is at version {GRPC_VERSION},"
        + " but the generated code in emulator_controller_pb2_grpc.py depends on"
        + f" grpcio>={GRPC_GENERATED_VERSION}."
        + f" Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}"
        + f" or downgrade your generated code using grpcio-tools<={GRPC_VERSION}."
    )


class EmulatorControllerStub(object):
    """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.
    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.streamSensor = channel.unary_stream(
            "/android.emulation.control.EmulatorController/streamSensor",
            request_serializer=emulator__controller__pb2.SensorValue.SerializeToString,
            response_deserializer=emulator__controller__pb2.SensorValue.FromString,
            _registered_method=True,
        )
        self.getSensor = channel.unary_unary(
            "/android.emulation.control.EmulatorController/getSensor",
            request_serializer=emulator__controller__pb2.SensorValue.SerializeToString,
            response_deserializer=emulator__controller__pb2.SensorValue.FromString,
            _registered_method=True,
        )
        self.setSensor = channel.unary_unary(
            "/android.emulation.control.EmulatorController/setSensor",
            request_serializer=emulator__controller__pb2.SensorValue.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.setPhysicalModel = channel.unary_unary(
            "/android.emulation.control.EmulatorController/setPhysicalModel",
            request_serializer=emulator__controller__pb2.PhysicalModelValue.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.getPhysicalModel = channel.unary_unary(
            "/android.emulation.control.EmulatorController/getPhysicalModel",
            request_serializer=emulator__controller__pb2.PhysicalModelValue.SerializeToString,
            response_deserializer=emulator__controller__pb2.PhysicalModelValue.FromString,
            _registered_method=True,
        )
        self.streamPhysicalModel = channel.unary_stream(
            "/android.emulation.control.EmulatorController/streamPhysicalModel",
            request_serializer=emulator__controller__pb2.PhysicalModelValue.SerializeToString,
            response_deserializer=emulator__controller__pb2.PhysicalModelValue.FromString,
            _registered_method=True,
        )
        self.setClipboard = channel.unary_unary(
            "/android.emulation.control.EmulatorController/setClipboard",
            request_serializer=emulator__controller__pb2.ClipData.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.getClipboard = channel.unary_unary(
            "/android.emulation.control.EmulatorController/getClipboard",
            request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            response_deserializer=emulator__controller__pb2.ClipData.FromString,
            _registered_method=True,
        )
        self.streamClipboard = channel.unary_stream(
            "/android.emulation.control.EmulatorController/streamClipboard",
            request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            response_deserializer=emulator__controller__pb2.ClipData.FromString,
            _registered_method=True,
        )
        self.setBattery = channel.unary_unary(
            "/android.emulation.control.EmulatorController/setBattery",
            request_serializer=emulator__controller__pb2.BatteryState.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.getBattery = channel.unary_unary(
            "/android.emulation.control.EmulatorController/getBattery",
            request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            response_deserializer=emulator__controller__pb2.BatteryState.FromString,
            _registered_method=True,
        )
        self.setGps = channel.unary_unary(
            "/android.emulation.control.EmulatorController/setGps",
            request_serializer=emulator__controller__pb2.GpsState.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.getGps = channel.unary_unary(
            "/android.emulation.control.EmulatorController/getGps",
            request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            response_deserializer=emulator__controller__pb2.GpsState.FromString,
            _registered_method=True,
        )
        self.sendFingerprint = channel.unary_unary(
            "/android.emulation.control.EmulatorController/sendFingerprint",
            request_serializer=emulator__controller__pb2.Fingerprint.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.sendKey = channel.unary_unary(
            "/android.emulation.control.EmulatorController/sendKey",
            request_serializer=emulator__controller__pb2.KeyboardEvent.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.sendTouch = channel.unary_unary(
            "/android.emulation.control.EmulatorController/sendTouch",
            request_serializer=emulator__controller__pb2.TouchEvent.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.sendMouse = channel.unary_unary(
            "/android.emulation.control.EmulatorController/sendMouse",
            request_serializer=emulator__controller__pb2.MouseEvent.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.injectWheel = channel.stream_unary(
            "/android.emulation.control.EmulatorController/injectWheel",
            request_serializer=emulator__controller__pb2.WheelEvent.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.streamInputEvent = channel.stream_unary(
            "/android.emulation.control.EmulatorController/streamInputEvent",
            request_serializer=emulator__controller__pb2.InputEvent.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.sendPhone = channel.unary_unary(
            "/android.emulation.control.EmulatorController/sendPhone",
            request_serializer=emulator__controller__pb2.PhoneCall.SerializeToString,
            response_deserializer=emulator__controller__pb2.PhoneResponse.FromString,
            _registered_method=True,
        )
        self.sendSms = channel.unary_unary(
            "/android.emulation.control.EmulatorController/sendSms",
            request_serializer=emulator__controller__pb2.SmsMessage.SerializeToString,
            response_deserializer=emulator__controller__pb2.PhoneResponse.FromString,
            _registered_method=True,
        )
        self.setPhoneNumber = channel.unary_unary(
            "/android.emulation.control.EmulatorController/setPhoneNumber",
            request_serializer=emulator__controller__pb2.PhoneNumber.SerializeToString,
            response_deserializer=emulator__controller__pb2.PhoneResponse.FromString,
            _registered_method=True,
        )
        self.getStatus = channel.unary_unary(
            "/android.emulation.control.EmulatorController/getStatus",
            request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            response_deserializer=emulator__controller__pb2.EmulatorStatus.FromString,
            _registered_method=True,
        )
        self.getScreenshot = channel.unary_unary(
            "/android.emulation.control.EmulatorController/getScreenshot",
            request_serializer=emulator__controller__pb2.ImageFormat.SerializeToString,
            response_deserializer=emulator__controller__pb2.Image.FromString,
            _registered_method=True,
        )
        self.streamScreenshot = channel.unary_stream(
            "/android.emulation.control.EmulatorController/streamScreenshot",
            request_serializer=emulator__controller__pb2.ImageFormat.SerializeToString,
            response_deserializer=emulator__controller__pb2.Image.FromString,
            _registered_method=True,
        )
        self.streamAudio = channel.unary_stream(
            "/android.emulation.control.EmulatorController/streamAudio",
            request_serializer=emulator__controller__pb2.AudioFormat.SerializeToString,
            response_deserializer=emulator__controller__pb2.AudioPacket.FromString,
            _registered_method=True,
        )
        self.injectAudio = channel.stream_unary(
            "/android.emulation.control.EmulatorController/injectAudio",
            request_serializer=emulator__controller__pb2.AudioPacket.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.getLogcat = channel.unary_unary(
            "/android.emulation.control.EmulatorController/getLogcat",
            request_serializer=emulator__controller__pb2.LogMessage.SerializeToString,
            response_deserializer=emulator__controller__pb2.LogMessage.FromString,
            _registered_method=True,
        )
        self.streamLogcat = channel.unary_stream(
            "/android.emulation.control.EmulatorController/streamLogcat",
            request_serializer=emulator__controller__pb2.LogMessage.SerializeToString,
            response_deserializer=emulator__controller__pb2.LogMessage.FromString,
            _registered_method=True,
        )
        self.setVmState = channel.unary_unary(
            "/android.emulation.control.EmulatorController/setVmState",
            request_serializer=emulator__controller__pb2.VmRunState.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.getVmState = channel.unary_unary(
            "/android.emulation.control.EmulatorController/getVmState",
            request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            response_deserializer=emulator__controller__pb2.VmRunState.FromString,
            _registered_method=True,
        )
        self.setDisplayConfigurations = channel.unary_unary(
            "/android.emulation.control.EmulatorController/setDisplayConfigurations",
            request_serializer=emulator__controller__pb2.DisplayConfigurations.SerializeToString,
            response_deserializer=emulator__controller__pb2.DisplayConfigurations.FromString,
            _registered_method=True,
        )
        self.getDisplayConfigurations = channel.unary_unary(
            "/android.emulation.control.EmulatorController/getDisplayConfigurations",
            request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            response_deserializer=emulator__controller__pb2.DisplayConfigurations.FromString,
            _registered_method=True,
        )
        self.streamNotification = channel.unary_stream(
            "/android.emulation.control.EmulatorController/streamNotification",
            request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            response_deserializer=emulator__controller__pb2.Notification.FromString,
            _registered_method=True,
        )
        self.rotateVirtualSceneCamera = channel.unary_unary(
            "/android.emulation.control.EmulatorController/rotateVirtualSceneCamera",
            request_serializer=emulator__controller__pb2.RotationRadian.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.setVirtualSceneCameraVelocity = channel.unary_unary(
            "/android.emulation.control.EmulatorController/setVirtualSceneCameraVelocity",
            request_serializer=emulator__controller__pb2.Velocity.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.setPosture = channel.unary_unary(
            "/android.emulation.control.EmulatorController/setPosture",
            request_serializer=emulator__controller__pb2.Posture.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.getBrightness = channel.unary_unary(
            "/android.emulation.control.EmulatorController/getBrightness",
            request_serializer=emulator__controller__pb2.BrightnessValue.SerializeToString,
            response_deserializer=emulator__controller__pb2.BrightnessValue.FromString,
            _registered_method=True,
        )
        self.setBrightness = channel.unary_unary(
            "/android.emulation.control.EmulatorController/setBrightness",
            request_serializer=emulator__controller__pb2.BrightnessValue.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.getDisplayMode = channel.unary_unary(
            "/android.emulation.control.EmulatorController/getDisplayMode",
            request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            response_deserializer=emulator__controller__pb2.DisplayMode.FromString,
            _registered_method=True,
        )
        self.setDisplayMode = channel.unary_unary(
            "/android.emulation.control.EmulatorController/setDisplayMode",
            request_serializer=emulator__controller__pb2.DisplayMode.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.setXrOptions = channel.unary_unary(
            "/android.emulation.control.EmulatorController/setXrOptions",
            request_serializer=emulator__controller__pb2.XrOptions.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            _registered_method=True,
        )
        self.getXrOptions = channel.unary_unary(
            "/android.emulation.control.EmulatorController/getXrOptions",
            request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            response_deserializer=emulator__controller__pb2.XrOptions.FromString,
            _registered_method=True,
        )


class EmulatorControllerServicer(object):
    """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.
    """

    def streamSensor(self, request, context):
        """set/get/stream the sensor data
        This RPC is not implemented in EmulatorController and will return an unimplemented error.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def getSensor(self, request, context):
        """Gets the current value of a specified sensor.

        The following gRPC error codes can be returned:
        -  INTERNAL (code 13) if `getSensorSize` fails to retrieve sensor dimensions.

        The `status` field in the `SensorValue` reply indicates the operational state:
        -  `OK` (0): Sensor data retrieved successfully.
        -  `UNKNOWN` (2): Unknown sensor type (should not happen if using valid `SensorType`).
        -  `DISABLED` (3): The sensor is disabled.
        -  `NO_SERVICE` (4): The `qemud` service responsible for sensors is not available or initiated.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def setSensor(self, request, context):
        """Sets the override value for a specified sensor. This operation is asynchronous
        and executed on the emulator's main looper. An immediate subsequent `getSensor`
        call might not reflect the newly set value.

        This method returns `OK` (code 0) upon successful asynchronous scheduling of the operation.
        No specific gRPC error codes are returned by this method itself, but underlying
        operations might log warnings if the sensor agent is unavailable.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def setPhysicalModel(self, request, context):
        """set/get/stream the physical model, this is likely the one you are
        looking for when you wish to modify the device state.

        This operation is asynchronous and executed on the emulator's main looper. An immediate subsequent `getPhysicalModel`
        call might not reflect the newly set value. The `interpolation` field from the request is used to determine the
        physical interpolation method, mapped using `abs((static_cast<int>(physicalValue.interpolation())) - 1)`.

        This method returns `OK` (code 0) upon successful asynchronous scheduling of the operation.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def getPhysicalModel(self, request, context):
        """Gets the current value of a specified physical model parameter.

        The `status` field in the `PhysicalModelValue` reply indicates the operational state:
        -  `OK` (0): Physical model data retrieved successfully.
        -  `UNKNOWN` (2): Unknown physical type (should not happen if using valid `PhysicalType`).
        -  `NO_SERVICE` (3): The `qemud` service responsible for physical parameters is not available or initiated.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def streamPhysicalModel(self, request, context):
        """This RPC is not implemented in EmulatorController and will return an unimplemented error."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def setClipboard(self, request, context):
        """Atomically sets the current primary clipboard data. This operation is asynchronous
        and executed on the emulator's main looper. It triggers a `ClipboardEvent`
        to all listeners (except the originating channel) indicating the new content.

        This method returns `OK` (code 0) upon successful asynchronous scheduling of the operation.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def getClipboard(self, request, context):
        """Retrieves the current primary clipboard data. This is a synchronous operation.

        This method returns `OK` (code 0) and the current `ClipData` upon success.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def streamClipboard(self, request, context):
        """Streams real-time updates of the clipboard content. Upon subscription,
        it immediately sends the current clipboard state. Subsequent updates are
        streamed as new content becomes available from the guest or is set via `setClipboard`
        from a different client. Events originating from the same client that initiated
        the stream are filtered out to prevent echoing.

        It is possible to miss very rapid clipboard updates. The stream will block
        awaiting new events after the initial state is sent.

        This method returns a server-side streaming reactor.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def setBattery(self, request, context):
        """Sets the emulator's battery state to the provided values. This operation is
        executed asynchronously on the main looper.

        This method returns `OK` (code 0) upon successful asynchronous scheduling
        of the operation. No explicit gRPC error codes are returned by this method.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def getBattery(self, request, context):
        """Retrieves the current battery state from the emulator. This is a
        synchronous operation that waits for completion.

        This method returns `OK` (code 0) and populates the `BatteryState` reply
        with the current information upon success. No explicit gRPC error codes
        are returned by this method.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def setGps(self, request, context):
        """Sets the state of the GPS in the emulator. This operation is asynchronous
        and executed on the main looper. It updates the emulator's GPS location
        (latitude, longitude, altitude, speed, bearing, and satellites) and sets
        the timestamp.

        Note: Setting the GPS position will not be immediately reflected in the user
        interface. Android typically samples GPS at 1 Hz.
        This method returns `OK` (code 0) upon successful asynchronous scheduling
        of the operation.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def getGps(self, request, context):
        """Gets the latest GPS state as reported by the emulator. This includes data
        delivered by previous `setGps` calls or from the location UI if active.
        This is a synchronous operation that waits for completion.

        Note: The returned GPS state is not necessarily the exact coordinate
        visible at the time due to Android's typical 1 Hz GPS sample frequency.

        This method returns `OK` (code 0) and populates the `GpsState` reply
        with the retrieved information upon success. No explicit gRPC error codes
        are returned by this method.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def sendFingerprint(self, request, context):
        """Simulates a touch event on the fingerprint sensor. This operation is
        executed asynchronously on the main looper.

        The `isTouching` field indicates whether the fingerprint sensor is being
        touched, and `touchId` specifies the identifier of the registered
        fingerprint. The `setTouch` agent function is used to apply these values.

        This method returns `OK` (code 0) upon successful asynchronous scheduling
        of the operation. No explicit gRPC error codes are returned by this method.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def sendKey(self, request, context):
        """Sends a keyboard event to the emulator. This operation is asynchronous
        and executed on the main looper.

        The `KeyboardEvent` message allows specifying input using `keyCode`, `key` (W3C standard string), or `text` (UTF-8 string).
        The `KeyEventSender` prioritizes `key`, then `keyCode`, then `text`.
        - If `key` is a non-printable W3C key string (e.g., "Backspace", "ArrowUp"), it's translated to an evdev keycode and sent.
        - If `key` is a printable Unicode character, it's converted to a sequence of evdev keydown/keyup events, handling modifiers.
        - If `keyCode` is provided, it's translated from its `codeType` (Usb, Evdev, XKB, Win, Mac) to an evdev keycode and sent as keydown/keyup pairs.
        - If `text` is provided, each UTF-8 character is converted to evdev keypress (keydown then keyup) events.

        This method returns `OK` (code 0) upon successful asynchronous scheduling of the operation.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def sendTouch(self, request, context):
        """Sends touch events to the emulator. This operation is asynchronous and executed on the main looper.

        The `TouchEvent` contains a list of `Touch` objects, each with `x`, `y` coordinates, `identifier`, `pressure`, `touch_major`, `touch_minor`, `expiration`, and `orientation`.
        Coordinates are scaled to the emulator's display resolution. Each `Touch` `identifier` is mapped to an internal Linux multitouch slot.
        Expiration handling ensures that inactive touch events are properly "lifted" after 120 seconds.

        This method returns `OK` (code 0) upon successful asynchronous scheduling of the operation. Warnings are logged if no touch slots are available.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def sendMouse(self, request, context):
        """Sends mouse events to the emulator. This operation is asynchronous and executed on the main looper.

        The `MouseEvent` specifies `x`, `y` coordinates, `buttons` state (bitmask: 1 for left, 2 for right), and `display` ID.
        In certain virtual input configurations (VirtioInput enabled, but VirtioMouse and VirtioTablet disabled), `buttons` may be masked to only consider the primary button.
        The event is sent to the emulator's `user_event_agent`.

        This method returns `OK` (code 0) upon successful asynchronous scheduling of the operation.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def injectWheel(self, request_iterator, context):
        """Injects a stream of wheel events into the emulator. This is a server-side streaming RPC.

        Each `WheelEvent` contains `dx`, `dy` (delta values, `dy` is pre-multiplied by 120 for scroll clicks), and `display` ID.
        If the emulator's input device has rotary capabilities (e.g., AVD_WEAR flavor), `dy` is scaled and sent as a rotary event.
        Otherwise, it's sent as a standard mouse wheel event.

        This method returns a server-side streaming reactor.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def streamInputEvent(self, request_iterator, context):
        """Streams a series of generic input events to the emulator. The events are processed in the order they arrive.
        This is a server-side streaming RPC that supports various input types encapsulated within `InputEvent`'s `oneof type` field.

        Supported input types:
        - `key_event` (KeyboardEvent): Processed by `KeyEventSender` as described in `sendKey`.
        - `touch_event` (TouchEvent): Processed by `TouchEventSender` as described in `sendTouch`.
        - `mouse_event` (MouseEvent): Processed by `MouseEventSender` as described in `sendMouse`.
        - `android_event` (AndroidEvent): Raw Linux input events (`type`, `code`, `value`) sent directly to the kernel.
        - `pen_event` (PenEvent): Processed by `PenEventSender` for pen input, including pressure, orientation, and button state.
        - `wheel_event` (WheelEvent): Processed by `WheelEventSender` as described in `injectWheel`.
        - `xr_command` (XrCommand): Executes XR-specific commands (e.g., `RECENTER` to recenter the viewport). Unknown actions are logged as warnings.
        - `xr_head_rotation_event` (RotationRadian): Sends head rotation data in radians. Logs an error if the agent call fails.
        - `xr_head_movement_event` (Translation): Sends head movement data in meters. Logs an error if the agent call fails.
        - `xr_head_angular_velocity_event` (AngularVelocity): Sends head angular velocity data in radians per second. Logs an error if the agent call fails.
        - `xr_head_velocity_event` (Velocity): Sends head velocity data in meters per second. Logs an error if the agent call fails.
        - `touchpad_event` (TouchpadEvent): Processed by `TouchpadEventSender` for touchpad input, similar to touch events but for a touchpad device.

        All underlying input sending operations for XR events are executed asynchronously on the main looper.

        Returns `INVALID_ARGUMENT` (code 3) if an unrecognized input event type is received, indicating a potential out-of-date emulator.
        The stream reactor automatically deletes itself upon completion.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def sendPhone(self, request, context):
        """Initiates or manipulates a phone call in the emulator. This is a synchronous
        operation executed on the main looper.

        The `PhoneCall` message specifies the `operation` (e.g., InitCall, AcceptCall)
        and the target phone `number`. The `telephonyCmd` agent function handles the
        actual call action.

        Returns a `PhoneResponse` indicating the outcome:
        - `OK` (0): The operation was successful.
        - `BadOperation` (1): The provided `operation` enum is out of range.
        - `BadNumber` (2): The provided `number` is malformed.
        - `InvalidAction` (3): The requested `operation` is invalid given the current call state (e.g., disconnecting when no call is active).
        - `ActionFailed` (4): An internal error occurred, typically if the modem agent is unavailable.
        - `RadioOff` (5): The emulator's radio is turned off.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def sendSms(self, request, context):
        """Sends an SMS message to the emulator. This is a synchronous operation.

        The `SmsMessage` contains the `srcAddress` (source phone number) and the `text` of the message.
        The `srcAddress` is validated for GSM formatting. The message `text` is converted into SMS PDUs
        (Protocol Data Units) and delivered via the modem agent.

        Returns a `PhoneResponse` indicating the outcome:
        - `OK` (0): The SMS message was successfully delivered.
        - `BadNumber` (2): The `srcAddress` is malformed.
        - `ActionFailed` (4): An internal error occurred, e.g., if the modem agent is unavailable or PDU creation fails.

        Other error cases from PDU creation (e.g., invalid characters in text) also result in `ActionFailed`.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def setPhoneNumber(self, request, context):
        """Sets the emulator's phone number. This is a synchronous operation.

        The `PhoneNumber` message contains the new `number` to be set. The modem agent's
        `amodem_update_phone_number` function is used for this update.

        Returns a `PhoneResponse` indicating the outcome:
        - `OK` (0): The phone number was successfully updated.
        - `BadNumber` (2): The provided `number` is invalid for the modem.
        - `ActionFailed` (4): An internal error occurred, typically if the modem agent is unavailable.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def getStatus(self, request, context):
        """Retrieves the current status of the emulator. This includes comprehensive
        information about the virtual machine's configuration and the guest operating system's state.

        The `EmulatorStatus` reply contains:
        - `version`: The emulator version string.
        - `uptime`: The time the emulator has been active in milliseconds.
        - `booted`: A boolean indicating if the device has completed booting.
        - `vmConfig`: Detailed `VmConfiguration` (hypervisor type, CPU cores, RAM size).
        - `hardwareConfig`: Key-value pairs describing the emulator's hardware configuration.
        - `heartbeat`: A monotonically increasing number indicating guest activity (incremented approximately once per second).
        - `guestConfig`: A map of key-value pairs with guest-specific configurations, including:
        - "multidisplay": "available" or "unavailable" based on display pipe readiness.
        - "androidVersion": The Android version of the guest OS.
        - "hypervisorVersion": The hypervisor version used by the guest.

        This method returns `OK` (code 0) upon successful retrieval of the emulator status.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def getScreenshot(self, request, context):
        """Retrieves a single screenshot in the desired format.

        The image will be scaled to the `desiredWidth` and `desiredHeight` specified in `ImageFormat`, while maintaining
        the aspect ratio. If `width` or `height` are 0, the device's current display dimensions are used.
        The returned image will never exceed the device's actual display resolution, but can be smaller.

        The `display` field in `ImageFormat` specifies the target display; 0 (or omitted) indicates the main display.
        For folded Pixel Fold devices, the display ID might be internally remapped, and `foldedDisplay` information will be populated.
        The resulting image is properly oriented based on the device's coarse-grained orientation, derived from sensor state.

        The `transport` field in `ImageFormat` can specify `MMAP` for shared memory delivery, but if the shared memory region
        is too small, a `FAILED_PRECONDITION` error will be returned.

        This method returns:
        - `OK` (code 0) and an `Image` object upon success.
        - `INVALID_ARGUMENT` (code 3) if the specified `display` ID is invalid or disabled.
        - `CANCELLED` (code 1) if the gRPC context is cancelled during the operation (an expensive operation).
        - `FAILED_PRECONDITION` (code 9) if the guest has not posted a new frame yet (for non-PNG formats when fast path is used).

        This method will return an image with width 0 and height 0 if the display is not visible.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def streamScreenshot(self, request, context):
        """Streams a series of screenshots in the desired format. This is a server-side streaming RPC.

        A new frame is delivered whenever the device produces a new frame or when sensor changes occur.
        Initial state: The first frame delivered might be an empty image (width 0, height 0) if the display is inactive.
        Subsequent frames are delivered when new content is available or a sensor event triggers an update.
        If the display becomes inactive, an empty image will be delivered again. Images resume when the display becomes active.

        `ImageFormat` parameters (format, width, height, display) behave as described in `getScreenshot`.
        The `transport` field in `ImageFormat` can specify `MMAP` for shared memory delivery. If `MMAP` is used and the
        provided shared memory handle is valid and mapped, pixel data will be written directly to it.
        The `image` field in the `Image` reply will be empty if `MMAP` transport is used.

        Performance considerations:
        - Streaming can produce a significant amount of data.
        - `PNG` format is CPU-intensive due to encoding overhead.
        - Using `MMAP` transport can significantly reduce gRPC overhead for pixel data.

        This method returns:
        - A server-side streaming reactor.
        - `INVALID_ARGUMENT` (code 3) if the specified `display` ID is invalid or disabled.
        - `CANCELLED` (code 1) if the gRPC context is cancelled during the operation.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def streamAudio(self, request, context):
        """Streams a series of audio packets in the desired format. This is a server-side streaming RPC.
        A new frame is delivered approximately every 20-30ms when the emulated device produces audio.
        If `samplingRate` is 0, it defaults to 44100 Hz.
        The stream may block indefinitely if the emulator ceases to produce audio.
        Packets are allocated with a buffer size calculated based on the audio format and a 30ms frame time.

        This method returns `OK` (code 0) upon successful streaming initiation.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def injectAudio(self, request_iterator, context):
        """Injects a series of audio packets into the Android microphone. This is a client-side streaming RPC.
        Audio packets are processed at a rate determined by the emulator's request for frames.
        An internal buffer can hold approximately 300ms of audio.

        Notes:
        - Only the `AudioFormat` from the first received packet is honored. Subsequent `AudioFormat` changes are ignored.
        - `MODE_REAL_TIME` is experimental: incoming data may overwrite existing data if the client does not control timing properly.
        - The circular buffer attempts to deliver all queued samples upon stream closure by writing silence for up to 300ms.

        Returns the following gRPC error codes:
        - `FAILED_PRECONDITION` (code 9): If another microphone is already active, or if unable to register the microphone.
        - `INVALID_ARGUMENT` (code 3): If the desired `samplingRate` exceeds 48kHz, or if an `AudioPacket` is too large for the internal buffer.

        This method returns `OK` (code 0) upon successful completion of the stream.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def getLogcat(self, request, context):
        """Deprecated, please use the streamLogcat method instead."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def streamLogcat(self, request, context):
        """Streams the logcat output from the emulator in real-time. This is a server-side streaming RPC.
        The stream sources its data from the `logcat` command executed via `AdbShellStream` in the Android guest.
        Log lines are processed individually as they arrive.

        The `LogMessage.sort` field determines the output format:
        - If `LogMessage.sort` is `Parsed`, each incoming log line is parsed into a structured `LogcatEntry` object,
        and these entries are returned in the `LogMessage.entries` field. Structured parsing is typically
        available for Android API Level 23 (Marshmallow) and later.
        - If `LogMessage.sort` is `Text` (or unspecified), the raw log line is returned in the `LogMessage.contents` field.

        The stream continues as long as the underlying `logcat` process is running and the client is connected.
        The stream will naturally terminate if the `logcat` process stops or the connection is lost.
        No explicit gRPC error codes are returned by this method during active streaming.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def setVmState(self, request, context):
        """Transitions the virtual machine to the desired state. This operation is asynchronous
        and executed on the QEMU looper to handle necessary IO locks. Note that some states
        (e.g., `UNKNOWN`, `RESTORE_VM`, `SAVE_VM`, `INTERNAL_ERROR`) are purely observable
        and cannot be set directly.

        The `VmRunState.state` field triggers specific VM operations:
        - `RESET`: Calls `vmReset()` to reset the VM.
        - `SHUTDOWN`: Calls `skin_winsys_quit_request()` for a graceful shutdown, similar to closing the emulator GUI.
        - `TERMINATE`: Forcefully kills the emulator process. This can lead to system corruption and should be used with extreme caution.
        - `PAUSED`: Calls `vmPause()` to pause the VM, halting CPU cycles.
        - `RUNNING`: Calls `vmResume()` to resume the VM.
        - `RESTART`: Calls `ui->requestRestart()` to perform a full emulator restart.
        - `START`: Calls `vmStart()` to resume a stopped emulator.
        - `STOP`: Calls `vmStop()` to stop (pause) a running emulator.

        This method returns `OK` (code 0) upon successful asynchronous scheduling of the operation.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def getVmState(self, request, context):
        """Retrieves the current run state of the virtual machine. This is a synchronous operation.

        Internal QEMU run states are mapped to `VmRunState.RunState` as follows:
        - `QEMU_RUN_STATE_PAUSED` and `QEMU_RUN_STATE_SUSPENDED` map to `PAUSED`.
        - `QEMU_RUN_STATE_RESTORE_VM` maps to `RESTORE_VM`.
        - `QEMU_RUN_STATE_RUNNING` maps to `RUNNING`.
        - `QEMU_RUN_STATE_SAVE_VM` maps to `SAVE_VM`.
        - `QEMU_RUN_STATE_SHUTDOWN` maps to `SHUTDOWN`.
        - `QEMU_RUN_STATE_GUEST_PANICKED`, `QEMU_RUN_STATE_INTERNAL_ERROR`, and `QEMU_RUN_STATE_IO_ERROR` map to `INTERNAL_ERROR`.
        - Any other states default to `UNKNOWN`.

        This method returns `OK` (code 0) and populates the `VmRunState` reply with the current VM state.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def setDisplayConfigurations(self, request, context):
        """Atomically changes the current multi-display configuration. This operation applies
        the provided `DisplayConfigurations`, with special handling for secondary displays.
        Display ID 0 (the primary display) cannot be modified via this RPC.

        Preconditions:
        - The `android::featurecontrol::MultiDisplay` feature must be enabled.

        Input Validation:
        - `INVALID_ARGUMENT` (code 3): If duplicate `display` IDs are found in the request.
        - `INVALID_ARGUMENT` (code 3): If any `DisplayConfiguration` (width, height, dpi, flags)
        is outside valid ranges as determined by `multiDisplayParamValidate`.
        - `INVALID_ARGUMENT` (code 3): If any `display` ID is outside the configurable range
        `[1, userConfigurable]`.

        Atomic Update and Rollback:
        The system attempts to apply each display configuration. If any update fails
        (e.g., after multiple retries for transient pipe errors), a rollback mechanism
        is initiated: successfully updated displays are reverted to their previous state,
        and newly added displays are deleted. In such cases, an `INTERNAL` error is returned.

        Deletion of Unrequested Displays:
        Any displays that were active before this call but are not present in the new
        `request.displays` (and are not display ID 0) will be deleted.

        Notifications:
        Upon successful completion, `notifyDisplayChanges()` is called to inform
        third-party subscribers.

        Returns the following gRPC error codes:
        - `OK` (code 0): Upon successful application of all configurations, returning the final active `DisplayConfigurations`.
        - `FAILED_PRECONDITION` (code 9): If the multi-display feature is not available.
        - `INTERNAL` (code 13): If an internal emulator failure occurs during display modification or rollback.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def getDisplayConfigurations(self, request, context):
        """Returns all currently valid logical displays configured in the emulator. This is a synchronous operation.

        Preconditions:
        - The `android::featurecontrol::MultiDisplay` feature must be enabled.

        The `DisplayConfigurations` reply contains:
        - `displays`: A repeated field of `DisplayConfiguration` objects, each detailing
        the width, height, DPI, flags, and ID of an active display.
        For Pixel Fold devices, only the main display configuration might be relevant.
        - `userConfigurable`: The maximum number of user-configurable displays (IDs from 1 up to this value).
        - `maxDisplays`: The total maximum number of displays the emulator supports.

        This method returns:
        - `OK` (code 0) and the current `DisplayConfigurations` upon success.
        - `FAILED_PRECONDITION` (code 9): If the AVD does not support the multi-display feature.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def streamNotification(self, request, context):
        """Notifies the client of various emulator state changes in real-time. This is a server-side streaming RPC.
        Upon subscription, the current states of virtual scene camera, foldable posture, boot completion,
        and XR options are immediately sent. The stream then continuously delivers new notifications
        when relevant events occur. `UniqueEventStreamWriter` ensures that only distinct state changes are streamed.

        Notifications include:
        - `CameraNotification`: Reports virtual scene camera activation/deactivation and associated display.
        - `DisplayConfigurationsChangedNotification`: Triggered when display configurations are modified via the extended UI. Does not fire for changes made through console or gRPC.
        - `Posture`: Reports changes in the device's foldable posture.
        - `BootCompletedNotification`: Indicates when the emulator has finished booting.
        - `BrightnessValue`: Reports changes in backlight brightness (LCD, keyboard, or button).
        - `TextViewFocus`: Sent when a text view gains or loses focus, or immediately on subscription.
        - `XrOptions`: Reports changes in XR-related settings (environment, passthrough coefficient), or immediately on subscription.

        This method returns a server-side streaming reactor.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def rotateVirtualSceneCamera(self, request, context):
        """Rotates the virtual scene camera relative to its current orientation. This operation is asynchronous
        and executed on the main looper.

        The `RotationRadian` message specifies angles in radians around the x, y, and z axes. The z component of rotation is currently unused.
        The coordinate system is right-handed: x-axis points right, y-axis points up, and z-axis points towards the viewer.
        This operation only succeeds if the virtual scene camera is actively connected.

        This method returns `OK` (code 0) upon successful asynchronous scheduling of the operation.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def setVirtualSceneCameraVelocity(self, request, context):
        """Sets the absolute velocity of the virtual scene camera. This operation is asynchronous
        and executed on the main looper.

        The `Velocity` message specifies components in meters per second along the x, y, and z axes.
        The coordinate system is right-handed: x-axis points right, y-axis points up, and z-axis points towards the viewer.
        The transition to these target velocity values may be smoothed over time by the implementation.
        This operation only succeeds if the virtual scene camera is actively connected.

        This method returns `OK` (code 0) upon successful asynchronous scheduling of the operation.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def setPosture(self, request, context):
        """Sets the foldable posture of the device. This operation is asynchronous
        and executed on the main looper.

        The `Posture` message contains a `PostureValue` enum, defining the desired
        physical configuration of the foldable device.

        Returns the following gRPC error codes:
        - `OK` (code 0): Upon successful asynchronous scheduling of the operation.
        - `FAILED_PRECONDITION` (code 9): If the emulator is unable to set the specified posture.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def getBrightness(self, request, context):
        """Retrieves the current backlight brightness for a specified light type. This is a synchronous operation.

        The `BrightnessValue.target` field (e.g., `LCD`, `KEYBOARD`, `BUTTON`) determines which light's brightness is queried.
        Internal mapping converts these to string names like "lcd_backlight".

        Returns the following gRPC error codes:
        - `OK` (code 0): Upon successful retrieval, populating the `BrightnessValue` reply with the `target` and current `value`.
        - `FAILED_PRECONDITION` (code 9): If the AVD does not support the `hw-control` agent or its `getBrightness` function is unavailable.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def setBrightness(self, request, context):
        """Sets the backlight brightness for a specified light type. This operation is asynchronous
        and executed on the main looper.

        The `BrightnessValue.target` field (e.g., `LCD`, `KEYBOARD`, `BUTTON`) determines which light's brightness is set.
        The `BrightnessValue.value` specifies the desired intensity, ranging from 0 to 255.
        Internal mapping converts `LightType` to string names like "lcd_backlight".

        Returns the following gRPC error codes:
        - `OK` (code 0): Upon successful asynchronous scheduling of the operation.
        - `FAILED_PRECONDITION` (code 9): If the AVD does not support the `hw-control` agent or its `setBrightness` function is unavailable.
        - `INVALID_ARGUMENT` (code 3): If the `brightness` value exceeds the valid range (0-255).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def getDisplayMode(self, request, context):
        """Returns the current mode of the primary display of a resizable AVD. This is a synchronous operation.

        Preconditions:
        - The AVD must be configured to support resizable displays (`resizableEnabled()` must be true).

        The `DisplayMode.value` field will be populated with the current `DisplayModeValue`,
        derived from the `getResizableActiveConfigId()`.

        Returns the following gRPC error codes:
        - `OK` (code 0): Upon successful retrieval of the display mode.
        - `FAILED_PRECONDITION` (code 9): If the AVD is not resizable.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def setDisplayMode(self, request, context):
        """Sets the size of the primary display of a resizable AVD to the specified `DisplayModeValue`. This operation is asynchronous
        and executed on the main looper.

        Preconditions:
        - The AVD must be configured to support resizable displays (`resizableEnabled()` must be true).
        - The emulator's `changeResizableDisplay` agent function must be available.

        The `DisplayMode.value` field specifies the desired display configuration (e.g., `PHONE`, `FOLDABLE`, `TABLET`, `DESKTOP`).

        Returns the following gRPC error codes:
        - `OK` (code 0): Upon successful asynchronous scheduling of the operation.
        - `FAILED_PRECONDITION` (code 9): If the AVD is not resizable.
        - `INTERNAL` (code 13): If the internal window agent function `changeResizableDisplay` is not available.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def setXrOptions(self, request, context):
        """Changes the XR-related settings of the emulator. This operation is asynchronous
        and executed on the main looper.

        The `XrOptions` message specifies the `environment` (e.g., `LIVING_ROOM_DAY`, `LIVING_ROOM_NIGHT`)
        and `passthrough_coefficient` (a float between 0.0 and 1.0 for real/artificial environment visibility).
        Values for `passthrough_coefficient` outside [0.0, 1.0] are ignored.

        Returns the following gRPC error codes:
        - `OK` (code 0): Upon successful asynchronous scheduling of the operation.
        - `FAILED_PRECONDITION` (code 9): If the `setXrOptions` agent function fails (e.g., if XR is not supported).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def getXrOptions(self, request, context):
        """Retrieves the current state of XR-related settings from the emulator. This is a synchronous operation.

        Preconditions:
        - XR mode must be supported in the current AVD (`isXrGuestOs()` must be true).
        (Note: Current implementation of `isXrGuestOs()` always returns true).

        The `XrOptions` reply contains the current `environment` and `passthrough_coefficient`.

        Returns the following gRPC error codes:
        - `OK` (code 0): Upon successful retrieval of the XR options.
        - `FAILED_PRECONDITION` (code 9): If XR mode is not supported in the current AVD or if the `getXrOptions` agent function fails.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")


def add_EmulatorControllerServicer_to_server(servicer, server):
    rpc_method_handlers = {
        "streamSensor": grpc.unary_stream_rpc_method_handler(
            servicer.streamSensor,
            request_deserializer=emulator__controller__pb2.SensorValue.FromString,
            response_serializer=emulator__controller__pb2.SensorValue.SerializeToString,
        ),
        "getSensor": grpc.unary_unary_rpc_method_handler(
            servicer.getSensor,
            request_deserializer=emulator__controller__pb2.SensorValue.FromString,
            response_serializer=emulator__controller__pb2.SensorValue.SerializeToString,
        ),
        "setSensor": grpc.unary_unary_rpc_method_handler(
            servicer.setSensor,
            request_deserializer=emulator__controller__pb2.SensorValue.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "setPhysicalModel": grpc.unary_unary_rpc_method_handler(
            servicer.setPhysicalModel,
            request_deserializer=emulator__controller__pb2.PhysicalModelValue.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "getPhysicalModel": grpc.unary_unary_rpc_method_handler(
            servicer.getPhysicalModel,
            request_deserializer=emulator__controller__pb2.PhysicalModelValue.FromString,
            response_serializer=emulator__controller__pb2.PhysicalModelValue.SerializeToString,
        ),
        "streamPhysicalModel": grpc.unary_stream_rpc_method_handler(
            servicer.streamPhysicalModel,
            request_deserializer=emulator__controller__pb2.PhysicalModelValue.FromString,
            response_serializer=emulator__controller__pb2.PhysicalModelValue.SerializeToString,
        ),
        "setClipboard": grpc.unary_unary_rpc_method_handler(
            servicer.setClipboard,
            request_deserializer=emulator__controller__pb2.ClipData.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "getClipboard": grpc.unary_unary_rpc_method_handler(
            servicer.getClipboard,
            request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            response_serializer=emulator__controller__pb2.ClipData.SerializeToString,
        ),
        "streamClipboard": grpc.unary_stream_rpc_method_handler(
            servicer.streamClipboard,
            request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            response_serializer=emulator__controller__pb2.ClipData.SerializeToString,
        ),
        "setBattery": grpc.unary_unary_rpc_method_handler(
            servicer.setBattery,
            request_deserializer=emulator__controller__pb2.BatteryState.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "getBattery": grpc.unary_unary_rpc_method_handler(
            servicer.getBattery,
            request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            response_serializer=emulator__controller__pb2.BatteryState.SerializeToString,
        ),
        "setGps": grpc.unary_unary_rpc_method_handler(
            servicer.setGps,
            request_deserializer=emulator__controller__pb2.GpsState.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "getGps": grpc.unary_unary_rpc_method_handler(
            servicer.getGps,
            request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            response_serializer=emulator__controller__pb2.GpsState.SerializeToString,
        ),
        "sendFingerprint": grpc.unary_unary_rpc_method_handler(
            servicer.sendFingerprint,
            request_deserializer=emulator__controller__pb2.Fingerprint.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "sendKey": grpc.unary_unary_rpc_method_handler(
            servicer.sendKey,
            request_deserializer=emulator__controller__pb2.KeyboardEvent.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "sendTouch": grpc.unary_unary_rpc_method_handler(
            servicer.sendTouch,
            request_deserializer=emulator__controller__pb2.TouchEvent.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "sendMouse": grpc.unary_unary_rpc_method_handler(
            servicer.sendMouse,
            request_deserializer=emulator__controller__pb2.MouseEvent.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "injectWheel": grpc.stream_unary_rpc_method_handler(
            servicer.injectWheel,
            request_deserializer=emulator__controller__pb2.WheelEvent.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "streamInputEvent": grpc.stream_unary_rpc_method_handler(
            servicer.streamInputEvent,
            request_deserializer=emulator__controller__pb2.InputEvent.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "sendPhone": grpc.unary_unary_rpc_method_handler(
            servicer.sendPhone,
            request_deserializer=emulator__controller__pb2.PhoneCall.FromString,
            response_serializer=emulator__controller__pb2.PhoneResponse.SerializeToString,
        ),
        "sendSms": grpc.unary_unary_rpc_method_handler(
            servicer.sendSms,
            request_deserializer=emulator__controller__pb2.SmsMessage.FromString,
            response_serializer=emulator__controller__pb2.PhoneResponse.SerializeToString,
        ),
        "setPhoneNumber": grpc.unary_unary_rpc_method_handler(
            servicer.setPhoneNumber,
            request_deserializer=emulator__controller__pb2.PhoneNumber.FromString,
            response_serializer=emulator__controller__pb2.PhoneResponse.SerializeToString,
        ),
        "getStatus": grpc.unary_unary_rpc_method_handler(
            servicer.getStatus,
            request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            response_serializer=emulator__controller__pb2.EmulatorStatus.SerializeToString,
        ),
        "getScreenshot": grpc.unary_unary_rpc_method_handler(
            servicer.getScreenshot,
            request_deserializer=emulator__controller__pb2.ImageFormat.FromString,
            response_serializer=emulator__controller__pb2.Image.SerializeToString,
        ),
        "streamScreenshot": grpc.unary_stream_rpc_method_handler(
            servicer.streamScreenshot,
            request_deserializer=emulator__controller__pb2.ImageFormat.FromString,
            response_serializer=emulator__controller__pb2.Image.SerializeToString,
        ),
        "streamAudio": grpc.unary_stream_rpc_method_handler(
            servicer.streamAudio,
            request_deserializer=emulator__controller__pb2.AudioFormat.FromString,
            response_serializer=emulator__controller__pb2.AudioPacket.SerializeToString,
        ),
        "injectAudio": grpc.stream_unary_rpc_method_handler(
            servicer.injectAudio,
            request_deserializer=emulator__controller__pb2.AudioPacket.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "getLogcat": grpc.unary_unary_rpc_method_handler(
            servicer.getLogcat,
            request_deserializer=emulator__controller__pb2.LogMessage.FromString,
            response_serializer=emulator__controller__pb2.LogMessage.SerializeToString,
        ),
        "streamLogcat": grpc.unary_stream_rpc_method_handler(
            servicer.streamLogcat,
            request_deserializer=emulator__controller__pb2.LogMessage.FromString,
            response_serializer=emulator__controller__pb2.LogMessage.SerializeToString,
        ),
        "setVmState": grpc.unary_unary_rpc_method_handler(
            servicer.setVmState,
            request_deserializer=emulator__controller__pb2.VmRunState.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "getVmState": grpc.unary_unary_rpc_method_handler(
            servicer.getVmState,
            request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            response_serializer=emulator__controller__pb2.VmRunState.SerializeToString,
        ),
        "setDisplayConfigurations": grpc.unary_unary_rpc_method_handler(
            servicer.setDisplayConfigurations,
            request_deserializer=emulator__controller__pb2.DisplayConfigurations.FromString,
            response_serializer=emulator__controller__pb2.DisplayConfigurations.SerializeToString,
        ),
        "getDisplayConfigurations": grpc.unary_unary_rpc_method_handler(
            servicer.getDisplayConfigurations,
            request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            response_serializer=emulator__controller__pb2.DisplayConfigurations.SerializeToString,
        ),
        "streamNotification": grpc.unary_stream_rpc_method_handler(
            servicer.streamNotification,
            request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            response_serializer=emulator__controller__pb2.Notification.SerializeToString,
        ),
        "rotateVirtualSceneCamera": grpc.unary_unary_rpc_method_handler(
            servicer.rotateVirtualSceneCamera,
            request_deserializer=emulator__controller__pb2.RotationRadian.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "setVirtualSceneCameraVelocity": grpc.unary_unary_rpc_method_handler(
            servicer.setVirtualSceneCameraVelocity,
            request_deserializer=emulator__controller__pb2.Velocity.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "setPosture": grpc.unary_unary_rpc_method_handler(
            servicer.setPosture,
            request_deserializer=emulator__controller__pb2.Posture.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "getBrightness": grpc.unary_unary_rpc_method_handler(
            servicer.getBrightness,
            request_deserializer=emulator__controller__pb2.BrightnessValue.FromString,
            response_serializer=emulator__controller__pb2.BrightnessValue.SerializeToString,
        ),
        "setBrightness": grpc.unary_unary_rpc_method_handler(
            servicer.setBrightness,
            request_deserializer=emulator__controller__pb2.BrightnessValue.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "getDisplayMode": grpc.unary_unary_rpc_method_handler(
            servicer.getDisplayMode,
            request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            response_serializer=emulator__controller__pb2.DisplayMode.SerializeToString,
        ),
        "setDisplayMode": grpc.unary_unary_rpc_method_handler(
            servicer.setDisplayMode,
            request_deserializer=emulator__controller__pb2.DisplayMode.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "setXrOptions": grpc.unary_unary_rpc_method_handler(
            servicer.setXrOptions,
            request_deserializer=emulator__controller__pb2.XrOptions.FromString,
            response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
        ),
        "getXrOptions": grpc.unary_unary_rpc_method_handler(
            servicer.getXrOptions,
            request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            response_serializer=emulator__controller__pb2.XrOptions.SerializeToString,
        ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
        "android.emulation.control.EmulatorController", rpc_method_handlers
    )
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers(
        "android.emulation.control.EmulatorController", rpc_method_handlers
    )


# This class is part of an EXPERIMENTAL API.
class EmulatorController(object):
    """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.
    """

    @staticmethod
    def streamSensor(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/android.emulation.control.EmulatorController/streamSensor",
            emulator__controller__pb2.SensorValue.SerializeToString,
            emulator__controller__pb2.SensorValue.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def getSensor(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/getSensor",
            emulator__controller__pb2.SensorValue.SerializeToString,
            emulator__controller__pb2.SensorValue.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def setSensor(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/setSensor",
            emulator__controller__pb2.SensorValue.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def setPhysicalModel(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/setPhysicalModel",
            emulator__controller__pb2.PhysicalModelValue.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def getPhysicalModel(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/getPhysicalModel",
            emulator__controller__pb2.PhysicalModelValue.SerializeToString,
            emulator__controller__pb2.PhysicalModelValue.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def streamPhysicalModel(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/android.emulation.control.EmulatorController/streamPhysicalModel",
            emulator__controller__pb2.PhysicalModelValue.SerializeToString,
            emulator__controller__pb2.PhysicalModelValue.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def setClipboard(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/setClipboard",
            emulator__controller__pb2.ClipData.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def getClipboard(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/getClipboard",
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            emulator__controller__pb2.ClipData.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def streamClipboard(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/android.emulation.control.EmulatorController/streamClipboard",
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            emulator__controller__pb2.ClipData.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def setBattery(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/setBattery",
            emulator__controller__pb2.BatteryState.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def getBattery(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/getBattery",
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            emulator__controller__pb2.BatteryState.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def setGps(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/setGps",
            emulator__controller__pb2.GpsState.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def getGps(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/getGps",
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            emulator__controller__pb2.GpsState.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def sendFingerprint(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/sendFingerprint",
            emulator__controller__pb2.Fingerprint.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def sendKey(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/sendKey",
            emulator__controller__pb2.KeyboardEvent.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def sendTouch(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/sendTouch",
            emulator__controller__pb2.TouchEvent.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def sendMouse(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/sendMouse",
            emulator__controller__pb2.MouseEvent.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def injectWheel(
        request_iterator,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.stream_unary(
            request_iterator,
            target,
            "/android.emulation.control.EmulatorController/injectWheel",
            emulator__controller__pb2.WheelEvent.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def streamInputEvent(
        request_iterator,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.stream_unary(
            request_iterator,
            target,
            "/android.emulation.control.EmulatorController/streamInputEvent",
            emulator__controller__pb2.InputEvent.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def sendPhone(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/sendPhone",
            emulator__controller__pb2.PhoneCall.SerializeToString,
            emulator__controller__pb2.PhoneResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def sendSms(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/sendSms",
            emulator__controller__pb2.SmsMessage.SerializeToString,
            emulator__controller__pb2.PhoneResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def setPhoneNumber(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/setPhoneNumber",
            emulator__controller__pb2.PhoneNumber.SerializeToString,
            emulator__controller__pb2.PhoneResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def getStatus(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/getStatus",
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            emulator__controller__pb2.EmulatorStatus.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def getScreenshot(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/getScreenshot",
            emulator__controller__pb2.ImageFormat.SerializeToString,
            emulator__controller__pb2.Image.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def streamScreenshot(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/android.emulation.control.EmulatorController/streamScreenshot",
            emulator__controller__pb2.ImageFormat.SerializeToString,
            emulator__controller__pb2.Image.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def streamAudio(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/android.emulation.control.EmulatorController/streamAudio",
            emulator__controller__pb2.AudioFormat.SerializeToString,
            emulator__controller__pb2.AudioPacket.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def injectAudio(
        request_iterator,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.stream_unary(
            request_iterator,
            target,
            "/android.emulation.control.EmulatorController/injectAudio",
            emulator__controller__pb2.AudioPacket.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def getLogcat(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/getLogcat",
            emulator__controller__pb2.LogMessage.SerializeToString,
            emulator__controller__pb2.LogMessage.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def streamLogcat(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/android.emulation.control.EmulatorController/streamLogcat",
            emulator__controller__pb2.LogMessage.SerializeToString,
            emulator__controller__pb2.LogMessage.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def setVmState(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/setVmState",
            emulator__controller__pb2.VmRunState.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def getVmState(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/getVmState",
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            emulator__controller__pb2.VmRunState.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def setDisplayConfigurations(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/setDisplayConfigurations",
            emulator__controller__pb2.DisplayConfigurations.SerializeToString,
            emulator__controller__pb2.DisplayConfigurations.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def getDisplayConfigurations(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/getDisplayConfigurations",
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            emulator__controller__pb2.DisplayConfigurations.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def streamNotification(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/android.emulation.control.EmulatorController/streamNotification",
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            emulator__controller__pb2.Notification.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def rotateVirtualSceneCamera(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/rotateVirtualSceneCamera",
            emulator__controller__pb2.RotationRadian.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def setVirtualSceneCameraVelocity(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/setVirtualSceneCameraVelocity",
            emulator__controller__pb2.Velocity.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def setPosture(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/setPosture",
            emulator__controller__pb2.Posture.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def getBrightness(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/getBrightness",
            emulator__controller__pb2.BrightnessValue.SerializeToString,
            emulator__controller__pb2.BrightnessValue.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def setBrightness(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/setBrightness",
            emulator__controller__pb2.BrightnessValue.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def getDisplayMode(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/getDisplayMode",
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            emulator__controller__pb2.DisplayMode.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def setDisplayMode(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/setDisplayMode",
            emulator__controller__pb2.DisplayMode.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def setXrOptions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/setXrOptions",
            emulator__controller__pb2.XrOptions.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def getXrOptions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/android.emulation.control.EmulatorController/getXrOptions",
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            emulator__controller__pb2.XrOptions.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )
