Implementação TCP socket com loop

// ************************
// ****** SocketBloc ******
// ************************

enum SocketState {
  IDLE,
  CREATING,
  CREATE_FAIL,
  READY,
  GET_DATA,
  GET_DATA_FAIL,
  SET_INCREMENT,
  SET_INCREMENT_FAIL,
}

class SocketBloc extends BlocBase {
  Socket _socket;
  DateTime _lastDone;
  SettingsBloc _settingsBloc = SettingsBloc();
  String _ip;
  int _port;

  // Fluxo de estado
  final _stateController =
      BehaviorSubject<SocketState>(seedValue: SocketState.IDLE);

  Stream<SocketState> get outState => _stateController.stream;

  Sink<SocketState> get inState => _stateController.sink;

  // Construtor padrão
  SocketBloc() {
    _log("SocketBloc Construtor", "Instanciado", "Inicializando...");

    _stateController.listen((SocketState state) {
      switch (state) {
        case SocketState.CREATING:
          _closeSocket();
          _createSocket();
          break;
        case SocketState.READY:
          _getAbastecimento();
          break;
        case SocketState.SET_INCREMENT: // TODO: SET_INCREMENT
        case SocketState.IDLE: // TODO: IDLE
        case SocketState.CREATE_FAIL: // TODO: CREATE_FAIL
        case SocketState.GET_DATA: // TODO: GET_DATA
        case SocketState.GET_DATA_FAIL: // TODO: GET_DATA_FAIL
        case SocketState.SET_INCREMENT_FAIL: // TODO: SET_INCREMENT_FAIL
      }
    });

    _settingsBloc.outConnection.listen((data) {
      bool setingsChanged = false;
      if (_ip != data["ip"]) {
        _ip = data["ip"];
        setingsChanged = true;
      }
      if (_port != data["port"]) {
        _port = data["port"];
        setingsChanged = true;
      }

      if (setingsChanged) {
        _log("SocketBloc Construtor", "IP/PORTA",
            "FLAG para tentar criar canal com Socket");
        _stateController.add(SocketState.CREATING);
      }
    });
  }

  Future<void> _createSocket() async {
    try {
      _socket = await Socket.connect(_ip, _port,
          timeout: Duration(milliseconds: 2000));

      _log("_createSocket", "Canal aberto",
          "Canal com socket aberto, ADICIONAR LISTENERS");
      _addListeners();

      _stateController.add(SocketState.READY);
    } catch (e) {
      print("Falha ao criar o socket: $e");
      _stateController.add(SocketState.CREATE_FAIL);
      _log("_createSocket", "Falha na criação do canal ",
          "Tentar criar novamente 10 segundos",
          jump: false);

      Future.delayed(Duration(seconds: 10)).then((_) {
        _createSocket();
      });
    }
  }

  void _addListeners() {
    _log("_addListeners", "Socket ok, adicionar listener",
        "listeners adicionados no canal");

    _socket.listen(dataHandler, onError: errorHandler);
  }

  void dataHandler(data) {
    String result = _stringChecked(data);

    // TODO: Verificar conteúdo da string quando não tem mais ponteiros com registros válidos, pois vem uma string com algum conteúdo
    _log("dataHandler", "String de resultado",
        "Resposta OK, validar string de $result",
        jump: false);

    if (result != "" && result != SWC_NO_CONTENT) {
      String pointer = result.substring(8, 14);

      _log("dataHandler", "Validou string",
          "Ponteiro atual: $pointer  String Válida: $result");

      switch (_stateController.stream.value) {
        // *** Dados de abastecimento
        case SocketState.GET_DATA:
          // TODO: Ponteiro não existe no BD (Grava SQLite)

          _setIncrement();
          break;

        // *** Confirmação de incremento do ponteiro
        case SocketState.SET_INCREMENT:
          print(
              "------------------------------------------------------------\n\n");
          _setReady();
          break;
        default:
      }
    } else {
      // *** Buffer de dados incorreto ou truncado, repetir na próxima iteração
      _log("dataHandler", "String Inválida",
          "String não é válida (ou não tem dados registrados)... tenta de novo na próxima iteração");
      _setReady();
    }
  }

  void errorHandler(error, StackTrace trace) {
    print(error);
    _log("errorHandler", "Falha ao receber",
        "Falha ao buscar informações no canal, tenta recriar socket...");

    _stateController.add(SocketState.CREATING);
  }

  void _getAbastecimento() {
    try {
      _stateController.add(SocketState.GET_DATA);
      _socket.write(GET_ABASTECIMENTO_STRING);
    } catch (e) {
      print("Falha ao consultar abastecimento: $e");
      _stateController.add(SocketState.GET_DATA_FAIL);
    }
  }

  void _setIncrement() {
    try {
      _stateController.add(SocketState.SET_INCREMENT);
      _socket.write(SET_INCREMENT_POINTER_STRING);
    } catch (e) {
      print("Falha incrementar ponteiro de abastecimento: $e");
      _stateController.add(SocketState.SET_INCREMENT_FAIL);
    }
  }

  void _setReady() {
    Future.delayed(SWC_DELAY_INTERVAL).then((_) {
      _stateController.add(SocketState.READY);
    });
  }

  String _stringChecked(List<int> buff) {
    // Verificação de estrutura do buffer
    // 5+ posições, sendo:
    //    - 1º caractere ">" (ASCII 62)
    //    - Último caractere "\n" (ASCII 13)
    //    - Penúltimo e antepenúltimo: CHECKSUM
    //    - posições de conteúdo, totalizando + de 4 posições no mínimo
    if (buff.length <= 4) return "";
    if (buff[0] != 62 || buff[buff.length - 1] != 13) return "";

    // 4 Validar Checksum
    int checksum = 0;
    for (int i = 1; i < buff.length - 3; i++) {
      checksum += buff[i];
      if (checksum > 256) checksum -= 256;
    }

    String str = String.fromCharCodes(buff).trim();
    String check = checksum.toRadixString(16).toUpperCase();
    print(
        "Checksum: $checksum  - Check: $check / ${str.substring(str.length - 2)}");
    return check == str.substring(str.length - 2) ? str : "";
  }

  DateTime get lastDone => _lastDone;

  @override
  void dispose() {
    _stateController.close();

    _closeSocket();
  }

  void _closeSocket() {
    try {
      if (_socket != null) _socket.close();
    } catch (e) {
      _socket = null;
    }
  }

  void _log(String method, String location, String message, {bool jump: true}) {
    print("------| LOG |------");
    print("\t- Socket: $_socket");
    print("\t- SocketState: ${_stateController.stream.value}");
    print("\t- Método: $method ( $location )");
    print("\t- Resultado: $message${jump ? "\n\n" : ""}");
  }
}



// ****************************
// ****** SocketWrapper  ******
// ****************************
class SocketWrapper extends StatefulWidget {
  @override
  _SocketWrapperState createState() => _SocketWrapperState();
}

class _SocketWrapperState extends State<SocketWrapper> {
  SocketBloc _socketBloc = SocketBloc();

  @override
  Widget build(BuildContext context) {
    final bloc = BlocProvider.of<SettingsBloc>(context);
    return StreamBuilder<SettingsState>(
      stream: bloc.outState,
      builder: (context, snapshot) {
        if (snapshot.data != SettingsState.DONE) {
          return Center(
            child: CircularProgressIndicator(),
          );
        }

        return HomeScreen();
      },
    );
  }

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


// ************************
// ****** LOGS ******
// ************************

1. Conexão 100%: https://pastebin.com/vr6qXh0F
2. Conexão 100% em seguida falha: https://pastebin.com/hvXqb1y7
3. Falha direto depois restabelece: https://pastebin.com/cRabGrZy