Better APIs

SessionHero01 · SessionHero01 · commit 402869824c4d · 2025-08-07T23:14:03.000+10:00
diff --git a/android_lib/demoapp/src/main/java/dev/fanchao/demoapp/MainActivity.kt b/android_lib/demoapp/src/main/java/dev/fanchao/demoapp/MainActivity.kt
@@ -8,10 +8,9 @@ import androidx.sqlite.db.SupportSQLiteDatabase
 import androidx.sqlite.db.SupportSQLiteOpenHelper
 import androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactory
 import dev.fanchao.demoapp.databinding.ActivityMainBinding
+import dev.fanchao.sqliteviewer.StartedInstance
 import dev.fanchao.sqliteviewer.model.SupportQueryable
 import dev.fanchao.sqliteviewer.startDatabaseViewerServer
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.Job
 import kotlin.getValue
 
 class MainActivity : ComponentActivity() {
@@ -45,25 +44,22 @@ class MainActivity : ComponentActivity() {
         val binding = ActivityMainBinding.inflate(LayoutInflater.from(this))
         setContentView(binding.root)
 
-        var job: Job? = null
+        var instance: StartedInstance? = null
 
         binding.start.setOnClickListener {
-            job = startDatabaseViewerServer(
+            instance = startDatabaseViewerServer(
                 context = this,
-                scope = GlobalScope,
                 port = 3000,
                 queryable = SupportQueryable(factory.writableDatabase)
             )
 
-            if (job != null) {
-                binding.start.isEnabled = false
-                binding.stop.isEnabled = true
-            }
+            binding.start.isEnabled = false
+            binding.stop.isEnabled = true
         }
 
         binding.stop.setOnClickListener {
-            job?.cancel()
-            job = null
+            instance?.stop()
+            instance = null
 
             binding.start.isEnabled = true
             binding.stop.isEnabled = false
diff --git a/android_lib/library/src/androidMain/AndroidManifest.xml b/android_lib/library/src/androidMain/AndroidManifest.xml
@@ -6,10 +6,14 @@
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <application>
-        <service android:name="dev.fanchao.sqliteviewer.DatabaseViewerService"
-            android:foregroundServiceType="specialUse"
-            android:exported="false" />
+        <service
+            android:name="dev.fanchao.sqliteviewer.DatabaseViewerService"
+            android:exported="false"
+            android:foregroundServiceType="specialUse" />
         <activity android:name="dev.fanchao.sqliteviewer.PermissionRequestActivity" />
+        <receiver
+            android:name="dev.fanchao.sqliteviewer.CopyTextReceiver"
+            android:exported="false" />
     </application>
 
 </manifest>
diff --git a/android_lib/library/src/androidMain/kotlin/dev/fanchao/sqliteviewer/CopyTextReceiver.kt b/android_lib/library/src/androidMain/kotlin/dev/fanchao/sqliteviewer/CopyTextReceiver.kt
@@ -0,0 +1,24 @@
+package dev.fanchao.sqliteviewer
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.widget.Toast
+
+class CopyTextReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        val textToCopy = intent.getStringExtra(EXTRA_TEXT) ?: return
+
+        // Use the ClipboardManager to copy the text
+        val clipboard =
+            context.getSystemService(Context.CLIPBOARD_SERVICE) as android.content.ClipboardManager
+        val clip = android.content.ClipData.newPlainText("Copied Text", textToCopy)
+        clipboard.setPrimaryClip(clip)
+
+        Toast.makeText(context, "\"$textToCopy\" copied", Toast.LENGTH_SHORT).show()
+    }
+
+    companion object {
+        const val EXTRA_TEXT = "text_to_copy"
+    }
+}
diff --git a/android_lib/library/src/androidMain/kotlin/dev/fanchao/sqliteviewer/DatabaseViewerServer.android.kt b/android_lib/library/src/androidMain/kotlin/dev/fanchao/sqliteviewer/DatabaseViewerServer.android.kt
@@ -7,39 +7,63 @@ import android.content.Intent
 import android.content.IntentFilter
 import android.os.Build
 import dev.fanchao.sqliteviewer.model.Queryable
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Job
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.flow.takeWhile
+import kotlinx.coroutines.flow.transformWhile
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
 import java.lang.ref.WeakReference
 import kotlin.coroutines.resume
 
 fun startDatabaseViewerServer(
     context: Activity,
-    scope: CoroutineScope,
     port: Int,
     queryable: Queryable,
-): Job? {
+): StartedInstance {
     val contextRef = WeakReference(context)
     val applicationContext = context.applicationContext
 
-    return scope.launch {
-        val (job, actualPort) = startDatabaseViewerServerShared(
-            port = port,
-            queryable = queryable,
-            assetProvider = AndroidAssetProvider(applicationContext),
-        )
+    val instance = startDatabaseViewerServerShared(
+        port = port,
+        queryable = queryable,
+        assetProvider = AndroidAssetProvider(applicationContext),
+    )
 
-        val (intent, broadcastAction) = DatabaseViewerService.createStartIntent(applicationContext, port)
-        contextRef.get()?.startService(intent)
+    GlobalScope.launch {
+        instance.state
+            .transformWhile { state ->
+                emit(state)
+                state !is StartedInstance.State.Stopped
+            }
+            .collect { state ->
+                when (state) {
+                    StartedInstance.State.Starting -> {}
 
-        try {
-            waitForBroadcast(applicationContext, broadcastAction)
-        } finally {
-            applicationContext.startService(DatabaseViewerService.createStopIntent(applicationContext, actualPort))
-            job.cancel()
-        }
+                    is StartedInstance.State.Running -> {
+                        val (intent, broadcastAction) = DatabaseViewerService.createStartIntent(applicationContext, port)
+                        contextRef.get()?.startService(intent)
+
+                        launch {
+                            waitForBroadcast(applicationContext, broadcastAction)
+                            instance.stop()
+                        }
+                    }
+
+                    is StartedInstance.State.Stopped -> {
+                        if (state.port != null) {
+                            applicationContext.startService(
+                                DatabaseViewerService.createStopIntent(
+                                    context = applicationContext,
+                                    port = state.port
+                                )
+                            )
+                        }
+                    }
+                }
+            }
     }
+
+    return instance
 }
 
 private suspend fun waitForBroadcast(
diff --git a/android_lib/library/src/androidMain/kotlin/dev/fanchao/sqliteviewer/DatabaseViewerService.kt b/android_lib/library/src/androidMain/kotlin/dev/fanchao/sqliteviewer/DatabaseViewerService.kt
@@ -5,10 +5,13 @@ import android.app.PendingIntent
 import android.app.Service
 import android.content.Context
 import android.content.Intent
+import android.os.Build
 import android.os.IBinder
 import androidx.core.app.NotificationChannelCompat
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
+import java.net.Inet4Address
+import java.net.NetworkInterface
 
 internal typealias BroadcastAction = String
 
@@ -27,21 +30,61 @@ internal class DatabaseViewerService : Service() {
 
         NotificationManagerCompat.from(this).createNotificationChannel(channel)
 
+        val ipAddresses = NetworkInterface.getNetworkInterfaces()
+            .asSequence()
+            .flatMap { it.inetAddresses.asSequence() }
+            .filter { !it.isLoopbackAddress && !it.isMulticastAddress }
+            .filterIsInstance<Inet4Address>()
+            .toSet()
+
         for (port in startedPorts) {
-            startForeground(port, NotificationCompat.Builder(this, channel.id)
-                .setContentTitle("Server running")
-                .setContentText("Listening on port $port")
+            val listeningOn = ipAddresses.map { "${it.hostAddress}:$port" } + "localhost:$port"
+            val listeningOnText = listeningOn.joinToString(separator = ", ")
+
+            val builder = NotificationCompat.Builder(this, channel.id)
+                .setOngoing(true)
+                .setContentTitle("SQLite Viewer Service running")
+                .setContentText("Listening on $listeningOnText")
                 // Set small icon to the package's launcher icon
                 .setSmallIcon(R.drawable.outline_architecture)
-                .addAction(R.drawable.ic_stop, "Stop", PendingIntent.getBroadcast(
-                    this,
-                    0,
-                    Intent("${STOP_BROADCAST_ACTION_PREFIX}$port").apply {
-                        `package` = this@DatabaseViewerService.packageName
-                    },
-                    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-                ))
-                .build())
+                .addAction(
+                    R.drawable.ic_stop, "Stop", PendingIntent.getBroadcast(
+                        this,
+                        0,
+                        Intent("${STOP_BROADCAST_ACTION_PREFIX}$port").apply {
+                            `package` = this@DatabaseViewerService.packageName
+                        },
+                        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+                    )
+                )
+                .addAction(
+                    R.drawable.baseline_article_24, "Copy adb command", PendingIntent.getBroadcast(
+                        this,
+                        1,
+                        Intent(this, CopyTextReceiver::class.java)
+                            .putExtra(
+                                CopyTextReceiver.EXTRA_TEXT,
+                                "adb forward tcp:$port tcp:$port"
+                            ),
+                        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+
+                    )
+                )
+
+            for ((index, address) in listeningOn.withIndex()) {
+                builder.addAction(
+                    R.drawable.baseline_article_24, "Copy \"$address\"",
+                    PendingIntent.getBroadcast(
+                        this,
+                        index + 2,
+                        Intent(this, CopyTextReceiver::class.java)
+                            .putExtra(CopyTextReceiver.EXTRA_TEXT, address),
+                        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+                    )
+                )
+            }
+
+            startForeground(port, builder.build())
         }
     }
 
diff --git a/android_lib/library/src/androidMain/res/drawable/baseline_article_24.xml b/android_lib/library/src/androidMain/res/drawable/baseline_article_24.xml
@@ -0,0 +1,5 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:autoMirrored="true" android:height="24dp" android:tint="#000000" android:viewportHeight="24" android:viewportWidth="24" android:width="24dp">
+      
+    <path android:fillColor="@android:color/white" android:pathData="M19,3L5,3c-1.1,0 -2,0.9 -2,2v14c0,1.1 0.9,2 2,2h14c1.1,0 2,-0.9 2,-2L21,5c0,-1.1 -0.9,-2 -2,-2zM14,17L7,17v-2h7v2zM17,13L7,13v-2h10v2zM17,9L7,9L7,7h10v2z"/>
+    
+</vector>
diff --git a/android_lib/library/src/commonMain/kotlin/dev/fanchao/sqliteviewer/DatabaseViewerServer.kt b/android_lib/library/src/commonMain/kotlin/dev/fanchao/sqliteviewer/DatabaseViewerServer.kt
@@ -10,6 +10,7 @@ import io.ktor.serialization.kotlinx.json.json
 import io.ktor.server.application.Application
 import io.ktor.server.application.install
 import io.ktor.server.cio.CIO
+import io.ktor.server.engine.EmbeddedServer
 import io.ktor.server.engine.embeddedServer
 import io.ktor.server.plugins.contentnegotiation.ContentNegotiation
 import io.ktor.server.request.path
@@ -19,33 +20,75 @@ import io.ktor.server.response.respondSource
 import io.ktor.server.routing.get
 import io.ktor.server.routing.post
 import io.ktor.server.routing.routing
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.Job
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
+import kotlin.concurrent.atomics.AtomicBoolean
+import kotlin.concurrent.atomics.ExperimentalAtomicApi
+
+@OptIn(ExperimentalAtomicApi::class, DelicateCoroutinesApi::class)
+class StartedInstance (
+    private val server: EmbeddedServer<*, *>
+) {
+    sealed interface State {
+        data object Starting : State
+        data class Running(val port: Int) : State
+        data class Stopped(val port: Int?) : State
+    }
+
+    private val stopRequested = AtomicBoolean(false)
+
+    val state: StateFlow<State> = flow {
+        var port: Int? = null
+        try {
+            coroutineScope {
+                val startJob = launch {
+                    server.startSuspend(wait = true)
+                }
+
+                port = server.engine.resolvedConnectors().first().port
+                emit(State.Running(port))
+                startJob.join() // Wait for the server to finish starting
+            }
+        } catch (e: Throwable) {
+            if (e is CancellationException) throw e
+        } finally {
+            emit(State.Stopped(port))
+        }
+    }.stateIn(GlobalScope, started = SharingStarted.Eagerly, initialValue = State.Starting)
+
+    fun stop() {
+        if (stopRequested.compareAndSet(expectedValue = false, newValue = true)) {
+            GlobalScope.launch {
+                server.stopSuspend()
+            }
+        }
+    }
+}
 
 /**
  * Launches the Ktor server in a new Job, returns Pair<Job, Deferred<Int>>.
  * Job is the server handle (cancel to stop), Deferred<Int> completes with the bound port.
  */
-suspend fun startDatabaseViewerServerShared(
+fun startDatabaseViewerServerShared(
     port: Int,
     queryable: Queryable,
     assetProvider: StaticAssetProvider,
-): Pair<Job, Int> {
+): StartedInstance {
     val server = embeddedServer(
         factory = CIO,
         port = port,
     ) {
         configureDatabaseViewerRouting(queryable, assetProvider)
     }
 
-    val job = GlobalScope.launch {
-        runCatching {  server.startSuspend(wait = true) }
-        server.stop(1000, 1000)
-    }
-
-    val port = server.engine.resolvedConnectors().first().port
-    return job to port
+    return StartedInstance(server)
 }
 
 private fun Application.configureDatabaseViewerRouting(queryable: Queryable, assetProvider: StaticAssetProvider) {
