04ba81e0ea
Keep chat and folder-picker UI on the Material path by removing obsolete Cupertino imports, icon metadata, flags, and alternate control handling while preserving existing behavior and focused test coverage.
448 lines
15 KiB
Dart
448 lines
15 KiB
Dart
import '../../../../core/servers/chat/federated_chat_gateway.dart';
|
|
import '../../../../core/servers/server_context.dart';
|
|
import 'chat_machine_picker.dart';
|
|
import '../../../../ui/adaptive/segmented_bar.dart';
|
|
import 'dart:async';
|
|
|
|
import 'package:flutter/material.dart';
|
|
|
|
import '../../../../ui/layout/content_width.dart';
|
|
|
|
import '../../../../core/api_gateway.dart';
|
|
import '../../../../shell/shell_bar.dart';
|
|
import '../../../../shell/shell_list_shortcuts.dart';
|
|
import '../../data/chat_repository.dart';
|
|
import '../../domain/chat_colors.dart';
|
|
import '../../domain/chat_cycle.dart';
|
|
import '../../domain/chat_sessions.dart';
|
|
import 'chat_adaptive.dart';
|
|
import 'chat_color_picker.dart';
|
|
import 'chat_session_local.dart';
|
|
import 'chat_sessions_body.dart';
|
|
import 'chat_sessions_controller.dart';
|
|
import 'create_chat_dialog.dart';
|
|
import 'rename_chat_dialog.dart';
|
|
import 'session_actions.dart';
|
|
|
|
/// Browses server-owned sessions. Opening a row is read-only at this layer.
|
|
class ChatSessionsScreen extends StatefulWidget {
|
|
const ChatSessionsScreen({
|
|
super.key,
|
|
required this.gateway,
|
|
required this.onOpen,
|
|
this.onOpenBeside,
|
|
this.onOpenBelow,
|
|
this.onShortcutOpen,
|
|
this.embedded = false,
|
|
this.syncToken = 0,
|
|
this.onSessions,
|
|
this.localStore,
|
|
this.controller,
|
|
this.activeSessionId,
|
|
this.visibleSessionIds = const {},
|
|
this.publishShellBar,
|
|
this.folds,
|
|
});
|
|
final ApiGateway gateway;
|
|
final void Function(JsonMap session) onOpen;
|
|
|
|
/// Optional split-pane actions; absent when the host cannot offer a split.
|
|
final ValueChanged<JsonMap>? onOpenBeside;
|
|
final ValueChanged<JsonMap>? onOpenBelow;
|
|
|
|
/// Opens a row the shell's Ctrl+1…Ctrl+9 named, so the destination can put
|
|
/// the keyboard in its composer; null opens it like a tap ([onOpen]).
|
|
final void Function(JsonMap session)? onShortcutOpen;
|
|
|
|
/// True under the application shell, which owns the single navigation bar.
|
|
final bool embedded;
|
|
|
|
/// Advances when the shared socket is replaced; sessions created, renamed or
|
|
/// closed elsewhere during the gap must not stay invisible until Refresh.
|
|
final int syncToken;
|
|
|
|
/// Reports the loaded rows after a frame. The destination resolves a routed
|
|
/// session id (a deep link) from them, so that conversation gets the same
|
|
/// title and model facts as a tapped row without a second list request.
|
|
final ValueChanged<List<JsonMap>>? onSessions;
|
|
|
|
/// The conversation open above this list, or null when the list is showing.
|
|
/// Pushed activity for it is being read, so it never raises a New mark.
|
|
final String? activeSessionId;
|
|
final Set<String> visibleSessionIds;
|
|
|
|
/// A pushed phone page owns separate chrome. Keep the underlying list's bar
|
|
/// ready without pretending its open conversation is unread/inactive.
|
|
final bool? publishShellBar;
|
|
|
|
/// Overrides the device-local hidden/read store in tests.
|
|
final ChatSessionLocalStore? localStore;
|
|
|
|
/// A list controller the destination owns and keeps across this screen's
|
|
/// life, so a session created from an open conversation can be listed here.
|
|
/// Null makes this screen own its own.
|
|
final ChatSessionsController? controller;
|
|
|
|
/// Which sections are folded, when the destination keeps them (Next chat
|
|
/// counts the same rows); null makes this screen keep its own.
|
|
final ChatSectionFolds? folds;
|
|
|
|
@override
|
|
State<ChatSessionsScreen> createState() => _ChatSessionsScreenState();
|
|
}
|
|
|
|
class _ChatSessionsScreenState extends State<ChatSessionsScreen> {
|
|
late final ChatSessionsController _controller =
|
|
(widget.controller ??
|
|
ChatSessionsController(
|
|
ChatRepository(widget.gateway),
|
|
localStore: widget.localStore,
|
|
))
|
|
..activeSessionId = widget.activeSessionId
|
|
..refresh();
|
|
final _search = TextEditingController();
|
|
late final ChatSectionFolds _folds = widget.folds ?? ChatSectionFolds();
|
|
Timer? _undoTimer;
|
|
String? _markedActiveSessionId;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_controller.addListener(_reportSessions);
|
|
}
|
|
|
|
/// Reports the loaded rows at the end of the frame: the destination learns a
|
|
/// routed row without this screen calling back inside its own build.
|
|
void _reportSessions() {
|
|
_markActiveSessionRead();
|
|
if (widget.onSessions == null) return;
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
if (!mounted) return;
|
|
widget.onSessions?.call(_controller.sessions);
|
|
});
|
|
}
|
|
|
|
void _markActiveSessionRead() {
|
|
final id = widget.activeSessionId;
|
|
if (id == null) {
|
|
_markedActiveSessionId = null;
|
|
return;
|
|
}
|
|
if (id == _markedActiveSessionId) return;
|
|
for (final session in _controller.sessions) {
|
|
if (_sessionId(session) != id) continue;
|
|
// Mark synchronously so row activation and subsequent list notifications
|
|
// cannot write the same read watermark twice.
|
|
_markedActiveSessionId = id;
|
|
unawaited(_controller.markOpened(session));
|
|
return;
|
|
}
|
|
}
|
|
|
|
@override
|
|
void didUpdateWidget(covariant ChatSessionsScreen oldWidget) {
|
|
super.didUpdateWidget(oldWidget);
|
|
_controller.activeSessionId = widget.activeSessionId;
|
|
_markActiveSessionRead();
|
|
if (oldWidget.gateway != widget.gateway) {
|
|
_controller.replaceRepository(ChatRepository(widget.gateway));
|
|
} else if (oldWidget.syncToken != widget.syncToken) {
|
|
unawaited(_controller.refresh());
|
|
}
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_undoTimer?.cancel();
|
|
_controller.removeListener(_reportSessions);
|
|
if (widget.controller == null) _controller.dispose();
|
|
if (widget.folds == null) _folds.dispose();
|
|
_search.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
String _sessionId(JsonMap session) => '${session['id'] ?? ''}';
|
|
|
|
Future<void> _rename(JsonMap session) async {
|
|
final id = _sessionId(session);
|
|
await showRenameChatDialog(
|
|
context,
|
|
session,
|
|
onSubmit: (title) => _controller.renameOrThrow(id, title),
|
|
);
|
|
}
|
|
|
|
Future<void> _close(JsonMap session) async {
|
|
if (!await confirmCloseChat(context, session)) return;
|
|
if (!mounted) return;
|
|
await _controller.close(_sessionId(session));
|
|
}
|
|
|
|
bool _openingRequestedChat = false;
|
|
|
|
void _resumeNewChatIntent() {
|
|
final scope = ServerContext.maybeOf(context);
|
|
if (_openingRequestedChat ||
|
|
scope == null ||
|
|
!scope.notifier!.takeNewChatIntent(scope.serverId)) {
|
|
return;
|
|
}
|
|
_openingRequestedChat = true;
|
|
WidgetsBinding.instance.addPostFrameCallback((_) async {
|
|
if (!mounted) return;
|
|
await _newChat(chooseMachine: false);
|
|
_openingRequestedChat = false;
|
|
});
|
|
}
|
|
|
|
Future<void> _newChat({bool chooseMachine = true}) async {
|
|
final scope = ServerContext.maybeOf(context);
|
|
var repository = _controller.repository;
|
|
if (chooseMachine && scope != null) {
|
|
final selected = await chooseChatMachine(context);
|
|
if (!mounted || selected == null) return;
|
|
if (repository.gateway is FederatedChatGateway) {
|
|
try {
|
|
repository = ChatRepository(
|
|
(repository.gateway as FederatedChatGateway).forServer(selected.id),
|
|
);
|
|
} catch (_) {
|
|
await showChatMachineError(
|
|
context,
|
|
'Sign in to ${selected.name} or retry its connection before creating a chat.',
|
|
);
|
|
return;
|
|
}
|
|
} else if (selected.id != scope.serverId) {
|
|
final switched = await scope.notifier!.requestNewChat(selected.id);
|
|
if (!switched && mounted) {
|
|
await showChatMachineError(
|
|
context,
|
|
scope.notifier!.error ?? 'The machine could not be selected.',
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
// One id per create intent: a refusal retried in the dialog reuses it.
|
|
final operationId = 'native-chat-${DateTime.now().microsecondsSinceEpoch}';
|
|
if (!mounted) return;
|
|
final session = await showChatCreateDialog(
|
|
context,
|
|
repository: repository,
|
|
operationId: operationId,
|
|
onSubmit: (draft, id) => _controller.createOrThrow(
|
|
targetRepository: repository,
|
|
title: draft.title,
|
|
directory: draft.directory,
|
|
backend: draft.backend,
|
|
instructions: draft.instructions,
|
|
operationId: id,
|
|
),
|
|
);
|
|
if (session != null && mounted) widget.onOpen(session);
|
|
}
|
|
|
|
void _markOpened(JsonMap session) {
|
|
_markedActiveSessionId = _sessionId(session);
|
|
unawaited(_controller.markOpened(session));
|
|
}
|
|
|
|
void _openBeside(JsonMap session) {
|
|
_markOpened(session);
|
|
widget.onOpenBeside?.call(session);
|
|
}
|
|
|
|
void _openBelow(JsonMap session) {
|
|
_markOpened(session);
|
|
widget.onOpenBelow?.call(session);
|
|
}
|
|
|
|
void _open(JsonMap session, {bool byShortcut = false}) {
|
|
_markOpened(session);
|
|
final open = byShortcut ? widget.onShortcutOpen : null;
|
|
(open ?? widget.onOpen)(session);
|
|
}
|
|
|
|
// Methods rather than closures, so the list's memoized rows see the same
|
|
// callbacks from one build to the next.
|
|
void _reopen(JsonMap session) => _controller.reopen(_sessionId(session));
|
|
|
|
void _star(JsonMap session) =>
|
|
_controller.star(_sessionId(session), session['starred'] != true);
|
|
|
|
Future<void> _color(JsonMap session) => showChatColorPicker(
|
|
context,
|
|
title: chatSessionTitle(session),
|
|
selected: chatSessionColor(session),
|
|
onSelected: (color) => _controller.setColor(_sessionId(session), color),
|
|
);
|
|
|
|
/// Ctrl+N: opens the Nth row the list draws (Starred first, then Chats by
|
|
/// directory, then Closed while it is unfolded), searched as shown.
|
|
bool _openIndex(int index) {
|
|
final rows = chatSessionsShown(
|
|
_controller.sessions,
|
|
query: _search.text,
|
|
isOpen: _folds.isOpen,
|
|
);
|
|
if (index < 0 || index >= rows.length) return false;
|
|
_open(rows[index], byShortcut: true);
|
|
return true;
|
|
}
|
|
|
|
Future<void> _hide(JsonMap session) async {
|
|
await _controller.hide(_sessionId(session));
|
|
_undoTimer?.cancel();
|
|
_undoTimer = Timer(const Duration(seconds: 8), () {
|
|
if (mounted) _controller.dismissUndo();
|
|
});
|
|
}
|
|
|
|
Future<void> _undoHide() async {
|
|
_undoTimer?.cancel();
|
|
await _controller.undoHide();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
_resumeNewChatIntent();
|
|
return ListenableBuilder(
|
|
listenable: _controller,
|
|
builder: (context, _) {
|
|
// Built under the page's scaffold, whose media padding carries the
|
|
// floating bar's height.
|
|
final body = Builder(
|
|
builder: (context) => Column(
|
|
children: [
|
|
// A notice above the list starts below the floating bar; the list
|
|
// under it then needs no inset of its own.
|
|
if (_controller.error != null)
|
|
Padding(
|
|
padding: EdgeInsets.only(
|
|
top: MediaQuery.paddingOf(context).top,
|
|
),
|
|
child: ChatErrorNotice(
|
|
message: _controller.error!,
|
|
onRetry: _controller.refresh,
|
|
),
|
|
),
|
|
Expanded(
|
|
child: MediaQuery.removePadding(
|
|
context: context,
|
|
removeTop: _controller.error != null,
|
|
child: Stack(
|
|
children: [
|
|
ContentWidth(
|
|
child: ChatSessionsBody(
|
|
sessions: _controller.sessions,
|
|
activeSessionId: widget.activeSessionId,
|
|
visibleSessionIds: widget.visibleSessionIds,
|
|
query: _search.text,
|
|
loading: _controller.loading,
|
|
error: _controller.error,
|
|
onOpen: _open,
|
|
onOpenBeside: widget.onOpenBeside == null
|
|
? null
|
|
: _openBeside,
|
|
onOpenBelow: widget.onOpenBelow == null
|
|
? null
|
|
: _openBelow,
|
|
onRename: _rename,
|
|
onClose: _close,
|
|
onReopen: _reopen,
|
|
onStar: _star,
|
|
onColor: _color,
|
|
onHide: _hide,
|
|
folds: _folds,
|
|
onClearSearch: () {
|
|
_search.clear();
|
|
setState(() {});
|
|
},
|
|
isUnseen: _controller.isUnseen,
|
|
errorFor: _controller.errorFor,
|
|
onDismissError: _controller.dismissError,
|
|
),
|
|
),
|
|
// The web's hide report is a fixed overlay: replacing or
|
|
// growing it must never move the list or overflow the screen.
|
|
if (_controller.lastHidden != null)
|
|
Positioned(
|
|
left: 8,
|
|
right: 8,
|
|
bottom: 8,
|
|
child: ChatUndoBar(
|
|
key: const Key('chat-undo-hide'),
|
|
message:
|
|
'Hidden on this device; the chat stays on the server.',
|
|
onUndo: _undoHide,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
// Under the shell, New chat and Refresh are its bar's actions; the
|
|
// list keeps the space without a search field.
|
|
if (widget.embedded) {
|
|
if (ShellBar.available(context)) {
|
|
return ShellBar(
|
|
active: widget.publishShellBar ?? widget.activeSessionId == null,
|
|
actions: _actions(),
|
|
// The Chat tab counts chats with messages not yet seen.
|
|
child: ShellBadge(
|
|
kind: ShellBadgeKind.unread,
|
|
count: _controller.sessions.where(_controller.isUnseen).length,
|
|
child: ShellListShortcut(onOpenIndex: _openIndex, child: body),
|
|
),
|
|
);
|
|
}
|
|
return Column(
|
|
children: [
|
|
Align(
|
|
alignment: AlignmentDirectional.centerEnd,
|
|
child: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: _actions(),
|
|
),
|
|
),
|
|
Expanded(child: body),
|
|
],
|
|
);
|
|
}
|
|
|
|
return Scaffold(
|
|
extendBodyBehindAppBar: true,
|
|
appBar: SegmentedBar(
|
|
cupertino: false,
|
|
title: 'Chats',
|
|
actions: _actions(),
|
|
),
|
|
// The list scrolls behind the floating bar; New chat is the bar's
|
|
// own action, so there is no second create button.
|
|
body: body,
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
List<Widget> _actions() => [
|
|
ChatBarAction(
|
|
key: const Key('chat-new-chat'),
|
|
label: 'New chat',
|
|
onPressed: _newChat,
|
|
materialIcon: Icons.add,
|
|
),
|
|
ChatBarAction(
|
|
key: const Key('chat-refresh'),
|
|
label: 'Refresh',
|
|
onPressed: _controller.refresh,
|
|
materialIcon: Icons.refresh,
|
|
),
|
|
];
|
|
}
|