03 · 운영체제와 프로세스

import Darwin

var threadList: thread_act_array_t?
var count: mach_msg_type_number_t = 0
// mach_task_self_가 곧 "이 앱 프로세스" = 현재 Mach task
let kr = task_threads(mach_task_self_, &threadList, &count)
if kr == KERN_SUCCESS, let threadList {
    print("이 앱 task의 커널 스레드 수: \(count)")
    // ⚠️ task_threads는 배열 메모리뿐 아니라 스레드마다 '커널 포트 send right'도 준다.
    //    포트를 반납하지 않으면 호출할 때마다 포트 이름이 누수되고, 반복하면
    //    "Exceeded system-wide per-process Port Limit"으로 앱이 죽는다.
    for i in 0..<Int(count) { mach_port_deallocate(mach_task_self_, threadList[i]) }
    vm_deallocate(mach_task_self_,
                  vm_address_t(UInt(bitPattern: threadList)),
                  vm_size_t(Int(count) * MemoryLayout<thread_t>.size))
}
// 관찰 지표: 앱 시작 직후엔 main + GCD/런타임 워커 몇 개 →
// URLSession/이미지 디코딩이 돌면 스레드 수가 늘었다 줄었다 한다.

import Foundation

// 스레드는 비싼 커널 자원이다. 보조 스레드 기본 스택 512KB, 메인 1MB.
// 수백 개를 만들면 스택만으로 수백 MB에 스케줄링 비용까지 붙는다.

// ❌ 작업 하나당 스레드 하나
func downloadAllBad(_ urls: [URL]) {
    for url in urls {
        Thread.detachNewThread {
            _ = try? Data(contentsOf: url)
        }
    }
}

// ✅ 작업만 던지고 스레드 관리는 런타임에 맡긴다
func downloadAll(_ urls: [URL]) async throws -> [Data] {
    try await withThrowingTaskGroup(of: Data.self) { group in
        for url in urls {
            group.addTask { try await URLSession.shared.data(from: url).0 }
        }
        var out: [Data] = []
        for try await d in group { out.append(d) }
        return out
    }
}

// 현재 이 프로세스의 커널 스레드 수를 직접 확인해 보면 차이가 보인다
func threadCount() -> Int {
    var count: mach_msg_type_number_t = 0
    var list: thread_act_array_t?
    guard task_threads(mach_task_self_, &list, &count) == KERN_SUCCESS, let list else { return 0 }
    // ① 스레드 포트 권한부터 반납 — 안 하면 호출마다 포트 누수
    for i in 0..<Int(count) { mach_port_deallocate(mach_task_self_, list[i]) }
    // ② 그다음 배열 메모리 해제
    vm_deallocate(mach_task_self_,
                  vm_address_t(UInt(bitPattern: list)),
                  vm_size_t(Int(count) * MemoryLayout<thread_t>.size))
    return Int(count)
}

// Thread를 직접 써야 하는 경우는 사실상 하나뿐이다:
// 스레드에 묶인 레거시(전용 RunLoop, 일부 C 라이브러리 컨텍스트)를 가둘 때.

import UIKit

// ❌ 런타임 규칙에만 의존 — 백그라운드에서 UI를 만지면 크래시나 미정의 동작
final class OldLoader {
    func load(into label: UILabel) {
        URLSession.shared.dataTask(with: url) { data, _, _ in
            label.text = "완료"          // 💥 백그라운드 스레드
        }.resume()
    }
    private let url = URL(string: "https://x")!
}

// ✅ @MainActor로 격리하면 잘못된 호출이 컴파일 에러가 된다
@MainActor
final class Loader {
    func load(into label: UILabel) async throws {
        let (data, _) = try await URLSession.shared.data(from: url)
        label.text = String(data: data, encoding: .utf8)   // ✅ 항상 메인
    }
    private let url = URL(string: "https://x")!
}

// ✅ 레거시 콜백 경계에서는 명시적으로 hop한다
func legacyBridge(_ label: UILabel) {
    someLegacyAPI { text in
        Task { @MainActor in
            label.text = text
        }
    }
}

// ✅ 개발 중 방어선 — 서드파티 콜백이 어느 스레드로 오는지 모를 때
func applyUnknownThread(_ label: UILabel, _ text: String) {
    dispatchPrecondition(condition: .onQueue(.main))
    label.text = text
}

// Xcode의 Main Thread Checker(Scheme → Diagnostics)를 켜 두면
// 백그라운드에서의 UIKit 호출을 런타임에 즉시 잡아 준다.

func someLegacyAPI(_ done: @escaping (String) -> Void) {}

import Foundation

// 같은 단어가 전혀 다른 두 개념을 가리킨다:
//   Mach task  = 커널 자원 컨테이너 (프로세스 하나 = task 하나)
//   Swift Task = 비동기 작업 단위 (수천 개가 스레드 몇 개 위에서 돈다)

// ❌ 이런 코드가 한 파일에 섞여 있으면 리뷰에서 반드시 혼선이 생긴다
func confusing() {
    let task = Task { await work() }              // Swift Task
    _ = task
    let t = mach_task_self_                       // Mach task
    _ = t
}

// ✅ 이름으로 층위를 드러낸다
func clear() {
    let refreshJob = Task { await work() }        // "Job" — 비동기 작업
    _ = refreshJob

    let currentMachTask = mach_task_self_         // "MachTask" — 커널 자원
    _ = currentMachTask
}

// ✅ 로그 문자열에서도 마찬가지
func logging() {
    let job = Task { await work() }
    print("[job] 시작")                            // Swift Task
    _ = job

    var info = task_vm_info_data_t()
    var count = mach_msg_type_number_t(
        MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<integer_t>.size)
    _ = withUnsafeMutablePointer(to: &info) {
        $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
            task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), $0, &count)
        }
    }
    print("[mach-task] footprint \(info.phys_footprint / 1024 / 1024)MB")
}

// 팀 컨벤션 예시:
//   Swift Task 변수  → xxxJob / xxxTask는 지양
//   Mach 관련        → machXxx 접두

func work() async {}

import Foundation

// 모드 전환(EL0→EL1)은 한 번당 수백 ns~µs다. 데이터 양보다 '횟수'가 비용을 정한다.

// ❌ 한 바이트마다 syscall — 1MB 파일이면 100만 번의 왕복
func readByteByByte(_ url: URL) throws -> Int {
    let fh = try FileHandle(forReadingFrom: url)
    defer { try? fh.close() }
    var count = 0
    while let b = try fh.read(upToCount: 1), !b.isEmpty { count += b.count }
    return count
}

// ✅ 큼직하게 읽는다 — 1MB 파일이면 read는 1~2번(+open·close)
func readBuffered(_ url: URL) throws -> Int {
    let fh = try FileHandle(forReadingFrom: url)
    defer { try? fh.close() }
    var count = 0
    while let chunk = try fh.read(upToCount: 1 << 20), !chunk.isEmpty {
        count += chunk.count
    }
    return count
}

// 차이를 직접 재 보면 자릿수가 다르다
func compare(_ url: URL) throws {
    let clock = ContinuousClock()
    let a = try clock.measure { _ = try readByteByByte(url) }
    let b = try clock.measure { _ = try readBuffered(url) }
    print("바이트 단위 \(a) vs 버퍼드 \(b)")
}

// 같은 원리가 쓰기·로그에도 적용된다
// ❌ 루프 안에서 write
// ✅ 메모리에 모았다가 한 번에
func writeLog(_ lines: [String], to url: URL) throws {
    let blob = lines.joined(separator: "\n")
    try blob.write(to: url, atomically: true, encoding: .utf8)
}

// 네트워크도 마찬가지다 — 작은 요청 100개보다 배치 1개가 거의 항상 빠르다

import Foundation

// 앱은 EL0에서 돈다. 커널 메모리도, 다른 앱의 메모리도 직접 볼 수 없다.
// "메모리에서 옆 앱 데이터를 읽자" 같은 발상은 하드웨어가 막는다.

// ❌ 다른 앱 컨테이너에 접근 시도 — 존재해도 열리지 않는다
func tryReadOtherApp() {
    let path = "/var/mobile/Containers/Data/Application/OTHER-UUID/Documents/db.sqlite"
    do {
        _ = try Data(contentsOf: URL(fileURLWithPath: path))
    } catch {
        print("차단됨: \(error)")     // MAC(샌드박스 프로필)이 open을 거부
    }
}

// ✅ 데이터를 나눠야 하면 OS가 제공하는 정식 통로를 쓴다
func sharedContainer() -> URL? {
    FileManager.default.containerURL(
        forSecurityApplicationGroupIdentifier: "group.com.company.app")
}

// ✅ 자격증명 공유는 Keychain access group
func sharedKeychainQuery() -> [String: Any] {
    [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccessGroup as String: "TEAMID.com.company.shared",
        kSecAttrAccount as String: "token"
    ]
}

// ✅ 다른 앱과의 상호작용은 URL Scheme / Universal Link / 공유 시트
func openPartnerApp() {
    if let url = URL(string: "partnerapp://open?ref=abc") {
        // UIApplication.shared.open(url)
        _ = url
    }
}

// 실무 함의: "권한을 우회하는 방법"을 찾는 대신
// 처음부터 App Group·Keychain group·확장을 전제로 아키텍처를 잡는다.

# open(2) syscall 스텁에 브레이크포인트
(lldb) breakpoint set -n open
(lldb) continue
# FileManager.default.copyItem(...) 이 실행되는 순간 멈춘다.
(lldb) bt    # 백트레이스: open ← ... ← Foundation ← 내 코드
# 관찰: Foundation 한 호출이 open/fstat/read/close로 분해됨

import Foundation

// FileManager.copyItem 한 줄 뒤에는 open/read/write/close가 줄줄이 깔린다.
// API가 편하다고 호출 횟수까지 공짜인 건 아니다.

// ❌ 루프에서 파일 속성을 매번 조회 — 파일 수 × syscall 수
func totalSizeSlow(_ urls: [URL]) throws -> Int {
    var total = 0
    for url in urls {
        let attrs = try FileManager.default.attributesOfItem(atPath: url.path)
        total += (attrs[.size] as? Int) ?? 0        // 파일마다 stat()
    }
    return total
}

// ✅ 한 번의 열거로 필요한 키를 함께 가져온다
func totalSizeFast(_ directory: URL) throws -> Int {
    let keys: [URLResourceKey] = [.fileSizeKey]
    let urls = try FileManager.default.contentsOfDirectory(
        at: directory, includingPropertiesForKeys: keys)
    return try urls.reduce(0) { sum, url in
        sum + (try url.resourceValues(forKeys: Set(keys)).fileSize ?? 0)
    }
}

// ✅ 디렉터리 순회는 enumerator에 키를 미리 지정하면 stat 횟수가 준다
func walk(_ root: URL) throws {
    let keys: [URLResourceKey] = [.isDirectoryKey, .fileSizeKey]
    guard let e = FileManager.default.enumerator(
        at: root, includingPropertiesForKeys: keys) else { return }
    for case let url as URL in e {
        let v = try url.resourceValues(forKeys: Set(keys))   // 캐시된 값을 읽는다
        _ = v.fileSize
    }
}

// 확인 방법: LLDB로 syscall에 브레이크포인트를 걸어 호출 횟수를 센다
//   (lldb) breakpoint set -n open
//   (lldb) breakpoint command add -o "bt 3" -o "continue"

import Foundation

// ❌ dlsym으로 문서화되지 않은 심볼을 부르는 코드
//    → App Store 심사 거부 + iOS 버전마다 깨진다
func privateSymbolCall() {
    guard let handle = dlopen(nil, RTLD_NOW) else { return }
    defer { dlclose(handle) }
    if let sym = dlsym(handle, "__undocumented_internal_api") {
        _ = sym            // 다음 iOS에서 사라지면 그날로 앱이 죽는다
    }
}

// ❌ 비공개 프레임워크 헤더를 복사해 쓰는 것도 같은 문제다
//    (심사 자동 스캐너가 심볼 이름으로 잡아낸다)

// ✅ 안정된 계약은 두 가지뿐이다: 공개 프레임워크와 공개 POSIX API
func supportedWays() throws {
    // ① 공개 프레임워크 (권장)
    let docs = try FileManager.default.url(
        for: .documentDirectory, in: .userDomainMask,
        appropriateFor: nil, create: true)
    _ = docs

    // ② 공개 POSIX — 문서화돼 있고 써도 된다
    let fd = open("/dev/null", O_RDONLY)
    if fd >= 0 { close(fd) }

    // ③ 공개 Darwin API
    print(ProcessInfo.processInfo.physicalMemory)
}

// ✅ 원하는 기능이 공개 API에 없다면
//    · Feedback Assistant로 요청하고
//    · 그동안은 다른 설계로 우회한다
//    (비공개 API로 우회하면 심사와 OS 업데이트라는 두 폭탄을 동시에 안는다)

// raw syscall 번호와 svc ABI 자체도 안정된 계약이 아니다 —
// 앱은 반드시 libSystem 래퍼(open/read/…)를 통해서만 접근해야 한다.

import UIKit
import BackgroundTasks

final class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    // ❌ 여기서 새 작업을 시작하면 곧 Suspended로 얼어 중간에 멈춘다
    func sceneDidEnterBackgroundBad(_ scene: UIScene) {
        Task { await syncEverything() }     // 몇 초 뒤 동결
    }

    // ✅ ① 짧은 마무리만 하고, 필요하면 유예 시간을 명시적으로 요청한다
    func sceneDidEnterBackground(_ scene: UIScene) {
        var bgTask: UIBackgroundTaskIdentifier = .invalid
        bgTask = UIApplication.shared.beginBackgroundTask(withName: "flush") {
            // 시간이 다 되면 여기가 불린다 — 반드시 정리하고 end를 부른다
            UIApplication.shared.endBackgroundTask(bgTask)
            bgTask = .invalid
        }

        Task {
            await store.flushPending()      // 수십 초 이내의 마무리 작업만
            UIApplication.shared.endBackgroundTask(bgTask)
            bgTask = .invalid
        }
    }

    // ✅ ② 긴 작업은 OS에 정식으로 예약한다
    func scheduleSync() {
        let request = BGProcessingTaskRequest(identifier: "com.app.sync")
        request.requiresNetworkConnectivity = true
        request.requiresExternalPower = false
        request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
        try? BGTaskScheduler.shared.submit(request)
    }
}

// AppDelegate에서 핸들러를 등록해 둬야 한다
func registerTasks() {
    BGTaskScheduler.shared.register(
        forTaskWithIdentifier: "com.app.sync", using: nil
    ) { task in
        Task {
            await syncEverything()
            task.setTaskCompleted(success: true)
        }
        task.expirationHandler = { /* 정리 */ }
    }
}

enum store { static func flushPending() async {} }
func syncEverything() async {}

import UIKit
import SQLite3

// suspend 중에 파일 락·SQLite 락·소켓을 쥐고 있으면 0xdead10cc로 종료된다.
// "다른 프로세스가 쓰려는데 얼어붙은 앱이 붙들고 있다"는 이유다.

final class Database {
    private var db: OpaquePointer?

    func open(_ path: String) {
        sqlite3_open(path, &db)
    }

    // ✅ 백그라운드 진입 전에 트랜잭션을 끝내고 연결을 닫는다
    func prepareForBackground() {
        if let db {
            sqlite3_exec(db, "COMMIT;", nil, nil, nil)     // 열린 트랜잭션 종료
            sqlite3_close_v2(db)                            // 락 해제
            self.db = nil
        }
    }
}

final class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    let database = Database()
    var fileHandle: FileHandle?
    var socket: FileHandle?

    func sceneDidEnterBackground(_ scene: UIScene) {
        // ① 쥐고 있던 것들을 순서대로 놓는다
        database.prepareForBackground()
        try? fileHandle?.close(); fileHandle = nil
        try? socket?.close();     socket = nil

        // ② Core Data라면 저장 후 컨텍스트를 비운다
        // try? viewContext.save(); viewContext.reset()
    }

    func sceneWillEnterForeground(_ scene: UIScene) {
        database.open(dbPath)          // 돌아올 때 다시 연다
    }

    private let dbPath = NSTemporaryDirectory() + "app.sqlite"
}

// ⚠️ 파일 보호 클래스가 .complete인 파일을 열어 둔 채 기기가 잠기면
//    접근이 막혀 같은 종류의 문제가 생긴다 — 잠금 전에 닫는 설계가 필요하다.

import Foundation
import BackgroundTasks

// Suspended 상태에서는 스레드가 한 톨의 CPU도 못 받는다.
// Timer·DispatchSourceTimer·Thread 어느 것도 진행되지 않는다.

// ❌ "백그라운드에서 5분마다 동기화" — 앱이 포그라운드일 때만 돈다
func brokenPeriodicSync() {
    Timer.scheduledTimer(withTimeInterval: 300, repeats: true) { _ in
        Task { await sync() }
    }
}

// ✅ ① 주기 작업은 OS에 맡긴다 (실행 시점은 시스템이 정한다)
func scheduleRefresh() {
    let request = BGAppRefreshTaskRequest(identifier: "com.app.refresh")
    request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
    try? BGTaskScheduler.shared.submit(request)
}

func handleRefresh(_ task: BGAppRefreshTask) {
    // ⚠️ 다음 예약은 지금 바로 걸어 둔다 — 안 그러면 다시는 안 불린다
    scheduleRefresh()

    let work = Task {
        await sync()
        task.setTaskCompleted(success: true)
    }
    task.expirationHandler = { work.cancel() }
}

// ✅ ② 서버가 먼저 알려야 하는 일이면 푸시(silent push)를 쓴다
//     content-available: 1 → application(_:didReceiveRemoteNotification:fetchCompletionHandler:)
//     (2-인자 버전은 iOS 10에서 deprecated고, 백그라운드 푸시 콜백이 아니다)

// ✅ ③ 포그라운드 복귀 시 '경과 시간'을 계산해 한 번에 따라잡는다
func catchUpOnForeground() async {
    let last = UserDefaults.standard.object(forKey: "lastSync") as? Date ?? .distantPast
    if Date().timeIntervalSince(last) > 300 {
        await sync()
        UserDefaults.standard.set(Date(), forKey: "lastSync")
    }
}

// ⚠️ BGTaskScheduler는 "언제 돌지"를 보장하지 않는다. 사용자 습관·배터리·
//    네트워크 상태에 따라 몇 시간 뒤일 수도, 아예 안 돌 수도 있다.
//    "정확히 N분마다"가 필요한 설계라면 그 요구사항 자체를 재검토해야 한다.

func sync() async {}

import UIKit

// applicationWillTerminate는 "올 수도 있는 보너스"다.
// Suspended 상태에서 시스템이 조용히 죽이면 절대 불리지 않는다.

final class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    // ✅ 여기가 '마지막으로 코드를 돌릴 수 있는 것이 보장된' 지점이다
    func sceneDidEnterBackground(_ scene: UIScene) {
        DraftStore.shared.saveAll()                    // 작성 중이던 글
        UserDefaults.standard.set(scrollOffset, forKey: "feed.offset")
        try? CoreDataStack.shared.viewContext.save()
    }

    // ⚠️ 여기에만 의존하면 대부분의 종료에서 저장이 날아간다
    func sceneDidDisconnect(_ scene: UIScene) {
        // 보조 수단으로만 취급
    }

    private var scrollOffset: Double = 0
}

// ✅ 더 안전한 설계: 입력 중에 주기적으로 draft를 남긴다
@MainActor
final class ComposeViewModel {
    private var saveTask: Task<Void, Never>?
    var text: String = "" { didSet { scheduleAutosave() } }

    private func scheduleAutosave() {
        saveTask?.cancel()
        saveTask = Task {
            try? await Task.sleep(for: .seconds(2))    // 디바운스
            guard !Task.isCancelled else { return }
            DraftStore.shared.save(text)
        }
    }
}

enum DraftStore {
    static let shared = DraftStoreImpl()
}
struct DraftStoreImpl {
    func saveAll() {}
    func save(_ text: String) {}
}
enum CoreDataStack {
    static let shared = CoreDataStackImpl()
}
struct CoreDataStackImpl {
    struct Context { func save() throws {} }
    var viewContext: Context { Context() }
}

import UIKit

// 사용자에게는 Suspended였는지 Terminated였는지가 보이지 않아야 한다.
// 둘 다 "아까 보던 그 자리"로 돌아와야 한다.

// ✅ ① 무엇을 복원할지 값 타입으로 정의한다
struct FeedState: Codable {
    var scrollOffset: Double
    var selectedFilter: String
    var draftText: String
}

// ✅ ② 백그라운드 진입 때 저장
final class FeedViewController: UIViewController {
    private var filter = "all"
    private var draft = ""

    func persist() {
        let state = FeedState(scrollOffset: tableView.contentOffset.y,
                              selectedFilter: filter,
                              draftText: draft)
        if let data = try? JSONEncoder().encode(state) {
            UserDefaults.standard.set(data, forKey: "feed.state")
        }
    }

    // ✅ ③ 실행 시 복원 — cold launch든 warm resume이든 같은 경로
    func restore() {
        guard let data = UserDefaults.standard.data(forKey: "feed.state"),
              let state = try? JSONDecoder().decode(FeedState.self, from: data)
        else { return }

        filter = state.selectedFilter
        draft = state.draftText
        // 레이아웃이 끝난 뒤 오프셋을 적용해야 실제로 반영된다
        view.layoutIfNeeded()
        tableView.setContentOffset(CGPoint(x: 0, y: state.scrollOffset), animated: false)
    }

    private let tableView = UITableView()
}

// ✅ ④ UIKit의 정식 메커니즘을 쓰면 시스템이 시점을 관리해 준다
//     · UISceneDelegate.stateRestorationActivity(for:)
//     · scene(_:willConnectTo:options:) 의 session.stateRestorationActivity
// SwiftUI라면 @SceneStorage가 같은 역할을 한다.

import UIKit
import os.signpost

// 종료 후 재실행(cold launch)이 사용자가 체감하는 "느린 앱"의 주범이다.
// 감으로 고치지 말고 구간을 나눠 측정한다.

let launchLog = OSLog(subsystem: "com.app.launch", category: .pointsOfInterest)

@main
final class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(
        _ app: UIApplication,
        didFinishLaunchingWithOptions options: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        os_signpost(.begin, log: launchLog, name: "didFinishLaunching")
        defer { os_signpost(.end, log: launchLog, name: "didFinishLaunching") }

        // ✅ 첫 화면에 필요 없는 초기화는 전부 뒤로 미룬다
        Task.detached(priority: .utility) {
            await Analytics.configure()
            await RemoteConfig.fetch()
        }

        // ❌ 여기서 동기 I/O·DB 마이그레이션·큰 JSON 파싱을 하면
        //    워치독 감시가 특히 엄격한 구간이라 hang이 아니라 강제 종료가 된다
        return true
    }
}

// ✅ 예산을 코드로 못 박고 회귀를 잡는다
func assertLaunchBudget(_ elapsed: Duration) {
    let budget = Duration.milliseconds(400)
    if elapsed > budget {
        assertionFailure("콜드 런치 예산 초과: \(elapsed) > \(budget)")
    }
}

/*  측정 도구
      · Instruments → App Launch 템플릿 (pre-main / post-main 구간 분리)
      · DYLD_PRINT_STATISTICS는 iOS 15의 새 dyld(dyld4)부터 제거되어 아무것도 출력하지 않는다.
        무엇이 로드되고 어떤 초기화가 도는지는 DYLD_PRINT_LIBRARIES / DYLD_PRINT_INITIALIZERS로 본다
      · MetricKit의 MXAppLaunchMetric     (실사용자 분포, p50/p90)          */

enum Analytics { static func configure() async {} }
enum RemoteConfig { static func fetch() async {} }

import os

// 이 프로세스가 죽기 전까지 더 쓸 수 있는 대략적 바이트
let headroom = os_proc_available_memory()
print("남은 여유: \(headroom / 1024 / 1024) MB")

// 임계에 다가가면 UIKit이 이 콜백을 준다 → 캐시 비우기
override func didReceiveMemoryWarning() {
    super.didReceiveMemoryWarning()
    imageCache.removeAll()   // 여기서 안 비우면 다음 차례는 jetsam
}

import UIKit
import ImageIO

// jetsam은 무작위가 아니다. 우선순위 밴드 안에서 '많이 쓰는 놈'부터 죽는다.

// ✅ ① 이미지는 원본 픽셀이 아니라 표시 크기로 디코딩한다
func thumbnail(_ url: URL, size: CGSize, scale: CGFloat) -> UIImage? {
    let srcOpt = [kCGImageSourceShouldCache: false] as CFDictionary
    guard let src = CGImageSourceCreateWithURL(url as CFURL, srcOpt) else { return nil }
    let opt = [
        kCGImageSourceCreateThumbnailFromImageAlways: true,
        kCGImageSourceShouldCacheImmediately: true,
        kCGImageSourceThumbnailMaxPixelSize: max(size.width, size.height) * scale
    ] as CFDictionary
    return CGImageSourceCreateThumbnailAtIndex(src, 0, opt).map(UIImage.init)
}

// ✅ ② 화면 밖 캐시는 경고 때 비운다
final class Screen: UIViewController {
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        ThumbCache.shared.removeAll()
        offscreenSnapshots.removeAll()
    }
    private var offscreenSnapshots: [UIImage] = []
}

// ✅ ③ 큰 작업 전에 남은 예산을 확인하고 규모를 조절한다
func safeBatchSize(itemBytes: Int) -> Int {
    let remaining = os_proc_available_memory()
    let usable = Int(Double(remaining) * 0.5)     // 절반만 쓴다
    return max(1, usable / max(1, itemBytes))
}

// ✅ ④ 사후 확인 — Xcode Organizer의 Jetsam event reports에서
//    per-process-limit(내 앱이 상한 초과) vs vm-pageshortage(시스템 전체 부족)를 구분한다

enum ThumbCache {
    static let shared = ThumbCacheImpl()
}
struct ThumbCacheImpl { func removeAll() {} }

import UIKit

// watchdog(0x8badf00d)은 "메인이 너무 오래 응답 없음"으로 앱을 죽인다.
// 특히 런치·화면 전환·백그라운드 전환 구간에서 감시가 엄격하다.

// ❌ 메인에서 큰 파싱 + 동기 I/O
final class BadViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        let data = try! Data(contentsOf: bigURL)                 // 동기 I/O
        items = try! JSONDecoder().decode([Item].self, from: data)  // 큰 파싱
    }
    private var items: [Item] = []
    private let bigURL = URL(fileURLWithPath: "/big.json")
}

// ✅ 무거운 일은 메인 밖에서, 반영만 메인에서
@MainActor
final class FeedViewController: UIViewController {
    private var items: [Item] = []

    override func viewDidLoad() {
        super.viewDidLoad()
        Task { await load() }
    }

    private func load() async {
        let decoded: [Item] = await Task.detached(priority: .userInitiated) {
            guard let data = try? Data(contentsOf: bigURL) else { return [] }
            return (try? JSONDecoder().decode([Item].self, from: data)) ?? []
        }.value

        items = decoded                 // ✅ 메인에서는 반영만
        tableView.reloadData()
    }

    private let tableView = UITableView()
}

// ✅ 메인 블로킹을 개발 중에 자동으로 잡는 감시자
final class MainThreadWatchdog {
    private var timer: DispatchSourceTimer?

    func start(threshold: TimeInterval = 0.25) {
        let t = DispatchSource.makeTimerSource(queue: .global(qos: .utility))
        t.schedule(deadline: .now(), repeating: .milliseconds(100))
        t.setEventHandler {
            // 지역 var를 두 실행 흐름이 나눠 쓰면 데이터 레이스이고,
            // main.async의 클로저는 @Sendable이라 Swift 6에서는 컴파일 에러다.
            let responded = OSAllocatedUnfairLock(initialState: false)
            DispatchQueue.main.async { responded.withLock { $0 = true } }
            Thread.sleep(forTimeInterval: threshold)
            if !responded.withLock({ $0 }) { print("⚠️ 메인 스레드 \(threshold)초 이상 정지") }
        }
        t.resume()
        timer = t
    }
}

struct Item: Decodable {}
let bigURL = URL(fileURLWithPath: "/big.json")

import UIKit
import SQLite3

// 0xdead10cc = "dead lock". suspend 중에 시스템 자원(파일 락, SQLite 락,
// 보호된 파일)을 쥐고 있으면 그 이유로 종료된다.

final class Store {
    private var db: OpaquePointer?
    private var openTransaction = false
    private var lockFile: FileHandle?

    func beginBatch() {
        sqlite3_exec(db, "BEGIN;", nil, nil, nil)
        openTransaction = true
    }

    // ✅ 백그라운드 진입 시 반드시 호출한다
    func prepareForSuspension() {
        // ① 열린 트랜잭션을 닫는다 — 이게 가장 흔한 원인이다
        if openTransaction {
            sqlite3_exec(db, "COMMIT;", nil, nil, nil)
            openTransaction = false
        }

        // ② WAL 체크포인트로 -wal 파일을 정리한다
        sqlite3_exec(db, "PRAGMA wal_checkpoint(TRUNCATE);", nil, nil, nil)

        // ③ 파일 락·핸들을 놓는다
        try? lockFile?.close()
        lockFile = nil

        // ④ 연결 자체를 닫는다
        if let db { sqlite3_close_v2(db); self.db = nil }
    }
}

final class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    let store = Store()

    func sceneDidEnterBackground(_ scene: UIScene) {
        store.prepareForSuspension()
    }
}

// ⚠️ 함정: 백그라운드에서 '조금만 더' 하려고 beginBackgroundTask를 쓰면서
//    그 안에서 트랜잭션을 새로 열면, 유예 시간이 끝날 때 같은 상태가 된다.
//    유예 작업도 반드시 endBackgroundTask 전에 정리를 끝내야 한다.

// 진단: 크래시 리포트의 Exception Codes에 0xdead10cc가 찍히고,
//       Termination Description에 어떤 자원인지("SQLite file lock" 등)가 나온다.

// 내 컨테이너 홈 — 접근 OK
print(NSHomeDirectory())
// 예: /var/mobile/Containers/Data/Application/<UUID>

// 컨테이너 밖은 차단 — 존재해도 못 읽음
let outside = "/var/mobile/Library/Preferences/com.apple.springboard.plist"
do {
    _ = try Data(contentsOf: URL(fileURLWithPath: outside))
} catch {
    print("차단됨: \(error)")   // MAC 정책이 open을 거부
}

import Foundation

// 컨테이너 UUID는 앱 업데이트·재설치 때 바뀐다. 저장해 두면 다음 실행에서 깨진다.

// ❌ 절대 경로를 상수로
let badPath = "/var/mobile/Containers/Data/Application/1A2B-3C4D/Documents/db.sqlite"

// ❌ 더 흔한 실수: 전체 URL을 UserDefaults·DB에 저장
func saveBad(_ url: URL) {
    UserDefaults.standard.set(url.path, forKey: "dbPath")   // 다음 실행에 무효
}

// ✅ 매번 시스템에 물어본다
func databaseURL() throws -> URL {
    let appSupport = try FileManager.default.url(
        for: .applicationSupportDirectory, in: .userDomainMask,
        appropriateFor: nil, create: true)
    return appSupport.appendingPathComponent("db.sqlite")
}

// ✅ 저장해야 한다면 '컨테이너 기준 상대 경로'만 저장한다
func saveRelative(_ url: URL) throws {
    let docs = try FileManager.default.url(
        for: .documentDirectory, in: .userDomainMask,
        appropriateFor: nil, create: true)
    let relative = url.path.replacingOccurrences(of: docs.path + "/", with: "")
    UserDefaults.standard.set(relative, forKey: "note.relativePath")
}

func resolveRelative() throws -> URL? {
    guard let rel = UserDefaults.standard.string(forKey: "note.relativePath")
    else { return nil }
    let docs = try FileManager.default.url(
        for: .documentDirectory, in: .userDomainMask,
        appropriateFor: nil, create: true)
    return docs.appendingPathComponent(rel)
}

// ✅ 사용자가 고른 외부 파일은 security-scoped bookmark로 저장한다
func bookmark(_ url: URL) throws -> Data {
    try url.bookmarkData(options: .minimalBookmark,
                         includingResourceValuesForKeys: nil, relativeTo: nil)
}

import Foundation

// 앱과 확장(위젯·공유시트·알림)은 서로 다른 프로세스이고 컨테이너도 분리돼 있다.
// 임의 IPC는 막혀 있으므로 OS가 제공하는 통로를 써야 한다.

// ✅ ① 파일·DB 공유 — App Group 컨테이너 (entitlement 필요)
enum SharedStorage {
    static let groupID = "group.com.company.app"

    static var container: URL? {
        FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: groupID)
    }

    static var databaseURL: URL? {
        container?.appendingPathComponent("shared.sqlite")
    }
}

// ✅ ② 설정 공유 — App Group을 스위트 이름으로 쓰는 UserDefaults
extension UserDefaults {
    static let shared = UserDefaults(suiteName: SharedStorage.groupID)!
}

func writeSharedFlag() {
    UserDefaults.shared.set(true, forKey: "widget.enabled")
}

// ✅ ③ 자격증명 공유 — Keychain access group
func sharedTokenQuery(account: String) -> [String: Any] {
    [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccessGroup as String: "TEAMID.com.company.shared",
        kSecAttrAccount as String: account,
        // 확장이 잠금 상태에서도 읽어야 하면 접근성도 맞춰야 한다
        kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlock
    ]
}

/*  entitlement에 반드시 선언해야 한다 (양쪽 타깃 모두):
      com.apple.security.application-groups → group.com.company.app
      keychain-access-groups                → $(AppIdentifierPrefix)com.company.shared

    ⚠️ App Group 컨테이너의 SQLite를 앱과 확장이 동시에 쓰면 락 경합이 생긴다.
       WAL 모드를 켜고, 쓰기는 한쪽으로 몰거나 조율 계층을 둔다.                */

import Foundation
import AVFoundation
import CoreLocation

// entitlement·권한은 많을수록 심사 리스크와 프라이버시 라벨 부담이 커진다.
// 최소 권한 원칙은 보안 원칙이자 출시 실무다.

// ✅ ① 권한은 '실제로 그 기능을 쓰는 순간'에 요청한다
final class CameraFeature {
    func startScanning() async -> Bool {
        // 앱 시작 시가 아니라, 사용자가 스캔 버튼을 눌렀을 때
        await AVCaptureDevice.requestAccess(for: .video)
    }
}

// ✅ ② 정밀도가 낮아도 되면 낮은 권한을 고른다
final class NearbyStores: NSObject, CLLocationManagerDelegate {
    private let manager = CLLocationManager()

    func request() {
        // 항상 허용이 아니라 사용 중 허용
        manager.requestWhenInUseAuthorization()
        // 정확한 위치가 필요 없으면 애초에 '대략적 위치' 권한만 요청한다
        // (Info.plist에 NSLocationDefaultAccuracyReduced = YES, 또는 아래 상수)
        manager.desiredAccuracy = kCLLocationAccuracyReduced
        // 참고: kCLLocationAccuracyKilometer 같은 값은 권한 수준이 아니라
        //       받을 데이터의 정밀도·배터리 트레이드오프 설정이다
    }
}

// ✅ ③ Info.plist 사용 설명 문구는 '왜 필요한지'를 구체적으로 적는다
//     (심사에서 거부되는 가장 흔한 이유 중 하나가 모호한 설명이다)
//     NSCameraUsageDescription:
//       "영수증을 촬영해 지출 내역으로 자동 등록하기 위해 카메라를 사용합니다."

// ✅ ④ 주기적으로 미사용 권한을 정리한다
//     · Info.plist의 Usage Description 중 코드에서 안 쓰는 것
//     · entitlements의 App Group·Keychain group 중 실제 공유가 없는 것
//     · Background Modes 중 실제로 안 쓰는 항목
//
//   확인:  codesign -d --entitlements - MyApp.app
//          grep -r "UsageDescription" Info.plist

// ⚠️ Background Modes를 켜 두고 실제로 쓰지 않으면 심사에서 지적된다.
//    "필요해 보여서" 미리 켜 두지 않는다.