Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Create a full chat application in rust and link it with flutter

  1. User

    Create a full chat application in rust and link it with flutter

  2. Assistant

    Certainly! Creating a full-featured chat application involves building both a backend server to handle message routing and a frontend client for user interaction. In this case, we'll use Rust for the backend and Flutter for the frontend. Rust provides performance and safety, making it ideal for a backend that can handle concurrent connections efficiently. Flutter allows for a beautiful and performant cross-platform UI.

    Below is a step-by-step guide to help you build a chat application using Rust and Flutter.


    Table of Contents

    1. Prerequisites
    2. Setting Up the Rust Backend
    3. Building the Flutter Frontend
    4. Integrating Backend and Frontend
    5. Running and Testing the Application
    6. Next Steps and Enhancements
    7. Conclusion

    1. Prerequisites

    Before starting, ensure you have the following installed on your machine:

    • Rust: Install from the official website.
    • Cargo: Comes with Rust installation.
    • Flutter SDK: Install from the Flutter website.
    • Visual Studio Code or another IDE (optional but recommended).
    • Web or Mobile Platform: Depending on where you want to run your Flutter app.

    2. Setting Up the Rust Backend

    Project Initialization

    Start by creating a new Rust project:

    cargo new chat-server --bin
    cd chat-server
    

    Choosing a Web Framework

    For the backend, we'll use Actix Web, a powerful and ergonomic web framework for Rust that supports asynchronous operations and WebSockets.

    Add dependencies in your Cargo.toml:

    [dependencies]
    actix-web = "4"
    actix = "0.13"
    actix-web-actors = "4" # For WebSocket support
    serde = { version = "1.0", features = ["derive"] }
    serde_json = "1.0"
    

    Update crates:

    cargo update
    

    Implementing WebSocket Communication

    Create a WebSocket server that handles incoming connections and messages.

    main.rs

    use actix::*;
    use actix_web::{web, App, Error, HttpRequest, HttpResponse, HttpServer};
    use actix_web_actors::ws;
    
    mod server;
    use server::ChatServer;
    
    async fn ws_index(
        req: HttpRequest,
        stream: web::Payload,
        srv: web::Data<Addr<ChatServer>>,
    ) -> Result<HttpResponse, Error> {
        ws::start(
            WebSocketSession {
                id: 0,
                room: "main".to_owned(),
                name: None,
                addr: srv.get_ref().clone(),
            },
            &req,
            stream,
        )
    }
    
    #[actix_rt::main]
    async fn main() -> std::io::Result<()> {
        let chat_server = ChatServer::default().start();
    
        HttpServer::new(move || {
            App::new()
                .data(chat_server.clone())
                .route("/ws/", web::get().to(ws_index))
        })
        .bind("127.0.0.1:8080")?
        .run()
        .await
    }
    

    server.rs

    use actix::*;
    use actix_web_actors::ws;
    use std::collections::HashMap;
    
    #[derive(Message)]
    #[rtype(result = "()")]
    pub struct ClientMessage(pub String);
    
    pub struct ChatServer {
        sessions: HashMap<usize, Recipient<ClientMessage>>,
        id_counter: usize,
    }
    
    impl Default for ChatServer {
        fn default() -> ChatServer {
            ChatServer {
                sessions: HashMap::new(),
                id_counter: 0,
            }
        }
    }
    
    impl ChatServer {
        fn send_message(&self, message: &str, skip_id: usize) {
            for (id, recipient) in &self.sessions {
                if *id != skip_id {
                    let _ = recipient.do_send(ClientMessage(message.to_owned()));
                }
            }
        }
    }
    
    impl Actor for ChatServer {
        type Context = Context<Self>;
    }
    
    // Message for connecting a session
    #[derive(Message)]
    #[rtype(usize)]
    pub struct Connect {
        pub addr: Recipient<ClientMessage>,
    }
    
    // Message for disconnecting a session
    #[derive(Message)]
    #[rtype(result = "()")]
    pub struct Disconnect {
        pub id: usize,
    }
    
    // Message for incoming chat messages
    #[derive(Message)]
    #[rtype(result = "()")]
    pub struct Message {
        pub id: usize,
        pub msg: String,
    }
    
    impl Handler<Connect> for ChatServer {
        type Result = usize;
    
        fn handle(&mut self, msg: Connect, _: &mut Context<Self>) -> Self::Result {
            self.id_counter += 1;
            self.sessions.insert(self.id_counter, msg.addr);
            self.id_counter
        }
    }
    
    impl Handler<Disconnect> for ChatServer {
        type Result = ();
    
        fn handle(&mut self, msg: Disconnect, _: &mut Context<Self>) {
            self.sessions.remove(&msg.id);
        }
    }
    
    impl Handler<Message> for ChatServer {
        type Result = ();
    
        fn handle(&mut self, msg: Message, _: &mut Context<Self>) {
            self.send_message(&msg.msg, msg.id);
        }
    }
    
    // WebSocket session
    pub struct WebSocketSession {
        pub id: usize,
        pub room: String,
        pub name: Option<String>,
        pub addr: Addr<ChatServer>,
    }
    
    impl Actor for WebSocketSession {
        type Context = ws::WebsocketContext<Self>;
    
        fn started(&mut self, ctx: &mut Self::Context) {
            let addr = ctx.address();
    
            let res = self.addr.send(Connect {
                addr: addr.recipient(),
            });
    
            res.into_actor(self)
                .then(|res, act, ctx| {
                    match res {
                        Ok(id) => act.id = id,
                        _ => ctx.stop(),
                    }
                    fut::ready(())
                })
                .wait(ctx);
        }
    
        fn stopping(&mut self, _: &mut Self::Context) -> Running {
            self.addr.do_send(Disconnect { id: self.id });
            Running::Stop
        }
    }
    
    // Handle incoming WebSocket messages
    impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for WebSocketSession {
        fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
            if let Ok(ws::Message::Text(text)) = msg {
                self.addr.do_send(Message {
                    id: self.id,
                    msg: text,
                });
            }
        }
    }
    
    // Handle messages from the server
    impl Handler<ClientMessage> for WebSocketSession {
        type Result = ();
    
        fn handle(&mut self, msg: ClientMessage, ctx: &mut Self::Context) {
            ctx.text(msg.0);
        }
    }
    

    Handling Chat Logic

    The above code sets up a basic chat server where:

    • Each connected client is assigned a unique ID.
    • Messages received from a client are broadcasted to all other connected clients.
    • The server handles client connections, disconnections, and message routing.

    3. Building the Flutter Frontend

    Project Setup

    Create a new Flutter project:

    flutter create chat_app
    cd chat_app
    

    Ensure you have the necessary dependencies in your pubspec.yaml:

    dependencies:
      flutter:
        sdk: flutter
      web_socket_channel: ^2.2.0
    

    Run flutter pub get to fetch the packages.

    UI Design

    Design a simple chat interface with a message list and an input field.

    lib/main.dart

    import 'package:flutter/material.dart';
    import 'package:web_socket_channel/io.dart';
    import 'package:web_socket_channel/web_socket_channel.dart';
    
    void main() => runApp(ChatApp());
    
    class ChatApp extends StatelessWidget {
      @override
      Widget build(BuildContext context) {
        return MaterialApp(
          title: 'Rust Flutter Chat',
          home: ChatPage(
            channel: IOWebSocketChannel.connect('ws://localhost:8080/ws/'),
          ),
        );
      }
    }
    
    class ChatPage extends StatefulWidget {
      final WebSocketChannel channel;
    
      ChatPage({required this.channel});
    
      @override
      _ChatPageState createState() => _ChatPageState();
    }
    
    class _ChatPageState extends State<ChatPage> {
      TextEditingController _controller = TextEditingController();
      List<String> _messages = [];
    
      @override
      void initState() {
        widget.channel.stream.listen((message) {
          setState(() {
            _messages.add(message);
          });
        });
        super.initState();
      }
    
      void _sendMessage() {
        if (_controller.text.isNotEmpty) {
          widget.channel.sink.add(_controller.text);
          setState(() {
            _messages.add("Me: " + _controller.text);
          });
          _controller.text = '';
        }
      }
    
      @override
      void dispose() {
        widget.channel.sink.close();
        _controller.dispose();
        super.dispose();
      }
    
      @override
      Widget build(BuildContext context) {
        return Scaffold(
            appBar: AppBar(
              title: Text('Rust Flutter Chat'),
            ),
            body: Column(
              children: [
                Expanded(
                    child: ListView.builder(
                        itemCount: _messages.length,
                        itemBuilder: (context, index) {
                          return ListTile(
                            title: Text(_messages[index]),
                          );
                        })),
                Padding(
                  padding: const EdgeInsets.symmetric(horizontal: 8.0),
                  child: Row(
                    children: [
                      Expanded(
                          child: TextField(
                        controller: _controller,
                        decoration:
                            InputDecoration(hintText: 'Enter your message'),
                      )),
                      IconButton(
                        icon: Icon(Icons.send),
                        onPressed: _sendMessage,
                      )
                    ],
                  ),
                )
              ],
            ));
      }
    }
    

    Establishing WebSocket Connection

    • Use web_socket_channel to connect to the Rust backend WebSocket server.
    • Replace 'ws://localhost:8080/ws/' with your server's IP address and port if running on a device.

    Sending and Receiving Messages

    • When the user sends a message, it is sent over the WebSocket channel.
    • Incoming messages are added to the _messages list and displayed in the ListView.

    4. Integrating Backend and Frontend

    • Ensure CORS and Network Permissions:

      • On mobile devices, update the app's network permissions (if necessary).
      • In the Rust server, you may need to handle CORS settings if you're making HTTP requests.
    • Run the Backend Server:

      • Start the Rust server by running cargo run in the chat-server directory.
    • Run the Flutter App:

      • Ensure the Flutter app can access localhost. If testing on a simulator/emulator, localhost refers to the local machine.
      • For physical devices, use the machine's IP address instead of localhost.

    5. Running and Testing the Application

    • Backend:

      • Open a terminal in the chat-server directory.
      • Run cargo run.
      • The server should start listening on 127.0.0.1:8080.
    • Frontend:

      • Open another terminal in the chat_app directory.
      • Run flutter run.
      • Launch the app on your desired platform.
    • Testing:

      • Open multiple instances of the app (emulators or web browsers).
      • Send messages from one instance and observe them appearing on the others.

    6. Next Steps and Enhancements

    • Authentication:

      • Implement user authentication to identify different users.
      • Use JWT or sessions for managing authenticated users.
    • Persistent Storage:

      • Store messages in a database (e.g., PostgreSQL, SQLite) using Rust ORM libraries like Diesel or sqlx.
      • Enable message history retrieval.
    • Message Formatting:

      • Enhance the frontend to display messages with timestamps and sender names.
      • Support rich text or multimedia messages.
    • Error Handling:

      • Implement proper error handling in both the backend and frontend.
      • Handle network disconnections gracefully.
    • Rooms/Channels:

      • Allow users to create or join different chat rooms.
      • Modify the server code to handle room-based message routing.
    • Deployment:

      • Deploy the Rust backend on a server or cloud platform.
      • Configure the Flutter app to connect to the deployed backend.

    7. Conclusion

    By following this guide, you've set up a fundamental chat application using Rust for the backend and Flutter for the frontend. While this application is basic, it provides a solid foundation upon which you can build more complex features. Both Rust and Flutter are powerful tools, and together they can be used to create fast and efficient applications.


    Feel free to ask if you need further clarification or assistance with specific parts of the implementation!