Coverage / app/src/main/java/io/oxygenhub/android/runner/RunnerService.kt 0.0%

package io.oxygenhub.android.runner

import android.app.Notification

import android.app.NotificationChannel

import android.app.NotificationManager

import android.app.PendingIntent

import android.app.Service

import android.content.BroadcastReceiver

import android.content.Context

import android.content.Intent

import android.content.IntentFilter

import android.content.pm.ServiceInfo

import android.net.ConnectivityManager

import android.net.Network

import android.net.NetworkCapabilities

import android.os.Build

import android.os.IBinder

import io.oxygenhub.android.MainActivity

import io.oxygenhub.android.R

import uniffi.rust_core.runnerServe

import uniffi.rust_core.runnerStop

/**

 * Runs the phone's OxygenFlow runner (#8) in the foreground, with a

 * notification saying so, while the phone is on charge and on Wi-Fi.

 * Leaving the charger gives it a minute: it claims nothing more, finishes

 * a job the hub expects to end within it and hands back any other, its

 * checkpoint saved; leaving Wi-Fi hands the job back at once

 * (oxygenflow#76). While its owner wants it, the service

 * then waits, and serves again once the phone is back on charge and Wi-Fi.

 */

class RunnerService : Service() {

    private var serving: Thread? = null

    private var connectivity: ConnectivityManager.NetworkCallback? = null

    private var watching = false

    private val power = object : BroadcastReceiver() {

        override fun onReceive(context: Context, intent: Intent) {

            when (intent.action) {

                Intent.ACTION_POWER_DISCONNECTED -> {

                    PhoneRunner.leave("taken off charge", noticeSecs = 60)

                    notify("Leaving: taken off charge")

                }

                Intent.ACTION_POWER_CONNECTED -> serveIfAllowed()

            }

        }

    }

    override fun onBind(intent: Intent?): IBinder? = null

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {

        // The special-use type is Android 14's; before it, the manifest's type stands.

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {

            startForeground(NOTIFICATION, notification("Starting"), ServiceInfo.FOREGROUND_SERVICE_TYPE_SPECIAL_USE)

        } else {

            startForeground(NOTIFICATION, notification("Starting"))

        }

        if (!watching) {

            watching = true

            registerReceiver(

                power,

                IntentFilter().apply {

                    addAction(Intent.ACTION_POWER_DISCONNECTED)

                    addAction(Intent.ACTION_POWER_CONNECTED)

                },

            )

            watchNetwork()

        }

        serveIfAllowed()

        return START_NOT_STICKY

    }

    /**

     * Serve while the policy allows (on charge, on Wi-Fi), else wait for it

     * in the foreground, saying why. Called again when the charger or the

     * network comes back, and when serving ends while the owner still wants it.

     */

    @Synchronized

    private fun serveIfAllowed() {

        if (serving != null) return

        val blocked = PhoneRunner.blockedBy(this)

        if (blocked != null) {

            PhoneRunner.set(PhoneRunner.State.Waiting(blocked))

            notify("Waiting: $blocked")

            return

        }

        val home = PhoneRunner.home(this).path

        PhoneRunner.set(PhoneRunner.State.Running)

        notify("Waiting for WASM jobs, on charge and Wi-Fi")

        serving = Thread {

            val failed = try {

                runnerServe(home)

                null

            } catch (e: Exception) {

                e.message ?: "the runner stopped"

            }

            served(failed)

        }.apply {

            name = "oxygenflow-runner"

            start()

        }

    }

    /** Serving ended: wait for the charger and Wi-Fi again while the owner wants it, else stop. */

    @Synchronized

    private fun served(failed: String?) {

        serving = null

        when {

            failed != null -> {

                PhoneRunner.set(PhoneRunner.State.Failed(failed))

                stopSelf()

            }

            PhoneRunner.wanted(this) -> serveIfAllowed()

            else -> {

                PhoneRunner.set(PhoneRunner.State.Stopped)

                stopSelf()

            }

        }

    }

    /** Off Wi-Fi (or onto a metered network): leave, handing its job back to another runner (oxygenflow#76). */

    private fun watchNetwork() {

        val net = getSystemService(ConnectivityManager::class.java) ?: return

        val callback = object : ConnectivityManager.NetworkCallback() {

            override fun onLost(network: Network) {

                if (PhoneRunner.blockedBy(this@RunnerService) != null) {

                    PhoneRunner.leave("off Wi-Fi")

                    notify("Off Wi-Fi: handing its job back")

                }

            }

            override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) {

                if (caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)) {

                    serveIfAllowed()

                } else {

                    PhoneRunner.leave("on a metered network")

                    notify("On a metered network: handing its job back")

                }

            }

        }

        net.registerDefaultNetworkCallback(callback)

        connectivity = callback

    }

    override fun onDestroy() {

        runCatching { unregisterReceiver(power) }

        connectivity?.let { cb -> runCatching { getSystemService(ConnectivityManager::class.java)?.unregisterNetworkCallback(cb) } }

        // Stopped from outside (the app, the system): drain rather than leave a job behind.

        if (serving != null) runnerStop()

        super.onDestroy()

    }

    private fun notify(text: String) {

        getSystemService(NotificationManager::class.java)?.notify(NOTIFICATION, notification(text))

    }

    private fun notification(text: String): Notification {

        val manager = getSystemService(NotificationManager::class.java)

        manager?.createNotificationChannel(

            NotificationChannel(CHANNEL, "OxygenFlow runner", NotificationManager.IMPORTANCE_LOW).apply {

                description = "While this phone runs OxygenFlow jobs"

            },

        )

        val open = PendingIntent.getActivity(this, 0, Intent(this, MainActivity::class.java), PendingIntent.FLAG_IMMUTABLE)

        return Notification.Builder(this, CHANNEL)

            .setSmallIcon(R.drawable.ic_launcher_monochrome)

            .setContentTitle("OxygenFlow runner")

            .setContentText(text)

            .setContentIntent(open)

            .setOngoing(true)

            .build()

    }

    private companion object {

        const val CHANNEL = "runner"

        const val NOTIFICATION = 8

    }

}