connect static method

Future<ConnectClient> connect()

Implementation

static Future<ConnectClient> connect() async {
  final service = serviceManager.service;
  if (service == null) throw 'VM service not found';

  final vm = await service.getVM();
  final isolateId = vm.isolates
      ?.where((e) => e.name?.contains('main') ?? false)
      .first
      .id;

  if (isolateId == null) throw 'Main isolate not found';

  try {
    await service.streamListen(EventStreams.kExtension);
  } catch (_) {
    // Throws if the stream is already listened to
  }

  final dtd = dtdManager.connection.value;
  if (dtd == null) throw 'DTD not found';

  final rootsResponse = await dtdManager.projectRoots();
  if (rootsResponse == null) throw 'Workspace roots not found';

  final uris = <Uri>[];
  for (final root in rootsResponse.uris ?? <Uri>[]) {
    final contents = await dtd
        .listDirectoryContentsRecursive(root.resolve('lib'))
        .toList();
    uris.addAll(contents);
  }

  final appPackageRoot = await serviceManager.connectedAppPackageRoot(
    dtdManager,
  );
  if (appPackageRoot == null) throw 'App package root not found';

  final RiftSchemasUris = uris
      .where((e) => e.path.endsWith('rift_adapters.g.yaml'))
      .toList();

  final appSchemas = <RiftSchema>[];
  final otherSchemas = <RiftSchema>[];
  for (final uri in RiftSchemasUris) {
    final contentResponse = await dtd.readFileAsString(uri);
    final content = contentResponse.content;
    if (content == null) continue;

    final schema = RiftSchema.fromJson(
      jsonDecode(jsonEncode(loadYaml(content))),
    );
    if (uri.path.startsWith(appPackageRoot.path)) {
      appSchemas.add(schema);
    } else {
      otherSchemas.add(schema);
    }
  }

  final types = {
    ...baseSchema,
    for (final schema in otherSchemas) ...schema.types,
    // Schemas for the currently running app take precedence
    for (final schema in appSchemas) ...schema.types,
  };

  final client = ConnectClient(service, isolateId, types);
  final handlers = <String, Function(Map<String, dynamic>)>{
    ConnectEvent.boxRegistered.event: (Map<String, dynamic> json) {
      client._boxRegisteredController.add(json['name']);
    },
    ConnectEvent.boxUnregistered.event: (Map<String, dynamic> json) {
      client._boxUnregisteredController.add(json['name']);
    },
    ConnectEvent.boxEvent.event: (Map<String, dynamic> json) {
      final payload = BoxEventPayload.fromJson(json);
      client._boxEventController.add(
        payload.copyWith(
          frame: payload.frame.copyWith(
            value: client._readValue(payload.frame.value),
          ),
        ),
      );
    },
  };
  service.onExtensionEvent.listen((event) {
    final data = event.extensionData?.data ?? {};
    handlers[event.extensionKind]?.call(data);
  });

  return client;
}