package cmvr.api;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 * <pre>
 * 生物头部机器人服务接口
 * </pre>
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.52.0)",
    comments = "Source: cmvr/api/biohead_service.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class BioHeadServiceGrpc {

  private BioHeadServiceGrpc() {}

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

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

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.BioheadCommand.StreamFacialExpression.Request,
      cmvr.api.BioheadCommand.StreamFacialExpression.Feedback> getStreamExpressionMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.BioheadCommand.GetStatus.Request,
      cmvr.api.BioheadCommand.GetStatus.Feedback> getGetSystemStatusMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.BioheadCommand.EmergencyStop.Request,
      cmvr.api.BioheadCommand.EmergencyStop.Feedback> getEmergencyStopMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.BioheadCommand.SpeakStart.Request,
      cmvr.api.BioheadCommand.SpeakStart.Feedback> getSpeakStartMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.BioheadCommand.SpeakStop.Request,
      cmvr.api.BioheadCommand.SpeakStop.Feedback> getSpeakStopMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.BioheadCommand.Happy.Request,
      cmvr.api.BioheadCommand.Happy.Feedback> getHappyMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.BioheadCommand.Surprise.Request,
      cmvr.api.BioheadCommand.Surprise.Feedback> getSurpriseMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.BioheadCommand.ExpressionTired.Request,
      cmvr.api.BioheadCommand.ExpressionTired.Feedback> getExpressionTiredMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.BioheadCommand.ExpressionAngry.Request,
      cmvr.api.BioheadCommand.ExpressionAngry.Feedback> getExpressionAngryMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.BioheadCommand.ExpressionSadness.Request,
      cmvr.api.BioheadCommand.ExpressionSadness.Feedback> getExpressionSadnessMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.BioheadCommand.ExpressionYawn.Request,
      cmvr.api.BioheadCommand.ExpressionYawn.Feedback> getExpressionYawnMethod;

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

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

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

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

  /**
   * <pre>
   * 生物头部机器人服务接口
   * </pre>
   */
  public static abstract class BioHeadServiceImplBase implements io.grpc.BindableService {

    /**
     * <pre>
     * 设置面部表情
     * </pre>
     */
    public void setExpression(cmvr.api.BioheadCommand.SetFacialExpression.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.SetFacialExpression.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetExpressionMethod(), responseObserver);
    }

    /**
     */
    public io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.StreamFacialExpression.Request> streamExpression(
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.StreamFacialExpression.Feedback> responseObserver) {
      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamExpressionMethod(), responseObserver);
    }

    /**
     * <pre>
     * 获取状态
     * </pre>
     */
    public void getSystemStatus(cmvr.api.BioheadCommand.GetStatus.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.GetStatus.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetSystemStatusMethod(), responseObserver);
    }

    /**
     * <pre>
     * 紧急停止
     * </pre>
     */
    public void emergencyStop(cmvr.api.BioheadCommand.EmergencyStop.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.EmergencyStop.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getEmergencyStopMethod(), responseObserver);
    }

    /**
     * <pre>
     * 开始说话
     * </pre>
     */
    public void speakStart(cmvr.api.BioheadCommand.SpeakStart.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.SpeakStart.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSpeakStartMethod(), responseObserver);
    }

    /**
     * <pre>
     * 停止说话
     * </pre>
     */
    public void speakStop(cmvr.api.BioheadCommand.SpeakStop.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.SpeakStop.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSpeakStopMethod(), responseObserver);
    }

    /**
     */
    public void happy(cmvr.api.BioheadCommand.Happy.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.Happy.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getHappyMethod(), responseObserver);
    }

    /**
     */
    public void surprise(cmvr.api.BioheadCommand.Surprise.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.Surprise.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSurpriseMethod(), responseObserver);
    }

    /**
     */
    public void expressionTired(cmvr.api.BioheadCommand.ExpressionTired.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.ExpressionTired.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getExpressionTiredMethod(), responseObserver);
    }

    /**
     */
    public void expressionAngry(cmvr.api.BioheadCommand.ExpressionAngry.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.ExpressionAngry.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getExpressionAngryMethod(), responseObserver);
    }

    /**
     */
    public void expressionSadness(cmvr.api.BioheadCommand.ExpressionSadness.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.ExpressionSadness.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getExpressionSadnessMethod(), responseObserver);
    }

    /**
     */
    public void expressionYawn(cmvr.api.BioheadCommand.ExpressionYawn.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.ExpressionYawn.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getExpressionYawnMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getSetExpressionMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.BioheadCommand.SetFacialExpression.Request,
                cmvr.api.BioheadCommand.SetFacialExpression.Feedback>(
                  this, METHODID_SET_EXPRESSION)))
          .addMethod(
            getStreamExpressionMethod(),
            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
              new MethodHandlers<
                cmvr.api.BioheadCommand.StreamFacialExpression.Request,
                cmvr.api.BioheadCommand.StreamFacialExpression.Feedback>(
                  this, METHODID_STREAM_EXPRESSION)))
          .addMethod(
            getGetSystemStatusMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.BioheadCommand.GetStatus.Request,
                cmvr.api.BioheadCommand.GetStatus.Feedback>(
                  this, METHODID_GET_SYSTEM_STATUS)))
          .addMethod(
            getEmergencyStopMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.BioheadCommand.EmergencyStop.Request,
                cmvr.api.BioheadCommand.EmergencyStop.Feedback>(
                  this, METHODID_EMERGENCY_STOP)))
          .addMethod(
            getSpeakStartMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.BioheadCommand.SpeakStart.Request,
                cmvr.api.BioheadCommand.SpeakStart.Feedback>(
                  this, METHODID_SPEAK_START)))
          .addMethod(
            getSpeakStopMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.BioheadCommand.SpeakStop.Request,
                cmvr.api.BioheadCommand.SpeakStop.Feedback>(
                  this, METHODID_SPEAK_STOP)))
          .addMethod(
            getHappyMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.BioheadCommand.Happy.Request,
                cmvr.api.BioheadCommand.Happy.Feedback>(
                  this, METHODID_HAPPY)))
          .addMethod(
            getSurpriseMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.BioheadCommand.Surprise.Request,
                cmvr.api.BioheadCommand.Surprise.Feedback>(
                  this, METHODID_SURPRISE)))
          .addMethod(
            getExpressionTiredMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.BioheadCommand.ExpressionTired.Request,
                cmvr.api.BioheadCommand.ExpressionTired.Feedback>(
                  this, METHODID_EXPRESSION_TIRED)))
          .addMethod(
            getExpressionAngryMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.BioheadCommand.ExpressionAngry.Request,
                cmvr.api.BioheadCommand.ExpressionAngry.Feedback>(
                  this, METHODID_EXPRESSION_ANGRY)))
          .addMethod(
            getExpressionSadnessMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.BioheadCommand.ExpressionSadness.Request,
                cmvr.api.BioheadCommand.ExpressionSadness.Feedback>(
                  this, METHODID_EXPRESSION_SADNESS)))
          .addMethod(
            getExpressionYawnMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.BioheadCommand.ExpressionYawn.Request,
                cmvr.api.BioheadCommand.ExpressionYawn.Feedback>(
                  this, METHODID_EXPRESSION_YAWN)))
          .build();
    }
  }

  /**
   * <pre>
   * 生物头部机器人服务接口
   * </pre>
   */
  public static final class BioHeadServiceStub extends io.grpc.stub.AbstractAsyncStub<BioHeadServiceStub> {
    private BioHeadServiceStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     * <pre>
     * 设置面部表情
     * </pre>
     */
    public void setExpression(cmvr.api.BioheadCommand.SetFacialExpression.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.SetFacialExpression.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetExpressionMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.StreamFacialExpression.Request> streamExpression(
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.StreamFacialExpression.Feedback> responseObserver) {
      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
          getChannel().newCall(getStreamExpressionMethod(), getCallOptions()), responseObserver);
    }

    /**
     * <pre>
     * 获取状态
     * </pre>
     */
    public void getSystemStatus(cmvr.api.BioheadCommand.GetStatus.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.GetStatus.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetSystemStatusMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 紧急停止
     * </pre>
     */
    public void emergencyStop(cmvr.api.BioheadCommand.EmergencyStop.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.EmergencyStop.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getEmergencyStopMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 开始说话
     * </pre>
     */
    public void speakStart(cmvr.api.BioheadCommand.SpeakStart.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.SpeakStart.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSpeakStartMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 停止说话
     * </pre>
     */
    public void speakStop(cmvr.api.BioheadCommand.SpeakStop.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.SpeakStop.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSpeakStopMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void happy(cmvr.api.BioheadCommand.Happy.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.Happy.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getHappyMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void surprise(cmvr.api.BioheadCommand.Surprise.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.Surprise.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSurpriseMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void expressionTired(cmvr.api.BioheadCommand.ExpressionTired.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.ExpressionTired.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getExpressionTiredMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void expressionAngry(cmvr.api.BioheadCommand.ExpressionAngry.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.ExpressionAngry.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getExpressionAngryMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void expressionSadness(cmvr.api.BioheadCommand.ExpressionSadness.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.ExpressionSadness.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getExpressionSadnessMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void expressionYawn(cmvr.api.BioheadCommand.ExpressionYawn.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.ExpressionYawn.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getExpressionYawnMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   * <pre>
   * 生物头部机器人服务接口
   * </pre>
   */
  public static final class BioHeadServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<BioHeadServiceBlockingStub> {
    private BioHeadServiceBlockingStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     * <pre>
     * 设置面部表情
     * </pre>
     */
    public cmvr.api.BioheadCommand.SetFacialExpression.Feedback setExpression(cmvr.api.BioheadCommand.SetFacialExpression.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetExpressionMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 获取状态
     * </pre>
     */
    public cmvr.api.BioheadCommand.GetStatus.Feedback getSystemStatus(cmvr.api.BioheadCommand.GetStatus.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetSystemStatusMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 紧急停止
     * </pre>
     */
    public cmvr.api.BioheadCommand.EmergencyStop.Feedback emergencyStop(cmvr.api.BioheadCommand.EmergencyStop.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getEmergencyStopMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 开始说话
     * </pre>
     */
    public cmvr.api.BioheadCommand.SpeakStart.Feedback speakStart(cmvr.api.BioheadCommand.SpeakStart.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSpeakStartMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 停止说话
     * </pre>
     */
    public cmvr.api.BioheadCommand.SpeakStop.Feedback speakStop(cmvr.api.BioheadCommand.SpeakStop.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSpeakStopMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.BioheadCommand.Happy.Feedback happy(cmvr.api.BioheadCommand.Happy.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getHappyMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.BioheadCommand.Surprise.Feedback surprise(cmvr.api.BioheadCommand.Surprise.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSurpriseMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.BioheadCommand.ExpressionTired.Feedback expressionTired(cmvr.api.BioheadCommand.ExpressionTired.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getExpressionTiredMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.BioheadCommand.ExpressionAngry.Feedback expressionAngry(cmvr.api.BioheadCommand.ExpressionAngry.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getExpressionAngryMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.BioheadCommand.ExpressionSadness.Feedback expressionSadness(cmvr.api.BioheadCommand.ExpressionSadness.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getExpressionSadnessMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.BioheadCommand.ExpressionYawn.Feedback expressionYawn(cmvr.api.BioheadCommand.ExpressionYawn.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getExpressionYawnMethod(), getCallOptions(), request);
    }
  }

  /**
   * <pre>
   * 生物头部机器人服务接口
   * </pre>
   */
  public static final class BioHeadServiceFutureStub extends io.grpc.stub.AbstractFutureStub<BioHeadServiceFutureStub> {
    private BioHeadServiceFutureStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     * <pre>
     * 设置面部表情
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.BioheadCommand.SetFacialExpression.Feedback> setExpression(
        cmvr.api.BioheadCommand.SetFacialExpression.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSetExpressionMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 获取状态
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.BioheadCommand.GetStatus.Feedback> getSystemStatus(
        cmvr.api.BioheadCommand.GetStatus.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetSystemStatusMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 紧急停止
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.BioheadCommand.EmergencyStop.Feedback> emergencyStop(
        cmvr.api.BioheadCommand.EmergencyStop.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getEmergencyStopMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 开始说话
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.BioheadCommand.SpeakStart.Feedback> speakStart(
        cmvr.api.BioheadCommand.SpeakStart.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSpeakStartMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 停止说话
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.BioheadCommand.SpeakStop.Feedback> speakStop(
        cmvr.api.BioheadCommand.SpeakStop.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSpeakStopMethod(), getCallOptions()), request);
    }

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

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

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

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

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

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

  private static final int METHODID_SET_EXPRESSION = 0;
  private static final int METHODID_GET_SYSTEM_STATUS = 1;
  private static final int METHODID_EMERGENCY_STOP = 2;
  private static final int METHODID_SPEAK_START = 3;
  private static final int METHODID_SPEAK_STOP = 4;
  private static final int METHODID_HAPPY = 5;
  private static final int METHODID_SURPRISE = 6;
  private static final int METHODID_EXPRESSION_TIRED = 7;
  private static final int METHODID_EXPRESSION_ANGRY = 8;
  private static final int METHODID_EXPRESSION_SADNESS = 9;
  private static final int METHODID_EXPRESSION_YAWN = 10;
  private static final int METHODID_STREAM_EXPRESSION = 11;

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

    MethodHandlers(BioHeadServiceImplBase 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_SET_EXPRESSION:
          serviceImpl.setExpression((cmvr.api.BioheadCommand.SetFacialExpression.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.SetFacialExpression.Feedback>) responseObserver);
          break;
        case METHODID_GET_SYSTEM_STATUS:
          serviceImpl.getSystemStatus((cmvr.api.BioheadCommand.GetStatus.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.GetStatus.Feedback>) responseObserver);
          break;
        case METHODID_EMERGENCY_STOP:
          serviceImpl.emergencyStop((cmvr.api.BioheadCommand.EmergencyStop.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.EmergencyStop.Feedback>) responseObserver);
          break;
        case METHODID_SPEAK_START:
          serviceImpl.speakStart((cmvr.api.BioheadCommand.SpeakStart.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.SpeakStart.Feedback>) responseObserver);
          break;
        case METHODID_SPEAK_STOP:
          serviceImpl.speakStop((cmvr.api.BioheadCommand.SpeakStop.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.SpeakStop.Feedback>) responseObserver);
          break;
        case METHODID_HAPPY:
          serviceImpl.happy((cmvr.api.BioheadCommand.Happy.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.Happy.Feedback>) responseObserver);
          break;
        case METHODID_SURPRISE:
          serviceImpl.surprise((cmvr.api.BioheadCommand.Surprise.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.Surprise.Feedback>) responseObserver);
          break;
        case METHODID_EXPRESSION_TIRED:
          serviceImpl.expressionTired((cmvr.api.BioheadCommand.ExpressionTired.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.ExpressionTired.Feedback>) responseObserver);
          break;
        case METHODID_EXPRESSION_ANGRY:
          serviceImpl.expressionAngry((cmvr.api.BioheadCommand.ExpressionAngry.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.ExpressionAngry.Feedback>) responseObserver);
          break;
        case METHODID_EXPRESSION_SADNESS:
          serviceImpl.expressionSadness((cmvr.api.BioheadCommand.ExpressionSadness.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.ExpressionSadness.Feedback>) responseObserver);
          break;
        case METHODID_EXPRESSION_YAWN:
          serviceImpl.expressionYawn((cmvr.api.BioheadCommand.ExpressionYawn.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.ExpressionYawn.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_STREAM_EXPRESSION:
          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamExpression(
              (io.grpc.stub.StreamObserver<cmvr.api.BioheadCommand.StreamFacialExpression.Feedback>) responseObserver);
        default:
          throw new AssertionError();
      }
    }
  }

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

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

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

  private static final class BioHeadServiceFileDescriptorSupplier
      extends BioHeadServiceBaseDescriptorSupplier {
    BioHeadServiceFileDescriptorSupplier() {}
  }

  private static final class BioHeadServiceMethodDescriptorSupplier
      extends BioHeadServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    BioHeadServiceMethodDescriptorSupplier(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 (BioHeadServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new BioHeadServiceFileDescriptorSupplier())
              .addMethod(getSetExpressionMethod())
              .addMethod(getStreamExpressionMethod())
              .addMethod(getGetSystemStatusMethod())
              .addMethod(getEmergencyStopMethod())
              .addMethod(getSpeakStartMethod())
              .addMethod(getSpeakStopMethod())
              .addMethod(getHappyMethod())
              .addMethod(getSurpriseMethod())
              .addMethod(getExpressionTiredMethod())
              .addMethod(getExpressionAngryMethod())
              .addMethod(getExpressionSadnessMethod())
              .addMethod(getExpressionYawnMethod())
              .build();
        }
      }
    }
    return result;
  }
}
