Files
pipelines/app/tool/notification_probe.dart
T

292 lines
9.2 KiB
Dart

import 'dart:js_interop';
import 'dart:js_interop_unsafe';
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:pipelines_app/features/attention/domain/attention_models.dart';
import 'package:pipelines_app/features/attention/notify/notification_bridge.dart';
import 'package:pipelines_app/features/attention/notify/notification_controller.dart';
import 'package:pipelines_app/features/attention/notify/notification_ledger.dart';
import 'package:pipelines_app/features/attention/notify/notification_models.dart';
import 'package:pipelines_app/features/attention/notify/notification_store.dart';
import 'package:pipelines_app/features/attention/runtime/attention_controller.dart';
import 'package:pipelines_app/features/attention/runtime/attention_store.dart';
import 'package:pipelines_app/features/attention/ui/notification_permission_tile.dart';
/// Browser capture entrypoint for the notification capability.
///
/// It drives the real [NotificationController] over the real web bridge, so a
/// browser drive can prove the seed is silent, one live transition raises
/// exactly one notification with the entry's own words and run+kind identity, a
/// dismissed or replayed transition raises none, a second decision gate of one
/// run raises a fresh notification, and the Settings tile reads honestly in
/// every state on both hosts. Nothing here opens a socket or touches real
/// operator data; the store is in memory.
void main() {
final params = Uri.base.queryParameters;
final mode = params['mode'] ?? 'transition';
final cupertino = params['host'] == 'cupertino';
final scale = double.tryParse(params['scale'] ?? '') ?? 1;
final brightness = params['theme'] == 'light'
? Brightness.light
: Brightness.dark;
Widget scaled(BuildContext context, Widget? app) => MediaQuery(
data: MediaQuery.of(context).copyWith(textScaler: TextScaler.linear(scale)),
child: app!,
);
final home = switch (mode) {
'tiles' => const _TileGallery(),
'tile' => _SingleTile(state: _stateOf(params['state'])),
_ => _NotificationProbe(mode: mode),
};
if (cupertino) {
runApp(
CupertinoApp(
theme: CupertinoThemeData(brightness: brightness),
builder: scaled,
home: home,
),
);
return;
}
runApp(
MaterialApp(
theme: ThemeData(
platform: TargetPlatform.android,
brightness: brightness,
),
builder: scaled,
home: home,
),
);
}
/// The report the browser drive reads, as a plain JS string.
void _publishReport(String value) =>
globalContext.setProperty('__probeReport'.toJS, value.toJS);
/// The permission state named by a `state` query parameter, defaulting to the
/// undecided one.
NotificationPermissionState _stateOf(String? name) {
for (final state in NotificationPermissionState.values) {
if (state.wireName == name) return state;
}
return NotificationPermissionState.notRequested;
}
String _at(Duration before) =>
DateTime.now().toUtc().subtract(before).toIso8601String();
Map<String, dynamic> _summary(
int id,
String status, {
String name = 'release',
String? title,
String diagnostic = '',
}) => {
'id': id,
'name': name,
'title': title ?? 'Run $id',
'status': status,
'diagnostic': diagnostic,
'created_at': _at(const Duration(hours: 1)),
// The server leaves finished_at empty while a run is in flight or waiting.
'finished_at': status == 'waiting' || status == 'running'
? ''
: _at(const Duration(minutes: 55)),
};
Map<String, dynamic> _frame(
int id,
String status, {
String name = 'release',
String? title,
String diagnostic = '',
}) => {
'type': 'run_event',
'run_id': id,
'name': name,
'title': title ?? 'Run $id',
'status': status,
'diagnostic': diagnostic,
'finished_at': status == 'waiting' || status == 'running'
? ''
: _at(const Duration(minutes: 1)),
};
/// Publish exactly as the manager wires it: the accumulated transitions and the
/// current qualifying keys from the same attention snapshot.
int _publish(NotificationController notify, AttentionController attention) =>
notify.publishTransitions(
attention.transitions,
qualifying: notificationQualifyingKeys(attention.rows),
dismissed: attention.dismissed,
);
/// Runs one notification scenario against the real bridge, then reports it and
/// draws the live permission tile underneath.
class _NotificationProbe extends StatefulWidget {
const _NotificationProbe({required this.mode});
final String mode;
@override
State<_NotificationProbe> createState() => _NotificationProbeState();
}
class _NotificationProbeState extends State<_NotificationProbe> {
String _report = 'running';
NotificationPermissionState _permission =
NotificationPermissionState.unsupported;
bool _asked = false;
@override
void initState() {
super.initState();
WidgetsBinding.instance.addPostFrameCallback((_) => _run());
}
Future<void> _run() async {
final bridge = createNotificationBridge();
final notify = NotificationController(
store: MemoryNotificationStore(),
bridge: bridge,
);
await notify.load();
final attention = AttentionController(store: MemoryAttentionStore());
await attention.load();
switch (widget.mode) {
case 'seed':
attention.seedRows([
_summary(1, 'failed', diagnostic: 'Stage 3 stopped'),
_summary(2, 'waiting'),
]);
_publish(notify, attention);
case 'dismissed':
attention.seedRows([_summary(1, 'running')]);
await attention.dismiss(attentionEntryFor(_summary(1, 'failed'))!);
attention.observeFrame(_frame(1, 'failed'));
_publish(notify, attention);
case 'reconnect':
attention.seedRows([_summary(1, 'running')]);
attention.observeFrame(_frame(1, 'failed'));
_publish(notify, attention);
attention.resetForReconnect();
attention.seedRows([_summary(1, 'failed')], reconnect: true);
_publish(notify, attention);
attention.observeFrame(_frame(1, 'failed'));
_publish(notify, attention);
case 'secondgate':
// A waiting run has no finished_at, so two gates of one run carry the
// same timestamps; leaving the state is what makes the second new.
attention.seedRows([_summary(7, 'running')]);
attention.observeFrame(_frame(7, 'waiting'));
_publish(notify, attention);
attention.observeFrame(_frame(7, 'running'));
_publish(notify, attention);
attention.observeFrame(_frame(7, 'waiting'));
_publish(notify, attention);
case 'denied':
case 'unsupported':
case 'default':
attention.seedRows([_summary(1, 'running')]);
attention.observeFrame(_frame(1, 'failed'));
_publish(notify, attention);
default:
attention.seedRows([_summary(1, 'running', name: 'nightly')]);
attention.observeFrame(
_frame(
1,
'failed',
name: 'nightly',
title: 'Nightly audit',
diagnostic: 'Stage 3 stopped',
),
);
_publish(notify, attention);
}
if (!mounted) return;
final report =
'mode=${widget.mode} posted=${notify.postedCount} '
'state=${notify.permission.wireName} asked=${notify.asked} '
'notified=${notify.notified.length}';
_publishReport(report);
setState(() {
_report = report;
_permission = notify.permission;
_asked = notify.asked;
});
notify.dispose();
attention.dispose();
}
@override
Widget build(BuildContext context) {
return Scaffold(
body: SafeArea(
child: ListView(
padding: const EdgeInsets.all(16),
children: [
Text(_report),
const SizedBox(height: 16),
NotificationPermissionTile(
state: _permission,
asked: _asked,
onRequest: () {},
),
],
),
),
);
}
}
/// One permission state on its own, so each can be captured and read at the
/// hardest width and text scale.
class _SingleTile extends StatelessWidget {
const _SingleTile({required this.state});
final NotificationPermissionState state;
@override
Widget build(BuildContext context) {
return Scaffold(
body: SafeArea(
child: SingleChildScrollView(
padding: const EdgeInsets.all(16),
child: NotificationPermissionTile(state: state, onRequest: () {}),
),
),
);
}
}
/// Every permission state at once, so both hosts can be captured and read in
/// one page without touching a real permission.
class _TileGallery extends StatelessWidget {
const _TileGallery();
@override
Widget build(BuildContext context) {
return Scaffold(
body: SafeArea(
child: SingleChildScrollView(
padding: const EdgeInsets.all(16),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
for (final state in NotificationPermissionState.values) ...[
Text(state.wireName),
NotificationPermissionTile(state: state, onRequest: () {}),
],
],
),
),
),
);
}
}