rama/halobestie-clone
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Phase 3.1: Remove flutter_bloc + equatable, delete old bloc files

Browse Source 
- Remove flutter_bloc and equatable dependencies from both apps
- Delete all 10 old bloc files (5 per app)
- Fix 6 remaining screens that used context.read<ApiClient>() from
  flutter_bloc → converted to ConsumerStatefulWidget/ConsumerWidget
  with ref.read(apiClientProvider)
- Both apps now use Riverpod exclusively for state management

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
ramadhan sjamsani
2026-04-09 14:12:28 +08:00
parent 35d470b851
commit fa8c963d92
20 changed files with 38 additions and 2106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

195
mitra_app/lib/core/chat/chat_request_bloc.dart
View File

@@ -1,195 +0,0 @@
import 'dart:async';
import 'dart:convert';
import 'package:dio/dio.dart';
import 'package:equatable/equatable.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:web_socket_channel/web_socket_channel.dart';
import '../api/api_client.dart';
import '../constants.dart';
// Events
abstract class ChatRequestEvent extends Equatable {
@override
List<Object?> get props => [];
}
class StartListening extends ChatRequestEvent {}
class StopListening extends ChatRequestEvent {}
class _RequestReceived extends ChatRequestEvent {
final Map<String, dynamic> data;
_RequestReceived(this.data);
@override
List<Object?> get props => [data];
}
class _ConnectionError extends ChatRequestEvent {}
class AcceptRequest extends ChatRequestEvent {
final String sessionId;
AcceptRequest(this.sessionId);
@override
List<Object?> get props => [sessionId];
}
class DeclineRequest extends ChatRequestEvent {
final String sessionId;
DeclineRequest(this.sessionId);
@override
List<Object?> get props => [sessionId];
}
// States
abstract class ChatRequestState extends Equatable {
@override
List<Object?> get props => [];
}
class ChatRequestIdle extends ChatRequestState {}
class ChatRequestListening extends ChatRequestState {}
class ChatRequestIncoming extends ChatRequestState {
final String sessionId;
ChatRequestIncoming(this.sessionId);
@override
List<Object?> get props => [sessionId];
}
class ChatRequestAccepting extends ChatRequestState {}
class ChatRequestAccepted extends ChatRequestState {
final Map<String, dynamic> session;
ChatRequestAccepted(this.session);
@override
List<Object?> get props => [session];
}
class ChatRequestError extends ChatRequestState {
final String message;
ChatRequestError(this.message);
@override
List<Object?> get props => [message];
}
// Bloc
class ChatRequestBloc extends Bloc<ChatRequestEvent, ChatRequestState> {
final ApiClient apiClient;
WebSocketChannel? _channel;
StreamSubscription? _wsSubscription;
ChatRequestBloc({required this.apiClient}) : super(ChatRequestIdle()) {
on<StartListening>(_onStartListening);
on<StopListening>(_onStopListening);
on<_RequestReceived>(_onRequestReceived);
on<_ConnectionError>(_onConnectionError);
on<AcceptRequest>(_onAcceptRequest);
on<DeclineRequest>(_onDeclineRequest);
}
Future<void> _onStartListening(StartListening event, Emitter<ChatRequestState> emit) async {
_closeWebSocket();
emit(ChatRequestListening());
await _connectWebSocket();
}
Future<void> _onStopListening(StopListening event, Emitter<ChatRequestState> emit) async {
_closeWebSocket();
emit(ChatRequestIdle());
}
Future<void> _connectWebSocket() async {
try {
final user = FirebaseAuth.instance.currentUser;
if (user == null) return;
final token = await user.getIdToken();
final wsUrl = ApiClient.baseUrl
.replaceFirst('https://', 'wss://')
.replaceFirst('http://', 'ws://');
_channel = WebSocketChannel.connect(Uri.parse('$wsUrl/api/shared/ws'));
_wsSubscription = _channel!.stream.listen(
(raw) {
final data = jsonDecode(raw as String) as Map<String, dynamic>;
if (data['type'] == WsMessage.authOk) return; // Auth confirmed, no action needed
add(_RequestReceived(data));
},
onError: (_) => add(_ConnectionError()),
onDone: () => add(_ConnectionError()),
);
// Authenticate without session_id — just for receiving notifications
_channel!.sink.add(jsonEncode({
'type': WsMessage.auth,
'token': token,
}));
} catch (_) {
add(_ConnectionError());
}
}
Future<void> _onConnectionError(_ConnectionError event, Emitter<ChatRequestState> emit) async {
_closeWebSocket();
// Stay in listening state — FCM will still deliver notifications
if (state is! ChatRequestIdle) {
emit(ChatRequestListening());
}
}
Future<void> _onRequestReceived(_RequestReceived event, Emitter<ChatRequestState> emit) async {
final data = event.data;
final type = data['type'] as String?;
if (type == WsMessage.chatRequest) {
emit(ChatRequestIncoming(data['session_id'] as String));
} else if (type == WsMessage.chatRequestClosed) {
// Request was taken by another mitra or cancelled
if (state is ChatRequestIncoming) {
emit(ChatRequestListening());
}
} else if (type == 'session_rerouted') {
// A session was rerouted away from us — refresh active sessions
emit(ChatRequestListening());
} else if (type == 'session_assigned') {
// A session was force-assigned to us
emit(ChatRequestAccepted({'session_id': data['session_id']}));
}
}
Future<void> _onAcceptRequest(AcceptRequest event, Emitter<ChatRequestState> emit) async {
emit(ChatRequestAccepting());
try {
final response = await apiClient.post('/api/mitra/chat-requests/${event.sessionId}/accept');
emit(ChatRequestAccepted(response['data'] as Map<String, dynamic>));
} on DioException catch (e) {
final code = e.response?.data?['error']?['code'];
if (code == 'REQUEST_UNAVAILABLE') {
emit(ChatRequestListening());
} else {
emit(ChatRequestError('Gagal menerima. Coba lagi.'));
}
}
}
Future<void> _onDeclineRequest(DeclineRequest event, Emitter<ChatRequestState> emit) async {
try {
await apiClient.post('/api/mitra/chat-requests/${event.sessionId}/decline');
} catch (_) {}
emit(ChatRequestListening());
}
void _closeWebSocket() {
_wsSubscription?.cancel();
_wsSubscription = null;
_channel?.sink.close();
_channel = null;
}
@override
Future<void> close() {
_closeWebSocket();
return super.close();
}
}

91
mitra_app/lib/core/chat/extension_bloc.dart
View File

@@ -1,91 +0,0 @@
import 'package:dio/dio.dart';
import 'package:equatable/equatable.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import '../api/api_client.dart';
// Events
abstract class ExtensionEvent extends Equatable {
@override
List<Object?> get props => [];
}
class RespondToExtension extends ExtensionEvent {
final String sessionId;
final String extensionId;
final bool accepted;
RespondToExtension({required this.sessionId, required this.extensionId, required this.accepted});
@override
List<Object?> get props => [sessionId, extensionId, accepted];
}
class SubmitGoodbye extends ExtensionEvent {
final String sessionId;
final String message;
SubmitGoodbye({required this.sessionId, required this.message});
@override
List<Object?> get props => [sessionId, message];
}
// States
abstract class ExtensionState extends Equatable {
@override
List<Object?> get props => [];
}
class ExtensionIdle extends ExtensionState {}
class ExtensionResponding extends ExtensionState {}
class ExtensionShowGoodbye extends ExtensionState {}
class ExtensionSubmitting extends ExtensionState {}
class ExtensionComplete extends ExtensionState {}
class ExtensionError extends ExtensionState {
final String message;
ExtensionError(this.message);
@override
List<Object?> get props => [message];
}
// Bloc
class ExtensionBloc extends Bloc<ExtensionEvent, ExtensionState> {
final ApiClient apiClient;
ExtensionBloc({required this.apiClient}) : super(ExtensionIdle()) {
on<RespondToExtension>(_onRespond);
on<SubmitGoodbye>(_onSubmitGoodbye);
}
Future<void> _onRespond(RespondToExtension event, Emitter<ExtensionState> emit) async {
emit(ExtensionResponding());
try {
await apiClient.post('/api/mitra/chat-requests/sessions/${event.sessionId}/extend-response', data: {
'extension_id': event.extensionId,
'accepted': event.accepted,
});
if (!event.accepted) {
emit(ExtensionShowGoodbye());
} else {
emit(ExtensionIdle());
}
} on DioException catch (e) {
final code = e.response?.data?['error']?['code'];
if (code == 'EXTENSION_RESOLVED') {
// Extension already timed out or resolved — move to goodbye
emit(ExtensionShowGoodbye());
} else {
emit(ExtensionError('Gagal merespon perpanjangan.'));
}
}
}
Future<void> _onSubmitGoodbye(SubmitGoodbye event, Emitter<ExtensionState> emit) async {
emit(ExtensionSubmitting());
try {
await apiClient.post('/api/shared/sessions/${event.sessionId}/close-message', data: {
'message': event.message,
});
emit(ExtensionComplete());
} catch (e) {
emit(ExtensionError('Gagal mengirim pesan penutup.'));
}
}
}

369
mitra_app/lib/core/chat/mitra_chat_bloc.dart
View File

@@ -1,369 +0,0 @@
import 'dart:async';
import 'dart:convert';
import 'package:equatable/equatable.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:web_socket_channel/web_socket_channel.dart';
import '../api/api_client.dart';
import '../constants.dart';
// Events
abstract class MitraChatEvent extends Equatable {
@override
List<Object?> get props => [];
}
class ConnectChat extends MitraChatEvent {
final String sessionId;
ConnectChat(this.sessionId);
@override
List<Object?> get props => [sessionId];
}
class DisconnectChat extends MitraChatEvent {}
class SendMessage extends MitraChatEvent {
final String content;
SendMessage(this.content);
@override
List<Object?> get props => [content];
}
class SendTyping extends MitraChatEvent {}
class _MessageReceived extends MitraChatEvent {
final Map<String, dynamic> data;
_MessageReceived(this.data);
@override
List<Object?> get props => [data];
}
class _ConnectionError extends MitraChatEvent {}
class MarkMessagesDelivered extends MitraChatEvent {
final List<String> messageIds;
MarkMessagesDelivered(this.messageIds);
@override
List<Object?> get props => [messageIds];
}
class MarkMessagesRead extends MitraChatEvent {
final List<String> messageIds;
MarkMessagesRead(this.messageIds);
@override
List<Object?> get props => [messageIds];
}
// States
abstract class MitraChatState extends Equatable {
@override
List<Object?> get props => [];
}
class ChatInitial extends MitraChatState {}
class ChatConnecting extends MitraChatState {}
class ChatConnected extends MitraChatState {
final List<ChatMessage> messages;
final bool isOtherTyping;
final int? remainingSeconds;
final bool sessionExpired;
final bool sessionClosing;
final Map<String, dynamic>? extensionRequest;
ChatConnected({
required this.messages,
this.isOtherTyping = false,
this.remainingSeconds,
this.sessionExpired = false,
this.sessionClosing = false,
this.extensionRequest,
});
ChatConnected copyWith({
List<ChatMessage>? messages,
bool? isOtherTyping,
int? remainingSeconds,
bool? sessionExpired,
bool? sessionClosing,
Map<String, dynamic>? extensionRequest,
bool clearExtensionRequest = false,
}) {
return ChatConnected(
messages: messages ?? this.messages,
isOtherTyping: isOtherTyping ?? this.isOtherTyping,
remainingSeconds: remainingSeconds ?? this.remainingSeconds,
sessionExpired: sessionExpired ?? this.sessionExpired,
sessionClosing: sessionClosing ?? this.sessionClosing,
extensionRequest: clearExtensionRequest ? null : (extensionRequest ?? this.extensionRequest),
);
}
@override
List<Object?> get props => [messages, isOtherTyping, remainingSeconds, sessionExpired, sessionClosing, extensionRequest];
}
class ChatError extends MitraChatState {
final String message;
ChatError(this.message);
@override
List<Object?> get props => [message];
}
// Message model
class ChatMessage {
final String id;
final String senderType;
final String content;
final String type;
final String status;
final DateTime createdAt;
ChatMessage({
required this.id,
required this.senderType,
required this.content,
this.type = MessageType.text,
this.status = MessageStatus.sent,
required this.createdAt,
});
ChatMessage copyWith({String? status}) {
return ChatMessage(
id: id,
senderType: senderType,
content: content,
type: type,
status: status ?? this.status,
createdAt: createdAt,
);
}
}
// Bloc
class MitraChatBloc extends Bloc<MitraChatEvent, MitraChatState> {
final ApiClient apiClient;
WebSocketChannel? _channel;
StreamSubscription? _wsSubscription;
Timer? _typingTimer;
MitraChatBloc({required this.apiClient}) : super(ChatInitial()) {
on<ConnectChat>(_onConnect);
on<DisconnectChat>(_onDisconnect);
on<SendMessage>(_onSendMessage);
on<SendTyping>(_onSendTyping);
on<_MessageReceived>(_onMessageReceived);
on<_ConnectionError>(_onConnectionError);
on<MarkMessagesDelivered>(_onMarkDelivered);
on<MarkMessagesRead>(_onMarkRead);
}
Future<void> _onConnect(ConnectChat event, Emitter<MitraChatState> emit) async {
emit(ChatConnecting());
try {
// Check session status before connecting
final sessionInfo = await apiClient.get('/api/shared/chat/${event.sessionId}/info');
final sessionData = sessionInfo['data'] as Map<String, dynamic>?;
final sessionStatus = sessionData?['status'] as String?;
if (sessionStatus == SessionStatus.completed ||
sessionStatus == SessionStatus.cancelled ||
sessionStatus == SessionStatus.expired) {
emit(ChatError('Sesi sudah berakhir.'));
return;
}
final isClosing = sessionStatus == SessionStatus.closing;
final response = await apiClient.get('/api/shared/chat/${event.sessionId}/messages');
final messagesData = response['data'] as List<dynamic>;
final messages = messagesData.map((m) => ChatMessage(
id: m['id'] as String,
senderType: m['sender_type'] as String,
content: m['content'] as String,
type: m['type'] as String? ?? MessageType.text,
status: m['status'] as String? ?? MessageStatus.sent,
createdAt: DateTime.parse(m['created_at'] as String),
)).toList();
final user = FirebaseAuth.instance.currentUser;
final token = await user?.getIdToken();
final wsUrl = ApiClient.baseUrl
.replaceFirst('https://', 'wss://')
.replaceFirst('http://', 'ws://');
_channel = WebSocketChannel.connect(Uri.parse('$wsUrl/api/shared/ws'));
_wsSubscription = _channel!.stream.listen(
(raw) {
final data = jsonDecode(raw as String) as Map<String, dynamic>;
add(_MessageReceived(data));
},
onError: (_) => add(_ConnectionError()),
onDone: () => add(_ConnectionError()),
);
_channel!.sink.add(jsonEncode({
'type': WsMessage.auth,
'token': token,
'session_id': event.sessionId,
}));
emit(ChatConnected(
messages: messages,
sessionClosing: isClosing,
));
} catch (e) {
emit(ChatError('Gagal terhubung ke chat.'));
}
}
void _onDisconnect(DisconnectChat event, Emitter<MitraChatState> emit) {
_cleanup();
emit(ChatInitial());
}
void _onSendMessage(SendMessage event, Emitter<MitraChatState> emit) {
if (state is! ChatConnected || _channel == null) return;
final current = state as ChatConnected;
final tempId = 'temp_${DateTime.now().millisecondsSinceEpoch}';
final msg = ChatMessage(
id: tempId,
senderType: UserType.mitra,
content: event.content,
status: 'sending',
createdAt: DateTime.now(),
);
emit(current.copyWith(messages: [...current.messages, msg]));
_channel!.sink.add(jsonEncode({
'type': WsMessage.message,
'content': event.content,
'_temp_id': tempId,
}));
}
void _onSendTyping(SendTyping event, Emitter<MitraChatState> emit) {
if (_channel == null) return;
_channel!.sink.add(jsonEncode({'type': WsMessage.typing}));
}
void _onMarkDelivered(MarkMessagesDelivered event, Emitter<MitraChatState> emit) {
if (_channel == null) return;
_channel!.sink.add(jsonEncode({'type': WsMessage.delivered, 'message_ids': event.messageIds}));
}
void _onMarkRead(MarkMessagesRead event, Emitter<MitraChatState> emit) {
if (_channel == null) return;
_channel!.sink.add(jsonEncode({'type': WsMessage.read, 'message_ids': event.messageIds}));
}
void _onMessageReceived(_MessageReceived event, Emitter<MitraChatState> emit) {
if (state is! ChatConnected) return;
final current = state as ChatConnected;
final data = event.data;
final type = data['type'] as String?;
switch (type) {
case WsMessage.authOk:
break;
case WsMessage.message:
final msg = ChatMessage(
id: data['message_id'] as String,
senderType: data['sender_type'] as String,
content: data['content'] as String,
type: data['message_type'] as String? ?? MessageType.text,
status: MessageStatus.sent,
createdAt: DateTime.parse(data['created_at'] as String),
);
emit(current.copyWith(messages: [...current.messages, msg]));
add(MarkMessagesDelivered([msg.id]));
break;
case WsMessage.messageAck:
final messageId = data['message_id'] as String;
final status = data['status'] as String;
final updatedMessages = current.messages.map((m) {
if (m.status == 'sending') return m.copyWith(status: status);
return m;
}).toList();
final idx = updatedMessages.indexWhere((m) => m.status == status && m.senderType == UserType.mitra);
if (idx >= 0) {
final old = updatedMessages[idx];
updatedMessages[idx] = ChatMessage(
id: messageId,
senderType: old.senderType,
content: old.content,
type: old.type,
status: status,
createdAt: old.createdAt,
);
}
emit(current.copyWith(messages: updatedMessages));
break;
case WsMessage.messageStatus:
final messageIds = (data['message_ids'] as List<dynamic>).cast<String>();
final status = data['status'] as String;
final updatedMessages = current.messages.map((m) {
if (messageIds.contains(m.id)) return m.copyWith(status: status);
return m;
}).toList();
emit(current.copyWith(messages: updatedMessages));
break;
case WsMessage.typing:
emit(current.copyWith(isOtherTyping: true));
_typingTimer?.cancel();
_typingTimer = Timer(const Duration(seconds: 3), () {
if (state is ChatConnected) {
emit((state as ChatConnected).copyWith(isOtherTyping: false));
}
});
break;
case WsMessage.sessionTimer:
emit(current.copyWith(remainingSeconds: data['remaining_seconds'] as int?));
break;
case WsMessage.sessionExpired:
emit(current.copyWith(sessionExpired: true));
break;
case WsMessage.extensionRequest:
emit(current.copyWith(extensionRequest: data));
break;
case WsMessage.sessionResumed:
emit(current.copyWith(sessionExpired: false, sessionClosing: false, clearExtensionRequest: true));
break;
case WsMessage.sessionClosing:
emit(current.copyWith(sessionClosing: true, clearExtensionRequest: true));
break;
case WsMessage.sessionCompleted:
_cleanup();
break;
}
}
void _onConnectionError(_ConnectionError event, Emitter<MitraChatState> emit) {}
void _cleanup() {
_wsSubscription?.cancel();
_wsSubscription = null;
_channel?.sink.close();
_channel = null;
_typingTimer?.cancel();
_typingTimer = null;
}
@override
Future<void> close() {
_cleanup();
return super.close();
}
}