Maximizing Revenue in Indie iOS Wallpaper Apps with AdMob + Gemini API

import CoreML
import Vision
 
class WallpaperStyleClassifier {
    private let model: VNCoreMLModel
    
    // Uses a custom Core ML model or lightweight on-device Gemma
    // Zero API cost: runs entirely on device
    init() throws {
        let mlModel = try WallpaperClassifierV2(configuration: MLModelConfiguration()).model
        model = try VNCoreMLModel(for: mlModel)
    }
    
    /// Classify wallpaper style without any API call
    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:
    """
    Convert natural language wallpaper queries into searchable tags.
    Uses Gemini 2.5 Flash for low-cost, fast responses.
    
    Input:  "bright wallpaper like a morning park"
    Output: {"tags": ["morning", "park", "bright", "nature", "sunlight"],
             "mood": "peaceful", "time_of_day": "morning"}
    """
    model = genai.GenerativeModel(
        "gemini-2.5-flash",
        system_instruction="""You are a wallpaper search optimization AI.
Convert the user's natural language query into English search tags.
Always respond in valid JSON only.
Keep tags to 5 or fewer, concrete and searchable.
mood: one of peaceful/energetic/romantic/minimalist/dramatic
time_of_day: one of 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,  # Tag conversion needs short output
                    temperature=0.3         # Prefer consistency over creativity
                )
            )
            
            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]  # Hard cap at 5 tags
            return result
            
        except Exception as e:
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)  # Exponential backoff
                continue
            # Final failure: return basic keyword split as fallback
            return {"tags": user_query.split()[:3], "mood": "any", "time_of_day": "any"}
 
# Example output:
# {"tags": ["morning", "park", "bright", "nature", "sunlight"],
#  "mood": "peaceful", "time_of_day": "morning"}

import Foundation
 
class AIUsageManager {
    private let userDefaults = UserDefaults.standard
    private let premiumKey = "isPremiumUser"
    private let dailyUsageKey = "aiDailyUsage"
    private let lastResetKey = "aiLastResetDate"
    
    static let shared = AIUsageManager()
    
    private let freeUserDailyLimit = 3
    
    var isPremiumUser: Bool {
        // In production: use StoreKit 2 Transaction.currentEntitlements
        return userDefaults.bool(forKey: premiumKey)
    }
    
    /// Call this before EVERY API request
    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")
        }
    }
    
    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)
}
 
// Wallpaper generation button handler
func handleAIGenerationTap() {
    let usageResult = AIUsageManager.shared.canUseAIFeature()
    
    switch usageResult {
    case .allowed(let remaining):
        Task {
            await generateAIWallpaper()
            AIUsageManager.shared.recordUsage()
            
            // Show upgrade hint BEFORE the limit is hit, not after
            // Conversion rate is significantly higher at "1 remaining" than at "0 remaining"
            if remaining == 1 {
                showUpgradeHintBanner()
            }
        }
    case .limitReached(let url):
        showUpgradePrompt(upgradeURL: url)
    }
}

from google.generativeai.types import HarmCategory, HarmBlockThreshold
 
# Strictest safety settings for wallpaper generation
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,
}
 
def generate_safe_wallpaper(prompt: str) -> bytes | None:
    """
    Generate wallpaper with maximum safety filters applied.
    Returns None on any safety block — caller handles fallback.
    """
    model = genai.ImageGenerationModel("imagen-4.0")
    
    # Prepend a safe framing to every user prompt
    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"
        )
        return response.images[0].image_bytes if response.images else None
    except Exception:
        return None

import hashlib
import json
import redis
 
class CachedTagOptimizer:
    def __init__(self, redis_client: redis.Redis):
        self.redis = redis_client
        self.cache_ttl = 86400  # 24-hour cache
 
    def optimize_with_cache(self, user_query: str) -> dict:
        """
        Return cached result for repeated queries.
        In production testing: reduced API calls by 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)
        
        result = optimize_wallpaper_tags(user_query)
        
        self.redis.setex(
            cache_key,
            self.cache_ttl,
            json.dumps(result, ensure_ascii=False)
        )
        
        return result