feat: Add REST API and Web UI for remote time tracking

app/build.gradle.kts

@@ -128,12 +128,14 @@ dependencies {
     implementation(project(":feature_change_goals"))
     implementation(project(":feature_change_goals:api"))
     implementation(project(":feature_change_goals:views"))
+    implementation(project(":wear_api"))
     "playImplementation"(project(":feature_wear"))
 
     implementation(libs.androidx.room)
     implementation(libs.ktx.navigationFragment)
     implementation(libs.ktx.navigationUi)
     implementation(libs.google.dagger)
+    implementation(libs.nanohttpd)
 
     ksp(libs.kapt.dagger)
     kspAndroidTest(libs.kapt.dagger)

app/src/main/AndroidManifest.xml

@@ -2,6 +2,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
 
+    <uses-permission android:name="android.permission.INTERNET" />
+
     <application
         android:name=".TimeTrackerApp"
         android:allowBackup="true"

app/src/main/java/com/example/util/simpletimetracker/TimeTrackerApp.kt

@@ -4,18 +4,30 @@ import android.app.Application
 import android.os.StrictMode
 import androidx.emoji2.bundled.BundledEmojiCompatConfig
 import androidx.emoji2.text.EmojiCompat
+import com.example.util.simpletimetracker.api.WebApiAdapter
 import dagger.hilt.android.HiltAndroidApp
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
 import timber.log.Timber
 import timber.log.Timber.DebugTree
+import javax.inject.Inject
 
 @HiltAndroidApp
 class TimeTrackerApp : Application() {
 
+    @Inject
+    lateinit var webApiAdapter: WebApiAdapter
+
+    private val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
     override fun onCreate() {
         super.onCreate()
         initLog()
         initLibraries()
         initStrictMode()
+        startWebApi()
     }
 
     private fun initLog() {
@@ -47,4 +59,15 @@ class TimeTrackerApp : Application() {
             )
         }
     }
+
+    private fun startWebApi() {
+        applicationScope.launch {
+            try {
+                webApiAdapter.start()
+                Timber.d("Web API started on port 8080")
+            } catch (e: Exception) {
+                Timber.e(e, "Failed to start Web API")
+            }
+        }
+    }
 }

app/src/play/java/com/example/util/simpletimetracker/api/WebApiAdapter.kt

@@ -0,0 +1,158 @@
+package com.example.util.simpletimetracker.api
+
+import com.example.util.simpletimetracker.wear_api.WearCommunicationAPI
+import com.example.util.simpletimetracker.wear_api.WearStartActivityRequest
+import com.example.util.simpletimetracker.wear_api.WearStopActivityRequest
+import fi.iki.elonen.NanoHTTPD
+import kotlinx.coroutines.runBlocking
+import org.json.JSONArray
+import org.json.JSONObject
+import javax.inject.Inject
+
+class WebApiAdapter @Inject constructor(
+    // Reuse the SAME interface that Wear OS uses!
+    private val wearApi: WearCommunicationAPI,
+) : NanoHTTPD(8080) {
+
+    override fun serve(session: IHTTPSession): Response {
+        val headers = mutableMapOf(
+            "Access-Control-Allow-Origin" to "*",
+            "Access-Control-Allow-Methods" to "GET, POST, OPTIONS",
+            "Access-Control-Allow-Headers" to "Content-Type"
+        )
+
+        if (session.method == Method.OPTIONS) {
+            return newFixedLengthResponse(Response.Status.OK, MIME_PLAINTEXT, "")
+                .apply { headers.forEach { (k, v) -> addHeader(k, v) } }
+        }
+
+        return try {
+            when {
+                // GET /api/activities
+                session.uri == "/api/activities" && session.method == Method.GET -> {
+                    getAllActivities(headers)
+                }
+                // GET /api/running
+                session.uri == "/api/running" && session.method == Method.GET -> {
+                    getRunningActivities(headers)
+                }
+                // POST /api/start/:id
+                session.uri.startsWith("/api/start/") && session.method == Method.POST -> {
+                    val id = session.uri.substringAfterLast("/").toLongOrNull()
+                    startActivity(id, headers)
+                }
+                // POST /api/stop/:id
+                session.uri.startsWith("/api/stop/") && session.method == Method.POST -> {
+                    val id = session.uri.substringAfterLast("/").toLongOrNull()
+                    stopActivity(id, headers)
+                }
+                else -> {
+                    newFixedLengthResponse(
+                        Response.Status.NOT_FOUND,
+                        "application/json",
+                        """{"error": "Not found"}"""
+                    ).apply { headers.forEach { (k, v) -> addHeader(k, v) } }
+                }
+            }
+        } catch (e: Exception) {
+            newFixedLengthResponse(
+                Response.Status.INTERNAL_ERROR,
+                "application/json",
+                """{"error": "${e.message}"}"""
+            ).apply { headers.forEach { (k, v) -> addHeader(k, v) } }
+        }
+    }
+
+    private fun getAllActivities(headers: Map<String, String>): Response = runBlocking {
+        // Reuse the EXACT same method Wear OS uses!
+        val activities = wearApi.queryActivities()
+        val currentState = wearApi.queryCurrentActivities()
+        val runningIds = currentState.currentActivities.map { it.id }.toSet()
+
+        val json = JSONArray()
+        activities.forEach { activity ->
+            json.put(JSONObject().apply {
+                put("id", activity.id)
+                put("name", activity.name)
+                put("icon", activity.icon)
+                put("color", activity.color)
+                put("isRunning", runningIds.contains(activity.id))
+            })
+        }
+
+        newFixedLengthResponse(
+            Response.Status.OK,
+            "application/json",
+            json.toString()
+        ).apply {
+            headers.forEach { (k, v) -> addHeader(k, v) }
+        }
+    }
+
+    private fun getRunningActivities(headers: Map<String, String>): Response = runBlocking {
+        // Reuse the EXACT same method Wear OS uses!
+        val currentState = wearApi.queryCurrentActivities()
+        val activities = wearApi.queryActivities().associateBy { it.id }
+
+        val json = JSONArray()
+        currentState.currentActivities.forEach { current ->
+            val activity = activities[current.id]
+            json.put(JSONObject().apply {
+                put("id", current.id)
+                put("name", activity?.name ?: "Unknown")
+                put("timeStarted", current.startedAt)
+                put("duration", System.currentTimeMillis() - current.startedAt)
+            })
+        }
+
+        newFixedLengthResponse(
+            Response.Status.OK,
+            "application/json",
+            json.toString()
+        ).apply {
+            headers.forEach { (k, v) -> addHeader(k, v) }
+        }
+    }
+
+    private fun startActivity(id: Long?, headers: Map<String, String>): Response = runBlocking {
+        if (id == null) {
+            return@runBlocking newFixedLengthResponse(
+                Response.Status.BAD_REQUEST,
+                "application/json",
+                """{"error": "Invalid ID"}"""
+            )
+        }
+
+        // Reuse the EXACT same method Wear OS uses!
+        wearApi.startActivity(WearStartActivityRequest(id = id, tags = null))
+
+        newFixedLengthResponse(
+            Response.Status.OK,
+            "application/json",
+            """{"success": true}"""
+        ).apply {
+            headers.forEach { (k, v) -> addHeader(k, v) }
+        }
+    }
+
+    private fun stopActivity(id: Long?, headers: Map<String, String>): Response = runBlocking {
+        if (id == null) {
+            return@runBlocking newFixedLengthResponse(
+                Response.Status.BAD_REQUEST,
+                "application/json",
+                """{"error": "Invalid ID"}"""
+            )
+        }
+
+        // Reuse the EXACT same method Wear OS uses!
+        wearApi.stopActivity(WearStopActivityRequest(id = id))
+
+        newFixedLengthResponse(
+            Response.Status.OK,
+            "application/json",
+            """{"success": true}"""
+        ).apply {
+            headers.forEach { (k, v) -> addHeader(k, v) }
+        }
+    }
+}

app/src/play/java/com/example/util/simpletimetracker/api/WebApiModule.kt

@@ -0,0 +1,19 @@
+package com.example.util.simpletimetracker.api
+
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+object WebApiModule {
+    @Provides
+    @Singleton
+    fun provideWebApiAdapter(
+        wearApi: com.example.util.simpletimetracker.wear_api.WearCommunicationAPI
+    ): WebApiAdapter {
+        return WebApiAdapter(wearApi)
+    }
+}

gradle/libs.versions.toml

@@ -6,6 +6,7 @@ ksp = "1.9.25-1.0.20" # same as kotlin
 marathon = "0.10.3"
 
 coroutines = "1.6.4"
+nanohttpd = "2.3.1"
 timber = "4.7.1"
 javax = "1"
 
@@ -55,6 +56,7 @@ rules = "1.5.0"
 kotlin = { group = "org.jetbrains.kotlin", name = "kotlin-stdlib", version.ref = "kotlin" }
 coroutines = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-android", version.ref = "coroutines" }
 javax = { group = "javax.inject", name = "javax.inject", version.ref = "javax" }
+nanohttpd = { module = "org.nanohttpd:nanohttpd", version.ref = "nanohttpd" }
 timber = { group = "com.jakewharton.timber", name = "timber", version.ref = "timber" }
 
 # Androidx