1 files changed, 33 insertions, 20 deletions

diff --git a/examples/chat/client.rs b/examples/chat/client.rs
index 15d515a..dceaf23 100644
--- a/examples/chat/client.rs
+++ b/examples/chat/client.rs
@@ -8,14 +8,14 @@ use bevy::{
     app::{AppExit, ScheduleRunnerPlugin},
     log::LogPlugin,
     prelude::{
-        info, warn, App, Commands, CoreStage, Deref, DerefMut, EventReader, EventWriter, Res,
+        info, warn, App, Commands, CoreStage, Deref, DerefMut, EventReader, EventWriter, Query,
         ResMut, Resource,
     },
 };
 use bevy_quinnet::{
     client::{
-        certificate::CertificateVerificationMode, Client, ClientConfigurationData, ConnectionEvent,
-        QuinnetClientPlugin,
+        certificate::{CertificateVerificationMode, TrustOnFirstUseConfig},
+        Client, Connection, ConnectionConfiguration, ConnectionEvent, QuinnetClientPlugin,
     },
     ClientId,
 };
@@ -35,16 +35,20 @@ struct Users {
 #[derive(Resource, Deref, DerefMut)]
 struct TerminalReceiver(mpsc::Receiver<String>);
 
-pub fn on_app_exit(app_exit_events: EventReader<AppExit>, client: Res<Client>) {
+pub fn on_app_exit(app_exit_events: EventReader<AppExit>, mut connection: Query<&Connection>) {
     if !app_exit_events.is_empty() {
-        client.send_message(ClientMessage::Disconnect {}).unwrap();
+        let connection = connection.get_single_mut().unwrap();
+        connection
+            .send_message(ClientMessage::Disconnect {})
+            .unwrap();
         // TODO Clean: event to let the async client send his last messages.
         sleep(Duration::from_secs_f32(0.1));
     }
 }
 
-fn handle_server_messages(mut client: ResMut<Client>, mut users: ResMut<Users>) {
-    while let Ok(Some(message)) = client.receive_message::<ServerMessage>() {
+fn handle_server_messages(mut users: ResMut<Users>, mut connection: Query<&mut Connection>) {
+    let mut connection = connection.get_single_mut().unwrap();
+    while let Ok(Some(message)) = connection.receive_message::<ServerMessage>() {
         match message {
             ServerMessage::ClientConnected {
                 client_id,
@@ -81,15 +85,16 @@ fn handle_server_messages(mut client: ResMut<Client>, mut users: ResMut<Users>)
 }
 
 fn handle_terminal_messages(
-    client: ResMut<Client>,
     mut terminal_messages: ResMut<TerminalReceiver>,
     mut app_exit_events: EventWriter<AppExit>,
+    mut connection: Query<&Connection>,
 ) {
+    let connection = connection.get_single_mut().unwrap();
     while let Ok(message) = terminal_messages.try_recv() {
         if message == "quit" {
             app_exit_events.send(AppExit);
         } else {
-            client
+            connection
                 .send_message(ClientMessage::ChatMessage { message: message })
                 .expect("Failed to send chat message");
         }
@@ -110,18 +115,25 @@ fn start_terminal_listener(mut commands: Commands) {
     commands.insert_resource(TerminalReceiver(from_terminal_receiver));
 }
 
-fn start_connection(client: ResMut<Client>) {
-    client
-        .connect(
-            ClientConfigurationData::new("127.0.0.1".to_string(), 6000, "0.0.0.0".to_string(), 0),
-            CertificateVerificationMode::SkipVerification,
-        )
-        .unwrap();
-
-    // You can already send message(s) even before being connected, they will be buffered. In this example we will wait for a ConnectionEvent. We could also check client.is_connected()
+fn start_connection(mut commands: Commands, client: ResMut<Client>) {
+    client.spawn_connection(
+        &mut commands,
+        ConnectionConfiguration::new("127.0.0.1".to_string(), 6000, "0.0.0.0".to_string(), 0),
+        CertificateVerificationMode::TrustOnFirstUse(TrustOnFirstUseConfig {
+            known_hosts: bevy_quinnet::client::certificate::KnownHosts::HostsFile(
+                "my_own_hosts_file".to_string(),
+            ),
+            ..Default::default()
+        }),
+    );
+
+    // You can already send message(s) even before being connected, they will be buffered. In this example we will wait for a ConnectionEvent.
 }
 
-fn handle_client_events(connection_events: EventReader<ConnectionEvent>, client: ResMut<Client>) {
+fn handle_client_events(
+    connection_events: EventReader<ConnectionEvent>,
+    mut connection: Query<&Connection>,
+) {
     if !connection_events.is_empty() {
         // We are connected
         let username: String = rand::thread_rng()
@@ -133,7 +145,8 @@ fn handle_client_events(connection_events: EventReader<ConnectionEvent>, client:
         println!("--- Joining with name: {}", username);
         println!("--- Type 'quit' to disconnect");
 
-        client
+        let connection = connection.get_single_mut().unwrap();
+        connection
             .send_message(ClientMessage::Join { name: username })
             .unwrap();