[FEAT/#95] 서버 방 생성 작업을 진행합니다.

PhotoGether/DataLayer/PhotoGetherData/PhotoGetherData/ConnectionClientImpl.swift

@@ -10,14 +10,18 @@ public final class ConnectionClientImpl: ConnectionClient {
     public var receivedDataPublisher = PassthroughSubject<Data, Never>()
 
     public var remoteVideoView: UIView = CapturableVideoView()
-    public var localVideoView: UIView = CapturableVideoView()
+    public var userInfo: UserInfoEntity?
 
-    public var peerID: String = ""
     public var roomID: String = ""
 
-    public init(signalingService: SignalingService, webRTCService: WebRTCService) {
+    public init(
+        signalingService: SignalingService,
+        webRTCService: WebRTCService,
+        userInfo: UserInfoEntity? = nil
+    ) {
         self.signalingService = signalingService
         self.webRTCService = webRTCService
+        self.userInfo = userInfo
 
         self.signalingService.delegate = self
         self.webRTCService.delegate = self
@@ -27,30 +31,26 @@ public final class ConnectionClientImpl: ConnectionClient {
 
         // VideoTrack과 나와 상대방의 화면을 볼 수 있는 뷰를 바인딩합니다.
         self.bindRemoteVideo()
-        self.bindLocalVideo()
     }
 
     public func sendOffer() {
+        guard let userInfo else { return }
+
         self.webRTCService.offer { sdp in
-            self.signalingService.send(sdp: sdp, peerID: self.peerID, roomID: self.roomID)
+            self.signalingService.send(
+                sdp: sdp,
+                peerID: userInfo.id,
+                roomID: userInfo.roomID ?? ""
+            )
         }
     }
 
     public func sendData(data: Data) {
         self.webRTCService.sendData(data)
     }
 
-    public func captureVideos() -> [UIImage] {
-        let localCaptureImage = getCapturedVideos(isLocal: true)
-        let remoteCaptureImage = getCapturedVideos(isLocal: false)
-
-        return [localCaptureImage, remoteCaptureImage]
-    }
-
-    private func getCapturedVideos(isLocal: Bool) -> UIImage {
-        let targetVideo = isLocal ? self.localVideoView : self.remoteVideoView
-
-        guard let videoView = targetVideo as? CapturableVideoView else {
+    public func captureVideo() -> UIImage {
+        guard let videoView = self.remoteVideoView as? CapturableVideoView else {
             return UIImage()
         }
 
@@ -71,7 +71,7 @@ public final class ConnectionClientImpl: ConnectionClient {
         self.webRTCService.renderRemoteVideo(to: remoteVideoView)
     }
 
-    private func bindLocalVideo() {
+    public func bindLocalVideo(_ localVideoView: UIView) {
         guard let localVideoView = localVideoView as? RTCMTLVideoView else { return }
         self.webRTCService.startCaptureLocalVideo(renderer: localVideoView)
     }
@@ -104,7 +104,13 @@ extension ConnectionClientImpl: SignalingServiceDelegate {
             guard self.webRTCService.peerConnection.localDescription == nil else { return }
 
             self.webRTCService.answer { sdp in
-                self.signalingService.send(sdp: sdp, peerID: self.peerID, roomID: self.roomID)
+                guard let userInfo = self.userInfo else { return }
+
+                self.signalingService.send(
+                    sdp: sdp,
+                    peerID: userInfo.id,
+                    roomID: userInfo.roomID ?? ""
+                )
             }
         }
     }
@@ -124,7 +130,13 @@ extension ConnectionClientImpl: WebRTCServiceDelegate {
         _ service: WebRTCService,
         didGenerateLocalCandidate candidate: RTCIceCandidate
     ) {
-        self.signalingService.send(candidate: candidate, peerID: self.peerID, roomID: self.roomID)
+        guard let userInfo else { return }
+
+        self.signalingService.send(
+            candidate: candidate,
+            peerID: userInfo.id,
+            roomID: userInfo.roomID ?? ""
+        )
     }
 
     public func webRTCService(

PhotoGether/DataLayer/PhotoGetherData/PhotoGetherData/ConnectionRepositoryImpl.swift

@@ -1,10 +1,23 @@
-import Foundation
+import UIKit
 import PhotoGetherDomainInterface
 
 public final class ConnectionRepositoryImpl: ConnectionRepository {
     public var clients: [ConnectionClient]
 
-    public init(clients: [ConnectionClient]) {
+    private let _localVideoView = CapturableVideoView()
+
+    public var localVideoView: UIView { _localVideoView }
+    public var capturedLocalVideo: UIImage? { _localVideoView.capturedImage }
+
+    public let roomService: RoomService
+
+    public init(clients: [ConnectionClient], roomService: RoomService) {
         self.clients = clients
+        self.roomService = roomService
+        bindLocalVideo()
+    }
+
+    private func bindLocalVideo() {
+        self.clients.forEach { $0.bindLocalVideo(_localVideoView) }
     }
 }

PhotoGether/DataLayer/PhotoGetherData/PhotoGetherData/Extension/Data+toDTO.swift

@@ -1,7 +1,7 @@
 import Foundation
 
 public extension Data {
-    func toDTO(type: Decodable.Type) -> Decodable? {
-        return try? JSONDecoder().decode(type, from: self)
+    func toDTO<T: Decodable>(type: T.Type, decoder: JSONDecoder) -> T? {
+        return try? decoder.decode(type, from: self)
     }
 }

PhotoGether/DataLayer/PhotoGetherData/PhotoGetherData/Extension/Encodable+toData.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+extension Encodable {
+    func toData(encoder: JSONEncoder) -> Data? {
+        return try? encoder.encode(self)
+    }
+}

PhotoGether/DataLayer/PhotoGetherData/PhotoGetherData/Interface/Delegate/RoomServiceDelegate.swift

@@ -1,4 +1,5 @@
 import Foundation
+import PhotoGetherDomainInterface
 
 public protocol RoomServiceDelegate: AnyObject {
     func roomService(_ roomService: RoomService, didReceiveResponseCreateRoom response: String)

PhotoGether/DataLayer/PhotoGetherData/PhotoGetherData/Interface/Message/CreateRoomResponseMessage.swift

@@ -0,0 +1,11 @@
+import Foundation
+import PhotoGetherDomainInterface
+
+public struct CreateRoomResponseMessage: Decodable {
+    let roomID: String
+    let hostID: String
+
+    public func toEntity() -> RoomOwnerEntity {
+        RoomOwnerEntity(roomID: self.roomID, hostID: self.hostID)
+    }
+}

PhotoGether/DataLayer/PhotoGetherData/PhotoGetherData/Interface/Message/JoinRoomRequestMessage.swift

@@ -0,0 +1,5 @@
+import Foundation
+
+public struct JoinRoomRequestMessage: Encodable {
+    public let roomID: String
+}

PhotoGether/DataLayer/PhotoGetherData/PhotoGetherData/Interface/Message/JoinRoomResponseMessage.swift

@@ -0,0 +1,16 @@
+import Foundation
+import PhotoGetherDomainInterface
+
+public struct JoinRoomResponseMessage: Decodable {
+    public let userID: String
+    public let clientsID: [String]
+
+    public init(userID: String, clientsID: [String]) {
+        self.userID = userID
+        self.clientsID = clientsID
+    }
+
+    public func toEntity() -> JoinRoomEntity {
+        JoinRoomEntity(userID: self.userID, clientsID: self.clientsID)
+    }
+}

PhotoGether/DataLayer/PhotoGetherData/PhotoGetherData/ServiceImpl/RoomServiceImpl.swift

@@ -1,32 +1,108 @@
 import Foundation
+import Combine
 import PhotoGetherNetwork
+import PhotoGetherDomainInterface
 
 public final class RoomServiceImpl: RoomService {
+    public var createRoomResponsePublisher: AnyPublisher<RoomOwnerEntity, Error> {
+        _createRoomResponsePublisher.eraseToAnyPublisher()
+    }
+    public var joinRoomResponsePublisher: AnyPublisher<JoinRoomEntity, Error> {
+        _joinRoomResponsePublisher.eraseToAnyPublisher()
+    }
+    private let _createRoomResponsePublisher = PassthroughSubject<RoomOwnerEntity, Error>()
+    private let _joinRoomResponsePublisher = PassthroughSubject<JoinRoomEntity, Error>()
+    private var cancellables: Set<AnyCancellable> = []
+
     private let decoder = JSONDecoder()
     private let encoder = JSONEncoder()
     private var webSocketClient: WebSocketClient
 
     public init(webSocketClient: WebSocketClient) {
         self.webSocketClient = webSocketClient
+        bindWebSocketClient()
+    }
+
+    public func createRoom() -> AnyPublisher<RoomOwnerEntity, Error> {
+        let createRoomRequest = RoomRequestDTO(messageType: .createRoom)
+
+        guard let data = createRoomRequest.toData(encoder: encoder) else {
+            debugPrint("방 생성 요청 데이터 인코딩 실패: \(createRoomRequest)")
+            return Fail(error: RoomServiceError.failedToEncoding).eraseToAnyPublisher()
+        }
+
+        webSocketClient.send(data: data)
+        return createRoomResponsePublisher
     }
 
-    public func send(request: any WebSocketRequestable) {
-        guard let data = request.toData(encoder: encoder) else {
-            debugPrint("방 생성 요청 데이터 인코딩 실패: \(request)")
-            return
+    public func joinRoom(to roomID: String) -> AnyPublisher<JoinRoomEntity, Error> {
+        let joinRoomMessage = JoinRoomRequestMessage(roomID: roomID).toData(encoder: encoder)
+        let joinRoomRequest = RoomRequestDTO(messageType: .joinRoom, message: joinRoomMessage)
+
+        guard let data = joinRoomRequest.toData(encoder: encoder) else {
+            debugPrint("방 참가 요청 데이터 인코딩 실패: \(joinRoomRequest)")
+            return Fail(error: RoomServiceError.failedToEncoding).eraseToAnyPublisher()
         }
 
         webSocketClient.send(data: data)
+        return joinRoomResponsePublisher
+    }
+
+    private func bindWebSocketClient() {
+        self.webSocketClient.webSocketdidReceiveDataPublisher
+            .sink { [weak self] data in
+                guard let self else { return }
+
+                guard let response = data.toDTO(type: RoomResponseDTO.self, decoder: decoder) else { return }
+
+                switch response.messageType {
+                case .createRoom:
+                    guard let message = response.message else { return }
+                    guard let message = message.toDTO(
+                        type: CreateRoomResponseMessage.self,
+                        decoder: decoder
+                    ) else {
+                        debugPrint("Decode Failed to CreateRoomMessage: \(message)")
+                        return
+                    }
+                    let roomOwnerEntity = message.toEntity()
+                    _createRoomResponsePublisher.send(roomOwnerEntity)
+
+                    debugPrint("방 생성 성공: \(message.roomID) \n 유저 아이디: \(message.hostID)")
+                case .joinRoom:
+                    guard let message = decodeMessage(
+                        response.message,
+                        type: JoinRoomResponseMessage.self
+                    ) else {
+                        debugPrint("Decode Failed to JoinRoomEntity: \(String(describing: response.message))")
+                        return
+                    }
+                    let joinRoomEntity = message.toEntity()
+                    _joinRoomResponsePublisher.send(joinRoomEntity)
+
+                    debugPrint("방 참가 성공\n 유저 아이디: \(message.userID) \n 방 유저들 아이디: \(message.clientsID)")
+                }
+            }.store(in: &cancellables)
+    }
+
+    private func decodeMessage<T: Decodable>(_ message: Data?, type: T.Type) -> T? {
+        guard let message = message else { return nil }
+        guard let dto = message.toDTO(type: type, decoder: decoder) else {
+            debugPrint("Decode Failed to: \(message)")
+            return nil
+        }
+
+        return dto
     }
 }
 
-// MARK: WebSocketDelegate
-extension RoomServiceImpl: WebSocketClientDelegate {
-    public func webSocketDidConnect(_ webSocket: WebSocketClient) { }
+public enum RoomServiceError: LocalizedError {
+    case failedToEncoding
 
-    public func webSocketDidDisconnect(_ webSocket: WebSocketClient) { }
-
-    public func webSocket(_ webSocket: WebSocketClient, didReceiveData data: Data) {
-        // TODO: 생성된 방번호 고유 아이디가 담긴 정보 디코딩
+    public var errorDescription: String? {
+        switch self {
+        case .failedToEncoding:
+            return "Failed to encode room service request"
+        }
     }
 }

PhotoGether/DataLayer/PhotoGetherData/PhotoGetherData/ServiceImpl/SignalingServiceImpl.swift

@@ -10,7 +10,7 @@ final public class SignalingServiceImpl: SignalingService {
 
     public init(webSocketClient: WebSocketClient) {
         self.webSocketClient = webSocketClient
-        self.webSocketClient.delegate = self
+        self.webSocketClient.delegates.append(self) 
     }
 
     public func connect() {

PhotoGether/DataLayer/PhotoGetherData/PhotoGetherData/ServiceImpl/WebRTCServiceImpl.swift

@@ -134,14 +134,24 @@ public extension WebRTCServiceImpl {
             fps: Int(fps.maxFrameRate)
         )
 
+        flipVideoRenderer(renderer)
+
         self.localVideoTrack?.add(renderer)
     }
 
     /// remoteVideoTrack에서 수신된 모든 프레임을 렌더링할 렌더러를 등록합니다.
     func renderRemoteVideo(to renderer: RTCVideoRenderer) {
+        flipVideoRenderer(renderer)
+
         self.remoteVideoTrack?.add(renderer)
     }
 
+    /// 들어오는 화면에 좌우 반전을 적용합니다
+    private func flipVideoRenderer(_ renderer: RTCVideoRenderer) {
+        guard let renderedView = renderer as? UIView else { return }
+        renderedView.transform = CGAffineTransform(scaleX: -1.0, y: 1.0)
+    }
+
     private func configureAudioSession() {
         self.rtcAudioSession.lockForConfiguration()
         do {

PhotoGether/DataLayer/PhotoGetherNetwork/PhotoGetherNetwork/WebSocket/WebSocketClient.swift

@@ -1,7 +1,11 @@
 import Foundation
+import Combine
 
 public protocol WebSocketClient {
-    var delegate: WebSocketClientDelegate? { get set }
+    var delegates: [WebSocketClientDelegate] { get set }
+    var webSocketDidConnectPublisher: AnyPublisher<Void, Never> { get }
+    var webSocketDidDisconnectPublisher: AnyPublisher<Void, Never> { get }
+    var webSocketdidReceiveDataPublisher: AnyPublisher<Data, Never> { get }
 
     func connect()
     func send(data: Data)

PhotoGether/DataLayer/PhotoGetherNetwork/PhotoGetherNetwork/WebSocket/WebSocketClientDelegate.swift

@@ -1,5 +1,6 @@
 import Foundation
 
+@available(*, deprecated, message: "Publisher로 교체될 예정입니다.")
 public protocol WebSocketClientDelegate: AnyObject {
     func webSocketDidConnect(_ webSocket: WebSocketClient)
     func webSocketDidDisconnect(_ webSocket: WebSocketClient)