Ver2.0 Flutter로 실시간 채팅앱 개발하기: Socket.IO 통합으로 인터랙티브한 메시징 구현하기

Flutter로 실시간 채팅앱 개발하기: Socket.IO 통합으로 인터랙티브한 메시징 구현하기
안녕하세요 여러분! 오늘은 요즘 핫한 Flutter로 채팅앱을 만들어보는 시간을 가져볼게요~ 🔥 특히 실시간 통신의 끝판왕 Socket.IO를 어떻게 Flutter와 연결하는지 A부터 Z까지 싹 다 알려드릴게요! 개발 경험 있으신 분들도, 이제 막 시작하시는 분들도 다 같이 따라오세요! ㅎㅎ
요즘 채팅앱은 그냥 기본 기능이죠. 카카오톡, 텔레그램, 디스코드... 우리 일상에 완전 녹아들었잖아요? 근데 이런 앱들이 어떻게 실시간으로 메시지를 주고받는지 궁금하지 않으셨나요? 오늘은 그 비밀을 파헤쳐보는 시간이에요! 😎
재능넷에서도 많은 개발자분들이 모바일 앱 개발 재능을 공유하고 계시는데요, 이런 실시간 채팅 기능은 정말 수요가 많은 기술이랍니다. 여러분도 이 글을 통해 배우신 내용으로 재능넷에서 여러분만의 개발 재능을 뽐내보는 건 어떨까요? ㅋㅋㅋ
📚 목차
- Flutter와 Socket.IO 소개
- 개발 환경 설정하기
- 프로젝트 구조 잡기
- Socket.IO 서버 구축하기
- Flutter에서 Socket.IO 클라이언트 연결하기
- 채팅 UI 구현하기
- 실시간 메시지 송수신 구현
- 사용자 상태 관리하기
- 파일 및 이미지 전송 기능 추가
- 푸시 알림 구현하기
- 성능 최적화 팁
- 배포 및 테스트
1. Flutter와 Socket.IO 소개 🚀
일단 Flutter가 뭔지부터 간단히 알아볼까요? Flutter는 구글에서 만든 크로스 플랫폼 UI 프레임워크예요. 하나의 코드베이스로 iOS, Android, 웹, 데스크톱까지 개발할 수 있어서 진짜 개발자들 사이에서 대박 인기죠! ㅋㅋㅋ
Flutter는 Dart라는 언어를 사용하는데, Java나 JavaScript 경험 있으신 분들은 쉽게 적응하실 수 있을 거예요. 요즘 트렌드는 확실히 Flutter죠! 2023년 기준으로 전 세계 개발자 70만 명 이상이 사용한다고 해요. 어마어마하죠? 😮
그리고 Socket.IO는 뭘까요? 간단히 말하면 실시간 양방향 통신을 가능하게 해주는 라이브러리예요. HTTP는 클라이언트가 요청해야만 서버가 응답하는 구조인데, Socket.IO는 서버에서도 클라이언트로 먼저 데이터를 보낼 수 있어요. 채팅처럼 실시간으로 데이터가 오가야 하는 앱에 딱이죠!
Flutter와 Socket.IO의 조합은 진짜 찰떡궁합이에요! Flutter로 예쁜 UI를 만들고, Socket.IO로 실시간 통신을 구현하면 카카오톡 같은 메신저 앱도 뚝딱 만들 수 있답니다. 물론 그렇게 쉽진 않지만요... 근데 이 글 끝까지 따라오시면 여러분도 할 수 있을 거예요! 화이팅! 💪
2. 개발 환경 설정하기 ⚙️
자, 이제 본격적으로 개발 환경을 세팅해볼게요! 먼저 필요한 것들부터 쭉 나열해볼게요.
Flutter SDK 설치
Flutter 공식 사이트(flutter.dev)에서 SDK를 다운로드하고 설치해주세요. 설치 후에는 환경변수 설정도 잊지 마세요! 터미널에서 아래 명령어로 제대로 설치됐는지 확인할 수 있어요.
flutter doctor
이 명령어를 실행하면 Flutter가 필요로 하는 모든 의존성을 체크해줘요. 빨간 X 표시가 있다면 해결해주세요! ㅋㅋ
IDE 설치
Flutter 개발에는 주로 Android Studio나 VS Code를 사용해요. 저는 개인적으로 VS Code를 추천합니다! 가볍고 Flutter 플러그인도 잘 지원하거든요. 근데 취향껏 골라쓰셔도 됩니다~ 😊
Node.js 설치
Socket.IO 서버를 구축하려면 Node.js가 필요해요. node.js 공식 사이트에서 LTS 버전을 설치하세요. 설치 후에는 터미널에서 확인해보세요.
node -v
npm -v
Flutter 프로젝트 생성
이제 Flutter 프로젝트를 만들어볼게요! 터미널에서 아래 명령어를 실행하세요.
flutter create chat_app
이렇게 하면 'chat_app'이라는 이름의 프로젝트가 생성돼요. 프로젝트 폴더로 이동해서 실행해볼까요?
cd chat_app
flutter run
오 대박! 이제 기본 Flutter 앱이 에뮬레이터나 연결된 기기에서 실행될 거예요. 이게 바로 우리 채팅앱의 시작점이 될 거예요! 😍
필요한 패키지 추가하기
채팅앱을 만들기 위해 몇 가지 패키지를 추가해야 해요. pubspec.yaml 파일을 열고 dependencies 섹션에 아래 패키지들을 추가해주세요.
dependencies:
flutter:
sdk: flutter
socket_io_client: ^2.0.0
provider: ^6.0.3
shared_preferences: ^2.0.15
image_picker: ^0.8.5+3
path_provider: ^2.0.11
intl: ^0.17.0
각 패키지의 역할을 간단히 설명해드릴게요:
- socket_io_client: Flutter에서 Socket.IO를 사용하기 위한 클라이언트 라이브러리
- provider: 상태 관리를 위한 패키지
- shared_preferences: 간단한 데이터 저장을 위한 패키지
- image_picker: 갤러리나 카메라에서 이미지를 선택하기 위한 패키지
- path_provider: 파일 경로 관련 기능을 제공하는 패키지
- intl: 국제화 및 날짜/시간 포맷팅을 위한 패키지
패키지를 추가한 후에는 아래 명령어로 설치해주세요.
flutter pub get
짜잔~ 이제 기본 환경 설정은 끝났어요! 다음 단계로 넘어가볼까요? 🚀
3. 프로젝트 구조 잡기 🏗️
좋은 앱은 좋은 구조에서 시작돼요! 코드를 깔끔하게 관리하기 위해 폴더 구조를 잘 잡아봅시다. 요즘 핫한 클린 아키텍처를 적용해볼게요! ㅋㅋ
lib 폴더 안에 다음과 같은 구조를 만들어주세요:
lib/
├── main.dart
├── config/
│ └── app_config.dart
├── models/
│ ├── message_model.dart
│ └── user_model.dart
├── services/
│ ├── socket_service.dart
│ └── auth_service.dart
├── providers/
│ ├── chat_provider.dart
│ └── auth_provider.dart
├── screens/
│ ├── login_screen.dart
│ ├── chat_list_screen.dart
│ └── chat_screen.dart
├── widgets/
│ ├── message_bubble.dart
│ ├── chat_input.dart
│ └── user_avatar.dart
└── utils/
├── constants.dart
└── helpers.dart
각 폴더의 역할을 간단히 설명해드릴게요:
- config: 앱의 설정 정보를 담는 폴더
- models: 데이터 모델 클래스들을 담는 폴더
- services: API 통신, 소켓 연결 등 외부 서비스와의 연동을 담당하는 폴더
- providers: 상태 관리를 위한 Provider 클래스들을 담는 폴더
- screens: 앱의 각 화면을 담당하는 위젯들을 담는 폴더
- widgets: 재사용 가능한 작은 위젯들을 담는 폴더
- utils: 유틸리티 함수, 상수 등을 담는 폴더
이런 구조로 프로젝트를 관리하면 나중에 코드가 복잡해져도 쉽게 찾을 수 있어요. 특히 팀 프로젝트라면 더더욱 중요하죠! 재능넷에서 팀원을 구해서 함께 개발한다면 이런 구조가 협업에 정말 도움이 될 거예요. 😉
기본 모델 클래스 만들기
채팅앱에 필요한 기본 모델 클래스부터 만들어볼게요. 먼저 메시지 모델부터 만들어볼까요?
models/message_model.dart 파일을 만들고 아래 코드를 작성해주세요:
class Message {
final String id;
final String senderId;
final String receiverId;
final String content;
final DateTime timestamp;
final bool isRead;
final String? imageUrl;
Message({
required this.id,
required this.senderId,
required this.receiverId,
required this.content,
required this.timestamp,
this.isRead = false,
this.imageUrl,
});
factory Message.fromJson(Map<String, dynamic> json) {
return Message(
id: json['id'],
senderId: json['senderId'],
receiverId: json['receiverId'],
content: json['content'],
timestamp: DateTime.parse(json['timestamp']),
isRead: json['isRead'] ?? false,
imageUrl: json['imageUrl'],
);
}
Map<String, dynamic> toJson() {
return {
'id': id,
'senderId': senderId,
'receiverId': receiverId,
'content': content,
'timestamp': timestamp.toIso8601String(),
'isRead': isRead,
'imageUrl': imageUrl,
};
}
}
다음으로 사용자 모델을 만들어볼게요. models/user_model.dart 파일을 만들고 아래 코드를 작성해주세요:
class User {
final String id;
final String username;
final String? profileImage;
final bool isOnline;
final DateTime? lastSeen;
User({
required this.id,
required this.username,
this.profileImage,
this.isOnline = false,
this.lastSeen,
});
factory User.fromJson(Map<String, dynamic> json) {
return User(
id: json['id'],
username: json['username'],
profileImage: json['profileImage'],
isOnline: json['isOnline'] ?? false,
lastSeen: json['lastSeen'] != null
? DateTime.parse(json['lastSeen'])
: null,
);
}
Map<String, dynamic> toJson() {
return {
'id': id,
'username': username,
'profileImage': profileImage,
'isOnline': isOnline,
'lastSeen': lastSeen?.toIso8601String(),
};
}
}
이렇게 기본 모델 클래스를 만들었어요! fromJson과 toJson 메서드는 서버와 데이터를 주고받을 때 JSON 형식으로 변환하기 위해 필요해요. 진짜 편하죠? ㅋㅋ
다음으로 Socket.IO 서비스를 만들어볼게요. 그 전에 먼저 앱 설정부터 해볼까요?
config/app_config.dart 파일을 만들고 아래 코드를 작성해주세요:
class AppConfig {
static const String socketUrl = 'http://10.0.2.2:3000'; // 안드로이드 에뮬레이터용
// static const String socketUrl = 'http://localhost:3000'; // iOS 시뮬레이터용
// static const String socketUrl = 'https://your-production-server.com'; // 프로덕션용
}
이렇게 설정 파일을 따로 만들어두면 개발 환경과 프로덕션 환경에서 쉽게 URL을 바꿀 수 있어요. 진짜 꿀팁이죠? 😎
4. Socket.IO 서버 구축하기 🖥️
이제 채팅앱의 심장이라고 할 수 있는 Socket.IO 서버를 만들어볼게요! Node.js와 Express를 사용해서 간단한 서버를 구축해볼게요.
먼저 프로젝트 루트 폴더에 'server'라는 새 폴더를 만들고, 그 안에서 npm을 초기화해주세요.
mkdir server
cd server
npm init -y
그다음 필요한 패키지들을 설치해볼게요.
npm install express socket.io cors uuid
이제 server 폴더에 index.js 파일을 만들고 아래 코드를 작성해주세요:
const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const cors = require('cors');
const { v4: uuidv4 } = require('uuid');
const app = express();
app.use(cors());
app.use(express.json());
const server = http.createServer(app);
const io = socketIo(server, {
cors: {
origin: "*",
methods: ["GET", "POST"]
}
});
// 메모리에 메시지와 사용자 저장 (실제 앱에서는 데이터베이스 사용)
const messages = [];
const users = {};
// 소켓 연결 처리
io.on('connection', (socket) => {
console.log('New client connected:', socket.id);
// 사용자 로그인
socket.on('login', (userData) => {
const user = {
id: userData.id || uuidv4(),
username: userData.username,
socketId: socket.id,
isOnline: true,
lastSeen: new Date()
};
users[user.id] = user;
socket.userId = user.id;
// 로그인 성공 응답
socket.emit('login_success', user);
// 다른 사용자들에게 새 사용자가 접속했음을 알림
socket.broadcast.emit('user_connected', user);
// 현재 접속 중인 사용자 목록 전송
socket.emit('user_list', Object.values(users));
});
// 메시지 전송
socket.on('send_message', (messageData) => {
const message = {
id: uuidv4(),
senderId: socket.userId,
receiverId: messageData.receiverId,
content: messageData.content,
timestamp: new Date(),
isRead: false,
imageUrl: messageData.imageUrl || null
};
messages.push(message);
// 메시지 발신자에게 확인 전송
socket.emit('message_sent', message);
// 수신자에게 메시지 전달
const receiverSocket = Object.values(users).find(
user => user.id === messageData.receiverId
)?.socketId;
if (receiverSocket) {
io.to(receiverSocket).emit('new_message', message);
}
});
// 메시지 읽음 표시
socket.on('mark_as_read', (messageId) => {
const message = messages.find(m => m.id === messageId);
if (message) {
message.isRead = true;
// 발신자에게 읽음 상태 업데이트 알림
const senderSocket = Object.values(users).find(
user => user.id === message.senderId
)?.socketId;
if (senderSocket) {
io.to(senderSocket).emit('message_read', messageId);
}
}
});
// 타이핑 중 표시
socket.on('typing', (receiverId) => {
const receiverSocket = Object.values(users).find(
user => user.id === receiverId
)?.socketId;
if (receiverSocket) {
io.to(receiverSocket).emit('user_typing', socket.userId);
}
});
// 타이핑 중지 표시
socket.on('stop_typing', (receiverId) => {
const receiverSocket = Object.values(users).find(
user => user.id === receiverId
)?.socketId;
if (receiverSocket) {
io.to(receiverSocket).emit('user_stop_typing', socket.userId);
}
});
// 연결 해제
socket.on('disconnect', () => {
console.log('Client disconnected:', socket.id);
if (socket.userId && users[socket.userId]) {
users[socket.userId].isOnline = false;
users[socket.userId].lastSeen = new Date();
// 다른 사용자들에게 연결 해제 알림
socket.broadcast.emit('user_disconnected', {
userId: socket.userId,
lastSeen: users[socket.userId].lastSeen
});
}
});
});
// 서버 API 엔드포인트
app.get('/messages', (req, res) => {
res.json(messages);
});
app.get('/users', (req, res) => {
res.json(Object.values(users));
});
// 서버 시작
const PORT = process.env.PORT || 3000;
server.listen(PORT, () => {
console.log(`Server running on port ${PORT}`);
});
우와~ 이게 바로 우리 채팅앱의 서버예요! 코드가 좀 길지만 하나하나 살펴볼게요.
이 서버는 다음과 같은 기능을 제공해요:
- 사용자 로그인: 사용자가 앱에 로그인하면 사용자 정보를 저장하고 다른 사용자들에게 알려줘요.
- 메시지 전송: 사용자가 메시지를 보내면 서버가 받아서 수신자에게 전달해요.
- 메시지 읽음 표시: 메시지를 읽으면 발신자에게 알려줘요.
- 타이핑 표시: 사용자가 메시지를 입력 중일 때 상대방에게 알려줘요.
- 연결 해제 처리: 사용자가 앱을 종료하면 다른 사용자들에게 알려줘요.
실제 프로덕션 앱에서는 데이터베이스를 사용해야 하지만, 이 예제에서는 간단하게 메모리에 데이터를 저장하고 있어요. MongoDB나 Firebase를 연결하면 더 좋겠죠? ㅎㅎ
서버를 실행해볼까요?
node index.js
짜잔~ 이제 Socket.IO 서버가 3000번 포트에서 실행되고 있어요! 다음으로 Flutter 앱에서 이 서버에 연결해볼게요! 🚀
5. Flutter에서 Socket.IO 클라이언트 연결하기 🔌
이제 Flutter 앱에서 Socket.IO 서버에 연결해볼게요! 먼저 Socket.IO 서비스를 만들어볼게요.
services/socket_service.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'package:flutter/foundation.dart';
import 'package:socket_io_client/socket_io_client.dart' as IO;
import '../config/app_config.dart';
import '../models/message_model.dart';
import '../models/user_model.dart';
class SocketService {
late IO.Socket socket;
final Function(User)? onUserConnected;
final Function(User)? onUserDisconnected;
final Function(Message)? onNewMessage;
final Function(String)? onMessageRead;
final Function(String)? onUserTyping;
final Function(String)? onUserStopTyping;
final Function(List<User>)? onUserList;
SocketService({
this.onUserConnected,
this.onUserDisconnected,
this.onNewMessage,
this.onMessageRead,
this.onUserTyping,
this.onUserStopTyping,
this.onUserList,
});
void connect() {
socket = IO.io(AppConfig.socketUrl, <String, dynamic>{
'transports': ['websocket'],
'autoConnect': true,
});
socket.onConnect((_) {
debugPrint('Socket connected: ${socket.id}');
});
socket.onDisconnect((_) {
debugPrint('Socket disconnected');
});
socket.on('user_connected', (data) {
if (onUserConnected != null) {
onUserConnected!(User.fromJson(data));
}
});
socket.on('user_disconnected', (data) {
if (onUserDisconnected != null) {
final user = User(
id: data['userId'],
username: '',
isOnline: false,
lastSeen: DateTime.parse(data['lastSeen']),
);
onUserDisconnected!(user);
}
});
socket.on('new_message', (data) {
if (onNewMessage != null) {
onNewMessage!(Message.fromJson(data));
}
});
socket.on('message_read', (messageId) {
if (onMessageRead != null) {
onMessageRead!(messageId);
}
});
socket.on('user_typing', (userId) {
if (onUserTyping != null) {
onUserTyping!(userId);
}
});
socket.on('user_stop_typing', (userId) {
if (onUserStopTyping != null) {
onUserStopTyping!(userId);
}
});
socket.on('user_list', (data) {
if (onUserList != null) {
final users = (data as List).map((user) => User.fromJson(user)).toList();
onUserList!(users);
}
});
socket.onError((error) {
debugPrint('Socket error: $error');
});
}
void login(User user) {
socket.emit('login', user.toJson());
}
void sendMessage(Message message) {
socket.emit('send_message', message.toJson());
}
void markAsRead(String messageId) {
socket.emit('mark_as_read', messageId);
}
void typing(String receiverId) {
socket.emit('typing', receiverId);
}
void stopTyping(String receiverId) {
socket.emit('stop_typing', receiverId);
}
void disconnect() {
socket.disconnect();
}
}
와우! 이 서비스 클래스는 Socket.IO 서버와의 모든 통신을 담당해요. 콜백 함수들을 통해 이벤트가 발생했을 때 앱의 다른 부분에 알려줄 수 있어요. 진짜 편하죠? ㅋㅋㅋ
이제 이 서비스를 사용할 Provider를 만들어볼게요. providers/chat_provider.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'package:flutter/foundation.dart';
import '../models/message_model.dart';
import '../models/user_model.dart';
import '../services/socket_service.dart';
class ChatProvider with ChangeNotifier {
final SocketService _socketService;
User? _currentUser;
List<User> _users = [];
List<Message> _messages = [];
Map<String, bool> _typingUsers = {};
ChatProvider(this._socketService) {
_socketService.onUserConnected = _handleUserConnected;
_socketService.onUserDisconnected = _handleUserDisconnected;
_socketService.onNewMessage = _handleNewMessage;
_socketService.onMessageRead = _handleMessageRead;
_socketService.onUserTyping = _handleUserTyping;
_socketService.onUserStopTyping = _handleUserStopTyping;
_socketService.onUserList = _handleUserList;
_socketService.connect();
}
// Getters
User? get currentUser => _currentUser;
List<User> get users => _users;
List<Message> get messages => _messages;
bool isUserTyping(String userId) => _typingUsers[userId] ?? false;
// 사용자 로그인
void login(String username) {
final user = User(
id: DateTime.now().millisecondsSinceEpoch.toString(),
username: username,
isOnline: true,
);
_socketService.login(user);
_currentUser = user;
notifyListeners();
}
// 메시지 전송
void sendMessage(String receiverId, String content, {String? imageUrl}) {
if (_currentUser == null) return;
final message = Message(
id: DateTime.now().millisecondsSinceEpoch.toString(),
senderId: _currentUser!.id,
receiverId: receiverId,
content: content,
timestamp: DateTime.now(),
imageUrl: imageUrl,
);
_socketService.sendMessage(message);
_messages.add(message);
notifyListeners();
}
// 메시지 읽음 표시
void markMessageAsRead(String messageId) {
_socketService.markAsRead(messageId);
final index = _messages.indexWhere((m) => m.id == messageId);
if (index != -1) {
final message = _messages[index];
_messages[index] = Message(
id: message.id,
senderId: message.senderId,
receiverId: message.receiverId,
content: message.content,
timestamp: message.timestamp,
isRead: true,
imageUrl: message.imageUrl,
);
notifyListeners();
}
}
// 타이핑 시작
void startTyping(String receiverId) {
_socketService.typing(receiverId);
}
// 타이핑 중지
void stopTyping(String receiverId) {
_socketService.stopTyping(receiverId);
}
// 이벤트 핸들러들
void _handleUserConnected(User user) {
final index = _users.indexWhere((u) => u.id == user.id);
if (index != -1) {
_users[index] = user;
} else {
_users.add(user);
}
notifyListeners();
}
void _handleUserDisconnected(User user) {
final index = _users.indexWhere((u) => u.id == user.id);
if (index != -1) {
_users[index] = User(
id: _users[index].id,
username: _users[index].username,
profileImage: _users[index].profileImage,
isOnline: false,
lastSeen: user.lastSeen,
);
notifyListeners();
}
}
void _handleNewMessage(Message message) {
_messages.add(message);
notifyListeners();
}
void _handleMessageRead(String messageId) {
final index = _messages.indexWhere((m) => m.id == messageId);
if (index != -1) {
final message = _messages[index];
_messages[index] = Message(
id: message.id,
senderId: message.senderId,
receiverId: message.receiverId,
content: message.content,
timestamp: message.timestamp,
isRead: true,
imageUrl: message.imageUrl,
);
notifyListeners();
}
}
void _handleUserTyping(String userId) {
_typingUsers[userId] = true;
notifyListeners();
}
void _handleUserStopTyping(String userId) {
_typingUsers[userId] = false;
notifyListeners();
}
void _handleUserList(List<User> users) {
_users = users;
notifyListeners();
}
@override
void dispose() {
_socketService.disconnect();
super.dispose();
}
}
이 Provider 클래스는 앱의 상태를 관리하고 Socket.IO 서비스와 UI 사이의 다리 역할을 해요. Provider 패턴을 사용하면 상태 관리가 정말 편해져요! ㅋㅋ
이제 main.dart 파일을 수정해서 Provider를 등록해볼게요:
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'services/socket_service.dart';
import 'providers/chat_provider.dart';
import 'screens/login_screen.dart';
void main() {
runApp(MyApp());
}
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MultiProvider(
providers: [
Provider(
create: (_) => SocketService(),
),
ChangeNotifierProxyProvider<SocketService, ChatProvider>(
create: (context) => ChatProvider(context.read<SocketService>()),
update: (context, socketService, previous) =>
previous ?? ChatProvider(socketService),
),
],
child: MaterialApp(
title: 'Flutter Chat App',
theme: ThemeData(
primarySwatch: Colors.blue,
visualDensity: VisualDensity.adaptivePlatformDensity,
),
home: LoginScreen(),
),
);
}
}
이제 Socket.IO 서버와 Flutter 앱이 연결될 준비가 되었어요! 다음으로 UI를 구현해볼게요! 😊
6. 채팅 UI 구현하기 🎨
이제 채팅앱의 UI를 구현해볼게요! 먼저 로그인 화면부터 만들어볼까요?
screens/login_screen.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../providers/chat_provider.dart';
import 'chat_list_screen.dart';
class LoginScreen extends StatefulWidget {
@override
_LoginScreenState createState() => _LoginScreenState();
}
class _LoginScreenState extends State<LoginScreen> {
final _usernameController = TextEditingController();
bool _isLoading = false;
void _login() {
if (_usernameController.text.trim().isEmpty) {
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(content: Text('사용자 이름을 입력해주세요!')),
);
return;
}
setState(() {
_isLoading = true;
});
// Provider를 통해 로그인 처리
final chatProvider = Provider.of<ChatProvider>(context, listen: false);
chatProvider.login(_usernameController.text.trim());
// 로그인 후 채팅 목록 화면으로 이동
Navigator.of(context).pushReplacement(
MaterialPageRoute(builder: (_) => ChatListScreen()),
);
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text('로그인'),
),
body: Padding(
padding: const EdgeInsets.all(16.0),
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Text(
'채팅앱에 오신 것을 환영합니다!',
style: TextStyle(
fontSize: 24,
fontWeight: FontWeight.bold,
),
),
SizedBox(height: 30),
TextField(
controller: _usernameController,
decoration: InputDecoration(
labelText: '사용자 이름',
border: OutlineInputBorder(),
prefixIcon: Icon(Icons.person),
),
),
SizedBox(height: 20),
ElevatedButton(
onPressed: _isLoading ? null : _login,
child: _isLoading
? CircularProgressIndicator(color: Colors.white)
: Text('입장하기'),
style: ElevatedButton.styleFrom(
minimumSize: Size(double.infinity, 50),
),
),
],
),
),
);
}
@override
void dispose() {
_usernameController.dispose();
super.dispose();
}
}
이제 채팅 목록 화면을 만들어볼게요. screens/chat_list_screen.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../providers/chat_provider.dart';
import '../models/user_model.dart';
import 'chat_screen.dart';
class ChatListScreen extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text('채팅 목록'),
actions: [
IconButton(
icon: Icon(Icons.exit_to_app),
onPressed: () {
Navigator.of(context).pushReplacement(
MaterialPageRoute(builder: (_) => LoginScreen()),
);
},
),
],
),
body: Consumer<ChatProvider>(
builder: (context, chatProvider, child) {
final currentUser = chatProvider.currentUser;
if (currentUser == null) {
return Center(child: Text('로그인이 필요합니다.'));
}
final users = chatProvider.users
.where((user) => user.id != currentUser.id)
.toList();
if (users.isEmpty) {
return Center(child: Text('접속 중인 사용자가 없습니다.'));
}
return ListView.builder(
itemCount: users.length,
itemBuilder: (context, index) {
final user = users[index];
return _buildUserListItem(context, user);
},
);
},
),
);
}
Widget _buildUserListItem(BuildContext context, User user) {
return ListTile(
leading: CircleAvatar(
backgroundColor: user.isOnline ? Colors.green : Colors.grey,
child: Text(
user.username.isNotEmpty ? user.username[0].toUpperCase() : '?',
style: TextStyle(color: Colors.white),
),
),
title: Text(user.username),
subtitle: Text(
user.isOnline ? '접속 중' : '마지막 접속: ${_formatLastSeen(user.lastSeen)}',
),
trailing: Icon(Icons.chat_bubble_outline),
onTap: () {
Navigator.of(context).push(
MaterialPageRoute(
builder: (_) => ChatScreen(user: user),
),
);
},
);
}
String _formatLastSeen(DateTime? lastSeen) {
if (lastSeen == null) return '알 수 없음';
final now = DateTime.now();
final difference = now.difference(lastSeen);
if (difference.inMinutes < 1) {
return '방금 전';
} else if (difference.inHours < 1) {
return '${difference.inMinutes}분 전';
} else if (difference.inDays < 1) {
return '${difference.inHours}시간 전';
} else {
return '${difference.inDays}일 전';
}
}
}
마지막으로 채팅 화면을 만들어볼게요. screens/chat_screen.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'dart:async';
import '../providers/chat_provider.dart';
import '../models/user_model.dart';
import '../models/message_model.dart';
import '../widgets/message_bubble.dart';
import '../widgets/chat_input.dart';
class ChatScreen extends StatefulWidget {
final User user;
ChatScreen({required this.user});
@override
_ChatScreenState createState() => _ChatScreenState();
}
class _ChatScreenState extends State<ChatScreen> {
Timer? _typingTimer;
bool _isTyping = false;
@override
void dispose() {
_typingTimer?.cancel();
super.dispose();
}
void _handleTyping(ChatProvider chatProvider) {
if (!_isTyping) {
setState(() {
_isTyping = true;
});
chatProvider.startTyping(widget.user.id);
}
_typingTimer?.cancel();
_typingTimer = Timer(Duration(seconds: 2), () {
setState(() {
_isTyping = false;
});
chatProvider.stopTyping(widget.user.id);
});
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Row(
children: [
CircleAvatar(
backgroundColor: widget.user.isOnline ? Colors.green : Colors.grey,
radius: 16,
child: Text(
widget.user.username.isNotEmpty
? widget.user.username[0].toUpperCase()
: '?',
style: TextStyle(color: Colors.white, fontSize: 14),
),
),
SizedBox(width: 8),
Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
widget.user.username,
style: TextStyle(fontSize: 16),
),
Consumer<ChatProvider>(
builder: (context, chatProvider, child) {
final isTyping = chatProvider.isUserTyping(widget.user.id);
return Text(
isTyping
? '입력 중...'
: (widget.user.isOnline ? '접속 중' : '오프라인'),
style: TextStyle(
fontSize: 12,
color: Colors.white70,
),
);
},
),
],
),
],
),
),
body: Column(
children: [
Expanded(
child: Consumer<ChatProvider>(
builder: (context, chatProvider, child) {
final currentUser = chatProvider.currentUser;
if (currentUser == null) {
return Center(child: Text('로그인이 필요합니다.'));
}
final messages = chatProvider.messages.where((message) {
return (message.senderId == currentUser.id &&
message.receiverId == widget.user.id) ||
(message.senderId == widget.user.id &&
message.receiverId == currentUser.id);
}).toList();
messages.sort((a, b) => a.timestamp.compareTo(b.timestamp));
if (messages.isEmpty) {
return Center(
child: Text('아직 대화 내용이 없습니다. 첫 메시지를 보내보세요!'),
);
}
return ListView.builder(
padding: EdgeInsets.all(8),
itemCount: messages.length,
itemBuilder: (context, index) {
final message = messages[index];
final isMe = message.senderId == currentUser.id;
// 읽지 않은 메시지 읽음 표시
if (!isMe && !message.isRead) {
chatProvider.markMessageAsRead(message.id);
}
return MessageBubble(
message: message,
isMe: isMe,
);
},
);
},
),
),
Consumer<ChatProvider>(
builder: (context, chatProvider, child) {
return ChatInput(
onSend: (message) {
chatProvider.sendMessage(widget.user.id, message);
},
onTyping: () {
_handleTyping(chatProvider);
},
);
},
),
],
),
);
}
}
이제 메시지 버블과 채팅 입력 위젯을 만들어볼게요. widgets/message_bubble.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'package:flutter/material.dart';
import 'package:intl/intl.dart';
import '../models/message_model.dart';
class MessageBubble extends StatelessWidget {
final Message message;
final bool isMe;
MessageBubble({
required this.message,
required this.isMe,
});
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.symmetric(vertical: 4),
child: Row(
mainAxisAlignment: isMe ? MainAxisAlignment.end : MainAxisAlignment.start,
children: [
if (!isMe) SizedBox(width: 12),
Container(
constraints: BoxConstraints(
maxWidth: MediaQuery.of(context).size.width * 0.7,
),
padding: EdgeInsets.symmetric(horizontal: 16, vertical: 10),
decoration: BoxDecoration(
color: isMe ? Colors.blue : Colors.grey[300],
borderRadius: BorderRadius.circular(20),
),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
if (message.imageUrl != null && message.imageUrl!.isNotEmpty)
ClipRRect(
borderRadius: BorderRadius.circular(12),
child: Image.network(
message.imageUrl!,
width: double.infinity,
fit: BoxFit.cover,
loadingBuilder: (context, child, loadingProgress) {
if (loadingProgress == null) return child;
return Center(
child: CircularProgressIndicator(),
);
},
errorBuilder: (context, error, stackTrace) {
return Container(
height: 100,
color: Colors.grey[200],
child: Center(
child: Icon(Icons.error),
),
);
},
),
),
if (message.imageUrl != null &&
message.imageUrl!.isNotEmpty &&
message.content.isNotEmpty)
SizedBox(height: 8),
Text(
message.content,
style: TextStyle(
color: isMe ? Colors.white : Colors.black,
),
),
SizedBox(height: 4),
Row(
mainAxisSize: MainAxisSize.min,
children: [
Text(
DateFormat('HH:mm').format(message.timestamp),
style: TextStyle(
color: isMe ? Colors.white70 : Colors.black54,
fontSize: 10,
),
),
SizedBox(width: 4),
if (isMe)
Icon(
message.isRead ? Icons.done_all : Icons.done,
size: 12,
color: Colors.white70,
),
],
),
],
),
),
if (isMe) SizedBox(width: 12),
],
),
);
}
}
마지막으로 채팅 입력 위젯을 만들어볼게요. widgets/chat_input.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'package:flutter/material.dart';
import 'package:image_picker/image_picker.dart';
import 'dart:io';
class ChatInput extends StatefulWidget {
final Function(String) onSend;
final Function() onTyping;
final Function(File)? onImageSelected;
ChatInput({
required this.onSend,
required this.onTyping,
this.onImageSelected,
});
@override
_ChatInputState createState() => _ChatInputState();
}
class _ChatInputState extends State<ChatInput> {
final _textController = TextEditingController();
final _imagePicker = ImagePicker();
void _handleSend() {
final text = _textController.text.trim();
if (text.isNotEmpty) {
widget.onSend(text);
_textController.clear();
}
}
Future<void> _pickImage() async {
try {
final pickedFile = await _imagePicker.pickImage(
source: ImageSource.gallery,
imageQuality: 70,
);
if (pickedFile != null && widget.onImageSelected != null) {
widget.onImageSelected!(File(pickedFile.path));
}
} catch (e) {
print('Error picking image: $e');
}
}
@override
Widget build(BuildContext context) {
return Container(
padding: EdgeInsets.symmetric(horizontal: 8, vertical: 4),
decoration: BoxDecoration(
color: Colors.white,
boxShadow: [
BoxShadow(
color: Colors.black12,
offset: Offset(0, -1),
blurRadius: 4,
),
],
),
child: Row(
children: [
IconButton(
icon: Icon(Icons.photo),
onPressed: _pickImage,
),
Expanded(
child: TextField(
controller: _textController,
decoration: InputDecoration(
hintText: '메시지를 입력하세요...',
border: InputBorder.none,
),
onChanged: (_) => widget.onTyping(),
textCapitalization: TextCapitalization.sentences,
),
),
IconButton(
icon: Icon(Icons.send, color: Colors.blue),
onPressed: _handleSend,
),
],
),
);
}
@override
void dispose() {
_textController.dispose();
super.dispose();
}
}
짜잔~ 이제 기본적인 채팅 UI가 완성되었어요! Flutter의 강력한 위젯 시스템을 활용하면 이렇게 예쁜 UI를 쉽게 만들 수 있어요. 진짜 Flutter 최고! ㅋㅋㅋ
7. 실시간 메시지 송수신 구현 📨
이제 실시간 메시지 송수신 기능을 더 자세히 살펴볼게요! 이미 기본적인 코드는 작성했지만, 몇 가지 기능을 더 추가해볼게요.
메시지 전송 상태 표시하기
메시지를 보냈을 때 전송 중, 전송 완료, 읽음 상태를 표시하면 사용자 경험이 더 좋아져요. providers/chat_provider.dart 파일에 아래 코드를 추가해주세요:
enum MessageStatus {
sending,
sent,
delivered,
read,
failed,
}
class MessageWithStatus extends Message {
final MessageStatus status;
MessageWithStatus({
required String id,
required String senderId,
required String receiverId,
required String content,
required DateTime timestamp,
bool isRead = false,
String? imageUrl,
this.status = MessageStatus.sending,
}) : super(
id: id,
senderId: senderId,
receiverId: receiverId,
content: content,
timestamp: timestamp,
isRead: isRead,
imageUrl: imageUrl,
);
factory MessageWithStatus.fromMessage(Message message, {
MessageStatus status = MessageStatus.sent,
}) {
return MessageWithStatus(
id: message.id,
senderId: message.senderId,
receiverId: message.receiverId,
content: message.content,
timestamp: message.timestamp,
isRead: message.isRead,
imageUrl: message.imageUrl,
status: status,
);
}
MessageWithStatus copyWith({
String? id,
String? senderId,
String? receiverId,
String? content,
DateTime? timestamp,
bool? isRead,
String? imageUrl,
MessageStatus? status,
}) {
return MessageWithStatus(
id: id ?? this.id,
senderId: senderId ?? this.senderId,
receiverId: receiverId ?? this.receiverId,
content: content ?? this.content,
timestamp: timestamp ?? this.timestamp,
isRead: isRead ?? this.isRead,
imageUrl: imageUrl ?? this.imageUrl,
status: status ?? this.status,
);
}
}
그리고 ChatProvider 클래스의 메시지 리스트 타입을 변경해주세요:
List<MessageWithStatus> _messages = [];
이제 메시지 전송 메서드를 수정해볼게요:
void sendMessage(String receiverId, String content, {String? imageUrl}) {
if (_currentUser == null) return;
final messageId = DateTime.now().millisecondsSinceEpoch.toString();
final message = MessageWithStatus(
id: messageId,
senderId: _currentUser!.id,
receiverId: receiverId,
content: content,
timestamp: DateTime.now(),
imageUrl: imageUrl,
status: MessageStatus.sending,
);
// 메시지를 목록에 추가 (sending 상태)
_messages.add(message);
notifyListeners();
// 서버로 메시지 전송
_socketService.sendMessage(message);
// 소켓 이벤트 핸들러 추가
_socketService.socket.once('message_sent', (data) {
if (data['id'] == messageId) {
final index = _messages.indexWhere((m) => m.id == messageId);
if (index != -1) {
_messages[index] = _messages[index].copyWith(status: MessageStatus.sent);
notifyListeners();
}
}
});
// 5초 후에도 응답이 없으면 실패로 처리
Future.delayed(Duration(seconds: 5), () {
final index = _messages.indexWhere((m) => m.id == messageId);
if (index != -1 && _messages[index].status == MessageStatus.sending) {
_messages[index] = _messages[index].copyWith(status: MessageStatus.failed);
notifyListeners();
}
});
}
이제 메시지 버블 위젯을 수정해서 상태를 표시해볼게요. widgets/message_bubble.dart 파일을 수정해주세요:
import 'package:flutter/material.dart';
import 'package:intl/intl.dart';
import '../models/message_model.dart';
import '../providers/chat_provider.dart';
class MessageBubble extends StatelessWidget {
final dynamic message;
final bool isMe;
MessageBubble({
required this.message,
required this.isMe,
});
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.symmetric(vertical: 4),
child: Row(
mainAxisAlignment: isMe ? MainAxisAlignment.end : MainAxisAlignment.start,
children: [
if (!isMe) SizedBox(width: 12),
Container(
constraints: BoxConstraints(
maxWidth: MediaQuery.of(context).size.width * 0.7,
),
padding: EdgeInsets.symmetric(horizontal: 16, vertical: 10),
decoration: BoxDecoration(
color: isMe ? Colors.blue : Colors.grey[300],
borderRadius: BorderRadius.circular(20),
),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
if (message.imageUrl != null && message.imageUrl!.isNotEmpty)
ClipRRect(
borderRadius: BorderRadius.circular(12),
child: Image.network(
message.imageUrl!,
width: double.infinity,
fit: BoxFit.cover,
loadingBuilder: (context, child, loadingProgress) {
if (loadingProgress == null) return child;
return Center(
child: CircularProgressIndicator(),
);
},
errorBuilder: (context, error, stackTrace) {
return Container(
height: 100,
color: Colors.grey[200],
child: Center(
child: Icon(Icons.error),
),
);
},
),
),
if (message.imageUrl != null &&
message.imageUrl!.isNotEmpty &&
message.content.isNotEmpty)
SizedBox(height: 8),
Text(
message.content,
style: TextStyle(
color: isMe ? Colors.white : Colors.black,
),
),
SizedBox(height: 4),
Row(
mainAxisSize: MainAxisSize.min,
children: [
Text(
DateFormat('HH:mm').format(message.timestamp),
style: TextStyle(
color: isMe ? Colors.white70 : Colors.black54,
fontSize: 10,
),
),
SizedBox(width: 4),
if (isMe) _buildStatusIcon(),
],
),
],
),
),
if (isMe) SizedBox(width: 12),
],
),
);
}
Widget _buildStatusIcon() {
if (message is MessageWithStatus) {
final status = (message as MessageWithStatus).status;
switch (status) {
case MessageStatus.sending:
return Icon(
Icons.access_time,
size: 12,
color: Colors.white70,
);
case MessageStatus.sent:
return Icon(
Icons.done,
size: 12,
color: Colors.white70,
);
case MessageStatus.delivered:
return Icon(
Icons.done_all,
size: 12,
color: Colors.white70,
);
case MessageStatus.read:
return Icon(
Icons.done_all,
size: 12,
color: Colors.lightBlueAccent,
);
case MessageStatus.failed:
return Icon(
Icons.error_outline,
size: 12,
color: Colors.redAccent,
);
default:
return SizedBox();
}
} else {
return Icon(
message.isRead ? Icons.done_all : Icons.done,
size: 12,
color: Colors.white70,
);
}
}
}
메시지 재전송 기능 추가하기
메시지 전송이 실패했을 때 재전송할 수 있는 기능을 추가해볼게요. MessageBubble 위젯을 수정해주세요:
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.symmetric(vertical: 4),
child: Row(
mainAxisAlignment: isMe ? MainAxisAlignment.end : MainAxisAlignment.start,
children: [
if (!isMe) SizedBox(width: 12),
Container(
constraints: BoxConstraints(
maxWidth: MediaQuery.of(context).size.width * 0.7,
),
padding: EdgeInsets.symmetric(horizontal: 16, vertical: 10),
decoration: BoxDecoration(
color: isMe ? Colors.blue : Colors.grey[300],
borderRadius: BorderRadius.circular(20),
),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
// 이미지 및 내용 부분은 동일
Row(
mainAxisSize: MainAxisSize.min,
children: [
Text(
DateFormat('HH:mm').format(message.timestamp),
style: TextStyle(
color: isMe ? Colors.white70 : Colors.black54,
fontSize: 10,
),
),
SizedBox(width: 4),
if (isMe) _buildStatusIcon(context),
],
),
],
),
),
if (isMe) SizedBox(width: 12),
],
),
);
}
Widget _buildStatusIcon(BuildContext context) {
if (message is MessageWithStatus) {
final status = (message as MessageWithStatus).status;
if (status == MessageStatus.failed) {
return GestureDetector(
onTap: () {
// 재전송 다이얼로그 표시
showDialog(
context: context,
builder: (context) => AlertDialog(
title: Text('메시지 재전송'),
content: Text('이 메시지를 다시 전송하시겠습니까?'),
actions: [
TextButton(
onPressed: () => Navigator.of(context).pop(),
child: Text('취소'),
),
TextButton(
onPressed: () {
Navigator.of(context).pop();
// Provider를 통해 메시지 재전송
Provider.of<ChatProvider>(context, listen: false)
.resendMessage(message.id);
},
child: Text('재전송'),
),
],
),
);
},
child: Icon(
Icons.error_outline,
size: 12,
color: Colors.redAccent,
),
);
}
// 나머지 상태 아이콘은 동일
}
return Icon(
message.isRead ? Icons.done_all : Icons.done,
size: 12,
color: Colors.white70,
);
}
그리고 ChatProvider에 재전송 메서드를 추가해주세요:
void resendMessage(String messageId) {
final index = _messages.indexWhere((m) => m.id == messageId);
if (index != -1) {
final message = _messages[index];
// 상태를 sending으로 변경
_messages[index] = message.copyWith(status: MessageStatus.sending);
notifyListeners();
// 서버로 메시지 재전송
_socketService.sendMessage(message);
// 소켓 이벤트 핸들러 추가
_socketService.socket.once('message_sent', (data) {
if (data['id'] == messageId) {
final updatedIndex = _messages.indexWhere((m) => m.id == messageId);
if (updatedIndex != -1) {
_messages[updatedIndex] = _messages[updatedIndex].copyWith(
status: MessageStatus.sent
);
notifyListeners();
}
}
});
// 5초 후에도 응답이 없으면 실패로 처리
Future.delayed(Duration(seconds: 5), () {
final updatedIndex = _messages.indexWhere((m) => m.id == messageId);
if (updatedIndex != -1 &&
_messages[updatedIndex].status == MessageStatus.sending) {
_messages[updatedIndex] = _messages[updatedIndex].copyWith(
status: MessageStatus.failed
);
notifyListeners();
}
});
}
}
이렇게 메시지 상태를 관리하면 사용자에게 더 좋은 경험을 제공할 수 있어요. 메시지가 전송 중인지, 전송 완료됐는지, 읽혔는지 알 수 있으니까요! 카카오톡이나 텔레그램 같은 앱들도 이런 기능을 제공하죠. ㅋㅋ
오프라인 메시지 큐 구현하기
인터넷 연결이 끊겼을 때도 메시지를 보낼 수 있게 오프라인 메시지 큐를 구현해볼게요. 먼저 utils/network_helper.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'dart:async';
import 'package:connectivity_plus/connectivity_plus.dart';
class NetworkHelper {
final Connectivity _connectivity = Connectivity();
bool _isConnected = true;
StreamController<bool> connectionChangeController = StreamController.broadcast();
bool get isConnected => _isConnected;
Stream<bool> get connectionChange => connectionChangeController.stream;
void initialize() {
_connectivity.onConnectivityChanged.listen(_connectionChange);
checkConnection();
}
Future<void> checkConnection() async {
final connectivityResult = await _connectivity.checkConnectivity();
_handleConnectivityResult(connectivityResult);
}
void _connectionChange(ConnectivityResult result) {
_handleConnectivityResult(result);
}
void _handleConnectivityResult(ConnectivityResult result) {
_isConnected = result != ConnectivityResult.none;
connectionChangeController.add(_isConnected);
}
void dispose() {
connectionChangeController.close();
}
}
이제 pubspec.yaml 파일에 connectivity_plus 패키지를 추가해주세요:
dependencies:
flutter:
sdk: flutter
socket_io_client: ^2.0.0
provider: ^6.0.3
shared_preferences: ^2.0.15
image_picker: ^0.8.5+3
path_provider: ^2.0.11
intl: ^0.17.0
connectivity_plus: ^3.0.2
그리고 ChatProvider에 오프라인 메시지 큐를 구현해볼게요:
class ChatProvider with ChangeNotifier {
final SocketService _socketService;
final NetworkHelper _networkHelper = NetworkHelper();
User? _currentUser;
List<MessageWithStatus> _messages = [];
List<MessageWithStatus> _offlineQueue = [];
Map<String, bool> _typingUsers = {};
List<User> _users = [];
ChatProvider(this._socketService) {
_socketService.onUserConnected = _handleUserConnected;
_socketService.onUserDisconnected = _handleUserDisconnected;
_socketService.onNewMessage = _handleNewMessage;
_socketService.onMessageRead = _handleMessageRead;
_socketService.onUserTyping = _handleUserTyping;
_socketService.onUserStopTyping = _handleUserStopTyping;
_socketService.onUserList = _handleUserList;
_socketService.connect();
_networkHelper.initialize();
_networkHelper.connectionChange.listen(_handleConnectionChange);
}
void _handleConnectionChange(bool isConnected) {
if (isConnected) {
// 연결이 복구되면 오프라인 큐의 메시지들을 전송
_processOfflineQueue();
}
}
void _processOfflineQueue() {
if (_offlineQueue.isEmpty) return;
// 오프라인 큐의 메시지들을 하나씩 전송
final queueCopy = List<MessageWithStatus>.from(_offlineQueue);
_offlineQueue.clear();
for (final message in queueCopy) {
sendMessage(
message.receiverId,
message.content,
imageUrl: message.imageUrl,
existingMessageId: message.id,
);
}
}
void sendMessage(
String receiverId,
String content, {
String? imageUrl,
String? existingMessageId,
}) {
if (_currentUser == null) return;
final messageId = existingMessageId ?? DateTime.now().millisecondsSinceEpoch.toString();
final message = MessageWithStatus(
id: messageId,
senderId: _currentUser!.id,
receiverId: receiverId,
content: content,
timestamp: DateTime.now(),
imageUrl: imageUrl,
status: MessageStatus.sending,
);
// 메시지를 목록에 추가 (sending 상태)
if (existingMessageId == null) {
_messages.add(message);
} else {
final index = _messages.indexWhere((m) => m.id == existingMessageId);
if (index != -1) {
_messages[index] = message;
} else {
_messages.add(message);
}
}
notifyListeners();
// 인터넷 연결 확인
if (!_networkHelper.isConnected) {
// 오프라인 상태면 큐에 추가하고 상태 업데이트
_offlineQueue.add(message);
final index = _messages.indexWhere((m) => m.id == messageId);
if (index != -1) {
_messages[index] = _messages[index].copyWith(
status: MessageStatus.failed,
);
notifyListeners();
}
return;
}
// 서버로 메시지 전송
_socketService.sendMessage(message);
// 소켓 이벤트 핸들러 추가
_socketService.socket.once('message_sent', (data) {
if (data['id'] == messageId) {
final index = _messages.indexWhere((m) => m.id == messageId);
if (index != -1) {
_messages[index] = _messages[index].copyWith(
status: MessageStatus.sent,
);
notifyListeners();
}
}
});
// 5초 후에도 응답이 없으면 실패로 처리
Future.delayed(Duration(seconds: 5), () {
final index = _messages.indexWhere((m) => m.id == messageId);
if (index != -1 && _messages[index].status == MessageStatus.sending) {
_messages[index] = _messages[index].copyWith(
status: MessageStatus.failed,
);
notifyListeners();
}
});
}
// 나머지 메서드들은 동일
@override
void dispose() {
_networkHelper.dispose();
_socketService.disconnect();
super.dispose();
}
}
이제 인터넷 연결이 끊겨도 메시지를 보낼 수 있고, 연결이 복구되면 자동으로 전송되는 기능이 구현되었어요! 이런 기능은 실제 메신저 앱에서 정말 중요한 기능이에요. 사용자 경험을 크게 향상시키죠! 😊
8. 사용자 상태 관리하기 👥
채팅앱에서 사용자의 온라인/오프라인 상태와 마지막 접속 시간을 표시하는 것은 정말 중요해요. 이미 기본적인 코드는 작성했지만, 몇 가지 기능을 더 추가해볼게요!
사용자 상태 표시 개선하기
사용자의 상태를 더 자세히 표시해볼게요. models/user_model.dart 파일에 UserStatus 열거형을 추가해주세요:
enum UserStatus {
online,
away,
busy,
offline,
}
class User {
final String id;
final String username;
final String? profileImage;
final UserStatus status;
final DateTime? lastSeen;
User({
required this.id,
required this.username,
this.profileImage,
this.status = UserStatus.offline,
this.lastSeen,
});
factory User.fromJson(Map<String, dynamic> json) {
return User(
id: json['id'],
username: json['username'],
profileImage: json['profileImage'],
status: _parseStatus(json['status'] ?? 'offline'),
lastSeen: json['lastSeen'] != null
? DateTime.parse(json['lastSeen'])
: null,
);
}
Map<String, dynamic> toJson() {
return {
'id': id,
'username': username,
'profileImage': profileImage,
'status': _statusToString(status),
'lastSeen': lastSeen?.toIso8601String(),
};
}
static UserStatus _parseStatus(String status) {
switch (status) {
case 'online':
return UserStatus.online;
case 'away':
return UserStatus.away;
case 'busy':
return UserStatus.busy;
case 'offline':
default:
return UserStatus.offline;
}
}
static String _statusToString(UserStatus status) {
switch (status) {
case UserStatus.online:
return 'online';
case UserStatus.away:
return 'away';
case UserStatus.busy:
return 'busy';
case UserStatus.offline:
return 'offline';
}
}
}
이제 서버 코드도 수정해야 해요. server/index.js 파일에서 사용자 상태 관련 코드를 수정해주세요:
// 사용자 로그인
socket.on('login', (userData) => {
const user = {
id: userData.id || uuidv4(),
username: userData.username,
socketId: socket.id,
status: userData.status || 'online',
lastSeen: new Date()
};
users[user.id] = user;
socket.userId = user.id;
// 로그인 성공 응답
socket.emit('login_success', user);
// 다른 사용자들에게 새 사용자가 접속했음을 알림
socket.broadcast.emit('user_connected', user);
// 현재 접속 중인 사용자 목록 전송
socket.emit('user_list', Object.values(users));
});
// 사용자 상태 변경
socket.on('update_status', (statusData) => {
if (socket.userId && users[socket.userId]) {
users[socket.userId].status = statusData.status;
// 다른 사용자들에게 상태 변경 알림
socket.broadcast.emit('user_status_updated', {
userId: socket.userId,
status: statusData.status
});
}
});
이제 Flutter 앱에서 사용자 상태를 업데이트하고 표시하는 기능을 추가해볼게요. services/socket_service.dart 파일에 아래 메서드를 추가해주세요:
void updateStatus(UserStatus status) {
socket.emit('update_status', {
'status': _statusToString(status),
});
}
String _statusToString(UserStatus status) {
switch (status) {
case UserStatus.online:
return 'online';
case UserStatus.away:
return 'away';
case UserStatus.busy:
return 'busy';
case UserStatus.offline:
return 'offline';
}
}
그리고 SocketService 클래스에 새로운 콜백 함수를 추가해주세요:
final Function(String, UserStatus)? onUserStatusUpdated;
SocketService({
this.onUserConnected,
this.onUserDisconnected,
this.onNewMessage,
this.onMessageRead,
this.onUserTyping,
this.onUserStopTyping,
this.onUserList,
this.onUserStatusUpdated,
});
그리고 connect 메서드에 이벤트 리스너를 추가해주세요:
socket.on('user_status_updated', (data) {
if (onUserStatusUpdated != null) {
final userId = data['userId'];
final status = _parseStatus(data['status']);
onUserStatusUpdated!(userId, status);
}
});
UserStatus _parseStatus(String status) {
switch (status) {
case 'online':
return UserStatus.online;
case 'away':
return UserStatus.away;
case 'busy':
return UserStatus.busy;
case 'offline':
default:
return UserStatus.offline;
}
}
이제 ChatProvider에 상태 업데이트 기능을 추가해볼게요:
ChatProvider(this._socketService) {
_socketService.onUserConnected = _handleUserConnected;
_socketService.onUserDisconnected = _handleUserDisconnected;
_socketService.onNewMessage = _handleNewMessage;
_socketService.onMessageRead = _handleMessageRead;
_socketService.onUserTyping = _handleUserTyping;
_socketService.onUserStopTyping = _handleUserStopTyping;
_socketService.onUserList = _handleUserList;
_socketService.onUserStatusUpdated = _handleUserStatusUpdated;
_socketService.connect();
_networkHelper.initialize();
_networkHelper.connectionChange.listen(_handleConnectionChange);
}
void updateStatus(UserStatus status) {
if (_currentUser == null) return;
_socketService.updateStatus(status);
// 현재 사용자의 상태 업데이트
_currentUser = User(
id: _currentUser!.id,
username: _currentUser!.username,
profileImage: _currentUser!.profileImage,
status: status,
lastSeen: _currentUser!.lastSeen,
);
notifyListeners();
}
void _handleUserStatusUpdated(String userId, UserStatus status) {
final index = _users.indexWhere((u) => u.id == userId);
if (index != -1) {
_users[index] = User(
id: _users[index].id,
username: _users[index].username,
profileImage: _users[index].profileImage,
status: status,
lastSeen: _users[index].lastSeen,
);
notifyListeners();
}
}
이제 사용자 상태를 표시하는 위젯을 만들어볼게요. widgets/user_status_indicator.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'package:flutter/material.dart';
import '../models/user_model.dart';
class UserStatusIndicator extends StatelessWidget {
final UserStatus status;
final double size;
UserStatusIndicator({
required this.status,
this.size = 10,
});
@override
Widget build(BuildContext context) {
return Container(
width: size,
height: size,
decoration: BoxDecoration(
color: _getStatusColor(),
shape: BoxShape.circle,
border: Border.all(
color: Colors.white,
width: size / 5,
),
),
);
}
Color _getStatusColor() {
switch (status) {
case UserStatus.online:
return Colors.green;
case UserStatus.away:
return Colors.orange;
case UserStatus.busy:
return Colors.red;
case UserStatus.offline:
return Colors.grey;
}
}
}
이제 ChatListScreen과 ChatScreen에서 이 위젯을 사용해볼게요. 먼저 ChatListScreen의 _buildUserListItem 메서드를 수정해주세요:
Widget _buildUserListItem(BuildContext context, User user) {
return ListTile(
leading: Stack(
children: [
CircleAvatar(
backgroundColor: Colors.blue.shade200,
child: Text(
user.username.isNotEmpty ? user.username[0].toUpperCase() : '?',
style: TextStyle(color: Colors.white),
),
),
Positioned(
right: 0,
bottom: 0,
child: UserStatusIndicator(status: user.status),
),
],
),
title: Text(user.username),
subtitle: Text(
_getStatusText(user),
),
trailing: Icon(Icons.chat_bubble_outline),
onTap: () {
Navigator.of(context).push(
MaterialPageRoute(
builder: (_) => ChatScreen(user: user),
),
);
},
);
}
String _getStatusText(User user) {
switch (user.status) {
case UserStatus.online:
return '접속 중';
case UserStatus.away:
return '자리 비움';
case UserStatus.busy:
return '바쁨';
case UserStatus.offline:
return '마지막 접속: ${_formatLastSeen(user.lastSeen)}';
}
}
그리고 ChatScreen의 AppBar 부분도 수정해주세요:
appBar: AppBar(
title: Row(
children: [
Stack(
children: [
CircleAvatar(
backgroundColor: Colors.blue.shade200,
radius: 16,
child: Text(
widget.user.username.isNotEmpty
? widget.user.username[0].toUpperCase()
: '?',
style: TextStyle(color: Colors.white, fontSize: 14),
),
),
Positioned(
right: 0,
bottom: 0,
child: UserStatusIndicator(
status: widget.user.status,
size: 8,
),
),
],
),
SizedBox(width: 8),
Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
widget.user.username,
style: TextStyle(fontSize: 16),
),
Consumer<ChatProvider>(
builder: (context, chatProvider, child) {
final isTyping = chatProvider.isUserTyping(widget.user.id);
return Text(
isTyping
? '입력 중...'
: _getStatusText(widget.user),
style: TextStyle(
fontSize: 12,
color: Colors.white70,
),
);
},
),
],
),
],
),
actions: [
PopupMenuButton<UserStatus>(
icon: Icon(Icons.more_vert),
onSelected: (status) {
Provider.of<ChatProvider>(context, listen: false)
.updateStatus(status);
},
itemBuilder: (context) => [
PopupMenuItem(
value: UserStatus.online,
child: Row(
children: [
UserStatusIndicator(status: UserStatus.online, size: 12),
SizedBox(width: 8),
Text('접속 중'),
],
),
),
PopupMenuItem(
value: UserStatus.away,
child: Row(
children: [
UserStatusIndicator(status: UserStatus.away, size: 12),
SizedBox(width: 8),
Text('자리 비움'),
],
),
),
PopupMenuItem(
value: UserStatus.busy,
child: Row(
children: [
UserStatusIndicator(status: UserStatus.busy, size: 12),
SizedBox(width: 8),
Text('바쁨'),
],
),
),
],
),
],
),
이제 사용자 상태를 더 자세히 표시하고 변경할 수 있는 기능이 추가되었어요! 이런 기능은 사용자 경험을 크게 향상시켜요. 상대방이 지금 채팅을 볼 수 있는 상태인지 알 수 있으니까요! ㅋㅋ
9. 파일 및 이미지 전송 기능 추가 📷
채팅앱에서 텍스트만 주고받을 수 있다면 좀 심심하겠죠? 이제 이미지와 파일을 전송하는 기능을 추가해볼게요! 🖼️
서버에 파일 업로드 기능 추가하기
먼저 서버에 파일을 저장할 수 있는 기능을 추가해볼게요. server 폴더에 필요한 패키지를 설치해주세요:
npm install multer fs-extra
그리고 server/index.js 파일에 파일 업로드 코드를 추가해주세요:
const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const cors = require('cors');
const { v4: uuidv4 } = require('uuid');
const multer = require('multer');
const fs = require('fs-extra');
const path = require('path');
const app = express();
app.use(cors());
app.use(express.json());
// 업로드 폴더 생성
const uploadDir = path.join(__dirname, 'uploads');
fs.ensureDirSync(uploadDir);
// 정적 파일 제공
app.use('/uploads', express.static(uploadDir));
// 파일 업로드 설정
const storage = multer.diskStorage({
destination: (req, file, cb) => {
cb(null, uploadDir);
},
filename: (req, file, cb) => {
const uniqueName = `${Date.now()}-${Math.round(Math.random() * 1E9)}${path.extname(file.originalname)}`;
cb(null, uniqueName);
}
});
const upload = multer({
storage,
limits: { fileSize: 5 * 1024 * 1024 }, // 5MB 제한
fileFilter: (req, file, cb) => {
// 허용할 파일 형식 설정
const filetypes = /jpeg|jpg|png|gif|pdf|doc|docx|xls|xlsx|ppt|pptx|txt/;
const mimetype = filetypes.test(file.mimetype);
const extname = filetypes.test(path.extname(file.originalname).toLowerCase());
if (mimetype && extname) {
return cb(null, true);
}
cb(new Error('지원하지 않는 파일 형식입니다.'));
}
});
// 파일 업로드 API 엔드포인트
app.post('/upload', upload.single('file'), (req, res) => {
if (!req.file) {
return res.status(400).json({ error: '파일이 없습니다.' });
}
const fileUrl = `${req.protocol}://${req.get('host')}/uploads/${req.file.filename}`;
res.json({ fileUrl });
});
// 서버 생성 및 소켓 설정
const server = http.createServer(app);
const io = socketIo(server, {
cors: {
origin: "*",
methods: ["GET", "POST"]
}
});
// 기존 소켓 코드...
// 서버 시작
const PORT = process.env.PORT || 3000;
server.listen(PORT, () => {
console.log(`Server running on port ${PORT}`);
});
Flutter에서 파일 업로드 서비스 만들기
이제 Flutter에서 파일을 업로드할 수 있는 서비스를 만들어볼게요. services/file_service.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'dart:io';
import 'package:flutter/foundation.dart';
import 'package:http/http.dart' as http;
import 'dart:convert';
import '../config/app_config.dart';
class FileService {
Future<String?> uploadFile(File file) async {
try {
final uri = Uri.parse('${AppConfig.socketUrl}/upload');
// 멀티파트 요청 생성
final request = http.MultipartRequest('POST', uri);
// 파일 추가
final fileStream = http.ByteStream(file.openRead());
final fileLength = await file.length();
final multipartFile = http.MultipartFile(
'file',
fileStream,
fileLength,
filename: file.path.split('/').last,
);
request.files.add(multipartFile);
// 요청 전송
final response = await request.send();
if (response.statusCode == 200) {
// 응답 처리
final responseData = await response.stream.bytesToString();
final jsonData = json.decode(responseData);
return jsonData['fileUrl'];
} else {
debugPrint('File upload failed with status: ${response.statusCode}');
return null;
}
} catch (e) {
debugPrint('Error uploading file: $e');
return null;
}
}
}
pubspec.yaml 파일에 http 패키지를 추가해주세요:
dependencies:
flutter:
sdk: flutter
socket_io_client: ^2.0.0
provider: ^6.0.3
shared_preferences: ^2.0.15
image_picker: ^0.8.5+3
path_provider: ^2.0.11
intl: ^0.17.0
connectivity_plus: ^3.0.2
http: ^0.13.5
채팅 입력 위젯 수정하기
이제 채팅 입력 위젯을 수정해서 이미지와 파일을 선택할 수 있게 해볼게요. widgets/chat_input.dart 파일을 수정해주세요:
import 'package:flutter/material.dart';
import 'package:image_picker/image_picker.dart';
import 'package:file_picker/file_picker.dart';
import 'dart:io';
import '../services/file_service.dart';
class ChatInput extends StatefulWidget {
final Function(String) onSend;
final Function(String, String) onSendWithFile;
final Function() onTyping;
ChatInput({
required this.onSend,
required this.onSendWithFile,
required this.onTyping,
});
@override
_ChatInputState createState() => _ChatInputState();
}
class _ChatInputState extends State<ChatInput> {
final _textController = TextEditingController();
final _imagePicker = ImagePicker();
final _fileService = FileService();
bool _isUploading = false;
void _handleSend() {
final text = _textController.text.trim();
if (text.isNotEmpty) {
widget.onSend(text);
_textController.clear();
}
}
Future<void> _pickImage() async {
try {
final pickedFile = await _imagePicker.pickImage(
source: ImageSource.gallery,
imageQuality: 70,
);
if (pickedFile != null) {
_uploadAndSendFile(File(pickedFile.path));
}
} catch (e) {
print('Error picking image: $e');
_showErrorSnackBar('이미지를 선택하는 중 오류가 발생했습니다.');
}
}
Future<void> _takePhoto() async {
try {
final pickedFile = await _imagePicker.pickImage(
source: ImageSource.camera,
imageQuality: 70,
);
if (pickedFile != null) {
_uploadAndSendFile(File(pickedFile.path));
}
} catch (e) {
print('Error taking photo: $e');
_showErrorSnackBar('사진을 촬영하는 중 오류가 발생했습니다.');
}
}
Future<void> _pickFile() async {
try {
final result = await FilePicker.platform.pickFiles(
type: FileType.custom,
allowedExtensions: ['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'txt'],
);
if (result != null && result.files.single.path != null) {
_uploadAndSendFile(File(result.files.single.path!));
}
} catch (e) {
print('Error picking file: $e');
_showErrorSnackBar('파일을 선택하는 중 오류가 발생했습니다.');
}
}
Future<void> _uploadAndSendFile(File file) async {
setState(() {
_isUploading = true;
});
try {
final fileUrl = await _fileService.uploadFile(file);
setState(() {
_isUploading = false;
});
if (fileUrl != null) {
final text = _textController.text.trim();
widget.onSendWithFile(text, fileUrl);
_textController.clear();
} else {
_showErrorSnackBar('파일 업로드에 실패했습니다.');
}
} catch (e) {
setState(() {
_isUploading = false;
});
_showErrorSnackBar('파일 업로드 중 오류가 발생했습니다.');
}
}
void _showErrorSnackBar(String message) {
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(content: Text(message)),
);
}
@override
Widget build(BuildContext context) {
return Container(
padding: EdgeInsets.symmetric(horizontal: 8, vertical: 4),
decoration: BoxDecoration(
color: Colors.white,
boxShadow: [
BoxShadow(
color: Colors.black12,
offset: Offset(0, -1),
blurRadius: 4,
),
],
),
child: Column(
mainAxisSize: MainAxisSize.min,
children: [
if (_isUploading)
LinearProgressIndicator(),
Row(
children: [
IconButton(
icon: Icon(Icons.attach_file),
onPressed: _isUploading ? null : () {
showModalBottomSheet(
context: context,
builder: (context) => _buildAttachmentOptions(),
);
},
),
Expanded(
child: TextField(
controller: _textController,
decoration: InputDecoration(
hintText: '메시지를 입력하세요...',
border: InputBorder.none,
),
onChanged: (_) => widget.onTyping(),
textCapitalization: TextCapitalization.sentences,
),
),
IconButton(
icon: Icon(Icons.send, color: Colors.blue),
onPressed: _isUploading ? null : _handleSend,
),
],
),
],
),
);
}
Widget _buildAttachmentOptions() {
return Container(
height: 180,
padding: EdgeInsets.all(16),
child: Column(
children: [
Text(
'파일 첨부',
style: TextStyle(
fontSize: 18,
fontWeight: FontWeight.bold,
),
),
SizedBox(height: 20),
Row(
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: [
_buildAttachmentOption(
icon: Icons.photo,
label: '갤러리',
onTap: () {
Navigator.pop(context);
_pickImage();
},
),
_buildAttachmentOption(
icon: Icons.camera_alt,
label: '카메라',
onTap: () {
Navigator.pop(context);
_takePhoto();
},
),
_buildAttachmentOption(
icon: Icons.insert_drive_file,
label: '파일',
onTap: () {
Navigator.pop(context);
_pickFile();
},
),
],
),
],
),
);
}
Widget _buildAttachmentOption({
required IconData icon,
required String label,
required VoidCallback onTap,
}) {
return GestureDetector(
onTap: onTap,
child: Column(
children: [
Container(
width: 60,
height: 60,
decoration: BoxDecoration(
color: Colors.blue.shade100,
shape: BoxShape.circle,
),
child: Icon(
icon,
color: Colors.blue,
size: 30,
),
),
SizedBox(height: 8),
Text(label),
],
),
);
}
@override
void dispose() {
_textController.dispose();
super.dispose();
}
}
pubspec.yaml 파일에 file_picker 패키지를 추가해주세요:
dependencies:
flutter:
sdk: flutter
socket_io_client: ^2.0.0
provider: ^6.0.3
shared_preferences: ^2.0.15
image_picker: ^0.8.5+3
path_provider: ^2.0.11
intl: ^0.17.0
connectivity_plus: ^3.0.2
http: ^0.13.5
file_picker: ^5.2.5
ChatProvider 수정하기
이제 ChatProvider를 수정해서 파일이 첨부된 메시지를 처리할 수 있게 해볼게요:
void sendMessageWithFile(String receiverId, String content, String fileUrl) {
if (_currentUser == null) return;
final messageId = DateTime.now().millisecondsSinceEpoch.toString();
final message = MessageWithStatus(
id: messageId,
senderId: _currentUser!.id,
receiverId: receiverId,
content: content,
timestamp: DateTime.now(),
imageUrl: fileUrl,
status: MessageStatus.sending,
);
// 메시지를 목록에 추가 (sending 상태)
_messages.add(message);
notifyListeners();
// 서버로 메시지 전송
_socketService.sendMessage(message);
// 소켓 이벤트 핸들러 추가
_socketService.socket.once('message_sent', (data) {
if (data['id'] == messageId) {
final index = _messages.indexWhere((m) => m.id == messageId);
if (index != -1) {
_messages[index] = _messages[index].copyWith(status: MessageStatus.sent);
notifyListeners();
}
}
});
// 5초 후에도 응답이 없으면 실패로 처리
Future.delayed(Duration(seconds: 5), () {
final index = _messages.indexWhere((m) => m.id == messageId);
if (index != -1 && _messages[index].status == MessageStatus.sending) {
_messages[index] = _messages[index].copyWith(status: MessageStatus.failed);
notifyListeners();
}
});
}
ChatScreen 수정하기
마지막으로 ChatScreen을 수정해서 파일이 첨부된 메시지를 보낼 수 있게 해볼게요:
Consumer<ChatProvider>(
builder: (context, chatProvider, child) {
return ChatInput(
onSend: (message) {
chatProvider.sendMessage(widget.user.id, message);
},
onSendWithFile: (message, fileUrl) {
chatProvider.sendMessageWithFile(widget.user.id, message, fileUrl);
},
onTyping: () {
_handleTyping(chatProvider);
},
);
},
),
메시지 버블 수정하기
이제 메시지 버블을 수정해서 다양한 파일 형식을 표시할 수 있게 해볼게요:
Widget _buildFilePreview() {
if (message.imageUrl == null || message.imageUrl!.isEmpty) {
return SizedBox();
}
final fileUrl = message.imageUrl!;
final fileExtension = fileUrl.split('.').last.toLowerCase();
// 이미지 파일인 경우
if (['jpg', 'jpeg', 'png', 'gif'].contains(fileExtension)) {
return ClipRRect(
borderRadius: BorderRadius.circular(12),
child: Image.network(
fileUrl,
width: double.infinity,
fit: BoxFit.cover,
loadingBuilder: (context, child, loadingProgress) {
if (loadingProgress == null) return child;
return Container(
height: 150,
child: Center(
child: CircularProgressIndicator(
value: loadingProgress.expectedTotalBytes != null
? loadingProgress.cumulativeBytesLoaded /
loadingProgress.expectedTotalBytes!
: null,
),
),
);
},
errorBuilder: (context, error, stackTrace) {
return Container(
height: 100,
color: Colors.grey[200],
child: Center(
child: Icon(Icons.error),
),
);
},
),
);
}
// 다른 파일 형식인 경우
IconData fileIcon;
Color iconColor;
if (['pdf'].contains(fileExtension)) {
fileIcon = Icons.picture_as_pdf;
iconColor = Colors.red;
} else if (['doc', 'docx'].contains(fileExtension)) {
fileIcon = Icons.description;
iconColor = Colors.blue;
} else if (['xls', 'xlsx'].contains(fileExtension)) {
fileIcon = Icons.table_chart;
iconColor = Colors.green;
} else if (['ppt', 'pptx'].contains(fileExtension)) {
fileIcon = Icons.slideshow;
iconColor = Colors.orange;
} else {
fileIcon = Icons.insert_drive_file;
iconColor = Colors.grey;
}
return GestureDetector(
onTap: () {
// 파일 열기 (URL 실행)
launchUrl(Uri.parse(fileUrl));
},
child: Container(
padding: EdgeInsets.all(12),
decoration: BoxDecoration(
color: isMe ? Colors.blue.shade800 : Colors.grey.shade200,
borderRadius: BorderRadius.circular(12),
),
child: Row(
mainAxisSize: MainAxisSize.min,
children: [
Icon(
fileIcon,
color: isMe ? Colors.white : iconColor,
size: 36,
),
SizedBox(width: 8),
Flexible(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
'파일',
style: TextStyle(
color: isMe ? Colors.white : Colors.black,
fontWeight: FontWeight.bold,
),
),
SizedBox(height: 4),
Text(
fileUrl.split('/').last,
style: TextStyle(
color: isMe ? Colors.white70 : Colors.black54,
fontSize: 12,
),
overflow: TextOverflow.ellipsis,
),
],
),
),
],
),
),
);
}
pubspec.yaml 파일에 url_launcher 패키지를 추가해주세요:
dependencies:
flutter:
sdk: flutter
socket_io_client: ^2.0.0
provider: ^6.0.3
shared_preferences: ^2.0.15
image_picker: ^0.8.5+3
path_provider: ^2.0.11
intl: ^0.17.0
connectivity_plus: ^3.0.2
http: ^0.13.5
file_picker: ^5.2.5
url_launcher: ^6.1.7
그리고 MessageBubble 위젯의 build 메서드에서 이미지 표시 부분을 _buildFilePreview 메서드로 교체해주세요:
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.symmetric(vertical: 4),
child: Row(
mainAxisAlignment: isMe ? MainAxisAlignment.end : MainAxisAlignment.start,
children: [
if (!isMe) SizedBox(width: 12),
Container(
constraints: BoxConstraints(
maxWidth: MediaQuery.of(context).size.width * 0.7,
),
padding: EdgeInsets.symmetric(horizontal: 16, vertical: 10),
decoration: BoxDecoration(
color: isMe ? Colors.blue : Colors.grey[300],
borderRadius: BorderRadius.circular(20),
),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
_buildFilePreview(),
if (message.imageUrl != null &&
message.imageUrl!.isNotEmpty &&
message.content.isNotEmpty)
SizedBox(height: 8),
if (message.content.isNotEmpty)
Text(
message.content,
style: TextStyle(
color: isMe ? Colors.white : Colors.black,
),
),
SizedBox(height: 4),
Row(
mainAxisSize: MainAxisSize.min,
children: [
Text(
DateFormat('HH:mm').format(message.timestamp),
style: TextStyle(
color: isMe ? Colors.white70 : Colors.black54,
fontSize: 10,
),
),
SizedBox(width: 4),
if (isMe) _buildStatusIcon(context),
],
),
],
),
),
if (isMe) SizedBox(width: 12),
],
),
);
}
이제 채팅앱에서 이미지와 파일을 주고받을 수 있어요! 이런 기능은 실제 메신저 앱에서 정말 중요한 기능이죠. 사진, 문서, 파일 등을 주고받을 수 있으니 훨씬 더 유용한 앱이 되었어요! 🎉
재능넷에서도 이런 파일 공유 기능은 재능 거래 시 포트폴리오나 작업물을 주고받을 때 정말 유용하게 사용될 수 있을 것 같네요! ㅎㅎ
10. 푸시 알림 구현하기 🔔
채팅앱에서 푸시 알림은 정말 중요한 기능이에요! 앱을 사용하지 않을 때도 새 메시지가 오면 알림을 받을 수 있어야 하니까요. 이제 Firebase Cloud Messaging(FCM)을 사용해서 푸시 알림을 구현해볼게요!
Firebase 프로젝트 설정하기
먼저 Firebase 콘솔(console.firebase.google.com)에서 새 프로젝트를 만들고, Flutter 앱을 등록해주세요. 그리고 Firebase CLI를 설치하고 FlutterFire 설정을 해주세요:
npm install -g firebase-tools
dart pub global activate flutterfire_cli
flutterfire configure
pubspec.yaml 파일에 Firebase 관련 패키지를 추가해주세요:
dependencies:
flutter:
sdk: flutter
socket_io_client: ^2.0.0
provider: ^6.0.3
shared_preferences: ^2.0.15
image_picker: ^0.8.5+3
path_provider: ^2.0.11
intl: ^0.17.0
connectivity_plus: ^3.0.2
http: ^0.13.5
file_picker: ^5.2.5
url_launcher: ^6.1.7
firebase_core: ^2.4.1
firebase_messaging: ^14.2.1
flutter_local_notifications: ^13.0.0
Firebase 초기화하기
main.dart 파일을 수정해서 Firebase를 초기화해주세요:
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';
import 'services/socket_service.dart';
import 'providers/chat_provider.dart';
import 'services/notification_service.dart';
import 'screens/login_screen.dart';
void main() async {
WidgetsFlutterBinding.ensureInitialized();
// Firebase 초기화
await Firebase.initializeApp(
options: DefaultFirebaseOptions.currentPlatform,
);
// 알림 서비스 초기화
await NotificationService().initialize();
runApp(MyApp());
}
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MultiProvider(
providers: [
Provider(
create: (_) => SocketService(),
),
Provider(
create: (_) => NotificationService(),
),
ChangeNotifierProxyProvider<SocketService, ChatProvider>(
create: (context) => ChatProvider(
context.read<SocketService>(),
context.read<NotificationService>(),
),
update: (context, socketService, previous) =>
previous ?? ChatProvider(
socketService,
context.read<NotificationService>(),
),
),
],
child: MaterialApp(
title: 'Flutter Chat App',
theme: ThemeData(
primarySwatch: Colors.blue,
visualDensity: VisualDensity.adaptivePlatformDensity,
),
home: LoginScreen(),
),
);
}
}
알림 서비스 만들기
services/notification_service.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
import 'dart:io';
class NotificationService {
final FirebaseMessaging _firebaseMessaging = FirebaseMessaging.instance;
final FlutterLocalNotificationsPlugin _localNotifications =
FlutterLocalNotificationsPlugin();
String? _token;
String? get token => _token;
Future<void> initialize() async {
// FCM 권한 요청
if (Platform.isIOS) {
await _firebaseMessaging.requestPermission(
alert: true,
badge: true,
sound: true,
);
}
// FCM 토큰 가져오기
_token = await _firebaseMessaging.getToken();
debugPrint('FCM Token: $_token');
// 토큰 갱신 리스너
_firebaseMessaging.onTokenRefresh.listen((newToken) {
_token = newToken;
debugPrint('FCM Token refreshed: $_token');
});
// 로컬 알림 초기화
const initializationSettingsAndroid =
AndroidInitializationSettings('@mipmap/ic_launcher');
final initializationSettingsIOS = DarwinInitializationSettings(
requestAlertPermission: true,
requestBadgePermission: true,
requestSoundPermission: true,
);
final initializationSettings = InitializationSettings(
android: initializationSettingsAndroid,
iOS: initializationSettingsIOS,
);
await _localNotifications.initialize(
initializationSettings,
);
// 포그라운드 메시지 핸들러
FirebaseMessaging.onMessage.listen(_handleForegroundMessage);
// 백그라운드 메시지 핸들러 설정
FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);
}
Future<void> _handleForegroundMessage(RemoteMessage message) async {
debugPrint('Foreground message received: ${message.notification?.title}');
if (message.notification != null) {
await _showLocalNotification(
message.notification!.title ?? '새 메시지',
message.notification!.body ?? '',
message.data,
);
}
}
Future<void> _showLocalNotification(
String title,
String body,
Map<String, dynamic> payload,
) async {
const androidDetails = AndroidNotificationDetails(
'chat_channel',
'Chat Notifications',
importance: Importance.high,
priority: Priority.high,
showWhen: true,
);
const iosDetails = DarwinNotificationDetails(
presentAlert: true,
presentBadge: true,
presentSound: true,
);
const notificationDetails = NotificationDetails(
android: androidDetails,
iOS: iosDetails,
);
await _localNotifications.show(
DateTime.now().millisecond,
title,
body,
notificationDetails,
payload: payload.toString(),
);
}
}
// 백그라운드 메시지 핸들러 (top-level 함수여야 함)
@pragma('vm:entry-point')
Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
// 백그라운드에서 Firebase 초기화
await Firebase.initializeApp();
debugPrint('Background message received: ${message.notification?.title}');
}
서버에 FCM 통합하기
이제 서버에 FCM을 통합해볼게요. 먼저 필요한 패키지를 설치해주세요:
npm install firebase-admin
Firebase 콘솔에서 서비스 계정 키를 다운로드하고, server 폴더에 저장해주세요. 그리고 server/index.js 파일을 수정해주세요:
const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const cors = require('cors');
const { v4: uuidv4 } = require('uuid');
const multer = require('multer');
const fs = require('fs-extra');
const path = require('path');
const admin = require('firebase-admin');
// Firebase Admin SDK 초기화
const serviceAccount = require('./serviceAccountKey.json');
admin.initializeApp({
credential: admin.credential.cert(serviceAccount),
});
const app = express();
app.use(cors());
app.use(express.json());
// 업로드 폴더 생성 및 정적 파일 제공 코드...
// 서버 생성 및 소켓 설정
const server = http.createServer(app);
const io = socketIo(server, {
cors: {
origin: "*",
methods: ["GET", "POST"]
}
});
// 메모리에 메시지와 사용자 저장
const messages = [];
const users = {};
const fcmTokens = {}; // FCM 토큰 저장
// 소켓 연결 처리
io.on('connection', (socket) => {
console.log('New client connected:', socket.id);
// 사용자 로그인
socket.on('login', (userData) => {
const user = {
id: userData.id || uuidv4(),
username: userData.username,
socketId: socket.id,
status: userData.status || 'online',
lastSeen: new Date()
};
users[user.id] = user;
socket.userId = user.id;
// FCM 토큰 저장
if (userData.fcmToken) {
fcmTokens[user.id] = userData.fcmToken;
}
// 로그인 성공 응답
socket.emit('login_success', user);
// 다른 사용자들에게 새 사용자가 접속했음을 알림
socket.broadcast.emit('user_connected', user);
// 현재 접속 중인 사용자 목록 전송
socket.emit('user_list', Object.values(users));
});
// 메시지 전송
socket.on('send_message', async (messageData) => {
const message = {
id: uuidv4(),
senderId: socket.userId,
receiverId: messageData.receiverId,
content: messageData.content,
timestamp: new Date(),
isRead: false,
imageUrl: messageData.imageUrl || null
};
messages.push(message);
// 메시지 발신자에게 확인 전송
socket.emit('message_sent', message);
// 수신자에게 메시지 전달
const receiverSocket = Object.values(users).find(
user => user.id === messageData.receiverId
)?.socketId;
if (receiverSocket) {
io.to(receiverSocket).emit('new_message', message);
}
// 수신자가 오프라인이거나 다른 화면을 보고 있을 경우 푸시 알림 전송
const receiverUser = users[messageData.receiverId];
if (!receiverUser || receiverUser.status !== 'online') {
const fcmToken = fcmTokens[messageData.receiverId];
if (fcmToken) {
try {
const senderName = users[socket.userId]?.username || '알 수 없음';
await admin.messaging().send({
token: fcmToken,
notification: {
title: senderName,
body: messageData.imageUrl
? '사진을 보냈습니다.'
: messageData.content,
},
data: {
senderId: socket.userId,
messageId: message.id,
type: 'new_message',
},
});
console.log('Push notification sent successfully');
} catch (error) {
console.error('Error sending push notification:', error);
}
}
}
});
// 나머지 이벤트 핸들러...
// FCM 토큰 업데이트
socket.on('update_fcm_token', (data) => {
if (socket.userId && data.token) {
fcmTokens[socket.userId] = data.token;
console.log(`FCM token updated for user ${socket.userId}`);
}
});
});
Flutter 앱에서 FCM 토큰 전송하기
이제 Flutter 앱에서 FCM 토큰을 서버로 전송해볼게요. services/socket_service.dart 파일에 아래 메서드를 추가해주세요:
void updateFcmToken(String token) {
socket.emit('update_fcm_token', {'token': token});
}
그리고 ChatProvider 클래스를 수정해서 NotificationService를 사용하도록 해주세요:
class ChatProvider with ChangeNotifier {
final SocketService _socketService;
final NetworkHelper _networkHelper = NetworkHelper();
final NotificationService _notificationService;
User? _currentUser;
List<MessageWithStatus> _messages = [];
List<MessageWithStatus> _offlineQueue = [];
Map<String, bool> _typingUsers = {};
List<User> _users = [];
ChatProvider(this._socketService, this._notificationService) {
_socketService.onUserConnected = _handleUserConnected;
_socketService.onUserDisconnected = _handleUserDisconnected;
_socketService.onNewMessage = _handleNewMessage;
_socketService.onMessageRead = _handleMessageRead;
_socketService.onUserTyping = _handleUserTyping;
_socketService.onUserStopTyping = _handleUserStopTyping;
_socketService.onUserList = _handleUserList;
_socketService.connect();
_networkHelper.initialize();
_networkHelper.connectionChange.listen(_handleConnectionChange);
// FCM 토큰이 있으면 서버로 전송
if (_notificationService.token != null) {
_socketService.updateFcmToken(_notificationService.token!);
}
}
// 로그인 메서드 수정
void login(String username) {
final user = User(
id: DateTime.now().millisecondsSinceEpoch.toString(),
username: username,
status: UserStatus.online,
);
// FCM 토큰 포함해서 로그인
final userData = user.toJson();
if (_notificationService.token != null) {
userData['fcmToken'] = _notificationService.token;
}
_socketService.login(userData);
_currentUser = user;
notifyListeners();
}
// 나머지 메서드들...
}
이제 채팅앱에서 푸시 알림 기능이 구현되었어요! 앱을 사용하지 않을 때도 새 메시지가 오면 알림을 받을 수 있어요. 이런 기능은 실제 메신저 앱에서 정말 중요한 기능이죠! 😊
11. 성능 최적화 팁 🚀
채팅앱을 개발하다 보면 메시지가 많아질수록 성능 이슈가 발생할 수 있어요. 이제 앱의 성능을 최적화하는 방법에 대해 알아볼게요!
메시지 페이징 구현하기
채팅방에 메시지가 많아지면 한 번에 모든 메시지를 로드하는 것은 비효율적이에요. 메시지를 페이징해서 로드하는 방법을 구현해볼게요.
먼저 서버에 페이징 API를 추가해주세요:
app.get('/messages/:senderId/:receiverId', (req, res) => {
const { senderId, receiverId } = req.params;
const { page = 1, limit = 20 } = req.query;
const pageInt = parseInt(page);
const limitInt = parseInt(limit);
// 두 사용자 간의 메시지 필터링
const filteredMessages = messages.filter(message =>
(message.senderId === senderId && message.receiverId === receiverId) ||
(message.senderId === receiverId && message.receiverId === senderId)
);
// 최신 메시지부터 정렬
filteredMessages.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
// 페이징 적용
const startIndex = (pageInt - 1) * limitInt;
const endIndex = pageInt * limitInt;
const paginatedMessages = filteredMessages.slice(startIndex, endIndex);
res.json({
messages: paginatedMessages,
totalCount: filteredMessages.length,
currentPage: pageInt,
totalPages: Math.ceil(filteredMessages.length / limitInt),
});
});
이제 Flutter 앱에서 메시지를 페이징해서 로드하는 서비스를 만들어볼게요. services/message_service.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'dart:convert';
import 'package:http/http.dart' as http;
import '../config/app_config.dart';
import '../models/message_model.dart';
class MessageService {
Future<Map<String, dynamic>> getMessages({
required String senderId,
required String receiverId,
int page = 1,
int limit = 20,
}) async {
try {
final uri = Uri.parse(
'${AppConfig.socketUrl}/messages/$senderId/$receiverId?page=$page&limit=$limit'
);
final response = await http.get(uri);
if (response.statusCode == 200) {
final data = json.decode(response.body);
final List<Message> messages = (data['messages'] as List)
.map((json) => Message.fromJson(json))
.toList();
return {
'messages': messages,
'totalCount': data['totalCount'],
'currentPage': data['currentPage'],
'totalPages': data['totalPages'],
};
} else {
throw Exception('Failed to load messages');
}
} catch (e) {
throw Exception('Error: $e');
}
}
}
이제 ChatProvider에 페이징 기능을 추가해볼게요:
class ChatProvider with ChangeNotifier {
// 기존 속성들...
final MessageService _messageService = MessageService();
bool _isLoadingMessages = false;
bool _hasMoreMessages = true;
int _currentPage = 1;
bool get isLoadingMessages => _isLoadingMessages;
bool get hasMoreMessages => _hasMoreMessages;
// 특정 사용자와의 메시지 로드
Future<void> loadMessages(String receiverId) async {
if (_currentUser == null || _isLoadingMessages || !_hasMoreMessages) return;
setState(() {
_isLoadingMessages = true;
});
try {
final result = await _messageService.getMessages(
senderId: _currentUser!.id,
receiverId: receiverId,
page: _currentPage,
);
final List<Message> messages = result['messages'];
// 메시지 상태 추가
final messagesWithStatus = messages.map((message) {
return MessageWithStatus.fromMessage(
message,
status: message.isRead ? MessageStatus.read : MessageStatus.sent,
);
}).toList();
if (_currentPage == 1) {
_messages = messagesWithStatus;
} else {
_messages.addAll(messagesWithStatus);
}
_currentPage++;
_hasMoreMessages = _currentPage <= result['totalPages'];
notifyListeners();
} catch (e) {
debugPrint('Error loading messages: $e');
} finally {
setState(() {
_isLoadingMessages = false;
});
}
}
// 메시지 로드 상태 초기화
void resetMessagePagination() {
_currentPage = 1;
_hasMoreMessages = true;
_messages = [];
notifyListeners();
}
void setState(Function() fn) {
fn();
notifyListeners();
}
}
이제 ChatScreen을 수정해서 페이징을 구현해볼게요:
class _ChatScreenState extends State<ChatScreen> {
Timer? _typingTimer;
bool _isTyping = false;
final ScrollController _scrollController = ScrollController();
@override
void initState() {
super.initState();
// 메시지 로드 상태 초기화
Provider.of<ChatProvider>(context, listen: false).resetMessagePagination();
// 첫 페이지 메시지 로드
Provider.of<ChatProvider>(context, listen: false).loadMessages(widget.user.id);
// 스크롤 리스너 추가
_scrollController.addListener(_scrollListener);
}
void _scrollListener() {
if (_scrollController.position.pixels == _scrollController.position.maxScrollExtent) {
// 스크롤이 맨 위에 도달하면 이전 메시지 로드
Provider.of<ChatProvider>(context, listen: false).loadMessages(widget.user.id);
}
}
@override
void dispose() {
_typingTimer?.cancel();
_scrollController.removeListener(_scrollListener);
_scrollController.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
// 앱바 코드...
),
body: Column(
children: [
Expanded(
child: Consumer<ChatProvider>(
builder: (context, chatProvider, child) {
final currentUser = chatProvider.currentUser;
if (currentUser == null) {
return Center(child: Text('로그인이 필요합니다.'));
}
final messages = chatProvider.messages.where((message) {
return (message.senderId == currentUser.id &&
message.receiverId == widget.user.id) ||
(message.senderId == widget.user.id &&
message.receiverId == currentUser.id);
}).toList();
messages.sort((a, b) => b.timestamp.compareTo(a.timestamp));
if (messages.isEmpty && !chatProvider.isLoadingMessages) {
return Center(
child: Text('아직 대화 내용이 없습니다. 첫 메시지를 보내보세요!'),
);
}
return Stack(
children: [
ListView.builder(
controller: _scrollController,
padding: EdgeInsets.all(8),
reverse: true, // 최신 메시지가 아래에 표시되도록
itemCount: messages.length + (chatProvider.hasMoreMessages ? 1 : 0),
itemBuilder: (context, index) {
if (index == messages.length && chatProvider.hasMoreMessages) {
return Center(
child: Padding(
padding: const EdgeInsets.all(8.0),
child: CircularProgressIndicator(),
),
);
}
final message = messages[index];
final isMe = message.senderId == currentUser.id;
// 읽지 않은 메시지 읽음 표시
if (!isMe && !message.isRead) {
chatProvider.markMessageAsRead(message.id);
}
return MessageBubble(
message: message,
isMe: isMe,
);
},
),
if (chatProvider.isLoadingMessages && messages.isEmpty)
Center(
child: CircularProgressIndicator(),
),
],
);
},
),
),
Consumer<ChatProvider>(
builder: (context, chatProvider, child) {
return ChatInput(
onSend: (message) {
chatProvider.sendMessage(widget.user.id, message);
// 메시지 전송 후 스크롤을 맨 아래로
Future.delayed(Duration(milliseconds: 100), () {
_scrollController.animateTo(
0,
duration: Duration(milliseconds: 300),
curve: Curves.easeOut,
);
});
},
onSendWithFile: (message, fileUrl) {
chatProvider.sendMessageWithFile(widget.user.id, message, fileUrl);
// 메시지 전송 후 스크롤을 맨 아래로
Future.delayed(Duration(milliseconds: 100), () {
_scrollController.animateTo(
0,
duration: Duration(milliseconds: 300),
curve: Curves.easeOut,
);
});
},
onTyping: () {
_handleTyping(chatProvider);
},
);
},
),
],
),
);
}
}
메시지 캐싱 구현하기
메시지를 로컬에 캐싱하면 앱을 다시 실행했을 때 더 빠르게 메시지를 표시할 수 있어요. shared_preferences를 사용해서 간단한 캐싱을 구현해볼게요:
import 'dart:convert';
import 'package:shared_preferences/shared_preferences.dart';
import '../models/message_model.dart';
class MessageCache {
static const String _cacheKeyPrefix = 'chat_messages_';
static Future<void> cacheMessages(String chatId, List<Message> messages) async {
try {
final prefs = await SharedPreferences.getInstance();
final messagesJson = messages.map((m) => jsonEncode(m.toJson())).toList();
await prefs.setStringList('${_cacheKeyPrefix}$chatId', messagesJson);
} catch (e) {
print('Error caching messages: $e');
}
}
static Future<List<Message>> getCachedMessages(String chatId) async {
try {
final prefs = await SharedPreferences.getInstance();
final messagesJson = prefs.getStringList('${_cacheKeyPrefix}$chatId') ?? [];
return messagesJson
.map((json) => Message.fromJson(jsonDecode(json)))
.toList();
} catch (e) {
print('Error getting cached messages: $e');
return [];
}
}
static Future<void> clearCache(String chatId) async {
try {
final prefs = await SharedPreferences.getInstance();
await prefs.remove('${_cacheKeyPrefix}$chatId');
} catch (e) {
print('Error clearing message cache: $e');
}
}
}
이제 ChatProvider에서 이 캐시를 사용해볼게요:
Future<void> loadMessages(String receiverId) async {
if (_currentUser == null) return;
final chatId = _getChatId(_currentUser!.id, receiverId);
setState(() {
_isLoadingMessages = true;
});
// 먼저 캐시에서 메시지 로드
if (_currentPage == 1) {
final cachedMessages = await MessageCache.getCachedMessages(chatId);
if (cachedMessages.isNotEmpty) {
final messagesWithStatus = cachedMessages.map((message) {
return MessageWithStatus.fromMessage(
message,
status: message.isRead ? MessageStatus.read : MessageStatus.sent,
);
}).toList();
_messages = messagesWithStatus;
notifyListeners();
}
}
try {
final result = await _messageService.getMessages(
senderId: _currentUser!.id,
receiverId: receiverId,
page: _currentPage,
);
final List<Message> messages = result['messages'];
// 메시지 상태 추가
final messagesWithStatus = messages.map((message) {
return MessageWithStatus.fromMessage(
message,
status: message.isRead ? MessageStatus.read : MessageStatus.sent,
);
}).toList();
if (_currentPage == 1) {
_messages = messagesWithStatus;
// 첫 페이지 메시지를 캐시에 저장
MessageCache.cacheMessages(chatId, messages);
} else {
_messages.addAll(messagesWithStatus);
}
_currentPage++;
_hasMoreMessages = _currentPage <= result['totalPages'];
notifyListeners();
} catch (e) {
debugPrint('Error loading messages: $e');
} finally {
setState(() {
_isLoadingMessages = false;
});
}
}
String _getChatId(String userId1, String userId2) {
// 항상 같은 순서로 채팅 ID 생성
final sortedIds = [userId1, userId2]..sort();
return '${sortedIds[0]}_${sortedIds[1]}';
}
이미지 최적화
채팅앱에서 이미지는 성능에 큰 영향을 미칠 수 있어요. 이미지를 최적화하는 방법을 알아볼게요:
Future<void> _pickImage() async {
try {
final pickedFile = await _imagePicker.pickImage(
source: ImageSource.gallery,
imageQuality: 70, // 이미지 품질 조정
maxWidth: 800, // 최대 너비 제한
maxHeight: 800, // 최대 높이 제한
);
if (pickedFile != null) {
_uploadAndSendFile(File(pickedFile.path));
}
} catch (e) {
print('Error picking image: $e');
_showErrorSnackBar('이미지를 선택하는 중 오류가 발생했습니다.');
}
}
그리고 MessageBubble 위젯에서 이미지를 표시할 때 캐싱을 사용해볼게요. pubspec.yaml 파일에 cached_network_image 패키지를 추가해주세요:
dependencies:
flutter:
sdk: flutter
socket_io_client: ^2.0.0
provider: ^6.0.3
shared_preferences: ^2.0.15
image_picker: ^0.8.5+3
path_provider: ^2.0.11
intl: ^0.17.0
connectivity_plus: ^3.0.2
http: ^0.13.5
file_picker: ^5.2.5
url_launcher: ^6.1.7
firebase_core: ^2.4.1
firebase_messaging: ^14.2.1
flutter_local_notifications: ^13.0.0
cached_network_image: ^3.2.3
이제 MessageBubble 위젯의 _buildFilePreview 메서드를 수정해주세요:
Widget _buildFilePreview() {
if (message.imageUrl == null || message.imageUrl!.isEmpty) {
return SizedBox();
}
final fileUrl = message.imageUrl!;
final fileExtension = fileUrl.split('.').last.toLowerCase();
// 이미지 파일인 경우
if (['jpg', 'jpeg', 'png', 'gif'].contains(fileExtension)) {
return ClipRRect(
borderRadius: BorderRadius.circular(12),
child: CachedNetworkImage(
imageUrl: fileUrl,
width: double.infinity,
fit: BoxFit.cover,
placeholder: (context, url) => Container(
height: 150,
child: Center(
child: CircularProgressIndicator(),
),
),
errorWidget: (context, url, error) => Container(
height: 100,
color: Colors.grey[200],
child: Center(
child: Icon(Icons.error),
),
),
),
);
}
// 다른 파일 형식인 경우 (기존 코드와 동일)
}
메모리 누수 방지
Flutter 앱에서 메모리 누수를 방지하는 것은 매우 중요해요. 특히 StreamSubscription과 같은 리소스는 반드시 dispose 메서드에서 해제해주세요:
class ChatProvider with ChangeNotifier {
// 기존 속성들...
StreamSubscription? _connectionSubscription;
ChatProvider(this._socketService, this._notificationService) {
// 기존 초기화 코드...
_connectionSubscription = _networkHelper.connectionChange.listen(_handleConnectionChange);
}
@override
void dispose() {
_connectionSubscription?.cancel();
_socketService.disconnect();
super.dispose();
}
}
이런 성능 최적화 기법들을 적용하면 채팅앱의 성능이 크게 향상돼요! 특히 메시지가 많아질수록 그 효과는 더 커지죠. 실제 프로덕션 앱에서는 이런 최적화가 필수예요! 🚀
재능넷에서 앱 개발 재능을 판매하실 때, 이런 성능 최적화 기법들을 적용하면 클라이언트들에게 더 높은 품질의 서비스를 제공할 수 있을 거예요! 😊
12. 배포 및 테스트 🚢
드디어 채팅앱이 거의 완성되었어요! 이제 앱을 배포하고 테스트하는 방법에 대해 알아볼게요.
서버 배포하기
Socket.IO 서버를 배포하는 방법은 여러 가지가 있어요. 가장 간단한 방법은 Heroku나 Railway 같은 PaaS(Platform as a Service)를 사용하는 거예요.
Heroku에 배포하는 방법을 간단히 알아볼게요:
- Heroku 계정 생성 및 Heroku CLI 설치
- server 폴더에 Procfile 생성 (내용:
web: node index.js) - server 폴더에서 Git 초기화 및 Heroku 앱 생성
cd server
git init
heroku create your-chat-app-name
git add .
git commit -m "Initial commit"
git push heroku master
이제 서버가 Heroku에 배포되었어요! 배포된 URL은 https://your-chat-app-name.herokuapp.com 형식이에요.
이제 Flutter 앱의 config/app_config.dart 파일을 수정해서 배포된 서버 URL을 사용하도록 해주세요:
class AppConfig {
static const String socketUrl = 'https://your-chat-app-name.herokuapp.com';
}
Flutter 앱 배포하기
Flutter 앱을 배포하는 방법은 플랫폼에 따라 다르지만, 기본적인 과정을 알아볼게요.
Android 앱 배포하기
- 앱 서명 키 생성
- 앱 번들 또는 APK 빌드
- Google Play Console에 업로드
flutter build appbundle --release
또는 APK를 빌드하려면:
flutter build apk --release
iOS 앱 배포하기
- Apple Developer 계정 필요
- Xcode에서 앱 서명 설정
- IPA 빌드
- App Store Connect에 업로드
flutter build ios --release
그 다음 Xcode에서 Product > Archive 메뉴를 사용해 앱을 App Store Connect에 업로드해야 해요.
앱 테스트하기
앱을 배포하기 전에 철저하게 테스트하는 것이 중요해요. Flutter에서는 여러 가지 테스트 방법을 제공해요:
단위 테스트
비즈니스 로직을 테스트하는 단위 테스트를 작성해볼게요. test/chat_provider_test.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'package:flutter_test/flutter_test.dart';
import 'package:mockito/mockito.dart';
import 'package:your_app_name/models/message_model.dart';
import 'package:your_app_name/models/user_model.dart';
import 'package:your_app_name/providers/chat_provider.dart';
import 'package:your_app_name/services/socket_service.dart';
import 'package:your_app_name/services/notification_service.dart';
class MockSocketService extends Mock implements SocketService {}
class MockNotificationService extends Mock implements NotificationService {}
void main() {
group('ChatProvider Tests', () {
late ChatProvider chatProvider;
late MockSocketService mockSocketService;
late MockNotificationService mockNotificationService;
setUp(() {
mockSocketService = MockSocketService();
mockNotificationService = MockNotificationService();
chatProvider = ChatProvider(mockSocketService, mockNotificationService);
});
test('login should update current user', () {
// Given
const username = 'testUser';
// When
chatProvider.login(username);
// Then
expect(chatProvider.currentUser, isNotNull);
expect(chatProvider.currentUser!.username, equals(username));
expect(chatProvider.currentUser!.status, equals(UserStatus.online));
});
test('sendMessage should add message to list', () {
// Given
const username = 'testUser';
const receiverId = 'receiver123';
const content = 'Hello, world!';
// When
chatProvider.login(username);
chatProvider.sendMessage(receiverId, content);
// Then
expect(chatProvider.messages, isNotEmpty);
expect(chatProvider.messages.first.content, equals(content));
expect(chatProvider.messages.first.receiverId, equals(receiverId));
});
});
}
위젯 테스트
UI 컴포넌트를 테스트하는 위젯 테스트를 작성해볼게요. test/message_bubble_test.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:your_app_name/models/message_model.dart';
import 'package:your_app_name/widgets/message_bubble.dart';
void main() {
testWidgets('MessageBubble displays content correctly', (WidgetTester tester) async {
// Given
final message = Message(
id: '1',
senderId: 'sender123',
receiverId: 'receiver123',
content: 'Hello, world!',
timestamp: DateTime.now(),
);
// When
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: MessageBubble(
message: message,
isMe: true,
),
),
),
);
// Then
expect(find.text('Hello, world!'), findsOneWidget);
});
testWidgets('MessageBubble shows different alignment based on isMe', (WidgetTester tester) async {
// Given
final message = Message(
id: '1',
senderId: 'sender123',
receiverId: 'receiver123',
content: 'Hello, world!',
timestamp: DateTime.now(),
);
// When - isMe = true
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: MessageBubble(
message: message,
isMe: true,
),
),
),
);
// Then
final row = tester.widget<Row>(find.byType(Row).first);
expect(row.mainAxisAlignment, equals(MainAxisAlignment.end));
// When - isMe = false
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: MessageBubble(
message: message,
isMe: false,
),
),
),
);
// Then
final updatedRow = tester.widget<Row>(find.byType(Row).first);
expect(updatedRow.mainAxisAlignment, equals(MainAxisAlignment.start));
});
}
통합 테스트
실제 기기나 에뮬레이터에서 앱을 테스트하는 통합 테스트를 작성해볼게요. integration_test/app_test.dart 파일을 만들고 아래 코드를 작성해주세요:
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';
import 'package:your_app_name/main.dart' as app;
void main() {
IntegrationTestWidgetsFlutterBinding.ensureInitialized();
group('end-to-end test', () {
testWidgets('login and send message', (WidgetTester tester) async {
// 앱 실행
app.main();
await tester.pumpAndSettle();
// 로그인 화면에서 사용자 이름 입력
await tester.enterText(find.byType(TextField), 'TestUser');
await tester.pumpAndSettle();
// 입장하기 버튼 클릭
await tester.tap(find.text('입장하기'));
await tester.pumpAndSettle();
// 채팅 목록 화면이 표시되는지 확인
expect(find.text('채팅 목록'), findsOneWidget);
// 여기서부터는 실제 서버 연결이 필요하므로 모의 데이터를 사용하거나
// 테스트 서버를 구축해야 합니다.
});
});
}
앱 모니터링
앱을 배포한 후에는 모니터링이 중요해요. Firebase Crashlytics와 Analytics를 사용해서 앱을 모니터링해볼게요.
pubspec.yaml 파일에 관련 패키지를 추가해주세요:
dependencies:
flutter:
sdk: flutter
socket_io_client: ^2.0.0
provider: ^6.0.3
shared_preferences: ^2.0.15
image_picker: ^0.8.5+3
path_provider: ^2.0.11
intl: ^0.17.0
connectivity_plus: ^3.0.2
http: ^0.13.5
file_picker: ^5.2.5
url_launcher: ^6.1.7
firebase_core: ^2.4.1
firebase_messaging: ^14.2.1
flutter_local_notifications: ^13.0.0
cached_network_image: ^3.2.3
firebase_crashlytics: ^3.0.11
firebase_analytics: ^10.1.0
main.dart 파일을 수정해서 Crashlytics와 Analytics를 초기화해주세요:
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_crashlytics/firebase_crashlytics.dart';
import 'package:firebase_analytics/firebase_analytics.dart';
import 'firebase_options.dart';
import 'services/socket_service.dart';
import 'providers/chat_provider.dart';
import 'services/notification_service.dart';
import 'screens/login_screen.dart';
void main() async {
WidgetsFlutterBinding.ensureInitialized();
// Firebase 초기화
await Firebase.initializeApp(
options: DefaultFirebaseOptions.currentPlatform,
);
// Crashlytics 초기화
FlutterError.onError = FirebaseCrashlytics.instance.recordFlutterFatalError;
// 알림 서비스 초기화
await NotificationService().initialize();
runApp(MyApp());
}
class MyApp extends StatelessWidget {
// Firebase Analytics 인스턴스
static FirebaseAnalytics analytics = FirebaseAnalytics.instance;
static FirebaseAnalyticsObserver observer =
FirebaseAnalyticsObserver(analytics: analytics);
@override
Widget build(BuildContext context) {
return MultiProvider(
providers: [
Provider(
create: (_) => SocketService(),
),
Provider(
create: (_) => NotificationService(),
),
ChangeNotifierProxyProvider<SocketService, ChatProvider>(
create: (context) => ChatProvider(
context.read<SocketService>(),
context.read<NotificationService>(),
),
update: (context, socketService, previous) =>
previous ?? ChatProvider(
socketService,
context.read<NotificationService>(),
),
),
],
child: MaterialApp(
title: 'Flutter Chat App',
theme: ThemeData(
primarySwatch: Colors.blue,
visualDensity: VisualDensity.adaptivePlatformDensity,
),
navigatorObservers: [observer], // Analytics 화면 추적
home: LoginScreen(),
),
);
}
}
이제 앱의 중요한 이벤트를 추적해볼게요. ChatProvider에 Analytics 이벤트를 추가해주세요:
void sendMessage(String receiverId, String content, {String? imageUrl}) {
if (_currentUser == null) return;
// 기존 코드...
// Analytics 이벤트 기록
FirebaseAnalytics.instance.logEvent(
name: 'send_message',
parameters: {
'has_image': imageUrl != null,
'content_length': content.length,
},
);
}
void login(String username) {
// 기존 코드...
// Analytics 이벤트 기록
FirebaseAnalytics.instance.logLogin();
}
이제 채팅앱이 완전히 배포 준비가 되었어요! 테스트와 모니터링을 통해 앱의 품질을 계속 유지하고 개선할 수 있어요. 실제 사용자들의 피드백을 받아 앱을 더 발전시켜 나가세요! 🚀
마무리: Flutter와 Socket.IO로 만드는 실시간 채팅앱의 세계 🌟
드디어 긴 여정이 끝났네요! Flutter와 Socket.IO를 사용해서 완전한 실시간 채팅앱을 만들어봤어요. 정말 많은 내용을 다뤘죠? ㅋㅋㅋ
이 글에서 우리는 다음과 같은 내용을 배웠어요:
- Flutter와 Socket.IO의 기본 개념
- 실시간 통신을 위한 서버 구축 방법
- Flutter에서 Socket.IO 클라이언트 연결 방법
- 채팅 UI 구현 방법
- 실시간 메시지 송수신 구현 방법
- 사용자 상태 관리 방법
- 파일 및 이미지 전송 기능 추가 방법
- 푸시 알림 구현 방법
- 성능 최적화 기법
- 앱 배포 및 테스트 방법
이 모든 지식을 바탕으로 여러분만의 채팅앱을 만들 수 있게 되었어요! 물론 이 글에서 다룬 내용은 기본적인 것들이고, 실제 프로덕션 앱에서는 더 많은 기능과 최적화가 필요할 수 있어요.
하지만 이 글이 여러분의 Flutter 개발 여정에 도움이 되었으면 좋겠어요. 여러분만의 창의적인 아이디어를 더해서 더 멋진 앱을 만들어보세요! 🚀
혹시 Flutter 개발에 관심이 있으시거나, 채팅앱을 만들고 싶은데 도움이 필요하시다면 재능넷에서 관련 재능을 찾아보세요! 많은 실력 있는 개발자분들이 여러분의 프로젝트를 도와드릴 준비가 되어 있답니다. 😊
마지막으로, 코딩은 끊임없는 학습의 과정이에요. 새로운 기술과 패턴을 계속 배우고 적용해보세요. 그리고 무엇보다 코딩을 즐기세요! 코딩은 정말 재밌는 활동이니까요! ㅋㅋㅋ
행복한 코딩 되세요! 👋
댓글 작성
이 글에 대한 여러분의 생각을 들려주세요
로그인이 필요합니다
댓글을 작성하려면 먼저 로그인해주세요.
댓글 0
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
아직 댓글이 없습니다.