Android 颤振流生成器不'；t更新小部件

我正在使用TableCalendar和CloudFireStore创建一个日历屏幕

在设置selectedEvent的位置为selectedEvent赋值后，我想设置

\u buildEventList（）

，但由于先调用

\u buildEventList（）

，所以它将为空。 但是，在设置值之后，我调用的是

setState（）{}

。为什么屏幕不会被更新

final _firestore = Firestore.instance;
FirebaseUser loggedInUser;

// Example holidays
final Map<DateTime, List> _holidays = {
  DateTime(2019, 1, 1): ['New Year\'s Day'],
  DateTime(2019, 1, 6): ['Epiphany'],
  DateTime(2019, 2, 14): ['Valentine\'s Day'],
  DateTime(2019, 4, 21): ['Easter Sunday'],
  DateTime(2019, 4, 22): ['Easter Monday'],
};

class CalenderScreen extends StatefulWidget {
  @override
  _CalenderScreenState createState() => _CalenderScreenState();
}

class _CalenderScreenState extends State<CalenderScreen>
    with TickerProviderStateMixin {
  DateTime _selectedDay;
  Map<DateTime, List> _events = {};
  Map<DateTime, List> _visibleEvents;
  Map<DateTime, List> _visibleHolidays;
  List _selectedEvents;
  AnimationController _controller;
  final _auth = FirebaseAuth.instance;
  Widget streamBuilder;
  Widget buildEvents;

  @override
  void initState() {
    print("calender");
    super.initState();
    getCurrentUser();
    _selectedDay = DateTime.now();
    _selectedEvents = _events[_selectedDay] ?? [];
    _visibleEvents = _events;
    _visibleHolidays = _holidays;

    _controller = AnimationController(
      vsync: this,
      duration: const Duration(milliseconds: 400),
    );

    _controller.forward();
  }

  void getCurrentUser() async {
    try {
      final user = await _auth.currentUser();
      if (user != null) {
        loggedInUser = user;
        setStreamBuilder();
      }
    } catch (e) {
      print(e);
    }
  }

  void setStreamBuilder() {
    setState(() {
      streamBuilder = StreamBuilder<QuerySnapshot>(
        stream: _firestore
            .collection('users')
            .document(loggedInUser.uid)
            .collection('history')
            .snapshots(),
        builder: (context, snapshot) {
          if (snapshot.data == null)
            return Center(child: CircularProgressIndicator());
          final historys = snapshot.data.documents;
          _events = {};
          for (var history in historys) {
            DateTime timeStamp = history.data['date'].toDate();
            DateTime currentDate =
                DateTime(timeStamp.year, timeStamp.month, timeStamp.day);
            if (_events.containsKey(currentDate)) {
              _events[currentDate].add(history);
            } else {
              _events[currentDate] = [history];
            }
          }
          print(_events);
          DateTime now = DateTime.now();
          _selectedDay = DateTime(now.year, now.month, now.day);
　　　　　　//here i set the _selectedEvents
          _selectedEvents = _events[_selectedDay] ?? [];
          _visibleEvents = _events;
          return _buildTableCalendar();
        },
      );
    });
  }

  void _onDaySelected(DateTime day, List events) {
    setState(() {
      _selectedDay = day;
      _selectedEvents = events;
    });
  }

  void _onVisibleDaysChanged(
      DateTime first, DateTime last, CalendarFormat format) {
    setState(() {
      _visibleEvents = Map.fromEntries(
        _events.entries.where(
          (entry) =>
              entry.key.isAfter(first.subtract(const Duration(days: 1))) &&
              entry.key.isBefore(last.add(const Duration(days: 1))),
        ),
      );

      _visibleHolidays = Map.fromEntries(
        _holidays.entries.where(
          (entry) =>
              entry.key.isAfter(first.subtract(const Duration(days: 1))) &&
              entry.key.isBefore(last.add(const Duration(days: 1))),
        ),
      );
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      backgroundColor: Color(0xFF232D3D),
      body: Column(
        mainAxisSize: MainAxisSize.max,
        children: <Widget>[
          streamBuilder != null
              ? streamBuilder
              : Center(
                  child: CircularProgressIndicator(),
                ),
          const SizedBox(height: 8.0),
          _buildEventList()
        ],
      ),
      floatingActionButton: FloatingPenButton(),
    );
  }

  Widget _buildTableCalendar() {
    return TableCalendar(
      ~~
    );
  }

  Widget _buildEventList() {
    print("bulid event");
    return Expanded(
      child: ListView(
        children: _selectedEvents
            .map(
              (event) => HistoryCard(
                history: HistoryData(
                    ~~
              ),
            )
            .toList(),
      ),
    );
  }
}

final\u firestore=firestore.instance；
FirebaseUser日志用户；
//例假
最终地图_假日={
日期时间（2019年1月1日）：[“新年”]，
日期时间（2019年1月6日）：[“顿悟”]，
日期时间（2019年2月14日）：[“情人节”]，
日期时间（2019年4月21日）：[“复活节周日”]，
日期时间（2019年4月22日）：[“复活节星期一”]，
};
类CalenderScreen扩展StatefulWidget{
@凌驾
_CalenderScreenState createState（）=>u CalenderScreenState（）；
}
类_压延屏幕状态扩展状态
使用TickerProviderStateMixin{
日期时间\u选择的日期；
映射_事件={}；
映射可视事件；
地图-可见假日；
列出所选事件；
动画控制器_控制器；
final _auth=FirebaseAuth.instance；
控件流生成器；
事件；
@凌驾
void initState（）{
印刷品（“日历”）；
super.initState（）；
getCurrentUser（）；
_selectedDay=DateTime.now（）；
_selectedEvents=_事件[_selectedDay]？？[]；
_visibleEvents=_事件；
_可见假日=_假日；
_控制器=动画控制器(
vsync:这个,，
持续时间：常量持续时间（毫秒：400），
);
_controller.forward（）；
}
void getCurrentUser（）异步{
试一试{
最终用户=等待_auth.currentUser（）；
如果（用户！=null）{
loggedInUser=用户；
setstreambulder（）；
}
}捕获（e）{
印刷品（e）；
}
}
void setstreambulder（）{
设置状态（）{
streamBuilder=streamBuilder(
流：_firestore
.collection（'用户'）
.document（loggedInUser.uid）
.collection（“历史记录”）
.snapshots（），
生成器：（上下文，快照）{
如果（snapshot.data==null）
返回中心（子项：CircularProgressIndicator（））；
最终历史=snapshot.data.documents；
_事件={}；
for（历史中的var历史）{
DateTime timeStamp=history.data['date'].toDate（）；
日期时间当前日期=
DateTime（timeStamp.year、timeStamp.month、timeStamp.day）；
如果（_events.containsKey（当前日期））{
_事件[currentDate]。添加（历史记录）；
}否则{
_事件[当前日期]=[历史]；
}
}
打印（_事件）；
DateTime now=DateTime.now（）；
_选择日期=日期时间（now.year，now.month，now.day）；
　　　　　　//在这里，我设置了所选事件
_selectedEvents=_事件[_selectedDay]？？[]；
_visibleEvents=_事件；
返回_buildTableCalendar（）；
},
);
});
}
void\u onDaySelected（日期时间日，列出事件）{
设置状态（）{
_选择日期=天；
_selectedEvents=事件；
});
}
无效_onVisibleDaysChanged(
DateTime first、DateTime last、CalendarFormat）{
设置状态（）{
_visibleEvents=Map.fromEntries(
_events.entries.where(
（条目）=>
entry.key.isAfter（first.subtract（常量持续时间（天：1）））&&
entry.key.isBefore（last.add（常量持续时间（天：1）），
),
);
_visibleHolidays=Map.fromEntries(
_假期、条目、地点(
（条目）=>
entry.key.isAfter（first.subtract（常量持续时间（天：1）））&&
entry.key.isBefore（last.add（常量持续时间（天：1）），
),
);
});
}
@凌驾
小部件构建（构建上下文）{
返回脚手架(
背景颜色：颜色（0xFF232D3D），
正文：专栏(
mainAxisSize:mainAxisSize.max，
儿童：[
streamBuilder！=null
？streamBuilder
：中心(
子对象：CircularProgressIndicator（），
),
const SizedBox（高度：8.0），
_buildEventList（）
],
),
floatingActionButton:FloatingPenButton（），
);
}
小部件_buildTableCalendar（）{
返回表日历(
~~
);
}
小部件_buildEventList（）{
打印（“bulid事件”）；
扩大回报(
子：ListView(
子项：\ u选择的事件
.地图(
（事件）=>历史记录卡(
历史：历史数据(
~~
),
)
.toList（），
),
);
}
}