Click here
Ver2.0 전체 열람

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

재능넷
댓글 0 전체 116 페이지
콘텐츠 대표 이미지 - Flutter로 실시간 채팅앱 개발하기: Socket.IO 통합으로 인터랙티브한 메시징 구현하기

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

안녕하세요 여러분! 오늘은 요즘 핫한 Flutter로 채팅앱을 만들어보는 시간을 가져볼게요~ 🔥 특히 실시간 통신의 끝판왕 Socket.IO를 어떻게 Flutter와 연결하는지 A부터 Z까지 싹 다 알려드릴게요! 개발 경험 있으신 분들도, 이제 막 시작하시는 분들도 다 같이 따라오세요! ㅎㅎ

요즘 채팅앱은 그냥 기본 기능이죠. 카카오톡, 텔레그램, 디스코드... 우리 일상에 완전 녹아들었잖아요? 근데 이런 앱들이 어떻게 실시간으로 메시지를 주고받는지 궁금하지 않으셨나요? 오늘은 그 비밀을 파헤쳐보는 시간이에요! 😎

재능넷에서도 많은 개발자분들이 모바일 앱 개발 재능을 공유하고 계시는데요, 이런 실시간 채팅 기능은 정말 수요가 많은 기술이랍니다. 여러분도 이 글을 통해 배우신 내용으로 재능넷에서 여러분만의 개발 재능을 뽐내보는 건 어떨까요? ㅋㅋㅋ

📚 목차

  1. Flutter와 Socket.IO 소개
  2. 개발 환경 설정하기
  3. 프로젝트 구조 잡기
  4. Socket.IO 서버 구축하기
  5. Flutter에서 Socket.IO 클라이언트 연결하기
  6. 채팅 UI 구현하기
  7. 실시간 메시지 송수신 구현
  8. 사용자 상태 관리하기
  9. 파일 및 이미지 전송 기능 추가
  10. 푸시 알림 구현하기
  11. 성능 최적화 팁
  12. 배포 및 테스트

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와 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

각 패키지의 역할을 간단히 설명해드릴게요:

  1. socket_io_client: Flutter에서 Socket.IO를 사용하기 위한 클라이언트 라이브러리
  2. provider: 상태 관리를 위한 패키지
  3. shared_preferences: 간단한 데이터 저장을 위한 패키지
  4. image_picker: 갤러리나 카메라에서 이미지를 선택하기 위한 패키지
  5. path_provider: 파일 경로 관련 기능을 제공하는 패키지
  6. 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

각 폴더의 역할을 간단히 설명해드릴게요:

  1. config: 앱의 설정 정보를 담는 폴더
  2. models: 데이터 모델 클래스들을 담는 폴더
  3. services: API 통신, 소켓 연결 등 외부 서비스와의 연동을 담당하는 폴더
  4. providers: 상태 관리를 위한 Provider 클래스들을 담는 폴더
  5. screens: 앱의 각 화면을 담당하는 위젯들을 담는 폴더
  6. widgets: 재사용 가능한 작은 위젯들을 담는 폴더
  7. 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}`);
});

우와~ 이게 바로 우리 채팅앱의 서버예요! 코드가 좀 길지만 하나하나 살펴볼게요.

이 서버는 다음과 같은 기능을 제공해요:

  1. 사용자 로그인: 사용자가 앱에 로그인하면 사용자 정보를 저장하고 다른 사용자들에게 알려줘요.
  2. 메시지 전송: 사용자가 메시지를 보내면 서버가 받아서 수신자에게 전달해요.
  3. 메시지 읽음 표시: 메시지를 읽으면 발신자에게 알려줘요.
  4. 타이핑 표시: 사용자가 메시지를 입력 중일 때 상대방에게 알려줘요.
  5. 연결 해제 처리: 사용자가 앱을 종료하면 다른 사용자들에게 알려줘요.

실제 프로덕션 앱에서는 데이터베이스를 사용해야 하지만, 이 예제에서는 간단하게 메모리에 데이터를 저장하고 있어요. MongoDB나 Firebase를 연결하면 더 좋겠죠? ㅎㅎ

서버를 실행해볼까요?

node index.js

짜잔~ 이제 Socket.IO 서버가 3000번 포트에서 실행되고 있어요! 다음으로 Flutter 앱에서 이 서버에 연결해볼게요! 🚀

Socket.IO 서버 - 사용자 관리 - 메시지 전달 - 상태 업데이트 - 이벤트 브로드캐스팅 Flutter 앱 - UI 렌더링 - 사용자 입력 처리 - 소켓 이벤트 수신 - 상태 관리 로그인 응답 메시지 전송 새 메시지 알림 타이핑 이벤트 실시간 양방향 통신

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 최고! ㅋㅋㅋ

J John Doe 접속 중 안녕하세요! 반가워요 😊 10:30 네 안녕하세요! 저도 반가워요~ 10:31 Flutter로 채팅앱 만드는 중인가요? 10:32 메시지를 입력하세요...

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('바쁨'),
            ],
          ),
        ),
      ],
    ),
  ],
),

이제 사용자 상태를 더 자세히 표시하고 변경할 수 있는 기능이 추가되었어요! 이런 기능은 사용자 경험을 크게 향상시켜요. 상대방이 지금 채팅을 볼 수 있는 상태인지 알 수 있으니까요! ㅋㅋ

접속 중 자리 비움 바쁨 오프라인 J John Doe 접속 중 A Alice Smith 10분 전

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();
  }
  
  // 나머지 메서드들...
}

이제 채팅앱에서 푸시 알림 기능이 구현되었어요! 앱을 사용하지 않을 때도 새 메시지가 오면 알림을 받을 수 있어요. 이런 기능은 실제 메신저 앱에서 정말 중요한 기능이죠! 😊

Flutter 채팅 J John Doe 안녕하세요! 새 메시지가 도착했어요. 지금 FCM 서버를 통해 푸시 알림 전송 사용자가 앱을 사용하지 않을 때도 알림 수신 가능

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에 배포하는 방법을 간단히 알아볼게요:

  1. Heroku 계정 생성 및 Heroku CLI 설치
  2. server 폴더에 Procfile 생성 (내용: web: node index.js)
  3. 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 앱 배포하기

  1. 앱 서명 키 생성
  2. 앱 번들 또는 APK 빌드
  3. Google Play Console에 업로드
flutter build appbundle --release

또는 APK를 빌드하려면:

flutter build apk --release

iOS 앱 배포하기

  1. Apple Developer 계정 필요
  2. Xcode에서 앱 서명 설정
  3. IPA 빌드
  4. 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 실시간 채팅앱 개발 프로세스 개발 Development - 코드 작성 - 기능 구현 - 버그 수정 테스트 Testing - 단위/위젯 테스트 - 통합 테스트 - QA 및 검증 배포 Deployment - 서버 배포 - Android 배포 - iOS 배포 모니터링 Monitoring - Crashlytics - Analytics - 사용자 피드백

마무리: Flutter와 Socket.IO로 만드는 실시간 채팅앱의 세계 🌟

드디어 긴 여정이 끝났네요! Flutter와 Socket.IO를 사용해서 완전한 실시간 채팅앱을 만들어봤어요. 정말 많은 내용을 다뤘죠? ㅋㅋㅋ

이 글에서 우리는 다음과 같은 내용을 배웠어요:

  1. Flutter와 Socket.IO의 기본 개념
  2. 실시간 통신을 위한 서버 구축 방법
  3. Flutter에서 Socket.IO 클라이언트 연결 방법
  4. 채팅 UI 구현 방법
  5. 실시간 메시지 송수신 구현 방법
  6. 사용자 상태 관리 방법
  7. 파일 및 이미지 전송 기능 추가 방법
  8. 푸시 알림 구현 방법
  9. 성능 최적화 기법
  10. 앱 배포 및 테스트 방법

이 모든 지식을 바탕으로 여러분만의 채팅앱을 만들 수 있게 되었어요! 물론 이 글에서 다룬 내용은 기본적인 것들이고, 실제 프로덕션 앱에서는 더 많은 기능과 최적화가 필요할 수 있어요.

하지만 이 글이 여러분의 Flutter 개발 여정에 도움이 되었으면 좋겠어요. 여러분만의 창의적인 아이디어를 더해서 더 멋진 앱을 만들어보세요! 🚀

혹시 Flutter 개발에 관심이 있으시거나, 채팅앱을 만들고 싶은데 도움이 필요하시다면 재능넷에서 관련 재능을 찾아보세요! 많은 실력 있는 개발자분들이 여러분의 프로젝트를 도와드릴 준비가 되어 있답니다. 😊

마지막으로, 코딩은 끊임없는 학습의 과정이에요. 새로운 기술과 패턴을 계속 배우고 적용해보세요. 그리고 무엇보다 코딩을 즐기세요! 코딩은 정말 재밌는 활동이니까요! ㅋㅋㅋ

행복한 코딩 되세요! 👋

댓글 작성

이 글에 대한 여러분의 생각을 들려주세요

댓글 0
댓글을 불러오는 중입니다.

아직 댓글이 없습니다.

지식인의 숲 - 지적 재산권 보호 고지

지적 재산권 보호 고지

  1. 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
  2. AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
  3. 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
  4. 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
  5. AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
4.3K

홈페이지 연동 모바일 앱, 유튜브 연동 앱, 퀴즈 앱 등 앱개발을 도와 드려요.

안녕하세요. 안드로이드 기반 개인 앱, 프로젝트용 앱부터 그 이상 기능이 추가된 앱까지 제작해 드립니다. - 앱 개발 툴: 안드로이드 스튜디오 - 안드로이드 언어: JAVA, XML - 데이터베이스 언어: 로컬DB-SQLite, 웹DB-MYSQL - 안드로이드 와 서버 통신 언어 - PHP 기능 추가 시 구현정도에 따라 협의가 필요하며 밑에 사항과 같이 연

8.3K

신뢰있는 앱 개발, 아무에게나 맡기지 마세요!

본 페이지는 실제 서비스와 시스템을 개발·운영하며 축적한 개발 경험과 프로젝트 사례를 소개합니다.사용자 화면, 관리 기능, 내부 처리 구조 등 서비스 전반을 고려한 개발 경험을 바탕으로 구성되어 있습니다. 150만명 회원 규모의 서비스를 직접 개발·운영해 온 경험을 바탕으로, 현실적인 운영 환경에 적합한 실효성 있는 솔루션을 제안합니다. 각 프로젝트는 단순

9.7K

사이트를 모바일앱으로 제작해 드립니다. 안드로이드 아이폰 앱제작 어플제작 전문

운영하는 사이트 주소가 있다면 사이트를 안드로이드 앱으로 만들어 드립니다. 기본 5000원은 아무런 기능이 없고 단순히 html 페이지를 로딩하는 앱을 제작하는 경우입니다. 구매할때 쇼핑몰 및 커뮤니티 사이트 등 일반사이트들은 구매옵션의 자바스크립트 지원을 필수 선택해야 제작해드립니다. 아이폰 ios 용 앱제작 의뢰의 경우 협의 가격으로 진행됩니다.먼저 문

1.6K

[Android / JAVA/ C] 신호처리 알고리즘/ 안드로이드 앱 개발

안녕하세요. 신호처리를 전공한 개발자 입니다. 1. 영상신호처리, 생체신호처리 알고리즘 개발 2. 안드로이드 앱 개발 3. 윈도우 프로그램 개발 위와 같은 개발에 도움을 드릴 수 있습니다.

1.8K

안드로이드, 메트렙, 자료구조, 신호처리, 통신이론 요청 받습니다.

------------------------------------ 만들고 싶어하는 앱을 제작해드립니다. ------------------------------------ 1. 안드로이드 ( 자바 ) * 블루투스, 카메라, 미디어 플레이어, 음성인식, 가계부, 소개팅 앱, 알람 앱, 사진 앱 등등 원하시는 어플리케이션을 만들어 드립니다. 2. 자료구조 ( C

734

내가 원하는 안드로이드, 아이폰 맞춤형 앱 개발

서비스 설명 맞춤형 앱 개발 전문회사로 의뢰자의 요청사항에 맞춘 기능을 검토해 빠르고 정확하게 개발해 드립니다. 정확한 작업 공정표에 의거 프로젝트 개발 기간을 최소로 잡고 진행해드립니다! ** 반드시 의뢰 내역 상담을 통해 최종 견적을 받아 주시고 재능넷에서 결제 바랍니다 ** 네이티브, 하이브리드 개발 전문팀으로 구성되어 있습니다. Android, iO

145

홈페이지를 앱처럼 PWA 전환 및 푸시 알림 개발

기존 홈페이지를 스마트폰 앱처럼 사용하고, 필요한 알림까지 전달할 수 있습니다. 별도의 앱스토어 등록 없이 홈페이지를 스마트폰 홈 화면에 설치하고 실행할 수 있도록 PWA(Progressive Web App)로 전환해 드립니다. 공지사항을 직접 발송하거나, 예약·신청·접수 등 업무 상황에 따라 자동으로 알림을 보내는 기능도 구현할 수 있습니다. 주요 제공

58

구글플레이/앱스토어 출시 등록 대행 및 심사 대응

※ 모든 상담과 진행 연락은 재능넷 메시지로만 합니다. 전화는 받지 않으니 메시지를 남겨 주세요. 등록부터 출시까지 한 곳에서 끝냅니다! (테스터 12명 포함) 등록 대행 따로, 테스터 따로 사지 마세요. 구글 플레이 출시에 필요한 일은 전부 80,000원 안에 들어 있습니다. (테스터 12명 · 14일 비공개 테스트 · 프로덕션 신청 · 심사 대응까지)

Loading...