Rork Max で Share Extension を実装する — iOS の共有シートにアプリを表示させる

import UIKit
import SwiftUI
import UniformTypeIdentifiers
 
class ShareViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
 
        // SwiftUI ビューを埋め込む
        let extensionContext = self.extensionContext
        let host = UIHostingController(
            rootView: ShareView(
                onSave: { [weak self] payload in
                    self?.savePayload(payload)
                },
                onCancel: { [weak self] in
                    self?.cancel()
                }
            )
        )
        addChild(host)
        host.view.frame = view.bounds
        host.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        view.addSubview(host.view)
        host.didMove(toParent: self)
    }
 
    private func savePayload(_ payload: SharePayload) {
        // App Group の UserDefaults に保存
        let defaults = UserDefaults(
            suiteName: "group.net.rorklab.readlater.shared"
        )
        var queue = defaults?.array(forKey: "pendingItems") as? [[String: String]] ?? []
        queue.append([
            "url": payload.url.absoluteString,
            "title": payload.title,
            "savedAt": ISO8601DateFormatter().string(from: Date())
        ])
        defaults?.set(queue, forKey: "pendingItems")
 
        // メインアプリを起動（共有完了後）
        let scheme = "readlater://import?count=\(queue.count)"
        if let url = URL(string: scheme) {
            openURL(url)
        }
        extensionContext?.completeRequest(returningItems: nil)
    }
 
    private func cancel() {
        let error = NSError(domain: "ShareExt", code: 0, userInfo: nil)
        extensionContext?.cancelRequest(withError: error)
    }
 
    // App Extension から URL Scheme を開くためのヘルパー
    @objc private func openURL(_ url: URL) -> Bool {
        var responder: UIResponder? = self
        while responder != nil {
            if let app = responder as? UIApplication {
                return app.perform(#selector(openURL(_:)), with: url) != nil
            }
            responder = responder?.next
        }
        return false
    }
}

struct SharePayload {
    let url: URL
    let title: String
}
 
struct ShareView: View {
    let onSave: (SharePayload) -> Void
    let onCancel: () -> Void
 
    @State private var payload: SharePayload?
    @State private var loadError: String?
 
    var body: some View {
        NavigationStack {
            VStack(spacing: 16) {
                if let p = payload {
                    Text(p.title)
                        .font(.headline)
                        .lineLimit(2)
                    Text(p.url.absoluteString)
                        .font(.caption)
                        .foregroundStyle(.secondary)
                        .lineLimit(1)
                } else if let err = loadError {
                    Text(err).foregroundStyle(.red)
                } else {
                    ProgressView("読み込み中…")
                }
            }
            .padding()
            .toolbar {
                ToolbarItem(placement: .cancellationAction) {
                    Button("キャンセル") { onCancel() }
                }
                ToolbarItem(placement: .confirmationAction) {
                    Button("保存") {
                        if let p = payload { onSave(p) }
                    }
                    .disabled(payload == nil)
                }
            }
            .task { await loadShared() }
        }
    }
 
    private func loadShared() async {
        // ShareViewController から渡される extensionContext を取得する別経路を使う
        // ここでは Notification 経由で取得する実装にしている例
    }
}

extension ShareViewController {
    func extractURLAndTitle(completion: @escaping (SharePayload?) -> Void) {
        guard let item = extensionContext?.inputItems.first as? NSExtensionItem,
              let provider = item.attachments?.first else {
            completion(nil)
            return
        }
 
        let urlType = UTType.url.identifier
        if provider.hasItemConformingToTypeIdentifier(urlType) {
            provider.loadItem(forTypeIdentifier: urlType, options: nil) { (data, error) in
                let url: URL? = (data as? URL) ??
                                (data as? String).flatMap { URL(string: $0) }
                let title = item.attributedContentText?.string ?? url?.absoluteString ?? ""
                if let u = url {
                    DispatchQueue.main.async {
                        completion(SharePayload(url: u, title: title))
                    }
                } else {
                    DispatchQueue.main.async { completion(nil) }
                }
            }
        } else {
            completion(nil)
        }
    }
}

import SwiftUI
import SwiftData
 
@MainActor
final class PendingImporter: ObservableObject {
    @Published var importedCount: Int = 0
    private let suite = "group.net.rorklab.readlater.shared"
 
    func drainPending(into context: ModelContext) {
        let defaults = UserDefaults(suiteName: suite)
        let queue = defaults?.array(forKey: "pendingItems") as? [[String: String]] ?? []
        var importedURLs: [String] = []
 
        for entry in queue {
            guard let urlStr = entry["url"], let url = URL(string: urlStr) else { continue }
            let title = entry["title"] ?? url.absoluteString
            // 重複は弾く（URL ベース）
            if !importedURLs.contains(urlStr) {
                let item = ReadingItem(url: url, title: title, savedAt: .now)
                context.insert(item)
                importedURLs.append(urlStr)
            }
        }
        try? context.save()
        defaults?.removeObject(forKey: "pendingItems")
        importedCount = importedURLs.count
    }
}

@main
struct ReadLaterApp: App {
    @StateObject private var importer = PendingImporter()
 
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(importer)
                .onOpenURL { url in
                    guard url.scheme == "readlater" else { return }
                    Task { @MainActor in
                        importer.drainPending(into: modelContext)
                    }
                }
        }
        .modelContainer(for: ReadingItem.self)
    }
}

<key>NSExtension</key>
<dict>
  <key>NSExtensionAttributes</key>
  <dict>
    <key>NSExtensionActivationRule</key>
    <dict>
      <key>NSExtensionActivationSupportsWebURLWithMaxCount</key>
      <integer>1</integer>
      <key>NSExtensionActivationSupportsWebPageWithMaxCount</key>
      <integer>1</integer>
      <key>NSExtensionActivationSupportsText</key>
      <true/>
    </dict>
  </dict>
  <key>NSExtensionMainStoryboard</key>
  <string>MainInterface</string>
  <key>NSExtensionPointIdentifier</key>
  <string>com.apple.share-services</string>
</dict>