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/speaker_service.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class SpeakerServiceGrpc {

  private SpeakerServiceGrpc() {}

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

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

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.SpeakerCommand.PlayAudioCommand.Request,
      cmvr.api.SpeakerCommand.PlayAudioCommand.Feedback> getPlayAudioMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.SpeakerCommand.StopSpeakerCommand.Request,
      cmvr.api.SpeakerCommand.StopSpeakerCommand.Feedback> getStopPlaybackMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.SpeakerCommand.PauseSpeakerCommand.Request,
      cmvr.api.SpeakerCommand.PauseSpeakerCommand.Feedback> getPausePlaybackMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.SpeakerCommand.ResumeSpeakerCommand.Request,
      cmvr.api.SpeakerCommand.ResumeSpeakerCommand.Feedback> getResumePlaybackMethod;

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

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

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

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

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

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

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

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

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

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

    /**
     */
    public void playAudio(cmvr.api.SpeakerCommand.PlayAudioCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.PlayAudioCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPlayAudioMethod(), responseObserver);
    }

    /**
     */
    public void stopPlayback(cmvr.api.SpeakerCommand.StopSpeakerCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.StopSpeakerCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStopPlaybackMethod(), responseObserver);
    }

    /**
     */
    public void pausePlayback(cmvr.api.SpeakerCommand.PauseSpeakerCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.PauseSpeakerCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPausePlaybackMethod(), responseObserver);
    }

    /**
     */
    public void resumePlayback(cmvr.api.SpeakerCommand.ResumeSpeakerCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.ResumeSpeakerCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getResumePlaybackMethod(), responseObserver);
    }

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

    /**
     */
    public void getVolume(cmvr.api.SpeakerCommand.GetSpeakerVolumeCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.GetSpeakerVolumeCommand.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.SpeakerCommand.GetSpeakerStateCommand.Request,
                cmvr.api.SpeakerCommand.GetSpeakerStateCommand.Feedback>(
                  this, METHODID_GET_STATUS)))
          .addMethod(
            getPlayAudioMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SpeakerCommand.PlayAudioCommand.Request,
                cmvr.api.SpeakerCommand.PlayAudioCommand.Feedback>(
                  this, METHODID_PLAY_AUDIO)))
          .addMethod(
            getStopPlaybackMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SpeakerCommand.StopSpeakerCommand.Request,
                cmvr.api.SpeakerCommand.StopSpeakerCommand.Feedback>(
                  this, METHODID_STOP_PLAYBACK)))
          .addMethod(
            getPausePlaybackMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SpeakerCommand.PauseSpeakerCommand.Request,
                cmvr.api.SpeakerCommand.PauseSpeakerCommand.Feedback>(
                  this, METHODID_PAUSE_PLAYBACK)))
          .addMethod(
            getResumePlaybackMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SpeakerCommand.ResumeSpeakerCommand.Request,
                cmvr.api.SpeakerCommand.ResumeSpeakerCommand.Feedback>(
                  this, METHODID_RESUME_PLAYBACK)))
          .addMethod(
            getSetVolumeMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SpeakerCommand.SetSpeakerVolumeCommand.Request,
                cmvr.api.SpeakerCommand.SetSpeakerVolumeCommand.Feedback>(
                  this, METHODID_SET_VOLUME)))
          .addMethod(
            getGetVolumeMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SpeakerCommand.GetSpeakerVolumeCommand.Request,
                cmvr.api.SpeakerCommand.GetSpeakerVolumeCommand.Feedback>(
                  this, METHODID_GET_VOLUME)))
          .build();
    }
  }

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

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

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

    /**
     */
    public void playAudio(cmvr.api.SpeakerCommand.PlayAudioCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.PlayAudioCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPlayAudioMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void stopPlayback(cmvr.api.SpeakerCommand.StopSpeakerCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.StopSpeakerCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getStopPlaybackMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void pausePlayback(cmvr.api.SpeakerCommand.PauseSpeakerCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.PauseSpeakerCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPausePlaybackMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void resumePlayback(cmvr.api.SpeakerCommand.ResumeSpeakerCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.ResumeSpeakerCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getResumePlaybackMethod(), getCallOptions()), request, responseObserver);
    }

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

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

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

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

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

    /**
     */
    public cmvr.api.SpeakerCommand.PlayAudioCommand.Feedback playAudio(cmvr.api.SpeakerCommand.PlayAudioCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPlayAudioMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.SpeakerCommand.StopSpeakerCommand.Feedback stopPlayback(cmvr.api.SpeakerCommand.StopSpeakerCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getStopPlaybackMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.SpeakerCommand.PauseSpeakerCommand.Feedback pausePlayback(cmvr.api.SpeakerCommand.PauseSpeakerCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPausePlaybackMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.SpeakerCommand.ResumeSpeakerCommand.Feedback resumePlayback(cmvr.api.SpeakerCommand.ResumeSpeakerCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getResumePlaybackMethod(), getCallOptions(), request);
    }

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

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

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

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

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

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

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

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

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

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

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.SpeakerCommand.GetSpeakerVolumeCommand.Feedback> getVolume(
        cmvr.api.SpeakerCommand.GetSpeakerVolumeCommand.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_PLAY_AUDIO = 1;
  private static final int METHODID_STOP_PLAYBACK = 2;
  private static final int METHODID_PAUSE_PLAYBACK = 3;
  private static final int METHODID_RESUME_PLAYBACK = 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 SpeakerServiceImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(SpeakerServiceImplBase 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.SpeakerCommand.GetSpeakerStateCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.GetSpeakerStateCommand.Feedback>) responseObserver);
          break;
        case METHODID_PLAY_AUDIO:
          serviceImpl.playAudio((cmvr.api.SpeakerCommand.PlayAudioCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.PlayAudioCommand.Feedback>) responseObserver);
          break;
        case METHODID_STOP_PLAYBACK:
          serviceImpl.stopPlayback((cmvr.api.SpeakerCommand.StopSpeakerCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.StopSpeakerCommand.Feedback>) responseObserver);
          break;
        case METHODID_PAUSE_PLAYBACK:
          serviceImpl.pausePlayback((cmvr.api.SpeakerCommand.PauseSpeakerCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.PauseSpeakerCommand.Feedback>) responseObserver);
          break;
        case METHODID_RESUME_PLAYBACK:
          serviceImpl.resumePlayback((cmvr.api.SpeakerCommand.ResumeSpeakerCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.ResumeSpeakerCommand.Feedback>) responseObserver);
          break;
        case METHODID_SET_VOLUME:
          serviceImpl.setVolume((cmvr.api.SpeakerCommand.SetSpeakerVolumeCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.SetSpeakerVolumeCommand.Feedback>) responseObserver);
          break;
        case METHODID_GET_VOLUME:
          serviceImpl.getVolume((cmvr.api.SpeakerCommand.GetSpeakerVolumeCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SpeakerCommand.GetSpeakerVolumeCommand.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 SpeakerServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    SpeakerServiceBaseDescriptorSupplier() {}

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

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

  private static final class SpeakerServiceFileDescriptorSupplier
      extends SpeakerServiceBaseDescriptorSupplier {
    SpeakerServiceFileDescriptorSupplier() {}
  }

  private static final class SpeakerServiceMethodDescriptorSupplier
      extends SpeakerServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    SpeakerServiceMethodDescriptorSupplier(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 (SpeakerServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new SpeakerServiceFileDescriptorSupplier())
              .addMethod(getGetStatusMethod())
              .addMethod(getPlayAudioMethod())
              .addMethod(getStopPlaybackMethod())
              .addMethod(getPausePlaybackMethod())
              .addMethod(getResumePlaybackMethod())
              .addMethod(getSetVolumeMethod())
              .addMethod(getGetVolumeMethod())
              .build();
        }
      }
    }
    return result;
  }
}
