Files
pipelines/app/lib/features/runs/screen.dart
T

282 lines
9.4 KiB
Dart

import 'dart:async';
import 'package:flutter/widgets.dart';
import '../../core/api_gateway.dart';
import '../../shell/destination.dart';
import '../../shell/detail_page.dart';
import '../../ui/adaptive/host.dart';
import '../attention/notify/notification_controller.dart';
import '../attention/runtime/attention_controller.dart';
import '../attention/runtime/attention_store.dart';
import 'actions/decision_action.dart';
import 'data/runs_repository.dart';
import 'domain/run_decisions.dart';
import 'ui/run_pipeline_link.dart';
import 'ui/run_detail_view.dart';
import 'ui/runs_controller.dart';
import 'ui/runs_list.dart';
/// The runs destination's list/detail switch.
///
/// The controller's `selectedRunId` is the only selection source, so an
/// initial run, a pending detail, a failed detail, Back and a route change all
/// navigate the same way. The shell owns the app bar; this screen adds no
/// second one.
class RunsScreen extends StatefulWidget {
const RunsScreen({
super.key,
required this.gateway,
this.initialRunId,
this.initialPipelineId,
this.initialStageKey,
this.initialVisit,
this.initialDecide = false,
this.syncToken = 0,
this.listRefreshToken = 0,
this.onRunSelected,
this.onBack,
this.onPipelineFilterChanged,
this.onOpenPipeline,
this.attentionStore = const SharedPreferencesAttentionStore(),
this.attentionNow,
this.notifications,
this.attention,
});
final ApiGateway gateway;
/// The run the current route names, or null for the list.
final int? initialRunId;
final int? initialPipelineId;
/// The recorded stage visit the route names inside [initialRunId]. The detail
/// applies it once per route target; the feature never invents a visit.
final String? initialStageKey;
final int? initialVisit;
/// The route's `?action=decide`: once the named run's detail is loaded, open
/// the recorded decision prompt when the run is genuinely waiting. Consumed
/// once per route target, so a rebuild or a live re-read never reopens it.
final bool initialDecide;
/// Advances when the shared socket is replaced. The loaded screen refreshes
/// in place instead of being remounted, so its selection survives.
final int syncToken;
/// Advances when a launch accepted outside this screen must be reflected by a
/// fresh `list_runs` read. It never inserts a row of its own.
final int listRefreshToken;
final ValueChanged<int>? onRunSelected;
final ValueChanged<int?>? onBack;
final ValueChanged<int?>? onPipelineFilterChanged;
/// Opens a pipeline from the run detail's pipeline name.
final OpenPipeline? onOpenPipeline;
/// Persisted attention dismissals and the clock for its local-day window.
/// The app uses SharedPreferences; tests and fixtures inject a memory store.
final AttentionStore attentionStore;
final DateTime Function()? attentionNow;
/// App-level notification delivery for live attention transitions.
final NotificationController? notifications;
/// The app's shared attention controller, mirrored on the shell's Runs tab.
final AttentionController? attention;
@override
State<RunsScreen> createState() => _RunsScreenState();
}
class _RunsScreenState extends State<RunsScreen> {
late final RunsController controller;
num? _shownRunId;
int? _reportedPipelineId;
bool _applyingRoutePipeline = false;
/// The route's decision request is one-shot: the first loaded detail for the
/// named run consumes it, whether or not that run is waiting.
bool _decideConsumed = false;
/// The open run is its own page over the tabs.
final DetailPageHost _page = DetailPageHost();
@override
void initState() {
super.initState();
controller = RunsController(RunsRepository(widget.gateway));
_reportedPipelineId = widget.initialPipelineId;
if (widget.initialPipelineId != null) {
controller.clearFilters();
controller.setPipeline(widget.initialPipelineId);
}
controller.listen(widget.gateway.frames);
controller.addListener(_selectionChanged);
controller.addListener(_pipelineFilterChanged);
controller.addListener(_detailChanged);
controller.load(widget.initialRunId);
}
@override
void didUpdateWidget(covariant RunsScreen oldWidget) {
super.didUpdateWidget(oldWidget);
if (widget.initialRunId != oldWidget.initialRunId ||
widget.initialDecide != oldWidget.initialDecide) {
_decideConsumed = false;
}
if (widget.initialPipelineId != oldWidget.initialPipelineId) {
final id = widget.initialPipelineId;
// A run detail replaces the list URL but retains its active list filter.
// Only a route back to the list can explicitly clear that facet.
if (id != null || widget.initialRunId == null) {
_applyingRoutePipeline = true;
try {
if (id != null) controller.clearFilters();
controller.setPipeline(id);
_reportedPipelineId = id;
} finally {
_applyingRoutePipeline = false;
}
}
}
if (widget.syncToken != oldWidget.syncToken) {
controller.resync();
}
// A launch accepted on another destination invalidates the list only. The
// route change below selects the returned run separately, so this is the
// one fresh server read that makes the new row appear.
if (widget.listRefreshToken != oldWidget.listRefreshToken) {
controller.load();
}
if (widget.initialRunId != oldWidget.initialRunId) {
final id = widget.initialRunId;
if (id == null) {
if (controller.selectedRunId != null) controller.back();
} else if (controller.selectedRunId != id) {
controller.select(id);
}
}
if (widget.initialRunId != oldWidget.initialRunId ||
widget.initialDecide != oldWidget.initialDecide) {
_detailChanged();
}
}
/// Rebuild the switch only when the selection changes. Detail progress and
/// live updates are already watched by [RunDetailView] and [RunsList], so
/// this avoids a second whole-detail rebuild per notification.
void _selectionChanged() {
final selected = controller.selectedRunId;
if (selected == _shownRunId) return;
_shownRunId = selected;
if (mounted) setState(() {});
}
void _pipelineFilterChanged() {
final id = controller.pipelineId;
if (_applyingRoutePipeline) {
_reportedPipelineId = id;
return;
}
if (id == _reportedPipelineId) return;
_reportedPipelineId = id;
if (controller.selectedRunId == null) {
widget.onPipelineFilterChanged?.call(id);
}
}
/// Opens the route's decision prompt after the named detail has arrived.
/// A non-waiting run consumes the request without a prompt, and the prompt
/// itself only closes; the detail underneath is left as it is.
void _detailChanged() {
if (!widget.initialDecide || _decideConsumed) return;
final run = controller.detail;
final selected = controller.selectedRunId;
if (run == null || selected == null || run['id'] != selected) return;
_decideConsumed = true;
if (pendingDecision(run) == null) return;
WidgetsBinding.instance.addPostFrameCallback((_) {
if (!mounted || controller.selectedRunId != selected) return;
final current = controller.detail;
if (current == null || pendingDecision(current) == null) return;
unawaited(
showRunDecisionPrompt(
context: context,
run: current,
gateway: widget.gateway,
onRunChanged: controller.acceptRunDetail,
cupertino: usesCupertinoHost(context),
isCurrent: () => mounted && controller.selectedRunId == selected,
),
);
});
}
void _select(num id) {
controller.select(id);
widget.onRunSelected?.call(id.toInt());
}
void _back() {
controller.back();
widget.onBack?.call(controller.pipelineId);
}
@override
void dispose() {
controller.removeListener(_selectionChanged);
controller.removeListener(_pipelineFilterChanged);
controller.removeListener(_detailChanged);
_page.dispose();
controller.dispose();
super.dispose();
}
Widget _detail(VoidCallback onBack) => RunDetailView(
controller: controller,
gateway: widget.gateway,
onBack: onBack,
onRunOpened: _select,
onOpenPipeline: widget.onOpenPipeline,
initialStageKey: widget.initialStageKey,
initialVisit: widget.initialVisit,
);
@override
Widget build(BuildContext context) {
final selected = controller.selectedRunId != null;
// On a phone an open run 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 && narrow,
destination: AppDestination.runs,
onClosed: _back,
builder: (context) => _detail(() => Navigator.of(context).maybePop()),
);
final list = AnimatedBuilder(
animation: controller,
builder: (context, _) => RunsList(
active: !selected,
controller: controller,
onSelected: _select,
syncToken: widget.syncToken,
attentionStore: widget.attentionStore,
attentionNow: widget.attentionNow,
notifications: widget.notifications,
attention: widget.attention,
),
);
if (narrow) return list;
return Stack(
children: [
Offstage(offstage: selected, child: list),
if (selected) _detail(_back),
],
);
}
}