为什么setState在一段时间后停止工作？

Question

我正在开发一个应用程序，其中每个StateFull小部件都在其initState函数中侦听Stream。然后，在小部件状态中更新从流接收的数据。

问题是，1分钟或更短时间后，图形界面不再更新。但是，流仍然在接收数据，我可以通过在listen函数中放置一个print函数来判断。

请注意，该流来自StreamController().stream.asBroadcastStream()，因为我需要从多个小部件中收听相同的流。如果它有帮助，Here是我收到的数据的API，以及他们的时间。每个数据包都在它自己的流中。

编辑：例如，

class DeltaInfo扩展StatefulWidget {DeltaInfoState createState（）=> DeltaInfoState（）; }

class DeltaInfoState extends State<DeltaInfo> {

  LapData playerCarLapData;
  LapData carBehindLapData;
  LapData carInFrontLapData;

  int carInFrontIndex;
  int carBehindIndex;
  int numberOfRacers = 20;
  int session = SessionStatus.raceOne;

  @override initState(){
    super.initState();
    sessionStream.asBroadcastStream().listen((PacketSessionInfo packet){
      session = packet.sessionType;
      sessionStream.drain();
    });

    lapDataStream.asBroadcastStream().listen((PacketLapData packet){
      if(SessionStatus.isRace(sessionType: session)){
        numberOfRacers = 0;
        playerCarLapData = packet.lapData[packet.headder.playerCarIndex];
        int i = 0;
        carInFrontLapData = null;
        carBehindLapData = null;
        carInFrontIndex = null;
        carBehindIndex = null;

        packet.lapData.forEach((LapData car){
          if(car == null) return;
          if(ResultStatus.isInRace(resultStatus: car.resultStatus)){
            this.numberOfRacers++;
          }
          if(car.carPosistion == playerCarLapData.carPosistion - 1){
            carInFrontIndex = i;
            carInFrontLapData = car;
          }
          if(car.carPosistion == playerCarLapData.carPosistion + 1) {
            carBehindIndex = i;
            carBehindLapData = car;
          }
          i++;
        });
        carTelemtryStream.asBroadcastStream().listen((PacketCarTelemtryData packet){
          CarTelemtryData playersCar = packet.carTelemtryData[packet.headder.playerCarIndex];
          if(carInFrontIndex != null){
            CarTelemtryData carInFront = packet.carTelemtryData[carInFrontIndex];
            double time = calculateDelta(
                carALapData: carInFrontLapData,
                carBLapData: playerCarLapData,
                carATelemtry: carInFront,
                carBTelemtry: playersCar,
                carAInfront: true
              );
            setState((){
              inFrontValue = "+ ${time.toStringAsFixed(3)}";
            });
          } else {
            setState((){
              inFrontValue = "In lead";
            });
          }

          if(carBehindIndex != null){
            CarTelemtryData carBehind = packet.carTelemtryData[carBehindIndex];
            setState((){
            double time = calculateDelta(
                carALapData: carBehindLapData,
                carBLapData: playerCarLapData,
                carATelemtry: carBehind,
                carBTelemtry: playersCar,
                carAInfront: false
              );
              behindValue = "- ${time.toStringAsFixed(3)}";
            });
          } else {
            setState((){
              behindValue = "Last Place";
            });
          }
        });
      } else {
        LapData player = packet.lapData[packet.headder.playerCarIndex];

        Map<String, int> currentTime = timeInfoFromSeconds(player.currentLapTime);
        int mins = currentTime["mins"];
        String seconds = currentTime["seconds"].toString().padLeft(2, '0');
        // String ms = (player.currentLapTime % 1).toString().substring(2, 5);
        String ms = "000";
        setState((){
          inFrontValue = "$mins:$seconds.$ms";
        });

        Map<String, int> bestTime = timeInfoFromSeconds(player.bestLapTime);
        mins = bestTime["mins"];
        seconds = bestTime["seconds"].toString().padLeft(2, '0');
        ms = (player.bestLapTime % 1).toString().substring(2, 5);
        setState((){
          behindValue = "$mins:$seconds.$ms";
        });
      }
      lapDataStream.drain();
    });
  }
  String inFrontValue = "A";
  String behindValue = "A";

  @override Widget build(BuildContext context){
    return Expanded(
      child: Column(
        children: [
          Expanded(
            child: FittedBox(
              child: Text("$inFrontValue"),
            ),
          ),
          Expanded(
            child: FittedBox(
              child: Text("$behindValue"),
            ),
          ),
        ]
      )
    );
  }
}


double calculateDelta(
  {@required LapData carALapData,
  @required LapData carBLapData,
  @required CarTelemtryData carATelemtry,
  @required CarTelemtryData carBTelemtry,
  @required bool carAInfront}
){
    if(carAInfront){
      double distanceDifference = carALapData.totalDistance - carBLapData.totalDistance;
      double carBSpeed = kphToMs(carBTelemtry.speed);
      return distanceDifference/carBSpeed;
    } else {
      double distanceDifference = carBLapData.totalDistance - carALapData.totalDistance;
      double carASpeed = kphToMs(carATelemtry.speed);
      return distanceDifference/carASpeed;
    }
}



double kphToMs(int kph){
  return kph*0.2777778;
}

然后将流定义如下

StreamController<PacketLapData> _lapDataStream = StreamController<PacketLapData>();
Stream<PacketLapData> lapDataStream = _lapDataStream.stream.asBroadcastStream();

Answer 1

最后，我没有在initState上监听流，而是在构建函数中使用了StreamBuilder。这种接缝已经停止了滞后/冻结。