[feat] 재연결 로직 구현

backend/src/main/java/io/f1/backend/domain/auth/dto/CurrentUserAndAdminResponse.java

@@ -3,19 +3,21 @@
 import io.f1.backend.domain.admin.dto.AdminPrincipal;
 import io.f1.backend.domain.user.dto.UserPrincipal;
 
-public record CurrentUserAndAdminResponse(Long id, String name, String role) {
+public record CurrentUserAndAdminResponse(Long id, String name, String role, String providerId) {
 
     public static CurrentUserAndAdminResponse from(UserPrincipal userPrincipal) {
         return new CurrentUserAndAdminResponse(
                 userPrincipal.getUserId(),
                 userPrincipal.getUserNickname(),
-                UserPrincipal.ROLE_USER);
+                UserPrincipal.ROLE_USER,
+                userPrincipal.getName());
     }
 
     public static CurrentUserAndAdminResponse from(AdminPrincipal adminPrincipal) {
         return new CurrentUserAndAdminResponse(
                 adminPrincipal.getAuthenticationAdmin().adminId(),
                 adminPrincipal.getUsername(),
-                AdminPrincipal.ROLE_ADMIN);
+                AdminPrincipal.ROLE_ADMIN,
+                null);
     }
 }

backend/src/main/java/io/f1/backend/domain/game/app/RoomService.java

@@ -11,6 +11,7 @@
 import static io.f1.backend.domain.game.mapper.RoomMapper.toRoomSetting;
 import static io.f1.backend.domain.game.mapper.RoomMapper.toRoomSettingResponse;
 import static io.f1.backend.domain.game.websocket.WebSocketUtils.getDestination;
+import static io.f1.backend.domain.quiz.mapper.QuizMapper.toGameStartResponse;
 import static io.f1.backend.global.util.SecurityUtils.getCurrentUserId;
 import static io.f1.backend.global.util.SecurityUtils.getCurrentUserNickname;
 
@@ -27,6 +28,7 @@
 import io.f1.backend.domain.game.dto.response.RoomSettingResponse;
 import io.f1.backend.domain.game.dto.response.SystemNoticeResponse;
 import io.f1.backend.domain.game.event.RoomCreatedEvent;
+import io.f1.backend.domain.game.model.ConnectionState;
 import io.f1.backend.domain.game.model.GameSetting;
 import io.f1.backend.domain.game.model.Player;
 import io.f1.backend.domain.game.model.Room;
@@ -88,7 +90,7 @@ public RoomCreateResponse saveRoom(RoomCreateRequest request) {
 
         Room room = new Room(newId, roomSetting, gameSetting, host);
 
-        room.getUserIdSessionMap().put(host.id, PENDING_SESSION_ID);
+        room.addValidatedUserId(getCurrentUserId());
 
         roomRepository.saveRoom(room);
 
@@ -111,7 +113,7 @@ public void enterRoom(RoomValidationRequest request) {
             }
 
             int maxUserCnt = room.getRoomSetting().maxUserCount();
-            int currentCnt = room.getUserIdSessionMap().size();
+            int currentCnt = room.getCurrentUserCnt();
             if (maxUserCnt == currentCnt) {
                 throw new CustomException(RoomErrorCode.ROOM_USER_LIMIT_REACHED);
             }
@@ -121,7 +123,7 @@ public void enterRoom(RoomValidationRequest request) {
                 throw new CustomException(RoomErrorCode.WRONG_PASSWORD);
             }
 
-            room.getUserIdSessionMap().put(getCurrentUserId(), PENDING_SESSION_ID);
+            room.addValidatedUserId(getCurrentUserId());
         }
     }
 
@@ -131,19 +133,7 @@ public void initializeRoomSocket(Long roomId, String sessionId, UserPrincipal pr
 
         Player player = createPlayer(principal);
 
-        Map<String, Player> playerSessionMap = room.getPlayerSessionMap();
-        Map<Long, String> userIdSessionMap = room.getUserIdSessionMap();
-
-        if (room.isHost(player.getId())) {
-            player.toggleReady();
-        }
-
-        playerSessionMap.put(sessionId, player);
-        String existingSession = userIdSessionMap.get(player.getId());
-        /* 정상 흐름 or 재연결 */
-        if (existingSession.equals(PENDING_SESSION_ID) || !existingSession.equals(sessionId)) {
-            userIdSessionMap.put(player.getId(), sessionId);
-        }
+        room.addPlayer(sessionId, player);
 
         RoomSettingResponse roomSettingResponse = toRoomSettingResponse(room);
 
@@ -175,8 +165,10 @@ public void exitRoom(Long roomId, String sessionId, UserPrincipal principal) {
 
             Player removePlayer = getRemovePlayer(room, sessionId, principal);
 
+            String destination = getDestination(roomId);
+
             /* 방 삭제 */
-            if (isLastPlayer(room, sessionId)) {
+            if (room.isLastPlayer(sessionId)) {
                 removeRoom(room);
                 return;
             }
@@ -194,8 +186,6 @@ public void exitRoom(Long roomId, String sessionId, UserPrincipal principal) {
 
             PlayerListResponse playerListResponse = toPlayerListResponse(room);
 
-            String destination = getDestination(roomId);
-
             messageSender.send(destination, MessageType.PLAYER_LIST, playerListResponse);
             messageSender.send(destination, MessageType.SYSTEM_NOTICE, systemNoticeResponse);
         }
@@ -280,6 +270,59 @@ public void chat(Long roomId, String sessionId, ChatMessage chatMessage) {
         }
     }
 
+    public void reconnectSession(
+            Long roomId, String oldSessionId, String newSessionId, UserPrincipal principal) {
+        Room room = findRoom(roomId);
+        room.reconnectSession(oldSessionId, newSessionId);
+
+        String destination = getDestination(roomId);
+
+        messageSender.send(
+                destination,
+                MessageType.SYSTEM_NOTICE,
+                ofPlayerEvent(principal.getUserNickname(), RoomEventType.RECONNECT));
+
+        if (room.isPlaying()) {
+            // todo 현재 round 및 타이머 ..
+            // todo 랭킹 리스트
+            messageSender.send(
+                    destination, MessageType.GAME_START, toGameStartResponse(room.getQuestions()));
+
+        } else {
+
+            RoomSettingResponse roomSettingResponse = toRoomSettingResponse(room);
+
+            Long quizId = room.getGameSetting().getQuizId();
+            Quiz quiz = quizService.getQuizWithQuestionsById(quizId);
+
+            GameSettingResponse gameSettingResponse =
+                    toGameSettingResponse(room.getGameSetting(), quiz);
+
+            PlayerListResponse playerListResponse = toPlayerListResponse(room);
+
+            messageSender.send(destination, MessageType.ROOM_SETTING, roomSettingResponse);
+            messageSender.send(destination, MessageType.GAME_SETTING, gameSettingResponse);
+            messageSender.send(destination, MessageType.PLAYER_LIST, playerListResponse);
+        }
+    }
+
+    public void changeConnectedStatus(Long roomId, String sessionId, ConnectionState newState) {
+        Room room = findRoom(roomId);
+        room.updatePlayerConnectionState(sessionId, newState);
+    }
+
+    public boolean isExit(String sessionId, Long roomId) {
+        Room room = findRoom(roomId);
+        return room.isExit(sessionId);
+    }
+
+    public void exitIfNotPlaying(Long roomId, String sessionId, UserPrincipal principal) {
+        Room room = findRoom(roomId);
+        if (!room.isPlaying()) {
+            exitRoom(roomId, sessionId, principal);
+        }
+    }
+
     private Player getRemovePlayer(Room room, String sessionId, UserPrincipal principal) {
         Player removePlayer = room.getPlayerSessionMap().get(sessionId);
         if (removePlayer == null) {
@@ -303,11 +346,6 @@ private Room findRoom(Long roomId) {
                 .orElseThrow(() -> new CustomException(RoomErrorCode.ROOM_NOT_FOUND));
     }
 
-    private boolean isLastPlayer(Room room, String sessionId) {
-        Map<String, Player> playerSessionMap = room.getPlayerSessionMap();
-        return playerSessionMap.size() == 1 && playerSessionMap.containsKey(sessionId);
-    }
-
     private void removeRoom(Room room) {
         Long roomId = room.getId();
         roomRepository.removeRoom(roomId);
@@ -319,8 +357,10 @@ private void changeHost(Room room, String hostSessionId) {
         Map<String, Player> playerSessionMap = room.getPlayerSessionMap();
 
         Optional<String> nextHostSessionId =
-                playerSessionMap.keySet().stream()
-                        .filter(key -> !key.equals(hostSessionId))
+                playerSessionMap.entrySet().stream()
+                        .filter(entry -> !entry.getKey().equals(hostSessionId))
+                        .filter(entry -> entry.getValue().getState() == ConnectionState.CONNECTED)
+                        .map(Map.Entry::getKey)
                         .findFirst();
 
         Player nextHost =
@@ -335,5 +375,6 @@ private void changeHost(Room room, String hostSessionId) {
     private void removePlayer(Room room, String sessionId, Player removePlayer) {
         room.removeUserId(removePlayer.getId());
         room.removeSessionId(sessionId);
+        room.removeValidatedUserIds(removePlayer.getId());
     }
 }

backend/src/main/java/io/f1/backend/domain/game/dto/RoomEventType.java

@@ -6,7 +6,8 @@ public enum RoomEventType {
     START(null),
     END(null),
     CORRECT_ANSWER(SystemNoticeMessage.CORRECT_ANSWER),
-    TIMEOUT(SystemNoticeMessage.TIMEOUT);
+    TIMEOUT(SystemNoticeMessage.TIMEOUT),
+    RECONNECT(SystemNoticeMessage.RECONNECT);
 
     private final SystemNoticeMessage systemMessage;
 

backend/src/main/java/io/f1/backend/domain/game/dto/SystemNoticeMessage.java

@@ -4,7 +4,8 @@ public enum SystemNoticeMessage {
     ENTER(" 님이 입장하셨습니다"),
     EXIT(" 님이 퇴장하셨습니다"),
     CORRECT_ANSWER(" 님 정답입니다 !"),
-    TIMEOUT("땡 ~ ⏰ 제한 시간 초과!");
+    TIMEOUT("땡 ~ ⏰ 제한 시간 초과!"),
+    RECONNECT(" 님이 재연결 되었습니다.");
 
     private final String message;
 

backend/src/main/java/io/f1/backend/domain/game/mapper/RoomMapper.java

@@ -90,9 +90,8 @@ public static SystemNoticeResponse ofPlayerEvent(String nickname, RoomEventType
         return new SystemNoticeResponse(roomEventType.getMessage(nickname), Instant.now());
     }
 
-    public static QuestionResultResponse toQuestionResultResponse(
-            String correctUser, String answer) {
-        return new QuestionResultResponse(correctUser, answer);
+    public static QuestionResultResponse toQuestionResultResponse(String nickname, String answer) {
+        return new QuestionResultResponse(nickname, answer);
     }
 
     public static RankUpdateResponse toRankUpdateResponse(Room room) {

backend/src/main/java/io/f1/backend/domain/game/model/Player.java

@@ -27,4 +27,8 @@ public void toggleReady() {
     public void increaseCorrectCount() {
         correctCount++;
     }
+
+    public void updateState(ConnectionState newState) {
+        state = newState;
+    }
 }

backend/src/main/java/io/f1/backend/domain/game/model/Room.java

@@ -1,13 +1,17 @@
 package io.f1.backend.domain.game.model;
 
 import io.f1.backend.domain.question.entity.Question;
+import io.f1.backend.global.exception.CustomException;
+import io.f1.backend.global.exception.errorcode.RoomErrorCode;
 
 import lombok.Getter;
 
 import java.time.LocalDateTime;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
@@ -30,7 +34,7 @@ public class Room {
 
     private Map<String, Player> playerSessionMap = new ConcurrentHashMap<>();
 
-    private Map<Long, String> userIdSessionMap = new ConcurrentHashMap<>();
+    private final Set<Long> validatedUserIds = new HashSet<>();
 
     private final LocalDateTime createdAt = LocalDateTime.now();
 
@@ -47,6 +51,26 @@ public Room(Long id, RoomSetting roomSetting, GameSetting gameSetting, Player ho
         this.host = host;
     }
 
+    public void addValidatedUserId(Long userId) {
+        validatedUserIds.add(userId);
+    }
+
+    public int getCurrentUserCnt() {
+        return validatedUserIds.size();
+    }
+
+    public void addPlayer(String sessionId, Player player) {
+        Long userId = player.getId();
+        if (!validatedUserIds.contains(userId)) {
+            throw new CustomException(RoomErrorCode.ROOM_ENTER_REQUIRED);
+        }
+
+        if (isHost(userId)) {
+            player.toggleReady();
+        }
+        playerSessionMap.put(sessionId, player);
+    }
+
     public boolean isHost(Long id) {
         return this.host.getId().equals(id);
     }
@@ -67,14 +91,18 @@ public void updateTimer(ScheduledFuture<?> timer) {
         this.timer = timer;
     }
 
-    public void removeUserId(Long id) {
-        this.userIdSessionMap.remove(id);
-    }
-
     public void removeSessionId(String sessionId) {
         this.playerSessionMap.remove(sessionId);
     }
 
+    public void removeValidatedUserIds(Long userId) {
+        validatedUserIds.remove(userId);
+    }
+
+    public void removeUserId(Long userId) {
+        validatedUserIds.remove(userId);
+    }
+
     public void increasePlayerCorrectCount(String sessionId) {
         this.playerSessionMap.get(sessionId).increaseCorrectCount();
     }
@@ -90,4 +118,26 @@ public Boolean isPlaying() {
     public void increaseCurrentRound() {
         currentRound++;
     }
+
+    public void reconnectSession(String oldSessionId, String newSessionId) {
+        Player player = playerSessionMap.get(oldSessionId);
+        removeSessionId(oldSessionId);
+        playerSessionMap.put(newSessionId, player);
+    }
+
+    public void updatePlayerConnectionState(String sessionId, ConnectionState newState) {
+        playerSessionMap.get(sessionId).updateState(newState);
+    }
+
+    public boolean isExit(String sessionId) {
+        return playerSessionMap.get(sessionId) == null;
+    }
+
+    public boolean isLastPlayer(String sessionId) {
+        long connectedCount =
+                playerSessionMap.values().stream()
+                        .filter(player -> player.getState() == ConnectionState.CONNECTED)
+                        .count();
+        return connectedCount == 1 && playerSessionMap.containsKey(sessionId);
+    }
 }

backend/src/main/java/io/f1/backend/domain/game/websocket/WebSocketUtils.java

@@ -22,4 +22,9 @@ public static UserPrincipal getSessionUser(Message<?> message) {
     public static String getDestination(Long roomId) {
         return "/sub/room/" + roomId;
     }
+
+    public static String getRoomSubscriptionDestination(Message<?> message) {
+        StompHeaderAccessor headerAccessor = StompHeaderAccessor.wrap(message);
+        return headerAccessor.getDestination();
+    }
 }

backend/src/main/java/io/f1/backend/domain/game/websocket/GameSocketController.java → backend/src/main/java/io/f1/backend/domain/game/websocket/controller/GameSocketController.java

@@ -1,4 +1,4 @@
-package io.f1.backend.domain.game.websocket;
+package io.f1.backend.domain.game.websocket.controller;
 
 import static io.f1.backend.domain.game.websocket.WebSocketUtils.getSessionId;
 import static io.f1.backend.domain.game.websocket.WebSocketUtils.getSessionUser;
@@ -7,6 +7,7 @@
 import io.f1.backend.domain.game.app.RoomService;
 import io.f1.backend.domain.game.dto.ChatMessage;
 import io.f1.backend.domain.game.dto.request.DefaultWebSocketRequest;
+import io.f1.backend.domain.game.websocket.service.SessionService;
 import io.f1.backend.domain.user.dto.UserPrincipal;
 
 import lombok.RequiredArgsConstructor;
@@ -22,15 +23,25 @@ public class GameSocketController {
 
     private final RoomService roomService;
     private final GameService gameService;
+    private final SessionService sessionService;
 
     @MessageMapping("/room/initializeRoomSocket/{roomId}")
     public void initializeRoomSocket(@DestinationVariable Long roomId, Message<?> message) {
 
         String websocketSessionId = getSessionId(message);
 
         UserPrincipal principal = getSessionUser(message);
-
-        roomService.initializeRoomSocket(roomId, websocketSessionId, principal);
+        Long userId = principal.getUserId();
+
+        if (sessionService.hasOldSessionId(userId)) {
+            String oldSessionId = sessionService.getOldSessionId(userId);
+            /* room 재연결 대상인지 아닌지 판별 */
+            if (!roomService.isExit(oldSessionId, roomId)) {
+                roomService.reconnectSession(roomId, oldSessionId, websocketSessionId, principal);
+            }
+        } else {
+            roomService.initializeRoomSocket(roomId, websocketSessionId, principal);
+        }
     }
 
     @MessageMapping("/room/exit/{roomId}")