`FxSubscriptions`

함께 취소되는 구독 자루 — 스트림마다 필드 하나가 아니라 정리는 호출 한 번.

class FxSubscriptions { int get length; bool get isEmpty; bool get isNotEmpty; StreamSubscription<T> add<T>(StreamSubscription<T> subscription); void addAll(Iterable<StreamSubscription<void>> subscriptions); Future<void> cancelAll(); // cancel every one, and empty the bag void pauseAll(); void resumeAll(); }

강의

여러 스트림을 듣는 객체는 오직 한 가지 이유로 모든 구독을 살려 둡니다: 나중에 다시 취소하려고요. 그 결과가 익숙한 널 가능 필드 더미입니다. 각각 맨 위에 선언되고, 각각 initState에서 할당되고, 각각 dispose에서 취소되고 — 그리고 누수는 언제나 누군가 세 번째 목록에 추가하기를 잊은 그 하나입니다.

FxSubscriptions는 그것을 객체 하나로 접습니다. add는 구독을 자루에 넣고 그것을 돌려주므로 문장이 아니라 식으로 읽히고, cancelAll()이 그 전부를 끝냅니다. 정리는 한 줄이 됩니다: Future<void> dispose() => subs.cancelAll();

pauseAll()과 resumeAll()은 더 부드러운 버전으로, 배선을 해체하지 않은 채 일만 멈춰야 할 때를 위한 것입니다 — 화면이 백그라운드로 가거나 탭이 포커스를 잃을 때요. 일시정지된 구독은 버리지 않고 버퍼에 담으므로 그 틈에서 잃는 것이 없습니다.

자루는 취소를 기다리기 전에 비워지므로, 기다리는 동안 두 번째 cancelAll()이 무언가를 두 번 취소할 수 없고, 같은 객체가 그 뒤로 새 세대의 구독을 담을 수 있습니다. fxdart 이벤트 레이어, Rx의 CompositeSubscription을 따랐습니다.

stopOn과 자연스럽게 짝을 이룹니다: stopOn은 무언가가 일어나서 체인이 끝나야 할 때, FxSubscriptions는 그것들을 소유하던 것이 사라져서 여러 체인이 끝나야 할 때 쓰세요.

데모 1 · dispose 한 줄

import 'dart:async';

import 'package:fxdart/fxdart.dart';

/// Emits each (offsetMs, value) pair at its offset, closing at [closeMs].
Stream<T> timed<T>(List<(int, T)> events, int closeMs) {
  final c = StreamController<T>();
  for (final (ms, v) in events) {
    Timer(Duration(milliseconds: ms), () => c.add(v));
  }
  Timer(Duration(milliseconds: closeMs), c.close);
  return c.stream;
}

Future<void> main() async {
  // A screen listening to three feeds at once.
  final ticks = StreamController<int>();
  final clicks = StreamController<String>();

final subs = FxSubscriptions();
  subs
    ..add(fxEvents(ticks.stream).map((v) => v * 2).listen((v) => print('tick $v')))
    ..add(fxEvents(clicks.stream).listen((v) => print('click $v')));

print('holding ${subs.length} subscriptions');

ticks.add(1);
  clicks.add('home');
  await Future<void>.delayed(Duration.zero);

// One call ends them all — the dispose() one-liner.
  await subs.cancelAll();
  print('after cancelAll: isEmpty = ${subs.isEmpty}');

ticks.add(2);
  clicks.add('cart');
  await Future<void>.delayed(Duration.zero); // nothing prints

await ticks.close();
  await clicks.close();
}

데모 2 · 해체하지 않고 멈추기

import 'dart:async';

import 'package:fxdart/fxdart.dart';

Future<void> main() async {
  final a = StreamController<int>();
  final b = StreamController<int>();
  final seen = <int>[];

final subs = FxSubscriptions();
  subs
    ..add(a.stream.listen(seen.add))
    ..add(b.stream.listen(seen.add));

// Backgrounded: hold everything without tearing it down.
  subs.pauseAll();
  a.add(1);
  b.add(2);
  await Future<void>.delayed(Duration.zero);
  print(seen); // [] — buffered, not lost

// Foregrounded again.
  subs.resumeAll();
  await Future<void>.delayed(Duration.zero);
  print(seen); // [1, 2]

await subs.cancelAll();
  await a.close();
  await b.close();
}

직접 해 보기

연습: addAll, 그리고 취소 후 자루 재사용.

import 'dart:async';

import 'package:fxdart/fxdart.dart';

Future<void> main() async {
  // Exercise: the bag is reusable. cancelAll empties it, so the same
  // object can hold a fresh generation of subscriptions afterwards.
  final feed = StreamController<int>.broadcast();
  final subs = FxSubscriptions();

// add returns what it was handed, so it reads as an expression.
  final first = subs.add(feed.stream.listen((v) => print('gen 1: $v')));
  print('same subscription back: ${identical(first, first)}');

feed.add(1);
  await Future<void>.delayed(Duration.zero);

await subs.cancelAll();

// addAll takes a batch — a second generation, after the first is gone.
  subs.addAll([
    feed.stream.listen((v) => print('gen 2a: $v')),
    feed.stream.listen((v) => print('gen 2b: $v')),
  ]);
  print('holding ${subs.length} again');

feed.add(2);
  await Future<void>.delayed(Duration.zero);

await subs.cancelAll();
  await feed.close();
}

관련 항목: stopOn — 소유자의 생명주기가 아니라 이벤트가 조종하는 정리 · fxEvents — 그 listen이 이 자루에 담을 구독을 건네주는 체인 · LiveValue — 자기 close()를 가지며, 이 자루에 담기지 않음