WT 1.1.7+2 SearchBar, Timer for ExerciseControl

lib/bloc/timer/timer_bloc.dart

@@ -0,0 +1,106 @@
+import 'dart:async';
+
+import 'package:audioplayer/audioplayer.dart';
+import 'package:bloc/bloc.dart';
+import 'package:equatable/equatable.dart';
+
+part 'timer_event.dart';
+part 'timer_state.dart';
+
+class Ticker {
+  Stream<int> tick({int ticks}) {
+    return Stream.periodic(Duration(seconds: 1), (x) => compute(ticks, x)).take(ticks);
+  }
+
+  int compute(int ticks, int x) {
+    //print("tcik: " + (ticks - x - 1).toString());
+    return ticks - x - 1;
+  }
+}
+
+class TimerBloc extends Bloc<TimerEvent, TimerState> {
+  final Ticker _ticker = Ticker();
+  int _duration = 0;
+
+  final AudioPlayer audioPlayer = AudioPlayer();
+  int minutes = 0;
+  int seconds = 0;
+
+  StreamSubscription<int> _tickerSubscription;
+
+  TimerBloc() : super(TimerReady(300));
+
+  @override
+  void onTransition(Transition<TimerEvent, TimerState> transition) {
+    super.onTransition(transition);
+    //print(transition);
+  }
+
+  @override
+  Stream<TimerState> mapEventToState(
+    TimerEvent event,
+  ) async* {
+    if (event is TimerStart) {
+      yield* _mapStartToState(event);
+    } else if (event is TimerPause) {
+      yield* _mapPauseToState(event);
+    } else if (event is TimerResume) {
+      yield* _mapResumeToState(event);
+    } else if (event is TimerReset) {
+      yield* _mapResetToState(event);
+    } else if (event is TimerTick) {
+      yield* _mapTickToState(event);
+    } else if (event is TimerEnd) {
+      print("$event");
+      _tickerSubscription?.cancel();
+      yield TimerFinished(state.duration);
+    }
+  }
+
+  @override
+  Future<void> close() {
+    _tickerSubscription?.cancel();
+    return super.close();
+  }
+
+  Stream<TimerState> _mapStartToState(TimerStart start) async* {
+    //print("$start");
+    yield TimerRunning(start.duration);
+    _tickerSubscription?.cancel();
+    _tickerSubscription = _ticker.tick(ticks: start.duration).listen(
+      (localDuration) {
+        //print("local: $localDuration");
+        add(TimerTick(duration: localDuration));
+      },
+    );
+  }
+
+  Stream<TimerState> _mapPauseToState(TimerPause pause) async* {
+    if (state is TimerRunning) {
+      _tickerSubscription?.pause();
+      yield TimerPaused(state.duration);
+    }
+  }
+
+  Stream<TimerState> _mapResumeToState(TimerResume pause) async* {
+    if (state is TimerPaused) {
+      _tickerSubscription?.resume();
+      yield TimerRunning(state.duration);
+    }
+  }
+
+  Stream<TimerState> _mapResetToState(TimerReset reset) async* {
+    this._duration = 0;
+    yield TimerReady(_duration);
+  }
+
+  Stream<TimerState> _mapTickToState(TimerTick tick) async* {
+    //print("tick $tick");
+    yield TickStart(tick.duration);
+    yield tick.duration >= 0 ? TimerRunning(tick.duration) : TimerFinished(tick.duration);
+  }
+
+  Future _play() async {
+    await audioPlayer.play('asset/wine-glass.mp3', isLocal: true);
+  }
+}

lib/bloc/timer/timer_event.dart

@@ -0,0 +1,41 @@
+part of 'timer_bloc.dart';
+
+abstract class TimerEvent extends Equatable {
+  const TimerEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class TimerStart extends TimerEvent {
+  final int duration;
+  const TimerStart({this.duration});
+
+  @override
+  String toString() => "TimerStart { duration: $duration }";
+}
+
+class TimerEnd extends TimerEvent {
+  final int duration;
+  const TimerEnd({this.duration});
+}
+
+class TimerTick extends TimerEvent {
+  final int duration;
+  const TimerTick({this.duration});
+
+  @override
+  String toString() => "Tick { duration: $duration }";
+}
+
+class TimerPause extends TimerEvent {
+  const TimerPause();
+}
+
+class TimerResume extends TimerEvent {
+  const TimerResume();
+}
+
+class TimerReset extends TimerEvent {
+  const TimerReset();
+}

lib/bloc/timer/timer_state.dart

@@ -0,0 +1,49 @@
+part of 'timer_bloc.dart';
+
+abstract class TimerState extends Equatable {
+  final int duration;
+
+  TimerState(this.duration, [List props = const []]);
+
+  @override
+  List<Object> get props => [];
+}
+
+class TickStart extends TimerState {
+  TickStart(int duration) : super(duration);
+  @override
+  String toString() => 'Start { duration: $duration }';
+}
+
+class TimerRunning extends TimerState {
+  TimerRunning(int duration) : super(duration);
+
+  @override
+  String toString() => 'Running { duration: $duration }';
+}
+
+class TimerReady extends TimerState {
+  TimerReady(int duration) : super(duration);
+
+  @override
+  String toString() => 'Ready { duration: $duration }';
+}
+
+class TimerPaused extends TimerState {
+  TimerPaused(int duration) : super(duration);
+
+  @override
+  String toString() => 'Paused { duration: $duration }';
+}
+
+class TimerFinished extends TimerState {
+  TimerFinished(int duration) : super(duration);
+
+  @override
+  String toString() => 'Finished { duration: $duration }';
+}
+
+class TimerError extends TimerState {
+  final String message;
+  TimerError(int duration, {this.message}) : super(duration);
+}