233 lines
7.6 KiB
Dart
233 lines
7.6 KiB
Dart
import '../../shell/destination.dart';
|
|
import '../../shell/detail_page.dart';
|
|
import 'dart:async';
|
|
|
|
import 'package:flutter/material.dart';
|
|
|
|
import '../../core/api_gateway.dart';
|
|
import 'conversation/chat_models.dart';
|
|
import 'conversation/chat_scroll.dart';
|
|
import 'conversation/chat_thread_view.dart';
|
|
import 'data/chat_repository.dart';
|
|
import 'ui/sessions/chat_sessions_controller.dart';
|
|
import 'ui/sessions/chat_sessions_screen.dart';
|
|
|
|
/// The Chat destination's list/detail switch.
|
|
///
|
|
/// The route names the open session, so a row tap, a deep link and Back all
|
|
/// navigate through the same value. The session list stays mounted (offstage)
|
|
/// while a conversation is open, so returning to it keeps its rows and query.
|
|
/// The destination owns the list controller too, so a session a conversation's
|
|
/// `/new` creates is listed, opened and refreshed from here.
|
|
/// The shell owns the app bar; this screen adds no second one.
|
|
class ChatScreen extends StatefulWidget {
|
|
const ChatScreen({
|
|
super.key,
|
|
required this.gateway,
|
|
this.initialSessionId,
|
|
this.syncToken = 0,
|
|
this.onSessionSelected,
|
|
this.onBack,
|
|
});
|
|
|
|
final ApiGateway gateway;
|
|
|
|
/// The chat session the current route names, or null for the list.
|
|
final String? initialSessionId;
|
|
|
|
/// Advances when the shared socket is replaced. The open conversation
|
|
/// re-subscribes and re-reads in place, so its selection survives.
|
|
final int syncToken;
|
|
|
|
final ValueChanged<String>? onSessionSelected;
|
|
final VoidCallback? onBack;
|
|
|
|
@override
|
|
State<ChatScreen> createState() => _ChatScreenState();
|
|
}
|
|
|
|
class _ChatScreenState extends State<ChatScreen> {
|
|
/// The list's controller, shared with the mounted list screen. The list
|
|
/// screen refreshes it on mount and swaps its repository when the socket is
|
|
/// replaced; this destination lists created rows and re-reads after a
|
|
/// conversation's command changes a session.
|
|
late final ChatSessionsController _sessions = ChatSessionsController(
|
|
ChatRepository(widget.gateway),
|
|
);
|
|
|
|
/// Rows this visit has opened, used for the native title and the recorded
|
|
/// model facts. The mounted list also reports its loaded rows, so a routed id
|
|
/// (a deep link) resolves the same row without a second list request.
|
|
final Map<String, JsonMap> _openedSessions = {};
|
|
|
|
/// Model switches the server accepted after a row was opened. The row that
|
|
/// opened the conversation may still carry the pre-switch model, so these win
|
|
/// for the rest of this visit, including when the same chat is reopened.
|
|
final Map<String, ChatModelSelection> _acceptedModels = {};
|
|
|
|
/// Transcript positions for this visit. It lives with the destination, not a
|
|
/// conversation view, so Back and a reopened chat return to the same place.
|
|
final ChatScrollStore _scrollPositions = MemoryChatScrollStore();
|
|
|
|
/// The line a just-created conversation opens on, tied to the selection
|
|
/// `/new` made. Leaving that conversation drops it, so a later reopen is an
|
|
/// ordinary visit.
|
|
({String id, String notice})? _startNotice;
|
|
|
|
String? _standaloneSelection;
|
|
|
|
String? get _selected {
|
|
final routed = widget.initialSessionId;
|
|
if (routed != null && routed.isNotEmpty) return routed;
|
|
return _standaloneSelection;
|
|
}
|
|
|
|
void _open(JsonMap session) {
|
|
final id = '${session['id'] ?? ''}';
|
|
if (id.isEmpty) return;
|
|
_openedSessions[id] = session;
|
|
if (_startNotice?.id != id) _startNotice = null;
|
|
final select = widget.onSessionSelected;
|
|
if (select != null) {
|
|
select(id);
|
|
} else {
|
|
setState(() => _standaloneSelection = id);
|
|
}
|
|
}
|
|
|
|
/// `/new` created [session]: list it at the head before its conversation
|
|
/// opens, open it on [notice], then re-read the list from the server.
|
|
void _openCreated(JsonMap session, String notice) {
|
|
final id = '${session['id'] ?? ''}';
|
|
if (id.isEmpty) return;
|
|
_sessions.insertCreated(session);
|
|
_startNotice = (id: id, notice: notice);
|
|
_open(session);
|
|
unawaited(_sessions.refresh());
|
|
}
|
|
|
|
/// `/rename` was accepted for [id]: the opened row follows the shared title
|
|
/// and the list re-reads it.
|
|
void _renamed(String id, String title) {
|
|
final row = _openedSessions[id];
|
|
if (row != null) {
|
|
setState(() => _openedSessions[id] = {...row, 'title': title});
|
|
}
|
|
unawaited(_sessions.refresh());
|
|
}
|
|
|
|
/// `/close` was accepted: the conversation leaves, back to the list, which
|
|
/// re-reads the closed row.
|
|
void _closed() {
|
|
_back();
|
|
unawaited(_sessions.refresh());
|
|
}
|
|
|
|
/// Adopts the list's loaded rows for the routed session: a deep link opens
|
|
/// the conversation before any row has been tapped, and the header's title
|
|
/// and model control come from that row. Called after a frame, never during
|
|
/// the list's own build.
|
|
void _adoptRows(List<JsonMap> rows) {
|
|
final id = _selected;
|
|
if (id == null || _openedSessions.containsKey(id)) return;
|
|
for (final row in rows) {
|
|
if ('${row['id'] ?? ''}' != id) continue;
|
|
setState(() => _openedSessions[id] = row);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void _modelChanged(String id, ChatModelSelection applied) {
|
|
if (!mounted) return;
|
|
setState(() => _acceptedModels[id] = applied);
|
|
}
|
|
|
|
/// The row to open for [id], with an accepted model folded in.
|
|
JsonMap? _rowFor(String id) {
|
|
final row = _openedSessions[id];
|
|
final accepted = _acceptedModels[id];
|
|
if (row == null || accepted == null) return row;
|
|
return {
|
|
...row,
|
|
'model': accepted.model,
|
|
'model_provider': accepted.provider,
|
|
'model_selection': accepted.selection,
|
|
};
|
|
}
|
|
|
|
void _back() {
|
|
_startNotice = null;
|
|
final back = widget.onBack;
|
|
if (back != null) {
|
|
back();
|
|
} else {
|
|
setState(() => _standaloneSelection = null);
|
|
}
|
|
}
|
|
|
|
/// The open chat is its own page over the tabs on a phone.
|
|
final DetailPageHost _page = DetailPageHost();
|
|
|
|
@override
|
|
void dispose() {
|
|
_page.dispose();
|
|
_sessions.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
Widget _thread(String selected, VoidCallback onBack) {
|
|
final row = _rowFor(selected);
|
|
final start = _startNotice;
|
|
return ChatThreadView(
|
|
key: ValueKey<String>('chat-session-$selected'),
|
|
gateway: widget.gateway,
|
|
sessionId: selected,
|
|
title: '${row?['title'] ?? ''}'.trim(),
|
|
session: row,
|
|
syncToken: widget.syncToken,
|
|
scrollPositions: _scrollPositions,
|
|
initialNotice: start != null && start.id == selected
|
|
? start.notice
|
|
: null,
|
|
onBack: onBack,
|
|
onModelChanged: (applied) => _modelChanged(selected, applied),
|
|
onCreatedSession: _openCreated,
|
|
onSessionRenamed: (title) => _renamed(selected, title),
|
|
onSessionClosed: _closed,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final selected = _selected;
|
|
// On a phone an open chat is its own page over the tabs; a wide window
|
|
// keeps it in the tab, beside the destination rail.
|
|
final narrow = MediaQuery.sizeOf(context).width < kDetailPageMaxWidth;
|
|
_page.sync(
|
|
context,
|
|
selected: selected != null && narrow,
|
|
destination: AppDestination.chat,
|
|
onClosed: _back,
|
|
builder: (context) => selected == null
|
|
? const SizedBox.shrink()
|
|
: _thread(selected, () => Navigator.of(context).maybePop()),
|
|
);
|
|
final list = ChatSessionsScreen(
|
|
gateway: widget.gateway,
|
|
embedded: true,
|
|
syncToken: widget.syncToken,
|
|
controller: _sessions,
|
|
onOpen: _open,
|
|
onSessions: _adoptRows,
|
|
activeSessionId: narrow ? null : selected,
|
|
);
|
|
if (narrow) return list;
|
|
return Stack(
|
|
children: [
|
|
Offstage(offstage: selected != null, child: list),
|
|
if (selected != null) _thread(selected, _back),
|
|
],
|
|
);
|
|
}
|
|
}
|