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

  private DexHandServiceGrpc() {}

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

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

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.DexhandCommand.SetDexHandPositionsCommand.Request,
      cmvr.api.DexhandCommand.SetDexHandPositionsCommand.Feedback> getSetDexHandPosMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.DexhandCommand.SetDexHandAnglesCommand.Request,
      cmvr.api.DexhandCommand.SetDexHandAnglesCommand.Feedback> getSetDexHandAngleMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.DexhandCommand.SetDexHandForceCommand.Request,
      cmvr.api.DexhandCommand.SetDexHandForceCommand.Feedback> getSetDexHandForceMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.DexhandCommand.SetDexHandSpeedCommand.Request,
      cmvr.api.DexhandCommand.SetDexHandSpeedCommand.Feedback> getSetDexHandSpeedMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.DexhandCommand.SetDexHandPresetActCommand.Request,
      cmvr.api.DexhandCommand.SetDexHandPresetActCommand.Feedback> getSetDexHandPresetActMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.DexhandCommand.GetSensorDataCommand.Request,
      cmvr.api.DexhandCommand.GetSensorDataCommand.Feedback> getGetSensorDataMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Request,
      cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Feedback> getGetSensorDataStreamMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetSensorDataStream",
      requestType = cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Request.class,
      responseType = cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
  public static io.grpc.MethodDescriptor<cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Request,
      cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Feedback> getGetSensorDataStreamMethod() {
    io.grpc.MethodDescriptor<cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Request, cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Feedback> getGetSensorDataStreamMethod;
    if ((getGetSensorDataStreamMethod = DexHandServiceGrpc.getGetSensorDataStreamMethod) == null) {
      synchronized (DexHandServiceGrpc.class) {
        if ((getGetSensorDataStreamMethod = DexHandServiceGrpc.getGetSensorDataStreamMethod) == null) {
          DexHandServiceGrpc.getGetSensorDataStreamMethod = getGetSensorDataStreamMethod =
              io.grpc.MethodDescriptor.<cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Request, cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetSensorDataStream"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new DexHandServiceMethodDescriptorSupplier("GetSensorDataStream"))
              .build();
        }
      }
    }
    return getGetSensorDataStreamMethod;
  }

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

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

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

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

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

    /**
     */
    public void setDexHandPos(cmvr.api.DexhandCommand.SetDexHandPositionsCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandPositionsCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetDexHandPosMethod(), responseObserver);
    }

    /**
     */
    public void setDexHandAngle(cmvr.api.DexhandCommand.SetDexHandAnglesCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandAnglesCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetDexHandAngleMethod(), responseObserver);
    }

    /**
     */
    public void setDexHandForce(cmvr.api.DexhandCommand.SetDexHandForceCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandForceCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetDexHandForceMethod(), responseObserver);
    }

    /**
     */
    public void setDexHandSpeed(cmvr.api.DexhandCommand.SetDexHandSpeedCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandSpeedCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetDexHandSpeedMethod(), responseObserver);
    }

    /**
     */
    public void setDexHandPresetAct(cmvr.api.DexhandCommand.SetDexHandPresetActCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandPresetActCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetDexHandPresetActMethod(), responseObserver);
    }

    /**
     */
    public void getSensorData(cmvr.api.DexhandCommand.GetSensorDataCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.GetSensorDataCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetSensorDataMethod(), responseObserver);
    }

    /**
     */
    public io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Request> getSensorDataStream(
        io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Feedback> responseObserver) {
      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getGetSensorDataStreamMethod(), 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.DexhandCommand.GetDexHandStateCommand.Request,
                cmvr.api.DexhandCommand.GetDexHandStateCommand.Feedback>(
                  this, METHODID_GET_STATUS)))
          .addMethod(
            getSetDexHandPosMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.DexhandCommand.SetDexHandPositionsCommand.Request,
                cmvr.api.DexhandCommand.SetDexHandPositionsCommand.Feedback>(
                  this, METHODID_SET_DEX_HAND_POS)))
          .addMethod(
            getSetDexHandAngleMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.DexhandCommand.SetDexHandAnglesCommand.Request,
                cmvr.api.DexhandCommand.SetDexHandAnglesCommand.Feedback>(
                  this, METHODID_SET_DEX_HAND_ANGLE)))
          .addMethod(
            getSetDexHandForceMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.DexhandCommand.SetDexHandForceCommand.Request,
                cmvr.api.DexhandCommand.SetDexHandForceCommand.Feedback>(
                  this, METHODID_SET_DEX_HAND_FORCE)))
          .addMethod(
            getSetDexHandSpeedMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.DexhandCommand.SetDexHandSpeedCommand.Request,
                cmvr.api.DexhandCommand.SetDexHandSpeedCommand.Feedback>(
                  this, METHODID_SET_DEX_HAND_SPEED)))
          .addMethod(
            getSetDexHandPresetActMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.DexhandCommand.SetDexHandPresetActCommand.Request,
                cmvr.api.DexhandCommand.SetDexHandPresetActCommand.Feedback>(
                  this, METHODID_SET_DEX_HAND_PRESET_ACT)))
          .addMethod(
            getGetSensorDataMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.DexhandCommand.GetSensorDataCommand.Request,
                cmvr.api.DexhandCommand.GetSensorDataCommand.Feedback>(
                  this, METHODID_GET_SENSOR_DATA)))
          .addMethod(
            getGetSensorDataStreamMethod(),
            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
              new MethodHandlers<
                cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Request,
                cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Feedback>(
                  this, METHODID_GET_SENSOR_DATA_STREAM)))
          .build();
    }
  }

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

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

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

    /**
     */
    public void setDexHandPos(cmvr.api.DexhandCommand.SetDexHandPositionsCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandPositionsCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetDexHandPosMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void setDexHandAngle(cmvr.api.DexhandCommand.SetDexHandAnglesCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandAnglesCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetDexHandAngleMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void setDexHandForce(cmvr.api.DexhandCommand.SetDexHandForceCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandForceCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetDexHandForceMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void setDexHandSpeed(cmvr.api.DexhandCommand.SetDexHandSpeedCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandSpeedCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetDexHandSpeedMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void setDexHandPresetAct(cmvr.api.DexhandCommand.SetDexHandPresetActCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandPresetActCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetDexHandPresetActMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getSensorData(cmvr.api.DexhandCommand.GetSensorDataCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.GetSensorDataCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetSensorDataMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Request> getSensorDataStream(
        io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Feedback> responseObserver) {
      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
          getChannel().newCall(getGetSensorDataStreamMethod(), getCallOptions()), responseObserver);
    }
  }

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

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

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

    /**
     */
    public cmvr.api.DexhandCommand.SetDexHandPositionsCommand.Feedback setDexHandPos(cmvr.api.DexhandCommand.SetDexHandPositionsCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetDexHandPosMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.DexhandCommand.SetDexHandAnglesCommand.Feedback setDexHandAngle(cmvr.api.DexhandCommand.SetDexHandAnglesCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetDexHandAngleMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.DexhandCommand.SetDexHandForceCommand.Feedback setDexHandForce(cmvr.api.DexhandCommand.SetDexHandForceCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetDexHandForceMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.DexhandCommand.SetDexHandSpeedCommand.Feedback setDexHandSpeed(cmvr.api.DexhandCommand.SetDexHandSpeedCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetDexHandSpeedMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.DexhandCommand.SetDexHandPresetActCommand.Feedback setDexHandPresetAct(cmvr.api.DexhandCommand.SetDexHandPresetActCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetDexHandPresetActMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.DexhandCommand.GetSensorDataCommand.Feedback getSensorData(cmvr.api.DexhandCommand.GetSensorDataCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetSensorDataMethod(), getCallOptions(), request);
    }
  }

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

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

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

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

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

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

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

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

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

  private static final int METHODID_GET_STATUS = 0;
  private static final int METHODID_SET_DEX_HAND_POS = 1;
  private static final int METHODID_SET_DEX_HAND_ANGLE = 2;
  private static final int METHODID_SET_DEX_HAND_FORCE = 3;
  private static final int METHODID_SET_DEX_HAND_SPEED = 4;
  private static final int METHODID_SET_DEX_HAND_PRESET_ACT = 5;
  private static final int METHODID_GET_SENSOR_DATA = 6;
  private static final int METHODID_GET_SENSOR_DATA_STREAM = 7;

  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 DexHandServiceImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(DexHandServiceImplBase 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.DexhandCommand.GetDexHandStateCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.GetDexHandStateCommand.Feedback>) responseObserver);
          break;
        case METHODID_SET_DEX_HAND_POS:
          serviceImpl.setDexHandPos((cmvr.api.DexhandCommand.SetDexHandPositionsCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandPositionsCommand.Feedback>) responseObserver);
          break;
        case METHODID_SET_DEX_HAND_ANGLE:
          serviceImpl.setDexHandAngle((cmvr.api.DexhandCommand.SetDexHandAnglesCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandAnglesCommand.Feedback>) responseObserver);
          break;
        case METHODID_SET_DEX_HAND_FORCE:
          serviceImpl.setDexHandForce((cmvr.api.DexhandCommand.SetDexHandForceCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandForceCommand.Feedback>) responseObserver);
          break;
        case METHODID_SET_DEX_HAND_SPEED:
          serviceImpl.setDexHandSpeed((cmvr.api.DexhandCommand.SetDexHandSpeedCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandSpeedCommand.Feedback>) responseObserver);
          break;
        case METHODID_SET_DEX_HAND_PRESET_ACT:
          serviceImpl.setDexHandPresetAct((cmvr.api.DexhandCommand.SetDexHandPresetActCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.SetDexHandPresetActCommand.Feedback>) responseObserver);
          break;
        case METHODID_GET_SENSOR_DATA:
          serviceImpl.getSensorData((cmvr.api.DexhandCommand.GetSensorDataCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.GetSensorDataCommand.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) {
        case METHODID_GET_SENSOR_DATA_STREAM:
          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.getSensorDataStream(
              (io.grpc.stub.StreamObserver<cmvr.api.DexhandCommand.GetSensorDataStreamCommand.Feedback>) responseObserver);
        default:
          throw new AssertionError();
      }
    }
  }

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

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

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

  private static final class DexHandServiceFileDescriptorSupplier
      extends DexHandServiceBaseDescriptorSupplier {
    DexHandServiceFileDescriptorSupplier() {}
  }

  private static final class DexHandServiceMethodDescriptorSupplier
      extends DexHandServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    DexHandServiceMethodDescriptorSupplier(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 (DexHandServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new DexHandServiceFileDescriptorSupplier())
              .addMethod(getGetStatusMethod())
              .addMethod(getSetDexHandPosMethod())
              .addMethod(getSetDexHandAngleMethod())
              .addMethod(getSetDexHandForceMethod())
              .addMethod(getSetDexHandSpeedMethod())
              .addMethod(getSetDexHandPresetActMethod())
              .addMethod(getGetSensorDataMethod())
              .addMethod(getGetSensorDataStreamMethod())
              .build();
        }
      }
    }
    return result;
  }
}
