streamBytes method

Implementation

Future<ByteStreamWriter> streamBytes(StreamBytesOptions? options) async {
  final streamId = options?.streamId ?? Uuid().v4();
  final timestamp = DateTime.timestamp().millisecondsSinceEpoch;

  final info = ByteStreamInfo(
    name: options?.name ?? 'unknown',
    id: streamId,
    mimeType: options?.mimeType ?? 'application/octet-stream',
    timestamp: timestamp,
    topic: options?.topic ?? '',
    size: options?.totalSize ?? 0,
    attributes: options?.attributes ?? {},
    sendingParticipantIdentity: identity,
  );

  final header = lk_models.DataStream_Header(
    totalLength: Int64(info.size),
    mimeType: info.mimeType,
    streamId: streamId,
    topic: options?.topic,
    encryptionType: options?.encryptionType,
    timestamp: Int64(timestamp),
    byteHeader: lk_models.DataStream_ByteHeader(
      name: info.name,
    ),
    attributes: options?.attributes.entries,
  );

  final destinationIdentities = options?.destinationIdentities;
  final packet = lk_models.DataPacket(
    kind: lk_models.DataPacket_Kind.RELIABLE,
    destinationIdentities: destinationIdentities,
    streamHeader: header,
  );

  await room.engine.sendDataPacket(packet, reliability: Reliability.reliable);

  final writableStream = WritableStream<Uint8List>(
    destinationIdentities: destinationIdentities,
    streamId: streamId,
    engine: room.engine,
  );

  onEngineClose() async {
    await writableStream.close();
  }

  final cancelFun = room.engine.events.once<EngineClosingEvent>((_) => onEngineClose);

  final byteWriter = ByteStreamWriter(
    writableStream: writableStream,
    info: info,
    onClose: cancelFun,
  );

  return byteWriter;
}