Web Socket

 import 'dart:convert';

import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
import 'package:socket_io_client/socket_io_client.dart' as io;
import 'package:socket_io_client/socket_io_client.dart';
import 'package:womenentrepreneur/configs/app_constant.dart';
import 'package:womenentrepreneur/configs/app_urls.dart';
import 'package:womenentrepreneur/models/support_conversion/support_conversion_mod.dart';
import 'package:womenentrepreneur/services/support_conversation/fetch_support_conversion.dart';
import 'package:womenentrepreneur/services/support_conversation/send_support_conversion.dart';

part 'support_conversion_event.dart';
part 'support_conversion_state.dart';

class SupportConversionBloc
    extends Bloc<SupportConversionEvent, SupportConversionState> {
  List<SupportConversionDatum> conversionList = [];
  io.Socket? socketIO;

  SupportConversionBloc() : super(SupportConversionInitial()) {
    on<DoFetchSupportConversion>((event, emit) async {
      emit(LoadingSupportConversion(conversionList: conversionList));

      final response = await fetchSupportConversationService(
          token: event.token, conversionId: event.conversationId);

      if (response.success != null && response.success == true) {
        conversionList = response.data ?? [];
        emit(SuccessSupportConversion(conversionList: conversionList));
      }
    });

    //local set msg
    on<SetLocalMessage>((event, emit) async {
      emit(LoadingSupportConversion(conversionList: conversionList));
      final singleConversion = event.singleConversion;
      final result = await sendSupportConversationService(
          token: event.token,
          conversionId: event.singleConversion.conversationId ?? 0,
          singleConversion: singleConversion);

      if (!result) {
        singleConversion.sendFailed = true;
      }

      conversionList.insert(0, singleConversion);

      emit(SuccessSupportConversion(conversionList: conversionList));
    });

//web socket set msg
    on<ReceiveSocketMessage>((event, emit) async {
      emit(LoadingSupportConversion(conversionList: conversionList));

      conversionList.insert(0, event.singleConversion);

      emit(SuccessSupportConversion(conversionList: conversionList));
    });
  }

  // Connect to socket
  void connectToSocket(String userId) {
    socketIO = io.io(
      AppUrls.socketUrl,
      io.OptionBuilder().setTransports(["websocket"]).setAuth(
          {"id": userId, "type": AppUrls.typeSocket}).build(),
    );

    logger.e("socketIO?.disconnected: ${socketIO?.disconnected}");
    if(socketIO?.disconnected == true){
      socketIO?.connect();
    }


    socketIO?.onConnect((_) {
      socketIO?.on("support-conversation", (data) {
        logger.e("message data: $data");
        SupportConversionDatum singleConversion2 =
            supportConversionDatumFromJson(jsonEncode(data));
        add(ReceiveSocketMessage(singleConversion: singleConversion2));
      });
    });
  }

  //close
  void disconnectSocket() {
    socketIO?.disconnect();
    socketIO?.dispose();
    logger.i("c?.connected: ${socketIO?.connected}");
  }
}

--------------------------------------------------------------------

Events

part of 'support_conversion_bloc.dart';

sealed class SupportConversionEvent extends Equatable {
  const SupportConversionEvent();

  @override
  List<Object> get props => [];
}

class DoFetchSupportConversion extends SupportConversionEvent{
  final int conversationId;
  final String token;

  const DoFetchSupportConversion({required this.token, required this.conversationId});
}

//here set message event
class SetLocalMessage extends SupportConversionEvent{
  final SupportConversionDatum singleConversion;
  final String token;
  const SetLocalMessage({required this.singleConversion, required this.token});
}

class ReceiveSocketMessage extends SupportConversionEvent{
  final SupportConversionDatum singleConversion;
  const ReceiveSocketMessage({required this.singleConversion});
}



---------------------------------------
states
part of 'support_conversion_bloc.dart';

sealed class SupportConversionState extends Equatable {
  const SupportConversionState();

  @override
  List<Object> get props => [];
}

final class SupportConversionInitial extends SupportConversionState {}

final class LoadingSupportConversion extends SupportConversionState {
  final List<SupportConversionDatum> conversionList;
  const LoadingSupportConversion({required this.conversionList});
}
// final class FailedSupportConversion extends SupportConversionState {}
final class SuccessSupportConversion extends SupportConversionState {
  final List<SupportConversionDatum> conversionList;
  const SuccessSupportConversion({required this.conversionList});
}


-------------------------------------
model
// To parse this JSON data, do
//
//     final supportConversionModel = supportConversionModelFromJson(jsonString);

import 'dart:convert';

SupportConversionModel supportConversionModelFromJson(String str) => SupportConversionModel.fromJson(json.decode(str));

String supportConversionModelToJson(SupportConversionModel data) => json.encode(data.toJson());

class SupportConversionModel {
  bool? success;
  String? message;
  List<SupportConversionDatum>? data;

  SupportConversionModel({
    this.success,
    this.message,
    this.data,
  });

  factory SupportConversionModel.fromJson(Map<String, dynamic> json) => SupportConversionModel(
    success: json["success"],
    message: json["message"],
    data: json["data"] == null ? [] : List<SupportConversionDatum>.from(json["data"]!.map((x) => SupportConversionDatum.fromJson(x))),
  );

  Map<String, dynamic> toJson() => {
    "success": success,
    "message": message,
    "data": data == null ? [] : List<dynamic>.from(data!.map((x) => x.toJson())),
  };
}

SupportConversionDatum supportConversionDatumFromJson(String str) => SupportConversionDatum.fromJson(json.decode(str));
class SupportConversionDatum {
  int? conversationId;
  int? id;
  String? sendByUser;
  String? message;
  List<SupportConversionAttachment>? attachment;
  DateTime? createdAt;
  bool sendFailed;

  SupportConversionDatum({
    this.conversationId,
    this.id,
    this.sendByUser,
    this.message,
    this.attachment,
    this.createdAt,
    this.sendFailed = false
  });

  factory SupportConversionDatum.fromJson(Map<String, dynamic> json) => SupportConversionDatum(
    conversationId: json["conversation_id"],
    id: json["id"],
    sendByUser: json["send_by_user"],
    message: json["message"],
    attachment: json["attachment"] == null ? [] : List<SupportConversionAttachment>.from(json["attachment"]!.map((x) => SupportConversionAttachment.fromJson(x))),
    createdAt: json["created_at"] == null ? null : DateTime.parse(json["created_at"]),
  );

  Map<String, dynamic> toJson() => {
    "conversation_id": conversationId,
    "id": id,
    "send_by_user": sendByUser,
    "message": message,
    "attachment": attachment == null ? [] : List<dynamic>.from(attachment!.map((x) => x.toJson())),
    "created_at": createdAt?.toIso8601String(),
  };
}

class SupportConversionAttachment {
  String? type;
  String? file;
  bool? isLocal;

  SupportConversionAttachment({
    this.type,
    this.file,
    this.isLocal = false
  });

  factory SupportConversionAttachment.fromJson(Map<String, dynamic> json) => SupportConversionAttachment(
    type: json["type"],
    file: json["file"],
  );

  Map<String, dynamic> toJson() => {
    "type": type,
    "file": file,
  };
}


-------------------------------------------------------------------------