AdMob + Gemini APIで個人開発iOS壁紙アプリの収益を最大化する設計パターン

import CoreML
import Vision
 
class WallpaperStyleClassifier {
    private let model: VNCoreMLModel
    
    // 簡略化した壁紙スタイル分類器
    // 実際はGemma 3B on-deviceまたはカスタムモデルを使用
    init() throws {
        let mlModel = try WallpaperClassifierV2(configuration: MLModelConfiguration()).model
        model = try VNCoreMLModel(for: mlModel)
    }
    
    /// APIコスト0でデバイス上でスタイルを分類
    func classify(image: UIImage) async throws -> WallpaperStyle {
        guard let cgImage = image.cgImage else {
            throw ClassifierError.invalidImage
        }
        
        return try await withCheckedThrowingContinuation { continuation in
            let request = VNCoreMLRequest(model: model) { request, error in
                if let error = error {
                    continuation.resume(throwing: error)
                    return
                }
                
                guard let results = request.results as? [VNClassificationObservation],
                      let topResult = results.first else {
                    continuation.resume(throwing: ClassifierError.noResults)
                    return
                }
                
                let style = WallpaperStyle(rawValue: topResult.identifier) ?? .unknown
                continuation.resume(returning: style)
            }
            
            let handler = VNImageRequestHandler(cgImage: cgImage)
            try? handler.perform([request])
        }
    }
}
 
enum WallpaperStyle: String {
    case nature, minimal, abstract, cityscape, pattern, unknown
}

import google.generativeai as genai
import json
import time
 
genai.configure(api_key="YOUR_GEMINI_API_KEY")
 
def optimize_wallpaper_tags(user_query: str, max_retries: int = 3) -> dict:
    """
    ユーザーの自然言語クエリを壁紙検索タグに変換する。
    Gemini 2.5 Flash を使用してコストを抑える。
    
    入力例: "朝の公園みたいな明るい壁紙"
    出力例: {"tags": ["morning", "park", "bright", "nature", "green"], 
             "mood": "peaceful", "time_of_day": "morning"}
    """
    model = genai.GenerativeModel(
        "gemini-2.5-flash",
        system_instruction="""あなたは壁紙アプリの検索最適化AIです。
ユーザーの自然言語クエリを英語の検索タグに変換してください。
必ずJSON形式で返してください。タグは5個以内で、具体的かつ検索に使えるものにしてください。
mood: peaceful/energetic/romantic/minimalist/dramatic のいずれか
time_of_day: morning/afternoon/evening/night/any のいずれか"""
    )
    
    for attempt in range(max_retries):
        try:
            response = model.generate_content(
                user_query,
                generation_config=genai.GenerationConfig(
                    response_mime_type="application/json",
                    max_output_tokens=150,  # タグ変換は短い出力で十分
                    temperature=0.3  # 一貫性を優先
                )
            )
            
            result = json.loads(response.text)
            
            # バリデーション
            if "tags" not in result or not isinstance(result["tags"], list):
                raise ValueError("Invalid response format")
            
            # タグ数を制限（コスト・品質のバランス）
            result["tags"] = result["tags"][:5]
            return result
            
        except Exception as e:
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)  # 指数バックオフ
                continue
            # 最終リトライ失敗時はフォールバック
            return {"tags": user_query.split()[:3], "mood": "any", "time_of_day": "any"}
 
# 使用例
query = "朝の公園みたいな明るい壁紙"
tags = optimize_wallpaper_tags(query)
print(tags)
# 出力例:
# {"tags": ["morning", "park", "bright", "nature", "sunlight"],
#  "mood": "peaceful", "time_of_day": "morning"}

import Foundation
import StoreKit
 
class AIUsageManager {
    private let userDefaults = UserDefaults.standard
    private let premiumCheckKey = "isPremiumUser"
    private let dailyUsageKey = "aiDailyUsage"
    private let lastResetKey = "aiLastResetDate"
    
    static let shared = AIUsageManager()
    
    // 無料プランの1日あたり上限
    private let freeUserDailyLimit = 3
    
    var isPremiumUser: Bool {
        // App内課金の購入状態を確認
        // 実際はStoreKit 2のTransaction.currentEntitlementsを使用
        return userDefaults.bool(forKey: premiumCheckKey)
    }
    
    /// AI機能の利用可否チェック（API呼び出し前に必ず確認）
    func canUseAIFeature() -> AIUsageResult {
        if isPremiumUser {
            return .allowed(remainingCount: Int.max)
        }
        
        resetDailyCountIfNeeded()
        
        let currentCount = userDefaults.integer(forKey: dailyUsageKey)
        let remaining = freeUserDailyLimit - currentCount
        
        if remaining > 0 {
            return .allowed(remainingCount: remaining)
        } else {
            return .limitReached(upgradeURL: "https://gemilab.net/membership")
        }
    }
    
    /// API呼び出し成功後にカウントを増加
    func recordUsage() {
        guard !isPremiumUser else { return }
        let current = userDefaults.integer(forKey: dailyUsageKey)
        userDefaults.set(current + 1, forKey: dailyUsageKey)
    }
    
    private func resetDailyCountIfNeeded() {
        let today = Calendar.current.startOfDay(for: Date())
        if let lastReset = userDefaults.object(forKey: lastResetKey) as? Date,
           Calendar.current.isDate(lastReset, inSameDayAs: today) {
            return // 今日はまだリセット不要
        }
        userDefaults.set(0, forKey: dailyUsageKey)
        userDefaults.set(today, forKey: lastResetKey)
    }
}
 
enum AIUsageResult {
    case allowed(remainingCount: Int)
    case limitReached(upgradeURL: String)
}
 
// 使用例（壁紙生成ボタンのタップ処理）
func handleAIGenerationTap() {
    let usageResult = AIUsageManager.shared.canUseAIFeature()
    
    switch usageResult {
    case .allowed(let remaining):
        // API呼び出しを実行
        Task {
            await generateAIWallpaper()
            AIUsageManager.shared.recordUsage()
            
            if remaining == 1 {
                showUpgradeHintBanner() // 残り1回でアップグレード訴求
            }
        }
    case .limitReached(let url):
        showUpgradePrompt(upgradeURL: url)
    }
}

from google.generativeai.types import HarmCategory, HarmBlockThreshold
 
# 壁紙生成専用の安全設定（最も厳格なセーフティ設定を使用）
safety_settings = {
    HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
}
 
# Imagen 4 での壁紙生成（プレミアムユーザー向け）
def generate_safe_wallpaper(prompt: str) -> bytes | None:
    """
    壁紙専用のセーフティ設定でImagen 4を使用して画像生成。
    SAFETY_BLOCKEDの場合はNoneを返してフォールバック処理へ。
    """
    model = genai.ImageGenerationModel("imagen-4.0")
    
    # 壁紙専用のシステムプロンプトを前置き
    safe_prompt = f"Beautiful, family-friendly wallpaper image: {prompt}. No people, no text, natural or abstract design only."
    
    try:
        response = model.generate_images(
            prompt=safe_prompt,
            number_of_images=1,
            safety_filter_level="block_most",
            aspect_ratio="9:16"  # スマートフォン縦向き
        )
        
        if response.images:
            return response.images[0].image_bytes
        return None
        
    except Exception as e:
        # セーフティブロック含む全エラーをキャッチしてNone返却
        print(f"Image generation failed: {e}")
        return None

// AI生成壁紙であることを示すメタデータをUIImageに付加
func addAIWatermark(to image: UIImage) -> UIImage {
    let renderer = UIGraphicsImageRenderer(size: image.size)
    
    return renderer.image { context in
        image.draw(at: .zero)
        
        // 右下に小さくAIラベルを追加
        let text = "AI"
        let attributes: [NSAttributedString.Key: Any] = [
            .font: UIFont.systemFont(ofSize: 12, weight: .medium),
            .foregroundColor: UIColor.white.withAlphaComponent(0.6)
        ]
        
        let size = (text as NSString).size(withAttributes: attributes)
        let x = image.size.width - size.width - 8
        let y = image.size.height - size.height - 8
        
        (text as NSString).draw(at: CGPoint(x: x, y: y), withAttributes: attributes)
    }
}

import hashlib
import json
import redis
from typing import Optional
 
class CachedGeminiTagOptimizer:
    def __init__(self, redis_client: redis.Redis):
        self.redis = redis_client
        self.cache_ttl = 86400  # 24時間キャッシュ
    
    def optimize_with_cache(self, user_query: str) -> dict:
        """
        同一クエリはキャッシュから返し、Gemini API呼び出しを削減。
        実測でAPI呼び出しを40〜60%削減できる。
        """
        cache_key = f"wallpaper_tags:{hashlib.md5(user_query.encode()).hexdigest()}"
        
        # キャッシュ確認
        cached = self.redis.get(cache_key)
        if cached:
            return json.loads(cached)
        
        # キャッシュなし → API呼び出し
        result = optimize_wallpaper_tags(user_query)
        
        # 結果をキャッシュに保存
        self.redis.setex(
            cache_key,
            self.cache_ttl,
            json.dumps(result, ensure_ascii=False)
        )
        
        return result