@@ -33,14 +33,15 @@ typedef DtdService = (String, DTDServiceCallback);
3333/// Provides services, streams, and RPC invocations to interact with the Widget Preview Scaffold.
3434class WidgetPreviewDtdServices {
3535 WidgetPreviewDtdServices ({
36- required this .previewAnalytics,
36+ required this .addUuidToServiceName,
37+ required this .dtdLauncher,
3738 required this .fs,
3839 required this .logger,
39- required this .shutdownHooks,
40- required this .dtdLauncher,
4140 required this .onHotRestartPreviewerRequest,
41+ required this .previewAnalytics,
4242 required this .project,
43- required this .addUuidToServiceName,
43+ required this .shutdownHooks,
44+ @visibleForTesting this ._dtd,
4445 }) {
4546 shutdownHooks.addShutdownHook (() async {
4647 await _dtd? .close ();
@@ -75,6 +76,28 @@ class WidgetPreviewDtdServices {
7576 /// The name of the language server protocol stream written to by the analysis server.
7677 static const kLspStream = 'Lsp' ;
7778
79+ /// The event kind posted to [kLspStream] once all LSP services have been registered with DTD.
80+ @visibleForTesting
81+ static const kLspInitializedEvent = 'initialized' ;
82+
83+ @visibleForTesting
84+ static const kGetFlutterWidgetPreviewsMethod = 'dart/workspace/getFlutterWidgetPreviews' ;
85+
86+ @visibleForTesting
87+ static const kGetFlutterWidgetPreviewsForFileMethod =
88+ 'dart/textDocument/getFlutterWidgetPreviews' ;
89+
90+ @visibleForTesting
91+ static const kWorkspaceAnalysisCompleteMethod = 'dart/workspace/analysis/complete' ;
92+
93+ /// The set of LSP service methods required by the widget previewer.
94+ @visibleForTesting
95+ static const kRequiredLspServices = < String > {
96+ kGetFlutterWidgetPreviewsMethod,
97+ kGetFlutterWidgetPreviewsForFileMethod,
98+ kWorkspaceAnalysisCompleteMethod,
99+ };
100+
78101 /// The name of the event sent from the analysis server for widget preview updates.
79102 static const kLspWidgetPreviewEventKind = 'dart/textDocument/publishFlutterWidgetPreviews' ;
80103
@@ -138,9 +161,7 @@ class WidgetPreviewDtdServices {
138161 Uri ? get dtdUri => _dtdUri;
139162 Uri ? _dtdUri;
140163
141- /// Returns true if the LSP service is registered with the connected DTD instance.
142- bool get lspServiceAvailable => _lspServiceAvailable;
143- bool _lspServiceAvailable = false ;
164+ bool _allLspServicesRegistered = false ;
144165
145166 /// Starts DTD in a child process before invoking [connect] with a [Uri] pointing to the new
146167 /// DTD instance.
@@ -158,99 +179,99 @@ class WidgetPreviewDtdServices {
158179 _dtdUri = dtdWsUri;
159180 _dtd = await DartToolingDaemon .connect (dtdWsUri);
160181
161- _lspServiceAvailable = false ;
182+ _allLspServicesRegistered = false ;
162183 final RegisteredServicesResponse registeredServices = await _dtd! .getRegisteredServices ();
163- _lspServiceAvailable =
164- registeredServices.dtdServices.contains (kLspStream) ||
165- registeredServices.clientServices.any ((service) => service.name == kLspStream);
184+ _allLspServicesRegistered = _areRequiredLspServicesRegistered (registeredServices);
166185
167186 await _registerServices ();
168187 logger.printTrace ('Connected to DTD and registered services.' );
169188 }
170189
171190 Future <FlutterWidgetPreviews > getFlutterWidgetPreviews () async {
172- await _waitForLspService ();
173- const maxAttempts = 50 ;
174- for (var attempts = 0 ; attempts < maxAttempts; attempts++ ) {
175- try {
176- final DTDResponse result = await _dtd! .call (
177- 'Lsp' ,
178- 'dart/workspace/getFlutterWidgetPreviews' ,
179- );
180- return FlutterWidgetPreviews .fromJson (result.result['result' ]! as Map <String , Object ?>);
181- } on RpcException catch (e) {
182- if (e.code == - 32601 && attempts < maxAttempts - 1 ) {
183- // Method not found
184- await Future <void >.delayed (const Duration (milliseconds: 200 ));
185- continue ;
186- }
187- rethrow ;
188- }
189- }
190- throw StateError ('Failed to call getFlutterWidgetPreviews after $maxAttempts attempts.' );
191+ final DTDResponse result = await _callLspService (kGetFlutterWidgetPreviewsMethod);
192+ return FlutterWidgetPreviews .fromJson (result.result['result' ]! as Map <String , Object ?>);
191193 }
192194
193195 Future <FlutterWidgetPreviews > getFlutterWidgetPreviewsForFile ({required String filePath}) async {
196+ final DTDResponse result = await _callLspService (
197+ kGetFlutterWidgetPreviewsForFileMethod,
198+ params: < String , Object ? > {'uri' : Uri .file (filePath).toString ()},
199+ );
200+ return FlutterWidgetPreviews .fromJson (result.result['result' ]! as Map <String , Object ?>);
201+ }
202+
203+ /// Returns a [Future] that completes when the analysis server connected to DTD
204+ /// has completed any in-progress initialization or analysis.
205+ ///
206+ /// This method will wait for [delay] before calling the server. If not
207+ /// provided, defaults to 100ms.
208+ Future <void > waitForAnalysis ({Duration delay = const Duration (milliseconds: 100 )}) async {
194209 await _waitForLspService ();
195- const maxAttempts = 50 ;
196- for (var attempts = 0 ; attempts < maxAttempts; attempts++ ) {
197- try {
198- final DTDResponse result = await _dtd! .call (
199- 'Lsp' ,
200- 'dart/textDocument/getFlutterWidgetPreviews' ,
201- params: {'uri' : Uri .file (filePath).toString ()},
202- );
203- return FlutterWidgetPreviews .fromJson (result.result['result' ]! as Map <String , Object ?>);
204- } on RpcException catch (e) {
205- if (e.code == - 32601 && attempts < maxAttempts - 1 ) {
206- // Method not found
207- await Future <void >.delayed (const Duration (milliseconds: 200 ));
208- continue ;
209- }
210- rethrow ;
211- }
212- }
213- throw StateError ('Failed to call getFlutterWidgetPreviewsForFile after $maxAttempts attempts.' );
210+ await Future <void >.delayed (delay);
211+ await _callLspService (kWorkspaceAnalysisCompleteMethod);
214212 }
215213
214+ Future <DTDResponse > _callLspService (String methodName, {Map <String , Object ?>? params}) async {
215+ await _waitForLspService ();
216+ return _dtd! .call (kLspStream, methodName, params: params);
217+ }
218+
219+ Future <void >? _waitForLspServiceFuture;
220+
216221 Future <void > _waitForLspService () async {
217- if (_lspServiceAvailable ) {
222+ if (_allLspServicesRegistered ) {
218223 return ;
219224 }
225+ final Future <void >? future = _waitForLspServiceFuture;
226+ if (future != null ) {
227+ return future;
228+ }
229+ _waitForLspServiceFuture = _waitForLspServiceHelper ();
230+ try {
231+ await _waitForLspServiceFuture;
232+ } finally {
233+ _waitForLspServiceFuture = null ;
234+ }
235+ }
236+
237+ bool _areRequiredLspServicesRegistered (RegisteredServicesResponse registeredServices) {
238+ return registeredServices.clientServices.any (
239+ (service) =>
240+ service.name == kLspStream && kRequiredLspServices.every (service.methods.containsKey),
241+ );
242+ }
220243
221- final lspRegisteredCompleter = Completer <void >();
244+ Future <void > _waitForLspServiceHelper () async {
245+ final lspInitializedCompleter = Completer <void >();
222246
223- const kServiceStream = 'Service' ;
224- await _dtd! .streamListen (kServiceStream);
225- final StreamSubscription <DTDEvent > serviceSubscription = _dtd! .onEvent (kServiceStream).listen ((
247+ final StreamSubscription <DTDEvent > lspSubscription = _dtd! .onEvent (kLspStream).listen ((
226248 DTDEvent event,
227249 ) {
228- if (lspRegisteredCompleter .isCompleted) {
250+ if (lspInitializedCompleter .isCompleted) {
229251 return ;
230252 }
231- if (event case DTDEvent ( kind: 'ServiceRegistered' , data : { 'service' : kLspStream}) ) {
232- _lspServiceAvailable = true ;
233- lspRegisteredCompleter .complete ();
253+ if (event. kind == kLspInitializedEvent ) {
254+ _allLspServicesRegistered = true ;
255+ lspInitializedCompleter .complete ();
234256 }
235257 });
236-
237258 try {
259+ await _dtd! .safeStreamListen (kLspStream);
238260 final RegisteredServicesResponse registeredServices = await _dtd! .getRegisteredServices ();
239- final bool alreadyRegistered =
240- registeredServices.dtdServices.contains (kLspStream) ||
241- registeredServices.clientServices.any ((service) => service.name == kLspStream);
242- if (alreadyRegistered) {
243- _lspServiceAvailable = true ;
244- lspRegisteredCompleter.complete ();
261+ if (_areRequiredLspServicesRegistered (registeredServices)) {
262+ _allLspServicesRegistered = true ;
263+ if (! lspInitializedCompleter.isCompleted) {
264+ lspInitializedCompleter.complete ();
265+ }
245266 } else {
246267 logger.printStatus ('Waiting for analysis server to register Lsp service with DTD...' );
247- await lspRegisteredCompleter .future.timeout (const Duration (seconds: 30 ));
268+ await lspInitializedCompleter .future.timeout (const Duration (seconds: 30 ));
248269 }
249270 } on TimeoutException {
250271 logger.printWarning ('Timed out waiting for the Lsp service to be registered with DTD.' );
251272 rethrow ;
252273 } finally {
253- await serviceSubscription .cancel ();
274+ await lspSubscription .cancel ();
254275 }
255276 }
256277
@@ -287,7 +308,7 @@ class WidgetPreviewDtdServices {
287308 }
288309 });
289310 await Future .wait (< Future <void >> [
290- dtd.streamListen (widgetPreviewScaffoldStream),
311+ dtd.safeStreamListen (widgetPreviewScaffoldStream),
291312 for (final (String method, DTDServiceCallback callback) in services)
292313 dtd
293314 .registerService (widgetPreviewService, method, callback)
@@ -379,3 +400,16 @@ class DtdLauncher {
379400
380401 Process ? _dtdProcess;
381402}
403+
404+ extension on DartToolingDaemon {
405+ /// A [streamListen] implementation that ignores already subscribed exceptions.
406+ Future <void > safeStreamListen (String streamId) async {
407+ try {
408+ await streamListen (streamId);
409+ } on RpcException catch (e) {
410+ if (e.code != RpcErrorCodes .kStreamAlreadySubscribed) {
411+ rethrow ;
412+ }
413+ }
414+ }
415+ }
0 commit comments