Building a Custom AI Keyboard Extension with Rork Max: A Complete iOS Keyboard Extension Guide

import UIKit
import SwiftUI
 
class KeyboardViewController: UIInputViewController {
    
    private var hostingController: UIHostingController<KeyboardView>?
    
    private let sharedDefaults = UserDefaults(
        suiteName: "group.com.yourcompany.aikeyboard"
    )
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupKeyboardView()
    }
    
    private func setupKeyboardView() {
        let keyboardView = KeyboardView(
            hasFullAccess: hasFullAccess,
            onTextInsert: { [weak self] text in
                self?.textDocumentProxy.insertText(text)
            },
            onTextDelete: { [weak self] in
                self?.textDocumentProxy.deleteBackward()
            },
            onNextKeyboard: { [weak self] in
                self?.advanceToNextInputMode()
            },
            onAIRequest: { [weak self] prompt, completion in
                self?.requestAICompletion(prompt: prompt, completion: completion)
            }
        )
        
        let hosting = UIHostingController(rootView: keyboardView)
        addChild(hosting)
        view.addSubview(hosting.view)
        hosting.view.translatesAutoresizingMaskIntoConstraints = false
        NSLayoutConstraint.activate([
            hosting.view.topAnchor.constraint(equalTo: view.topAnchor),
            hosting.view.bottomAnchor.constraint(equalTo: view.bottomAnchor),
            hosting.view.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            hosting.view.trailingAnchor.constraint(equalTo: view.trailingAnchor)
        ])
        hosting.didMove(toParent: self)
        hostingController = hosting
    }
    
    private func requestAICompletion(prompt: String, completion: @escaping (String) -> Void) {
        guard hasFullAccess else {
            completion("")
            return
        }
        
        guard let apiKey = sharedDefaults?.string(forKey: "claude_api_key"),
              \!apiKey.isEmpty else {
            completion("")
            return
        }
        
        Task {
            do {
                let result = try await AIService.complete(prompt: prompt, apiKey: apiKey)
                await MainActor.run { completion(result) }
            } catch {
                await MainActor.run { completion("") }
            }
        }
    }
}

import SwiftUI
 
struct KeyboardView: View {
    let hasFullAccess: Bool
    let onTextInsert: (String) -> Void
    let onTextDelete: () -> Void
    let onNextKeyboard: () -> Void
    let onAIRequest: (String, @escaping (String) -> Void) -> Void
    
    @State private var suggestions: [String] = []
    @State private var currentInput: String = ""
    @State private var isLoadingAI: Bool = false
    
    var body: some View {
        VStack(spacing: 0) {
            // AI Suggestion Bar
            SuggestionBar(
                suggestions: suggestions,
                isLoading: isLoadingAI,
                hasFullAccess: hasFullAccess,
                onSelect: { suggestion in
                    onTextInsert(suggestion)
                    clearSuggestions()
                }
            )
            
            // Key Grid
            KeyGrid(onKeyTap: handleKeyTap)
            
            // Toolbar
            KeyboardToolbar(
                hasFullAccess: hasFullAccess,
                onNextKeyboard: onNextKeyboard,
                onDelete: onTextDelete,
                onReturn: { onTextInsert("\n") }
            )
        }
        .background(Color(UIColor.systemGroupedBackground))
    }
    
    private func handleKeyTap(_ key: KeyType) {
        switch key {
        case .character(let char):
            onTextInsert(char)
            currentInput += char
            if currentInput.count >= 3 && hasFullAccess {
                debouncedFetchSuggestions()
            }
        case .delete:
            onTextDelete()
            if \!currentInput.isEmpty { currentInput.removeLast() }
            if currentInput.count < 3 { suggestions = [] }
        case .space:
            onTextInsert(" ")
            clearSuggestions()
        case .return:
            onTextInsert("\n")
            clearSuggestions()
        }
    }
    
    private var debounceTask: Task<Void, Never>?
    
    private func debouncedFetchSuggestions() {
        debounceTask?.cancel()
        debounceTask = Task {
            try? await Task.sleep(nanoseconds: 400_000_000)  // 400ms debounce
            guard \!Task.isCancelled else { return }
            await fetchSuggestions()
        }
    }
    
    @MainActor
    private func fetchSuggestions() async {
        isLoadingAI = true
        onAIRequest(currentInput) { result in
            let items = result
                .components(separatedBy: "\n")
                .map { $0.trimmingCharacters(in: .whitespaces) }
                .filter { \!$0.isEmpty }
                .prefix(3)
            suggestions = Array(items)
            isLoadingAI = false
        }
    }
    
    private func clearSuggestions() {
        currentInput = ""
        suggestions = []
        isLoadingAI = false
    }
}

import Foundation
 
actor AIService {
    
    static func complete(prompt: String, apiKey: String) async throws -> String {
        guard let url = URL(string: "https://api.anthropic.com/v1/messages") else {
            throw AIError.invalidURL
        }
        
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.timeoutInterval = 8
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
        request.setValue("2023-06-01", forHTTPHeaderField: "anthropic-version")
        
        let systemPrompt = """
        You are an AI keyboard autocomplete assistant.
        Given the text the user is currently typing, suggest 3 natural completions.
        Rules:
        - Output exactly 3 suggestions, one per line
        - Each suggestion should be under 25 words
        - Do not repeat the input text — provide only the completion
        - Match the tone and language of the input
        """
        
        let body: [String: Any] = [
            "model": "claude-haiku-4-5-20251001",
            "max_tokens": 150,
            "system": systemPrompt,
            "messages": [
                ["role": "user", "content": "Complete: \(prompt)"]
            ]
        ]
        
        request.httpBody = try JSONSerialization.data(withJSONObject: body)
        
        let (data, response) = try await URLSession.shared.data(for: request)
        
        guard let httpResponse = response as? HTTPURLResponse else {
            throw AIError.invalidResponse
        }
        
        guard (200...299).contains(httpResponse.statusCode) else {
            throw AIError.httpError(statusCode: httpResponse.statusCode)
        }
        
        guard let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
              let content = json["content"] as? [[String: Any]],
              let firstContent = content.first,
              let text = firstContent["text"] as? String else {
            throw AIError.parsingFailed
        }
        
        return text
    }
    
    enum AIError: Error, LocalizedError {
        case invalidURL
        case invalidResponse
        case httpError(statusCode: Int)
        case parsingFailed
        
        var errorDescription: String? {
            switch self {
            case .invalidURL: return "Invalid API URL"
            case .invalidResponse: return "Invalid response from API"
            case .httpError(let code): return "HTTP error: \(code)"
            case .parsingFailed: return "Failed to parse API response"
            }
        }
    }
}

// SharedDefaults.swift — used by BOTH targets
 
struct SharedDefaults {
    static let groupID = "group.com.yourcompany.aikeyboard"
    
    private static var defaults: UserDefaults {
        UserDefaults(suiteName: groupID) ?? .standard
    }
    
    // API Configuration
    // In production: store in Keychain with shared access group, not UserDefaults
    static var apiKey: String {
        get { defaults.string(forKey: "api_key") ?? "" }
        set { defaults.set(newValue, forKey: "api_key") }
    }
    
    // User Preferences
    static var aiEnabled: Bool {
        get { defaults.bool(forKey: "ai_enabled") }
        set { defaults.set(newValue, forKey: "ai_enabled") }
    }
    
    static var suggestionLanguage: String {
        get { defaults.string(forKey: "suggestion_language") ?? "en" }
        set { defaults.set(newValue, forKey: "suggestion_language") }
    }
    
    // Subscription State — synced from RevenueCat in main app
    static var isPremiumActive: Bool {
        get { defaults.bool(forKey: "is_premium_active") }
        set { defaults.set(newValue, forKey: "is_premium_active") }
    }
    
    // Usage Tracking for Freemium Limits
    static var dailyCompletionCount: Int {
        get { defaults.integer(forKey: "daily_completion_count") }
        set { defaults.set(newValue, forKey: "daily_completion_count") }
    }
    
    static var lastResetDate: Date {
        get { defaults.object(forKey: "last_reset_date") as? Date ?? Date() }
        set { defaults.set(newValue, forKey: "last_reset_date") }
    }
    
    // Reset daily counter if it's a new day
    static func resetDailyCountIfNeeded() {
        let calendar = Calendar.current
        if \!calendar.isDateInToday(lastResetDate) {
            dailyCompletionCount = 0
            lastResetDate = Date()
        }
    }
}

import RevenueCat
 
// In App.init() or AppDelegate.application(_:didFinishLaunchingWithOptions:)
func configureRevenueCat() {
    Purchases.configure(withAPIKey: "YOUR_REVENUECAT_PUBLIC_KEY")
    Purchases.shared.logLevel = .warn
    
    syncSubscriptionToSharedDefaults()
}
 
func syncSubscriptionToSharedDefaults() {
    Purchases.shared.getCustomerInfo { customerInfo, error in
        if let error = error {
            print("RevenueCat error: \(error.localizedDescription)")
            return
        }
        
        let isPremium = customerInfo?.entitlements["premium"]?.isActive == true
        SharedDefaults.isPremiumActive = isPremium
    }
}
 
// Call this after successful purchase
func handleSuccessfulPurchase() {
    syncSubscriptionToSharedDefaults()
    // Also post a notification for any active extension instances
}

// In KeyboardView.swift
private func canUseAI() -> Bool {
    guard hasFullAccess else { return false }
    
    // Premium users: unlimited
    if SharedDefaults.isPremiumActive { return true }
    
    // Free users: 5 completions per day
    SharedDefaults.resetDailyCountIfNeeded()
    return SharedDefaults.dailyCompletionCount < 5
}
 
private func useOneCompletion() {
    if \!SharedDefaults.isPremiumActive {
        SharedDefaults.dailyCompletionCount += 1
    }
}

// TranslationService.swift
 
struct TranslationService {
    
    static func translate(
        text: String,
        from sourceLanguage: String,
        to targetLanguage: String,
        apiKey: String
    ) async throws -> String {
        
        let languageNames: [String: String] = [
            "ja": "Japanese", "en": "English", "zh": "Chinese",
            "ko": "Korean", "es": "Spanish", "fr": "French",
            "de": "German", "pt": "Portuguese", "it": "Italian"
        ]
        
        let sourceName = languageNames[sourceLanguage] ?? sourceLanguage
        let targetName = languageNames[targetLanguage] ?? targetLanguage
        
        let systemPrompt = """
        You are a professional translator. Translate the given text from \(sourceName) to \(targetName).
        Rules:
        - Output only the translated text, nothing else
        - Preserve the tone and style of the original
        - Keep proper nouns, technical terms, and brand names unchanged
        - If the text is already in \(targetName), return it unchanged
        """
        
        let body: [String: Any] = [
            "model": "claude-haiku-4-5-20251001",
            "max_tokens": 500,
            "system": systemPrompt,
            "messages": [
                ["role": "user", "content": text]
            ]
        ]
        
        // Reuse the base request configuration from AIService
        guard let url = URL(string: "https://api.anthropic.com/v1/messages") else {
            throw AIError.invalidURL
        }
        
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.timeoutInterval = 15  // Translation needs more time than autocomplete
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
        request.setValue("2023-06-01", forHTTPHeaderField: "anthropic-version")
        request.httpBody = try JSONSerialization.data(withJSONObject: body)
        
        let (data, response) = try await URLSession.shared.data(for: request)
        
        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).contains(httpResponse.statusCode),
              let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
              let content = json["content"] as? [[String: Any]],
              let first = content.first,
              let translatedText = first["text"] as? String else {
            throw AIError.parsingFailed
        }
        
        return translatedText.trimmingCharacters(in: .whitespacesAndNewlines)
    }
}

// In KeyboardToolbar.swift
Button(action: {
    guard hasFullAccess,
          let currentText = textDocumentProxy.documentContextBeforeInput,
          \!currentText.isEmpty else { return }
    
    isTranslating = true
    
    Task {
        do {
            let translated = try await TranslationService.translate(
                text: currentText,
                from: SharedDefaults.preferredLanguage,
                to: targetLanguage,
                apiKey: SharedDefaults.apiKey
            )
            
            await MainActor.run {
                // Delete existing text and insert translation
                let textLength = currentText.count
                for _ in 0..<textLength {
                    textDocumentProxy.deleteBackward()
                }
                textDocumentProxy.insertText(translated)
                isTranslating = false
            }
        } catch {
            await MainActor.run { isTranslating = false }
        }
    }
}) {
    Label("Translate", systemImage: "globe")
        .labelStyle(.iconOnly)
        .opacity(isTranslating ? 0.3 : 1.0)
}
.disabled(\!hasFullAccess || isTranslating)

struct TemplateEngine {
    
    struct ParsedTemplate {
        let text: String
        let placeholders: [String]
    }
    
    static func parse(_ template: String) -> ParsedTemplate {
        let pattern = #"\[([^\]]+)\]"#
        let regex = try? NSRegularExpression(pattern: pattern)
        let range = NSRange(template.startIndex..., in: template)
        let matches = regex?.matches(in: template, range: range) ?? []
        
        var placeholders: [String] = []
        for match in matches {
            if let range = Range(match.range(at: 1), in: template) {
                let placeholder = String(template[range])
                if \!placeholders.contains(placeholder) {
                    placeholders.append(placeholder)
                }
            }
        }
        
        return ParsedTemplate(text: template, placeholders: placeholders)
    }
    
    static func fill(_ template: String, with values: [String: String]) -> String {
        var result = template
        for (placeholder, value) in values {
            result = result.replacingOccurrences(of: "[\(placeholder)]", with: value)
        }
        return result
    }
}

// In the main Containing App — not in the Extension
import PostHog
 
struct KeyboardAnalytics {
    
    static func trackAICompletionResult(
        success: Bool,
        latencyMs: Int,
        language: String
    ) {
        PostHogSDK.shared.capture(
            "ai_completion",
            properties: [
                "success": success,
                "latency_ms": latencyMs,
                "language": language,
                "is_premium": SharedDefaults.isPremiumActive
            ]
        )
    }
    
    static func trackTemplateUsed(templateCategory: String) {
        PostHogSDK.shared.capture(
            "template_used",
            properties: ["category": templateCategory]
        )
    }
    
    static func trackFullAccessGranted() {
        PostHogSDK.shared.capture("full_access_granted")
    }
    
    static func trackPaywallShown(trigger: String) {
        PostHogSDK.shared.capture(
            "paywall_shown",
            properties: ["trigger": trigger]
        )
    }
}