WIP: message delivery status and refresh safety; fix reconcile listener recursion

The transcript listener read the lazily built _controller while _attach was
still building it (load() notifies synchronously), so it built another
controller, recursively, until the test process ran out of memory.
This commit is contained in:
2026-10-31 19:54:48 +00:00
parent 24956266d8
commit 4bc99f490b
15 changed files with 1133 additions and 177 deletions
@@ -458,9 +458,8 @@ class _ChatComposerBarState extends State<ChatComposerBar> {
}
/// Builds the chips' exact wire parts and hands them to the composer with the
/// draft's text and operation id. The chips stay while the prompt is in
/// flight so a refusal leaves the draft and its files together; only an
/// accepted prompt clears them.
/// draft's text and operation id. The chips leave the composer with the
/// message; a refusal keeps them on its "Not sent" bubble for Retry.
Future<void> _send() async {
final composer = widget.composer;
if (_uploading || composer.sending || composer.draft.trim().isEmpty) {
@@ -508,14 +507,16 @@ class _ChatComposerBarState extends State<ChatComposerBar> {
if (_uploading) setState(() => _uploading = false);
// Keep the caret in the field while the prompt is in flight, as before.
_focus.requestFocus();
final accepted = await composer.send(attachments: parts);
if (!mounted) return;
if (accepted) {
final sending = composer.send(attachments: parts);
// The sent message now owns its files: a refusal keeps them with its
// "Not sent" bubble for Retry, so the composer is free for the next one.
if (composer.sending) {
setState(() {
_replaceAttachments(const [], const []);
_attachmentError = null;
});
}
await sending;
}
/// Adds the operator's explicit selection through the host seam. A dismissed
@@ -5,34 +5,13 @@ import 'package:flutter/foundation.dart';
import '../../../core/api_gateway.dart';
import '../../../core/servers/server_scope.dart';
import '../data/chat_repository.dart';
import 'chat_composer_send.dart';
import 'chat_deliveries.dart';
import 'chat_draft_store.dart';
import 'leave_guard/chat_leave_guard.dart';
/// One plain-message send: the optimistic identity the thread shows and the
/// exact wire intent. A lost response retries the same intent with these ids.
class ChatComposerSend {
const ChatComposerSend({
required this.sessionId,
required this.text,
required this.operationId,
required this.nativeMessageId,
this.attachments = const [],
});
final String sessionId;
/// The trimmed wire text.
final String text;
final String operationId;
final String nativeMessageId;
/// The `{name, mime, data}` parts already built from the composer's chips,
/// in draft order. Empty for a text-only prompt.
final List<JsonMap> attachments;
/// Mirrors the web's `nativeChatMessageId(operationId) || local-<operationId>`.
String get optimisticId =>
nativeMessageId.isEmpty ? 'local-$operationId' : nativeMessageId;
}
export 'chat_composer_send.dart';
export 'chat_deliveries.dart';
typedef ChatSendCallback = void Function(ChatComposerSend send);
typedef ChatSendRejected = void Function(ChatComposerSend send, String error);
@@ -41,6 +20,11 @@ typedef ChatSendAccepted = void Function(ChatComposerSend send, bool queued);
/// The composer state for one conversation: exact draft, the one plain prompt
/// in flight, the reply's queued flag and Stop. It is not a transcript:
/// [onOptimistic] and [onRejected] are the thread's seam; Stop settles nothing.
///
/// A sent message stays in device storage until the server accepts it, so a
/// reload or crash mid-request cannot lose it: [loadUnsent] reads it back and
/// [deliveries] reports it as "Not sent" with Retry (the same operation id)
/// and Edit, unless the server's history shows it arrived.
class ChatComposerController extends ChangeNotifier {
ChatComposerController(
this.gateway,
@@ -83,11 +67,16 @@ class ChatComposerController extends ChangeNotifier {
int _operationSeq = 0;
int _loadGeneration = 0;
Future<void> _writes = Future<void>.value();
ChatComposerSend? _pending;
bool _disposed = false;
/// The exact text in the composer. A refusal restores it only when the
/// operator has not typed anything newer.
/// Every intent the server has not accepted yet, as stored on the device.
final List<ChatComposerSend> _stored = [];
/// The delivery state of this conversation's own messages.
final ChatDeliveries deliveries = ChatDeliveries();
/// The exact text in the composer. A refused message is not put back here;
/// it stays "Not sent" until the operator retries or edits it.
String get draft => _draft;
/// One prompt request is awaiting its reply; a second send is refused.
@@ -134,74 +123,149 @@ class ChatComposerController extends ChangeNotifier {
}
/// Sends the non-blank draft as one plain message, carrying [attachments] in
/// draft order. Only the wire text is trimmed. A refused unchanged intent
/// (same text and parts) reuses its operation id; a refusal restores the
/// exact draft unless newer text is already present. Returns whether the
/// server accepted this prompt, so the composer can clear its chips only
/// once the send is accepted.
/// draft order. Only the wire text is trimmed. The draft is cleared at once
/// and the intent is stored until the server accepts it; a refusal or lost
/// request leaves it in [deliveries] as "Not sent" for [retry] or [edit].
/// Returns whether the server accepted this prompt.
Future<bool> send({List<JsonMap> attachments = const []}) async {
if (_disposed || _sending) return false;
final exact = _draft;
final text = exact.trim();
final text = _draft.trim();
if (text.isEmpty) return false;
final previous = _pending;
late final ChatComposerSend intent;
if (previous != null &&
previous.text == text &&
_sameAttachments(previous.attachments, attachments)) {
intent = previous;
} else {
final operationId = _nextOperationId();
intent = ChatComposerSend(
sessionId: sessionId,
text: text,
operationId: operationId,
nativeMessageId: nativeChatMessageId(operationId),
attachments: attachments,
);
}
_pending = intent;
_sending = true;
_error = null;
final operationId = _nextOperationId();
final intent = ChatComposerSend(
sessionId: sessionId,
text: text,
operationId: operationId,
nativeMessageId: nativeChatMessageId(operationId),
attachments: attachments,
);
_draft = '';
_edited = true;
return _deliver(intent, clearDraft: true);
}
/// Sends an unsent intent again with its own operation id, so the server and
/// the transcript see the same message rather than a second one.
Future<bool> retry(String operationId) async {
if (_disposed || _sending) return false;
final intent = _unsentIntent(operationId);
if (intent == null || !intent.canRetry) return false;
return _deliver(intent, clearDraft: false);
}
/// Takes an unsent intent back into the composer: its text replaces an empty
/// draft or follows newer typing, and the intent is no longer kept.
Future<void> edit(String operationId) async {
if (_disposed) return;
final intent = _unsentIntent(operationId);
if (intent == null) return;
discard(operationId);
final current = _draft.trimRight();
final next = current.isEmpty ? intent.text : '$current\n${intent.text}';
await setDraft(next);
}
/// Drops an unsent intent without sending it or touching the draft.
void discard(String operationId) {
if (_disposed) return;
deliveries.forget(operationId);
_forgetStored(operationId);
}
/// Reads the intents a previous visit stored but never saw accepted. They
/// are settled by [reconcile] once an authoritative history read arrives.
Future<void> loadUnsent() async {
if (_disposed) return;
List<Object?> saved;
try {
saved = await _drafts.readUnsent(sessionId);
} catch (_) {
saved = const [];
}
if (_disposed) return;
final intents = [
for (final entry in saved)
if (ChatComposerSend.fromJson(entry) case final intent?)
if (!_stored.any((item) => item.operationId == intent.operationId))
intent,
];
if (intents.isEmpty) return;
_stored.insertAll(0, intents);
deliveries.restore(intents);
}
/// Settles unsent intents against an authoritative transcript: one the
/// server recorded is cleared from device storage.
void reconcile(List<JsonMap> messages) {
if (_disposed) return;
final confirmed = deliveries.reconcile(messages);
if (confirmed.isEmpty) return;
_stored.removeWhere(confirmed.contains);
_persistUnsent();
}
Future<bool> _deliver(
ChatComposerSend intent, {
required bool clearDraft,
}) async {
_sending = true;
setChatLeaveGuard(this, active: true);
_error = null;
if (!_stored.any((item) => item.operationId == intent.operationId)) {
_stored.add(intent);
}
deliveries.sending(intent);
_notify();
onOptimistic?.call(intent);
await _persistDraft('');
// The intent is on the device before the request leaves, so a reload
// while it is in flight still finds it.
_persistUnsent();
if (clearDraft) await _persistDraft('');
if (_disposed) return false;
try {
final reply = await _repository.prompt(
sessionId,
text,
intent.text,
operationId: intent.operationId,
attachments: intent.attachments,
);
if (_disposed) return false;
_queued = reply['chat_queued'] == true;
_forgetStored(intent.operationId);
deliveries.accepted(intent, queued: _queued);
onAccepted?.call(intent, _queued);
_pending = null;
_sending = false;
_error = null;
_notify();
_settle(null);
return true;
} catch (error) {
if (_disposed) return false;
final message = '$error';
_sending = false;
_error = message;
if (_draft.isEmpty) {
_draft = exact;
_edited = true;
_notify();
await _persistDraft(exact);
if (_disposed) return false;
}
deliveries.failed(intent);
onRejected?.call(intent, message);
_notify();
_settle(message);
return false;
}
}
void _settle(String? error) {
_sending = false;
setChatLeaveGuard(this, active: false);
_error = error;
_notify();
}
ChatComposerSend? _unsentIntent(String operationId) {
for (final intent in deliveries.unsent) {
if (intent.operationId == operationId) return intent;
}
return null;
}
void _forgetStored(String operationId) {
final before = _stored.length;
_stored.removeWhere((item) => item.operationId == operationId);
if (_stored.length != before) _persistUnsent();
}
/// Stops the running turn with the exact `chat_interrupt` query. A failure
/// stays visible and settles nothing; only a reply or frame changes state.
Future<void> stop() async {
@@ -231,6 +295,7 @@ class ChatComposerController extends ChangeNotifier {
final kind = body['kind'];
if (kind == 'usage' || kind == 'compaction') return;
_queued = false;
deliveries.admitQueued();
_notify();
}
@@ -238,23 +303,6 @@ class ChatComposerController extends ChangeNotifier {
newOperationId?.call() ??
'native-chat-${DateTime.now().microsecondsSinceEpoch}-${_operationSeq++}';
/// Whether two prompts carry the same attachment parts, so a retry after a
/// refusal can keep the original operation id. Parts are the exact wire maps
/// this composer built, so a shallow key-by-key comparison is enough.
bool _sameAttachments(List<JsonMap> a, List<JsonMap> b) {
if (identical(a, b)) return true;
if (a.length != b.length) return false;
for (var index = 0; index < a.length; index += 1) {
final first = a[index];
final second = b[index];
if (first.length != second.length) return false;
for (final key in first.keys) {
if (!second.containsKey(key) || first[key] != second[key]) return false;
}
}
return true;
}
Future<void> _persistDraft(String text) {
final write = _writes.then((_) async {
var stored = false;
@@ -274,6 +322,18 @@ class ChatComposerController extends ChangeNotifier {
return write;
}
/// Writes every not-yet-accepted intent, in order, after earlier writes.
void _persistUnsent() {
final snapshot = [for (final intent in _stored) intent.toJson()];
_writes = _writes.then((_) async {
try {
await _drafts.writeUnsent(sessionId, snapshot);
} catch (_) {
// The in-memory intent still shows; only a reload could lose it.
}
});
}
void _notify() {
if (!_disposed) notifyListeners();
}
@@ -283,6 +343,8 @@ class ChatComposerController extends ChangeNotifier {
if (_disposed) return;
_disposed = true;
_loadGeneration++;
setChatLeaveGuard(this, active: false);
deliveries.dispose();
unawaited(_subscription?.cancel());
super.dispose();
}
@@ -0,0 +1,115 @@
import '../../../core/api_gateway.dart';
import '../domain/chat_attachment_image.dart';
/// One plain-message send: the optimistic identity the thread shows and the
/// exact wire intent. A retry sends this same intent with these ids.
class ChatComposerSend {
const ChatComposerSend({
required this.sessionId,
required this.text,
required this.operationId,
required this.nativeMessageId,
this.attachments = const [],
this.attachmentsOmitted = false,
});
final String sessionId;
/// The trimmed wire text.
final String text;
final String operationId;
final String nativeMessageId;
/// The `{name, mime, data}` parts already built from the composer's chips,
/// in draft order. Empty for a text-only prompt.
final List<JsonMap> attachments;
/// True for an intent read back from device storage whose attachment bytes
/// were too large to keep: [attachments] then carries names only, so the
/// intent cannot be re-sent as it was.
final bool attachmentsOmitted;
/// Whether this exact intent can be sent again.
bool get canRetry => !attachmentsOmitted;
/// Mirrors the web's `nativeChatMessageId(operationId) || local-<operationId>`.
String get optimisticId =>
nativeMessageId.isEmpty ? 'local-$operationId' : nativeMessageId;
/// The local user message the thread draws for this intent.
JsonMap toMessage() => {
'id': optimisticId,
'session_id': sessionId,
'role': 'user',
'operation_id': operationId,
'native_message_id': nativeMessageId,
'parts': [
{'type': 'text', 'text': text},
for (final attachment in attachments)
{
'type': 'file',
'name': attachment['name'],
'uri': chatOptimisticAttachmentUri(attachment),
'mime': attachment['mime'],
},
],
};
/// Whether [message] is the server's record of this intent: the same
/// operation id, or the native message id the prompt carried.
bool recordedBy(JsonMap message) {
if (message['role'] != 'user') return false;
if (message['operation_id'] == operationId) return true;
if (nativeMessageId.isEmpty) return false;
return message['id'] == nativeMessageId ||
message['native_message_id'] == nativeMessageId;
}
/// The device-storage form. Attachment bytes are kept only while their
/// total stays under [maxStoredAttachmentData]; beyond that only names and
/// types are kept and the read-back intent reports [attachmentsOmitted].
JsonMap toJson() {
var size = 0;
for (final attachment in attachments) {
size += '${attachment['data'] ?? ''}'.length;
}
final omit = attachmentsOmitted || size > maxStoredAttachmentData;
return {
'session_id': sessionId,
'text': text,
'operation_id': operationId,
'native_message_id': nativeMessageId,
'attachments': [
for (final attachment in attachments)
omit
? {'name': attachment['name'], 'mime': attachment['mime']}
: Map<String, dynamic>.from(attachment),
],
if (omit && attachments.isNotEmpty) 'attachments_omitted': true,
};
}
/// Reads a stored intent, or null when the entry is not a usable intent.
static ChatComposerSend? fromJson(Object? value) {
if (value is! Map) return null;
final text = '${value['text'] ?? ''}';
final operationId = '${value['operation_id'] ?? ''}';
if (text.trim().isEmpty || operationId.isEmpty) return null;
return ChatComposerSend(
sessionId: '${value['session_id'] ?? ''}',
text: text,
operationId: operationId,
nativeMessageId: '${value['native_message_id'] ?? ''}',
attachments: [
for (final attachment in value['attachments'] as List? ?? const [])
if (attachment is Map) Map<String, dynamic>.from(attachment),
],
attachmentsOmitted: value['attachments_omitted'] == true,
);
}
/// Base64 characters of attachment data kept on the device with an unsent
/// intent. Browser storage is small and shared, so larger files are named
/// but not kept.
static const int maxStoredAttachmentData = 512 * 1024;
}
@@ -0,0 +1,162 @@
import 'package:flutter/foundation.dart';
import '../../../core/api_gateway.dart';
import 'chat_composer_send.dart';
/// Where one of the operator's own messages is on its way to the server.
enum ChatDelivery {
/// The prompt request is awaiting the server's reply.
sending,
/// The server accepted the prompt.
sent,
/// The server accepted the prompt behind the turn in flight.
queued,
/// The server refused the prompt, or its request was lost.
failed,
}
/// The delivery state of this conversation's own sends, and the messages that
/// were not sent.
///
/// Messages read from history carry no state: they were sent. Only sends made
/// from this composer (and intents read back from device storage) are
/// tracked. An unsent intent is not a transcript message, so it is listed in
/// [unsent] and drawn after the transcript until it is re-sent, edited or
/// found in the server's history.
class ChatDeliveries extends ChangeNotifier {
final Map<String, ChatDelivery> _states = {};
final Map<String, String> _operationByNative = {};
final List<ChatComposerSend> _unsent = [];
/// Intents read back from device storage that no history read has checked.
final List<ChatComposerSend> _unverified = [];
String? _latestSent;
bool _disposed = false;
/// The intents the server has not accepted, in send order.
List<ChatComposerSend> get unsent => List.unmodifiable(_unsent);
/// Whether any intent still waits for a history read to settle it.
bool get hasUnverified => _unverified.isNotEmpty;
/// The state to draw under a transcript user [message], or null for a quiet
/// message. "Sent" is shown only on the newest accepted send.
ChatDelivery? stateFor(JsonMap message) {
final operation = _operationOf(message);
if (operation == null) return null;
final state = _states[operation];
if (state == ChatDelivery.sent && operation != _latestSent) return null;
return state;
}
String? _operationOf(JsonMap message) {
final operation = message['operation_id'];
if (operation is String && _states.containsKey(operation)) {
return operation;
}
for (final key in [message['native_message_id'], message['id']]) {
if (key is String && _operationByNative.containsKey(key)) {
return _operationByNative[key];
}
}
return null;
}
void sending(ChatComposerSend send) {
_unsent.removeWhere((item) => item.operationId == send.operationId);
_set(send, ChatDelivery.sending);
}
void accepted(ChatComposerSend send, {required bool queued}) {
if (!queued) _latestSent = send.operationId;
_set(send, queued ? ChatDelivery.queued : ChatDelivery.sent);
}
void failed(ChatComposerSend send) {
_unsent
..removeWhere((item) => item.operationId == send.operationId)
..add(send);
_set(send, ChatDelivery.failed);
}
/// A queued prompt was admitted: the turn it waited behind moved on.
void admitQueued() {
var changed = false;
for (final entry in _states.entries.toList()) {
if (entry.value != ChatDelivery.queued) continue;
_states[entry.key] = ChatDelivery.sent;
_latestSent = entry.key;
changed = true;
}
if (changed) _notify();
}
/// Drops an unsent intent the operator took back into the composer.
void forget(String operationId) {
final before = _unsent.length + _unverified.length;
_unsent.removeWhere((item) => item.operationId == operationId);
_unverified.removeWhere((item) => item.operationId == operationId);
_states.remove(operationId);
if (_unsent.length + _unverified.length != before) _notify();
}
/// Adopts intents read back from device storage. They stay hidden until
/// [reconcile] has checked them against an authoritative history read.
void restore(List<ChatComposerSend> intents) {
var changed = false;
for (final intent in intents) {
if (_states.containsKey(intent.operationId)) continue;
_remember(intent);
_states[intent.operationId] = ChatDelivery.failed;
_unverified.add(intent);
changed = true;
}
if (changed) _notify();
}
/// Settles stored and unsent intents against an authoritative transcript:
/// one the server recorded was sent and is returned so its stored copy can
/// be cleared; an unchecked one that is absent becomes "Not sent".
List<ChatComposerSend> reconcile(List<JsonMap> messages) {
bool recorded(ChatComposerSend intent) =>
messages.any((message) => intent.recordedBy(message));
final confirmed = <ChatComposerSend>[
for (final intent in [..._unverified, ..._unsent])
if (recorded(intent)) intent,
];
final changed = confirmed.isNotEmpty || _unverified.isNotEmpty;
for (final intent in confirmed) {
_states[intent.operationId] = ChatDelivery.sent;
}
_unsent.removeWhere(confirmed.contains);
_unverified.removeWhere(confirmed.contains);
_unsent.addAll(_unverified);
_unverified.clear();
if (changed) _notify();
return confirmed;
}
void _remember(ChatComposerSend send) {
if (send.nativeMessageId.isEmpty) return;
_operationByNative[send.nativeMessageId] = send.operationId;
}
void _set(ChatComposerSend send, ChatDelivery state) {
_remember(send);
_states[send.operationId] = state;
_notify();
}
void _notify() {
if (!_disposed) notifyListeners();
}
@override
void dispose() {
_disposed = true;
super.dispose();
}
}
@@ -0,0 +1,104 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'chat_deliveries.dart';
/// The words each delivery state reads as, beside its icon.
String chatDeliveryLabel(ChatDelivery state) => switch (state) {
ChatDelivery.sending => 'Sending…',
ChatDelivery.sent => 'Sent',
ChatDelivery.queued => 'Queued',
ChatDelivery.failed => 'Not sent',
};
/// A small muted line under the operator's own bubble saying whether the
/// server has the message. "Not sent" takes the error colour and offers the
/// native Retry (same operation id) and Edit (back into the composer) — or
/// Discard when the stored intent can no longer be sent as it was.
class ChatDeliveryIndicator extends StatelessWidget {
const ChatDeliveryIndicator({
super.key,
required this.state,
required this.cupertino,
this.onRetry,
this.onEdit,
this.editLabel = 'Edit',
});
final ChatDelivery state;
final bool cupertino;
final VoidCallback? onRetry;
final VoidCallback? onEdit;
final String editLabel;
@override
Widget build(BuildContext context) {
final failed = state == ChatDelivery.failed;
final color = failed
? (cupertino
? CupertinoColors.systemRed.resolveFrom(context)
: Theme.of(context).colorScheme.error)
: (cupertino
? CupertinoColors.secondaryLabel.resolveFrom(context)
: Theme.of(context).colorScheme.onSurfaceVariant);
final style = DefaultTextStyle.of(
context,
).style.merge(TextStyle(fontSize: 12, color: color));
final label = chatDeliveryLabel(state);
return Semantics(
container: true,
label: 'Delivery: $label',
child: Wrap(
key: Key('chat-delivery-${state.name}'),
spacing: 4,
crossAxisAlignment: WrapCrossAlignment.center,
children: [
ExcludeSemantics(
child: Icon(_icon, size: style.fontSize! + 2, color: color),
),
ExcludeSemantics(child: Text(label, style: style)),
if (failed && onRetry != null)
_action('chat-delivery-retry', 'Retry', onRetry!, style),
if (failed && onEdit != null)
_action('chat-delivery-edit', editLabel, onEdit!, style),
],
),
);
}
IconData get _icon => switch (state) {
ChatDelivery.sending => cupertino ? CupertinoIcons.clock : Icons.schedule,
ChatDelivery.sent => cupertino ? CupertinoIcons.checkmark : Icons.done,
ChatDelivery.queued =>
cupertino ? CupertinoIcons.hourglass : Icons.hourglass_empty,
ChatDelivery.failed =>
cupertino ? CupertinoIcons.exclamationmark_circle : Icons.error_outline,
};
Widget _action(
String key,
String text,
VoidCallback onPressed,
TextStyle style,
) {
if (cupertino) {
return CupertinoButton(
key: Key(key),
padding: const EdgeInsets.symmetric(horizontal: 6),
minimumSize: Size.zero,
onPressed: onPressed,
child: Text(text, style: style.copyWith(fontWeight: FontWeight.w600)),
);
}
return TextButton(
key: Key(key),
style: TextButton.styleFrom(
foregroundColor: style.color,
visualDensity: VisualDensity.compact,
textStyle: style.copyWith(fontWeight: FontWeight.w600),
),
onPressed: onPressed,
child: Text(text),
);
}
}
@@ -1,3 +1,5 @@
import 'dart:convert';
import 'package:shared_preferences/shared_preferences.dart';
import '../../../core/servers/server_scope.dart';
@@ -15,12 +17,23 @@ abstract interface class ChatDraftStore {
/// Stores [text] exactly. A blank draft removes the entry so the store does
/// not grow without bound. Returns false when nothing was stored.
Future<bool> write(String sessionId, String text);
/// The messages sent from this device that the server has not yet accepted,
/// as stored JSON intents in send order. Empty when there are none.
Future<List<Object?>> readUnsent(String sessionId);
/// Replaces the stored unsent intents; an empty list removes the entry.
/// Returns false when nothing was stored.
Future<bool> writeUnsent(String sessionId, List<Object?> intents);
}
/// The app's per-session draft keys. Independent of the legacy web/Android
/// storage: no old draft is imported or written under an old key.
const String chatDraftKeyPrefix = 'pipelines.next.chatDraft.v1.';
/// The per-session key for messages still awaiting the server's acceptance.
const String chatUnsentKeyPrefix = 'pipelines.next.chatUnsent.v1.';
/// `shared_preferences`-backed draft storage.
///
/// Reads are tolerant and a write reports failure instead of throwing, so the
@@ -62,14 +75,52 @@ class SharedPreferencesChatDraftStore implements ChatDraftStore {
return false;
}
}
String _unsentKey(String sessionId) =>
scopedServerKey('$chatUnsentKeyPrefix$sessionId', serverId);
@override
Future<List<Object?>> readUnsent(String sessionId) async {
final preferences = await _preferences();
if (preferences == null) return const [];
try {
final stored = preferences.getString(_unsentKey(sessionId));
if (stored == null || stored.isEmpty) return const [];
final decoded = jsonDecode(stored);
return decoded is List ? decoded : const [];
} catch (_) {
return const [];
}
}
@override
Future<bool> writeUnsent(String sessionId, List<Object?> intents) async {
final preferences = await _preferences();
if (preferences == null) return false;
try {
final key = _unsentKey(sessionId);
if (intents.isEmpty) return await preferences.remove(key);
return await preferences.setString(key, jsonEncode(intents));
} catch (_) {
return false;
}
}
}
/// An in-memory store for tests and previews. It never touches the platform
/// store, so no production preference can be mutated by a fixture.
class MemoryChatDraftStore implements ChatDraftStore {
MemoryChatDraftStore({Map<String, String>? drafts}) : _drafts = {...?drafts};
MemoryChatDraftStore({
Map<String, String>? drafts,
Map<String, List<Object?>>? unsent,
}) : _drafts = {...?drafts},
_unsent = {...?unsent};
final Map<String, String> _drafts;
final Map<String, List<Object?>> _unsent;
/// A snapshot of the stored unsent intents per session.
Map<String, List<Object?>> get unsentEntries => Map.unmodifiable(_unsent);
bool failReads = false;
bool failWrites = false;
@@ -93,4 +144,22 @@ class MemoryChatDraftStore implements ChatDraftStore {
}
return true;
}
@override
Future<List<Object?>> readUnsent(String sessionId) async {
if (failReads) throw StateError('Draft storage is unavailable.');
// A round trip through JSON, exactly as the device store keeps it.
return jsonDecode(jsonEncode(_unsent[sessionId] ?? const [])) as List;
}
@override
Future<bool> writeUnsent(String sessionId, List<Object?> intents) async {
if (failWrites) return false;
if (intents.isEmpty) {
_unsent.remove(sessionId);
} else {
_unsent[sessionId] = jsonDecode(jsonEncode(intents)) as List;
}
return true;
}
}
@@ -9,7 +9,6 @@ import '../../../shell/shell_bar.dart';
import '../data/chat_attachment_images.dart';
import '../data/chat_repository.dart';
import '../domain/chat_activity_detail.dart';
import '../domain/chat_attachment_image.dart';
import '../domain/chat_notice.dart';
import '../domain/chat_attachment_picker.dart';
import '../domain/chat_transcript.dart';
@@ -21,6 +20,7 @@ import 'chat_background_tasks.dart';
import 'chat_command_actions.dart';
import 'chat_composer_bar.dart';
import 'chat_composer_controller.dart';
import 'chat_delivery_indicator.dart';
import 'chat_draft_store.dart';
import 'chat_mode_control.dart';
import 'chat_model_control.dart';
@@ -203,11 +203,33 @@ class _ChatThreadViewState extends State<ChatThreadView> {
/// counted against it for the jump control's arrival count.
String? _newestAtRelease;
ChatThreadController _attach() => ChatThreadController(
widget.gateway,
widget.sessionId,
cached: widget.transcripts?.read(widget.sessionId),
)..load();
ChatThreadController _attach() {
final controller = ChatThreadController(
widget.gateway,
widget.sessionId,
cached: widget.transcripts?.read(widget.sessionId),
);
// The listener names this controller: load() can notify before _attach
// returns, while reading _controller would build another one, and so on.
controller.transcriptChanges.addListener(
() => _reconcileUnsent(controller),
);
unawaited(controller.load());
return controller;
}
/// Settles stored unsent messages once the transcript is an authoritative
/// read: a message the server recorded was sent after all.
void _reconcileUnsent(ChatThreadController controller) {
if (!mounted ||
!controller.loaded ||
controller.loading ||
controller.error != null ||
controller.showingCached) {
return;
}
_composer.reconcile(controller.messages);
}
/// `/close` finished this conversation; its transcript is not kept.
bool _closed = false;
@@ -238,38 +260,39 @@ class _ChatThreadViewState extends State<ChatThreadView> {
widget.onSessionClosed?.call();
}
ChatComposerController _attachComposer() => ChatComposerController(
widget.gateway,
widget.sessionId,
drafts: widget.drafts,
newOperationId: widget.newOperationId,
onOptimistic: _onOptimistic,
onRejected: _onRejected,
onAccepted: (send, queued) =>
_controller.promptAccepted(send.operationId, queued: queued),
);
void _onOptimistic(ChatComposerSend send) {
if (!mounted) return;
_controller.insertLocal({
'id': send.optimisticId,
'session_id': send.sessionId,
'role': 'user',
'operation_id': send.operationId,
'native_message_id': send.nativeMessageId,
'parts': [
{'type': 'text', 'text': send.text},
for (final attachment in send.attachments)
{
'type': 'file',
'name': attachment['name'],
'uri': chatOptimisticAttachmentUri(attachment),
'mime': attachment['mime'],
},
],
});
ChatComposerController _attachComposer() {
final composer = ChatComposerController(
widget.gateway,
widget.sessionId,
drafts: widget.drafts,
newOperationId: widget.newOperationId,
onOptimistic: _onOptimistic,
onRejected: _onRejected,
onAccepted: (send, queued) =>
_controller.promptAccepted(send.operationId, queued: queued),
);
// A message a previous visit sent but never saw accepted comes back as
// "Not sent" unless the history read shows the server has it.
unawaited(
composer.loadUnsent().then((_) {
if (mounted && identical(composer, _composer)) {
_reconcileUnsent(_controller);
}
}),
);
return composer;
}
/// Draws a sent (or retried) message where it was sent: a retry moves the
/// message to the end, since that is when it is sent.
void _onOptimistic(ChatComposerSend send) {
if (!mounted) return;
_controller.removeLocal(send.operationId);
_controller.insertLocal(send.toMessage());
}
/// A refused message leaves the transcript; it is drawn after it as "Not
/// sent" from the composer's deliveries instead.
void _onRejected(ChatComposerSend send, String error) {
if (!mounted) return;
_controller.removeLocal(send.operationId);
@@ -643,7 +666,10 @@ class _ChatThreadViewState extends State<ChatThreadView> {
@override
Widget build(BuildContext context) => AnimatedBuilder(
animation: _controller.transcriptChanges,
animation: Listenable.merge([
_controller.transcriptChanges,
_composer.deliveries,
]),
builder: (context, _) {
final cupertino =
chatControlsStyleOf(context) == ChatControlsStyle.cupertino;
@@ -845,6 +871,18 @@ class _ChatThreadViewState extends State<ChatThreadView> {
: null,
),
),
// Messages the server has not accepted follow the
// transcript until they are retried or edited.
for (final send in _composer.deliveries.unsent)
Padding(
key: ValueKey<String>(
'chat-unsent-${send.operationId}',
),
padding: const EdgeInsets.symmetric(
horizontal: 16,
),
child: _unsentRow(send, cupertino),
),
// The conversation's own command lines sit after the
// turns, as on the web; they are never bubbles.
for (final notice in _commandNotices)
@@ -1024,13 +1062,56 @@ class _ChatThreadViewState extends State<ChatThreadView> {
child: chips.firstOrNull ?? const SizedBox.shrink(),
);
}
final delivery = kind == 'user' && row['message'] is Map
? _composer.deliveries.stateFor(
Map<String, dynamic>.from(row['message'] as Map),
)
: null;
return ChatMessageView(
row: row,
textBuilder: chatMarkdownText,
footer: chips,
footer: [
...chips,
if (delivery != null)
ChatDeliveryIndicator(
state: delivery,
cupertino:
chatControlsStyleOf(context) == ChatControlsStyle.cupertino,
),
],
images: _images,
);
}
/// One message the server has not accepted, as the operator's bubble with
/// "Not sent" and its Retry and Edit.
Widget _unsentRow(ChatComposerSend send, bool cupertino) {
final composer = _composer;
return ChatMessageView(
row: {
'kind': 'user',
'key': send.optimisticId,
'message': send.toMessage(),
},
textBuilder: chatMarkdownText,
images: _images,
footer: [
ChatDeliveryIndicator(
state: ChatDelivery.failed,
cupertino: cupertino,
onRetry: send.canRetry && !composer.sending
? () => unawaited(composer.retry(send.operationId))
: null,
// Attachment bytes cannot go back into the composer's chips, so an
// intent with files is discarded rather than silently trimmed.
editLabel: send.attachments.isEmpty ? 'Edit' : 'Discard',
onEdit: send.attachments.isEmpty
? () => unawaited(composer.edit(send.operationId))
: () => composer.discard(send.operationId),
),
],
);
}
}
/// The native dismiss control shared by a local notice and a running
@@ -0,0 +1,9 @@
import 'chat_leave_guard_stub.dart'
if (dart.library.js_interop) 'chat_leave_guard_web.dart'
as impl;
/// Asks before the page is left or reloaded while [owner] holds a prompt in
/// flight. Only the web build can be reloaded mid-request; elsewhere this does
/// nothing. Each owner releases its own hold with `active: false`.
void setChatLeaveGuard(Object owner, {required bool active}) =>
impl.setChatLeaveGuard(owner, active: active);
@@ -0,0 +1,2 @@
/// Non-web hosts have no page to reload, so there is nothing to guard.
void setChatLeaveGuard(Object owner, {required bool active}) {}
@@ -0,0 +1,27 @@
import 'dart:js_interop';
import 'package:web/web.dart' as web;
final Set<Object> _owners = {};
bool _listening = false;
/// Registers one `beforeunload` listener for the page and keeps it inert
/// unless some composer holds a prompt in flight. The browser then shows its
/// own "Leave site?" confirmation; the wording is the browser's.
void setChatLeaveGuard(Object owner, {required bool active}) {
if (active) {
_owners.add(owner);
} else {
_owners.remove(owner);
}
if (_listening || _owners.isEmpty) return;
_listening = true;
web.window.addEventListener('beforeunload', _onBeforeUnload.toJS);
}
void _onBeforeUnload(web.Event event) {
if (_owners.isEmpty) return;
event.preventDefault();
// Older engines still require a non-null returnValue to ask.
(event as web.BeforeUnloadEvent).returnValue = '';
}
@@ -36,7 +36,8 @@ class ChatMessageView extends StatelessWidget {
static final ChatAttachmentImages _inlineImages = ChatAttachmentImages(null);
/// The turn's settled permissions, independent of passive activity details.
/// Beneath the turn: an agent turn's settled permissions, or the delivery
/// line under the operator's own message.
final List<Widget> footer;
@override
@@ -103,27 +104,40 @@ class ChatMessageView extends StatelessWidget {
: row;
/// Attached images sit above the operator's bubble, as their own thumbnails;
/// an images-only turn draws no empty bubble.
/// an images-only turn draws no empty bubble. The footer (the delivery line)
/// sits under the bubble's trailing corner.
Widget _userTurn(bool cupertino, List<Widget> content, Widget body) {
final thumbnails = [
for (final part in _partsOf(_userMessage))
if (_isFile(part) && chatPartIsThumbnail(part)) part,
];
if (thumbnails.isEmpty) {
if (thumbnails.isEmpty && footer.isEmpty) {
return ChatUserBubble(cupertino: cupertino, child: body);
}
return Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.end,
children: [
ChatAttachmentGallery(
parts: thumbnails,
images: images ?? _inlineImages,
cupertino: cupertino,
),
if (content.isNotEmpty) const SizedBox(height: 6),
if (content.isNotEmpty)
if (thumbnails.isNotEmpty)
ChatAttachmentGallery(
parts: thumbnails,
images: images ?? _inlineImages,
cupertino: cupertino,
),
if (thumbnails.isNotEmpty && content.isNotEmpty)
const SizedBox(height: 6),
if (content.isNotEmpty || thumbnails.isEmpty)
ChatUserBubble(cupertino: cupertino, child: body),
if (footer.isNotEmpty) ...[
const SizedBox(height: 2),
Wrap(
key: const Key('chat-message-footer'),
spacing: 8,
alignment: WrapAlignment.end,
crossAxisAlignment: WrapCrossAlignment.center,
children: footer,
),
],
],
);
}
@@ -26,6 +26,13 @@ class _DelayedDraftStore implements ChatDraftStore {
writes.add(text);
return true;
}
@override
Future<List<Object?>> readUnsent(String sessionId) async => const [];
@override
Future<bool> writeUnsent(String sessionId, List<Object?> intents) async =>
true;
}
void main() {
@@ -90,41 +90,47 @@ void main() {
expect(controller.sending, isFalse);
});
test('a refused unchanged intent retries with the same identity', () async {
var fail = true;
gateway.prompt = (_, _) async {
if (fail) throw StateError('response lost');
return const {};
};
await controller.setDraft(' keep me ');
test(
'a refused intent is kept as Not sent and Retry reuses its identity',
() async {
var fail = true;
gateway.prompt = (_, _) async {
if (fail) throw StateError('response lost');
return const {};
};
await controller.setDraft(' keep me ');
await controller.send();
expect(controller.error, contains('response lost'));
expect(controller.draft, ' keep me ');
expect(await drafts.read('s'), ' keep me ');
expect(rejected.single, contains('response lost'));
await controller.send();
expect(controller.error, contains('response lost'));
// The composer is free for the next message; the refused one is kept.
expect(controller.draft, '');
expect(rejected.single, contains('response lost'));
expect(controller.deliveries.unsent.single.operationId, 'op/1');
expect(drafts.unsentEntries['s'], hasLength(1));
fail = false;
await controller.send();
expect(gateway.promptBodies.map((body) => body['operation_id']), [
'op/1',
'op/1',
]);
expect(gateway.promptBodies.map((body) => body['native_message_id']), [
'msg_op1',
'msg_op1',
]);
expect(controller.draft, '');
expect(controller.error, isNull);
fail = false;
expect(await controller.retry('op/1'), isTrue);
expect(gateway.promptBodies.map((body) => body['operation_id']), [
'op/1',
'op/1',
]);
expect(gateway.promptBodies.map((body) => body['native_message_id']), [
'msg_op1',
'msg_op1',
]);
expect(controller.error, isNull);
expect(controller.deliveries.unsent, isEmpty);
expect(drafts.unsentEntries, isEmpty);
fail = true;
await controller.setDraft('other');
await controller.send();
expect(gateway.promptBodies.last['operation_id'], 'op/2');
expect(gateway.promptBodies.last['native_message_id'], 'msg_op2');
});
fail = true;
await controller.setDraft('other');
await controller.send();
expect(gateway.promptBodies.last['operation_id'], 'op/2');
expect(gateway.promptBodies.last['native_message_id'], 'msg_op2');
},
);
test('a refusal keeps newer typing instead of restoring the draft', () async {
test('a refusal keeps newer typing and the refused message apart', () async {
final reply = Completer<Map<String, dynamic>>();
gateway.prompt = (_, _) => reply.future;
await controller.setDraft('original');
@@ -140,8 +146,13 @@ void main() {
expect(await drafts.read('s'), 'newer');
expect(controller.error, contains('refused'));
expect(rejected.single, contains('refused'));
// The optimistic turn still carries the intent that was refused.
expect(optimistic.single.text, 'original');
expect(controller.deliveries.unsent.single.text, 'original');
// Edit puts the refused text after the newer typing and forgets it.
await controller.edit('op/1');
expect(controller.draft, 'newer\noriginal');
expect(controller.deliveries.unsent, isEmpty);
expect(drafts.unsentEntries, isEmpty);
});
test(
@@ -0,0 +1,247 @@
import 'dart:async';
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/chat/conversation/chat_draft_store.dart';
import 'package:pipelines_app/features/chat/conversation/chat_thread_view.dart';
import 'chat_thread_fixtures.dart';
/// A thread gateway whose prompt replies the test settles one by one.
class _Gateway extends FakeChatGateway {
final prompts = <Completer<JsonMap>>[];
final promptBodies = <JsonMap>[];
List<JsonMap> messages = [];
_Gateway() {
history = (_) async => chatPage(messages);
}
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) {
if (type == 'chat_prompt') {
promptBodies.add(fields['chat_prompt'] as JsonMap);
final reply = Completer<JsonMap>();
prompts.add(reply);
return reply.future;
}
return super.call(type, fields);
}
}
Future<void> _pump(WidgetTester tester) async {
await tester.pump();
await tester.pump(const Duration(milliseconds: 100));
await tester.pump();
}
/// Hosts one thread; [generation] changes the key so a second call simulates
/// a page reload: a fresh thread and composer over the same device store.
Future<void> _host(
WidgetTester tester,
_Gateway gateway,
MemoryChatDraftStore drafts, {
bool cupertino = false,
int generation = 0,
}) async {
var sequence = 0;
final thread = ChatThreadView(
key: ValueKey(generation),
gateway: gateway,
sessionId: 's',
onBack: () {},
drafts: drafts,
newOperationId: () => 'op-$generation-${++sequence}',
);
await tester.pumpWidget(
cupertino
? CupertinoApp(home: CupertinoPageScaffold(child: thread))
: MaterialApp(home: Scaffold(body: thread)),
);
await _pump(tester);
}
Future<void> _send(WidgetTester tester, String text) async {
await tester.enterText(find.byKey(const Key('chat-composer-field')), text);
await tester.pump();
await tester.tap(find.byKey(const Key('chat-composer-primary')));
await _pump(tester);
}
Finder _state(String name) => find.byKey(Key('chat-delivery-$name'));
void main() {
for (final cupertino in [false, true]) {
testWidgets('send shows Sending… then Sent ($cupertino)', (tester) async {
final gateway = _Gateway();
addTearDown(gateway.close);
await _host(
tester,
gateway,
MemoryChatDraftStore(),
cupertino: cupertino,
);
await _send(tester, 'Hello');
expect(_state('sending'), findsOneWidget);
expect(find.text('Sending…'), findsOneWidget);
gateway.prompts.single.complete({});
await _pump(tester);
expect(_state('sending'), findsNothing);
expect(_state('sent'), findsOneWidget);
// Only the newest accepted message keeps its quiet check.
await _send(tester, 'Again');
gateway.prompts.last.complete({});
await _pump(tester);
expect(_state('sent'), findsOneWidget);
});
testWidgets('a queued reply shows Queued until the turn moves on '
'($cupertino)', (tester) async {
final gateway = _Gateway();
addTearDown(gateway.close);
await _host(
tester,
gateway,
MemoryChatDraftStore(),
cupertino: cupertino,
);
await _send(tester, 'Later please');
gateway.prompts.single.complete({'chat_queued': true});
await _pump(tester);
expect(_state('queued'), findsOneWidget);
expect(find.text('Queued'), findsOneWidget);
gateway.emitEvent(chatStepFrame('running'));
await _pump(tester);
expect(_state('queued'), findsNothing);
expect(_state('sent'), findsOneWidget);
});
testWidgets('a refusal shows Not sent and Retry reuses the operation id '
'($cupertino)', (tester) async {
final gateway = _Gateway();
addTearDown(gateway.close);
final drafts = MemoryChatDraftStore();
await _host(tester, gateway, drafts, cupertino: cupertino);
await _send(tester, 'Please refuse');
gateway.prompts.single.completeError(StateError('refused'));
await _pump(tester);
expect(_state('failed'), findsOneWidget);
expect(find.text('Not sent'), findsOneWidget);
expect(find.text('Please refuse'), findsOneWidget);
expect(drafts.unsentEntries['s'], hasLength(1));
await tester.tap(find.byKey(const Key('chat-delivery-retry')));
await _pump(tester);
expect(_state('sending'), findsOneWidget);
expect(_state('failed'), findsNothing);
expect(gateway.promptBodies.map((body) => body['operation_id']), [
'op-0-1',
'op-0-1',
]);
gateway.prompts.last.complete({});
await _pump(tester);
expect(_state('sent'), findsOneWidget);
expect(find.text('Please refuse'), findsOneWidget);
expect(drafts.unsentEntries, isEmpty);
});
}
testWidgets('a message in flight at reload comes back as Not sent with '
'Retry and Edit', (tester) async {
final gateway = _Gateway();
addTearDown(gateway.close);
final drafts = MemoryChatDraftStore();
await _host(tester, gateway, drafts);
await _send(tester, 'Did this arrive?');
expect(_state('sending'), findsOneWidget);
// The draft is gone from the composer but the message is on the device.
expect(drafts.entries, isEmpty);
expect(drafts.unsentEntries['s'], hasLength(1));
// Reload: a new thread and composer; the old request never answers.
await _host(tester, gateway, drafts, generation: 1);
expect(_state('failed'), findsOneWidget);
expect(find.text('Did this arrive?'), findsOneWidget);
expect(find.byKey(const Key('chat-delivery-edit')), findsOneWidget);
await tester.tap(find.byKey(const Key('chat-delivery-retry')));
await _pump(tester);
expect(gateway.promptBodies.last['operation_id'], 'op-0-1');
expect(gateway.promptBodies.last['native_message_id'], 'msg_op01');
gateway.prompts.last.complete({});
await _pump(tester);
expect(_state('sent'), findsOneWidget);
expect(drafts.unsentEntries, isEmpty);
});
testWidgets('Edit puts a reloaded unsent message back in the composer', (
tester,
) async {
final gateway = _Gateway();
addTearDown(gateway.close);
final drafts = MemoryChatDraftStore(
unsent: {
's': [
{
'session_id': 's',
'text': 'Fix the typo',
'operation_id': 'op-old',
'native_message_id': 'msg_opold',
},
],
},
);
await _host(tester, gateway, drafts);
expect(_state('failed'), findsOneWidget);
await tester.tap(find.byKey(const Key('chat-delivery-edit')));
await _pump(tester);
expect(_state('failed'), findsNothing);
final field = tester.widget<EditableText>(find.byType(EditableText));
expect(field.controller.text, 'Fix the typo');
expect(drafts.unsentEntries, isEmpty);
expect(gateway.promptBodies, isEmpty);
});
testWidgets('a stored message the history already records is cleared as '
'sent', (tester) async {
final gateway = _Gateway()
..messages = [
{
'id': 'msg_opold',
'role': 'user',
'parts': [
{'type': 'text', 'text': 'Already there'},
],
},
];
addTearDown(gateway.close);
final drafts = MemoryChatDraftStore(
unsent: {
's': [
{
'session_id': 's',
'text': 'Already there',
'operation_id': 'op-old',
'native_message_id': 'msg_opold',
},
],
},
);
await _host(tester, gateway, drafts);
expect(_state('failed'), findsNothing);
expect(find.text('Already there'), findsOneWidget);
expect(drafts.unsentEntries, isEmpty);
});
}
+46 -1
View File
@@ -95,6 +95,10 @@ class _ProbeGateway implements ApiGateway {
if (text.toLowerCase().contains('refuse')) {
throw StateError('The fixture refused this prompt.');
}
// `hold`: the reply never arrives, so the message stays Sending….
if (text.toLowerCase().contains('hold')) {
return Completer<JsonMap>().future;
}
final queued = text.toLowerCase().contains('queued');
Timer(const Duration(milliseconds: 150), _running);
await Future<void>.delayed(const Duration(milliseconds: 450));
@@ -197,6 +201,11 @@ const _probeStyle = String.fromEnvironment(
/// Browser overrides: `?platform=cupertino|material`, `?theme=dark|light`,
/// `?long=1`, `?paras=1` (a chunked multi-paragraph reply), `?tasks=<n>`, `?mode=0` (no permission mode recorded) and
/// `?model=0` (a backend without models).
///
/// Delivery states: `?send=<text>` types and sends that text once the thread
/// has loaded (`hold` never replies, `queued` queues, `refuse` is refused), and
/// `?unsent=1` opens with a message a previous visit sent but never saw
/// accepted, as after a page reload mid-request.
Map<String, String> get _query => Uri.base.queryParameters;
int get _probeTasks => int.tryParse(_query['tasks'] ?? '') ?? 0;
@@ -219,9 +228,28 @@ void main() {
},
},
onBack: () {},
drafts: MemoryChatDraftStore(),
drafts: MemoryChatDraftStore(
drafts: {'probe-composer': ?_query['send']},
unsent: {
if (_query['unsent'] == '1')
'probe-composer': [
{
'session_id': 'probe-composer',
'text': 'Did this one reach the server before the reload?',
'operation_id': 'probe-op-reloaded',
'native_message_id': 'msg_probeopreloaded',
},
],
},
),
newOperationId: gateway.nextOperation,
);
if (_query['send'] != null) {
Timer(
const Duration(milliseconds: 1200),
() => _press('chat-composer-primary'),
);
}
if (cupertino) {
runApp(
CupertinoApp(
@@ -243,3 +271,20 @@ void main() {
),
);
}
/// Presses the native button carrying [key], as a tap would; the probe has no
/// pointer in a headless screenshot.
void _press(String key) {
void visit(Element element) {
final widget = element.widget;
if (widget.key == Key(key)) {
if (widget is CupertinoButton) widget.onPressed?.call();
if (widget is ButtonStyleButton) widget.onPressed?.call();
if (widget is IconButton) widget.onPressed?.call();
return;
}
element.visitChildren(visit);
}
WidgetsBinding.instance.rootElement?.visitChildren(visit);
}