자, 커피 한 잔 챙겨왔어? 😄

오늘 얘기할 주제는 iOS/iPadOS의 멀티 윈도우(Multiple Windows)야.
쉽게 말하면 내 앱을 한 화면에 두 개, 세 개 띄우는 기능이지.

메모 앱에서 왼쪽엔 회의록, 오른쪽엔 할 일 목록.
사파리에서 창 두 개 띄워놓고 비교하는 그거.
"나도 내 앱에 저거 넣고 싶다!" 싶었던 적 있지?

근데 막상 시작하면 AppDelegate? SceneDelegate? UISceneSession? NSUserActivity? 하면서 멘붕이 오거든.
그래서 오늘 처음부터 끝까지, 순서대로 정리해줄게.

🎬 1. 왜 갑자기 Scene이라는 게 생겼을까?

옛날 iOS 앱은 구조가 단순했어.
앱 하나 = 화면 하나 = UIWindow 하나. 끝.

그래서 AppDelegate가 모든 걸 다 했지.
앱이 켜지면 application(_:didFinishLaunchingWithOptions:), 백그라운드 가면 applicationDidEnterBackground(_:).
앱 생명주기 = UI 생명주기였던 거야.

그런데 iOS 13 / iPadOS 13 (2019년)에서 애플이 사고를 쳤어.
"이제 앱 하나가 창을 여러 개 띄울 수 있다!" 라고 선언한 거지.

그래서 등장한 게 UIScene이야.

즉 구조가 이렇게 바뀐 거야.

[ UIApplication ]  ← 앱은 하나
      │
      ├── UISceneSession A ── UIWindowScene A ── UIWindow ── RootVC
      ├── UISceneSession B ── UIWindowScene B ── UIWindow ── RootVC
      └── UISceneSession C ── UIWindowScene C ── UIWindow ── RootVC

여기서 진짜 중요한 포인트 하나!
Scene이 여러 개여도 프로세스는 하나야.
메모리도 공유하고, 싱글톤도 공유해.
이거 모르고 static var currentUser 같은 걸로 화면 상태 관리하면… 창 두 개 띄우는 순간 지옥문이 열려. 😈

🗺️ 2. 전체 아키텍처 한눈에 보기

그림 보면 감 오지?
위는 하나, 가운데는 여러 개, 아래는 다시 하나.
이 구조를 머리에 박아두면 나머지는 전부 디테일이야.

⚙️ 3. 첫 단추 — Info.plist와 프로젝트 설정

멀티 윈도우는 코드보다 설정이 먼저야.
Xcode에서 타겟 → General → "Supports multiple windows" 체크박스 하나면 끝나긴 하는데,
실제로 Info.plist에 뭐가 들어가는지는 알아둬야 해.

<key>UIApplicationSceneManifest</key>
<dict>
  <key>UIApplicationSupportsMultipleScenes</key>
  <true/>
  <key>UISceneConfigurations</key>
  <dict>
    <key>UIWindowSceneSessionRoleApplication</key>
    <array>
      <dict>
        <key>UISceneConfigurationName</key>
        <string>Default Configuration</string>
        <key>UISceneDelegateClassName</key>
        <string>$(PRODUCT_MODULE_NAME).SceneDelegate</string>
        <key>UISceneStoryboardFile</key>
        <string>Main</string>
      </dict>
      <dict>
        <key>UISceneConfigurationName</key>
        <string>Editor Configuration</string>
        <key>UISceneDelegateClassName</key>
        <string>$(PRODUCT_MODULE_NAME).EditorSceneDelegate</string>
      </dict>
    </array>
  </dict>
</dict>

참고로 멀티 윈도우는 iPadOS와 macOS(Catalyst/Designed for iPad)에서만 실제로 동작해.
아이폰은 Scene 구조는 쓰지만 창은 항상 1개야. 이거 헷갈리지 마!

🧩 4. AppDelegate와 SceneDelegate 역할 나누기

AppDelegate는 "회사 전체", SceneDelegate는 "각 지점"

이렇게 비유하면 딱 이해돼.
회사 전체 방침(로그인 세션, DB 초기화, 푸시 등록)은 AppDelegate.
각 지점 인테리어(윈도우 생성, 화면 복원)는 SceneDelegate.

@main
final class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions options: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        DatabaseStack.shared.setup()   // 전역 1회 초기화
        return true
    }

    // 새 Scene이 필요할 때 어떤 설정을 쓸지 결정
    func application(_ application: UIApplication,
                     configurationForConnecting session: UISceneSession,
                     options: UIScene.ConnectionOptions) -> UISceneConfiguration {

        if session.role == .windowApplication,
           options.userActivities.first?.activityType == DocumentActivity.type {
            return UISceneConfiguration(name: "Editor Configuration", sessionRole: session.role)
        }
        return UISceneConfiguration(name: "Default Configuration", sessionRole: session.role)
    }

    // 사용자가 앱 스위처에서 창을 버렸을 때 → 저장된 데이터 정리
    func application(_ application: UIApplication,
                     didDiscardSceneSessions sessions: Set<UISceneSession>) {
        sessions.forEach { DraftStore.shared.removeDraft(for: $0.persistentIdentifier) }
    }
}

그리고 SceneDelegate 쪽.

final class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    func scene(_ scene: UIScene,
               willConnectTo session: UISceneSession,
               options: UIScene.ConnectionOptions) {

        guard let windowScene = scene as? UIWindowScene else { return }

        let window = UIWindow(windowScene: windowScene)

        // 1) 새 창 요청에 딸려온 activity
        // 2) 시스템이 복원해주는 stateRestorationActivity
        let activity = options.userActivities.first ?? session.stateRestorationActivity

        window.rootViewController = RootBuilder.make(from: activity)
        window.makeKeyAndVisible()
        self.window = window
    }

    // 창이 닫히기 직전, 상태를 activity에 담아 시스템에 맡긴다
    func stateRestorationActivity(for scene: UIScene) -> NSUserActivity? {
        (window?.rootViewController as? StateRestorable)?.currentActivity()
    }

    func sceneDidEnterBackground(_ scene: UIScene) {
        DraftStore.shared.flush()
    }
}

keyWindow 대신 이렇게 쓰자

extension UIViewController {
    var currentWindowScene: UIWindowScene? {
        view.window?.windowScene
    }
}

// 전역으로 찾아야 할 때 (최후의 수단)
let activeScene = UIApplication.shared.connectedScenes
    .compactMap { $0 as? UIWindowScene }
    .first { $0.activationState == .foregroundActive }

가능하면 "내가 속한 뷰에서 window를 타고 올라가는 방식"을 써.
전역 검색은 창이 여러 개일 때 엉뚱한 창을 잡을 수 있거든.

🚪 5. 진짜 새 창 띄우기 — requestSceneSessionActivation

이제 본론! 버튼 눌러서 창 띄우는 코드.

func openDocumentInNewWindow(_ document: Document) {
    let activity = NSUserActivity(activityType: DocumentActivity.type)
    activity.title = document.title
    activity.userInfo = ["documentID": document.id.uuidString]
    activity.targetContentIdentifier = document.id.uuidString  // 중복 창 방지 키

    UIApplication.shared.requestSceneSessionActivation(
        nil,                 // nil = 새 Scene 생성
        userActivity: activity,
        options: nil,
        errorHandler: { error in
            print("창 열기 실패: \(error)")
        }
    )
}

이미 열려 있는 창이면 새로 만들지 말자

같은 문서를 두 번 열면 사용자가 헷갈려.
그래서 중복 체크를 먼저 해주는 게 예의지. 🙇

func focusOrOpen(documentID: String) {
    let existing = UIApplication.shared.openSessions.first { session in
        session.stateRestorationActivity?.userInfo?["documentID"] as? String == documentID
    }

    let activity = DocumentActivity.make(id: documentID)
    let options = UIWindowScene.ActivationRequestOptions()
    options.requestingScene = view.window?.windowScene

    UIApplication.shared.requestSceneSessionActivation(
        existing,            // 있으면 그 창 활성화, 없으면 nil → 새 창
        userActivity: activity,
        options: options,
        errorHandler: nil
    )
}

창 닫기

if let session = view.window?.windowScene?.session {
    UIApplication.shared.requestSceneSessionDestruction(
        session,
        options: nil,
        errorHandler: nil
    )
}

참고로 requestSceneSessionDestruction을 쓰면
didDiscardSceneSessions가 호출되니까 임시 데이터 정리는 거기서 하면 돼.

🎒 6. NSUserActivity — 멀티 윈도우의 심장

여기가 제일 중요해. 진짜야.

새 창을 열 때 객체를 직접 넘길 수가 없어.
왜냐고? 시스템이 창을 언제든 종료했다가 나중에 복원할 수 있거든.
그때 메모리에 있던 객체는 이미 사라진 뒤야.

그래서 애플은 이렇게 정했어.
"창의 상태는 NSUserActivity라는 직렬화 가능한 봉투에 담아라."

Activity를 타입 안전하게 감싸기

enum DocumentActivity {
    static let type = "com.jaenung.editor.document"

    static func make(id: String, scrollOffset: CGFloat = 0) -> NSUserActivity {
        let a = NSUserActivity(activityType: type)
        a.title = "문서 편집"
        a.userInfo = ["documentID": id, "scroll": scrollOffset]
        a.targetContentIdentifier = id
        a.isEligibleForHandoff = true     // 맥/다른 기기로 이어받기
        return a
    }

    static func documentID(from activity: NSUserActivity?) -> String? {
        guard activity?.activityType == type else { return nil }
        return activity?.userInfo?["documentID"] as? String
    }
}

Info.plist에 activity 타입 등록

<key>NSUserActivityTypes</key>
<array>
  <string>com.jaenung.editor.document</string>
</array>

이거 빼먹으면 Handoff랑 일부 복원 동작이 조용히 안 먹혀. 진짜 조용히. 😑

🖐️ 7. 드래그 앤 드롭으로 창 꺼내기

iPadOS의 꽃이지.
목록에서 셀을 화면 가장자리로 쭉 끌면 창이 쪼개지는 그 동작.

구현 원리는 의외로 단순해.
NSItemProvider에 NSUserActivity를 실어서 던져주면 시스템이 알아서 창을 만들어줘.

extension DocumentListViewController: UITableViewDragDelegate {

    func tableView(_ tableView: UITableView,
                   itemsForBeginning session: UIDragSession,
                   at indexPath: IndexPath) -> [UIDragItem] {

        let doc = documents[indexPath.row]
        let activity = DocumentActivity.make(id: doc.id.uuidString)

        let provider = NSItemProvider(object: doc.title as NSString)
        provider.registerObject(activity, visibility: .all)   // ★ 핵심

        let item = UIDragItem(itemProvider: provider)
        item.localObject = doc          // 앱 내부 드롭 최적화용
        return [item]
    }
}

// viewDidLoad에서
tableView.dragDelegate = self
tableView.dragInteractionEnabled = true   // iPhone에서도 드래그 켜려면 필요

Context Menu에도 넣어주자

드래그는 발견하기 어려운 제스처라, 롱프레스 메뉴에도 같은 기능을 넣는 게 UX 정석이야.

func tableView(_ tableView: UITableView,
               contextMenuConfigurationForRowAt indexPath: IndexPath,
               point: CGPoint) -> UIContextMenuConfiguration? {

    guard UIApplication.shared.supportsMultipleScenes else { return nil }

    let doc = documents[indexPath.row]
    return UIContextMenuConfiguration(identifier: nil, previewProvider: nil) { _ in
        UIMenu(children: [
            UIAction(title: "새 창에서 열기",
                     image: UIImage(systemName: "square.on.square")) { [weak self] _ in
                self?.focusOrOpen(documentID: doc.id.uuidString)
            }
        ])
    }
}

UIApplication.shared.supportsMultipleScenes 체크 잊지 마!
아이폰에서 "새 창에서 열기"가 보이면 그건 버그야. 😅

🍏 8. SwiftUI로 하면 얼마나 편할까?

솔직히 말할게. 비교가 안 되게 편해.

@main
struct EditorApp: App {
    var body: some Scene {
        WindowGroup {
            DocumentListView()
        }
        .handlesExternalEvents(matching: ["document"])
    }
}

WindowGroup은 이름 그대로 "같은 종류의 창 묶음"이야.
사용자가 창을 여러 개 만들면 같은 뷰 계층이 각각 독립 상태로 생성돼.

SwiftUI에서 새 창 열기

struct DocumentRow: View {
    let document: Document
    @Environment(\.openURL) private var openURL
    @Environment(\.supportsMultipleWindows) private var supportsMulti

    var body: some View {
        HStack {
            Text(document.title)
            Spacer()
            if supportsMulti {
                Button {
                    openURL(URL(string: "myapp://document/\(document.id)")!)
                } label: {
                    Image(systemName: "square.on.square")
                }
            }
        }
    }
}

@main
struct EditorApp: App {
    var body: some Scene {
        WindowGroup {
            DocumentListView()
        }

        // 값 기반 창: 같은 값이면 기존 창을 재사용해준다
        WindowGroup(id: "editor", for: Document.ID.self) { $docID in
            DocumentDetailView(documentID: docID)
        }
    }
}

struct DocumentRow: View {
    let document: Document
    @Environment(\.openWindow) private var openWindow

    var body: some View {
        Button("새 창으로 열기") {
            openWindow(id: "editor", value: document.id)
        }
    }
}

봤지? 중복 창 방지까지 시스템이 알아서 해줘.
UIKit에서 openSessions 뒤지던 그 코드가 통째로 사라진 거야. 😭 (감격)

🧠 9. 멀티 윈도우에서 데이터 동기화하기

여기가 실무에서 제일 많이 깨지는 구간이야.

창 A에서 문서 제목을 바꿨는데, 창 B의 목록은 옛날 제목 그대로. 😱
이런 버그, 멀티 윈도우 지원하면 100% 만나게 돼.

핵심 원칙: Single Source of Truth

final class DocumentStore {
    static let shared = DocumentStore()

    private let subject = CurrentValueSubject<[Document], Never>([])
    var publisher: AnyPublisher<[Document], Never> { subject.eraseToAnyPublisher() }

    func update(_ doc: Document) {
        var list = subject.value
        if let i = list.firstIndex(where: { $0.id == doc.id }) { list[i] = doc }
        subject.send(list)      // 모든 창이 동시에 갱신됨
    }
}

규칙은 딱 하나야.
"뷰컨트롤러는 데이터를 소유하지 않는다. 구독할 뿐이다."
이걸 지키면 창이 10개가 돼도 안 깨져.

viewContext.automaticallyMergesChangesFromParent = true

📐 10. Stage Manager와 가변 창 크기 대응

iPadOS 16에서 Stage Manager가 등장하면서 판이 또 바뀌었어.
이제 창 크기가 사용자가 드래그하는 대로 자유롭게 변해.

예전엔 Slide Over / Split View의 정해진 비율만 대응하면 됐는데,
이제는 거의 모든 크기를 가정해야 해.

최소 크기 지정하기 (iOS 16+)

func scene(_ scene: UIScene, willConnectTo session: UISceneSession,
           options: UIScene.ConnectionOptions) {
    guard let ws = scene as? UIWindowScene else { return }

    if let geometry = ws.effectiveGeometry as? UIWindowSceneGeometry {
        print("현재 창 크기:", geometry.systemFrame)
    }

    let pref = UIWindowScene.GeometryPreferences.iOS(
        interfaceOrientations: .landscape
    )
    ws.requestGeometryUpdate(pref) { error in
        print("크기 변경 실패:", error)
    }
}

그리고 Info.plist에서 최소 크기를 정할 수도 있어.

<key>UILaunchScreen</key> ...
<key>UIApplicationSceneManifest</key>
<dict>
  <key>UIApplicationPreferredDefaultSceneSessionRole</key>
  <string>UIWindowSceneSessionRoleApplication</string>
</dict>

Size Class 기반 적응형 레이아웃

override func traitCollectionDidChange(_ previous: UITraitCollection?) {
    super.traitCollectionDidChange(previous)

    guard traitCollection.horizontalSizeClass != previous?.horizontalSizeClass else { return }

    if traitCollection.horizontalSizeClass == .compact {
        splitViewController?.preferredDisplayMode = .oneOverSecondary
    } else {
        splitViewController?.preferredDisplayMode = .oneBesideSecondary
    }
}

🧪 11. 디버깅 & 테스트 요령

멀티 윈도우는 재현이 어려운 버그가 많아.
그래서 테스트 루틴을 미리 정해두는 게 좋아.

Scene 로그 찍어두기

extension UIScene {
    var debugTag: String {
        "[\(session.persistentIdentifier.prefix(6))]"
    }
}

func sceneDidBecomeActive(_ scene: UIScene) {
    print("\(scene.debugTag) active | total scenes: \(UIApplication.shared.connectedScenes.count)")
}

persistentIdentifier는 창마다 고유하고, 창이 살아있는 동안 유지돼.
로그 앞에 이걸 붙여두면 "어느 창에서 난 로그인지" 바로 구분돼서 삶의 질이 올라가. 👍

🎨 12. UX 관점 — 언제 멀티 윈도우를 지원해야 할까?

기술적으로 가능하다고 다 넣는 게 정답은 아니야.
멀티 윈도우가 진짜 가치 있는 앱 유형은 정해져 있어.

반대로 단일 흐름 중심 앱(간단한 계산기, 결제 앱, 단순 뷰어)은
멀티 윈도우를 넣어도 사용자가 쓸 일이 거의 없어.
오히려 상태 동기화 버그만 늘어나지. 😇

🚀 13. 마이그레이션 로드맵

진심으로 조언 하나 할게.
2단계(전역 상태 제거)가 전체 작업의 70%야.

Scene 붙이는 건 반나절이면 끝나.
근데 "현재 선택된 항목"을 싱글톤에 박아둔 코드,
"화면 전환"을 AppDelegate에서 하던 코드,
이런 걸 정리하는 데 며칠이 걸려.

그래서 신규 프로젝트라면 처음부터 멀티 윈도우를 가정하고 설계하는 게 훨씬 싸게 먹혀.

🎯 마무리 — 정리하면 이것만 기억해

처음엔 "Scene이 뭐야, 왜 이렇게 복잡해" 싶었을 거야.
근데 한 번 구조를 이해하고 나면, 오히려 앱 아키텍처가 훨씬 깔끔해졌다는 걸 느끼게 돼.

왜냐면 멀티 윈도우를 지원하려면
어쩔 수 없이 데이터와 화면을 제대로 분리하게 되거든.
결국 좋은 설계로 끌려가게 되는 셈이지. 😌

그리고 요즘은 비전OS(visionOS)까지 나오면서
"여러 창을 공간에 띄우는" 경험이 더 중요해졌어.
Scene 기반 설계를 해두면 그쪽 확장도 자연스럽게 이어져.

더 깊은 iOS 아키텍처 이야기나 실무 코드 리뷰가 필요하면
재능넷의 개발 분야 전문가들에게 직접 물어보는 것도 좋은 방법이야.
혼자 삽질하는 시간보다 훨씬 빠르게 답이 나올 때가 많거든. 🙂

자, 이제 Xcode 켜고 "Supports multiple windows" 체크부터 해보자!
아이패드에서 내 앱 창이 두 개 뜨는 순간, 진짜 짜릿하다. ✨