Gemini API × SwiftUI 本番アプリ実装ガイド：ストリーミング・マルチモーダル・エラーハンドリング・App Store対策まで

// MultimodalClient.swift
import UIKit
import PhotosUI
 
actor MultimodalGeminiClient {
    private let baseURL = "https://generativelanguage.googleapis.com/v1beta/models"
    private let model = "gemini-2.5-flash-preview-04-17"
 
    /// 画像を最大1024pxにリサイズしてBase64エンコード（メモリ最適化）
    private func prepareImage(_ image: UIImage, maxDimension: CGFloat = 1024) -> String? {
        let scale = min(maxDimension / image.size.width, maxDimension / image.size.height, 1.0)
        let newSize = CGSize(width: image.size.width * scale, height: image.size.height * scale)
 
        UIGraphicsBeginImageContextWithOptions(newSize, false, 1.0)
        defer { UIGraphicsEndImageContext() }
        image.draw(in: CGRect(origin: .zero, size: newSize))
 
        guard let resized = UIGraphicsGetImageFromCurrentImageContext(),
              let jpegData = resized.jpegData(compressionQuality: 0.8) else { return nil }
 
        return jpegData.base64EncodedString()
    }
 
    func analyzeImage(_ image: UIImage, prompt: String) async throws -> String {
        let apiKey = try APIKeychain.shared.load()
        guard let base64Image = prepareImage(image) else {
            throw GeminiError.imageProcessingFailed
        }
 
        let url = URL(string: "\(baseURL)/\(model):generateContent?key=\(apiKey)")!
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
 
        let body: [String: Any] = [
            "contents": [[
                "parts": [
                    ["inline_data": ["mime_type": "image/jpeg", "data": base64Image]],
                    ["text": prompt]
                ]
            ]],
            "generationConfig": ["maxOutputTokens": 1024]
        ]
        request.httpBody = try JSONSerialization.data(withJSONObject: body)
 
        let (data, response) = try await URLSession.shared.data(for: request)
        guard let httpResponse = response as? HTTPURLResponse,
              httpResponse.statusCode == 200 else {
            throw GeminiError.invalidResponse
        }
 
        guard let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
              let candidates = json["candidates"] as? [[String: Any]],
              let content = candidates.first?["content"] as? [String: Any],
              let parts = content["parts"] as? [[String: Any]],
              let text = parts.first?["text"] as? String else {
            throw GeminiError.parsingFailed
        }
        return text
    }
}
 
// SwiftUI での画像選択 UI
struct ImageAnalysisView: View {
    @State private var selectedItem: PhotosPickerItem?
    @State private var selectedImage: UIImage?
    @State private var analysisResult = ""
    @State private var isAnalyzing = false
    @State private var promptText = "この画像を詳しく説明してください"
 
    private let client = MultimodalGeminiClient()
 
    var body: some View {
        ScrollView {
            VStack(spacing: 20) {
                PhotosPicker(selection: $selectedItem, matching: .images) {
                    Group {
                        if let image = selectedImage {
                            Image(uiImage: image)
                                .resizable()
                                .scaledToFit()
                                .frame(maxHeight: 300)
                                .clipShape(RoundedRectangle(cornerRadius: 12))
                        } else {
                            RoundedRectangle(cornerRadius: 12)
                                .fill(Color(.systemGray5))
                                .frame(height: 200)
                                .overlay(Image(systemName: "photo.badge.plus").font(.largeTitle))
                        }
                    }
                }
                .onChange(of: selectedItem) { loadImage() }
 
                TextField("分析の指示", text: $promptText, axis: .vertical)
                    .textFieldStyle(.roundedBorder)
                    .lineLimit(3)
 
                Button {
                    Task { await analyze() }
                } label: {
                    Label(isAnalyzing ? "分析中…" : "AI で分析する", systemImage: "sparkles")
                        .frame(maxWidth: .infinity)
                        .padding()
                        .background(Color.blue)
                        .foregroundColor(.white)
                        .clipShape(RoundedRectangle(cornerRadius: 12))
                }
                .disabled(selectedImage == nil || isAnalyzing)
 
                if !analysisResult.isEmpty {
                    Text(analysisResult)
                        .padding()
                        .background(Color(.systemGray6))
                        .clipShape(RoundedRectangle(cornerRadius: 12))
                }
            }
            .padding()
        }
    }
 
    private func loadImage() {
        Task {
            if let data = try? await selectedItem?.loadTransferable(type: Data.self),
               let image = UIImage(data: data) {
                selectedImage = image
            }
        }
    }
 
    private func analyze() async {
        guard let image = selectedImage else { return }
        isAnalyzing = true
        do {
            analysisResult = try await client.analyzeImage(image, prompt: promptText)
        } catch {
            analysisResult = "エラーが発生しました: \(error.localizedDescription)"
        }
        isAnalyzing = false
    }
}

// RetryableGeminiClient.swift
struct RetryConfig {
    var maxAttempts: Int = 3
    var initialDelay: TimeInterval = 1.0
    var multiplier: Double = 2.0
    var maxDelay: TimeInterval = 30.0
    var jitterFactor: Double = 0.1  // 同時リトライの分散
 
    func delay(for attempt: Int) -> TimeInterval {
        let exponential = initialDelay * pow(multiplier, Double(attempt - 1))
        let capped = min(exponential, maxDelay)
        let jitter = capped * jitterFactor * Double.random(in: -1...1)
        return capped + jitter
    }
}
 
enum GeminiError: LocalizedError {
    case rateLimitExceeded
    case serverError(Int)
    case invalidResponse
    case imageProcessingFailed
    case parsingFailed
    case apiKeyMissing
 
    var errorDescription: String? {
        switch self {
        case .rateLimitExceeded: return "リクエストが集中しています。しばらくお待ちください。"
        case .serverError(let code): return "サーバーエラー（\(code)）が発生しました。"
        case .invalidResponse: return "AIからの応答が無効です。"
        case .imageProcessingFailed: return "画像の処理に失敗しました。"
        case .parsingFailed: return "応答の解析に失敗しました。"
        case .apiKeyMissing: return "APIキーが設定されていません。"
        }
    }
 
    var isRetryable: Bool {
        switch self {
        case .rateLimitExceeded, .serverError: return true
        default: return false
        }
    }
}
 
func withRetry<T>(
    config: RetryConfig = RetryConfig(),
    operation: () async throws -> T
) async throws -> T {
    var lastError: Error?
 
    for attempt in 1...config.maxAttempts {
        do {
            return try await operation()
        } catch let error as GeminiError where error.isRetryable {
            lastError = error
            if attempt < config.maxAttempts {
                let delay = config.delay(for: attempt)
                try await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
            }
        } catch {
            throw error // リトライ不可のエラーは即座に投げる
        }
    }
    throw lastError ?? GeminiError.invalidResponse
}
 
// 使用例
func generateWithRetry(prompt: String) async throws -> String {
    try await withRetry {
        try await geminiClient.generate(prompt: prompt)
    }
}

// ResponseCache.swift
import CryptoKit
 
final class GeminiResponseCache {
    private let cache = NSCache<NSString, CacheEntry>()
    private let ttl: TimeInterval = 3600  // 1時間
 
    init(countLimit: Int = 100) {
        cache.countLimit = countLimit
    }
 
    private func cacheKey(for prompt: String) -> NSString {
        let hash = SHA256.hash(data: Data(prompt.utf8))
        return hash.compactMap { String(format: "%02x", $0) }.joined() as NSString
    }
 
    func get(prompt: String) -> String? {
        let key = cacheKey(for: prompt)
        guard let entry = cache.object(forKey: key),
              Date().timeIntervalSince(entry.timestamp) < ttl else {
            return nil
        }
        return entry.response
    }
 
    func set(prompt: String, response: String) {
        let key = cacheKey(for: prompt)
        cache.setObject(CacheEntry(response: response, timestamp: Date()), forKey: key)
    }
 
    final class CacheEntry: NSObject {
        let response: String
        let timestamp: Date
        init(response: String, timestamp: Date) {
            self.response = response
            self.timestamp = timestamp
        }
    }
}
 
// キャッシュを活用したラッパー
actor CachedGeminiClient {
    private let client: GeminiStreamingClient
    private let cache = GeminiResponseCache()
 
    init(client: GeminiStreamingClient) { self.client = client }
 
    func generate(prompt: String) async throws -> AsyncStream<String> {
        // キャッシュヒットなら即座に返す
        if let cached = cache.get(prompt: prompt) {
            return AsyncStream { continuation in
                continuation.yield(cached)
                continuation.finish()
            }
        }
 
        // キャッシュミス：APIを呼び出して結果を蓄積
        return AsyncStream { continuation in
            Task {
                var full = ""
                for await chunk in await client.stream(prompt: prompt) {
                    full += chunk
                    continuation.yield(chunk)
                }
                await self.cache.set(prompt: prompt, response: full)
                continuation.finish()
            }
        }
    }
}

// MockURLProtocol.swift（テストターゲットに追加）
final class MockURLProtocol: URLProtocol {
    static var mockData: Data?
    static var mockError: Error?
    static var statusCode = 200
 
    override class func canInit(with request: URLRequest) -> Bool { true }
    override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }
 
    override func startLoading() {
        if let error = MockURLProtocol.mockError {
            client?.urlProtocol(self, didFailWithError: error)
            return
        }
        let response = HTTPURLResponse(
            url: request.url!,
            statusCode: MockURLProtocol.statusCode,
            httpVersion: nil,
            headerFields: ["Content-Type": "text/event-stream"]
        )!
        client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
        if let data = MockURLProtocol.mockData {
            client?.urlProtocol(self, didLoad: data)
        }
        client?.urlProtocolDidFinishLoading(self)
    }
 
    override func stopLoading() {}
}
 
// テストコード例
import XCTest
 
@MainActor
final class ChatViewModelTests: XCTestCase {
    var sut: ChatViewModel!
    var session: URLSession!
 
    override func setUp() {
        let config = URLSessionConfiguration.ephemeral
        config.protocolClasses = [MockURLProtocol.self]
        session = URLSession(configuration: config)
        sut = ChatViewModel(session: session)
    }
 
    func testStreamingResponse() async throws {
        // SSE形式のモックレスポンス
        let sseData = """
        data: {"candidates":[{"content":{"parts":[{"text":"こんにちは"}]}}]}
 
        data: {"candidates":[{"content":{"parts":[{"text":"！"}]}}]}
 
        data: [DONE]
        """.data(using: .utf8)
 
        MockURLProtocol.mockData = sseData
        MockURLProtocol.statusCode = 200
 
        await sut.send(prompt: "挨拶して")
 
        XCTAssertEqual(sut.messages.last?.text, "こんにちは！")
        XCTAssertFalse(sut.isStreaming)
    }
 
    func testRateLimitHandling() async throws {
        MockURLProtocol.statusCode = 429
 
        await sut.send(prompt: "テスト")
 
        XCTAssertNotNil(sut.errorMessage)
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>NSPrivacyCollectedDataTypes</key>
    <array>
        <!-- Gemini API に送るテキスト・画像は「ユーザーコンテンツ」 -->
        <dict>
            <key>NSPrivacyCollectedDataType</key>
            <string>NSPrivacyCollectedDataTypeUserContent</string>
            <key>NSPrivacyCollectedDataTypeLinked</key>
            <false/>
            <key>NSPrivacyCollectedDataTypeTracking</key>
            <false/>
            <key>NSPrivacyCollectedDataTypePurposes</key>
            <array>
                <string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
            </array>
        </dict>
    </array>
    <key>NSPrivacyAccessedAPITypes</key>
    <array/>
</dict>
</plist>

// TokenCounter.swift — 送信前のトークン数見積もり（近似値）
struct TokenEstimator {
    /// 日本語テキストは1文字≒1〜2トークン（近似）
    static func estimate(text: String) -> Int {
        let japanese = text.unicodeScalars.filter { $0.value > 0x3000 }.count
        let other = text.count - japanese
        return japanese * 2 + other / 4
    }
 
    /// 画像は解像度に依存（1024x1024 ≒ 765トークン）
    static func estimate(imageSize: CGSize) -> Int {
        let tiles = ceil(imageSize.width / 256) * ceil(imageSize.height / 256)
        return Int(tiles) * 258 + 85
    }
}
 
// コンテキスト圧縮（会話が長くなりすぎた場合のサマライズ）
actor ContextManager {
    private var messages: [Message] = []
    private let maxTokens = 30000
    private let client: GeminiStreamingClient
 
    init(client: GeminiStreamingClient) { self.client = client }
 
    func addMessage(_ message: Message) async {
        messages.append(message)
        let estimated = messages.reduce(0) { $0 + TokenEstimator.estimate(text: $1.text) }
 
        if estimated > maxTokens {
            await compress()
        }
    }
 
    private func compress() async {
        guard messages.count > 4 else { return }
        let oldMessages = Array(messages.dropLast(4))
        let summary = try? await client.generate(
            prompt: "以下の会話を3行に要約してください:\n\(oldMessages.map { "\($0.role): \($0.text)" }.joined(separator: "\n"))"
        )
        if let summary {
            messages = [Message(role: .system, text: "これまでの会話の要約:\n\(summary)")] + messages.suffix(4)
        }
    }
}

// StreamingChatView.swift — scenePhase でストリームを安全に畳む
struct StreamingChatView: View {
    @Environment(\.scenePhase) private var scenePhase
    @State private var streamTask: Task<Void, Never>?
    @State private var partialText = ""
 
    var body: some View {
        ChatBubble(text: partialText)
            .onChange(of: scenePhase) { _, newPhase in
                if newPhase == .background {
                    // 進行中のストリームを中断し、途中までの応答を確定保存
                    streamTask?.cancel()
                    if !partialText.isEmpty {
                        persistDraft(partialText)  // 復帰時に続きから再開できるようにする
                    }
                }
            }
    }
 
    private func startStream(prompt: String) {
        streamTask = Task {
            do {
                for try await chunk in geminiClient.stream(prompt: prompt) {
                    if Task.isCancelled { break }  // ← これが無いと cancel しても回り続ける
                    partialText += chunk
                }
            } catch is CancellationError {
                // 想定内。何もしない
            } catch {
                showError(error)
            }
        }
    }
}

// SSELineBuffer.swift — チャンク境界をまたぐ不完全な行を吸収する
struct SSELineBuffer {
    private var buffer = ""
 
    /// チャンクを受け取り、改行で完結した行だけを返す
    mutating func append(_ chunk: String) -> [String] {
        buffer += chunk
        var completeLines: [String] = []
        while let newlineIndex = buffer.firstIndex(of: "\n") {
            let line = String(buffer[..<newlineIndex])
            buffer.removeSubrange(...newlineIndex)
            if line.hasPrefix("data: ") {
                completeLines.append(String(line.dropFirst(6)))
            }
        }
        return completeLines  // 未完の行は buffer に残したまま次回へ持ち越す
    }
}

def validate_gemini_request(payload):
    """本番前のリクエスト検証"""
    assert payload.get("max_output_tokens", 8000) <= 8192, "max_output_tokens超過"
    assert 0.0 <= payload.get("temperature", 1.0) <= 2.0, "temperature範囲外"
    assert payload.get("top_p", 0.95) > 0 and payload.get("top_p") <= 1.0, "top_p範囲外"
    assert payload.get("top_k", 40) >= 1, "top_k値が不正"
    return True

# Google Cloud Monitoring連携例
def alert_on_quota_approaching(current_rpm, quota_limit):
    """配額の80%に到達時にアラート"""
    if current_rpm > quota_limit * 0.8:
        send_alert(f"API配額が{int((current_rpm/quota_limit)*100)}%に達しました")

import os
from google.cloud import secretmanager
 
def get_api_key():
    """Google Cloud Secret Managerからキーを取得"""
    client = secretmanager.SecretManagerServiceClient()
    secret_name = f"projects/{os.environ['GCP_PROJECT_ID']}/secrets/gemini-api-key/versions/latest"
    response = client.access_secret_version(request={"name": secret_name})
    return response.payload.data.decode("UTF-8")

import time
import random
from google.generativeai import GenerativeModel
 
def call_with_exponential_backoff(prompt, model="gemini-2.0-flash", max_retries=5):
    """Exponential Backoff + Jitterを含むAPI呼び出し"""
    model_instance = GenerativeModel(model)
    
    for attempt in range(max_retries):
        try:
            response = model_instance.generate_content(prompt)
            return response
        
        except Exception as e:
            if "429" not in str(e) and "RESOURCE_EXHAUSTED" not in str(e):
                raise  # リトライ不可能なエラーは即座に上げる
            
            if attempt == max_retries - 1:
                raise  # 最大リトライ回数に到達
            
            # Exponential Backoff + Jitter
            wait_time = min(2 ** attempt + random.uniform(0, 1), 60)
            print(f"レート制限: {wait_time:.1f}秒待機してリトライ")
            time.sleep(wait_time)
    
    return None

async function callWithExponentialBackoff(
  prompt: string,
  model: string = "gemini-2.0-flash",
  maxRetries: number = 5
): Promise<any> {
  const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
  const modelInstance = genAI.getGenerativeModel({ model });
 
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await modelInstance.generateContent(prompt);
      return response;
    } catch (error: any) {
      const errorMsg = error.message || "";
      
      if (\!errorMsg.includes("429") && \!errorMsg.includes("RESOURCE_EXHAUSTED")) {
        throw error;  // リトライ不可能なエラー
      }
 
      if (attempt === maxRetries - 1) {
        throw new Error(`Max retries exceeded after ${maxRetries} attempts`);
      }
 
      const waitTime = Math.min(Math.pow(2, attempt) + Math.random(), 60) * 1000;
      console.log(`Rate limited: waiting ${waitTime}ms before retry...`);
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }
  }
}

def estimate_monthly_cost(monthly_tokens_input, monthly_tokens_output, model="flash"):
    """月間トークン数からコスト推定"""
    # Outputトークンの単価（Inputより通常2倍以上高い）
    output_multiplier = 4.0 if model == "flash" else 15.0
    
    total_input_tokens = monthly_tokens_input
    total_output_tokens = int(monthly_tokens_output)
    
    # Tier判定（$での計算、その後JPYに換算可）
    if model == "flash":
        input_price_per_m = 0.075 if total_input_tokens < 10_000_000 else (
            0.0594 if total_input_tokens < 100_000_000 else 0.036
        )
        output_price_per_m = input_price_per_m * output_multiplier
    else:  # Pro
        input_price_per_m = 3.50 if total_input_tokens < 10_000_000 else (
            2.80 if total_input_tokens < 100_000_000 else 1.70
        )
        output_price_per_m = input_price_per_m * output_multiplier
    
    monthly_cost_usd = (
        (total_input_tokens / 1_000_000) * input_price_per_m +
        (total_output_tokens / 1_000_000) * output_price_per_m
    )
    
    return monthly_cost_usd * 150  # USD→JPY（概算）

# Google Cloud Tasksを使った例
from google.cloud import tasks_v2
import json
 
def enqueue_gemini_request(project_id, queue_name, payload):
    """Gemini API呼び出しをキューに投入"""
    client = tasks_v2.CloudTasksClient()
    parent = client.queue_path(project_id, "asia-northeast1", queue_name)
    
    task = {
        "http_request": {
            "http_method": "POST",
            "url": "https://your-backend.com/api/gemini-worker",
            "headers": {"Content-Type": "application/json"},
            "body": json.dumps(payload).encode(),
        }
    }
    
    response = client.create_task(request={"parent": parent, "task": task})
    return response.name

def qa_with_context_caching(document_content, question, cache_ttl_seconds=3600):
    """Context Caching活用でコスト削減"""
    import genai
    
    client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
    
    # システムプロンプト + ドキュメント をキャッシュ対象に
    cached_content = {
        "role": "user",
        "parts": [
            {
                "text": f"以下の公式ドキュメントに基づいて質問に答えてください:\n\n{document_content}"
            }
        ],
        # キャッシュ有効期限を指定
        "cache_control": {
            "type": "ephemeral",
            "expires_in_seconds": cache_ttl_seconds
        }
    }
    
    response = client.models.generate_content(
        model="gemini-2.0-flash",
        contents=[
            cached_content,
            {
                "role": "user",
                "parts": [{"text": question}]
            }
        ]
    )
    
    # キャッシュ統計を確認
    print(f"キャッシュ入力トークン: {response.usage_metadata.cached_content_input_tokens}")
    print(f"非キャッシュ入力トークン: {response.usage_metadata.prompt_token_count}")
    
    return response.text