305 lines
9.0 KiB
Dart
305 lines
9.0 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:flutter/foundation.dart';
|
|
|
|
import '../../../../core/api_gateway.dart';
|
|
import '../../../../core/transport/connection_state.dart';
|
|
import '../../data/chat_repository.dart';
|
|
import '../../domain/chat_sessions.dart';
|
|
import 'chat_session_local.dart';
|
|
|
|
/// Owns the session list, its refresh generation and the shared row actions.
|
|
///
|
|
/// A refresh that finishes after a newer one (or after the screen is gone) is
|
|
/// discarded, so a slow reply can never replace fresher state. Accepted
|
|
/// mutations always re-read the server list; only this device's hidden ids and
|
|
/// read watermark are local.
|
|
class ChatSessionsController extends ChangeNotifier {
|
|
ChatSessionsController(this.repository, {ChatSessionLocalStore? localStore})
|
|
: _localStore =
|
|
localStore ?? const SharedPreferencesChatSessionLocalStore() {
|
|
_listenFrames();
|
|
}
|
|
|
|
ChatRepository repository;
|
|
final ChatSessionLocalStore _localStore;
|
|
ChatSessionLocal _local = const ChatSessionLocal();
|
|
final Map<String, String> _actionErrors = {};
|
|
List<JsonMap> _sessions = const [];
|
|
String? _error;
|
|
String? _lastHidden;
|
|
bool _loading = true;
|
|
bool _localLoaded = false;
|
|
Future<void>? _localLoading;
|
|
bool _disposed = false;
|
|
int _generation = 0;
|
|
StreamSubscription<JsonMap>? _frameSubscription;
|
|
String? activeSessionId;
|
|
|
|
void _listenFrames() {
|
|
_frameSubscription?.cancel();
|
|
_frameSubscription = repository.gateway.frames.listen(_onFrame);
|
|
}
|
|
|
|
void _onFrame(JsonMap frame) {
|
|
final type = frame['type'];
|
|
String? id;
|
|
if (type == 'chat_event') {
|
|
final event = frame['chat_event'];
|
|
if (event is! Map || event['kind'] == 'usage') return;
|
|
id = event['session_id'] is String ? event['session_id'] as String : null;
|
|
} else if (type == 'chat_permission') {
|
|
final permission = frame['chat_permission'];
|
|
if (permission is! Map) return;
|
|
id = permission['session_id'] is String
|
|
? permission['session_id'] as String
|
|
: null;
|
|
} else {
|
|
return;
|
|
}
|
|
if (id == null || id.isEmpty || id == activeSessionId) return;
|
|
unawaited(_markUnseen(id));
|
|
}
|
|
|
|
Future<void> _markUnseen(String id) async {
|
|
await _ensureLocal();
|
|
final next = _local.markUnseen(id);
|
|
if (identical(next, _local)) return;
|
|
_local = next;
|
|
_notify();
|
|
await _persist();
|
|
}
|
|
|
|
List<JsonMap> get sessions => [
|
|
for (final session in _sessions)
|
|
if (!_local.isHidden('${session['id'] ?? ''}')) session,
|
|
];
|
|
|
|
String? get error => _error;
|
|
bool get loading => _loading;
|
|
|
|
/// The row an action failed on; the message is the server's own words.
|
|
String? errorFor(String sessionId) => _actionErrors[sessionId];
|
|
|
|
/// The operator acknowledged [sessionId]'s refusal; nothing is sent.
|
|
void dismissError(String sessionId) {
|
|
if (_actionErrors.remove(sessionId) != null) _notify();
|
|
}
|
|
|
|
/// The last hidden session, while its Undo is still offered.
|
|
String? get lastHidden => _lastHidden;
|
|
|
|
bool isUnseen(JsonMap session) {
|
|
final id = '${session['id'] ?? ''}';
|
|
if (id == activeSessionId) return false;
|
|
// Closed chats keep their recency from the close, but they are not new
|
|
// work: both the web list and the Android list suppress unseen there.
|
|
if (!_localLoaded ||
|
|
id.isEmpty ||
|
|
session['running'] == true ||
|
|
session['closed_at'] != null ||
|
|
session['closed'] == true) {
|
|
return false;
|
|
}
|
|
if (_local.isUnseen(id)) return true;
|
|
final updatedAt = chatSessionMillis(session['updated_at']);
|
|
return updatedAt > 0 && updatedAt > _local.watermark(id);
|
|
}
|
|
|
|
void replaceRepository(ChatRepository next) {
|
|
if (identical(next.gateway, repository.gateway)) return;
|
|
repository = next;
|
|
_listenFrames();
|
|
refresh();
|
|
}
|
|
|
|
Future<void> refresh() async {
|
|
if (_disposed) return;
|
|
final generation = ++_generation;
|
|
_loading = true;
|
|
_error = null;
|
|
_notify();
|
|
// Device preferences never gate the server read: a slow platform store
|
|
// must not hide the list or delay the first request.
|
|
unawaited(_ensureLocal());
|
|
try {
|
|
final sessions = await repository.sessions();
|
|
if (generation != _generation) return;
|
|
_sessions = sessions;
|
|
_seedLocal();
|
|
_loading = false;
|
|
_notify();
|
|
} catch (error) {
|
|
if (generation != _generation) return;
|
|
_error = '$error';
|
|
_loading = false;
|
|
_notify();
|
|
}
|
|
}
|
|
|
|
Future<void> star(String sessionId, bool starred) =>
|
|
_mutate(sessionId, () => repository.star(sessionId, starred));
|
|
|
|
Future<void> close(String sessionId) =>
|
|
_mutate(sessionId, () => repository.close(sessionId));
|
|
|
|
Future<void> reopen(String sessionId) =>
|
|
_mutate(sessionId, () => repository.reopen(sessionId));
|
|
|
|
/// Renames through the shared server field. Throws the server's refusal so the
|
|
/// open dialog can keep it in view; success refreshes the list from the server.
|
|
///
|
|
/// The dialog owns the refusal, so no row error is stored: the same sentence
|
|
/// must not also stick under the list row.
|
|
Future<void> renameOrThrow(String sessionId, String title) async {
|
|
await repository.rename(sessionId, title);
|
|
_actionErrors.remove(sessionId);
|
|
await refresh();
|
|
}
|
|
|
|
/// Creates one session and returns the server's `chat_session`. A reply
|
|
/// without one is refused rather than opening an invented row.
|
|
Future<JsonMap> createOrThrow({
|
|
required String title,
|
|
required String directory,
|
|
required String backend,
|
|
required String instructions,
|
|
required String operationId,
|
|
}) async {
|
|
final reply = await repository.create(
|
|
title: title,
|
|
directory: directory,
|
|
backend: backend,
|
|
operationId: operationId,
|
|
instructions: instructions,
|
|
);
|
|
final session = reply['chat_session'];
|
|
if (session is! Map) {
|
|
// The web reports exactly this refusal, so the dialog shows the same
|
|
// sentence instead of a Dart `Bad state:` prefix.
|
|
throw const ProtocolError(
|
|
'The server did not return the new chat session.',
|
|
);
|
|
}
|
|
// Opening the created chat must not wait for the list refresh: the dialog
|
|
// has already closed, so a slow listing would look like a failed create.
|
|
unawaited(refresh());
|
|
return Map<String, dynamic>.from(session);
|
|
}
|
|
|
|
/// Lists a session the server just created at the head of the loaded rows,
|
|
/// so the row is present before its conversation opens; the caller re-reads
|
|
/// the list from the server afterwards. A row with the same id is replaced,
|
|
/// never duplicated.
|
|
void insertCreated(JsonMap session) {
|
|
final id = '${session['id'] ?? ''}';
|
|
_sessions = [
|
|
session,
|
|
for (final row in _sessions)
|
|
if ('${row['id'] ?? ''}' != id) row,
|
|
];
|
|
_seedLocal();
|
|
_notify();
|
|
}
|
|
|
|
/// Records that this device has read [session]'s current recency.
|
|
Future<void> markOpened(JsonMap session) async {
|
|
final id = '${session['id'] ?? ''}';
|
|
if (id.isEmpty) return;
|
|
activeSessionId = id;
|
|
await _ensureLocal();
|
|
final next = _local.read(id, chatSessionMillis(session['updated_at']));
|
|
if (identical(next, _local)) return;
|
|
_local = next;
|
|
_notify();
|
|
await _persist();
|
|
}
|
|
|
|
/// Hides one row on this device only; the server row is untouched.
|
|
Future<void> hide(String sessionId) async {
|
|
await _ensureLocal();
|
|
final next = _local.hide(sessionId);
|
|
if (identical(next, _local)) return;
|
|
_local = next;
|
|
_lastHidden = sessionId;
|
|
_notify();
|
|
await _persist();
|
|
}
|
|
|
|
Future<void> undoHide() async {
|
|
final id = _lastHidden;
|
|
if (id == null) return;
|
|
_local = _local.restore(id);
|
|
_lastHidden = null;
|
|
_notify();
|
|
await _persist();
|
|
}
|
|
|
|
void dismissUndo() {
|
|
if (_lastHidden == null) return;
|
|
_lastHidden = null;
|
|
_notify();
|
|
}
|
|
|
|
Future<void> _mutate(
|
|
String sessionId,
|
|
Future<JsonMap> Function() action,
|
|
) async {
|
|
try {
|
|
await action();
|
|
_actionErrors.remove(sessionId);
|
|
await refresh();
|
|
} catch (error) {
|
|
_actionErrors[sessionId] = '$error';
|
|
_notify();
|
|
}
|
|
}
|
|
|
|
Future<void> _ensureLocal() => _localLoading ??= _loadLocal();
|
|
|
|
Future<void> _loadLocal() async {
|
|
try {
|
|
_local = await _localStore.load();
|
|
} catch (_) {
|
|
_local = const ChatSessionLocal();
|
|
}
|
|
_localLoaded = true;
|
|
_seedLocal();
|
|
_notify();
|
|
}
|
|
|
|
void _seedLocal() {
|
|
if (!_localLoaded) return;
|
|
final next = _local.seed([
|
|
for (final session in _sessions)
|
|
(
|
|
id: '${session['id'] ?? ''}',
|
|
updatedAt: chatSessionMillis(session['updated_at']),
|
|
),
|
|
]);
|
|
if (identical(next, _local)) return;
|
|
_local = next;
|
|
unawaited(_persist());
|
|
}
|
|
|
|
Future<void> _persist() async {
|
|
try {
|
|
await _localStore.save(_local);
|
|
} catch (_) {
|
|
// The in-memory choice still applies for this session.
|
|
}
|
|
}
|
|
|
|
void _notify() {
|
|
if (!_disposed) notifyListeners();
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_disposed = true;
|
|
_generation++;
|
|
unawaited(_frameSubscription?.cancel());
|
|
super.dispose();
|
|
}
|
|
}
|