package cmvr.api;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.52.0)",
    comments = "Source: cmvr/api/microphone_service.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class MicPhoneServiceGrpc {

  private MicPhoneServiceGrpc() {}

  public static final String SERVICE_NAME = "cmvr.api.MicPhoneService";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.GetMicStateCommand.Request,
      cmvr.api.MicrophoneCommand.GetMicStateCommand.Feedback> getGetStatusMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetStatus",
      requestType = cmvr.api.MicrophoneCommand.GetMicStateCommand.Request.class,
      responseType = cmvr.api.MicrophoneCommand.GetMicStateCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.GetMicStateCommand.Request,
      cmvr.api.MicrophoneCommand.GetMicStateCommand.Feedback> getGetStatusMethod() {
    io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.GetMicStateCommand.Request, cmvr.api.MicrophoneCommand.GetMicStateCommand.Feedback> getGetStatusMethod;
    if ((getGetStatusMethod = MicPhoneServiceGrpc.getGetStatusMethod) == null) {
      synchronized (MicPhoneServiceGrpc.class) {
        if ((getGetStatusMethod = MicPhoneServiceGrpc.getGetStatusMethod) == null) {
          MicPhoneServiceGrpc.getGetStatusMethod = getGetStatusMethod =
              io.grpc.MethodDescriptor.<cmvr.api.MicrophoneCommand.GetMicStateCommand.Request, cmvr.api.MicrophoneCommand.GetMicStateCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetStatus"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.MicrophoneCommand.GetMicStateCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.MicrophoneCommand.GetMicStateCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new MicPhoneServiceMethodDescriptorSupplier("GetStatus"))
              .build();
        }
      }
    }
    return getGetStatusMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Request,
      cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Feedback> getStartRecordMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "StartRecord",
      requestType = cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Request.class,
      responseType = cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Request,
      cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Feedback> getStartRecordMethod() {
    io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Request, cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Feedback> getStartRecordMethod;
    if ((getStartRecordMethod = MicPhoneServiceGrpc.getStartRecordMethod) == null) {
      synchronized (MicPhoneServiceGrpc.class) {
        if ((getStartRecordMethod = MicPhoneServiceGrpc.getStartRecordMethod) == null) {
          MicPhoneServiceGrpc.getStartRecordMethod = getStartRecordMethod =
              io.grpc.MethodDescriptor.<cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Request, cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StartRecord"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new MicPhoneServiceMethodDescriptorSupplier("StartRecord"))
              .build();
        }
      }
    }
    return getStartRecordMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Request,
      cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Feedback> getStopRecordMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "StopRecord",
      requestType = cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Request.class,
      responseType = cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Request,
      cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Feedback> getStopRecordMethod() {
    io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Request, cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Feedback> getStopRecordMethod;
    if ((getStopRecordMethod = MicPhoneServiceGrpc.getStopRecordMethod) == null) {
      synchronized (MicPhoneServiceGrpc.class) {
        if ((getStopRecordMethod = MicPhoneServiceGrpc.getStopRecordMethod) == null) {
          MicPhoneServiceGrpc.getStopRecordMethod = getStopRecordMethod =
              io.grpc.MethodDescriptor.<cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Request, cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StopRecord"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new MicPhoneServiceMethodDescriptorSupplier("StopRecord"))
              .build();
        }
      }
    }
    return getStopRecordMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Request,
      cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Feedback> getPauseRecordMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PauseRecord",
      requestType = cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Request.class,
      responseType = cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Request,
      cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Feedback> getPauseRecordMethod() {
    io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Request, cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Feedback> getPauseRecordMethod;
    if ((getPauseRecordMethod = MicPhoneServiceGrpc.getPauseRecordMethod) == null) {
      synchronized (MicPhoneServiceGrpc.class) {
        if ((getPauseRecordMethod = MicPhoneServiceGrpc.getPauseRecordMethod) == null) {
          MicPhoneServiceGrpc.getPauseRecordMethod = getPauseRecordMethod =
              io.grpc.MethodDescriptor.<cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Request, cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PauseRecord"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new MicPhoneServiceMethodDescriptorSupplier("PauseRecord"))
              .build();
        }
      }
    }
    return getPauseRecordMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Request,
      cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Feedback> getResumeRecordMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ResumeRecord",
      requestType = cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Request.class,
      responseType = cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Request,
      cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Feedback> getResumeRecordMethod() {
    io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Request, cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Feedback> getResumeRecordMethod;
    if ((getResumeRecordMethod = MicPhoneServiceGrpc.getResumeRecordMethod) == null) {
      synchronized (MicPhoneServiceGrpc.class) {
        if ((getResumeRecordMethod = MicPhoneServiceGrpc.getResumeRecordMethod) == null) {
          MicPhoneServiceGrpc.getResumeRecordMethod = getResumeRecordMethod =
              io.grpc.MethodDescriptor.<cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Request, cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ResumeRecord"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new MicPhoneServiceMethodDescriptorSupplier("ResumeRecord"))
              .build();
        }
      }
    }
    return getResumeRecordMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Request,
      cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Feedback> getSetVolumeMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SetVolume",
      requestType = cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Request.class,
      responseType = cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Request,
      cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Feedback> getSetVolumeMethod() {
    io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Request, cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Feedback> getSetVolumeMethod;
    if ((getSetVolumeMethod = MicPhoneServiceGrpc.getSetVolumeMethod) == null) {
      synchronized (MicPhoneServiceGrpc.class) {
        if ((getSetVolumeMethod = MicPhoneServiceGrpc.getSetVolumeMethod) == null) {
          MicPhoneServiceGrpc.getSetVolumeMethod = getSetVolumeMethod =
              io.grpc.MethodDescriptor.<cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Request, cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetVolume"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new MicPhoneServiceMethodDescriptorSupplier("SetVolume"))
              .build();
        }
      }
    }
    return getSetVolumeMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Request,
      cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Feedback> getGetVolumeMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetVolume",
      requestType = cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Request.class,
      responseType = cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Request,
      cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Feedback> getGetVolumeMethod() {
    io.grpc.MethodDescriptor<cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Request, cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Feedback> getGetVolumeMethod;
    if ((getGetVolumeMethod = MicPhoneServiceGrpc.getGetVolumeMethod) == null) {
      synchronized (MicPhoneServiceGrpc.class) {
        if ((getGetVolumeMethod = MicPhoneServiceGrpc.getGetVolumeMethod) == null) {
          MicPhoneServiceGrpc.getGetVolumeMethod = getGetVolumeMethod =
              io.grpc.MethodDescriptor.<cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Request, cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetVolume"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new MicPhoneServiceMethodDescriptorSupplier("GetVolume"))
              .build();
        }
      }
    }
    return getGetVolumeMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static MicPhoneServiceStub newStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<MicPhoneServiceStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<MicPhoneServiceStub>() {
        @java.lang.Override
        public MicPhoneServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new MicPhoneServiceStub(channel, callOptions);
        }
      };
    return MicPhoneServiceStub.newStub(factory, channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static MicPhoneServiceBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<MicPhoneServiceBlockingStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<MicPhoneServiceBlockingStub>() {
        @java.lang.Override
        public MicPhoneServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new MicPhoneServiceBlockingStub(channel, callOptions);
        }
      };
    return MicPhoneServiceBlockingStub.newStub(factory, channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static MicPhoneServiceFutureStub newFutureStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<MicPhoneServiceFutureStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<MicPhoneServiceFutureStub>() {
        @java.lang.Override
        public MicPhoneServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new MicPhoneServiceFutureStub(channel, callOptions);
        }
      };
    return MicPhoneServiceFutureStub.newStub(factory, channel);
  }

  /**
   */
  public static abstract class MicPhoneServiceImplBase implements io.grpc.BindableService {

    /**
     * <pre>
     * 基本控制
     * </pre>
     */
    public void getStatus(cmvr.api.MicrophoneCommand.GetMicStateCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.GetMicStateCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetStatusMethod(), responseObserver);
    }

    /**
     */
    public void startRecord(cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStartRecordMethod(), responseObserver);
    }

    /**
     */
    public void stopRecord(cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStopRecordMethod(), responseObserver);
    }

    /**
     */
    public void pauseRecord(cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPauseRecordMethod(), responseObserver);
    }

    /**
     */
    public void resumeRecord(cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getResumeRecordMethod(), responseObserver);
    }

    /**
     * <pre>
     * 音量控制
     * </pre>
     */
    public void setVolume(cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetVolumeMethod(), responseObserver);
    }

    /**
     */
    public void getVolume(cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetVolumeMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getGetStatusMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.MicrophoneCommand.GetMicStateCommand.Request,
                cmvr.api.MicrophoneCommand.GetMicStateCommand.Feedback>(
                  this, METHODID_GET_STATUS)))
          .addMethod(
            getStartRecordMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Request,
                cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Feedback>(
                  this, METHODID_START_RECORD)))
          .addMethod(
            getStopRecordMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Request,
                cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Feedback>(
                  this, METHODID_STOP_RECORD)))
          .addMethod(
            getPauseRecordMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Request,
                cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Feedback>(
                  this, METHODID_PAUSE_RECORD)))
          .addMethod(
            getResumeRecordMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Request,
                cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Feedback>(
                  this, METHODID_RESUME_RECORD)))
          .addMethod(
            getSetVolumeMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Request,
                cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Feedback>(
                  this, METHODID_SET_VOLUME)))
          .addMethod(
            getGetVolumeMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Request,
                cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Feedback>(
                  this, METHODID_GET_VOLUME)))
          .build();
    }
  }

  /**
   */
  public static final class MicPhoneServiceStub extends io.grpc.stub.AbstractAsyncStub<MicPhoneServiceStub> {
    private MicPhoneServiceStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected MicPhoneServiceStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new MicPhoneServiceStub(channel, callOptions);
    }

    /**
     * <pre>
     * 基本控制
     * </pre>
     */
    public void getStatus(cmvr.api.MicrophoneCommand.GetMicStateCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.GetMicStateCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetStatusMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void startRecord(cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getStartRecordMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void stopRecord(cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getStopRecordMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void pauseRecord(cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPauseRecordMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void resumeRecord(cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getResumeRecordMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 音量控制
     * </pre>
     */
    public void setVolume(cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetVolumeMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getVolume(cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetVolumeMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   */
  public static final class MicPhoneServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<MicPhoneServiceBlockingStub> {
    private MicPhoneServiceBlockingStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected MicPhoneServiceBlockingStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new MicPhoneServiceBlockingStub(channel, callOptions);
    }

    /**
     * <pre>
     * 基本控制
     * </pre>
     */
    public cmvr.api.MicrophoneCommand.GetMicStateCommand.Feedback getStatus(cmvr.api.MicrophoneCommand.GetMicStateCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetStatusMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Feedback startRecord(cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getStartRecordMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Feedback stopRecord(cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getStopRecordMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Feedback pauseRecord(cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPauseRecordMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Feedback resumeRecord(cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getResumeRecordMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 音量控制
     * </pre>
     */
    public cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Feedback setVolume(cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetVolumeMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Feedback getVolume(cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetVolumeMethod(), getCallOptions(), request);
    }
  }

  /**
   */
  public static final class MicPhoneServiceFutureStub extends io.grpc.stub.AbstractFutureStub<MicPhoneServiceFutureStub> {
    private MicPhoneServiceFutureStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected MicPhoneServiceFutureStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new MicPhoneServiceFutureStub(channel, callOptions);
    }

    /**
     * <pre>
     * 基本控制
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.MicrophoneCommand.GetMicStateCommand.Feedback> getStatus(
        cmvr.api.MicrophoneCommand.GetMicStateCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetStatusMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Feedback> startRecord(
        cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getStartRecordMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Feedback> stopRecord(
        cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getStopRecordMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Feedback> pauseRecord(
        cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPauseRecordMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Feedback> resumeRecord(
        cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getResumeRecordMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 音量控制
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Feedback> setVolume(
        cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSetVolumeMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Feedback> getVolume(
        cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetVolumeMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_GET_STATUS = 0;
  private static final int METHODID_START_RECORD = 1;
  private static final int METHODID_STOP_RECORD = 2;
  private static final int METHODID_PAUSE_RECORD = 3;
  private static final int METHODID_RESUME_RECORD = 4;
  private static final int METHODID_SET_VOLUME = 5;
  private static final int METHODID_GET_VOLUME = 6;

  private static final class MethodHandlers<Req, Resp> implements
      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
    private final MicPhoneServiceImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(MicPhoneServiceImplBase serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_GET_STATUS:
          serviceImpl.getStatus((cmvr.api.MicrophoneCommand.GetMicStateCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.GetMicStateCommand.Feedback>) responseObserver);
          break;
        case METHODID_START_RECORD:
          serviceImpl.startRecord((cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.StartMicRecordingCommand.Feedback>) responseObserver);
          break;
        case METHODID_STOP_RECORD:
          serviceImpl.stopRecord((cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.StopMicRecordingCommand.Feedback>) responseObserver);
          break;
        case METHODID_PAUSE_RECORD:
          serviceImpl.pauseRecord((cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.PauseMicRecordingCommand.Feedback>) responseObserver);
          break;
        case METHODID_RESUME_RECORD:
          serviceImpl.resumeRecord((cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.ResumeMicRecordingCommand.Feedback>) responseObserver);
          break;
        case METHODID_SET_VOLUME:
          serviceImpl.setVolume((cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.SetMicPhoneVolumeCommand.Feedback>) responseObserver);
          break;
        case METHODID_GET_VOLUME:
          serviceImpl.getVolume((cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.MicrophoneCommand.GetMicPhoneVolumeCommand.Feedback>) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver<Req> invoke(
        io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        default:
          throw new AssertionError();
      }
    }
  }

  private static abstract class MicPhoneServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    MicPhoneServiceBaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return cmvr.api.MicrophoneService.getDescriptor();
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("MicPhoneService");
    }
  }

  private static final class MicPhoneServiceFileDescriptorSupplier
      extends MicPhoneServiceBaseDescriptorSupplier {
    MicPhoneServiceFileDescriptorSupplier() {}
  }

  private static final class MicPhoneServiceMethodDescriptorSupplier
      extends MicPhoneServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    MicPhoneServiceMethodDescriptorSupplier(String methodName) {
      this.methodName = methodName;
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (MicPhoneServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new MicPhoneServiceFileDescriptorSupplier())
              .addMethod(getGetStatusMethod())
              .addMethod(getStartRecordMethod())
              .addMethod(getStopRecordMethod())
              .addMethod(getPauseRecordMethod())
              .addMethod(getResumeRecordMethod())
              .addMethod(getSetVolumeMethod())
              .addMethod(getGetVolumeMethod())
              .build();
        }
      }
    }
    return result;
  }
}
