Flutter 颤振列表生成器重置已删除项下的小部件

不过，这是一个令人困惑的问题，如果这是一个简单的问题，我很抱歉，但我在网上找不到任何信息。无论如何，我有一个由一个集团控制的列表生成器，它使用另一个集团控制的计时器。每当我删除一个计时器时，它都会重置已删除项下面的所有计时器，但会将计时器保留在“精细”之上

以下第0项和第2项处于活动状态，仅供参考。如果删除项目1，则项目2将重置

我能阻止吗？我目前有一个全局键，该键在所示的item tile的state类中调用，并且我还从父窗口小部件传递一个键

下面是子ItemTile小部件：

    class ItemTile extends StatefulWidget {
  final Function(String) onDeletePressed;
  final int index;
  final Timer timer;
  //final key; // = UniqueKey();

  ItemTile({
    Key key,
    @required this.index,
    @required this.timer,
    @required this.onDeletePressed,
  }) : //: key = ObjectKey(timer.id),
        super(key: key);

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

class _ItemTileState extends State<ItemTile> {
  final key = GlobalKey();
  @override
  Widget build(BuildContext context) {
    return Container(
      child: Row(
        children: [
          Text('${widget.index.toString()}'),
          BlocProvider(
            create: (context) =>
                TimerBloc(ticker: Ticker(), timer: widget.timer),
            child: Container(
              height: (MediaQuery.of(context).size.height - 100) / 5,
              child: Row(
                children: [
                  Column(
                    mainAxisAlignment: MainAxisAlignment.center,
                    crossAxisAlignment: CrossAxisAlignment.center,
                    children: <Widget>[
                      Padding(
                        padding: EdgeInsets.symmetric(vertical: 10.0),
                        child: Center(
                          child: BlocBuilder<TimerBloc, TimerState>(
                            builder: (context, state) {
                              final String minutesStr =
                                  ((state.duration / 60) % 60)
                                      .floor()
                                      .toString()
                                      .padLeft(2, '0');
                              final String secondsStr = (state.duration % 60)
                                  .floor()
                                  .toString()
                                  .padLeft(2, '0');
                              return Text(
                                '$minutesStr:$secondsStr',
                              );
                            },
                          ),
                        ),
                      ),
                      BlocBuilder<TimerBloc, TimerState>(
                        buildWhen: (previousState, currentState) =>
                            currentState.runtimeType !=
                            previousState.runtimeType,
                        builder: (context, state) => TimerActions(),
                      ),
                    ],
                  ),
                ],
              ),
            ),
          ),
          widget.timer.isDeleting
              ? CircularProgressIndicator()
              : IconButton(
                  icon: Icon(Icons.delete, color: Colors.red),
                  onPressed: () {
                    widget.onDeletePressed(widget.timer.id);
                  },
                ),
        ],
      ),
    );
  }
}

class ItemTile扩展了StatefulWidget{
最终函数（字符串）已按下；
最终整数指数；
最终定时器；
//最后一个键；/=UniqueKey（）；
项目瓦({
关键点，
@需要这个索引，
@需要这个计时器，
@需要此项。按此键，
})：/：key=ObjectKey（timer.id），
超级（键：键）；
@凌驾
_ItemTileState createState（）=>\u ItemTileState（）；
}
类_ItemTileState扩展状态{
final key=GlobalKey（）；
@凌驾
小部件构建（构建上下文）{
返回容器(
孩子：排(
儿童：[
文本（“${widget.index.toString（）}”），
BlocProvider(
创建：（上下文）=>
TimerBloc（ticker:ticker（），timer:widget.timer），
子：容器(
高度：（MediaQuery.of（context）.size.height-100）/5，
孩子：排(
儿童：[
纵队(
mainAxisAlignment:mainAxisAlignment.center，
crossAxisAlignment:crossAxisAlignment.center，
儿童：[
填充物(
填充：边缘设置。对称（垂直：10.0），
儿童：中心(
孩子：BlocBuilder(
生成器：（上下文、状态）{
最终字符串分钟数=
（（state.duration/60）%60）
.会议室（）
.toString（）
.padLeft（2，'0'）；
最终字符串secondsStr=（state.duration%60）
.会议室（）
.toString（）
.padLeft（2，'0'）；
返回文本(
“$minutesStr:$secondsStr”，
);
},
),
),
),
BlocBuilder(
buildWhen：（previousState，currentState）=>
currentState.runtimeType=
previousState.runtimeType，
生成器：（上下文，状态）=>TimerActions（），
),
],
),
],
),
),
),
widget.timer.isDeleting
？循环压缩机指示器（）
：图标按钮(
图标：图标（Icons.delete，颜色：Colors.red），
已按下：（）{
onDeletePressed（widget.timer.id）；
},
),
],
),
);
}
}

下面是家长主页小部件：

class HomePage extends StatefulWidget {
  static const TextStyle timerTextStyle = TextStyle(
    fontSize: 30,
    fontWeight: FontWeight.bold,
  );

  final Stream shouldTriggerChange;
  HomePage({@required this.shouldTriggerChange});
  @override
  _HomePageState createState() => _HomePageState();
}

class _HomePageState extends State<HomePage> {
  StreamSubscription streamSubscription;

  @override
  initState() {
    super.initState();
    streamSubscription = widget.shouldTriggerChange.listen((data) {
      createTimer(context, data);
    });
  }

  void createTimer(BuildContext context, timer_type timer) {
    BlocProvider.of<ListBloc>(context).add(Add(
        id: DateTime.now().toString(),
        duration: timer == timer_type.timer ? 100 : 0,
        timer: timer,
        timerTextStyle: HomePage.timerTextStyle));
  }

  @override
  didUpdateWidget(HomePage old) {
    super.didUpdateWidget(old);
    // in case the stream instance changed, subscribe to the new one
    if (widget.shouldTriggerChange != old.shouldTriggerChange) {
      streamSubscription.cancel();
      streamSubscription = widget.shouldTriggerChange
          .listen((data) => createTimer(context, data));
    }
  }

  @override
  dispose() {
    super.dispose();
    streamSubscription.cancel();
  }

  @override
  Widget build(BuildContext context) {
    return BlocBuilder<ListBloc, ListState>(
      builder: (context, state) {
        if (state is Failure) {
          return Center(
            child: Text('Oops something went wrong!'),
          );
        }
        if (state is Loaded) {
          return Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              state.timers.isEmpty
                  ? Center(
                      child: Text('no content'),
                    )
                  : Expanded(
                      child: ListView.builder(
                        itemBuilder: (BuildContext context, int index) {
                          return ItemTile(
                            key: ObjectKey(state.timers[index]),
                            index: index,
                            timer: state.timers[index],
                            onDeletePressed: (id) {
                              BlocProvider.of<ListBloc>(context)
                                  .add(Delete(id: id));
                            },
                          );
                        },
                        itemCount: state.timers.length,
                      ),
                    ),
            ],
          );
        }
        return Center(
          child: CircularProgressIndicator(),
        );
      },
    );
  }
}

类主页扩展StatefulWidget{
静态常量TextStyle timerTextStyle=TextStyle(
尺寸：30，
fontWeight:fontWeight.bold，
);
最终流应触发更改；
主页（{@required this.shouldTriggerChange}）；
@凌驾
_HomePageState createState（）=>\u HomePageState（）；
}
类_HomePageState扩展状态{
流订阅流订阅；
@凌驾
initState（）{
super.initState（）；
streamSubscription=widget.shouldTriggerChange.listen（（数据）{
createTimer（上下文、数据）；
});
}
void createTimer（BuildContext上下文，timer\u类型timer）{
BlocProvider.of（上下文）.add（添加(
id:DateTime.now（）.toString（），
持续时间：timer==timer\u type.timer？100:0，
定时器：定时器，
timerTextStyle:HomePage.timerTextStyle）；
}
@凌驾
didUpdateWidget（旧主页）{
super.diupdatewidget（旧）；
//如果流实例已更改，请订阅新实例
if（widget.shouldTriggerChange！=old.shouldTriggerChange）{
streamSubscription.cancel（）；
streamSubscription=widget.shouldTriggerChange
.listen（（数据）=>createTimer（上下文，数据））；
}
}
@凌驾
处置{
super.dispose（）；
streamSubscription.cancel（）；
}
@凌驾
小部件构建（构建上下文）{
返回BlocBuilder(
生成器：（上下文、状态）{
如果（状态为失败）{
返回中心(
孩子：文本（‘哎呀，出问题了！’），
);
}
如果（状态已加载）{
返回列(
mainAxisAlignment:mainAxisAlignment.center，
儿童：[
state.timers.isEmpty
？中心(
子项：文本（“无内容”），
)
：扩展(
子项：ListView.builder(
itemBuilder:（构建上下文，int索引）{
返回项目磁贴(
key:ObjectKey（state.timers[index]），
索引:索引,，
计时器：状态。计时器[索引]，
onDeletePressed:（id）{
BlocProvider.of（上下文）
.添加（删除（id:id））；
},
);
},
itemCount:state.timers.length