fdkk_meta/src/main/java/com/fdkk/fdkkmeta/task/UpdateFrameMetaTask.java

package com.fdkk.fdkkmeta.task;

import cn.hutool.core.util.ArrayUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.fdkk.fdkkmeta.config.MetaConfig;
import com.fdkk.fdkkmeta.domain.entity.mysql.BreakpointsEntity;
import com.fdkk.fdkkmeta.domain.entity.mysql.MoveFrameEntity;
import com.fdkk.fdkkmeta.domain.entity.mysql.RotateFrameEntity;
import com.fdkk.fdkkmeta.domain.entity.mysql.UserEntity;
import com.fdkk.fdkkmeta.domain.po.*;
import com.fdkk.fdkkmeta.grpc.*;
import com.fdkk.fdkkmeta.grpcService.SceneGrpcService;
import com.fdkk.fdkkmeta.redis.RedisCache;
import com.fdkk.fdkkmeta.service.BreakpointsService;
import com.fdkk.fdkkmeta.service.MoveFrameService;
import com.fdkk.fdkkmeta.service.UserService;
import com.fdkk.fdkkmeta.service.RotateFrameService;
import com.fdkk.fdkkmeta.util.ProtoJsonUtils;
import com.google.protobuf.util.JsonFormat;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @author Xiewj
 * @date 2022/3/30
 */
@Component
@Slf4j
public class UpdateFrameMetaTask {
    @Autowired
    MetaConfig metaConfig;
    @Autowired
    RedisCache redisCache;
    @Autowired
    UserService userService;
    @Autowired
    RotateFrameService rotateFrameService;
    @Autowired
    MoveFrameService moveFrameService;
    @Autowired
    SceneGrpcService sceneGrpcService;
    @Autowired
    BreakpointsService breakpointsService;
    @Scheduled(initialDelay=200, fixedDelay=1000/30)
   public void updateFrameMetadata(){
       List<UserEntity> userOnline = userService.findUserOnline(true);
       log.info("进入定时任务{}", ArrayUtil.isNotEmpty(userOnline)?userOnline.size():0);
//        JSONObject a=new JSONObject();
//        a.put("123123",123123);
       //使用并行流处理数据
       userOnline.parallelStream().forEach(
               userEntity -> {
                   //UserEntity user = redisCache.getCacheObject("setCacheRequest:" + userEntity.getUserId());
//                   redisCache.set("updateFrameMetadata:"+userEntity.getUserId(),a.toJSONString());
                   List<ActionPO> list = redisCache.getCacheList("setCacheRequest:"+userEntity.getUserId());
                   handle( userEntity,list);
               }
       );
   }

    private void handle(UserEntity user,List<ActionPO> list){
        try {
            if(list.size() == 0){
                //写入一个默认数据到redis里
                createDefaultFrameMetadata( user);
                return;
            }

            List<ActionPO> rotateJoystickList = new ArrayList<ActionPO>();
            JSONObject myState = redisCache.getCacheObject("UserState:"+user.getUserId());

            ActionPO _actionPO = list.get(0);
            int firstActionType = _actionPO.getAction_type();
            JSONArray path = _actionPO.getPath();
            if(firstActionType == 1014||firstActionType == 15){
                rotateJoystickList.add(_actionPO);
            }
            else if(firstActionType == 1){
                long startBreakPointId = path.getLongValue(0);
                long endBreakPointId = path.getLongValue(1);
                BreakpointsEntity startBreakpointsEntity = breakpointsService.findById(startBreakPointId);
                BreakpointsEntity endBreakpointsEntity = breakpointsService.findById(endBreakPointId);

                //过渡
                if(myState.getIntValue("isMoving") == 1){
                    MoveFrameEntity moveFrameEntity = moveFrameService.findByAppIAndStartBreakPointIdAndEndBreakPointIdAndAngleAndFrameIndex(user.getAppId(), startBreakPointId, endBreakPointId,_actionPO.getCameraAngle().getYaw(),_actionPO.getFrameIndex()+1);
                    //准备过渡下一段
                    if(moveFrameEntity==null){
                        RotateFrameEntity rotateFrameEntity = rotateFrameService.findByAppIdAndBreakPointIdAndFrameIndex(user.getAppId(),endBreakPointId,_actionPO.getCameraAngle().getYaw());
                        path.remove(0);
                        if(path.size()>1){
                            startBreakPointId = endBreakPointId;
                            endBreakPointId = path.getLongValue(1);
                            _actionPO.setPath(path);
                            _actionPO.setFrameIndex(0);
                            _actionPO.setStartPostion(null);
                            _actionPO.setEndPosition(null);

                            int subFrameIndex = moveFrameService.getCountByAppIAndStartBreakPointIdAndEndBreakPointIdAndAngle( user.getAppId(),startBreakPointId,endBreakPointId, _actionPO.getCameraAngle().getYaw()%45);
                            _actionPO.setSubFrameIndex(subFrameIndex);
                            _actionPO.setPlayerPosition(endBreakpointsEntity.getPosition());

                            startBreakpointsEntity = breakpointsService.findById(startBreakPointId);
                            endBreakpointsEntity = breakpointsService.findById(endBreakPointId);
                            int _angle = sceneGrpcService.calAngleForBreakPointId(startBreakpointsEntity,endBreakpointsEntity);
                            AnglePO playerAngle = user.getPlayerAngle();
                            playerAngle.setYaw(_angle);
                            _actionPO.setPlayerAngle(playerAngle);
                            //更新redis记录
                            redisCache.setCacheListByIndex("setCacheRequest:"+user.getUserId(),0,_actionPO);

                            myState.put("isMoving",0);
                            redisCache.setCacheObject("UserState:"+user.getUserId(),myState);

                            //moveFrameEntity = moveFrameService.findByAppIAndStartBreakPointIdAndEndBreakPointIdAndAngleAndFrameIndex(user.getAppId(), startBreakPointId, endBreakPointId,_actionPO.getCameraAngle().getYaw(),0);
                            user.setFrameId(rotateFrameEntity.getId());
                            user.setPlayerAngle(playerAngle);
                            user.setBreakPointId(startBreakPointId);
                            user.setPlayerPosition(startBreakpointsEntity.getPosition());
                            userService.updateById(user);
                        }
                        //过渡全部结束
                        else{
                            //删除redis里的数据
                            redisCache.lTrim("setCacheRequest:"+user.getUserId(),1,-1);
                            //更新user表
                            //moveFrameEntity = moveFrameService.findByAppIAndStartBreakPointIdAndEndBreakPointIdAndAngleAndFrameIndex(user.getAppId(), startBreakPointId, endBreakPointId,_actionPO.getCameraAngle().getYaw(),_actionPO.getFrameIndex());
                            user.setPlayerPosition(endBreakpointsEntity.getPosition());
                            user.setFrameId(rotateFrameEntity.getId());
                            user.setPlayerAngle(_actionPO.getPlayerAngle());
                            user.setBreakPointId(endBreakPointId);
                            userService.updateById(user);

                            myState.put("isMoving",0);
                            redisCache.setCacheObject("UserState:"+user.getUserId(),myState);
                            //执行下一条记录
                            list.remove(0);
                        }

                        handle( user,list);
                        return ;
                    }
                    //更新
                    if(_actionPO.getStartPostion() == null){
                        _actionPO.setStartPostion(startBreakpointsEntity.getPosition());
                        _actionPO.setEndPosition(endBreakpointsEntity.getPosition());
                    }
                    _actionPO.setFrameIndex(_actionPO.getFrameIndex()+1);
                    PointPO playerPosition = new PointPO();
                    playerPosition.setX((_actionPO.getEndPosition().getX() - _actionPO.getStartPostion().getX())/_actionPO.getSubFrameIndex()*_actionPO.getFrameIndex());
                    playerPosition.setY((_actionPO.getEndPosition().getY() - _actionPO.getStartPostion().getY())/_actionPO.getSubFrameIndex()*_actionPO.getFrameIndex());
                    playerPosition.setZ((_actionPO.getEndPosition().getZ() - _actionPO.getStartPostion().getZ())/_actionPO.getSubFrameIndex()*_actionPO.getFrameIndex());
                    createMoveFrameMetadata(user.getUserId(),_actionPO.getPlayerAngle(), playerPosition, moveFrameEntity,_actionPO.getTrace_id());
                    //更新redis里的数据
                    redisCache.setCacheListByIndex("setCacheRequest:"+user.getUserId(),0,_actionPO);
                }
                else if(myState.getIntValue("isMoving") == 0){
                    if(list.size()>0){
                        //中断,执行下一条记录
                        list.remove(0);
                        redisCache.lTrim("setCacheRequest:"+user.getUserId(),1,-1);
                        handle( user,list);
                        return ;
                    }
                    else{
                        //过渡
                        myState.put("isMoving",1);
                        redisCache.setCacheObject("UserState:"+user.getUserId(),myState);

                        MoveFrameEntity moveFrameEntity = moveFrameService.findByAppIAndStartBreakPointIdAndEndBreakPointIdAndAngleAndFrameIndex(user.getAppId(), startBreakPointId, endBreakPointId,_actionPO.getCameraAngle().getYaw(),_actionPO.getFrameIndex()+1);
                        //更新
                        int _angle = sceneGrpcService.calAngleForBreakPointId(startBreakpointsEntity,endBreakpointsEntity);
                        AnglePO playerAngle = user.getPlayerAngle();
                        playerAngle.setYaw(_angle);
                        createMoveFrameMetadata( user.getUserId(),playerAngle,startBreakpointsEntity.getPosition(), moveFrameEntity,_actionPO.getTrace_id());
                        _actionPO.setFrameIndex(_actionPO.getFrameIndex()+1);
                        _actionPO.setStartPostion(startBreakpointsEntity.getPosition());
                        _actionPO.setEndPosition(endBreakpointsEntity.getPosition());
                        //更新redis里的数据
                        redisCache.setCacheListByIndex("setCacheRequest:"+user.getUserId(),0,_actionPO);
                    }
                }
                /****************************************************************************************/
                return;
            }
            long lastFrameId = _actionPO.getFrameId();
            for(int i=1;i<list.size();++i){
                ActionPO actionPO = list.get(i);
//            if(firstActionType != actionPO.getAction_type()){
//                break;
//            }
                //旋转
                if(actionPO.getAction_type() == 1014||actionPO.getAction_type() == 15){
                    rotateJoystickList.add(actionPO);
                    lastFrameId = actionPO.getFrameId();
                    continue;
                }
                else{
                    break;
                }
            }
            createRotateFrameMetadata( user, rotateJoystickList, firstActionType);
            //删除redis里的数据
            redisCache.lTrim("setCacheRequest:"+user.getUserId(),rotateJoystickList.size(),-1);
            //更新user表
            user.setFrameId(lastFrameId);
            userService.updateById(user);
        }catch (Exception e){
            e.printStackTrace();
            log.info("handleException{}",e.getMessage());

        }
    }

    private void createDefaultFrameMetadata(UserEntity user) throws IOException {
        String[] traceIds = new String[1];
        traceIds[0] = "";
        JSONArray actionResponses = new JSONArray();

        RotateFrameEntity rotateFrameEntity = rotateFrameService.findById(user.getFrameId());
        PointPO playerPosition = user.getPlayerPosition();
        Point playerPt = Point.newBuilder().setX(String.valueOf(playerPosition.getX())).setY(String.valueOf(playerPosition.getY())).setZ(String.valueOf(playerPosition.getZ())).build();
        AnglePO playerAngle = user.getPlayerAngle();
        AngleUe4 playerAg =AngleUe4.newBuilder().setPitch(playerAngle.getPitch()).setYaw(playerAngle.getYaw()).setRoll(playerAngle.getRoll()).build();
        Space player = sceneGrpcService.createSpace(playerPt,playerAg);

        PointPO cameraPoint = rotateFrameEntity.getCameraPosition();
        Point cameraPosition = sceneGrpcService.createPoint(String.valueOf(cameraPoint.getX()),String.valueOf(cameraPoint.getY()),String.valueOf(cameraPoint.getZ()));
        AnglePO cameraAnglePO = rotateFrameEntity.getCameraAngle();
        AngleUe4 cameraAngle = sceneGrpcService.createAngle(cameraAnglePO.getPitch(),cameraAnglePO.getYaw(),cameraAnglePO.getRoll());
        Space camera = sceneGrpcService.createSpace(cameraPosition,cameraAngle);

        MetaDataFrameReply.Builder builder = MetaDataFrameReply.newBuilder();
        for(int i=0;i<traceIds.length;++i){
            builder.addTraceIds(traceIds[i]);
        }
        State playerState = sceneGrpcService.createPlayerState2(player,camera,playerPt);

        RenderInfo renderInfo = sceneGrpcService.createRenderInfo();
        UserState userState = sceneGrpcService.createUserState( user.getUserId(), playerState, renderInfo, null);

        builder.addNewUserStates(userState);

        builder.setGetStateType(0);
        builder.setCode(200);
        builder.setMsg("ok");
        //newUserStates

        String mediaSrc = metaConfig.getVideoFramePath()+"/"+"0000000001"+"/"+rotateFrameEntity.getBreakPointId()+"/"+rotateFrameEntity.getDirectory()+"/"+rotateFrameEntity.getFileName()+"?m="+new Date().getTime();
        builder.setMediaSrc(mediaSrc);

        redisCache.lLeftPush("updateFrameMetadata:"+user.getUserId(), ProtoJsonUtils.toJson(builder));
    }

    private void createMoveFrameMetadata(String user_id,AnglePO playerAngle,PointPO playerPosition,MoveFrameEntity moveFrameEntity,String traceId) throws IOException {
        String[] traceIds = new String[1];
        traceIds[0] = traceId;
        JSONArray actionResponses = new JSONArray();

        //RotateFrameEntity rotateFrameEntity = rotateFrameService.findById(user.getFrameId());
        //PointPO playerPosition = user.getPlayerPosition();
        Point playerPt = Point.newBuilder().setX(String.valueOf(playerPosition.getX())).setY(String.valueOf(playerPosition.getY())).setZ(String.valueOf(playerPosition.getZ())).build();
        //AnglePO playerAngle = user.getPlayerAngle();
        AngleUe4 playerAg =AngleUe4.newBuilder().setPitch(playerAngle.getPitch()).setYaw(playerAngle.getYaw()).setRoll(playerAngle.getRoll()).build();
        Space player = sceneGrpcService.createSpace(playerPt,playerAg);

        PointPO cameraPoint = moveFrameEntity.getCameraPosition();
        Point cameraPosition = sceneGrpcService.createPoint(String.valueOf(cameraPoint.getX()),String.valueOf(cameraPoint.getY()),String.valueOf(cameraPoint.getZ()));
        AnglePO cameraAnglePO = moveFrameEntity.getCameraAngle();
        AngleUe4 cameraAngle = sceneGrpcService.createAngle(cameraAnglePO.getPitch(),cameraAnglePO.getYaw(),cameraAnglePO.getRoll());
        Space camera = sceneGrpcService.createSpace(cameraPosition,cameraAngle);


        MetaDataFrameReply.Builder builder = MetaDataFrameReply.newBuilder();
        for(int i=0;i<traceIds.length;++i){
            builder.addTraceIds(traceIds[i]);
        }

        State playerState = sceneGrpcService.createPlayerState2(player,camera,playerPt);

        RenderInfo renderInfo = sceneGrpcService.createRenderInfo();
        UserState userState = sceneGrpcService.createUserState( user_id, playerState, renderInfo, null);


        builder.addNewUserStates(userState);

        builder.setGetStateType(0);
        builder.setCode(200);
        builder.setMsg("ok");


        String mediaSrc = metaConfig.getVideoFramePath()+"/"+"0000000001"+"/"+moveFrameEntity.getStartBreakPointId()+"/"+moveFrameEntity.getDirectory()+"/"+moveFrameEntity.getFileName()+"?m="+new Date().getTime();
        builder.setMediaSrc(mediaSrc);
        redisCache.lLeftPush("updateFrameMetadata:"+user_id,ProtoJsonUtils.toJson(builder));
    }

    private void createRotateFrameMetadata(UserEntity user,List<ActionPO> rotateJoystickList,int firstActionType) throws IOException {
        JSONArray actionResponses = new JSONArray();
        String[] traceIds = new String[rotateJoystickList.size()];
        if(rotateJoystickList.size()>0){
            for(int j=0;j<rotateJoystickList.size();++j){
                ActionPO actionPO = rotateJoystickList.get(j);
                JSONObject actionResponse = sceneGrpcService.createActionResponse(actionPO.getAction_type(),actionPO.getTrace_id());
                actionResponses.add(actionResponse);
                traceIds[j] = actionPO.getTrace_id();
            }
        }

        ActionPO lastActionPO = rotateJoystickList.get(rotateJoystickList.size()-1);
        RotateFrameEntity rotateFrameEntity = rotateFrameService.findById(lastActionPO.getFrameId());
        PointPO playerPosition = user.getPlayerPosition();
        Point playerPt = Point.newBuilder().setX(String.valueOf(playerPosition.getX())).setY(String.valueOf(playerPosition.getY())).setZ(String.valueOf(playerPosition.getZ())).build();
        AnglePO playerAngle = user.getPlayerAngle();
        AngleUe4 playerAg = null;
        if(firstActionType == 15){
            playerAngle.setYaw(lastActionPO.getPlayerAngle().getYaw());
        }
        playerAg = AngleUe4.newBuilder().setPitch(playerAngle.getPitch()).setYaw(playerAngle.getYaw()).setRoll(playerAngle.getRoll()).build();
        Space player = sceneGrpcService.createSpace(playerPt,playerAg);

        PointPO cameraPoint = rotateFrameEntity.getCameraPosition();
        log.info("旋转时：计算的frameId:"+lastActionPO.getFrameId()+",相机的坐标："+cameraPoint.toString());
        Point cameraPosition = sceneGrpcService.createPoint(String.valueOf(cameraPoint.getX()),String.valueOf(cameraPoint.getY()),String.valueOf(cameraPoint.getZ()));
        AnglePO cameraAnglePO = rotateFrameEntity.getCameraAngle();
        AngleUe4 cameraAngle = sceneGrpcService.createAngle(cameraAnglePO.getPitch(),cameraAnglePO.getYaw(),cameraAnglePO.getRoll());
        Space camera = sceneGrpcService.createSpace(cameraPosition,cameraAngle);


        MetaDataFrameReply.Builder builder = MetaDataFrameReply.newBuilder();
        for(int i=0;i<traceIds.length;++i){
            builder.addTraceIds(traceIds[i]);
        }
        State playerState = sceneGrpcService.createPlayerState2(player,camera,playerPt);

        RenderInfo renderInfo = sceneGrpcService.createRenderInfo();
        UserState userState = sceneGrpcService.createUserState( user.getUserId(), playerState, renderInfo, null);


        builder.addNewUserStates(userState);

        builder.setGetStateType(0);
        builder.setCode(200);
        builder.setMsg("ok");

        String mediaSrc = metaConfig.getVideoFramePath()+"/"+"0000000001"+"/"+rotateFrameEntity.getBreakPointId()+"/"+rotateFrameEntity.getDirectory()+"/"+rotateFrameEntity.getFileName()+"?m="+new Date().getTime();
        builder.setMediaSrc(mediaSrc);
        redisCache.lLeftPush("updateFrameMetadata:"+user.getUserId(),ProtoJsonUtils.toJson(builder));

        //更新user表
        user.setFrameId(lastActionPO.getFrameId());
        user.setPlayerAngle(playerAngle);
    }
   /*
   * {
        "traceIds": ["d0864cd0-378d-4d49-b7b0-3e8e1b9494c3", "d0864cd0-378d-4d49-b7b0-3e8e1b9494c3", "939087ff-4999-4551-92e4-26ecb67f8aa2"],
        "vehicle": null,
        "newUserStates": [{
            "userId": "dcff36ae4fc1d",
            "playerState": {
                "roomTypeId": "",
                "person": 0,
                "avatarId": "",
                "skinId": "",
                "roomId": ""
                "isHost": false,
                "isFollowHost": false,
                "skinDataVersion": "",
                "avatarComponents": "",
                "nickName": "",
                "movingMode": 0,
                "attitude": "",
                "areaName": "",
                "pathName": "",
                "pathId": "",
                "avatarSize": 1,
                "extra": "",
                "prioritySync": false,
                "player": {
                    "position": {
                        "x": -421.30057,
                        "y": -1434.4198,
                        "z": -34
                    },
                    "angle": {
                        "pitch": 0,
                        "yaw": 47,
                        "roll": 0
                    }
                },
                "camera": {
                    "position": {
                        "x": -436.2,
                        "y": -1408.8,
                        "z": 130.7
                    },
                    "angle": {
                        "pitch": 0,
                        "yaw": 315,
                        "roll": 0
                    }
                },
                "cameraCenter": {
                    "x": -400,
                    "y": -1450,
                    "z": 10.610336
                }
            },
            "renderInfo": {
                "renderType": 0,
                "videoFrame": null,
                "cameraStateType": 3,
                "isMoving": 1,
                "needIfr": 0,
                "isVideo": 0,
                "stillFrame": 0,
                "isRotating": 0,
                "isFollowing": 0,
                "clientPanoTitlesBitmap": [],
                "clientPanoTreceId": "",
                "prefetchVideoId": "",
                "noMedia": false
            },
            "event": null,
            "relation": 1
        }],
        "actionResponses": [{
            "actionType": 15,
            "pointType": 100,
            "extra": "",
            "traceId": "d0864cd0-378d-4d49-b7b0-3e8e1b9494c3",
            "packetId": "d44bd2f5-f877-4dd7-868b-803c64f99082",
            "nps": [],
            "peopleNum": 0,
            "zoneId": "",
            "echoMsg": "",
            "reserveDetail": null,
            "userWithAvatarList": [],
            "newUserStates": [],
            "code": 0,
            "msg": ""
        }, {
            "actionType": 1,
            "pointType": 0,
            "extra": "",
            "traceId": "939087ff-4999-4551-92e4-26ecb67f8aa2",
            "packetId": "",
            "nps": [],
            "peopleNum": 0,
            "zoneId": "",
            "echoMsg": "",
            "reserveDetail": null,
            "userWithAvatarList": [],
            "newUserStates": [],
            "code": 0,
            "msg": ""
        }],
        "getStateType": 0,
        "code": 0,
        "msg": "OK"
    }
   * */
}