Dart 在简历上更新小部件？

在Flatter中，当用户离开应用程序并直接返回应用程序时，是否有方法更新小部件？我的应用程序是基于时间的，尽快更新时间会很有帮助。

您可以通过这样做来收听生命周期事件，例如：

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

class LifecycleEventHandler extends WidgetsBindingObserver {
  final AsyncCallback resumeCallBack;
  final AsyncCallback suspendingCallBack;

  LifecycleEventHandler({
    this.resumeCallBack,
    this.suspendingCallBack,
  });

  @override
  Future<void> didChangeAppLifecycleState(AppLifecycleState state) async {
    switch (state) {
      case AppLifecycleState.resumed:
        if (resumeCallBack != null) {
          await resumeCallBack();
        }
        break;
      case AppLifecycleState.inactive:
      case AppLifecycleState.paused:
      case AppLifecycleState.detached:
        if (suspendingCallBack != null) {
          await suspendingCallBack();
        }
        break;
    }
  }
}



class AppWidgetState extends State<AppWidget> {
  void initState() {
    super.initState();

    WidgetsBinding.instance.addObserver(
      LifecycleEventHandler(resumeCallBack: () async => setState(() {
        // do something
      }))
    );
  }
  ...
}

导入“包装：颤振/材料.省道”；
进口“包装：颤振/基础.dart”；
类LifecycleEventHandler扩展了WidgetsBindingObserver{
最终异步回调恢复回调；
最终异步回调suspendingCallBack；
生命周期文坦德勒({
这个,这个,，
这是suspendingCallBack，
});
@凌驾
Future didChangeAppLifecycleState（AppLifecycleState状态）异步{
开关（状态）{
案例AppLifecycleState.resumed：
if（resumeCallBack！=null）{
等待恢复回调（）；
}
打破
案例AppLifecycleState.inactive：
案例AppLifecycleState.paused：
案例AppLifecycleState.0：
if（suspendingCallBack！=null）{
等待suspendingCallBack（）；
}
打破
}
}
}
类AppWidgetState扩展了状态{
void initState（）{
super.initState（）；
WidgetsBinding.instance.addObserver(
LifecycleEventHandler（resumeCallBack:（）异步=>setState（）{
//做点什么
}))
);
}
...
}

使用系统频道：

import 'package:flutter/services.dart';

SystemChannels.lifecycle.setMessageHandler((msg){
  debugPrint('SystemChannels> $msg');
  if(msg==AppLifecycleState.resumed.toString())setState((){});
});

`简单方法：

import 'package:flutter/services.dart';

handleAppLifecycleState() {
    AppLifecycleState _lastLifecyleState;
    SystemChannels.lifecycle.setMessageHandler((msg) {

     print('SystemChannels> $msg');

        switch (msg) {
          case "AppLifecycleState.paused":
            _lastLifecyleState = AppLifecycleState.paused;
            break;
          case "AppLifecycleState.inactive":
            _lastLifecyleState = AppLifecycleState.inactive;
            break;
          case "AppLifecycleState.resumed":
            _lastLifecyleState = AppLifecycleState.resumed;
            break;
          case "AppLifecycleState.suspending":
            _lastLifecyleState = AppLifecycleState.suspending;
            break;
          default:
        }
    });
  }

只需在

init（）中添加
handlapplifecyclestate（）

或

class AppLifecycleReactor extends StatefulWidget {
      const AppLifecycleReactor({ Key key }) : super(key: key);

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

    class _AppLifecycleReactorState extends State<AppLifecycleReactor> with WidgetsBindingObserver {
      @override
      void initState() {
        super.initState();
        WidgetsBinding.instance.addObserver(this);
      }

      @override
      void dispose() {
        WidgetsBinding.instance.removeObserver(this);
        super.dispose();
      }

      AppLifecycleState _notification;

      @override
      void didChangeAppLifecycleState(AppLifecycleState state) {
        setState(() { _notification = state; });
      }

      @override
      Widget build(BuildContext context) {
        return Text('Last notification: $_notification');
      }
    }

类AppLifecycleReactor扩展StatefulWidget{
常量applifecycleActor（{Key}）：super（Key:Key）；
@凌驾
_ApplifecycleActorState createState（）=>\u ApplifecycleActorState（）；
}
类applifecycleactorstate扩展状态
进行深入测试，我认为结果值得一读。如果你对应该使用哪种方法感到好奇，请阅读以下内容：（在Android上测试）

生命周期解决方案有三种方法

WidgetsBindingObserver
SystemChannels.lifecycle

WidgetsBindingObserver
和
SystemChannels.lifecycle
之间的主要区别在于
WidgetsBindingObserver
如果有一组小部件需要监听生命周期，则具有更多的功能
SystemChannels
是较低的层，由
WidgetsBindingObserver
使用

在多次测试之后，如果在
runApp
之后使用
SystemChannels
，并且主页小部件与
WidgetsBindingObserver
混合，主页小部件将失败，因为
SystemChannels.lifecycle.setMessageHandler
覆盖主页的方法

因此，如果您想使用全局单一方法，请选择
SystemChannels.lifecycle
，其他方法选择
WidgetsBindingObserver

第三种方法呢？这仅适用于Android，如果您必须在
runApp
之前绑定您的方法，这是唯一的方法。
下面是一个如何观察包含活动（）的生命周期状态的示例：

import'package:flatter/widgets.dart'；
类LifecycleWatcher扩展StatefulWidget{
@凌驾
_LifecycleWatcherState createState（）=>\u LifecycleWatcherState（）；
}
类_LifecycleWatcherState使用WidgetsBindingObserver扩展状态{
ApplifecycleEstate\u lastLifecycleState；
@凌驾
void initState（）{
super.initState（）；
WidgetsBinding.instance.addObserver（这个）；
}
@凌驾
无效处置（）{
WidgetsBinding.instance.removeObserver（此）；
super.dispose（）；
}
@凌驾
void didchangeAppifecyclestate（AppLifecycleState状态）{
设置状态（）{
_lastLifecycleState=状态；
});
}
@凌驾
小部件构建（构建上下文）{
如果（_lastLifecycleState==null）
返回文本（'此小部件未观察到任何生命周期更改'，textDirection:textDirection.ltr）；
return Text（'此小部件观察到的最新生命周期状态为：$\u lastLifecycleState'，
textDirection:textDirection.ltr）；
}
}
void main（）{
runApp（中心（子：LifecycleWatcher（））；
}
导入“包装：颤振/材料.飞镖”；
抽象类LifecycleWatcherState扩展了状态
使用WidgetsBindingObserver{
@凌驾
小部件构建（构建上下文）{
返回null；
}
@凌驾
void initState（）{
super.initState（）；
WidgetsBinding.instance.addObserver（这个）；
}
@凌驾
无效处置（）{
WidgetsBinding.instance.removeObserver（此）；
super.dispose（）；
}
@凌驾
void didchangeAppifecyclestate（AppLifecycleState状态）{
开关（状态）{
案例AppLifecycleState.resumed：
onresume（）；
打破
案例AppLifecycleState.inactive：
onPaused（）；
打破
案例AppLifecycleState.paused：
onInactive（）；
打破
案例AppLifecycleState.0：
onDetached（）；
打破
}
}
无效（）；
void onPaused（）；
void onInactive（）；
void onDetached（）；
}

示例

class ExampleStatefulWidget extends StatefulWidget {
  @override
  _ExampleStatefulWidgetState createState() => _ExampleStatefulWidgetState();
}

class _ExampleStatefulWidgetState
    extends LifecycleWatcherState<ExampleStatefulWidget> {
  @override
  Widget build(BuildContext context) {
    return Container();
  }

  @override
  void onDetached() {

  }

  @override
  void onInactive() {

  }

  @override
  void onPaused() {

  }

  @override
  void onResumed() {

  }
}

class ExampleStatefulWidget扩展了StatefulWidget{
@凌驾
_ExampleStatefulWidgetState createState（）=>\u ExampleStatefulWidgetState（）；
}
类\u ExampleStatefulWidgetState
扩展LifecycleWatcherState{
@凌驾
小部件构建（构建上下文）{
返回容器（）；
}
@凌驾
void onDetached（）{
}
@凌驾
void onInactive（）{
}
@凌驾
void onPaused（）{
}
@凌驾
作废{
}
}
使用“WidgetsBindingObserver”检测onResume事件的解决方案
或者“SystemChannels.lifecycle”仅在应用程序完全在后台运行时起作用，就像在锁屏事件期间或切换到另一个应用程序时一样。如果用户在应用程序的屏幕之间导航，它将不起作用。如果您想在同一应用程序的不同屏幕之间切换时检测onResume事件，请使用visibility_detector library f
import 'package:flutter/material.dart';

abstract class LifecycleWatcherState<T extends StatefulWidget> extends State<T>
    with WidgetsBindingObserver {
  @override
  Widget build(BuildContext context) {
    return null;
  }

  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
  }

  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this);
    super.dispose();
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    switch (state) {
      case AppLifecycleState.resumed:
        onResumed();
        break;
      case AppLifecycleState.inactive:
        onPaused();
        break;
      case AppLifecycleState.paused:
        onInactive();
        break;
      case AppLifecycleState.detached:
        onDetached();
        break;
    }
  }

  void onResumed();
  void onPaused();
  void onInactive();
  void onDetached();
}

class ExampleStatefulWidget extends StatefulWidget {
  @override
  _ExampleStatefulWidgetState createState() => _ExampleStatefulWidgetState();
}

class _ExampleStatefulWidgetState
    extends LifecycleWatcherState<ExampleStatefulWidget> {
  @override
  Widget build(BuildContext context) {
    return Container();
  }

  @override
  void onDetached() {

  }

  @override
  void onInactive() {

  }

  @override
  void onPaused() {

  }

  @override
  void onResumed() {

  }
}

  @override
Widget build(BuildContext context) {
  return VisibilityDetector(
    key: Key('my-widget-key'),
    onVisibilityChanged: (visibilityInfo) {
      num visiblePercentage = visibilityInfo.visibleFraction * 100;
      debugPrint(
          'Widget ${visibilityInfo.key} is ${visiblePercentage}% visible');
      if(visiblePercentage == 100){
                debugPrint("Resumed !");
              }
    },
    child: someOtherWidget,
  );
}