A Dart timer that can be paused, resumed and reset.
import 'package:pausable_timer/pausable_timer.dart';
void main() async {
print('Create a timer that fires in 1 second, but it is not started yet');
final timer = PausableTimer(Duration(seconds: 1), () => print('Fired!'));
print('So we start it');
timer.start();
print('And wait 1/2 second...');
await Future<void>.delayed(timer.duration ~/ 2);
print('Not yet fired, still 1/2 second to go!');
print('We can pause it now');
timer.pause();
// When paused, time can pass but the timer won't be fired
print('And we wait a whole second...');
await Future<void>.delayed(timer.duration);
print("But our timer doesn't care while it's paused");
print('It will still wait for ${timer.duration - timer.elapsed} after '
"it's started again");
print('So we start it again');
timer.start();
print('And wait for 1/2 second again, it should have fired when we are done');
await Future<void>.delayed(timer.duration ~/ 2);
print('And we are done, "Fired!" should be up there π');
print('Now our timer completed ${timer.tick} tick');
print('We can reset it if we want to use it again');
timer.reset();
print('We have to start it again after the reset because it was not running');
timer.start();
print('Now we wait a whole second in one go...');
await Future<void>.delayed(timer.duration);
print('And we are done, so you should see "Fired!" up there again π');
print('Now the timer has ${timer.tick} ticks');
print('We can reset it and start it again');
timer.reset();
timer.start();
print('And you can cancel it too, so it will not fire again');
timer.cancel();
print("After a timer is cancelled, it can't be used again");
print('But important information can still be retrieved:');
print('duration: ${timer.duration}');
print('elapsed: ${timer.elapsed}');
print('tick: ${timer.tick}');
print('isPaused: ${timer.isPaused}');
print('isActive: ${timer.isActive}');
print('isExpired: ${timer.isExpired}');
print('isCancelled: ${timer.isCancelled}');
}
/// Example on how to implement countdown making a PausableTimer periodic.
import 'package:pausable_timer/pausable_timer.dart';
void main() async {
// We need to make it nullable because we have a "circular dependency" between
// the callback and the variable. Since we are using the same variable we are
// initializing, the compiler can't guarantee the callback won't be called
// before the PausableTimer constructor finishes.
PausableTimer? timerInit;
var countDown = 5;
print('Create a periodic timer that fires every 1 second and starts it');
timerInit = PausableTimer(
Duration(seconds: 1),
() {
countDown--;
// If we reached 0, we don't reset and restart the time, so it won't fire
// again, but it can be reused afterwards if needed. If we cancel the
// timer, then it can be reused after the countdown is over.
if (countDown > 0) {
// we know the callback won't be called before the constructor ends, so
// it is safe to use !
timerInit!
..reset()
..start();
}
// This is really what your callback do.
print('\t$countDown');
},
)..start();
// We create a new non-nullable binding for the timer to avoid writing timer!
// everywhere when we *know* it will be non-null.
PausableTimer timer = timerInit;
print('And wait 2.1 seconds...');
print('(0.1 extra to make sure there is no race between the timer and the '
'waiting here)');
await Future<void>.delayed(timer.duration * 2.1);
print('By now 2 events should have fired: 4, 3\n');
print('We can pause it now');
timer.pause();
print('And we wait for 2 more seconds...');
await Future<void>.delayed(timer.duration * 2);
print("But our timer doesn't care while it's paused\n");
print('So we start it again');
timer.start();
print('And wait for 3.1 seconds more...');
await Future<void>.delayed(timer.duration * 3.1);
print('And we are done: 2, 1 and 0 should have been printed');
print('The timer should be unpaused, inactive, expired and not cancelled');
print('isPaused: ${timer.isPaused}');
print('isActive: ${timer.isActive}');
print('isExpired: ${timer.isExpired}');
print('isCancelled: ${timer.isCancelled}');
print('We can now reset it and start it again, now for 3 seconds');
countDown = 3;
timer
..reset()
..start();
print('And wait for 3.1 seconds...');
await Future<void>.delayed(timer.duration * 3.1);
print('And it should be done printing: 2, 1 and 0');
}