@PostMapping(path = "/start_game")
public JsonResponse callContainerExample(HttpServletRequest httpRequest) {
    // 开发者可以直接通过请求头获取直播间信息,无需自行通过token置换

    // 应用id
    String appID = httpRequest.getHeader("X-TT-AppID");
    // 直播间id
    String roomID = httpRequest.getHeader("X-Room-ID");
    // 主播id
    String anchorOpenID = httpRequest.getHeader("X-Anchor-OpenID");
    // 主播头像url
    String avatarUrl = httpRequest.getHeader("X-Avatar-Url");
    // 主播昵称
    String nickName = httpRequest.getHeader("X-Nick-Name");

    log.info("appID: {}, roomID: {}, anchorOpenID: {}, avatarUrl: {}, nickName: {}", appID,
            roomID, anchorOpenID, avatarUrl, nickName);


    // 调用弹幕玩法服务端API，开启直播间推送任务，开启后，开发者服务器会通过/live_data_callback接口 收到直播间玩法指令
    List<String> msgTypeList = new ArrayList<>();
    msgTypeList.add("live_like");
    msgTypeList.add("live_comment");
    msgTypeList.add("live_gift");
    msgTypeList.add("live_fansclub");

    for (String msgType : msgTypeList) {
        boolean result = startLiveDataTask(appID, roomID, msgType);
        if (result) {
            log.info("{} 推送开启成功", msgType);
        } else {
            log.error("{} 推送开启失败", msgType);
        }
    }

    JsonResponse response = new JsonResponse();
    response.success("开始玩法对局成功");
    return response;
}

private boolean startLiveDataTask(String appID, String roomID, String msgType) {
    // example: 通过java OkHttp库发起http请求,开发者可使用其余http访问形式
    OkHttpClient client = new OkHttpClient();
    String body = new JSONObject()
            .fluentPut("roomid", roomID)
            .fluentPut("appid", appID)
            .fluentPut("msg_type", msgType)
            .toString();
    Request request = new Request.Builder()
            .url("http://webcast-bytedance-com.openapi.dyc.ivolces.com/api/live_data/task/start") // 内网专线访问小玩法openAPI,无需https协议
            .addHeader("Content-Type", "application/json") // 无需维护access_token
            .post(
                    okhttp3.RequestBody.create(
                            MediaType.get("application/json; charset=utf-8"),
                            body
                    )
            )
            .build();

    try {
        Response httpResponse = client.newCall(request).execute();
        if (httpResponse.code() != 200) {
            log.error("开启推送任务失败,http访问非200");
            return false;
        }
        LivePlayAPIResponse livePlayAPIResponse
                = JSON.parseObject(httpResponse.body().string(), LivePlayAPIResponse.class);
        if (livePlayAPIResponse.getErrNo() != 0) {
            log.error("开启推送任务失败，错误信息: {}", livePlayAPIResponse.getErrorMsg());
            return false;
        }
    } catch (IOException e) {
        log.error("开启推送任务异常,e: {}", e.getMessage(), e);
        return false;
    }
    return true;
}

@RequestMapping(path = "/websocket_callback", method = {RequestMethod.POST, RequestMethod.GET})
public JsonResponse websocketCallback(HttpServletRequest request) {
    String eventType = request.getHeader("x-tt-event-type");
    switch (eventType) {
        case "connect":
            // 客户端建连
        case "disconnect": {
            // 客户端断连
        }
        case "uplink": {
            // 客户端上行发消息
        }
        default:
            break;
    }
    JsonResponse response = new JsonResponse();
    response.success("success");
    return response;
}

@PostMapping(path = "/live_data_callback")
public JsonResponse liveDataCallbackExample(
        @RequestHeader("X-Anchor-OpenID") String anchorOpenID,
        @RequestHeader("x-msg-type") String msgType,
        @RequestBody String body) {
    List<LiveDataModel> liveDataModelList = JSON.parseArray(body, LiveDataModel.class);
    liveDataModelList.forEach(liveDataModel ->
            pushDataToClientByDouyinCloudWebsocket(anchorOpenID, liveDataModel.getMsgID(), msgType, body)
    );
    JsonResponse response = new JsonResponse();
    response.success("success");
    return response;
}

private void pushDataToClientByDouyinCloudWebsocket(String anchorOpenId, String msgID, String msgType, String data) {
        // 这里通过HTTP POST请求将数据推送给抖音云网关,进而抖音云网关推送给主播端
        OkHttpClient client = new OkHttpClient();

        Map<String, String> bodyMap = new HashMap<>();
        bodyMap.put("msg_id", msgID);
        bodyMap.put("msg_type", msgType);
        bodyMap.put("data", data);
//        bodyMap.put("extra_data", "");
        String bodyStr = JSON.toJSONString(bodyMap);

        Request request = new Request.Builder()
                .url("http://ws-push.dyc.ivolces.com/ws/live_interaction/push_data")
                .addHeader("Content-Type", "application/json")
                .addHeader("X-TT-WS-OPENIDS", JSON.toJSONString(Arrays.asList(anchorOpenId)))
                .post(
                        okhttp3.RequestBody.create(
                                MediaType.parse("application/json; charset=utf-8"),
                                bodyStr
                        )
                )
                .build();

        try {
            Response httpResponse = client.newCall(request).execute();
            log.info("websocket http call done, response: {}", JSON.toJSONString(httpResponse));
        } catch (IOException e) {
            log.error("websocket http call exception, e: ", e);
        }
    }

/** 
* @param params 调用参数，HTTP 请求下为请求体
 * @param context 调用上下文
 *
 * @return 函数的返回数据，HTTP 场景下会作为 Response Body
 *
 */
interface Data {
  err_no?: number;
  err_msg?: string;
  data?: any;
}
import { dySDK } from '@open-dy/node-server-sdk';
export default async function (params: any, context: any) {
  let serviceContext = dySDK.context(context);
  let { appId, roomId, anchorOpenId, avatarUrl, nickName } = serviceContext.getContext();
  context.log(`appId is ${appId}, roomId is ${roomId}, anchorOpenID is ${anchorOpenId}, avatarUrl is ${avatarUrl}, nickName is ${nickName}`);
  try {
    let msgTypes = ['live_comment', 'live_like', 'live_gift', 'live_fansclub'];
    for (const msgType of msgTypes) {
      await startLiveDataTask(appId, roomId, context, msgType);
    }
  } catch (err) {
    context.log(err);
  }
};

async function startLiveDataTask(appId: string, roomId: string, context: any, msgType: string) {
  const serviceContext = dySDK.context(context);
  try {
    let param = {
      roomid: roomId,
      appid: appId,
      msg_type: msgType
    };
       // 调用弹幕玩法服务端API，开启直播间推送任务，开启后，开发者服务器会通过/live_data_callback_example接口 收到直播间玩法指令
    const res: Data = await serviceContext.openApiInvoke({
      url: "https://webcast-bytedance-com.openapi.dyc.ivolces.com/api/live_data/task/start",
      method: "POST", // openAPI 调用方式，
      headers: { "Content-Type": "application/json" }, // openAPI 请求头
      data: param
    });
    if (res?.err_no === 0) {
      return res?.data;
    }
    context.log('开启评论推送任务失败，错误信息', res?.err_msg);
 
    return res?.err_msg;
  } catch (err) {
    context.log('启评论推送任务失败，错误信息为', err);
    return 'error';
  }
}

/** 
* 抖音云websocket监听的回调函数,客户端建连/上行发消息都会走到该HTTP回调函数中
ref:https://developer.open-douyin.com/docs/resource/zh-CN/developer/tools/cloud/develop-guide/websocket-guide/websocket#%E5%BB%BA%E8%BF%9E%E8%AF%B7%E6%B1%82
 */

export default async function (params: any, context: any) {
  let eventType = context.headers['x-tt-event-type'];
  switch (eventType) {
    // 客户端建连
    case "connect":
      context.log('connect');
      break;
    // 客户端断连
    case "disconnect": {
      context.log('disconnect');
      break;
    }
    // 客户端上行发消息
    case "uplink": {
      context.log('uplink', params.toString());
      break;
    }
    default:
      break;
  }
  return "success";
};

/** 
  * 通过抖音云服务接受直播间数据，内网专线加速+免域名备案
  * 通过内网专线会自动携带X-Anchor-OpenID字段
  * ref: <a href="https://developer.open-douyin.com/docs/resource/zh-CN/developer/tools/cloud/develop-guide/danmu-callback">...</a>
 */
import { dySDK } from '@open-dy/node-server-sdk';
export default async function (params: any, context: any) {
  const anchorOpenID = context.headers['x-anchor-openid'];
  const msgType = context.headers['x-msg-type'];
  let body = {
    msg_id: params[0].msg_id,
    msg_type: msgType,
    data:  JSON.stringify(params)
  }
  // 推送失败时，开发者可增加相关重试逻辑再次调用pushDataToClientByDouyinCloudWebsocket。
  await pushDataToClientByDouyinCloudWebsocket(body, anchorOpenID, context);
  return "success";
};
/**
 * 使用抖音云websocket网关,将数据推送到主播端
 * ref: <a href="https://developer.open-douyin.com/docs/resource/zh-CN/developer/tools/cloud/develop-guide/websocket-guide/websocket#%E4%B8%8B%E8%A1%8C%E6%B6%88%E6%81%AF%E6%8E%A8%E9%80%81">...</a>
 */
async function pushDataToClientByDouyinCloudWebsocket(params: any, anchorOpenID: string, context: any) {
  const serviceContext = dySDK.context(context);
   try {
    const res = await serviceContext.openApiInvoke({
      url: "http://ws-push.dyc.ivolces.com/ws/live_interaction/push_data",
      method: "POST", // openAPI 调用方式，
      headers: { "Content-Type": "application/json",'X-TT-WS-OPENIDS': JSON.stringify([anchorOpenID]) }, // openAPI 请求头
      data: params
    });
    context.log("抖音云弹幕推送res", res);
    return res;
  } catch (err) {
    context.error('抖音云弹幕推送错误err', err);
    return err;
  }
}

/** 
* @param params 调用参数，HTTP 请求下为请求体
 * @param context 调用上下文
 *
 * @return 函数的返回数据，HTTP 场景下会作为 Response Body
 *
 */

export default async function (params: any, context: any) {
  return '结束玩法成功';
};