21026233449

Committed 15 Jan 2026 09:26AM UTC coverage: 80.184% (-8.3%) from 88.441%

Build # 21026233449

Build Type

push

github

Committed by

web-flow

Commit Message

feat: Capability-based API migration pt2 (#323)

Run Details

162 of 408 new or added lines in 23 files covered. (39.71%)

328 existing lines in 17 files now uncovered.

4354 of 5430 relevant lines covered (80.18%)

34.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

48.57

/lib/src/capabilities/action_capability_impl.dart

import "dart:async";

import "package:duit_kernel/duit_kernel.dart";
import "package:flutter/widgets.dart";
import "package:flutter_duit/flutter_duit.dart";

class DuitActionManager with ServerActionExecutionCapabilityDelegate {
  late final UIDriver _driver;
  final _dataSources = <int, StreamSubscription<ServerEvent>>{};
  UserDefinedEventHandler? _navigationHandler,
      _openUrlHandler,
      _customEventHandler;

  Future<ServerEvent?> _executeAction(
    ServerAction action,
  ) async {
    switch (action) {
      //transport
      case TransportAction(
          :final dependsOn,
        ):
        try {
          final payload = _driver.preparePayload(dependsOn);
          final res = await _driver.executeRemoteAction(action, payload);

          if (res != null) {
            return ServerEvent.parseEvent(res);
          }
          return null;
        } catch (e, s) {
          _driver.logError(
            "[Error while executing transport action]",
            e,
            s,
          );
        }
        break;
      //local execution
      case LocalAction(
          :final event,
        ):
        return event;
      //script
      case ScriptAction(
          :final dependsOn,
          :final script,
          :final eventName,
        ):
        try {
          final body = _driver.preparePayload(dependsOn);

          final scriptInvocationResult = await _driver.execScript(
            script.functionName,
            url: eventName,
            meta: action.script.meta,
            body: body,
          );

          if (scriptInvocationResult != null) {
            return ServerEvent.parseEvent(scriptInvocationResult);
          }
          return null;
        } catch (e, s) {
          _driver.logError(
            "[Error while executing script action]",
            e,
            s,
          );
        }
        break;
    }
    return null;
  }

  @override
  Map<String, dynamic> preparePayload(
    Iterable<ActionDependency> dependencies,
  ) {
    final payload = <String, dynamic>{};

    if (dependencies.isNotEmpty) {
      for (final dependency in dependencies) {
        final controller = _driver.getController(dependency.id);
        if (controller != null) {
          final attribute = controller.attributes.payload;
          payload[dependency.target] = attribute["value"];
        }
      }
    }
    return payload;
  }

  @override
  Future<void> resolveEvent(BuildContext context, eventData) async {
    ServerEvent event;

    if (eventData is ServerEvent) {
      event = eventData;
    } else {
      event = ServerEvent.parseEvent(eventData);
    }

    try {
      switch (event) {
        case UpdateEvent(
            :final updates,
          ):
          for (final MapEntry(:key, :value) in updates.entries) {
            _driver.updateAttributes(key, value);
          }
          break;
        case NavigationEvent(
            :final path,
            :final extra,
          ):
          if (_navigationHandler != null) {
            await _navigationHandler!(context, path, extra);
          } else {
            _driver.logWarning(
              "NavigationEvent received but no handler attached",
            );
          }
          break;
        case OpenUrlEvent(
            :final url,
          ):
          if (_openUrlHandler != null) {
            await _openUrlHandler!(context, url, const {});
          } else {
            _driver.logWarning(
              "OpenUrlEvent received but no handler attached",
            );
          }
          break;
        case CustomEvent(
            :final key,
            :final extra,
          ):
          if (_driver.isModule) {
            await _driver.invokeNativeMethod<Map<String, dynamic>>(
              key,
              extra,
            );
          } else {
            if (_customEventHandler != null) {
              await _customEventHandler!(context, key, extra);
            } else {
              _driver.logWarning(
                "CustomEvent received but no handler attached",
              );
            }
          }
          break;
        case SequencedEventGroup(
            :final events,
          ):
          for (final entry in events) {
            if (context.mounted) {
              await resolveEvent(context, entry.event);
              await Future.delayed(entry.delay);
            }
          }
          break;
        case CommonEventGroup(
            :final events,
          ):
          for (final entry in events) {
            await resolveEvent(context, entry.event);
          }
          break;
        case CommandEvent(
            :final command,
          ):
          final c = _driver.getController(command.controllerId);
          await c?.emitCommand(command);
          break;
        case TimerEvent(
            :final timerDelay,
            :final payload,
          ):
          Future.delayed(
            timerDelay,
            () async {
              if (context.mounted) {
                await resolveEvent(context, payload);
              }
            },
          );
          break;
        default:
          break;
      }
    } catch (e, s) {
      _driver.logError(
        "Error while resolving ${event.type} event",
        e,
        s,
      );
    }
  }

  @override
  Future<void> execute(ServerAction action) async {
    try {
      final event = await _executeAction(
        action,
      );

      final ctx = _driver.buildContext;
      if (event != null && ctx.mounted) {
        resolveEvent(ctx, event);
      }
    } catch (e, s) {
      _driver.logError(
        "Error executing action",
        e,
        s,
      );
    }
  }

  @override
  void addExternalEventStream(
    Stream<Map<String, dynamic>> stream,
  ) {
    final id = stream.hashCode;

    _dataSources[id] = stream.map(ServerEvent.parseEvent).listen(
      (event) {
        if (event is NullEvent) {
          throw const NullEventException("NullEvent received from data source");
        }
        resolveEvent(
          // ignore: use_build_context_synchronously
          _driver.buildContext,
          event,
        );
      },
      onDone: () => _cancelSub(id),
      onError: (e, s) => _cancelSub(id),
    );
  }

  @preferInline
  void _cancelSub(int code) => _dataSources.remove(code)?.cancel();

  @override
  void releaseResources() {
    for (final subscription in _dataSources.values) {
      subscription.cancel();
    }
    _dataSources.clear();
  }

  @override
  void attachExternalHandler(
    UserDefinedHandlerKind type,
    UserDefinedEventHandler handle,
  ) {
    switch (type) {
      case UserDefinedHandlerKind.navigation:
        _navigationHandler = handle;
        break;
      case UserDefinedHandlerKind.openUrl:
        _openUrlHandler = handle;
        break;
      case UserDefinedHandlerKind.custom:
        _customEventHandler = handle;
        break;
    }
  }

  @override
  void linkDriver(UIDriver driver) => _driver = driver;
}

1	import "dart:async";
2
3	import "package:duit_kernel/duit_kernel.dart";
4	import "package:flutter/widgets.dart";
5	import "package:flutter_duit/flutter_duit.dart";
6
7	class DuitActionManager with ServerActionExecutionCapabilityDelegate {
8	late final UIDriver _driver;
9	final _dataSources = <int, StreamSubscription<ServerEvent>>{};
10	UserDefinedEventHandler? _navigationHandler,
11	_openUrlHandler,
12	_customEventHandler;
13
14	Future<ServerEvent?> _executeAction(	44✔
15	ServerAction action,
16	) async {
17	switch (action) {
18	//transport
19	case TransportAction(	44✔
20	:final dependsOn,	×
21	):
22	try {
23	final payload = _driver.preparePayload(dependsOn);	×
NEW 24	final res = await _driver.executeRemoteAction(action, payload);	×
25
26	if (res != null) {
27	return ServerEvent.parseEvent(res);	×
28	}
29	return null;
30	} catch (e, s) {
NEW 31	_driver.logError(	×
32	"[Error while executing transport action]",
33	e,
34	s,
35	);
36	}
37	break;
38	//local execution
39	case LocalAction(	44✔
40	:final event,	44✔
41	):
42	return event;
43	//script
44	case ScriptAction(	×
45	:final dependsOn,	×
46	:final script,	×
47	:final eventName,	×
48	):
49	try {
50	final body = _driver.preparePayload(dependsOn);	×
51
NEW 52	final scriptInvocationResult = await _driver.execScript(	×
53	script.functionName,	×
54	url: eventName,
55	meta: action.script.meta,	×
56	body: body,
57	);
58
59	if (scriptInvocationResult != null) {
60	return ServerEvent.parseEvent(scriptInvocationResult);	×
61	}
62	return null;
63	} catch (e, s) {
NEW 64	_driver.logError(	×
65	"[Error while executing script action]",
66	e,
67	s,
68	);
69	}
70	break;
71	}
72	return null;
73	}
74
75	@override	4✔
76	Map<String, dynamic> preparePayload(
77	Iterable<ActionDependency> dependencies,
78	) {
79	final payload = <String, dynamic>{};	4✔
80
81	if (dependencies.isNotEmpty) {	4✔
82	for (final dependency in dependencies) {	8✔
83	final controller = _driver.getController(dependency.id);	12✔
84	if (controller != null) {
85	final attribute = controller.attributes.payload;	8✔
86	payload[dependency.target] = attribute["value"];	12✔
87	}
88	}
89	}
90	return payload;
91	}
92
93	@override	48✔
94	Future<void> resolveEvent(BuildContext context, eventData) async {
95	ServerEvent event;
96
97	if (eventData is ServerEvent) {	48✔
98	event = eventData;
99	} else {
100	event = ServerEvent.parseEvent(eventData);	×
101	}
102
103	try {
104	switch (event) {
105	case UpdateEvent(	48✔
106	:final updates,	36✔
107	):
108	for (final MapEntry(:key, :value) in updates.entries) {	144✔
109	_driver.updateAttributes(key, value);	72✔
110	}
111	break;
112	case NavigationEvent(	20✔
113	:final path,	×
114	:final extra,	×
115	):
116	if (_navigationHandler != null) {	×
117	await _navigationHandler!(context, path, extra);	×
118	} else {
NEW 119	_driver.logWarning(	×
120	"NavigationEvent received but no handler attached",
121	);
122	}
123	break;
124	case OpenUrlEvent(	20✔
125	:final url,	×
126	):
127	if (_openUrlHandler != null) {	×
128	await _openUrlHandler!(context, url, const {});	×
129	} else {
NEW 130	_driver.logWarning(	×
131	"OpenUrlEvent received but no handler attached",
132	);
133	}
134	break;
135	case CustomEvent(	20✔
136	:final key,	4✔
137	:final extra,	4✔
138	):
139	if (_driver.isModule) {	8✔
NEW 140	await _driver.invokeNativeMethod<Map<String, dynamic>>(	×
141	key,
142	extra,
143	);
144	} else {
145	if (_customEventHandler != null) {	4✔
146	await _customEventHandler!(context, key, extra);	×
147	} else {
148	_driver.logWarning(	8✔
149	"CustomEvent received but no handler attached",
150	);
151	}
152	}
153	break;
154	case SequencedEventGroup(	16✔
155	:final events,	×
156	):
157	for (final entry in events) {	×
158	if (context.mounted) {	×
159	await resolveEvent(context, entry.event);	×
160	await Future.delayed(entry.delay);	×
161	}
162	}
163	break;
164	case CommonEventGroup(	16✔
165	:final events,	×
166	):
167	for (final entry in events) {	×
168	await resolveEvent(context, entry.event);	×
169	}
170	break;
171	case CommandEvent(	16✔
172	:final command,	16✔
173	):
174	final c = _driver.getController(command.controllerId);	48✔
175	await c?.emitCommand(command);	16✔
176	break;
177	case TimerEvent(	×
178	:final timerDelay,	×
179	:final payload,	×
180	):
181	Future.delayed(	×
182	timerDelay,
183	() async {	×
184	if (context.mounted) {	×
185	await resolveEvent(context, payload);	×
186	}
187	},
188	);
189	break;
190	default:
191	break;
192	}
193	} catch (e, s) {
NEW 194	_driver.logError(	×
195	"Error while resolving ${event.type} event",	×
196	e,
197	s,
198	);
199	}
200	}
201
202	@override	44✔
203	Future<void> execute(ServerAction action) async {
204	try {
205	final event = await _executeAction(	44✔
206	action,
207	);
208
209	final ctx = _driver.buildContext;	88✔
210	if (event != null && ctx.mounted) {	44✔
211	resolveEvent(ctx, event);	44✔
212	}
213	} catch (e, s) {
NEW 214	_driver.logError(	×
215	"Error executing action",
216	e,
217	s,
218	);
219	}
220	}
221
222	@override	4✔
223	void addExternalEventStream(
224	Stream<Map<String, dynamic>> stream,
225	) {
226	final id = stream.hashCode;	4✔
227
228	_dataSources[id] = stream.map(ServerEvent.parseEvent).listen(	16✔
229	(event) {	4✔
230	if (event is NullEvent) {	4✔
231	throw const NullEventException("NullEvent received from data source");
232	}
233	resolveEvent(	4✔
234	// ignore: use_build_context_synchronously
235	_driver.buildContext,	8✔
236	event,
237	);
238	},
239	onDone: () => _cancelSub(id),	8✔
240	onError: (e, s) => _cancelSub(id),	×
241	);
242	}
243
244	@preferInline	4✔
245	void _cancelSub(int code) => _dataSources.remove(code)?.cancel();	12✔
246
247	@override	4✔
248	void releaseResources() {
249	for (final subscription in _dataSources.values) {	8✔
250	subscription.cancel();	×
251	}
252	_dataSources.clear();	8✔
253	}
254
255	@override	×
256	void attachExternalHandler(
257	UserDefinedHandlerKind type,
258	UserDefinedEventHandler handle,
259	) {
260	switch (type) {
261	case UserDefinedHandlerKind.navigation:	×
262	_navigationHandler = handle;	×
263	break;
264	case UserDefinedHandlerKind.openUrl:	×
265	_openUrlHandler = handle;	×
266	break;
267	case UserDefinedHandlerKind.custom:	×
268	_customEventHandler = handle;	×
269	break;
270	}
271	}
272
273	@override	348✔
274	void linkDriver(UIDriver driver) => _driver = driver;	348✔
275	}

Duit-Foundation / flutter_duit / 21026233449

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous