KI-Integration in mobile Apps: Ein praktischer Schritt-für-Schritt-Leitfaden

dependencies {
    implementation("com.google.mlkit:image-labeling:17.0.7")
}

import android.content.Context
import android.net.Uri
import com.google.mlkit.vision.common.InputImage
import com.google.mlkit.vision.label.ImageLabeling
import com.google.mlkit.vision.label.defaults.ImageLabelerOptions

class ImageClassifier(private val context: Context) {

    fun classifyImage(imageUri: Uri, onSuccess: (List<String>) -> Unit, onFailure: (Exception) -> Unit) {
        try {
            // 1. Bereiten Sie das InputImage aus der Uri vor
            val image = InputImage.fromFilePath(context, imageUri)
            
            // 2. Initialisieren Sie den standardmäßigen lokalen Image Labeler
            val labeler = ImageLabeling.getClient(ImageLabelerOptions.DEFAULT_OPTIONS)
            
            // 3. Verarbeiten Sie das Bild
            labeler.process(image)
                .addOnSuccessListener { labels ->
                    val result = labels.map { "${it.text} (${(it.confidence * 100).toInt()}%)" }
                    onSuccess(result)
                }
                .addOnFailureListener { e ->
                    onFailure(e)
                }
        } catch (e: Exception) {
            onFailure(e)
        }
    }
}

import Vision
import CoreML
import UIKit

class iOSImageClassifier {
    
    func classifyImage(image: UIImage, completion: @escaping (Result<[String], Error>) -> Void) {
        // 1. Laden des CoreML-Modells mit dem Vision-Wrapper
        guard let configuration = try? MLModelConfiguration(),
              let coreMLModel = try? MobileNetV2(configuration: configuration),
              let visionModel = try? VNCoreMLModel(for: coreMLModel) else {
            completion(.failure(NSError(domain: "Classifier", code: 1, userInfo: [NSLocalizedDescriptionKey: "Modell konnte nicht geladen werden"])))
            return
        }
        
        // 2. Erstellen einer Vision-Anfrage
        let request = VNCoreMLRequest(model: visionModel) { request, error in
            if let error = error {
                completion(.failure(error))
                return
            }
            
            guard let results = request.results as? [VNClassificationObservation] else {
                completion(.success([]))
                return
            }
            
            // 3. Formatieren der wichtigsten Klassifizierungen
            let formattedResults = results.prefix(3).map { 
                "\($0.identifier) (\(Int($0.confidence * 100))%)" 
            }
            completion(.success(formattedResults))
        }
        
        // 4. Konvertieren von UIImage in CGImage und Ausführen der Anfrage
        guard let cgImage = image.cgImage else {
            completion(.failure(NSError(domain: "Classifier", code: 2, userInfo: [NSLocalizedDescriptionKey: "Ungültiges Bildformat"])))
            return
        }
        
        let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
        DispatchQueue.global(qos: .userInitiated).async {
            do {
                try handler.perform([request])
            } catch {
                completion(.failure(error))
            }
        }
    }
}

import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import java.io.IOException

class CloudAIService {
    private val client = OkHttpClient()
    private val mediaType = "application/json; charset=utf-8".toMediaType()

    fun generateText(prompt: String, callback: (String?) -> Unit) {
        val jsonPayload = """
            {
                "model": "gpt-4-mini",
                "messages": [{"role": "user", "content": "$prompt"}]
            }
        """.trimIndent()

        val requestBody = jsonPayload.toRequestBody(mediaType)
        val request = Request.Builder()
            .url("https://api.ghaznix.com/v1/ai/generate")
            .post(requestBody)
            .build()

        client.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {
                callback(null)
            }

            override fun onResponse(call: Call, response: Response) {
                if (response.isSuccessful) {
                    val responseString = response.body?.string()
                    callback(responseString)
                } else {
                    callback(null)
                }
            }
        })
    }
}

import Foundation

class CloudAIService {
    
    struct ChatRequest: Codable {
        let model: String
        let messages: [Message]
    }
    
    struct Message: Codable {
        let role: String
        let content: String
    }
    
    func generateText(prompt: String) async throws -> String {
        guard let url = URL(string: "https://api.ghaznix.com/v1/ai/generate") else {
            throw URLError(.badURL)
        }
        
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        
        let payload = ChatRequest(
            model: "gpt-4-mini",
            messages: [Message(role: "user", content: prompt)]
        )
        
        request.httpBody = try JSONEncoder().encode(payload)
        
        let (data, response) = try await URLSession.shared.data(for: request)
        
        guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
            throw URLError(.badServerResponse)
        }
        
        if let jsonString = String(data: data, encoding: .utf8) {
            return jsonString
        } else {
            throw URLError(.cannotDecodeContentData)
        }
    }
}