signalling server

Signed-off-by: ale <ale@manalejandro.com>

server/server.js

@@ -0,0 +1,541 @@
+const express = require('express');
+const http = require('http');
+const socketIo = require('socket.io');
+const cors = require('cors');
+const path = require('path');
+
+const app = express();
+const server = http.createServer(app);
+const io = socketIo(server, {
+    cors: {
+        origin: "*",
+        methods: ["GET", "POST"],
+        allowedHeaders: ["Content-Type"],
+        credentials: true
+    },
+    transports: ['websocket', 'polling']
+});
+
+// Middleware
+app.use(cors());
+app.use(express.json());
+app.use(express.static(path.join(__dirname, 'public')));
+
+// Store active users and rooms
+const users = new Map(); // socketId -> user info
+const rooms = new Map(); // roomId -> Set of socketIds
+const userRooms = new Map(); // socketId -> roomId
+
+// Default room for all users
+const DEFAULT_ROOM = 'main-chat';
+
+// Utility functions
+function getUserInfo(socketId) {
+    return users.get(socketId);
+}
+
+function addUserToRoom(socketId, roomId = DEFAULT_ROOM) {
+    if (!rooms.has(roomId)) {
+        rooms.set(roomId, new Set());
+    }
+    rooms.get(roomId).add(socketId);
+    userRooms.set(socketId, roomId);
+}
+
+function removeUserFromRoom(socketId) {
+    const roomId = userRooms.get(socketId);
+    if (roomId && rooms.has(roomId)) {
+        rooms.get(roomId).delete(socketId);
+        if (rooms.get(roomId).size === 0) {
+            rooms.delete(roomId);
+        }
+    }
+    userRooms.delete(socketId);
+}
+
+function getRoomUsers(roomId) {
+    const roomUsers = [];
+    if (rooms.has(roomId)) {
+        for (const socketId of rooms.get(roomId)) {
+            const user = users.get(socketId);
+            if (user) {
+                roomUsers.push({
+                    socketId,
+                    nickname: user.nickname,
+                    joinedAt: user.joinedAt
+                });
+            }
+        }
+    }
+    return roomUsers;
+}
+
+function broadcastToRoom(roomId, event, data, exceptSocketId = null) {
+    if (rooms.has(roomId)) {
+        for (const socketId of rooms.get(roomId)) {
+            if (socketId !== exceptSocketId) {
+                io.to(socketId).emit(event, data);
+            }
+        }
+    }
+}
+
+// Socket.IO connection handling
+io.on('connection', (socket) => {
+    console.log(`[${new Date().toISOString()}] User connected: ${socket.id}`);
+
+    // Handle user joining
+    socket.on('join-room', (data) => {
+        try {
+            const { nickname, roomId = DEFAULT_ROOM } = typeof data === 'string' 
+                ? { nickname: data, roomId: DEFAULT_ROOM }
+                : data;
+
+            if (!nickname || nickname.trim().length === 0) {
+                socket.emit('error', { message: 'Nickname is required' });
+                return;
+            }
+
+            // Check if nickname is already taken in the room
+            const roomUsers = getRoomUsers(roomId);
+            const nicknameExists = roomUsers.some(user => 
+                user.nickname.toLowerCase() === nickname.toLowerCase()
+            );
+
+            if (nicknameExists) {
+                socket.emit('error', { 
+                    message: 'Nickname already taken in this room',
+                    code: 'NICKNAME_TAKEN'
+                });
+                return;
+            }
+
+            // Store user information
+            const userInfo = {
+                nickname: nickname.trim(),
+                roomId,
+                joinedAt: new Date().toISOString(),
+                isVideoEnabled: true,
+                isAudioEnabled: true
+            };
+            
+            users.set(socket.id, userInfo);
+            addUserToRoom(socket.id, roomId);
+
+            // Join socket room
+            socket.join(roomId);
+
+            // Notify user they successfully joined
+            socket.emit('joined-room', {
+                roomId,
+                nickname: userInfo.nickname,
+                users: getRoomUsers(roomId)
+            });
+
+            // Notify others in the room
+            broadcastToRoom(roomId, 'user-joined', {
+                socketId: socket.id,
+                nickname: userInfo.nickname,
+                joinedAt: userInfo.joinedAt
+            }, socket.id);
+
+            console.log(`[${new Date().toISOString()}] ${userInfo.nickname} joined room: ${roomId}`);
+
+        } catch (error) {
+            console.error('Error in join-room:', error);
+            socket.emit('error', { message: 'Failed to join room' });
+        }
+    });
+
+    // Handle WebRTC signaling - Offer
+    socket.on('offer', (data) => {
+        try {
+            const user = getUserInfo(socket.id);
+            if (!user) {
+                socket.emit('error', { message: 'Not authenticated' });
+                return;
+            }
+
+            const { targetSocketId, offer } = data;
+            
+            if (targetSocketId) {
+                // Send to specific user
+                io.to(targetSocketId).emit('offer', {
+                    fromSocketId: socket.id,
+                    fromNickname: user.nickname,
+                    offer
+                });
+            } else {
+                // Broadcast to room (for group calls)
+                broadcastToRoom(user.roomId, 'offer', {
+                    fromSocketId: socket.id,
+                    fromNickname: user.nickname,
+                    offer
+                }, socket.id);
+            }
+
+            console.log(`[${new Date().toISOString()}] Offer from ${user.nickname} to ${targetSocketId || 'room'}`);
+
+        } catch (error) {
+            console.error('Error in offer:', error);
+            socket.emit('error', { message: 'Failed to send offer' });
+        }
+    });
+
+    // Handle WebRTC signaling - Answer
+    socket.on('answer', (data) => {
+        try {
+            const user = getUserInfo(socket.id);
+            if (!user) {
+                socket.emit('error', { message: 'Not authenticated' });
+                return;
+            }
+
+            const { targetSocketId, answer } = data;
+            
+            if (targetSocketId) {
+                io.to(targetSocketId).emit('answer', {
+                    fromSocketId: socket.id,
+                    fromNickname: user.nickname,
+                    answer
+                });
+            }
+
+            console.log(`[${new Date().toISOString()}] Answer from ${user.nickname} to ${targetSocketId}`);
+
+        } catch (error) {
+            console.error('Error in answer:', error);
+            socket.emit('error', { message: 'Failed to send answer' });
+        }
+    });
+
+    // Handle WebRTC signaling - ICE Candidate
+    socket.on('ice-candidate', (data) => {
+        try {
+            const user = getUserInfo(socket.id);
+            if (!user) {
+                socket.emit('error', { message: 'Not authenticated' });
+                return;
+            }
+
+            const { targetSocketId, candidate } = data;
+            
+            if (targetSocketId) {
+                io.to(targetSocketId).emit('ice-candidate', {
+                    fromSocketId: socket.id,
+                    fromNickname: user.nickname,
+                    candidate
+                });
+            } else {
+                // Broadcast to room
+                broadcastToRoom(user.roomId, 'ice-candidate', {
+                    fromSocketId: socket.id,
+                    fromNickname: user.nickname,
+                    candidate
+                }, socket.id);
+            }
+
+        } catch (error) {
+            console.error('Error in ice-candidate:', error);
+            socket.emit('error', { message: 'Failed to send ICE candidate' });
+        }
+    });
+
+    // Handle media state changes
+    socket.on('media-state', (data) => {
+        try {
+            const user = getUserInfo(socket.id);
+            if (!user) {
+                socket.emit('error', { message: 'Not authenticated' });
+                return;
+            }
+
+            const { isVideoEnabled, isAudioEnabled } = data;
+            
+            // Update user state
+            user.isVideoEnabled = isVideoEnabled;
+            user.isAudioEnabled = isAudioEnabled;
+
+            // Broadcast to room
+            broadcastToRoom(user.roomId, 'user-media-state', {
+                socketId: socket.id,
+                nickname: user.nickname,
+                isVideoEnabled,
+                isAudioEnabled
+            }, socket.id);
+
+            console.log(`[${new Date().toISOString()}] ${user.nickname} media state - Video: ${isVideoEnabled}, Audio: ${isAudioEnabled}`);
+
+        } catch (error) {
+            console.error('Error in media-state:', error);
+        }
+    });
+
+    // Handle chat messages (backup for data channel failures)
+    socket.on('chat-message', (data) => {
+        try {
+            const user = getUserInfo(socket.id);
+            if (!user) {
+                socket.emit('error', { message: 'Not authenticated' });
+                return;
+            }
+
+            const { message } = data;
+            if (!message || message.trim().length === 0) {
+                return;
+            }
+
+            const messageData = {
+                fromSocketId: socket.id,
+                fromNickname: user.nickname,
+                message: message.trim(),
+                timestamp: new Date().toISOString()
+            };
+
+            // Broadcast to room
+            broadcastToRoom(user.roomId, 'chat-message', messageData, socket.id);
+
+            console.log(`[${new Date().toISOString()}] Message from ${user.nickname}: ${message}`);
+
+        } catch (error) {
+            console.error('Error in chat-message:', error);
+        }
+    });
+
+    // Handle room list request
+    socket.on('get-rooms', () => {
+        try {
+            const roomList = [];
+            for (const [roomId, userSet] of rooms.entries()) {
+                roomList.push({
+                    roomId,
+                    userCount: userSet.size,
+                    users: getRoomUsers(roomId).map(u => ({
+                        nickname: u.nickname,
+                        joinedAt: u.joinedAt
+                    }))
+                });
+            }
+            socket.emit('rooms-list', roomList);
+        } catch (error) {
+            console.error('Error getting rooms:', error);
+            socket.emit('error', { message: 'Failed to get rooms' });
+        }
+    });
+
+    // Handle user list request for current room
+    socket.on('get-room-users', () => {
+        try {
+            const user = getUserInfo(socket.id);
+            if (user) {
+                const roomUsers = getRoomUsers(user.roomId);
+                socket.emit('room-users', {
+                    roomId: user.roomId,
+                    users: roomUsers
+                });
+            }
+        } catch (error) {
+            console.error('Error getting room users:', error);
+        }
+    });
+
+    // Handle ping for connection monitoring
+    socket.on('ping', () => {
+        socket.emit('pong', { timestamp: Date.now() });
+    });
+
+    // Handle disconnection
+    socket.on('disconnect', (reason) => {
+        try {
+            const user = getUserInfo(socket.id);
+            if (user) {
+                // Notify others in the room
+                broadcastToRoom(user.roomId, 'user-left', {
+                    socketId: socket.id,
+                    nickname: user.nickname,
+                    reason
+                });
+
+                console.log(`[${new Date().toISOString()}] ${user.nickname} left room: ${user.roomId} (${reason})`);
+                
+                // Clean up
+                removeUserFromRoom(socket.id);
+                users.delete(socket.id);
+            } else {
+                console.log(`[${new Date().toISOString()}] Unknown user disconnected: ${socket.id} (${reason})`);
+            }
+        } catch (error) {
+            console.error('Error handling disconnect:', error);
+        }
+    });
+
+    // Handle errors
+    socket.on('error', (error) => {
+        console.error(`[${new Date().toISOString()}] Socket error for ${socket.id}:`, error);
+    });
+});
+
+// REST API endpoints
+app.get('/api/status', (req, res) => {
+    res.json({
+        status: 'running',
+        timestamp: new Date().toISOString(),
+        connectedUsers: users.size,
+        activeRooms: rooms.size,
+        uptime: process.uptime()
+    });
+});
+
+app.get('/api/rooms', (req, res) => {
+    const roomList = [];
+    for (const [roomId, userSet] of rooms.entries()) {
+        roomList.push({
+            roomId,
+            userCount: userSet.size,
+            users: getRoomUsers(roomId).map(u => ({
+                nickname: u.nickname,
+                joinedAt: u.joinedAt
+            }))
+        });
+    }
+    res.json(roomList);
+});
+
+app.get('/api/rooms/:roomId', (req, res) => {
+    const { roomId } = req.params;
+    if (rooms.has(roomId)) {
+        res.json({
+            roomId,
+            userCount: rooms.get(roomId).size,
+            users: getRoomUsers(roomId)
+        });
+    } else {
+        res.status(404).json({ error: 'Room not found' });
+    }
+});
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+    res.status(200).json({ 
+        status: 'healthy',
+        timestamp: new Date().toISOString()
+    });
+});
+
+// Serve a simple test page
+app.get('/', (req, res) => {
+    res.send(`
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>ChatRTC Signaling Server</title>
+            <meta charset="utf-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1">
+            <style>
+                body { font-family: Arial, sans-serif; margin: 40px; background: #f5f5f5; }
+                .container { max-width: 800px; margin: 0 auto; background: white; padding: 30px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
+                h1 { color: #2196F3; }
+                .status { background: #e8f5e8; padding: 15px; border-radius: 5px; margin: 20px 0; }
+                .endpoint { background: #f8f9fa; padding: 10px; margin: 10px 0; border-left: 4px solid #2196F3; }
+                code { background: #f0f0f0; padding: 2px 5px; border-radius: 3px; }
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <h1>🚀 ChatRTC Signaling Server</h1>
+                <div class="status">
+                    <strong>✅ Server is running successfully!</strong><br>
+                    Connected Users: <span id="users">${users.size}</span><br>
+                    Active Rooms: <span id="rooms">${rooms.size}</span><br>
+                    Uptime: <span id="uptime">${Math.floor(process.uptime())}s</span>
+                </div>
+                
+                <h2>📡 API Endpoints</h2>
+                <div class="endpoint">
+                    <strong>GET /api/status</strong> - Server status and statistics
+                </div>
+                <div class="endpoint">
+                    <strong>GET /api/rooms</strong> - List all active rooms
+                </div>
+                <div class="endpoint">
+                    <strong>GET /api/rooms/:roomId</strong> - Get specific room info
+                </div>
+                <div class="endpoint">
+                    <strong>GET /health</strong> - Health check endpoint
+                </div>
+                
+                <h2>🔧 Socket.IO Events</h2>
+                <p>The server handles the following Socket.IO events for WebRTC signaling:</p>
+                <ul>
+                    <li><code>join-room</code> - Join a chat room</li>
+                    <li><code>offer</code> - WebRTC offer signaling</li>
+                    <li><code>answer</code> - WebRTC answer signaling</li>
+                    <li><code>ice-candidate</code> - ICE candidate exchange</li>
+                    <li><code>media-state</code> - Video/audio state updates</li>
+                    <li><code>chat-message</code> - Text message fallback</li>
+                </ul>
+                
+                <h2>📱 Android App Connection</h2>
+                <p>Update your Android app's WebRTCManager.java with this server URL:</p>
+                <div class="endpoint">
+                    <code>private static final String SIGNALING_SERVER_URL = "http://YOUR_SERVER_IP:${process.env.PORT || 3000}";</code>
+                </div>
+                
+                <p><em>Server started at: ${new Date().toISOString()}</em></p>
+            </div>
+            
+            <script>
+                // Auto-refresh stats every 5 seconds
+                setInterval(async () => {
+                    try {
+                        const response = await fetch('/api/status');
+                        const data = await response.json();
+                        document.getElementById('users').textContent = data.connectedUsers;
+                        document.getElementById('rooms').textContent = data.activeRooms;
+                        document.getElementById('uptime').textContent = Math.floor(data.uptime) + 's';
+                    } catch (error) {
+                        console.error('Failed to update stats:', error);
+                    }
+                }, 5000);
+            </script>
+        </body>
+        </html>
+    `);
+});
+
+// Error handling
+app.use((err, req, res, next) => {
+    console.error('Express error:', err);
+    res.status(500).json({ error: 'Internal server error' });
+});
+
+// Graceful shutdown
+process.on('SIGTERM', () => {
+    console.log('SIGTERM received, shutting down gracefully');
+    server.close(() => {
+        console.log('Server closed');
+        process.exit(0);
+    });
+});
+
+process.on('SIGINT', () => {
+    console.log('SIGINT received, shutting down gracefully');
+    server.close(() => {
+        console.log('Server closed');
+        process.exit(0);
+    });
+});
+
+// Start server
+const PORT = process.env.PORT || 3000;
+const HOST = process.env.HOST || '0.0.0.0';
+
+server.listen(PORT, HOST, () => {
+    console.log('🚀 ChatRTC Signaling Server Started');
+    console.log(`📡 Server running on http://${HOST}:${PORT}`);
+    console.log(`🌐 Socket.IO enabled with CORS`);
+    console.log(`📱 Ready for Android app connections`);
+    console.log(`⏰ Started at: ${new Date().toISOString()}`);
+});
+
+module.exports = { app, server, io };