static Future create()

in dwds/lib/src/dwds_vm_client.dart [44:143]
86 lines of code
5 McCabe index (conditional complexity)

  static Future<DwdsVmClient> create(
      DebugService debugService, DwdsStats dwdsStats) async {
    // Set up hot restart as an extension.
    var requestController = StreamController<Map<String, Object>>();
    var responseController = StreamController<Map<String, Object>>();
    VmServerConnection(requestController.stream, responseController.sink,
        debugService.serviceExtensionRegistry, debugService.chromeProxyService);
    var client =
        VmService(responseController.stream.map(jsonEncode), (request) {
      if (requestController.isClosed) {
        _logger.warning(
            'Attempted to send a request but the connection is closed:\n\n'
            '$request');
        return;
      }
      requestController.sink.add(jsonDecode(request) as Map<String, dynamic>);
    });
    var chromeProxyService =
        debugService.chromeProxyService as ChromeProxyService;

    // Register '_flutter.listViews' method on the chrome proxy service vm.
    // In native world, this method is provided by the engine, but the web
    // engine is not aware of the VM uri or the isolates.
    //
    // Issue: https://github.com/dart-lang/webdev/issues/1315
    client.registerServiceCallback('_flutter.listViews', (request) async {
      final vm = await chromeProxyService.getVM();
      final isolates = vm.isolates;
      return <String, dynamic>{
        'result': <String, Object>{
          'views': <Object>[
            for (var isolate in isolates)
              <String, Object>{
                'id': isolate.id,
                'isolate': isolate.toJson(),
              }
          ],
        }
      };
    });
    await client.registerService('_flutter.listViews', 'DWDS');

    client.registerServiceCallback(
        'hotRestart',
        (request) => captureElapsedTime(
            () => _hotRestart(chromeProxyService, client),
            (_) => DwdsEvent.hotRestart()));
    await client.registerService('hotRestart', 'DWDS');

    client.registerServiceCallback(
        'fullReload',
        (request) => captureElapsedTime(() => _fullReload(chromeProxyService),
            (_) => DwdsEvent.fullReload()));
    await client.registerService('fullReload', 'DWDS');

    client.registerServiceCallback('ext.dwds.screenshot', (_) async {
      await chromeProxyService.remoteDebugger.enablePage();
      var response = await chromeProxyService.remoteDebugger
          .sendCommand('Page.captureScreenshot');
      return {'result': response.result};
    });
    await client.registerService('ext.dwds.screenshot', 'DWDS');

    client.registerServiceCallback('ext.dwds.sendEvent', (event) async {
      _processSendEvent(event, chromeProxyService, dwdsStats);
      return {'result': Success().toJson()};
    });
    await client.registerService('ext.dwds.sendEvent', 'DWDS');

    client.registerServiceCallback('ext.dwds.emitEvent', (event) async {
      emitEvent(DwdsEvent(
          event['type'] as String, event['payload'] as Map<String, dynamic>));
      return {'result': Success().toJson()};
    });
    await client.registerService('ext.dwds.emitEvent', 'DWDS');

    client.registerServiceCallback('_yieldControlToDDS', (request) async {
      final ddsUri = request['uri'] as String;
      if (ddsUri == null) {
        return RPCError(
          request['method'] as String,
          RPCError.kInvalidParams,
          "'Missing parameter: 'uri'",
        ).toMap();
      }
      return DebugService.yieldControlToDDS(ddsUri)
          ? {'result': Success().toJson()}
          : {
              'error': {
                'code': kFeatureDisabled,
                'message': kFeatureDisabledMessage,
                'details':
                    'Existing VM service clients prevent DDS from taking control.',
              },
            };
    });
    await client.registerService('_yieldControlToDDS', 'DWDS');

    return DwdsVmClient(client, requestController, responseController);
  }