Files
pipelines/app/lib/features/chat/chat_screen_workspace.dart
T
alan 45f5323c75 Keep phone chat back on the list
Treat server-synced open workspace snapshots as pane membership only so they do not show or retain a phone chat page. Add regression coverage for repeated system, button, and predictive Back cycles with tiled and floating entries.
2026-11-12 13:18:05 +00:00

531 lines
19 KiB
Dart

part of 'screen.dart';
/// Pane layout, focus and route publication for one Chat destination visit.
mixin _ChatScreenWorkspace on State<ChatScreen> {
Map<String, JsonMap> get _openedSessions;
ChatComposerFocusRequests get _composerFocus;
bool _chatOwnsKeyboard();
JsonMap? _rowFor(String id);
void _back();
bool get _pageOpen;
Widget _thread(ChatWorkspacePane pane);
ChatSidebarMode _sidebarMode = ChatSidebarMode.expanded;
void _setSidebarMode(ChatSidebarMode mode) {
if (_sidebarMode == mode) return;
setState(() => _sidebarMode = mode);
_workspaceBinding?.changed();
}
Widget _sidebarList(Widget full, String? selected, bool beside) {
final mode = selected == null || !beside
? ChatSidebarMode.expanded
: _sidebarMode;
final navigation = ShellBarScope.maybeOf(context);
return Stack(
fit: StackFit.expand,
children: [
Offstage(
offstage: mode != ChatSidebarMode.expanded,
child: ExcludeFocus(
excluding: mode != ChatSidebarMode.expanded,
child: full,
),
),
if (mode == ChatSidebarMode.compact)
ChatCompactSidebar(
navigation: navigation?.registry.canNavigate == true
? ShellDestinationMenu(
current: AppDestination.chat,
onSelected: navigation!.registry.navigateTo,
)
: null,
controller: _sessionsForSidebar,
folds: _foldsForSidebar,
activeSessionId: selected,
visibleSessionIds: _visibleSidebarSessions,
onOpen: _openSidebarSession,
onExpand: () => _setSidebarMode(ChatSidebarMode.expanded),
),
],
);
}
Set<String> _visibleWorkspaceSessions = const {};
/// Each pane's move targets as the workspace last laid them out. Read when
/// the chat list's row menu opens; it needs no rebuild of its own.
Map<String, Map<ChatPaneDirection, String>> _paneMoveTargets = const {};
void _paneMoveTargetsChanged(
Map<String, Map<ChatPaneDirection, String>> targets,
) {
_paneMoveTargets = targets;
}
void _workspaceVisibilityChanged(Set<String> sessions) {
if (!mounted || setEquals(_visibleWorkspaceSessions, sessions)) return;
setState(() => _visibleWorkspaceSessions = Set.unmodifiable(sessions));
}
Set<String> get _visibleSidebarSessions {
if (!_workspaceVisible) return const {};
final retained = _workspace.panes.map((pane) => pane.sessionId).toSet();
final visible = _visibleWorkspaceSessions.intersection(retained);
final active = _workspace.activePane?.sessionId;
return visible.isNotEmpty ? visible : {?active};
}
ChatSessionsController get _sessionsForSidebar;
ChatSectionFolds get _foldsForSidebar;
void _openSidebarSession(JsonMap session);
final ChatWorkspaceController _workspace = ChatWorkspaceController();
ChatOpenWorkspaceController? _openWorkspace;
bool _applyingServerWorkspace = false;
ChatWorkspaceBinding? _workspaceBinding;
String? _workspaceScope;
Iterable<ChatOpenWorkspaceEntry> _serverWorkspaceEntries() sync* {
final floating =
widget.windows?.floatingSessionIds.toSet() ?? const <String>{};
for (final pane in _workspace.panes) {
yield ChatOpenWorkspaceEntry(
pane.sessionId,
floating: floating.contains(pane.sessionId),
);
}
for (final sessionId in floating) {
if (!_workspace.holdsSession(sessionId)) {
yield ChatOpenWorkspaceEntry(sessionId, floating: true);
}
}
}
/// Sends this device's open chats to the server, unless the change is the
/// server's own snapshot being applied.
void _syncOpenWorkspace() {
if (_applyingServerWorkspace) return;
_openWorkspace?.replace(_serverWorkspaceEntries());
}
/// Binds the server's open-chat set for [widget.gateway], disposing the
/// previous binding (its subscription and queued writes) first. A
/// federated list spans several servers, so it keeps its local layout.
void _bindOpenWorkspace({required Future<void> after}) {
_openWorkspace?.dispose();
_openWorkspace = null;
_openWorkspaceApplied = false;
if (!widget.persistWorkspace || widget.gateway is FederatedChatGateway) {
return;
}
final open = ChatOpenWorkspaceController(gateway: widget.gateway)
..onChanged = _applyOpenWorkspace;
_openWorkspace = open;
// Seed from the restored local layout once it is restored.
unawaited(
after.then((_) async {
if (!mounted || open.disposed) return;
await open.start(local: _serverWorkspaceEntries());
}),
);
}
void _bindWorkspacePersistence() {
if (!widget.persistWorkspace) {
_bindOpenWorkspace(after: Future.value());
return;
}
final scope = serverStorageScope(serverIdentity(widget.gateway));
_workspaceScope = scope;
_workspaceBinding = ChatWorkspaceBinding(
controller: _workspace,
store: widget.gateway is FederatedChatGateway
? FederatedWorkspaceStore(
primary: (widget.gateway as FederatedChatGateway).primary(),
)
: SharedPreferencesChatWorkspaceStore(serverScope: scope),
sidebarMode: () => _sidebarMode.name,
onRestored: (snapshot) {
if (!mounted) return;
setState(() {
_sidebarMode = ChatSidebarMode.values.firstWhere(
(mode) => mode.name == snapshot.sidebarMode,
);
// Older snapshots could hide the rail. Keep their recovery affordance
// now that layout changes happen at the divider instead of a menu.
if (_sidebarMode == ChatSidebarMode.hidden) {
_sidebarMode = ChatSidebarMode.compact;
}
_usedWorkspace = true;
_workspaceVisible = _workspace.paneCount > 0;
});
_publishWorkspaceRoute();
},
);
_bindOpenWorkspace(
after: _workspaceBinding!.start(
initialSessionId: widget.initialSessionId,
),
);
}
/// Whether a server snapshot was applied since binding. The first one keeps
/// the chat this visit was opened on (a deep link) and adds it if absent.
bool _openWorkspaceApplied = false;
/// Applies the server's membership: windows and panes for chats it no
/// longer lists close, floating state follows it, and tiled chats take its
/// order while this device's split geometry stays.
void _applyOpenWorkspace(ChatOpenWorkspaceSnapshot snapshot) {
if (!mounted) return;
final initial = widget.initialSessionId ?? '';
final first = !_openWorkspaceApplied;
final keepInitial =
first &&
initial.isNotEmpty &&
!snapshot.entries.any((entry) => entry.sessionId == initial);
_openWorkspaceApplied = true;
if (keepInitial) {
snapshot = ChatOpenWorkspaceSnapshot(snapshot.revision, [
...snapshot.entries,
ChatOpenWorkspaceEntry(initial),
]);
}
_applyingServerWorkspace = true;
try {
final windows = widget.windows;
if (windows != null) {
final entriesBySession = {
for (final entry in snapshot.entries) entry.sessionId: entry,
};
for (final window in windows.windows.toList()) {
if (!entriesBySession.containsKey(window.contentId)) {
windows.manager.close(window.id);
}
}
for (final entry in snapshot.entries) {
final localWindow = windows.windows
.where((window) => window.contentId == entry.sessionId)
.firstOrNull;
if (entry.floating && localWindow == null) {
final pane = _workspace.panes
.where((pane) => pane.sessionId == entry.sessionId)
.firstOrNull;
if (pane != null) _workspace.close(pane.id);
windows.float(entry.sessionId);
} else if (!entry.floating && localWindow != null) {
windows.dock(localWindow);
}
}
}
_workspace.reconcileSessions(
snapshot.entries
.where((entry) => !entry.floating)
.map((entry) => entry.sessionId),
);
if (keepInitial) {
final pane = _workspace.panes
.where((pane) => pane.sessionId == initial)
.firstOrNull;
if (pane != null) _workspace.activate(pane.id);
}
} finally {
_applyingServerWorkspace = false;
}
// A snapshot only changes pane membership. It never shows the workspace,
// pushes a chat route or changes the view: on a phone the list stays the
// list until the user opens a chat.
if (keepInitial) _syncOpenWorkspace();
}
bool _updateWorkspacePersistence(ChatScreen oldWidget) {
final scope = serverStorageScope(serverIdentity(widget.gateway));
if (oldWidget.persistWorkspace == widget.persistWorkspace &&
(!widget.persistWorkspace || scope == _workspaceScope)) {
// Another connection to the same server: only the open-chat sync
// follows the gateway.
if (widget.persistWorkspace &&
!identical(oldWidget.gateway, widget.gateway)) {
_bindOpenWorkspace(after: Future.value());
}
return false;
}
_workspaceBinding?.dispose();
_workspaceBinding = null;
_openWorkspace?.dispose();
_openWorkspace = null;
if (_workspaceScope != null && scope != _workspaceScope) {
_workspace.restoreLayout(ChatWorkspaceSnapshot.fromLayout(null, null)!);
_workspaceVisible = false;
_usedWorkspace = true;
_sidebarMode = ChatSidebarMode.expanded;
_publishedWorkspaceSession = null;
final initial = widget.initialSessionId;
if (initial != null && initial.isNotEmpty) {
_workspace.open(initial);
_workspaceVisible = true;
}
}
_workspaceScope = null;
_bindWorkspacePersistence();
return true;
}
final GlobalKey _workspaceKey = GlobalKey();
bool _workspaceVisible = false;
bool _usedWorkspace = false;
String? _publishedWorkspaceSession;
String _workspaceSignature = '';
/// Ctrl+Tab cycles the floating chat windows while any is shown, from the
/// tiling as well (see [ChatWindows]). With none shown it cycles the
/// retained panes, even when the sidebar or toolbar owns focus, and over a
/// single pane it does nothing: it never brings up a chat that is not
/// visible in the tiling. Command+Tab stays with the operating system's
/// application switcher. While the app's terminal is shown, Ctrl+Tab moves
/// between its tabs instead. A floating window that is not a chat, or any
/// other window holding the keyboard, keeps the key.
bool _cycleChatKey(KeyEvent event) {
final keyboard = HardwareKeyboard.instance;
if (event is! KeyDownEvent ||
TerminalScope.peek(context)?.claimsTabKeys == true ||
keyboardWindow() != null ||
event.logicalKey != LogicalKeyboardKey.tab ||
!keyboard.isControlPressed ||
keyboard.isMetaPressed ||
keyboard.isAltPressed ||
!_chatOwnsKeyboard()) {
return false;
}
if (widget.windows?.raiseTopFromTiling() ?? false) return true;
if (!_workspaceVisible || _workspace.paneCount < 2) return false;
final panes = _workspace.panes;
final active = panes.indexWhere(
(pane) => pane.id == _workspace.activePaneId,
);
final direction = keyboard.isShiftPressed ? -1 : 1;
final target =
panes[((active < 0 ? 0 : active) + direction) % panes.length];
_workspace.activate(target.id);
WidgetsBinding.instance.addPostFrameCallback((_) {
if (!mounted ||
!_workspaceVisible ||
_workspace.activePaneId != target.id) {
return;
}
final destination = ShellBarScope.maybeOf(context)?.registry.focus;
if (destination == null || destination == AppDestination.chat) {
_composerFocus.request(target.sessionId);
}
});
WidgetsBinding.instance.ensureVisualUpdate();
return true;
}
void _workspaceChanged() {
if (!mounted) return;
if (_workspaceBinding?.isRestoring == true) return;
final signature =
'${_workspace.activePaneId}:${_workspace.panes.map((p) => '${p.id}=${p.sessionId}').join(',')}';
if (_workspaceSignature == signature) return;
_workspaceSignature = signature;
_syncOpenWorkspace();
void update() {
if (!mounted) return;
setState(() {});
_publishWorkspaceRoute();
}
if (SchedulerBinding.instance.schedulerPhase ==
SchedulerPhase.persistentCallbacks) {
WidgetsBinding.instance.addPostFrameCallback((_) => update());
} else {
update();
}
}
void _publishWorkspaceRoute() {
if (!mounted) return;
final id = _workspace.activePane?.sessionId;
final destination = ShellBarScope.maybeOf(context)?.registry.focus;
if (!_workspaceVisible ||
id == null ||
id == _publishedWorkspaceSession ||
(destination != null && destination != AppDestination.chat)) {
return;
}
_publishedWorkspaceSession = id;
widget.onSessionSelected?.call(id);
}
void _split(JsonMap session, ChatSplitAxis axis) {
final id = '${session['id'] ?? ''}';
if (id.isEmpty) return;
_openedSessions[id] = session;
_workspaceVisible = true;
if (!_pageOpen && showsListBesideDetail(context)) _usedWorkspace = true;
_workspace.splitActive(id, axis);
if (showsListBesideDetail(context) ||
chatSelectionFocusesComposer(const {})) {
_composerFocus.request(id);
} else {
_composerFocus.cancel();
FocusManager.instance.primaryFocus?.unfocus();
}
}
void _openBeside(JsonMap session) =>
_split(session, ChatSplitAxis.horizontal);
void _openBelow(JsonMap session) => _split(session, ChatSplitAxis.vertical);
/// The pane's chat trades places with [targetPaneId]'s and keeps focus; the
/// retained view moves, so its scroll, draft and running turn stay.
void _movePane(String paneId, String targetPaneId) {
_workspace.swap(paneId, targetPaneId);
final session = _workspace.activePane?.sessionId;
if (session != null) _composerFocus.request(session);
}
void _closePane(String paneId) {
_workspace.close(paneId);
if (_workspace.paneCount == 0) _back();
}
void _pickPane(BuildContext context) => showChatPanePicker(
context,
panes: [
for (final pane in _workspace.panes)
(
id: pane.id,
title: '${_rowFor(pane.sessionId)?['title'] ?? pane.sessionId}',
),
],
activeId: _workspace.activePaneId,
onSelected: (id) {
_workspace.activate(id);
final session = _workspace.activePane?.sessionId;
if (session != null && chatSelectionFocusesComposer(const {})) {
_composerFocus.request(session);
}
},
);
void _addPane(BuildContext context) {
// The action normally lives in the pane's More menu. Let that menu finish
// closing before pushing the picker, otherwise its root-overlay teardown
// can hide the newly opened anchored menu.
Future<void>.delayed(Duration.zero, () {
if (!context.mounted) return;
unawaited(
showAddChatPanePicker(
context,
controller: _sessionsForSidebar,
sidebarFolds: _foldsForSidebar,
excludedSessionIds: _workspace.panes
.map((pane) => pane.sessionId)
.toSet(),
onSelected: (session) {
if (!showsListBesideDetail(context)) {
// Save a horizontal desktop layout underneath the phone tape.
// Keep the rail compact so unfolding leaves room for the panes.
_setSidebarMode(ChatSidebarMode.compact);
_openBeside(session);
} else {
_openBelow(session);
}
},
),
);
});
}
Widget _workspaceView() => SafeArea(
top: false,
child: ChatCenterStageKeys(
controller: ChatCenterStageController.instance,
enabled: () =>
_workspaceVisible &&
_workspace.paneCount > 0 &&
showsListBesideDetail(context) &&
_chatOwnsKeyboard(),
child: ChatWorkspace(
key: _workspaceKey,
centerStage: ChatCenterStageController.instance,
paneColor: (pane) =>
chatColorShade(context, chatSessionColor(_rowFor(pane.sessionId))),
controller: _workspace,
onVisibleSessionIdsChanged: _workspaceVisibilityChanged,
onMoveTargetsChanged: _paneMoveTargetsChanged,
shortcutsEnabled: _workspaceVisible,
singlePane: !showsListBesideDetail(context),
mobilePeeks: true,
paneTitle: (pane) =>
'${_rowFor(pane.sessionId)?['title'] ?? pane.sessionId}',
onFocusPane: (pane) => _composerFocus.request(pane.sessionId),
paneBuilder: (context, pane, active) {
final scope = ChatWorkspacePaneScope.maybeOf(context);
final topShared = scope?.topEdgeShared ?? false;
final bottomShared = scope?.bottomEdgeShared ?? false;
final leftShared = scope?.leftEdgeShared ?? false;
final rightShared = scope?.rightEdgeShared ?? false;
final activeColor = _workspace.paneCount > 1 && active
? chatColorShade(
context,
chatSessionColor(_rowFor(pane.sessionId)),
) ??
Theme.of(context).colorScheme.primary
: Colors.transparent;
return Semantics(
selected: active,
child: AnimatedContainer(
duration: showsListBesideDetail(context)
? Motion.of(context, Motion.standard)
: Duration.zero,
curve: Motion.curve,
foregroundDecoration: BoxDecoration(
border: showsListBesideDetail(context)
? Border(
top: bottomShared && !topShared
? BorderSide(color: activeColor)
: BorderSide.none,
bottom: BorderSide(
color: bottomShared
? Colors.transparent
: activeColor,
),
left: bottomShared && topShared && !leftShared
? BorderSide(color: activeColor)
: BorderSide.none,
right:
bottomShared &&
topShared &&
leftShared &&
!rightShared
? BorderSide(color: activeColor)
: BorderSide.none,
)
: Border(
bottom: BorderSide(
color: bottomShared
? Colors.transparent
: activeColor,
),
),
),
// Every pane's bar carries its own chat's colour; beside the
// active pane the others fade theirs.
child: ChatPaneActivity(
inactive: _workspace.paneCount > 1 && !active,
child: KeyedSubtree(
key: ValueKey('chat-pane-detail-${pane.id}'),
child: _thread(pane),
),
),
),
);
},
),
),
);
}