251 lines
7.8 KiB
Dart
251 lines
7.8 KiB
Dart
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
|
|
import '../core/transport/connection_state.dart';
|
|
import '../features/runs/screen.dart';
|
|
import '../ui/adaptive/host.dart';
|
|
import 'app_session.dart';
|
|
import 'server_endpoint.dart';
|
|
|
|
/// The Runs destination: the loaded screen plus an honest connection status.
|
|
///
|
|
/// Before the first successful connection there is nothing to show, so the
|
|
/// destination is a full connection screen. After that the screen stays
|
|
/// mounted through drops and reconnects: a status banner reports reconnecting
|
|
/// or not live, and the screen reloads in place without losing the open run.
|
|
class RunsDestination extends StatelessWidget {
|
|
const RunsDestination({
|
|
super.key,
|
|
required this.session,
|
|
required this.server,
|
|
this.initialRunId,
|
|
this.onRunSelected,
|
|
this.onBack,
|
|
});
|
|
|
|
final AppSession session;
|
|
final ServerEndpoint server;
|
|
final int? initialRunId;
|
|
final ValueChanged<int>? onRunSelected;
|
|
final VoidCallback? onBack;
|
|
|
|
@override
|
|
Widget build(BuildContext context) => AnimatedBuilder(
|
|
animation: session,
|
|
builder: (context, _) {
|
|
final cupertino = usesCupertinoHost(context);
|
|
if ((server.requiresConfiguration || server.error != null) &&
|
|
session.endpoint == null) {
|
|
return _ConnectionScreen(
|
|
session: session,
|
|
server: server,
|
|
cupertino: cupertino,
|
|
);
|
|
}
|
|
if (!session.everConnected) {
|
|
if (session.connected) return _runsScreen();
|
|
return _ConnectionScreen(
|
|
session: session,
|
|
server: server,
|
|
cupertino: cupertino,
|
|
);
|
|
}
|
|
return Column(
|
|
children: [
|
|
if (!session.connected ||
|
|
session.subscription == RunSubscriptionState.refused)
|
|
_ConnectionBanner(session: session, cupertino: cupertino),
|
|
Expanded(child: _runsScreen()),
|
|
],
|
|
);
|
|
},
|
|
);
|
|
|
|
Widget _runsScreen() => RunsScreen(
|
|
gateway: session.gateway,
|
|
initialRunId: initialRunId,
|
|
syncToken: session.connectionEpoch,
|
|
onRunSelected: onRunSelected,
|
|
onBack: onBack,
|
|
);
|
|
}
|
|
|
|
class _ConnectionScreen extends StatelessWidget {
|
|
const _ConnectionScreen({
|
|
required this.session,
|
|
required this.server,
|
|
required this.cupertino,
|
|
});
|
|
|
|
final AppSession session;
|
|
final ServerEndpoint server;
|
|
final bool cupertino;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final state = session.connection;
|
|
if (server.requiresConfiguration) {
|
|
return _status(
|
|
context,
|
|
title: 'Server endpoint not configured',
|
|
detail:
|
|
'Build the native app with an explicit Pipelines endpoint, for '
|
|
'example --dart-define=PIPELINES_SERVER_URL=ws://host:port/connect.',
|
|
);
|
|
}
|
|
if (server.error != null) {
|
|
return _status(context, title: server.error!, detail: '');
|
|
}
|
|
// Only the very first attempt is "connecting". A failed attempt keeps the
|
|
// same honest unavailable state while the client retries behind it, so the
|
|
// screen no longer flickers between unavailable and connecting.
|
|
if (state.kind == ConnectionKind.connecting && state.attempt <= 1) {
|
|
return _status(
|
|
context,
|
|
title: 'Connecting to Pipelines…',
|
|
detail: '',
|
|
progress: true,
|
|
);
|
|
}
|
|
return _status(
|
|
context,
|
|
title: 'Pipelines server unavailable',
|
|
detail: state.retrying
|
|
? 'Retrying automatically. Check that the Pipelines server is running.'
|
|
: 'Check that the Pipelines server is running, then try again.',
|
|
onRetry: session.retry,
|
|
);
|
|
}
|
|
|
|
Widget _status(
|
|
BuildContext context, {
|
|
required String title,
|
|
required String detail,
|
|
bool progress = false,
|
|
VoidCallback? onRetry,
|
|
}) {
|
|
final theme = Theme.of(context);
|
|
return Center(
|
|
child: SingleChildScrollView(
|
|
padding: const EdgeInsets.all(24),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
if (progress)
|
|
Padding(
|
|
padding: const EdgeInsets.only(bottom: 12),
|
|
child: cupertino
|
|
? const CupertinoActivityIndicator()
|
|
: const CircularProgressIndicator(),
|
|
),
|
|
Semantics(
|
|
liveRegion: true,
|
|
child: Text(
|
|
title,
|
|
textAlign: TextAlign.center,
|
|
style: cupertino
|
|
? CupertinoTheme.of(context).textTheme.navTitleTextStyle
|
|
: theme.textTheme.titleMedium,
|
|
),
|
|
),
|
|
if (detail.isNotEmpty) ...[
|
|
const SizedBox(height: 8),
|
|
Text(
|
|
detail,
|
|
textAlign: TextAlign.center,
|
|
style: cupertino ? null : theme.textTheme.bodyMedium,
|
|
),
|
|
],
|
|
if (onRetry != null) ...[
|
|
const SizedBox(height: 16),
|
|
if (cupertino)
|
|
CupertinoButton(onPressed: onRetry, child: const Text('Retry'))
|
|
else
|
|
FilledButton(onPressed: onRetry, child: const Text('Retry')),
|
|
],
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// A compact status bar above the retained Runs screen.
|
|
class _ConnectionBanner extends StatelessWidget {
|
|
const _ConnectionBanner({required this.session, required this.cupertino});
|
|
|
|
final AppSession session;
|
|
final bool cupertino;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final state = session.connection;
|
|
final refused = session.subscription == RunSubscriptionState.refused;
|
|
final reconnecting =
|
|
!session.connected &&
|
|
(state.kind == ConnectionKind.connecting || state.retrying);
|
|
final String title;
|
|
final String detail;
|
|
final VoidCallback onRetry;
|
|
if (session.connected && refused) {
|
|
title = 'Not live — run updates are unavailable.';
|
|
detail = session.subscriptionError;
|
|
onRetry = session.resubscribe;
|
|
} else if (reconnecting) {
|
|
title = 'Reconnecting to Pipelines…';
|
|
detail = '';
|
|
onRetry = session.retry;
|
|
} else {
|
|
title = 'Not live — Pipelines server unavailable.';
|
|
detail = 'Check that the Pipelines server is running.';
|
|
onRetry = session.retry;
|
|
}
|
|
final textStyle = cupertino
|
|
? CupertinoTheme.of(context).textTheme.textStyle
|
|
: Theme.of(context).textTheme.bodyMedium;
|
|
return ColoredBox(
|
|
color: cupertino
|
|
? CupertinoDynamicColor.resolve(CupertinoColors.systemGrey5, context)
|
|
: Theme.of(context).colorScheme.surfaceContainerHighest,
|
|
child: Padding(
|
|
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
|
|
child: Row(
|
|
children: [
|
|
if (reconnecting) ...[
|
|
cupertino
|
|
? const CupertinoActivityIndicator(radius: 7)
|
|
: const SizedBox(
|
|
width: 14,
|
|
height: 14,
|
|
child: CircularProgressIndicator(strokeWidth: 2),
|
|
),
|
|
const SizedBox(width: 10),
|
|
],
|
|
Expanded(
|
|
child: Semantics(
|
|
liveRegion: true,
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(title, style: textStyle),
|
|
if (detail.isNotEmpty) Text(detail, style: textStyle),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
if (cupertino)
|
|
CupertinoButton(
|
|
padding: EdgeInsets.zero,
|
|
onPressed: onRetry,
|
|
child: const Text('Retry'),
|
|
)
|
|
else
|
|
TextButton(onPressed: onRetry, child: const Text('Retry')),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|