Manga Kotoba, Part 5: SwiftUI Polish, StoreKit Paywall, and Shipping to the App Store

Five parts, seven months, one shipped app. This is the finale of the Manga Kotoba series — the one where we stop building and start shipping. We'll polish the SwiftUI layer, wire up StoreKit 2 for subscriptions, fight our way through App Store review, and reflect on what it all meant.

--- ## 1. Where We Left Off The app was working at the end of Part 4 — you could sign in, browse manga, study vocabulary cards with spaced repetition. But "working" and "App Store ready" are not the same thing. Missing: monetisation, a real onboarding flow, polished animations, and the courage to actually submit. --- ## 2. SwiftUI Component Gallery {: class="marginalia" } SwiftUI previews in Xcode 15+ are dramatically faster than the old simulator-based ones. I ran the canvas at 1× on a Mac Studio and got near-instant refreshes for most components. Below is an interactive mock of the four main screens. Click the tab bar icons to switch. This runs entirely in the browser to give you a feel for the component architecture. --- ## 3. The Swipe-to-Know Gesture Getting swipe gestures right in SwiftUI took three iterations. ### Attempt 1: onTapGesture

// ❌ Wrong — no directional info
VocabCardView(card: card)
    .onTapGesture {
        // We know it was tapped, but left or right?
        viewModel.markKnown(card)
    }

Obvious in hindsight. `onTapGesture` gives you a tap location, but we need direction. ### Attempt 2: DragGesture with .onEnded

// ⚠️ Better, but no real-time feedback
VocabCardView(card: card)
    .gesture(
        DragGesture()
            .onEnded { value in
                if value.translation.width > 50 {
                    viewModel.markKnown(card)
                } else if value.translation.width < -50 {
                    viewModel.markSkipped(card)
                }
            }
    )

Works, but the card doesn't visually tilt while dragging. Feels unresponsive. ### Final: DragGesture with .onChanged + .onEnded {: class="marginalia" } The `.onChanged` closure fires every time the finger moves. Combining it with `withAnimation` keeps SwiftUI's layout engine happy and avoids dropped frames. On a real device this stays at 120 fps.

struct SwipeableCard: View {
    let card: VocabCard
    var onSwipe: (SwipeDirection) -> Void

    @State private var dragOffset: CGSize = .zero
    @State private var isDragging = false

    private var rotation: Double {
        Double(dragOffset.width / 20)
    }
    private var swipeIndicator: SwipeDirection? {
        if dragOffset.width > 60 { return .right }
        if dragOffset.width < -60 { return .left }
        return nil
    }

    var body: some View {
        ZStack {
            cardContent
            if let dir = swipeIndicator {
                SwipeLabel(direction: dir)
                    .transition(.opacity)
            }
        }
        .rotationEffect(.degrees(rotation))
        .offset(dragOffset)
        .gesture(
            DragGesture()
                .onChanged { value in
                    withAnimation(.interactiveSpring()) {
                        dragOffset = value.translation
                        isDragging = true
                    }
                }
                .onEnded { value in
                    let threshold: CGFloat = 100
                    if value.translation.width > threshold {
                        flyOut(to: .right)
                    } else if value.translation.width < -threshold {
                        flyOut(to: .left)
                    } else {
                        withAnimation(.spring()) { dragOffset = .zero }
                    }
                    isDragging = false
                }
        )
    }

    private func flyOut(to direction: SwipeDirection) {
        let xTarget: CGFloat = direction == .right ? 500 : -500
        withAnimation(.easeIn(duration: 0.25)) {
            dragOffset = CGSize(width: xTarget, height: 0)
        }
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
            onSwipe(direction)
        }
    }
}

### Interactive Drag Demo Drag the card below left or right (or click the buttons): --- ## 4. StoreKit 2 Paywall {: class="marginalia" } StoreKit 2 was a complete rewrite released with iOS 15. The old StoreKit required parsing XML receipts and doing server-side OpenSSL verification. StoreKit 2 uses JWS tokens and async/await — it's dramatically simpler. The freemium model: **3 manga free, unlimited with Pro** ($2.99/month or $19.99/year). ### Fetching Products

actor StoreService {
    static let productIDs = [
        "com.mangakotoba.pro.monthly",
        "com.mangakotoba.pro.yearly"
    ]

    private(set) var products: [Product] = []

    func loadProducts() async throws {
        products = try await Product.products(for: Self.productIDs)
    }
}

### Purchasing and Handling Result

func purchase(_ product: Product) async {
    do {
        let result = try await product.purchase()
        switch result {
        case .success(let verification):
            switch verification {
            case .verified(let transaction):
                await transaction.finish()
                await updateProStatus()
            case .unverified:
                // JWS signature check failed — treat as no purchase
                break
            }
        case .userCancelled, .pending:
            break
        @unknown default:
            break
        }
    } catch {
        print("Purchase error: " + error.localizedDescription)
    }
}

### Checking Active Entitlements

func updateProStatus() async {
    var isActive = false
    for await result in Transaction.currentEntitlements {
        if case .verified(let tx) = result,
           tx.productType == .autoRenewableSubscription {
            isActive = true
        }
    }
    await MainActor.run { isPro = isActive }
}

No more OpenSSL. No more base64-decoding receipt blobs. The entire entitlement check is four lines of async Swift. ### Interactive Paywall Demo --- ## 5. Onboarding Flow {: class="marginalia" } Apple's review team has gotten faster — average review time in 2025 is under 24 hours for most apps. But the first submission of a new app often takes 2-3 days as a human reviewer looks at it more carefully. First-launch onboarding shows exactly once and then is dismissed forever. Five screens. The SwiftUI implementation uses a `PageTabViewStyle` inside a `TabView`, which gives us the swipe-between-pages animation for free:

TabView(selection: $onboardingPage) {
    WelcomeView().tag(0)
    MangaPickerView().tag(1)
    DailyGoalView().tag(2)
    NotificationsView().tag(3)
    ReadyView().tag(4)
}
.tabViewStyle(.page(indexDisplayMode: .never))
.fullScreenCover(isPresented: $showOnboarding) { ... }

The `showOnboarding` flag is stored in `@AppStorage("hasCompletedOnboarding")` — it defaults to `false` on first launch and is set to `true` when the user taps "Start". --- ## 6. App Store Submission Horror Stories The app was ready in early April. Submission was… not clean. ### Rejection 1: Missing NSCameraUsageDescription ### Rejection 2: "App Does Not Function As Advertised" ### The 3-Day Human Review Wait After automated checks passed (usually ~30 minutes), we sat in "Waiting for Review" for 68 hours before a human looked at it. This is normal for first-time app submissions. After that initial friction, subsequent updates reviewed in under 8 hours. ### Rejection 3: Screenshot Metadata Mismatch ### Lessons Learned - **Test App Review accounts on production before submitting.** This is obvious in retrospect. - **Audit your dependency tree** for privacy manifest keys. Even if *your* code doesn't use a capability, your dependencies might declare one. - **Screenshots should be taken from the final binary**, not mockups. Automate this if you can (Fastlane's `snapshot` tool). - **Metadata changes don't require binary resubmission**, but they still go through review. Budget time. - **Keep an App Store rejection log.** It becomes an invaluable reference for the next app. --- ## 7. "Would I Do It Again?" Retrospective {: class="marginalia" } The App Store takes a 30% cut (15% for small developers under $1M/year revenue via the Small Business Program). For a $2.99/month subscription, you net ~$2.09 after Apple's cut. ### What I'm Proud Of - **The vocabulary extraction pipeline** — parsing manga pages, normalising Japanese text, linking to JLPT word lists, and surfacing the most useful vocabulary per chapter. This is the product's actual moat. - **The SwiftUI architecture** — clean separation between `View`, `ViewModel`, and the async `APIClient`. Easy to test, easy to extend. - **Actually shipping.** 95% of side projects don't make it to the App Store. This one did. ### What I'd Change - **Earlier monetisation thinking.** StoreKit integration came in at the very end. It would have been easier to design the feature gates earlier in the codebase. - **Expo/React Native instead of SwiftUI?** Considered it. Decided against it for the "real native" experience. I don't regret it, but for a solo developer who needs Android too, RN is worth the trade-off. - **Keep Symfony?** Yes, without question. The API Platform overhead is real — writing resource classes and state processors feels verbose at first — but the auto-generated OpenAPI docs and the Symfony ecosystem (Messenger, Doctrine, the security system) were worth every line. --- ## 8. What's Next ---

Thanks for following along through all five parts. If you built something with this series, I'd love to hear about it — @malukenho on Twitter/X.