// Code generated by protoc-gen-go-grpc. DO NOT EDIT.

package android_emulator_control_proto

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

// EmulatorControllerClient is the client API for EmulatorController service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type EmulatorControllerClient interface {
	// set/get/stream the sensor data
	StreamSensor(ctx context.Context, in *SensorValue, opts ...grpc.CallOption) (EmulatorController_StreamSensorClient, error)
	GetSensor(ctx context.Context, in *SensorValue, opts ...grpc.CallOption) (*SensorValue, error)
	SetSensor(ctx context.Context, in *SensorValue, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// set/get/stream the physical model, this is likely the one you are
	// looking for when you wish to modify the device state.
	SetPhysicalModel(ctx context.Context, in *PhysicalModelValue, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetPhysicalModel(ctx context.Context, in *PhysicalModelValue, opts ...grpc.CallOption) (*PhysicalModelValue, error)
	StreamPhysicalModel(ctx context.Context, in *PhysicalModelValue, opts ...grpc.CallOption) (EmulatorController_StreamPhysicalModelClient, error)
	// Atomically set/get the current primary clipboard data.
	SetClipboard(ctx context.Context, in *ClipData, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetClipboard(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ClipData, error)
	// Streams the current data on the clipboard. This will immediately produce
	// a result with the current state of the clipboard after which the stream
	// will block and wait until a new clip event is available from the guest.
	// Calling the setClipboard method above will not result in generating a clip
	// event. It is possible to lose clipboard events if the clipboard updates
	// very rapidly.
	StreamClipboard(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (EmulatorController_StreamClipboardClient, error)
	// Set/get the battery to the given state.
	SetBattery(ctx context.Context, in *BatteryState, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetBattery(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*BatteryState, error)
	// Set the state of the gps, gps support will only work
	// properly if:
	//
	// - no location ui is active. That is the emulator
	//   is launched in headless mode (-no-window) or the location
	//   ui is disabled (-no-location-ui).
	// - the passiveUpdate is set to false. Setting this to false
	//   will disable/break the LocationUI.
	//
	// Keep in mind that android usually only samples the gps at 1 hz.
	SetGps(ctx context.Context, in *GpsState, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Gets the latest gps state as delivered by the setGps call, or location ui
	// if active.
	//
	// Note: this is not necessarily the actual gps coordinate visible at the
	// time, due to gps sample frequency (usually 1hz).
	GetGps(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GpsState, error)
	// Simulate a touch event on the finger print sensor.
	SendFingerprint(ctx context.Context, in *Fingerprint, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Send a keyboard event. Translating the event.
	SendKey(ctx context.Context, in *KeyboardEvent, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Send touch/mouse events. Note that mouse events can be simulated
	// by touch events.
	SendTouch(ctx context.Context, in *TouchEvent, opts ...grpc.CallOption) (*emptypb.Empty, error)
	SendMouse(ctx context.Context, in *MouseEvent, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Make a phone call.
	SendPhone(ctx context.Context, in *PhoneCall, opts ...grpc.CallOption) (*PhoneResponse, error)
	// Sends an sms message to the emulator.
	SendSms(ctx context.Context, in *SmsMessage, opts ...grpc.CallOption) (*PhoneResponse, error)
	// Retrieve the status of the emulator. This will contain general
	// hardware information, and whether the device has booted or not.
	GetStatus(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*EmulatorStatus, error)
	// Gets an individual screenshot in the desired format.
	//
	// The image will be scaled to the desired ImageFormat, while maintaining
	// the aspect ratio. The returned image will never exceed the provided width
	// and height. Not setting the width or height (i.e. they are 0) will result
	// in using the device width and height.
	//
	// The resulting image will be properly oriented and can be displayed
	// directly without post processing. For example, if the device has a
	// 1080x1920 screen and is in landscape mode and called with no width or
	// height parameter, it will return an 1920x1080 image.
	//
	// This method will return an empty image if the display is not visible.
	GetScreenshot(ctx context.Context, in *ImageFormat, opts ...grpc.CallOption) (*Image, error)
	// Streams a series of screenshots in the desired format.
	// A new frame will be delivered whenever the device produces a new frame.
	// (Beware that this can produce a significant amount of data, and that
	// certain translations are (png transform) can be costly).
	//
	// If the requested display is not visible it will send a single empty image
	// and wait start producing images once the display becomes active, again
	// producing a single empty image when the display becomes inactive.
	StreamScreenshot(ctx context.Context, in *ImageFormat, opts ...grpc.CallOption) (EmulatorController_StreamScreenshotClient, error)
	// Streams a series of audio packets in the desired format.
	// A new frame will be delivered whenever the emulated device
	// produces a new audio frame. You can expect packets to be
	// delivered in intervals of 20-30ms.
	//
	// Be aware that this can block when the emulator does not
	// produce any audio whatsoever!
	StreamAudio(ctx context.Context, in *AudioFormat, opts ...grpc.CallOption) (EmulatorController_StreamAudioClient, error)
	// Injects a series of audio packets to the android microphone.
	// A new frame will be delivered whenever the emulated device
	// requests a new audio frame. Audio is usually delivered at a rate
	// that the emulator is requesting frames. Audio will be stored in a
	// temporary buffer that can hold 500ms of audio.
	//
	// Note: Currently the emulator will downsample to 16khz.
	//
	// -  INVALID_ARGUMENT (code 3) The sampling rate was too high
	// -  INVALID_ARGUMENT (code 3) The audio packet was too large to handle.
	// -  FAILED_PRECONDITION (code 9) If there was a microphone registered already.
	InjectAudio(ctx context.Context, opts ...grpc.CallOption) (EmulatorController_InjectAudioClient, error)
	// Returns the last 128Kb of logcat output from the emulator
	// Note that parsed logcat messages are only available after L (Api >23).
	// it is possible that the logcat buffer gets overwritten, or falls behind.
	GetLogcat(ctx context.Context, in *LogMessage, opts ...grpc.CallOption) (*LogMessage, error)
	// Streams the logcat output from the emulator. The first call
	// can retrieve up to 128Kb. This call will not return.
	// Note that parsed logcat messages are only available after L (Api >23)
	// it is possible that the logcat buffer gets overwritten, or falls behind.
	StreamLogcat(ctx context.Context, in *LogMessage, opts ...grpc.CallOption) (EmulatorController_StreamLogcatClient, error)
	// Transition the virtual machine to the desired state. Note that
	// some states are only observable. For example you cannot transition
	// to the error state.
	SetVmState(ctx context.Context, in *VmRunState, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Gets the state of the virtual machine.
	GetVmState(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*VmRunState, error)
	// Atomically changes the current multi-display configuration.
	// After this call the given display configurations will be activated. You
	// can only update secondary displays. Displays with id 0 will be ignored.
	//
	// This call can result in the removal or addition of secondary displays, the final
	// display state can be observed by the returned configuration.
	//
	// The following gRPC error codes can be returned:
	// -  FAILED_PRECONDITION (code 9) if the AVD does not support a configurable
	//    secondary display.
	// -  INVALID_ARGUMENT (code 3) if:
	//     - The same display id is defined multiple times.
	//     - The display configurations are outside valid ranges
	//       (see DisplayConfiguration)
	// -  INTERNAL (code 13) if there was an internal emulator failure.
	SetDisplayConfigurations(ctx context.Context, in *DisplayConfigurations, opts ...grpc.CallOption) (*DisplayConfigurations, error)
	// Returns all currently valid logical displays.
	// The gRPC error code FAILED_PRECONDITION (code 9) is returned if the AVD
	// does not support a configurable secondary display.
	GetDisplayConfigurations(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*DisplayConfigurations, error)
	// Notifies client of the following changes:
	//
	// - Virtual scene camera status change.
	// - Display configuration changes from extended ui. This will only be fired
	//   if the user makes modifications the extended displays through the extended
	//   control tab.
	//
	// Note that this method will send the initial virtual scene state immediately.
	StreamNotification(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (EmulatorController_StreamNotificationClient, error)
	// RotationRadian is relative to the camera's current orientation.
	RotateVirtualSceneCamera(ctx context.Context, in *RotationRadian, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Velocity is absolute
	SetVirtualSceneCameraVelocity(ctx context.Context, in *Velocity, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type emulatorControllerClient struct {
	cc grpc.ClientConnInterface
}

func NewEmulatorControllerClient(cc grpc.ClientConnInterface) EmulatorControllerClient {
	return &emulatorControllerClient{cc}
}

func (c *emulatorControllerClient) StreamSensor(ctx context.Context, in *SensorValue, opts ...grpc.CallOption) (EmulatorController_StreamSensorClient, error) {
	stream, err := c.cc.NewStream(ctx, &EmulatorController_ServiceDesc.Streams[0], "/android.emulation.control.EmulatorController/streamSensor", opts...)
	if err != nil {
		return nil, err
	}
	x := &emulatorControllerStreamSensorClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type EmulatorController_StreamSensorClient interface {
	Recv() (*SensorValue, error)
	grpc.ClientStream
}

type emulatorControllerStreamSensorClient struct {
	grpc.ClientStream
}

func (x *emulatorControllerStreamSensorClient) Recv() (*SensorValue, error) {
	m := new(SensorValue)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *emulatorControllerClient) GetSensor(ctx context.Context, in *SensorValue, opts ...grpc.CallOption) (*SensorValue, error) {
	out := new(SensorValue)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/getSensor", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) SetSensor(ctx context.Context, in *SensorValue, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/setSensor", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) SetPhysicalModel(ctx context.Context, in *PhysicalModelValue, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/setPhysicalModel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) GetPhysicalModel(ctx context.Context, in *PhysicalModelValue, opts ...grpc.CallOption) (*PhysicalModelValue, error) {
	out := new(PhysicalModelValue)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/getPhysicalModel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) StreamPhysicalModel(ctx context.Context, in *PhysicalModelValue, opts ...grpc.CallOption) (EmulatorController_StreamPhysicalModelClient, error) {
	stream, err := c.cc.NewStream(ctx, &EmulatorController_ServiceDesc.Streams[1], "/android.emulation.control.EmulatorController/streamPhysicalModel", opts...)
	if err != nil {
		return nil, err
	}
	x := &emulatorControllerStreamPhysicalModelClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type EmulatorController_StreamPhysicalModelClient interface {
	Recv() (*PhysicalModelValue, error)
	grpc.ClientStream
}

type emulatorControllerStreamPhysicalModelClient struct {
	grpc.ClientStream
}

func (x *emulatorControllerStreamPhysicalModelClient) Recv() (*PhysicalModelValue, error) {
	m := new(PhysicalModelValue)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *emulatorControllerClient) SetClipboard(ctx context.Context, in *ClipData, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/setClipboard", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) GetClipboard(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ClipData, error) {
	out := new(ClipData)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/getClipboard", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) StreamClipboard(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (EmulatorController_StreamClipboardClient, error) {
	stream, err := c.cc.NewStream(ctx, &EmulatorController_ServiceDesc.Streams[2], "/android.emulation.control.EmulatorController/streamClipboard", opts...)
	if err != nil {
		return nil, err
	}
	x := &emulatorControllerStreamClipboardClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type EmulatorController_StreamClipboardClient interface {
	Recv() (*ClipData, error)
	grpc.ClientStream
}

type emulatorControllerStreamClipboardClient struct {
	grpc.ClientStream
}

func (x *emulatorControllerStreamClipboardClient) Recv() (*ClipData, error) {
	m := new(ClipData)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *emulatorControllerClient) SetBattery(ctx context.Context, in *BatteryState, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/setBattery", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) GetBattery(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*BatteryState, error) {
	out := new(BatteryState)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/getBattery", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) SetGps(ctx context.Context, in *GpsState, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/setGps", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) GetGps(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GpsState, error) {
	out := new(GpsState)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/getGps", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) SendFingerprint(ctx context.Context, in *Fingerprint, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/sendFingerprint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) SendKey(ctx context.Context, in *KeyboardEvent, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/sendKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) SendTouch(ctx context.Context, in *TouchEvent, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/sendTouch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) SendMouse(ctx context.Context, in *MouseEvent, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/sendMouse", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) SendPhone(ctx context.Context, in *PhoneCall, opts ...grpc.CallOption) (*PhoneResponse, error) {
	out := new(PhoneResponse)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/sendPhone", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) SendSms(ctx context.Context, in *SmsMessage, opts ...grpc.CallOption) (*PhoneResponse, error) {
	out := new(PhoneResponse)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/sendSms", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) GetStatus(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*EmulatorStatus, error) {
	out := new(EmulatorStatus)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/getStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) GetScreenshot(ctx context.Context, in *ImageFormat, opts ...grpc.CallOption) (*Image, error) {
	out := new(Image)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/getScreenshot", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) StreamScreenshot(ctx context.Context, in *ImageFormat, opts ...grpc.CallOption) (EmulatorController_StreamScreenshotClient, error) {
	stream, err := c.cc.NewStream(ctx, &EmulatorController_ServiceDesc.Streams[3], "/android.emulation.control.EmulatorController/streamScreenshot", opts...)
	if err != nil {
		return nil, err
	}
	x := &emulatorControllerStreamScreenshotClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type EmulatorController_StreamScreenshotClient interface {
	Recv() (*Image, error)
	grpc.ClientStream
}

type emulatorControllerStreamScreenshotClient struct {
	grpc.ClientStream
}

func (x *emulatorControllerStreamScreenshotClient) Recv() (*Image, error) {
	m := new(Image)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *emulatorControllerClient) StreamAudio(ctx context.Context, in *AudioFormat, opts ...grpc.CallOption) (EmulatorController_StreamAudioClient, error) {
	stream, err := c.cc.NewStream(ctx, &EmulatorController_ServiceDesc.Streams[4], "/android.emulation.control.EmulatorController/streamAudio", opts...)
	if err != nil {
		return nil, err
	}
	x := &emulatorControllerStreamAudioClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type EmulatorController_StreamAudioClient interface {
	Recv() (*AudioPacket, error)
	grpc.ClientStream
}

type emulatorControllerStreamAudioClient struct {
	grpc.ClientStream
}

func (x *emulatorControllerStreamAudioClient) Recv() (*AudioPacket, error) {
	m := new(AudioPacket)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *emulatorControllerClient) InjectAudio(ctx context.Context, opts ...grpc.CallOption) (EmulatorController_InjectAudioClient, error) {
	stream, err := c.cc.NewStream(ctx, &EmulatorController_ServiceDesc.Streams[5], "/android.emulation.control.EmulatorController/injectAudio", opts...)
	if err != nil {
		return nil, err
	}
	x := &emulatorControllerInjectAudioClient{stream}
	return x, nil
}

type EmulatorController_InjectAudioClient interface {
	Send(*AudioPacket) error
	CloseAndRecv() (*emptypb.Empty, error)
	grpc.ClientStream
}

type emulatorControllerInjectAudioClient struct {
	grpc.ClientStream
}

func (x *emulatorControllerInjectAudioClient) Send(m *AudioPacket) error {
	return x.ClientStream.SendMsg(m)
}

func (x *emulatorControllerInjectAudioClient) CloseAndRecv() (*emptypb.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(emptypb.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *emulatorControllerClient) GetLogcat(ctx context.Context, in *LogMessage, opts ...grpc.CallOption) (*LogMessage, error) {
	out := new(LogMessage)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/getLogcat", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) StreamLogcat(ctx context.Context, in *LogMessage, opts ...grpc.CallOption) (EmulatorController_StreamLogcatClient, error) {
	stream, err := c.cc.NewStream(ctx, &EmulatorController_ServiceDesc.Streams[6], "/android.emulation.control.EmulatorController/streamLogcat", opts...)
	if err != nil {
		return nil, err
	}
	x := &emulatorControllerStreamLogcatClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type EmulatorController_StreamLogcatClient interface {
	Recv() (*LogMessage, error)
	grpc.ClientStream
}

type emulatorControllerStreamLogcatClient struct {
	grpc.ClientStream
}

func (x *emulatorControllerStreamLogcatClient) Recv() (*LogMessage, error) {
	m := new(LogMessage)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *emulatorControllerClient) SetVmState(ctx context.Context, in *VmRunState, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/setVmState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) GetVmState(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*VmRunState, error) {
	out := new(VmRunState)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/getVmState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) SetDisplayConfigurations(ctx context.Context, in *DisplayConfigurations, opts ...grpc.CallOption) (*DisplayConfigurations, error) {
	out := new(DisplayConfigurations)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/setDisplayConfigurations", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) GetDisplayConfigurations(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*DisplayConfigurations, error) {
	out := new(DisplayConfigurations)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/getDisplayConfigurations", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) StreamNotification(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (EmulatorController_StreamNotificationClient, error) {
	stream, err := c.cc.NewStream(ctx, &EmulatorController_ServiceDesc.Streams[7], "/android.emulation.control.EmulatorController/streamNotification", opts...)
	if err != nil {
		return nil, err
	}
	x := &emulatorControllerStreamNotificationClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type EmulatorController_StreamNotificationClient interface {
	Recv() (*Notification, error)
	grpc.ClientStream
}

type emulatorControllerStreamNotificationClient struct {
	grpc.ClientStream
}

func (x *emulatorControllerStreamNotificationClient) Recv() (*Notification, error) {
	m := new(Notification)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *emulatorControllerClient) RotateVirtualSceneCamera(ctx context.Context, in *RotationRadian, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/rotateVirtualSceneCamera", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *emulatorControllerClient) SetVirtualSceneCameraVelocity(ctx context.Context, in *Velocity, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/android.emulation.control.EmulatorController/setVirtualSceneCameraVelocity", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// EmulatorControllerServer is the server API for EmulatorController service.
// All implementations must embed UnimplementedEmulatorControllerServer
// for forward compatibility
type EmulatorControllerServer interface {
	// set/get/stream the sensor data
	StreamSensor(*SensorValue, EmulatorController_StreamSensorServer) error
	GetSensor(context.Context, *SensorValue) (*SensorValue, error)
	SetSensor(context.Context, *SensorValue) (*emptypb.Empty, error)
	// set/get/stream the physical model, this is likely the one you are
	// looking for when you wish to modify the device state.
	SetPhysicalModel(context.Context, *PhysicalModelValue) (*emptypb.Empty, error)
	GetPhysicalModel(context.Context, *PhysicalModelValue) (*PhysicalModelValue, error)
	StreamPhysicalModel(*PhysicalModelValue, EmulatorController_StreamPhysicalModelServer) error
	// Atomically set/get the current primary clipboard data.
	SetClipboard(context.Context, *ClipData) (*emptypb.Empty, error)
	GetClipboard(context.Context, *emptypb.Empty) (*ClipData, error)
	// Streams the current data on the clipboard. This will immediately produce
	// a result with the current state of the clipboard after which the stream
	// will block and wait until a new clip event is available from the guest.
	// Calling the setClipboard method above will not result in generating a clip
	// event. It is possible to lose clipboard events if the clipboard updates
	// very rapidly.
	StreamClipboard(*emptypb.Empty, EmulatorController_StreamClipboardServer) error
	// Set/get the battery to the given state.
	SetBattery(context.Context, *BatteryState) (*emptypb.Empty, error)
	GetBattery(context.Context, *emptypb.Empty) (*BatteryState, error)
	// Set the state of the gps, gps support will only work
	// properly if:
	//
	// - no location ui is active. That is the emulator
	//   is launched in headless mode (-no-window) or the location
	//   ui is disabled (-no-location-ui).
	// - the passiveUpdate is set to false. Setting this to false
	//   will disable/break the LocationUI.
	//
	// Keep in mind that android usually only samples the gps at 1 hz.
	SetGps(context.Context, *GpsState) (*emptypb.Empty, error)
	// Gets the latest gps state as delivered by the setGps call, or location ui
	// if active.
	//
	// Note: this is not necessarily the actual gps coordinate visible at the
	// time, due to gps sample frequency (usually 1hz).
	GetGps(context.Context, *emptypb.Empty) (*GpsState, error)
	// Simulate a touch event on the finger print sensor.
	SendFingerprint(context.Context, *Fingerprint) (*emptypb.Empty, error)
	// Send a keyboard event. Translating the event.
	SendKey(context.Context, *KeyboardEvent) (*emptypb.Empty, error)
	// Send touch/mouse events. Note that mouse events can be simulated
	// by touch events.
	SendTouch(context.Context, *TouchEvent) (*emptypb.Empty, error)
	SendMouse(context.Context, *MouseEvent) (*emptypb.Empty, error)
	// Make a phone call.
	SendPhone(context.Context, *PhoneCall) (*PhoneResponse, error)
	// Sends an sms message to the emulator.
	SendSms(context.Context, *SmsMessage) (*PhoneResponse, error)
	// Retrieve the status of the emulator. This will contain general
	// hardware information, and whether the device has booted or not.
	GetStatus(context.Context, *emptypb.Empty) (*EmulatorStatus, error)
	// Gets an individual screenshot in the desired format.
	//
	// The image will be scaled to the desired ImageFormat, while maintaining
	// the aspect ratio. The returned image will never exceed the provided width
	// and height. Not setting the width or height (i.e. they are 0) will result
	// in using the device width and height.
	//
	// The resulting image will be properly oriented and can be displayed
	// directly without post processing. For example, if the device has a
	// 1080x1920 screen and is in landscape mode and called with no width or
	// height parameter, it will return an 1920x1080 image.
	//
	// This method will return an empty image if the display is not visible.
	GetScreenshot(context.Context, *ImageFormat) (*Image, error)
	// Streams a series of screenshots in the desired format.
	// A new frame will be delivered whenever the device produces a new frame.
	// (Beware that this can produce a significant amount of data, and that
	// certain translations are (png transform) can be costly).
	//
	// If the requested display is not visible it will send a single empty image
	// and wait start producing images once the display becomes active, again
	// producing a single empty image when the display becomes inactive.
	StreamScreenshot(*ImageFormat, EmulatorController_StreamScreenshotServer) error
	// Streams a series of audio packets in the desired format.
	// A new frame will be delivered whenever the emulated device
	// produces a new audio frame. You can expect packets to be
	// delivered in intervals of 20-30ms.
	//
	// Be aware that this can block when the emulator does not
	// produce any audio whatsoever!
	StreamAudio(*AudioFormat, EmulatorController_StreamAudioServer) error
	// Injects a series of audio packets to the android microphone.
	// A new frame will be delivered whenever the emulated device
	// requests a new audio frame. Audio is usually delivered at a rate
	// that the emulator is requesting frames. Audio will be stored in a
	// temporary buffer that can hold 500ms of audio.
	//
	// Note: Currently the emulator will downsample to 16khz.
	//
	// -  INVALID_ARGUMENT (code 3) The sampling rate was too high
	// -  INVALID_ARGUMENT (code 3) The audio packet was too large to handle.
	// -  FAILED_PRECONDITION (code 9) If there was a microphone registered already.
	InjectAudio(EmulatorController_InjectAudioServer) error
	// Returns the last 128Kb of logcat output from the emulator
	// Note that parsed logcat messages are only available after L (Api >23).
	// it is possible that the logcat buffer gets overwritten, or falls behind.
	GetLogcat(context.Context, *LogMessage) (*LogMessage, error)
	// Streams the logcat output from the emulator. The first call
	// can retrieve up to 128Kb. This call will not return.
	// Note that parsed logcat messages are only available after L (Api >23)
	// it is possible that the logcat buffer gets overwritten, or falls behind.
	StreamLogcat(*LogMessage, EmulatorController_StreamLogcatServer) error
	// Transition the virtual machine to the desired state. Note that
	// some states are only observable. For example you cannot transition
	// to the error state.
	SetVmState(context.Context, *VmRunState) (*emptypb.Empty, error)
	// Gets the state of the virtual machine.
	GetVmState(context.Context, *emptypb.Empty) (*VmRunState, error)
	// Atomically changes the current multi-display configuration.
	// After this call the given display configurations will be activated. You
	// can only update secondary displays. Displays with id 0 will be ignored.
	//
	// This call can result in the removal or addition of secondary displays, the final
	// display state can be observed by the returned configuration.
	//
	// The following gRPC error codes can be returned:
	// -  FAILED_PRECONDITION (code 9) if the AVD does not support a configurable
	//    secondary display.
	// -  INVALID_ARGUMENT (code 3) if:
	//     - The same display id is defined multiple times.
	//     - The display configurations are outside valid ranges
	//       (see DisplayConfiguration)
	// -  INTERNAL (code 13) if there was an internal emulator failure.
	SetDisplayConfigurations(context.Context, *DisplayConfigurations) (*DisplayConfigurations, error)
	// Returns all currently valid logical displays.
	// The gRPC error code FAILED_PRECONDITION (code 9) is returned if the AVD
	// does not support a configurable secondary display.
	GetDisplayConfigurations(context.Context, *emptypb.Empty) (*DisplayConfigurations, error)
	// Notifies client of the following changes:
	//
	// - Virtual scene camera status change.
	// - Display configuration changes from extended ui. This will only be fired
	//   if the user makes modifications the extended displays through the extended
	//   control tab.
	//
	// Note that this method will send the initial virtual scene state immediately.
	StreamNotification(*emptypb.Empty, EmulatorController_StreamNotificationServer) error
	// RotationRadian is relative to the camera's current orientation.
	RotateVirtualSceneCamera(context.Context, *RotationRadian) (*emptypb.Empty, error)
	// Velocity is absolute
	SetVirtualSceneCameraVelocity(context.Context, *Velocity) (*emptypb.Empty, error)
	mustEmbedUnimplementedEmulatorControllerServer()
}

// UnimplementedEmulatorControllerServer must be embedded to have forward compatible implementations.
type UnimplementedEmulatorControllerServer struct {
}

func (UnimplementedEmulatorControllerServer) StreamSensor(*SensorValue, EmulatorController_StreamSensorServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamSensor not implemented")
}
func (UnimplementedEmulatorControllerServer) GetSensor(context.Context, *SensorValue) (*SensorValue, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSensor not implemented")
}
func (UnimplementedEmulatorControllerServer) SetSensor(context.Context, *SensorValue) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetSensor not implemented")
}
func (UnimplementedEmulatorControllerServer) SetPhysicalModel(context.Context, *PhysicalModelValue) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetPhysicalModel not implemented")
}
func (UnimplementedEmulatorControllerServer) GetPhysicalModel(context.Context, *PhysicalModelValue) (*PhysicalModelValue, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPhysicalModel not implemented")
}
func (UnimplementedEmulatorControllerServer) StreamPhysicalModel(*PhysicalModelValue, EmulatorController_StreamPhysicalModelServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamPhysicalModel not implemented")
}
func (UnimplementedEmulatorControllerServer) SetClipboard(context.Context, *ClipData) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetClipboard not implemented")
}
func (UnimplementedEmulatorControllerServer) GetClipboard(context.Context, *emptypb.Empty) (*ClipData, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetClipboard not implemented")
}
func (UnimplementedEmulatorControllerServer) StreamClipboard(*emptypb.Empty, EmulatorController_StreamClipboardServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamClipboard not implemented")
}
func (UnimplementedEmulatorControllerServer) SetBattery(context.Context, *BatteryState) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetBattery not implemented")
}
func (UnimplementedEmulatorControllerServer) GetBattery(context.Context, *emptypb.Empty) (*BatteryState, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBattery not implemented")
}
func (UnimplementedEmulatorControllerServer) SetGps(context.Context, *GpsState) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetGps not implemented")
}
func (UnimplementedEmulatorControllerServer) GetGps(context.Context, *emptypb.Empty) (*GpsState, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetGps not implemented")
}
func (UnimplementedEmulatorControllerServer) SendFingerprint(context.Context, *Fingerprint) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendFingerprint not implemented")
}
func (UnimplementedEmulatorControllerServer) SendKey(context.Context, *KeyboardEvent) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendKey not implemented")
}
func (UnimplementedEmulatorControllerServer) SendTouch(context.Context, *TouchEvent) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendTouch not implemented")
}
func (UnimplementedEmulatorControllerServer) SendMouse(context.Context, *MouseEvent) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendMouse not implemented")
}
func (UnimplementedEmulatorControllerServer) SendPhone(context.Context, *PhoneCall) (*PhoneResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendPhone not implemented")
}
func (UnimplementedEmulatorControllerServer) SendSms(context.Context, *SmsMessage) (*PhoneResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendSms not implemented")
}
func (UnimplementedEmulatorControllerServer) GetStatus(context.Context, *emptypb.Empty) (*EmulatorStatus, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetStatus not implemented")
}
func (UnimplementedEmulatorControllerServer) GetScreenshot(context.Context, *ImageFormat) (*Image, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetScreenshot not implemented")
}
func (UnimplementedEmulatorControllerServer) StreamScreenshot(*ImageFormat, EmulatorController_StreamScreenshotServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamScreenshot not implemented")
}
func (UnimplementedEmulatorControllerServer) StreamAudio(*AudioFormat, EmulatorController_StreamAudioServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamAudio not implemented")
}
func (UnimplementedEmulatorControllerServer) InjectAudio(EmulatorController_InjectAudioServer) error {
	return status.Errorf(codes.Unimplemented, "method InjectAudio not implemented")
}
func (UnimplementedEmulatorControllerServer) GetLogcat(context.Context, *LogMessage) (*LogMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLogcat not implemented")
}
func (UnimplementedEmulatorControllerServer) StreamLogcat(*LogMessage, EmulatorController_StreamLogcatServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamLogcat not implemented")
}
func (UnimplementedEmulatorControllerServer) SetVmState(context.Context, *VmRunState) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetVmState not implemented")
}
func (UnimplementedEmulatorControllerServer) GetVmState(context.Context, *emptypb.Empty) (*VmRunState, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVmState not implemented")
}
func (UnimplementedEmulatorControllerServer) SetDisplayConfigurations(context.Context, *DisplayConfigurations) (*DisplayConfigurations, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetDisplayConfigurations not implemented")
}
func (UnimplementedEmulatorControllerServer) GetDisplayConfigurations(context.Context, *emptypb.Empty) (*DisplayConfigurations, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDisplayConfigurations not implemented")
}
func (UnimplementedEmulatorControllerServer) StreamNotification(*emptypb.Empty, EmulatorController_StreamNotificationServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamNotification not implemented")
}
func (UnimplementedEmulatorControllerServer) RotateVirtualSceneCamera(context.Context, *RotationRadian) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RotateVirtualSceneCamera not implemented")
}
func (UnimplementedEmulatorControllerServer) SetVirtualSceneCameraVelocity(context.Context, *Velocity) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetVirtualSceneCameraVelocity not implemented")
}
func (UnimplementedEmulatorControllerServer) mustEmbedUnimplementedEmulatorControllerServer() {}

// UnsafeEmulatorControllerServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to EmulatorControllerServer will
// result in compilation errors.
type UnsafeEmulatorControllerServer interface {
	mustEmbedUnimplementedEmulatorControllerServer()
}

func RegisterEmulatorControllerServer(s grpc.ServiceRegistrar, srv EmulatorControllerServer) {
	s.RegisterService(&EmulatorController_ServiceDesc, srv)
}

func _EmulatorController_StreamSensor_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SensorValue)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(EmulatorControllerServer).StreamSensor(m, &emulatorControllerStreamSensorServer{stream})
}

type EmulatorController_StreamSensorServer interface {
	Send(*SensorValue) error
	grpc.ServerStream
}

type emulatorControllerStreamSensorServer struct {
	grpc.ServerStream
}

func (x *emulatorControllerStreamSensorServer) Send(m *SensorValue) error {
	return x.ServerStream.SendMsg(m)
}

func _EmulatorController_GetSensor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SensorValue)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).GetSensor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/getSensor",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).GetSensor(ctx, req.(*SensorValue))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_SetSensor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SensorValue)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).SetSensor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/setSensor",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).SetSensor(ctx, req.(*SensorValue))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_SetPhysicalModel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PhysicalModelValue)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).SetPhysicalModel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/setPhysicalModel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).SetPhysicalModel(ctx, req.(*PhysicalModelValue))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_GetPhysicalModel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PhysicalModelValue)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).GetPhysicalModel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/getPhysicalModel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).GetPhysicalModel(ctx, req.(*PhysicalModelValue))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_StreamPhysicalModel_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PhysicalModelValue)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(EmulatorControllerServer).StreamPhysicalModel(m, &emulatorControllerStreamPhysicalModelServer{stream})
}

type EmulatorController_StreamPhysicalModelServer interface {
	Send(*PhysicalModelValue) error
	grpc.ServerStream
}

type emulatorControllerStreamPhysicalModelServer struct {
	grpc.ServerStream
}

func (x *emulatorControllerStreamPhysicalModelServer) Send(m *PhysicalModelValue) error {
	return x.ServerStream.SendMsg(m)
}

func _EmulatorController_SetClipboard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClipData)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).SetClipboard(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/setClipboard",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).SetClipboard(ctx, req.(*ClipData))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_GetClipboard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).GetClipboard(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/getClipboard",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).GetClipboard(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_StreamClipboard_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(emptypb.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(EmulatorControllerServer).StreamClipboard(m, &emulatorControllerStreamClipboardServer{stream})
}

type EmulatorController_StreamClipboardServer interface {
	Send(*ClipData) error
	grpc.ServerStream
}

type emulatorControllerStreamClipboardServer struct {
	grpc.ServerStream
}

func (x *emulatorControllerStreamClipboardServer) Send(m *ClipData) error {
	return x.ServerStream.SendMsg(m)
}

func _EmulatorController_SetBattery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatteryState)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).SetBattery(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/setBattery",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).SetBattery(ctx, req.(*BatteryState))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_GetBattery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).GetBattery(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/getBattery",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).GetBattery(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_SetGps_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GpsState)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).SetGps(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/setGps",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).SetGps(ctx, req.(*GpsState))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_GetGps_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).GetGps(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/getGps",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).GetGps(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_SendFingerprint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Fingerprint)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).SendFingerprint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/sendFingerprint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).SendFingerprint(ctx, req.(*Fingerprint))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_SendKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(KeyboardEvent)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).SendKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/sendKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).SendKey(ctx, req.(*KeyboardEvent))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_SendTouch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TouchEvent)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).SendTouch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/sendTouch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).SendTouch(ctx, req.(*TouchEvent))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_SendMouse_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MouseEvent)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).SendMouse(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/sendMouse",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).SendMouse(ctx, req.(*MouseEvent))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_SendPhone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PhoneCall)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).SendPhone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/sendPhone",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).SendPhone(ctx, req.(*PhoneCall))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_SendSms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SmsMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).SendSms(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/sendSms",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).SendSms(ctx, req.(*SmsMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_GetStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).GetStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/getStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).GetStatus(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_GetScreenshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImageFormat)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).GetScreenshot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/getScreenshot",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).GetScreenshot(ctx, req.(*ImageFormat))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_StreamScreenshot_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ImageFormat)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(EmulatorControllerServer).StreamScreenshot(m, &emulatorControllerStreamScreenshotServer{stream})
}

type EmulatorController_StreamScreenshotServer interface {
	Send(*Image) error
	grpc.ServerStream
}

type emulatorControllerStreamScreenshotServer struct {
	grpc.ServerStream
}

func (x *emulatorControllerStreamScreenshotServer) Send(m *Image) error {
	return x.ServerStream.SendMsg(m)
}

func _EmulatorController_StreamAudio_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AudioFormat)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(EmulatorControllerServer).StreamAudio(m, &emulatorControllerStreamAudioServer{stream})
}

type EmulatorController_StreamAudioServer interface {
	Send(*AudioPacket) error
	grpc.ServerStream
}

type emulatorControllerStreamAudioServer struct {
	grpc.ServerStream
}

func (x *emulatorControllerStreamAudioServer) Send(m *AudioPacket) error {
	return x.ServerStream.SendMsg(m)
}

func _EmulatorController_InjectAudio_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(EmulatorControllerServer).InjectAudio(&emulatorControllerInjectAudioServer{stream})
}

type EmulatorController_InjectAudioServer interface {
	SendAndClose(*emptypb.Empty) error
	Recv() (*AudioPacket, error)
	grpc.ServerStream
}

type emulatorControllerInjectAudioServer struct {
	grpc.ServerStream
}

func (x *emulatorControllerInjectAudioServer) SendAndClose(m *emptypb.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *emulatorControllerInjectAudioServer) Recv() (*AudioPacket, error) {
	m := new(AudioPacket)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _EmulatorController_GetLogcat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LogMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).GetLogcat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/getLogcat",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).GetLogcat(ctx, req.(*LogMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_StreamLogcat_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LogMessage)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(EmulatorControllerServer).StreamLogcat(m, &emulatorControllerStreamLogcatServer{stream})
}

type EmulatorController_StreamLogcatServer interface {
	Send(*LogMessage) error
	grpc.ServerStream
}

type emulatorControllerStreamLogcatServer struct {
	grpc.ServerStream
}

func (x *emulatorControllerStreamLogcatServer) Send(m *LogMessage) error {
	return x.ServerStream.SendMsg(m)
}

func _EmulatorController_SetVmState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VmRunState)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).SetVmState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/setVmState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).SetVmState(ctx, req.(*VmRunState))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_GetVmState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).GetVmState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/getVmState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).GetVmState(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_SetDisplayConfigurations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DisplayConfigurations)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).SetDisplayConfigurations(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/setDisplayConfigurations",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).SetDisplayConfigurations(ctx, req.(*DisplayConfigurations))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_GetDisplayConfigurations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).GetDisplayConfigurations(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/getDisplayConfigurations",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).GetDisplayConfigurations(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_StreamNotification_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(emptypb.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(EmulatorControllerServer).StreamNotification(m, &emulatorControllerStreamNotificationServer{stream})
}

type EmulatorController_StreamNotificationServer interface {
	Send(*Notification) error
	grpc.ServerStream
}

type emulatorControllerStreamNotificationServer struct {
	grpc.ServerStream
}

func (x *emulatorControllerStreamNotificationServer) Send(m *Notification) error {
	return x.ServerStream.SendMsg(m)
}

func _EmulatorController_RotateVirtualSceneCamera_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RotationRadian)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).RotateVirtualSceneCamera(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/rotateVirtualSceneCamera",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).RotateVirtualSceneCamera(ctx, req.(*RotationRadian))
	}
	return interceptor(ctx, in, info, handler)
}

func _EmulatorController_SetVirtualSceneCameraVelocity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Velocity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EmulatorControllerServer).SetVirtualSceneCameraVelocity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/android.emulation.control.EmulatorController/setVirtualSceneCameraVelocity",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EmulatorControllerServer).SetVirtualSceneCameraVelocity(ctx, req.(*Velocity))
	}
	return interceptor(ctx, in, info, handler)
}

// EmulatorController_ServiceDesc is the grpc.ServiceDesc for EmulatorController service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var EmulatorController_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "android.emulation.control.EmulatorController",
	HandlerType: (*EmulatorControllerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "getSensor",
			Handler:    _EmulatorController_GetSensor_Handler,
		},
		{
			MethodName: "setSensor",
			Handler:    _EmulatorController_SetSensor_Handler,
		},
		{
			MethodName: "setPhysicalModel",
			Handler:    _EmulatorController_SetPhysicalModel_Handler,
		},
		{
			MethodName: "getPhysicalModel",
			Handler:    _EmulatorController_GetPhysicalModel_Handler,
		},
		{
			MethodName: "setClipboard",
			Handler:    _EmulatorController_SetClipboard_Handler,
		},
		{
			MethodName: "getClipboard",
			Handler:    _EmulatorController_GetClipboard_Handler,
		},
		{
			MethodName: "setBattery",
			Handler:    _EmulatorController_SetBattery_Handler,
		},
		{
			MethodName: "getBattery",
			Handler:    _EmulatorController_GetBattery_Handler,
		},
		{
			MethodName: "setGps",
			Handler:    _EmulatorController_SetGps_Handler,
		},
		{
			MethodName: "getGps",
			Handler:    _EmulatorController_GetGps_Handler,
		},
		{
			MethodName: "sendFingerprint",
			Handler:    _EmulatorController_SendFingerprint_Handler,
		},
		{
			MethodName: "sendKey",
			Handler:    _EmulatorController_SendKey_Handler,
		},
		{
			MethodName: "sendTouch",
			Handler:    _EmulatorController_SendTouch_Handler,
		},
		{
			MethodName: "sendMouse",
			Handler:    _EmulatorController_SendMouse_Handler,
		},
		{
			MethodName: "sendPhone",
			Handler:    _EmulatorController_SendPhone_Handler,
		},
		{
			MethodName: "sendSms",
			Handler:    _EmulatorController_SendSms_Handler,
		},
		{
			MethodName: "getStatus",
			Handler:    _EmulatorController_GetStatus_Handler,
		},
		{
			MethodName: "getScreenshot",
			Handler:    _EmulatorController_GetScreenshot_Handler,
		},
		{
			MethodName: "getLogcat",
			Handler:    _EmulatorController_GetLogcat_Handler,
		},
		{
			MethodName: "setVmState",
			Handler:    _EmulatorController_SetVmState_Handler,
		},
		{
			MethodName: "getVmState",
			Handler:    _EmulatorController_GetVmState_Handler,
		},
		{
			MethodName: "setDisplayConfigurations",
			Handler:    _EmulatorController_SetDisplayConfigurations_Handler,
		},
		{
			MethodName: "getDisplayConfigurations",
			Handler:    _EmulatorController_GetDisplayConfigurations_Handler,
		},
		{
			MethodName: "rotateVirtualSceneCamera",
			Handler:    _EmulatorController_RotateVirtualSceneCamera_Handler,
		},
		{
			MethodName: "setVirtualSceneCameraVelocity",
			Handler:    _EmulatorController_SetVirtualSceneCameraVelocity_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "streamSensor",
			Handler:       _EmulatorController_StreamSensor_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "streamPhysicalModel",
			Handler:       _EmulatorController_StreamPhysicalModel_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "streamClipboard",
			Handler:       _EmulatorController_StreamClipboard_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "streamScreenshot",
			Handler:       _EmulatorController_StreamScreenshot_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "streamAudio",
			Handler:       _EmulatorController_StreamAudio_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "injectAudio",
			Handler:       _EmulatorController_InjectAudio_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "streamLogcat",
			Handler:       _EmulatorController_StreamLogcat_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "streamNotification",
			Handler:       _EmulatorController_StreamNotification_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "emulator_controller.proto",
}