Building Mobile AI Apps with Google Nano Banana Pro

# Download via command line
gsutil -m cp gs://google-ai-models/nano-banana-pro-v1.0.tar.gz ./

# Verify integrity
sha256sum nano-banana-pro-v1.0.tar.gz
# Expected: abc123def456... (provided by Google)

# Extract
tar -xzf nano-banana-pro-v1.0.tar.gz

buildscript {
    repositories {
        google()
        mavenCentral()
        maven { url 'https://google-ai-models.storage.googleapis.com/maven' }
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:8.2.0'
        classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.0'
    }
}

plugins {
    id 'com.android.application'
    id 'kotlin-android'
}

android {
    compileSdk 34
    defaultConfig {
        applicationId "com.example.mobileai"
        minSdk 24
        targetSdk 34
        versionCode 1
        versionName "1.0"
    }

    buildFeatures {
        viewBinding true
    }
}

dependencies {
    // Core Nano Banana Pro
    implementation("com.google.ai.edge:nano-banana-pro:1.0.0")

    // Kotlin coroutines for async operations
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")

    // AndroidX libraries
    implementation("androidx.appcompat:appcompat:1.6.1")
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.6.2")

    // For AI model optimization
    implementation("com.google.ai.edge:acceleration-tools:1.0.0")

    // Testing
    testImplementation("junit:junit:4.13.2")
    androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
}

// ModelManager.kt
import android.content.Context
import com.google.ai.edge.nanobananapro.NanoBananaPro
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

class ModelManager(private val context: Context) {
    private var model: NanoBananaPro? = null
    private var isLoading = false

    suspend fun initializeModel(): Result<Unit> = withContext(Dispatchers.IO) {
        return@withContext try {
            if (model != null) {
                return@withContext Result.success(Unit)
            }

            isLoading = true

            // Download model if not cached
            val modelPath = context.getExternalFilesDir("models")?.absolutePath
                ?: throw IllegalStateException("Model directory unavailable")

            model = NanoBananaPro.Builder(context)
                .setModelPath(modelPath)
                .setDeviceOptimization(true)
                .setMaxCacheSize(512) // MB
                .build()

            isLoading = false
            Result.success(Unit)
        } catch (e: Exception) {
            isLoading = false
            Result.failure(e)
        }
    }

    suspend fun generateText(
        prompt: String,
        maxTokens: Int = 500,
        temperature: Float = 0.7f
    ): Result<String> = withContext(Dispatchers.Default) {
        return@withContext try {
            val currentModel = model
                ?: return@withContext Result.failure(
                    IllegalStateException("Model not initialized")
                )

            val response = currentModel.generateText(
                prompt = prompt,
                maxTokens = maxTokens,
                temperature = temperature,
                topP = 0.95f,
                topK = 40
            )

            Result.success(response.text)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }

    suspend fun streamText(
        prompt: String,
        maxTokens: Int = 500,
        onToken: suspend (String) -> Unit
    ): Result<Unit> = withContext(Dispatchers.Default) {
        return@withContext try {
            val currentModel = model
                ?: return@withContext Result.failure(
                    IllegalStateException("Model not initialized")
                )

            currentModel.streamText(
                prompt = prompt,
                maxTokens = maxTokens,
                temperature = 0.7f
            ) { token ->
                onToken(token)
            }

            Result.success(Unit)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }

    fun unloadModel() {
        model?.close()
        model = null
    }
}

// AIAssistantActivity.kt
import android.os.Bundle
import android.view.View
import android.widget.Button
import android.widget.EditText
import android.widget.ProgressBar
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.launch

class AIAssistantActivity : AppCompatActivity() {
    private lateinit var modelManager: ModelManager
    private lateinit var inputText: EditText
    private lateinit var outputText: TextView
    private lateinit var generateButton: Button
    private lateinit var loadingIndicator: ProgressBar

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_ai_assistant)

        // Initialize views
        inputText = findViewById(R.id.input_text)
        outputText = findViewById(R.id.output_text)
        generateButton = findViewById(R.id.generate_button)
        loadingIndicator = findViewById(R.id.loading)

        // Initialize model manager
        modelManager = ModelManager(this)

        // Load model on startup
        lifecycleScope.launch {
            loadingIndicator.visibility = View.VISIBLE
            val result = modelManager.initializeModel()
            loadingIndicator.visibility = View.GONE

            result.onFailure { error ->
                outputText.text = "Failed to load model: ${error.message}"
            }
        }

        // Set up generate button
        generateButton.setOnClickListener {
            val prompt = inputText.text.toString()
            if (prompt.isNotEmpty()) {
                generateResponse(prompt)
            }
        }
    }

    private fun generateResponse(prompt: String) {
        lifecycleScope.launch {
            loadingIndicator.visibility = View.VISIBLE
            generateButton.isEnabled = false
            outputText.text = ""

            // Stream text for better UX
            modelManager.streamText(
                prompt = prompt,
                maxTokens = 500,
                onToken = { token ->
                    outputText.append(token)
                }
            ).onFailure { error ->
                outputText.text = "Generation failed: ${error.message}"
            }

            loadingIndicator.visibility = View.GONE
            generateButton.isEnabled = true
        }
    }

    override fun onDestroy() {
        modelManager.unloadModel()
        super.onDestroy()
    }
}

// DeviceOptimizer.kt
import android.app.ActivityManager
import android.content.Context
import android.os.Debug

class DeviceOptimizer(private val context: Context) {
    fun getAvailableMemory(): Long {
        val runtime = Runtime.getRuntime()
        return runtime.maxMemory() - (runtime.totalMemory() - runtime.freeMemory())
    }

    fun isMemorySufficient(): Boolean {
        return getAvailableMemory() > 1_500_000_000 // 1.5GB minimum
    }

    fun canRunInference(): Boolean {
        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE)
            as ActivityManager
        val memInfo = ActivityManager.MemoryInfo()
        activityManager.getMemoryInfo(memInfo)

        return !memInfo.lowMemory && isMemorySufficient()
    }

    fun getBatteryOptimizedSettings(): InferenceSettings {
        val isBatteryLow = context.resources.configuration.isScreenOn == false

        return InferenceSettings(
            maxTokens = if (isBatteryLow) 200 else 500,
            temperature = 0.7f,
            useFastExecution = isBatteryLow,
            enableCaching = true
        )
    }
}

data class InferenceSettings(
    val maxTokens: Int,
    val temperature: Float,
    val useFastExecution: Boolean,
    val enableCaching: Boolean
)

# Podfile
platform :ios, '14.0'

target 'MobileAIApp' do
    pod 'GoogleAINanoBananaPro', '~> 1.0'
    pod 'Alamofire', '~> 5.8'
    pod 'SnapKit', '~> 5.6'

    # Optional: for advanced UI
    pod 'Kingfisher', '~> 7.0'
    pod 'RxSwift', '~> 6.0'
end

pod install

// ModelManager.swift
import GoogleAINanoBananaPro
import Foundation

actor ModelManager {
    static let shared = ModelManager()

    private var model: NanoBananaPro?
    private(set) var isLoaded = false
    private var loadingTask: Task<Void, Error>?

    func initializeModel() async throws {
        // Return existing task if already loading
        if let existingTask = loadingTask {
            try await existingTask.value
            return
        }

        // Return early if already loaded
        if isLoaded { return }

        let task = Task {
            try await performInitialization()
        }
        loadingTask = task
        try await task.value
    }

    private func performInitialization() async throws {
        let modelPath = FileManager.default.urls(
            for: .documentDirectory,
            in: .userDomainMask
        )[0].appendingPathComponent("models")

        // Create directory if needed
        try? FileManager.default.createDirectory(
            at: modelPath,
            withIntermediateDirectories: true
        )

        model = try await NanoBananaPro.load(
            modelPath: modelPath.path,
            configuration: .default
        )

        isLoaded = true
    }

    func generateText(
        prompt: String,
        maxTokens: Int = 500,
        temperature: Float = 0.7
    ) async throws -> String {
        guard let model = model else {
            throw NSError(domain: "ModelManager", code: -1,
                         userInfo: [NSLocalizedDescriptionKey: "Model not loaded"])
        }

        let response = try await model.generateText(
            prompt: prompt,
            parameters: GenerationParameters(
                maxTokens: maxTokens,
                temperature: temperature,
                topP: 0.95,
                topK: 40
            )
        )

        return response.text
    }

    func streamText(
        prompt: String,
        maxTokens: Int = 500
    ) async throws -> AsyncStream<String> {
        guard let model = model else {
            throw NSError(domain: "ModelManager", code: -1,
                         userInfo: [NSLocalizedDescriptionKey: "Model not loaded"])
        }

        return try await model.streamText(
            prompt: prompt,
            parameters: GenerationParameters(
                maxTokens: maxTokens,
                temperature: 0.7,
                topP: 0.95,
                topK: 40
            )
        )
    }

    func unload() {
        model = nil
        isLoaded = false
    }
}

// AIAssistantView.swift
import SwiftUI

struct AIAssistantView: View {
    @State private var inputText = ""
    @State private var outputText = ""
    @State private var isLoading = false
    @State private var modelError: String?
    @State private var modelLoaded = false

    var body: some View {
        VStack(spacing: 16) {
            // Header
            Text("AI Assistant")
                .font(.title)
                .fontWeight(.bold)

            // Input Section
            VStack(alignment: .leading, spacing: 8) {
                Text("Your Prompt")
                    .font(.headline)

                TextEditor(text: $inputText)
                    .frame(height: 100)
                    .border(Color.gray.opacity(0.3))
                    .cornerRadius(8)
                    .disabled(isLoading)
            }

            // Generate Button
            Button(action: generateResponse) {
                if isLoading {
                    HStack {
                        ProgressView()
                            .progressViewStyle(.circular)
                        Text("Generating...")
                    }
                } else {
                    Text("Generate Response")
                }
            }
            .frame(maxWidth: .infinity)
            .padding()
            .background(modelLoaded ? Color.blue : Color.gray)
            .foregroundColor(.white)
            .cornerRadius(8)
            .disabled(!modelLoaded || isLoading || inputText.isEmpty)

            // Output Section
            VStack(alignment: .leading, spacing: 8) {
                Text("Response")
                    .font(.headline)

                ScrollView {
                    Text(outputText.isEmpty ? "Response will appear here..." : outputText)
                        .frame(maxWidth: .infinity, alignment: .topLeading)
                        .padding()
                        .foregroundColor(outputText.isEmpty ? .gray : .black)
                }
                .frame(maxHeight: .infinity)
                .border(Color.gray.opacity(0.3))
                .cornerRadius(8)
            }

            // Error Display
            if let error = modelError {
                Text("Error: (error)")
                    .foregroundColor(.red)
                    .font(.caption)
            }
        }
        .padding()
        .onAppear(perform: loadModel)
    }

    private func loadModel() {
        Task {
            do {
                try await ModelManager.shared.initializeModel()
                modelLoaded = true
            } catch {
                modelError = error.localizedDescription
            }
        }
    }

    private func generateResponse() {
        guard !inputText.isEmpty else { return }

        Task {
            isLoading = true
            outputText = ""

            do {
                // Stream response token by token
                let stream = try await ModelManager.shared.streamText(
                    prompt: inputText,
                    maxTokens: 500
                )

                for try await token in stream {
                    await MainActor.run {
                        outputText.append(token)
                    }
                }
            } catch {
                modelError = error.localizedDescription
                outputText = "Generation failed: (error.localizedDescription)"
            }

            isLoading = false
        }
    }
}

#Preview {
    AIAssistantView()
}

// PromptTemplate.kt
data class PromptTemplate(
    val name: String,
    val template: String,
    val placeholders: List<String>
) {
    fun render(values: Map<String, String>): String {
        var result = template
        for ((key, value) in values) {
            result = result.replace("{$key}", value)
        }
        return result
    }
}

// Pre-built templates
object PromptTemplates {
    val contentRewriter = PromptTemplate(
        name = "Content Rewriter",
        template = """
            Rewrite the following content in a {tone} tone for a {audience} audience.

            Original content:
            {content}

            Rewritten version:
        """.trimIndent(),
        placeholders = listOf("tone", "audience", "content")
    )

    val codeExplainer = PromptTemplate(
        name = "Code Explainer",
        template = """
            Explain the following code in simple terms:

            ```{language}
            {code}
            ```

            Explanation:
        """.trimIndent(),
        placeholders = listOf("language", "code")
    )
}

// CacheManager.kt
import android.content.Context
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.stringPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import kotlinx.coroutines.flow.first
import java.time.Instant

private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(
    name = "ai_cache"
)

class CacheManager(private val context: Context) {
    private val requestKey = stringPreferencesKey("request")
    private val responseKey = stringPreferencesKey("response")
    private val timestampKey = stringPreferencesKey("timestamp")

    suspend fun cacheResponse(prompt: String, response: String) {
        context.dataStore.edit { preferences ->
            preferences[requestKey] = prompt
            preferences[responseKey] = response
            preferences[timestampKey] = Instant.now().toString()
        }
    }

    suspend fun getCachedResponse(prompt: String): String? {
        val preferences = context.dataStore.data.first()
        return if (preferences[requestKey] == prompt) {
            preferences[responseKey]
        } else {
            null
        }
    }
}

// PerformanceMonitor.kt
import android.app.ActivityManager
import android.content.Context
import android.os.BatteryManager
import android.os.Build

class PerformanceMonitor(private val context: Context) {
    fun shouldOptimizeForBattery(): Boolean {
        val batteryManager = context.getSystemService(
            Context.BATTERY_SERVICE
        ) as BatteryManager

        return batteryManager.getIntProperty(
            BatteryManager.BATTERY_PROPERTY_PERCENTAGE
        ) < 25
    }

    fun getRecommendedTokenLimit(): Int {
        return when {
            shouldOptimizeForBattery() -> 200
            isLowMemoryDevice() -> 300
            else -> 500
        }
    }

    private fun isLowMemoryDevice(): Boolean {
        val activityManager = context.getSystemService(
            Context.ACTIVITY_SERVICE
        ) as ActivityManager
        return activityManager.isLowRamDevice
    }

    fun getOptimalThreadCount(): Int {
        val processors = Runtime.getRuntime().availableProcessors()
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
            (processors / 2).coerceAtLeast(1)
        } else {
            1
        }
    }
}

// BatchProcessor.swift
import Foundation

actor BatchProcessor {
    private let modelManager: ModelManager
    private let batchSize = 5

    init(modelManager: ModelManager) {
        self.modelManager = modelManager
    }

    func processBatch(_ items: [String]) async throws -> [String] {
        var results: [String] = []

        for chunk in items.chunked(into: batchSize) {
            let chunkResults = try await withThrowingTaskGroup(
                of: String.self
            ) { group in
                for item in chunk {
                    group.addTask {
                        try await self.modelManager.generateText(
                            prompt: item,
                            maxTokens: 200
                        )
                    }
                }

                var chunkResults: [String] = []
                for try await result in group {
                    chunkResults.append(result)
                }
                return chunkResults
            }

            results.append(contentsOf: chunkResults)
        }

        return results
    }
}

extension Array {
    func chunked(into size: Int) -> [[Element]] {
        stride(from: 0, to: count, by: size).map {
            Array(self[$0..<Swift.min($0 + size, count)])
        }
    }
}

// SymptomCheckerActivity.kt
data class SymptomCheckResult(
    val symptoms: String,
    val analysis: String,
    val recommendations: String,
    val disclaimers: String
)

class SymptomCheckerActivity : AppCompatActivity() {
    private lateinit var modelManager: ModelManager

    private suspend fun checkSymptoms(symptomDescription: String): SymptomCheckResult {
        val prompt = """
            You are a healthcare information assistant. Based on the following
            symptoms, provide general health information. IMPORTANT: Always
            recommend consulting with a healthcare provider for proper diagnosis.

            Symptoms: $symptomDescription

            Provide:
            1. Analysis (what these symptoms might indicate)
            2. General recommendations
            3. When to seek immediate care
        """.trimIndent()

        val response = modelManager.generateText(prompt).getOrThrow()

        return SymptomCheckResult(
            symptoms = symptomDescription,
            analysis = extractSection(response, "Analysis"),
            recommendations = extractSection(response, "General recommendations"),
            disclaimers = "Always consult healthcare professionals for medical advice"
        )
    }

    private fun extractSection(text: String, header: String): String {
        val regex = Regex("(?:^|
)\d+.\s*$header[^:]*:(.*?)(?=
\d+.|$)")
        return regex.find(text)?.groupValues?.get(1)?.trim() ?: ""
    }
}

// FinanceAssistantView.swift
struct FinanceAssistantView: View {
    @State private var expenses: [Expense] = []
    @State private var analysis: String = ""

    func analyzeSpending() {
        Task {
            let expenseSummary = formatExpensesForAnalysis(expenses)

            let prompt = """
            Analyze these monthly expenses and provide budget recommendations:

            (expenseSummary)

            Categories to consider:
            - Essential vs. discretionary spending
            - Potential savings areas
            - Budget optimization tips
            """

            do {
                analysis = try await ModelManager.shared.generateText(
                    prompt: prompt,
                    maxTokens: 500
                )
            } catch {
                analysis = "Failed to analyze spending: (error.localizedDescription)"
            }
        }
    }

    private func formatExpensesForAnalysis(_ expenses: [Expense]) -> String {
        let grouped = Dictionary(grouping: expenses, by: { $0.category })
        return grouped.map { category, items in
            let total = items.reduce(0) { $0 + $1.amount }
            return "(category): $(total.formatted())"
        }.joined(separator: "
")
    }
}

struct Expense: Identifiable {
    let id = UUID()
    let category: String
    let amount: Double
    let date: Date
}

// Version tracking for model updates
ext {
    modelVersion = "1.0.0"
    minModelVersion = "1.0.0"
}

task checkModelVersion {
    doLast {
        println "Current model version: ${modelVersion}"
    }
}

assemble.dependsOn checkModelVersion

// ModelManagerTest.kt
import kotlinx.coroutines.test.runTest
import org.junit.Test

class ModelManagerTest {
    private lateinit var modelManager: ModelManager

    @Test
    fun testModelInitialization() = runTest {
        val result = modelManager.initializeModel()
        assert(result.isSuccess)
    }

    @Test
    fun testTextGeneration() = runTest {
        modelManager.initializeModel()

        val result = modelManager.generateText("Hello")
        assert(result.isSuccess)

        val text = result.getOrNull()
        assert(!text.isNullOrEmpty())
    }
}