Timer 颤振倒计时_Timer_Dart_Flutter_Countdown

Timer 颤振倒计时

timer dart flutter

Timer 颤振倒计时,timer,dart,flutter,countdown,Timer,Dart,Flutter,Countdown,如何将传递的值放入构造中，使计时器四舍五入到第一个小数点，并显示在我的RaisedButton的子文本中？我试过了，但运气不好。我设法用一个简单的计时器使回调函数工作，但没有周期性，也没有在文本中实时更新值 import 'package:flutter/material.dart'; import 'dart:ui'; import 'dart:async'; class TimerButton extends StatefulWidget { final Duration timerT

如何将传递的值放入构造中，使计时器四舍五入到第一个小数点，并显示在我的RaisedButton的子文本中？我试过了，但运气不好。我设法用一个简单的计时器使回调函数工作，但没有周期性，也没有在文本中实时更新值

import 'package:flutter/material.dart';
import 'dart:ui';
import 'dart:async';

class TimerButton extends StatefulWidget {
  final Duration timerTastoPremuto;


  TimerButton(this.timerTastoPremuto);

  @override
  _TimerButtonState createState() => _TimerButtonState();
}

class _TimerButtonState extends State<TimerButton> {
  @override
  Widget build(BuildContext context) {
    return Container(
      margin: EdgeInsets.all(5.0),
      height: 135.0,
      width: 135.0,
      child: new RaisedButton(
        elevation: 100.0,
        color: Colors.white.withOpacity(.8),
        highlightElevation: 0.0,
        onPressed: () {
          int _start = widget.timerTastoPremuto.inMilliseconds;

          const oneDecimal = const Duration(milliseconds: 100);
          Timer _timer = new Timer.periodic(
              oneDecimal,
                  (Timer timer) =>
                  setState(() {
                    if (_start < 100) {
                      _timer.cancel();
                    } else {
                      _start = _start - 100;
                    }
                  }));

        },
        splashColor: Colors.red,
        highlightColor: Colors.red,
        //shape: RoundedRectangleBorder e tutto il resto uguale
        shape: BeveledRectangleBorder(
            side: BorderSide(color: Colors.black, width: 2.5),
            borderRadius: new BorderRadius.circular(15.0)),
        child: new Text(
          "$_start",
          style: new TextStyle(fontFamily: "Minim", fontSize: 50.0),
        ),
      ),
    );
  }
}

导入“包装：颤振/材料.省道”；
导入“dart:ui”；
导入“dart:async”；
类TimerButton扩展StatefulWidget{
最终持续时间tStopRemuto；
TimerButton（this.timertastoremuto）；
@凌驾
_TimerButtonState createState（）；
}
类_TimerButtonState扩展状态{
@凌驾
小部件构建（构建上下文）{
返回容器(
边距：所有边缘集（5.0），
身高：135.0，
宽度：135.0，
孩子：新升起的按钮(
标高：100.0，
颜色：颜色。白色。不透明度（.8），
远光灯高度：0.0，
已按下：（）{
int _start=widget.timerTastoPremuto.in毫秒；
const oneDecimal=const持续时间（毫秒：100）；
定时器_Timer=新定时器。周期性(
一位小数，
（计时器）=>
设置状态（）{
如果（_开始<100）{
_timer.cancel（）；
}否则{
_开始=_开始-100；
}
}));
},
颜色：颜色。红色，
highlightColor:Colors.red，
//形状：圆形直角边框，图为乌戈尔餐厅
形状：斜面矩形边框(
侧边：边框侧边（颜色：Colors.black，宽度：2.5），
borderRadius:新的borderRadius.圆形（15.0）），
儿童：新文本(
“$\u开始”，
样式：新的文本样式（fontFamily:“Minim”，fontSize:50.0），
),
),
);
}
}

以下是一个示例：

倒计时从按钮点击时的

到

开始：

import 'dart:async';

[...]

Timer _timer;
int _start = 10;

void startTimer() {
  const oneSec = const Duration(seconds: 1);
  _timer = new Timer.periodic(
    oneSec,
    (Timer timer) {
      if (_start == 0) {
        setState(() {
          timer.cancel();
        });
      } else {
        setState(() {
          _start--;
        });
      }
    },
  );
}

@override
void dispose() {
  _timer.cancel();
  super.dispose();
}

Widget build(BuildContext context) {
  return new Scaffold(
    appBar: AppBar(title: Text("Timer test")),
    body: Column(
      children: <Widget>[
        RaisedButton(
          onPressed: () {
            startTimer();
          },
          child: Text("start"),
        ),
        Text("$_start")
      ],
    ),
  );
}

如果要在每次单击时重新启动计时器，请取消计时器并重置倒计时：

if（_timer！=null）{
_timer.cancel（）；
_开始=10；
}
_计时器=新计时器。周期性（…）；

如果您希望该按钮像播放/暂停按钮一样工作：

if（_timer！=null）{
_timer.cancel（）；
_定时器=空；
}否则{
_计时器=新计时器。周期性（…）；
}

您还可以使用这个官方软件包，它提供了一个从

Timer

扩展而来的类，并添加了

reset

方法

所以只需调用

\u timer.reset（）在每个按钮上单击
最后，代码笔现在支持Flutter！所以这里有一个活生生的例子，每个人都可以使用它：
我创建了一个通用的计时器小部件，它可以用来显示任何类型的计时器及其灵活性
此小部件具有以下属性
secondsRemaining：计时器需要以秒为单位运行的持续时间
当超时时：如果计时器完成，需要执行什么操作
倒计时方式：你想给计时器的任何一种方式
倒计时格式化程序：用户希望显示倒计时计时器的方式，例如
hh-mm-ss
string-like01小时：20分钟：45秒
您可以提供默认格式设置程序（formatHHMMSS
），以防您不想从任何地方提供它
//提供此格式HHMMSS（duration.unseconds）的实现或使用下面我提供的代码
import 'package:flutter/material.dart';
class CountDownTimer extends StatefulWidget {
  const CountDownTimer({
    Key key,
    int secondsRemaining,
    this.countDownTimerStyle,
    this.whenTimeExpires,
    this.countDownFormatter,
  })  : secondsRemaining = secondsRemaining,
        super(key: key);

  final int secondsRemaining;
  final Function whenTimeExpires;
  final Function countDownFormatter;
  final TextStyle countDownTimerStyle;

  State createState() => new _CountDownTimerState();
}

class _CountDownTimerState extends State<CountDownTimer>
    with TickerProviderStateMixin {
  AnimationController _controller;
  Duration duration;

  String get timerDisplayString {
    Duration duration = _controller.duration * _controller.value;
    return widget.countDownFormatter != null
        ? widget.countDownFormatter(duration.inSeconds)
        : formatHHMMSS(duration.inSeconds);
      // In case user doesn't provide formatter use the default one
     // for that create a method which will be called formatHHMMSS or whatever you like
  }

  @override
  void initState() {
    super.initState();
    duration = new Duration(seconds: widget.secondsRemaining);
    _controller = new AnimationController(
      vsync: this,
      duration: duration,
    );
    _controller.reverse(from: widget.secondsRemaining.toDouble());
    _controller.addStatusListener((status) {
      if (status == AnimationStatus.completed || status == AnimationStatus.dismissed) {
        widget.whenTimeExpires();
      }
    });
  }

  @override
  void didUpdateWidget(CountDownTimer oldWidget) {
    if (widget.secondsRemaining != oldWidget.secondsRemaining) {
      setState(() {
        duration = new Duration(seconds: widget.secondsRemaining);
        _controller.dispose();
        _controller = new AnimationController(
          vsync: this,
          duration: duration,
        );
        _controller.reverse(from: widget.secondsRemaining.toDouble());
        _controller.addStatusListener((status) {
          if (status == AnimationStatus.completed) {
            widget.whenTimeExpires();
          } else if (status == AnimationStatus.dismissed) {
            print("Animation Complete");
          }
        });
      });
    }
  }

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return new Center(
        child: AnimatedBuilder(
            animation: _controller,
            builder: (_, Widget child) {
              return Text(
                timerDisplayString,
                style: widget.countDownTimerStyle,
              );
            }));
  }
}

格式hhmms的示例：
String formatHHMMSS(int seconds) {
  int hours = (seconds / 3600).truncate();
  seconds = (seconds % 3600).truncate();
  int minutes = (seconds / 60).truncate();

  String hoursStr = (hours).toString().padLeft(2, '0');
  String minutesStr = (minutes).toString().padLeft(2, '0');
  String secondsStr = (seconds % 60).toString().padLeft(2, '0');

  if (hours == 0) {
    return "$minutesStr:$secondsStr";
  }

  return "$hoursStr:$minutesStr:$secondsStr";
}

一行倒计时计时器
CountdownTimer(Duration(seconds: 5), Duration(seconds: 1)).listen((data){
})..onData((data){
  print('data $data');
})..onDone((){
  print('onDone.........');
});

不要直接回答你的问题。但对于那些想在一段时间后开始做某事的人来说是有帮助的
Future.delayed(Duration(seconds: 1), () {
            print('yo hey');
          });

如果您只需要一个简单的倒计时计时器，那么这是一个替代安装软件包的好方法。快乐编码
countDownTimer() async {
 int timerCount;
 for (int x = 5; x > 0; x--) {
   await Future.delayed(Duration(seconds: 1)).then((_) {
     setState(() {
       timerCount -= 1;
    });
  });
 }
}

这是我的计时器小部件，与问题无关，但可能会帮助某些人
import 'dart:async';

import 'package:flutter/material.dart';

class OtpTimer extends StatefulWidget {
  @override
  _OtpTimerState createState() => _OtpTimerState();
}

class _OtpTimerState extends State<OtpTimer> {
  final interval = const Duration(seconds: 1);

  final int timerMaxSeconds = 60;

  int currentSeconds = 0;

  String get timerText =>
      '${((timerMaxSeconds - currentSeconds) ~/ 60).toString().padLeft(2, '0')}: ${((timerMaxSeconds - currentSeconds) % 60).toString().padLeft(2, '0')}';

  startTimeout([int milliseconds]) {
    var duration = interval;
    Timer.periodic(duration, (timer) {
      setState(() {
        print(timer.tick);
        currentSeconds = timer.tick;
        if (timer.tick >= timerMaxSeconds) timer.cancel();
      });
    });
  }

  @override
  void initState() {
    startTimeout();
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return Row(
      mainAxisSize: MainAxisSize.min,
      children: <Widget>[
        Icon(Icons.timer),
        SizedBox(
          width: 5,
        ),
        Text(timerText)
      ],
    );
  }
}

导入'dart:async'；
进口“包装：颤振/材料.省道”；
类OtpTimer扩展StatefulWidget{
@凌驾
_OtpTimerState createState（）=>\u OtpTimerState（）；
}
类_otoptimerState扩展状态{
最终间隔=持续时间（秒：1）；
最终int timerMaxSeconds=60；
int currentSeconds=0；
字符串get timerText=>
“${（（timerMaxSeconds-currentSeconds）~/60.toString（）.padLeft（2，'0'）}:${（（timerMaxSeconds-currentSeconds）%60.toString（）.padLeft（2，'0'）}”；
startTimeout（[int毫秒]）{
var持续时间=间隔；
定时器。周期（持续时间，（定时器）{
设置状态（）{
打印（计时器勾选）；
currentSeconds=timer.tick；
如果（timer.tick>=timerMaxSeconds）timer.cancel（）；
});
});
}
@凌驾
void initState（）{
startTimeout（）；
super.initState（）；
}
@凌驾
小部件构建（构建上下文）{
返回行(
mainAxisSize:mainAxisSize.min，
儿童：[
图标（图标。计时器），
大小盒子(
宽度：5，
),
文本（timerText）
],
);
}
}

你会得到这样的结果
我正在使用
依赖项：
颤振计时器：^1.0.0
$flatter酒吧
CountdownTimer(endTime: 1594829147719)

1594829147719是你的时间戳（以毫秒为单位）
派对有点晚了，但你们为什么不试试动画。不，我不是在告诉你们管理动画控制器，并将它们处理掉等等。有一个内置的小部件用于调用它。你可以在任何类型的值之间设置动画，下面是一个带有Duration类的示例
TweenAnimationBuilder<Duration>(
              duration: Duration(minutes: 3),
              tween: Tween(begin: Duration(minutes: 3), end: Duration.zero),
              onEnd: () {
                print('Timer ended');
              },
              builder: (BuildContext context, Duration value, Widget child) {
              final minutes = value.inMinutes;
              final seconds = value.inSeconds % 60;
              return Padding(
                     padding: const EdgeInsets.symmetric(vertical: 5),
                     child: Text('$minutes:$seconds',
                            textAlign: TextAlign.center,
                            style: TextStyle(
                            color: Colors.black,
                            fontWeight: FontWeight.bold,
                            fontSize: 30)));
              }),

TweenAnimationBuilder(
持续时间：持续时间（分钟数：3），
吐温：吐温（开始：持续时间（分钟数：3），结束：持续时间。零），
ONED:（）{
打印（“计时器结束”）；
},
生成器：（BuildContext上下文、持续时间值、小部件子项）{
最终分钟数=value.in分钟；
CountdownTimer(endTime: 1594829147719)

TweenAnimationBuilder<Duration>(
              duration: Duration(minutes: 3),
              tween: Tween(begin: Duration(minutes: 3), end: Duration.zero),
              onEnd: () {
                print('Timer ended');
              },
              builder: (BuildContext context, Duration value, Widget child) {
              final minutes = value.inMinutes;
              final seconds = value.inSeconds % 60;
              return Padding(
                     padding: const EdgeInsets.symmetric(vertical: 5),
                     child: Text('$minutes:$seconds',
                            textAlign: TextAlign.center,
                            style: TextStyle(
                            color: Colors.black,
                            fontWeight: FontWeight.bold,
                            fontSize: 30)));
              }),

import 'package:timer_builder/timer_builder.dart';

class ClockWidget extends StatelessWidget {

  @override
  Widget build(BuildContext context) {
    return TimerBuilder.periodic(Duration(seconds: 1),
      builder: (context) {
        return Text("${DateTime.now()}");
      }
    );
  }
  
}

import 'package:timer_builder/timer_builder.dart';

class StatusIndicator extends StatelessWidget {

  final DateTime startTime;
  final DateTime endTime;
  
  StatusIndicator(this.startTime, this.endTime);
  
  @override
  Widget build(BuildContext context) {
    return TimerBuilder.scheduled([startTime, endTime],
      builder: (context) {
        final now = DateTime.now();
        final started = now.compareTo(startTime) >= 0;
        final ended = now.compareTo(endTime) >= 0;
        return Text(started ? ended ? "Ended": "Started": "Not Started");
      }
    );
  }
  
}

dependencies:
  custom_timer: ^0.0.3 

@override
  Widget build(BuildContext context) {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      home: Scaffold(
        appBar: AppBar(
          title: Text("CustomTimer example"),
        ),
        body: Center(
          child: CustomTimer(
            from: Duration(hours: 12),
            to: Duration(hours: 0),
            onBuildAction: CustomTimerAction.auto_start,
            builder: (CustomTimerRemainingTime remaining) {
              return Text(
                "${remaining.hours}:${remaining.minutes}:${remaining.seconds}",
                style: TextStyle(fontSize: 30.0),
              );
            },
          ),
        ),
      ),
    );
  }

import 'dart:async';
import 'package:flutter/material.dart';

class CustomTimer extends StatefulWidget {
  @override
  _CustomTimerState createState() => _CustomTimerState();
}

class _CustomTimerState extends State<CustomTimer> {
  final _maxSeconds = 61;
  int _currentSecond = 0;
  Timer _timer;

  String get _timerText {
    final secondsPerMinute = 60;
    final secondsLeft = _maxSeconds - _currentSecond;

    final formattedMinutesLeft =
        (secondsLeft ~/ secondsPerMinute).toString().padLeft(2, '0');
    final formattedSecondsLeft =
        (secondsLeft % secondsPerMinute).toString().padLeft(2, '0');

    print('$formattedMinutesLeft : $formattedSecondsLeft');
    return '$formattedMinutesLeft : $formattedSecondsLeft';
  }

  @override
  void initState() {
    super.initState();
    _startTimer();
  }

  @override
  void dispose() {
    _timer.cancel();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Center(
        child: Row(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Icon(Icons.timer),
            Text(_timerText),
          ],
        ),
      ),
    );
  }

  void _startTimer() {
    final duration = Duration(seconds: 1);
    _timer = Timer.periodic(duration, (Timer timer) {
      setState(() {
        _currentSecond = timer.tick;
        if (timer.tick >= _maxSeconds) timer.cancel();
      });
    });
  }
}