Battery Optimization for Mobile AI Apps in 20 Minutes

# Run on a physical device — simulators don't reflect real power draw
# Instruments → Energy Log → Start Recording
# Use your AI feature for 5 minutes, then export

# Enable battery stats collection
adb shell dumpsys batterystats --reset
adb shell dumpsys batterystats --enable full-wake-history

# Use app for 5 minutes, then pull report
adb bugreport bugreport.zip
# Upload to https://bathist.ef.lc/ for visual analysis

// iOS — Swift: Token bucket for inference scheduling
class InferenceScheduler {
    private var lastInferenceTime: Date = .distantPast
    private let minInterval: TimeInterval = 0.5 // 2 inferences/sec max

    func shouldRunInference() -> Bool {
        let now = Date()
        guard now.timeIntervalSince(lastInferenceTime) >= minInterval else {
            return false // Skip this frame
        }
        lastInferenceTime = now
        return true
    }
}

// Android — Kotlin: Debounced inference with coroutines
class InferenceScheduler {
    private val scope = CoroutineScope(Dispatchers.Default)
    private var debounceJob: Job? = null

    fun scheduleInference(input: FloatArray, onResult: (FloatArray) -> Unit) {
        debounceJob?.cancel()
        debounceJob = scope.launch {
            delay(500L) // Wait 500ms before running
            val result = runModel(input) // Your inference call
            withContext(Dispatchers.Main) { onResult(result) }
        }
    }
}

// iOS — CoreML lazy loading with background release
class ModelManager {
    private var model: VNCoreMLModel?
    private var idleTimer: Timer?

    func getModel() throws -> VNCoreMLModel {
        idleTimer?.invalidate()
        if model == nil {
            // Load only when needed — this takes ~150ms on A15+
            model = try VNCoreMLModel(for: MyModel(configuration: MLModelConfiguration()).model)
        }
        // Auto-release after 10 seconds of inactivity
        idleTimer = Timer.scheduledTimer(withTimeInterval: 10, repeats: false) { [weak self] _ in
            self?.model = nil
        }
        return model!
    }
}

// Android — TensorFlow Lite with explicit lifecycle
class ModelManager(context: Context) : DefaultLifecycleObserver {
    private var interpreter: Interpreter? = null
    private val modelBuffer by lazy { loadModelFile(context, "model.tflite") }

    override fun onStart(owner: LifecycleOwner) {
        // Load when app comes to foreground
        interpreter = Interpreter(modelBuffer, Interpreter.Options().apply {
            setNumThreads(2) // Cap threads — more isn't faster, just hotter
            setUseNNAPI(true) // Delegate to Neural Processing Unit when available
        })
    }

    override fun onStop(owner: LifecycleOwner) {
        interpreter?.close() // Release GPU/NPU resources immediately
        interpreter = null
    }
}

// Android — Try NNAPI → GPU → CPU fallback chain
fun createOptimizedInterpreter(context: Context, model: MappedByteBuffer): Interpreter {
    val options = Interpreter.Options()

    // Tier 1: NNAPI (Neural Processing Unit) — lowest power
    try {
        val nnapi = NnApiDelegate(NnApiDelegate.Options().apply {
            setAllowFp16(true) // 2x faster, minimal accuracy loss
            setExecutionPreference(NnApiDelegate.Options.EXECUTION_PREFERENCE_SUSTAINED_SPEED)
        })
        options.addDelegate(nnapi)
        return Interpreter(model, options)
    } catch (e: Exception) { /* NNAPI not supported, try GPU */ }

    // Tier 2: GPU delegate — moderate power
    try {
        options.addDelegate(GpuDelegate())
        return Interpreter(model, options)
    } catch (e: Exception) { /* No GPU support */ }

    // Tier 3: CPU fallback — cap threads to reduce heat
    options.setNumThreads(2)
    return Interpreter(model, options)
}

// iOS — CoreML automatically uses Neural Engine
// Force it explicitly to avoid falling back to CPU:
let config = MLModelConfiguration()
config.computeUnits = .cpuAndNeuralEngine // Exclude GPU for sustained workloads
// .all includes GPU which is faster but hotter for continuous inference

// iOS — Pause inference on background, resume on foreground
class AIFeatureController {
    private var isActive = true

    init() {
        NotificationCenter.default.addObserver(self,
            selector: #selector(appDidBackground),
            name: UIApplication.didEnterBackgroundNotification, object: nil)
        NotificationCenter.default.addObserver(self,
            selector: #selector(appWillForeground),
            name: UIApplication.willEnterForegroundNotification, object: nil)
    }

    @objc private func appDidBackground() {
        isActive = false
        ModelManager.shared.releaseModel() // Free hardware resources
    }

    @objc private func appWillForeground() {
        isActive = true
    }
}

// Android — Use ProcessLifecycleOwner for app-level background detection
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(object : DefaultLifecycleObserver {
            override fun onStop(owner: LifecycleOwner) {
                // App went to background — cancel any queued inference
                InferenceScheduler.cancelPending()
                ModelManager.release()
            }
        })
    }
}

# iOS: Re-run Instruments Energy Log with fixes applied
# Compare "Energy Impact" column before/after — target: Low or Fair (not High)

# Android: Re-run Battery Historian
adb shell dumpsys batterystats --reset
# Use app for 5 minutes
adb bugreport bugreport_after.zip