app.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: app.proto

package apprpc

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type Empty struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Empty) Reset()         { *m = Empty{} }
func (m *Empty) String() string { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage()    {}
func (*Empty) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0f9056a14b86d47, []int{0}
}

func (m *Empty) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Empty.Unmarshal(m, b)
}
func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
}
func (m *Empty) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Empty.Merge(m, src)
}
func (m *Empty) XXX_Size() int {
	return xxx_messageInfo_Empty.Size(m)
}
func (m *Empty) XXX_DiscardUnknown() {
	xxx_messageInfo_Empty.DiscardUnknown(m)
}

var xxx_messageInfo_Empty proto.InternalMessageInfo

type Message struct {
	Message              string   `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Message) Reset()         { *m = Message{} }
func (m *Message) String() string { return proto.CompactTextString(m) }
func (*Message) ProtoMessage()    {}
func (*Message) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0f9056a14b86d47, []int{1}
}

func (m *Message) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Message.Unmarshal(m, b)
}
func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Message.Marshal(b, m, deterministic)
}
func (m *Message) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Message.Merge(m, src)
}
func (m *Message) XXX_Size() int {
	return xxx_messageInfo_Message.Size(m)
}
func (m *Message) XXX_DiscardUnknown() {
	xxx_messageInfo_Message.DiscardUnknown(m)
}

var xxx_messageInfo_Message proto.InternalMessageInfo

func (m *Message) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type Device struct {
	Serial               string   `protobuf:"bytes,1,opt,name=serial,proto3" json:"serial,omitempty"`
	ServiceIp            string   `protobuf:"bytes,2,opt,name=serviceIp,proto3" json:"serviceIp,omitempty"`
	ServicePort          string   `protobuf:"bytes,3,opt,name=servicePort,proto3" json:"servicePort,omitempty"`
	ServicePid1          string   `protobuf:"bytes,4,opt,name=servicePid1,proto3" json:"servicePid1,omitempty"`
	ServicePid2          string   `protobuf:"bytes,5,opt,name=servicePid2,proto3" json:"servicePid2,omitempty"`
	ServiceForward       string   `protobuf:"bytes,7,opt,name=serviceForward,proto3" json:"serviceForward,omitempty"`
	ServiceLaunched      bool     `protobuf:"varint,6,opt,name=serviceLaunched,proto3" json:"serviceLaunched,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Device) Reset()         { *m = Device{} }
func (m *Device) String() string { return proto.CompactTextString(m) }
func (*Device) ProtoMessage()    {}
func (*Device) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0f9056a14b86d47, []int{2}
}

func (m *Device) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Device.Unmarshal(m, b)
}
func (m *Device) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Device.Marshal(b, m, deterministic)
}
func (m *Device) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Device.Merge(m, src)
}
func (m *Device) XXX_Size() int {
	return xxx_messageInfo_Device.Size(m)
}
func (m *Device) XXX_DiscardUnknown() {
	xxx_messageInfo_Device.DiscardUnknown(m)
}

var xxx_messageInfo_Device proto.InternalMessageInfo

func (m *Device) GetSerial() string {
	if m != nil {
		return m.Serial
	}
	return ""
}

func (m *Device) GetServiceIp() string {
	if m != nil {
		return m.ServiceIp
	}
	return ""
}

func (m *Device) GetServicePort() string {
	if m != nil {
		return m.ServicePort
	}
	return ""
}

func (m *Device) GetServicePid1() string {
	if m != nil {
		return m.ServicePid1
	}
	return ""
}

func (m *Device) GetServicePid2() string {
	if m != nil {
		return m.ServicePid2
	}
	return ""
}

func (m *Device) GetServiceForward() string {
	if m != nil {
		return m.ServiceForward
	}
	return ""
}

func (m *Device) GetServiceLaunched() bool {
	if m != nil {
		return m.ServiceLaunched
	}
	return false
}

type Devices struct {
	Devices              []*Device `protobuf:"bytes,1,rep,name=devices,proto3" json:"devices,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *Devices) Reset()         { *m = Devices{} }
func (m *Devices) String() string { return proto.CompactTextString(m) }
func (*Devices) ProtoMessage()    {}
func (*Devices) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0f9056a14b86d47, []int{3}
}

func (m *Devices) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Devices.Unmarshal(m, b)
}
func (m *Devices) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Devices.Marshal(b, m, deterministic)
}
func (m *Devices) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Devices.Merge(m, src)
}
func (m *Devices) XXX_Size() int {
	return xxx_messageInfo_Devices.Size(m)
}
func (m *Devices) XXX_DiscardUnknown() {
	xxx_messageInfo_Devices.DiscardUnknown(m)
}

var xxx_messageInfo_Devices proto.InternalMessageInfo

func (m *Devices) GetDevices() []*Device {
	if m != nil {
		return m.Devices
	}
	return nil
}

type DeviceSerial struct {
	Serial               string   `protobuf:"bytes,1,opt,name=serial,proto3" json:"serial,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeviceSerial) Reset()         { *m = DeviceSerial{} }
func (m *DeviceSerial) String() string { return proto.CompactTextString(m) }
func (*DeviceSerial) ProtoMessage()    {}
func (*DeviceSerial) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0f9056a14b86d47, []int{4}
}

func (m *DeviceSerial) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DeviceSerial.Unmarshal(m, b)
}
func (m *DeviceSerial) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DeviceSerial.Marshal(b, m, deterministic)
}
func (m *DeviceSerial) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeviceSerial.Merge(m, src)
}
func (m *DeviceSerial) XXX_Size() int {
	return xxx_messageInfo_DeviceSerial.Size(m)
}
func (m *DeviceSerial) XXX_DiscardUnknown() {
	xxx_messageInfo_DeviceSerial.DiscardUnknown(m)
}

var xxx_messageInfo_DeviceSerial proto.InternalMessageInfo

func (m *DeviceSerial) GetSerial() string {
	if m != nil {
		return m.Serial
	}
	return ""
}

type GetStartCommandResult struct {
	LdPath               string   `protobuf:"bytes,1,opt,name=ldPath,proto3" json:"ldPath,omitempty"`
	ClassPath            string   `protobuf:"bytes,2,opt,name=classPath,proto3" json:"classPath,omitempty"`
	AppProcess           string   `protobuf:"bytes,3,opt,name=appProcess,proto3" json:"appProcess,omitempty"`
	BaseCommand          string   `protobuf:"bytes,4,opt,name=baseCommand,proto3" json:"baseCommand,omitempty"`
	FullCommand          string   `protobuf:"bytes,5,opt,name=fullCommand,proto3" json:"fullCommand,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetStartCommandResult) Reset()         { *m = GetStartCommandResult{} }
func (m *GetStartCommandResult) String() string { return proto.CompactTextString(m) }
func (*GetStartCommandResult) ProtoMessage()    {}
func (*GetStartCommandResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0f9056a14b86d47, []int{5}
}

func (m *GetStartCommandResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetStartCommandResult.Unmarshal(m, b)
}
func (m *GetStartCommandResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetStartCommandResult.Marshal(b, m, deterministic)
}
func (m *GetStartCommandResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetStartCommandResult.Merge(m, src)
}
func (m *GetStartCommandResult) XXX_Size() int {
	return xxx_messageInfo_GetStartCommandResult.Size(m)
}
func (m *GetStartCommandResult) XXX_DiscardUnknown() {
	xxx_messageInfo_GetStartCommandResult.DiscardUnknown(m)
}

var xxx_messageInfo_GetStartCommandResult proto.InternalMessageInfo

func (m *GetStartCommandResult) GetLdPath() string {
	if m != nil {
		return m.LdPath
	}
	return ""
}

func (m *GetStartCommandResult) GetClassPath() string {
	if m != nil {
		return m.ClassPath
	}
	return ""
}

func (m *GetStartCommandResult) GetAppProcess() string {
	if m != nil {
		return m.AppProcess
	}
	return ""
}

func (m *GetStartCommandResult) GetBaseCommand() string {
	if m != nil {
		return m.BaseCommand
	}
	return ""
}

func (m *GetStartCommandResult) GetFullCommand() string {
	if m != nil {
		return m.FullCommand
	}
	return ""
}

type AdbConnectParams struct {
	Ip                   string   `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"`
	Port                 string   `protobuf:"bytes,2,opt,name=port,proto3" json:"port,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AdbConnectParams) Reset()         { *m = AdbConnectParams{} }
func (m *AdbConnectParams) String() string { return proto.CompactTextString(m) }
func (*AdbConnectParams) ProtoMessage()    {}
func (*AdbConnectParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0f9056a14b86d47, []int{6}
}

func (m *AdbConnectParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AdbConnectParams.Unmarshal(m, b)
}
func (m *AdbConnectParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AdbConnectParams.Marshal(b, m, deterministic)
}
func (m *AdbConnectParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AdbConnectParams.Merge(m, src)
}
func (m *AdbConnectParams) XXX_Size() int {
	return xxx_messageInfo_AdbConnectParams.Size(m)
}
func (m *AdbConnectParams) XXX_DiscardUnknown() {
	xxx_messageInfo_AdbConnectParams.DiscardUnknown(m)
}

var xxx_messageInfo_AdbConnectParams proto.InternalMessageInfo

func (m *AdbConnectParams) GetIp() string {
	if m != nil {
		return m.Ip
	}
	return ""
}

func (m *AdbConnectParams) GetPort() string {
	if m != nil {
		return m.Port
	}
	return ""
}

type AdbShellParams struct {
	Serial               string   `protobuf:"bytes,1,opt,name=serial,proto3" json:"serial,omitempty"`
	Command              string   `protobuf:"bytes,2,opt,name=command,proto3" json:"command,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AdbShellParams) Reset()         { *m = AdbShellParams{} }
func (m *AdbShellParams) String() string { return proto.CompactTextString(m) }
func (*AdbShellParams) ProtoMessage()    {}
func (*AdbShellParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0f9056a14b86d47, []int{7}
}

func (m *AdbShellParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AdbShellParams.Unmarshal(m, b)
}
func (m *AdbShellParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AdbShellParams.Marshal(b, m, deterministic)
}
func (m *AdbShellParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AdbShellParams.Merge(m, src)
}
func (m *AdbShellParams) XXX_Size() int {
	return xxx_messageInfo_AdbShellParams.Size(m)
}
func (m *AdbShellParams) XXX_DiscardUnknown() {
	xxx_messageInfo_AdbShellParams.DiscardUnknown(m)
}

var xxx_messageInfo_AdbShellParams proto.InternalMessageInfo

func (m *AdbShellParams) GetSerial() string {
	if m != nil {
		return m.Serial
	}
	return ""
}

func (m *AdbShellParams) GetCommand() string {
	if m != nil {
		return m.Command
	}
	return ""
}

type AdbForwardParams struct {
	Serial               string   `protobuf:"bytes,1,opt,name=serial,proto3" json:"serial,omitempty"`
	DevicePort           string   `protobuf:"bytes,2,opt,name=devicePort,proto3" json:"devicePort,omitempty"`
	PcPort               string   `protobuf:"bytes,3,opt,name=pcPort,proto3" json:"pcPort,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AdbForwardParams) Reset()         { *m = AdbForwardParams{} }
func (m *AdbForwardParams) String() string { return proto.CompactTextString(m) }
func (*AdbForwardParams) ProtoMessage()    {}
func (*AdbForwardParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0f9056a14b86d47, []int{8}
}

func (m *AdbForwardParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AdbForwardParams.Unmarshal(m, b)
}
func (m *AdbForwardParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AdbForwardParams.Marshal(b, m, deterministic)
}
func (m *AdbForwardParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AdbForwardParams.Merge(m, src)
}
func (m *AdbForwardParams) XXX_Size() int {
	return xxx_messageInfo_AdbForwardParams.Size(m)
}
func (m *AdbForwardParams) XXX_DiscardUnknown() {
	xxx_messageInfo_AdbForwardParams.DiscardUnknown(m)
}

var xxx_messageInfo_AdbForwardParams proto.InternalMessageInfo

func (m *AdbForwardParams) GetSerial() string {
	if m != nil {
		return m.Serial
	}
	return ""
}

func (m *AdbForwardParams) GetDevicePort() string {
	if m != nil {
		return m.DevicePort
	}
	return ""
}

func (m *AdbForwardParams) GetPcPort() string {
	if m != nil {
		return m.PcPort
	}
	return ""
}

type AdbTCPIPParams struct {
	Serial               string   `protobuf:"bytes,1,opt,name=serial,proto3" json:"serial,omitempty"`
	Port                 string   `protobuf:"bytes,2,opt,name=port,proto3" json:"port,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AdbTCPIPParams) Reset()         { *m = AdbTCPIPParams{} }
func (m *AdbTCPIPParams) String() string { return proto.CompactTextString(m) }
func (*AdbTCPIPParams) ProtoMessage()    {}
func (*AdbTCPIPParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0f9056a14b86d47, []int{9}
}

func (m *AdbTCPIPParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AdbTCPIPParams.Unmarshal(m, b)
}
func (m *AdbTCPIPParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AdbTCPIPParams.Marshal(b, m, deterministic)
}
func (m *AdbTCPIPParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AdbTCPIPParams.Merge(m, src)
}
func (m *AdbTCPIPParams) XXX_Size() int {
	return xxx_messageInfo_AdbTCPIPParams.Size(m)
}
func (m *AdbTCPIPParams) XXX_DiscardUnknown() {
	xxx_messageInfo_AdbTCPIPParams.DiscardUnknown(m)
}

var xxx_messageInfo_AdbTCPIPParams proto.InternalMessageInfo

func (m *AdbTCPIPParams) GetSerial() string {
	if m != nil {
		return m.Serial
	}
	return ""
}

func (m *AdbTCPIPParams) GetPort() string {
	if m != nil {
		return m.Port
	}
	return ""
}

type StartServiceResult struct {
	Pid1                 string   `protobuf:"bytes,1,opt,name=pid1,proto3" json:"pid1,omitempty"`
	Pid2                 string   `protobuf:"bytes,2,opt,name=pid2,proto3" json:"pid2,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StartServiceResult) Reset()         { *m = StartServiceResult{} }
func (m *StartServiceResult) String() string { return proto.CompactTextString(m) }
func (*StartServiceResult) ProtoMessage()    {}
func (*StartServiceResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0f9056a14b86d47, []int{10}
}

func (m *StartServiceResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StartServiceResult.Unmarshal(m, b)
}
func (m *StartServiceResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StartServiceResult.Marshal(b, m, deterministic)
}
func (m *StartServiceResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StartServiceResult.Merge(m, src)
}
func (m *StartServiceResult) XXX_Size() int {
	return xxx_messageInfo_StartServiceResult.Size(m)
}
func (m *StartServiceResult) XXX_DiscardUnknown() {
	xxx_messageInfo_StartServiceResult.DiscardUnknown(m)
}

var xxx_messageInfo_StartServiceResult proto.InternalMessageInfo

func (m *StartServiceResult) GetPid1() string {
	if m != nil {
		return m.Pid1
	}
	return ""
}

func (m *StartServiceResult) GetPid2() string {
	if m != nil {
		return m.Pid2
	}
	return ""
}

type CreateGRPCProxy struct {
	GrpcAddress          string   `protobuf:"bytes,1,opt,name=grpcAddress,proto3" json:"grpcAddress,omitempty"`
	HttpAddress          string   `protobuf:"bytes,2,opt,name=httpAddress,proto3" json:"httpAddress,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateGRPCProxy) Reset()         { *m = CreateGRPCProxy{} }
func (m *CreateGRPCProxy) String() string { return proto.CompactTextString(m) }
func (*CreateGRPCProxy) ProtoMessage()    {}
func (*CreateGRPCProxy) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0f9056a14b86d47, []int{11}
}

func (m *CreateGRPCProxy) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CreateGRPCProxy.Unmarshal(m, b)
}
func (m *CreateGRPCProxy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CreateGRPCProxy.Marshal(b, m, deterministic)
}
func (m *CreateGRPCProxy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateGRPCProxy.Merge(m, src)
}
func (m *CreateGRPCProxy) XXX_Size() int {
	return xxx_messageInfo_CreateGRPCProxy.Size(m)
}
func (m *CreateGRPCProxy) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateGRPCProxy.DiscardUnknown(m)
}

var xxx_messageInfo_CreateGRPCProxy proto.InternalMessageInfo

func (m *CreateGRPCProxy) GetGrpcAddress() string {
	if m != nil {
		return m.GrpcAddress
	}
	return ""
}

func (m *CreateGRPCProxy) GetHttpAddress() string {
	if m != nil {
		return m.HttpAddress
	}
	return ""
}

func init() {
	proto.RegisterType((*Empty)(nil), "apprpc.Empty")
	proto.RegisterType((*Message)(nil), "apprpc.Message")
	proto.RegisterType((*Device)(nil), "apprpc.Device")
	proto.RegisterType((*Devices)(nil), "apprpc.Devices")
	proto.RegisterType((*DeviceSerial)(nil), "apprpc.DeviceSerial")
	proto.RegisterType((*GetStartCommandResult)(nil), "apprpc.GetStartCommandResult")
	proto.RegisterType((*AdbConnectParams)(nil), "apprpc.AdbConnectParams")
	proto.RegisterType((*AdbShellParams)(nil), "apprpc.AdbShellParams")
	proto.RegisterType((*AdbForwardParams)(nil), "apprpc.AdbForwardParams")
	proto.RegisterType((*AdbTCPIPParams)(nil), "apprpc.AdbTCPIPParams")
	proto.RegisterType((*StartServiceResult)(nil), "apprpc.StartServiceResult")
	proto.RegisterType((*CreateGRPCProxy)(nil), "apprpc.CreateGRPCProxy")
}

func init() { proto.RegisterFile("app.proto", fileDescriptor_e0f9056a14b86d47) }

var fileDescriptor_e0f9056a14b86d47 = []byte{
	// 642 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x95, 0xdd, 0x6e, 0xd3, 0x30,
	0x14, 0xc7, 0x9b, 0x7d, 0x34, 0xdb, 0xe9, 0x68, 0x91, 0x05, 0x23, 0x9a, 0x60, 0xaa, 0x8c, 0x34,
	0xf5, 0x02, 0x55, 0x5a, 0x26, 0x26, 0x21, 0xed, 0xa6, 0x2b, 0x30, 0x26, 0x0d, 0x29, 0x4a, 0xe1,
	0x01, 0xdc, 0xc4, 0xac, 0x91, 0xd2, 0xc6, 0xb2, 0x3d, 0x60, 0xd7, 0x3c, 0x11, 0x2f, 0xc7, 0x35,
	0xf2, 0xd7, 0xea, 0x84, 0x94, 0xdd, 0xe5, 0xfc, 0xfd, 0x3f, 0x3e, 0xa7, 0xe7, 0xfc, 0xe4, 0xc2,
	0x3e, 0x61, 0x6c, 0xcc, 0x78, 0x25, 0x2b, 0xd4, 0x25, 0x8c, 0x71, 0x96, 0xe1, 0x10, 0x76, 0x3f,
	0x2c, 0x99, 0xbc, 0xc7, 0xaf, 0x21, 0xfc, 0x4c, 0x85, 0x20, 0xb7, 0x14, 0x45, 0x10, 0x2e, 0xcd,
	0x67, 0x14, 0x0c, 0x83, 0xd1, 0x7e, 0xea, 0x42, 0xfc, 0x27, 0x80, 0xee, 0x7b, 0xfa, 0xbd, 0xc8,
	0x28, 0x3a, 0x84, 0xae, 0xa0, 0xbc, 0x20, 0xa5, 0xf5, 0xd8, 0x08, 0xbd, 0x84, 0x7d, 0x41, 0xb9,
	0xb2, 0x5c, 0xb3, 0x68, 0x4b, 0x1f, 0xad, 0x05, 0x34, 0x84, 0x9e, 0x0d, 0x92, 0x8a, 0xcb, 0x68,
	0x5b, 0x9f, 0xfb, 0x92, 0xef, 0x28, 0xf2, 0xd3, 0x68, 0xa7, 0xee, 0x28, 0xf2, 0xd3, 0xba, 0x23,
	0x8e, 0x76, 0x9b, 0x8e, 0x18, 0x9d, 0x40, 0xdf, 0x86, 0x1f, 0x2b, 0xfe, 0x83, 0xf0, 0x3c, 0x0a,
	0xb5, 0xa9, 0xa1, 0xa2, 0x11, 0x0c, 0xac, 0x72, 0x43, 0xee, 0x56, 0xd9, 0x82, 0xe6, 0x51, 0x77,
	0x18, 0x8c, 0xf6, 0xd2, 0xa6, 0x8c, 0xcf, 0x20, 0x34, 0xbf, 0x5b, 0xa0, 0x11, 0x84, 0xb9, 0xf9,
	0x8c, 0x82, 0xe1, 0xf6, 0xa8, 0x17, 0xf7, 0xc7, 0x66, 0x96, 0x63, 0xe3, 0x48, 0xdd, 0x31, 0x3e,
	0x81, 0x03, 0x23, 0xcd, 0xcc, 0x68, 0x36, 0x8c, 0x0c, 0xff, 0x0e, 0xe0, 0xf9, 0x15, 0x95, 0x33,
	0x49, 0xb8, 0x9c, 0x56, 0xcb, 0x25, 0x59, 0xe5, 0x29, 0x15, 0x77, 0xa5, 0x54, 0x19, 0x65, 0x9e,
	0x10, 0xb9, 0x70, 0x19, 0x26, 0x52, 0x43, 0xce, 0x4a, 0x22, 0x84, 0x3e, 0xb2, 0x43, 0x7e, 0x10,
	0xd0, 0x31, 0x00, 0x61, 0x2c, 0xe1, 0x55, 0x46, 0x85, 0xb0, 0x33, 0xf6, 0x14, 0x35, 0xc0, 0x39,
	0x11, 0xd4, 0x96, 0x72, 0x23, 0xf6, 0x24, 0xe5, 0xf8, 0x76, 0x57, 0x96, 0xce, 0x61, 0x47, 0xec,
	0x49, 0xf8, 0x1c, 0x9e, 0x4e, 0xf2, 0xf9, 0xb4, 0x5a, 0xad, 0x68, 0x26, 0x13, 0xc2, 0xc9, 0x52,
	0xa0, 0x3e, 0x6c, 0x15, 0xcc, 0x76, 0xba, 0x55, 0x30, 0x84, 0x60, 0x87, 0xa9, 0x2d, 0x9b, 0x06,
	0xf5, 0x37, 0xbe, 0x84, 0xfe, 0x24, 0x9f, 0xcf, 0x16, 0xb4, 0x2c, 0x6d, 0xd6, 0x26, 0x90, 0x22,
	0x08, 0x33, 0x5b, 0xdf, 0x5c, 0xe0, 0x42, 0x3c, 0xd7, 0xb5, 0xed, 0x12, 0x1f, 0xb9, 0xe5, 0x18,
	0xc0, 0xac, 0x23, 0x59, 0x77, 0xe2, 0x29, 0x2a, 0x8f, 0x65, 0x1e, 0x8b, 0x36, 0xc2, 0x17, 0xba,
	0xcf, 0x2f, 0xd3, 0xe4, 0x3a, 0x79, 0xa4, 0x42, 0xdb, 0xaf, 0xbc, 0x00, 0xa4, 0xb7, 0x39, 0x33,
	0x18, 0xd9, 0x6d, 0x2a, 0xa7, 0x62, 0x3a, 0xb0, 0x4e, 0x05, 0xb3, 0xd1, 0xe2, 0x87, 0xec, 0x22,
	0x8f, 0xf1, 0x57, 0x18, 0x4c, 0x39, 0x25, 0x92, 0x5e, 0xa5, 0xc9, 0x34, 0xe1, 0xd5, 0xcf, 0x7b,
	0xb5, 0x90, 0x5b, 0xce, 0xb2, 0x49, 0x9e, 0x73, 0xb5, 0x53, 0x73, 0x83, 0x2f, 0x29, 0xc7, 0x42,
	0x4a, 0xe6, 0x1c, 0xe6, 0x3e, 0x5f, 0x8a, 0x7f, 0xed, 0x02, 0x4c, 0x18, 0xb3, 0x3d, 0xa1, 0x31,
	0xc0, 0x15, 0x95, 0x8e, 0xea, 0x27, 0x0e, 0x62, 0xfd, 0x1a, 0x1c, 0x0d, 0xea, 0x4c, 0x0b, 0xdc,
	0x41, 0x9f, 0x60, 0xd0, 0x80, 0x14, 0x3d, 0xab, 0xbb, 0x0c, 0xe6, 0x47, 0xaf, 0x9c, 0xda, 0xca,
	0x34, 0xee, 0xa0, 0x77, 0x00, 0x6b, 0x76, 0x50, 0xe4, 0xec, 0x4d, 0x9e, 0xd6, 0x4d, 0xd8, 0x87,
	0x09, 0x77, 0xd0, 0x1b, 0x9d, 0x9a, 0x52, 0xa1, 0xee, 0x6d, 0x36, 0x5d, 0x0f, 0x71, 0x07, 0xbd,
	0x85, 0x3d, 0x07, 0x1b, 0x3a, 0xf4, 0xca, 0x78, 0xf8, 0xb5, 0x15, 0x31, 0xfd, 0xb9, 0x47, 0xc2,
	0xef, 0xaf, 0xc6, 0x5c, 0x5b, 0x6a, 0xac, 0xb1, 0xb1, 0xb6, 0x9b, 0x42, 0xc8, 0x8d, 0x83, 0x5d,
	0xe7, 0x98, 0x2e, 0x35, 0x6a, 0xb5, 0x2e, 0x3d, 0xf8, 0xda, 0xd2, 0x2e, 0xe1, 0xc0, 0x67, 0x6c,
	0xc3, 0x32, 0x8e, 0x9c, 0xfa, 0x2f, 0x8f, 0xb8, 0x83, 0xce, 0xa1, 0x37, 0x93, 0x15, 0xfb, 0xff,
	0x15, 0xad, 0x13, 0xea, 0x19, 0x42, 0x0d, 0x9d, 0x2f, 0x9c, 0xa3, 0x81, 0x6d, 0x4b, 0xea, 0xbc,
	0xab, 0xff, 0x7f, 0xce, 0xfe, 0x06, 0x00, 0x00, 0xff, 0xff, 0xd4, 0xdf, 0xe1, 0xc3, 0x8c, 0x06,
	0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// AppServiceClient is the client API for AppService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AppServiceClient interface {
	GetDevices(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Devices, error)
	GetStartCommand(ctx context.Context, in *DeviceSerial, opts ...grpc.CallOption) (*GetStartCommandResult, error)
	AdbConnect(ctx context.Context, in *AdbConnectParams, opts ...grpc.CallOption) (*Message, error)
	AdbRestart(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error)
	AdbShell(ctx context.Context, in *AdbShellParams, opts ...grpc.CallOption) (*Message, error)
	AdbForward(ctx context.Context, in *AdbForwardParams, opts ...grpc.CallOption) (*Message, error)
	AdbForwardList(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Message, error)
	AdbTCPIP(ctx context.Context, in *AdbTCPIPParams, opts ...grpc.CallOption) (*Message, error)
	StartService(ctx context.Context, in *DeviceSerial, opts ...grpc.CallOption) (*StartServiceResult, error)
	StopService(ctx context.Context, in *DeviceSerial, opts ...grpc.CallOption) (*Message, error)
	CreateProxy(ctx context.Context, in *CreateGRPCProxy, opts ...grpc.CallOption) (*Message, error)
}

type appServiceClient struct {
	cc *grpc.ClientConn
}

func NewAppServiceClient(cc *grpc.ClientConn) AppServiceClient {
	return &appServiceClient{cc}
}

func (c *appServiceClient) GetDevices(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Devices, error) {
	out := new(Devices)
	err := c.cc.Invoke(ctx, "/apprpc.AppService/GetDevices", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appServiceClient) GetStartCommand(ctx context.Context, in *DeviceSerial, opts ...grpc.CallOption) (*GetStartCommandResult, error) {
	out := new(GetStartCommandResult)
	err := c.cc.Invoke(ctx, "/apprpc.AppService/GetStartCommand", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appServiceClient) AdbConnect(ctx context.Context, in *AdbConnectParams, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/apprpc.AppService/AdbConnect", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appServiceClient) AdbRestart(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/apprpc.AppService/AdbRestart", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appServiceClient) AdbShell(ctx context.Context, in *AdbShellParams, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/apprpc.AppService/AdbShell", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appServiceClient) AdbForward(ctx context.Context, in *AdbForwardParams, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/apprpc.AppService/AdbForward", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appServiceClient) AdbForwardList(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/apprpc.AppService/AdbForwardList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appServiceClient) AdbTCPIP(ctx context.Context, in *AdbTCPIPParams, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/apprpc.AppService/AdbTCPIP", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appServiceClient) StartService(ctx context.Context, in *DeviceSerial, opts ...grpc.CallOption) (*StartServiceResult, error) {
	out := new(StartServiceResult)
	err := c.cc.Invoke(ctx, "/apprpc.AppService/StartService", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appServiceClient) StopService(ctx context.Context, in *DeviceSerial, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/apprpc.AppService/StopService", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appServiceClient) CreateProxy(ctx context.Context, in *CreateGRPCProxy, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/apprpc.AppService/CreateProxy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AppServiceServer is the server API for AppService service.
type AppServiceServer interface {
	GetDevices(context.Context, *Empty) (*Devices, error)
	GetStartCommand(context.Context, *DeviceSerial) (*GetStartCommandResult, error)
	AdbConnect(context.Context, *AdbConnectParams) (*Message, error)
	AdbRestart(context.Context, *Empty) (*Empty, error)
	AdbShell(context.Context, *AdbShellParams) (*Message, error)
	AdbForward(context.Context, *AdbForwardParams) (*Message, error)
	AdbForwardList(context.Context, *Empty) (*Message, error)
	AdbTCPIP(context.Context, *AdbTCPIPParams) (*Message, error)
	StartService(context.Context, *DeviceSerial) (*StartServiceResult, error)
	StopService(context.Context, *DeviceSerial) (*Message, error)
	CreateProxy(context.Context, *CreateGRPCProxy) (*Message, error)
}

// UnimplementedAppServiceServer can be embedded to have forward compatible implementations.
type UnimplementedAppServiceServer struct {
}

func (*UnimplementedAppServiceServer) GetDevices(ctx context.Context, req *Empty) (*Devices, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDevices not implemented")
}
func (*UnimplementedAppServiceServer) GetStartCommand(ctx context.Context, req *DeviceSerial) (*GetStartCommandResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetStartCommand not implemented")
}
func (*UnimplementedAppServiceServer) AdbConnect(ctx context.Context, req *AdbConnectParams) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AdbConnect not implemented")
}
func (*UnimplementedAppServiceServer) AdbRestart(ctx context.Context, req *Empty) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AdbRestart not implemented")
}
func (*UnimplementedAppServiceServer) AdbShell(ctx context.Context, req *AdbShellParams) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AdbShell not implemented")
}
func (*UnimplementedAppServiceServer) AdbForward(ctx context.Context, req *AdbForwardParams) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AdbForward not implemented")
}
func (*UnimplementedAppServiceServer) AdbForwardList(ctx context.Context, req *Empty) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AdbForwardList not implemented")
}
func (*UnimplementedAppServiceServer) AdbTCPIP(ctx context.Context, req *AdbTCPIPParams) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AdbTCPIP not implemented")
}
func (*UnimplementedAppServiceServer) StartService(ctx context.Context, req *DeviceSerial) (*StartServiceResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartService not implemented")
}
func (*UnimplementedAppServiceServer) StopService(ctx context.Context, req *DeviceSerial) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopService not implemented")
}
func (*UnimplementedAppServiceServer) CreateProxy(ctx context.Context, req *CreateGRPCProxy) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateProxy not implemented")
}

func RegisterAppServiceServer(s *grpc.Server, srv AppServiceServer) {
	s.RegisterService(&_AppService_serviceDesc, srv)
}

func _AppService_GetDevices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppServiceServer).GetDevices(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apprpc.AppService/GetDevices",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppServiceServer).GetDevices(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppService_GetStartCommand_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeviceSerial)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppServiceServer).GetStartCommand(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apprpc.AppService/GetStartCommand",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppServiceServer).GetStartCommand(ctx, req.(*DeviceSerial))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppService_AdbConnect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdbConnectParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppServiceServer).AdbConnect(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apprpc.AppService/AdbConnect",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppServiceServer).AdbConnect(ctx, req.(*AdbConnectParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppService_AdbRestart_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppServiceServer).AdbRestart(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apprpc.AppService/AdbRestart",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppServiceServer).AdbRestart(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppService_AdbShell_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdbShellParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppServiceServer).AdbShell(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apprpc.AppService/AdbShell",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppServiceServer).AdbShell(ctx, req.(*AdbShellParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppService_AdbForward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdbForwardParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppServiceServer).AdbForward(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apprpc.AppService/AdbForward",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppServiceServer).AdbForward(ctx, req.(*AdbForwardParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppService_AdbForwardList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppServiceServer).AdbForwardList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apprpc.AppService/AdbForwardList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppServiceServer).AdbForwardList(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppService_AdbTCPIP_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdbTCPIPParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppServiceServer).AdbTCPIP(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apprpc.AppService/AdbTCPIP",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppServiceServer).AdbTCPIP(ctx, req.(*AdbTCPIPParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppService_StartService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeviceSerial)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppServiceServer).StartService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apprpc.AppService/StartService",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppServiceServer).StartService(ctx, req.(*DeviceSerial))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppService_StopService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeviceSerial)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppServiceServer).StopService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apprpc.AppService/StopService",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppServiceServer).StopService(ctx, req.(*DeviceSerial))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppService_CreateProxy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateGRPCProxy)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppServiceServer).CreateProxy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apprpc.AppService/CreateProxy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppServiceServer).CreateProxy(ctx, req.(*CreateGRPCProxy))
	}
	return interceptor(ctx, in, info, handler)
}

var _AppService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "apprpc.AppService",
	HandlerType: (*AppServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetDevices",
			Handler:    _AppService_GetDevices_Handler,
		},
		{
			MethodName: "GetStartCommand",
			Handler:    _AppService_GetStartCommand_Handler,
		},
		{
			MethodName: "AdbConnect",
			Handler:    _AppService_AdbConnect_Handler,
		},
		{
			MethodName: "AdbRestart",
			Handler:    _AppService_AdbRestart_Handler,
		},
		{
			MethodName: "AdbShell",
			Handler:    _AppService_AdbShell_Handler,
		},
		{
			MethodName: "AdbForward",
			Handler:    _AppService_AdbForward_Handler,
		},
		{
			MethodName: "AdbForwardList",
			Handler:    _AppService_AdbForwardList_Handler,
		},
		{
			MethodName: "AdbTCPIP",
			Handler:    _AppService_AdbTCPIP_Handler,
		},
		{
			MethodName: "StartService",
			Handler:    _AppService_StartService_Handler,
		},
		{
			MethodName: "StopService",
			Handler:    _AppService_StopService_Handler,
		},
		{
			MethodName: "CreateProxy",
			Handler:    _AppService_CreateProxy_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "app.proto",
}