ca30f73 · opencode-android

git.iko.soy/opencode-android

Fix 11 bugs: TTS data race, notif goAsync ANR, share/unshare idempotency, PartTimeInfo, re-share nav, mDNS stale-entry, delete-reschedule race, network handoff offline, activeRuns eviction, notif permission re-prompt

ca30f73iko3 months ago

app/src/main/java/soy/iko/opencode/MainActivity.kt+33−3

compare with master

unifiedsplit

@@ -38,6 +38,13 @@ class MainActivity : FragmentActivity() {

38 private var shareIntentHandled = false

39 private var openSessionHandled = false

40 private var newSessionHandled = false

41+ // Track whether the notification-permission prompt has been shown for this Activity

42+ // instance. onCreate only requests when savedInstanceState == null (a fresh process),

43+ // but an Activity recreated by a config change NOT listed in the manifest's configChanges

44+ // (e.g. a locale change) has a non-null savedInstanceState and would otherwise skip the

45+ // prompt forever. onResume re-requests once per instance when still ungranted so the user

46+ // is never silently left without notifications after such a recreation.

47+ private var notificationPermissionRequested = false

42 override fun onCreate(savedInstanceState: Bundle?) {

49 override fun onCreate(savedInstanceState: Bundle?) {

43 val splash = installSplashScreen()

50 val splash = installSplashScreen()

@@ -50,7 +57,14 @@ class MainActivity : FragmentActivity() {

50 }

57 }

51 val container = (application as OpencodeApp).container

58 val container = (application as OpencodeApp).container

52 handleIntent(intent)

59 handleIntent(intent)

60+ if (savedInstanceState == null) {

53− if (savedInstanceState == null) maybeRequestNotificationPermission()

61+ maybeRequestNotificationPermission()

62+ } else {

63+ // Restored instance: the permission may have been requested pre-recreation, but

64+ // we can't know the result from here. onResume will re-check and request if still

65+ // ungranted (once per Activity instance).

66+ notificationPermissionRequested = savedInstanceState.getBoolean(KEY_NOTIF_PERM_REQUESTED, false)

67+ }

54 // Hold the splash until the persisted theme and app-lock settings load, so we never

68 // Hold the splash until the persisted theme and app-lock settings load, so we never

55 // paint a frame with the defaults (dynamicColor=true / SYSTEM, app lock off) that then

69 // paint a frame with the defaults (dynamicColor=true / SYSTEM, app lock off) that then

56 // snap to the user's real choice — including a brief unlocked, un-FLAG_SECURE'd frame

70 // snap to the user's real choice — including a brief unlocked, un-FLAG_SECURE'd frame

@@ -112,6 +126,15 @@ class MainActivity : FragmentActivity() {

112 (application as OpencodeApp).container.setForeground(false)

126 (application as OpencodeApp).container.setForeground(false)

113 }

127 }

114

128

129+ override fun onResume() {

130+ super.onResume()

131+ // Re-check on resume: an Activity recreated by a config change not in configChanges

132+ // (e.g. locale) has savedInstanceState != null, so onCreate skipped the request. This

133+ // ensures the user is prompted once per Activity instance when still ungranted rather

134+ // than silently losing all notifications.

135+ maybeRequestNotificationPermission()

136+ }

137+

115 /** Capture text shared from another app so it can be prefilled into a session draft,

138 /** Capture text shared from another app so it can be prefilled into a session draft,

116 * and session ids from notification taps / deep links so we can open them. */

139 * and session ids from notification taps / deep links so we can open them. */

117 private fun handleIntent(intent: Intent?) {

140 private fun handleIntent(intent: Intent?) {

@@ -183,6 +206,7 @@ class MainActivity : FragmentActivity() {

183 private const val KEY_SHARE_HANDLED = "shareIntentHandled"

206 private const val KEY_SHARE_HANDLED = "shareIntentHandled"

184 private const val KEY_OPEN_SESSION_HANDLED = "openSessionHandled"

207 private const val KEY_OPEN_SESSION_HANDLED = "openSessionHandled"

185 private const val KEY_NEW_SESSION_HANDLED = "newSessionHandled"

208 private const val KEY_NEW_SESSION_HANDLED = "newSessionHandled"

209+ private const val KEY_NOTIF_PERM_REQUESTED = "notificationPermissionRequested"

186 }

210 }

187

211

188 override fun onSaveInstanceState(outState: Bundle) {

212 override fun onSaveInstanceState(outState: Bundle) {

@@ -190,13 +214,19 @@ class MainActivity : FragmentActivity() {

190 outState.putBoolean(KEY_SHARE_HANDLED, shareIntentHandled)

214 outState.putBoolean(KEY_SHARE_HANDLED, shareIntentHandled)

191 outState.putBoolean(KEY_OPEN_SESSION_HANDLED, openSessionHandled)

215 outState.putBoolean(KEY_OPEN_SESSION_HANDLED, openSessionHandled)

192 outState.putBoolean(KEY_NEW_SESSION_HANDLED, newSessionHandled)

216 outState.putBoolean(KEY_NEW_SESSION_HANDLED, newSessionHandled)

217+ outState.putBoolean(KEY_NOTIF_PERM_REQUESTED, notificationPermissionRequested)

193 }

218 }

194

219

195− /** Ask for POST_NOTIFICATIONS once on Android 13+ so run/completion notifications show. */

220+ /** Ask for POST_NOTIFICATIONS on Android 13+ so run/completion notifications show.

221+ * Idempotent per Activity instance via [notificationPermissionRequested]. */

196 private fun maybeRequestNotificationPermission() {

222 private fun maybeRequestNotificationPermission() {

223+ if (notificationPermissionRequested) return

197 if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return

224 if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return

198 val granted = ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) ==

225 val granted = ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) ==

199 PackageManager.PERMISSION_GRANTED

226 PackageManager.PERMISSION_GRANTED

227+ if (!granted) {

228+ notificationPermissionRequested = true

200− if (!granted) requestNotificationPermission.launch(Manifest.permission.POST_NOTIFICATIONS)

229+ requestNotificationPermission.launch(Manifest.permission.POST_NOTIFICATIONS)

230+ }

201 }

231 }

202}

232}

app/src/main/java/soy/iko/opencode/data/model/Common.kt+13

@@ -11,6 +11,19 @@ data class TimeInfo(

11 val completed: Long? = null,

12)

14+/** Timing carried by message parts and tool states. The opencode server sends `time: { start,

15+ * end?, compacted? }` for these (unlike Session/MessageInfo/Permission, which use the

16+ * created/updated/completed shape of [TimeInfo]). With `ignoreUnknownKeys`, modelling these

17+ * fields with [TimeInfo] would silently discard start/end/compacted — every part/tool time

18+ * would decode to all-nulls — so this separate shape exists for them. */

19+@Immutable

20+@Serializable

21+data class PartTimeInfo(

22+ val start: Long? = null,

23+ val end: Long? = null,

24+ val compacted: Long? = null,

25+)

26+

14@Immutable

27@Immutable

15@Serializable

28@Serializable

16data class Tokens(

29data class Tokens(

app/src/main/java/soy/iko/opencode/data/model/Part.kt+2−2

@@ -32,7 +32,7 @@ data class TextPart(

32 val text: String = "",

33 val synthetic: Boolean = false,

34 val ignored: Boolean = false,

35− val time: TimeInfo? = null,

35+ val time: PartTimeInfo? = null,

36) : Part

38@Immutable

@@ -43,7 +43,7 @@ data class ReasoningPart(

43 override val messageID: String? = null,

44 override val sessionID: String? = null,

45 val text: String = "",

46− val time: TimeInfo? = null,

46+ val time: PartTimeInfo? = null,

47) : Part

49@Immutable

app/src/main/java/soy/iko/opencode/data/model/ToolState.kt+3−3

@@ -25,7 +25,7 @@ data object ToolPending : ToolState

25data class ToolRunning(

26 val input: JsonElement? = null,

27 val title: String? = null,

28− val time: TimeInfo? = null,

28+ val time: PartTimeInfo? = null,

29) : ToolState

31@Immutable

@@ -35,7 +35,7 @@ data class ToolCompleted(

35 val input: JsonElement? = null,

36 val output: String? = null,

37 val title: String? = null,

38− val time: TimeInfo? = null,

38+ val time: PartTimeInfo? = null,

39) : ToolState

41@Immutable

@@ -44,7 +44,7 @@ data class ToolCompleted(

44data class ToolError(

45 val input: JsonElement? = null,

46 val error: String? = null,

47− val time: TimeInfo? = null,

47+ val time: PartTimeInfo? = null,

48) : ToolState

50/** Fallback for an unrecognized `status`. */

app/src/main/java/soy/iko/opencode/data/network/NetworkConfig.kt−2

@@ -153,8 +153,6 @@ object NetworkConfig {

153

154 /** Delay before retrying the message-activity observer after a failure. */

155 const val observerRetryDelayMs = 5_000L

156− /** Max concurrent assistant runs to track for completion notifications. */

157− const val activeRunsLimit = 200

158 /** Debounce before the run foreground-service is started/stopped in response to

156 /** Debounce before the run foreground-service is started/stopped in response to

159 * run-activity changes. A run that starts and then fails/idles almost immediately

157 * run-activity changes. A run that starts and then fails/idles almost immediately

160 * would otherwise dispatch startForegroundService() then stopService() back-to-back;

158 * would otherwise dispatch startForegroundService() then stopService() back-to-back;

app/src/main/java/soy/iko/opencode/data/network/NsdDiscovery.kt+12

@@ -52,6 +52,12 @@ open class NsdDiscovery(context: Context?) {

52 }

53 // Thread-safe: mutated by the resolver coroutine and the (main-thread) lost callback.

54 val found = java.util.concurrent.ConcurrentHashMap<String, DiscoveredServer>()

55+ // Names reported lost before the serialized resolver reached them. Without this, a

56+ // service that disappears between onServiceFound and the resolver dequeuing it would

57+ // be re-inserted into `found` after onServiceLost already fired (and returned null),

58+ // leaving a phantom entry that lingers until discovery stops — the lost callback never

59+ // fires twice for the same name. The resolver consults this set and skips the insert.

60+ val lostPending = java.util.Collections.newSetFromMap(java.util.concurrent.ConcurrentHashMap<String, Boolean>())

55 val toResolve = Channel<NsdServiceInfo>(Channel.UNLIMITED)

61 val toResolve = Channel<NsdServiceInfo>(Channel.UNLIMITED)

57 val resolver = launch {

63 val resolver = launch {

@@ -66,6 +72,9 @@ open class NsdDiscovery(context: Context?) {

66 // so every later-discovered service queued behind it is never processed and the

72 // so every later-discovered service queued behind it is never processed and the

67 // emitted list silently stops updating. Abandon a stuck resolve and keep draining.

73 // emitted list silently stops updating. Abandon a stuck resolve and keep draining.

68 val resolved = withTimeoutOrNull(RESOLVE_TIMEOUT_MS) { resolveService(nsd, info) } ?: continue

74 val resolved = withTimeoutOrNull(RESOLVE_TIMEOUT_MS) { resolveService(nsd, info) } ?: continue

75+ // The service was reported lost while queued behind other resolves: don't

76+ // resurrect it. Clear the marker so the name is free for a future re-appearance.

77+ if (lostPending.remove(discoveredName)) continue

69 val name = resolved.serviceName.orEmpty()

78 val name = resolved.serviceName.orEmpty()

70 // Keep only opencode's own advertisements, not every _http._tcp service

79 // Keep only opencode's own advertisements, not every _http._tcp service

71 // (printers, routers, other web servers) on the network.

80 // (printers, routers, other web servers) on the network.

@@ -84,6 +93,9 @@ open class NsdDiscovery(context: Context?) {

84 }

93 }

85 override fun onServiceLost(serviceInfo: NsdServiceInfo) {

94 override fun onServiceLost(serviceInfo: NsdServiceInfo) {

86 val name = serviceInfo.serviceName ?: return

95 val name = serviceInfo.serviceName ?: return

96+ // Mark the name lost so the resolver skips it if it hasn't been processed yet.

97+ // If it's already in `found` (resolved before the lost), remove and emit now.

98+ lostPending.add(name)

87 if (found.remove(name) != null) trySend(found.values.sortedBy { it.name })

99 if (found.remove(name) != null) trySend(found.values.sortedBy { it.name })

88 }

100 }

89 override fun onDiscoveryStopped(serviceType: String?) {}

101 override fun onDiscoveryStopped(serviceType: String?) {}

app/src/main/java/soy/iko/opencode/data/network/OpencodeApiClient.kt+21−6

@@ -223,14 +223,29 @@ open class OpencodeApiClient private constructor(

223 client!!.post("session/${encode(sessionId)}/unrevert").body()

224 }

225

226− /** Create a public share link for the session. Returns the session with [Session.share] set. */

226+ /** Create a public share link for the session. Returns the session with [Session.share] set.

227+ * Mint the Idempotency-Key *before* withRetry so a retried POST (first request reached the

228+ * server but its response was lost) doesn't create a second, orphaned, still-valid share. */

227− open suspend fun shareSession(sessionId: String): Session = withRetry {

229+ open suspend fun shareSession(sessionId: String): Session {

230+ val idempotencyKey = java.util.UUID.randomUUID().toString()

231+ return withRetry {

228− client!!.post("session/${encode(sessionId)}/share").body()

232+ client!!.post("session/${encode(sessionId)}/share") {

233+ header("Idempotency-Key", idempotencyKey)

234+ }.body()

235+ }

229 }

236 }

230

237

231− /** Revoke the session's public share link. Returns the session with share cleared. */

238+ /** Revoke the session's public share link. Returns the session with share cleared.

239+ * Like [deleteSession], a retried DELETE (first reached the server but the response was

240+ * lost) hits an already-unshared session and gets 404 — revoking a non-shared session is

241+ * effectively success, so swallow 404 rather than surfacing a spurious failure. */

232− open suspend fun unshareSession(sessionId: String): Session = withRetry {

242+ open suspend fun unshareSession(sessionId: String): Session {

243+ return try {

233− client!!.delete("session/${encode(sessionId)}/share").body()

244+ withRetry { client!!.delete("session/${encode(sessionId)}/share").body() }

245+ } catch (t: ClientRequestException) {

246+ if (t.response.status.value != 404) throw t

247+ client!!.get("session/${encode(sessionId)}").body()

248+ }

234 }

249 }

235

250

236 /** Ask the agent to summarize/compact the conversation to reclaim context. The compacted

251 /** Ask the agent to summarize/compact the conversation to reclaim context. The compacted

app/src/main/java/soy/iko/opencode/di/AppContainer.kt+62−45

@@ -535,12 +535,9 @@ open class AppContainer private constructor(

535 // represent a finished run worth notifying about.

536 if (isLiveRunActivity(event)) {

537 // The add-under-lock is required both for thread-safety and for the

538− // LRU access-order refresh (keeps a continuously-streaming session

538+ // access-order refresh (keeps a continuously-streaming session from

539− // from being evicted), so it runs per event.

539+ // being evicted), so it runs per event.

540 synchronized(activeRuns) {

541− if (activeRuns.size >= activeRunsLimit) {

542− activeRuns.remove(activeRuns.iterator().next())

543− }

544 activeRuns.add(sid)

541 activeRuns.add(sid)

545 // Derive the flag from the set state *inside* the same lock that

542 // Derive the flag from the set state *inside* the same lock that

546 // guards the set, so a concurrent reconnect sweep (which clears

543 // guards the set, so a concurrent reconnect sweep (which clears

@@ -577,9 +574,11 @@ open class AppContainer private constructor(

577 /** Session ids currently streaming an assistant run (best-effort, in-process). Backed by

574 /** Session ids currently streaming an assistant run (best-effort, in-process). Backed by

578 * an access-order [java.util.LinkedHashMap] so re-adding an already-present id on each

575 * an access-order [java.util.LinkedHashMap] so re-adding an already-present id on each

579 * streaming event refreshes its recency (a plain LinkedHashSet.add is a no-op that does

576 * streaming event refreshes its recency (a plain LinkedHashSet.add is a no-op that does

580− * NOT reorder). This keeps a long, continuously-streaming session from being evicted as

577+ * NOT reorder). Entries are drained by [SessionIdle] (and cleared wholesale on reconnect

581− * the eldest once [activeRunsLimit] other sessions appear — which would drop its

578+ * reconcile); we intentionally do NOT cap the set, because evicting the eldest would drop

582− * completion notification when its SessionIdle finally arrives. */

579+ * its completion notification when its SessionIdle eventually arrives — a busy server

580+ * with many concurrent runs is still bounded by the server's own concurrency, so growth

581+ * is not unbounded in practice. */

583 private val activeRuns: MutableSet<String> = java.util.Collections.synchronizedSet(

582 private val activeRuns: MutableSet<String> = java.util.Collections.synchronizedSet(

584 java.util.Collections.newSetFromMap(java.util.LinkedHashMap<String, Boolean>(16, 0.75f, true)),

583 java.util.Collections.newSetFromMap(java.util.LinkedHashMap<String, Boolean>(16, 0.75f, true)),

585 )

584 )

@@ -589,9 +588,6 @@ open class AppContainer private constructor(

589 * badge counts messages, not deltas. Cleared when a session is viewed or on connect. */

588 * badge counts messages, not deltas. Cleared when a session is viewed or on connect. */

590 private val unreadMessageIds = java.util.concurrent.ConcurrentHashMap<String, MutableSet<String>>()

589 private val unreadMessageIds = java.util.concurrent.ConcurrentHashMap<String, MutableSet<String>>()

591

590

592− /** Upper bound on [activeRuns] to prevent unbounded growth if SessionIdle never arrives. */

593− private val activeRunsLimit = NetworkConfig.activeRunsLimit

594−

595 /** Guards connect/disconnect so concurrent callers can't leak an old connection. */

591 /** Guards connect/disconnect so concurrent callers can't leak an old connection. */

596 private val connectionMutex = Mutex()

592 private val connectionMutex = Mutex()

597

593

@@ -650,14 +646,22 @@ open class AppContainer private constructor(

650 onDone: (Boolean) -> Unit,

646 onDone: (Boolean) -> Unit,

651 ) {

647 ) {

652 appScope.launch {

648 appScope.launch {

653− val success = runCatchingCancellable {

649+ // Guarantee onDone (so the BroadcastReceiver's goAsync() finishes) even if the

650+ // scope is cancelled mid-call (process shutdown cancels appScope first). Without

651+ // this, a cancelled scope leaves pending.finish() never called → a receiver ANR

652+ // and the permission response silently lost.

653+ var success = false

654+ try {

655+ success = runCatchingCancellable {

654− val api = activeConnection.value?.api ?: return@runCatchingCancellable false

656+ val api = activeConnection.value?.api ?: return@runCatchingCancellable false

655− api.respondPermission(sessionId, permissionId, response)

657+ api.respondPermission(sessionId, permissionId, response)

656− true

658+ true

657− }.onFailure {

659+ }.onFailure {

658− Log.w("AppContainer", "notif permission respond failed: ${safeExceptionSummary(it)}")

660+ Log.w("AppContainer", "notif permission respond failed: ${safeExceptionSummary(it)}")

659− }.getOrDefault(false)

661+ }.getOrDefault(false)

662+ } finally {

660− onDone(success)

663+ onDone(success)

664+ }

661 }

665 }

662 }

666 }

663

667

@@ -671,30 +675,36 @@ open class AppContainer private constructor(

671 * notification on success. */

675 * notification on success. */

672 open fun sendPromptFromNotification(sessionId: String, text: String, onDone: (Boolean) -> Unit) {

676 open fun sendPromptFromNotification(sessionId: String, text: String, onDone: (Boolean) -> Unit) {

673 appScope.launch {

677 appScope.launch {

678+ // Guarantee onDone (so the BroadcastReceiver's goAsync() finishes) even if the

679+ // scope is cancelled mid-call — see respondToPermissionFromNotification above.

680+ var enqueued = false

681+ try {

674− // Attribute to the active (or most-recent) profile so a reconnect to a different

682+ // Attribute to the active (or most-recent) profile so a reconnect to a different

675− // server doesn't misfire this against a session id that only exists elsewhere.

683+ // server doesn't misfire this against a session id that only exists elsewhere.

676− val profileId = activeConnection.value?.profile?.id

684+ val profileId = activeConnection.value?.profile?.id

677− ?: runCatchingCancellable { profileStore.profiles.first().firstOrNull()?.id }.getOrNull()

685+ ?: runCatchingCancellable { profileStore.profiles.first().firstOrNull()?.id }.getOrNull()

678− val enqueued = if (profileId == null) {

686+ enqueued = if (profileId == null) {

679− false

687+ false

680− } else {

688+ } else {

681− runCatchingCancellable {

689+ runCatchingCancellable {

682− outboxStore.enqueue(

690+ outboxStore.enqueue(

683− OutboxMessage(

691+ OutboxMessage(

684− id = java.util.UUID.randomUUID().toString(),

692+ id = java.util.UUID.randomUUID().toString(),

685− profileId = profileId,

693+ profileId = profileId,

686− sessionId = sessionId,

694+ sessionId = sessionId,

687− text = text,

695+ text = text,

688− model = null,

696+ model = null,

689− createdAt = System.currentTimeMillis(),

697+ createdAt = System.currentTimeMillis(),

690− ),

698+ ),

691− )

699+ )

692− }.onFailure {

700+ }.onFailure {

693− Log.w("AppContainer", "notif reply enqueue failed: ${safeExceptionSummary(it)}")

701+ Log.w("AppContainer", "notif reply enqueue failed: ${safeExceptionSummary(it)}")

694− }.isSuccess

702+ }.isSuccess

703+ }

704+ if (enqueued) flushOutbox()

705+ } finally {

706+ onDone(enqueued)

695 }

707 }

696− if (enqueued) flushOutbox()

697− onDone(enqueued)

698 }

708 }

699 }

709 }

700

710

@@ -750,7 +760,12 @@ open class AppContainer private constructor(

750 _isOnline.value = runCatching { cm.activeNetwork != null }.getOrDefault(true)

760 _isOnline.value = runCatching { cm.activeNetwork != null }.getOrDefault(true)

751 val callback = object : ConnectivityManager.NetworkCallback() {

761 val callback = object : ConnectivityManager.NetworkCallback() {

752 override fun onAvailable(network: Network) { _isOnline.value = true; activeConnection.value?.events?.triggerReconnect() }

762 override fun onAvailable(network: Network) { _isOnline.value = true; activeConnection.value?.events?.triggerReconnect() }

763+ // Don't flip offline on onLost: during a Wi-Fi→cellular handoff, onLost(WiFi) fires

764+ // before onAvailable(cellular), and cm.activeNetwork is transiently null in that

765+ // window — eagerly marking offline would skip outbox flushing and flash an offline

766+ // indicator. onUnavailable (no networks left at all) is the reliable offline signal.

753− override fun onLost(network: Network) { _isOnline.value = cm.activeNetwork != null }

767+ override fun onLost(network: Network) { /* handled by onUnavailable */ }

768+ override fun onUnavailable() { _isOnline.value = false }

754 }

769 }

755 // Only match networks that actually provide internet — a capability-less request

770 // Only match networks that actually provide internet — a capability-less request

756 // fires onAvailable for transports that can't reach the server (and would trigger

771 // fires onAvailable for transports that can't reach the server (and would trigger

@@ -854,7 +869,8 @@ open class AppContainer private constructor(

854 .onSuccess { onDeleted() }

869 .onSuccess { onDeleted() }

855 .onFailure { onError(it) }

870 .onFailure { onError(it) }

856 }

871 }

857− pendingProfileDeletes.put(id, job)?.cancel()

872+ pendingProfileDeletes[id]?.cancel()

873+ pendingProfileDeletes[id] = job

858 }

874 }

859

875

860 /** Cancel a pending deferred profile delete (the Undo action). Returns true if it was

876 /** Cancel a pending deferred profile delete (the Undo action). Returns true if it was

@@ -917,7 +933,8 @@ open class AppContainer private constructor(

917 .onFailure { onError(it) }

933 .onFailure { onError(it) }

918 }

934 }

919 }

935 }

920− pendingSessionDeletes.put(id, job)?.cancel()

936+ pendingSessionDeletes[id]?.cancel()

937+ pendingSessionDeletes[id] = job

921 }

938 }

922

939

923 /** Cancel a pending deferred session delete (the Undo action). Returns true if it was

940 /** Cancel a pending deferred session delete (the Undo action). Returns true if it was

app/src/main/java/soy/iko/opencode/ui/OpencodeApp.kt+9−1

@@ -68,10 +68,18 @@ fun OpencodeApp(container: AppContainer) {

68 // setPendingShare under an unchanged connection id — still navigates, while a re-trigger

69 // carrying no new share (a bare server switch, which routes through a null connection, or

70 // a share the user already navigated for) leaves them where they are.

71+ //

72+ // Reset the remembered media when the pending list is drained (the chosen ChatScreen

73+ // consumes it via consumePendingSharedMedia). Without this, re-sharing the *same* images

74+ // after consumption compares equal structurally ([A,B] == [A,B]) and would be treated as

75+ // "already handled", silently skipping the session-list navigation the second time.

71 var handledShareText by remember { mutableStateOf<String?>(null) }

76 var handledShareText by remember { mutableStateOf<String?>(null) }

72 var handledSharedMedia by remember { mutableStateOf<List<String>>(emptyList()) }

77 var handledSharedMedia by remember { mutableStateOf<List<String>>(emptyList()) }

73 LaunchedEffect(pendingShare, pendingSharedMedia, connection) {

78 LaunchedEffect(pendingShare, pendingSharedMedia, connection) {

74− if (pendingShare == null && pendingSharedMedia.isEmpty()) return@LaunchedEffect

79+ if (pendingShare == null && pendingSharedMedia.isEmpty()) {

80+ handledSharedMedia = emptyList()

81+ return@LaunchedEffect

82+ }

75 if (connection == null) return@LaunchedEffect

83 if (connection == null) return@LaunchedEffect

76 val newShare = (pendingShare != null && pendingShare != handledShareText) ||

84 val newShare = (pendingShare != null && pendingShare != handledShareText) ||

77 (pendingSharedMedia.isNotEmpty() && pendingSharedMedia != handledSharedMedia)

85 (pendingSharedMedia.isNotEmpty() && pendingSharedMedia != handledSharedMedia)

app/src/main/java/soy/iko/opencode/ui/chat/TtsController.kt+4−1

@@ -36,7 +36,10 @@ fun rememberTtsController(): TtsController {

36class TtsController(context: Context) : RememberObserver {

38 private val mainHandler = Handler(Looper.getMainLooper())

39+ // Written from the TextToSpeech init callback (a binder thread) and read from the main

40+ // thread in toggle(); @Volatile guarantees the main thread observes a successful init

41+ // promptly instead of a stale false, which would silently drop the read-aloud request.

39− private var ready = false

42+ @Volatile private var ready = false

40 private var shutDown = false

43 private var shutDown = false

42 private val _speakingId = mutableStateOf<String?>(null)

45 private val _speakingId = mutableStateOf<String?>(null)