veloren_voxygen/menu/main/
mod.rs

1pub(crate) mod client_init;
2mod ui;
3
4use super::{char_selection::CharSelectionState, dummy_scene::Scene, server_info::ServerInfoState};
5#[cfg(feature = "singleplayer")]
6use crate::singleplayer::SingleplayerState;
7use crate::{
8    Direction, GlobalState, PlayState, PlayStateResult, hud,
9    render::{Drawer, GlobalsBindGroup},
10    session::SessionState,
11    settings::Settings,
12    window::Event,
13};
14use chrono::{DateTime, Local, Utc};
15use client::{
16    Client, ClientInitStage, ServerInfo,
17    addr::ConnectionArgs,
18    error::{InitProtocolError, NetworkConnectError, NetworkError},
19};
20use client_init::{ClientInit, Error as InitError, Msg as InitMsg};
21use common::{comp, event::UpdateCharacterMetadata};
22use common_base::span;
23use common_net::msg::ClientType;
24#[cfg(feature = "plugins")]
25use common_state::plugin::PluginMgr;
26use i18n::{LocalizationGuard, LocalizationHandle, fluent_args};
27#[cfg(feature = "singleplayer")]
28use server::ServerInitStage;
29#[cfg(any(feature = "singleplayer", feature = "plugins"))]
30use specs::WorldExt;
31use std::{cell::RefCell, path::Path, rc::Rc, sync::Arc};
32use tokio::runtime;
33use tracing::error;
34use ui::{Event as MainMenuEvent, MainMenuUi};
35
36pub use ui::rand_bg_image_spec;
37
38#[derive(Debug)]
39pub enum DetailedInitializationStage {
40    #[cfg(feature = "singleplayer")]
41    Singleplayer,
42    #[cfg(feature = "singleplayer")]
43    SingleplayerServer(ServerInitStage),
44    StartingMultiplayer,
45    Client(ClientInitStage),
46    CreatingRenderPipeline(usize, usize),
47}
48
49enum InitState {
50    None,
51    // Waiting on the client initialization
52    Client(ClientInit),
53    // Client initialized but still waiting on Renderer pipeline creation
54    Pipeline(Box<Client>, hud::MessageBacklog),
55}
56
57impl InitState {
58    fn client(&self) -> Option<&ClientInit> {
59        if let Self::Client(client_init) = &self {
60            Some(client_init)
61        } else {
62            None
63        }
64    }
65}
66
67pub struct MainMenuState {
68    main_menu_ui: MainMenuUi,
69    init: InitState,
70    scene: Scene,
71}
72
73impl MainMenuState {
74    /// Create a new `MainMenuState`.
75    pub fn new(global_state: &mut GlobalState) -> Self {
76        Self {
77            main_menu_ui: MainMenuUi::new(global_state),
78            init: InitState::None,
79            scene: Scene::new(global_state.window.renderer_mut()),
80        }
81    }
82}
83
84impl PlayState for MainMenuState {
85    fn enter(&mut self, global_state: &mut GlobalState, _: Direction) {
86        // Kick off title music
87        if global_state.settings.audio.output.is_enabled() && global_state.audio.music_enabled() {
88            global_state.audio.play_title_music();
89        }
90
91        // Reset singleplayer server if it was running already
92        #[cfg(feature = "singleplayer")]
93        {
94            global_state.singleplayer = SingleplayerState::None;
95        }
96
97        // Updated localization in case the selected language was changed
98        self.main_menu_ui
99            .update_language(global_state.i18n, &global_state.settings);
100        // Set scale mode in case it was change
101        self.main_menu_ui
102            .set_scale_mode(global_state.settings.interface.ui_scale);
103
104        #[cfg(feature = "discord")]
105        global_state.discord.enter_main_menu();
106    }
107
108    fn tick(&mut self, global_state: &mut GlobalState, events: Vec<Event>) -> PlayStateResult {
109        span!(_guard, "tick", "<MainMenuState as PlayState>::tick");
110
111        // Pull in localizations
112        let localized_strings = &global_state.i18n.read();
113
114        // Poll server creation
115        #[cfg(feature = "singleplayer")]
116        {
117            if let Some(singleplayer) = global_state.singleplayer.as_running() {
118                if let Ok(stage_update) = singleplayer.init_stage_receiver.try_recv() {
119                    self.main_menu_ui.update_stage(
120                        DetailedInitializationStage::SingleplayerServer(stage_update),
121                    );
122                }
123
124                match singleplayer.receiver.try_recv() {
125                    Ok(Ok(())) => {
126                        // Attempt login after the server is finished initializing
127                        attempt_login(
128                            &mut global_state.info_message,
129                            "singleplayer".to_owned(),
130                            "".to_owned(),
131                            ConnectionArgs::Mpsc(14004),
132                            &mut self.init,
133                            &global_state.tokio_runtime,
134                            global_state.settings.language.send_to_server.then_some(
135                                global_state.settings.language.selected_language.clone(),
136                            ),
137                            &global_state.i18n,
138                            &global_state.config_dir,
139                            global_state.args.client_type.0,
140                        );
141                    },
142                    Ok(Err(e)) => {
143                        error!(?e, "Could not start server");
144                        global_state.singleplayer = SingleplayerState::None;
145                        self.init = InitState::None;
146                        self.main_menu_ui.cancel_connection();
147                        let server_err = match e {
148                            server::Error::NetworkErr(e) => localized_strings
149                                .get_msg_ctx("main-servers-network_error", &i18n::fluent_args! {
150                                    "raw_error" => e.to_string()
151                                })
152                                .into_owned(),
153                            server::Error::ParticipantErr(e) => localized_strings
154                                .get_msg_ctx(
155                                    "main-servers-participant_error",
156                                    &i18n::fluent_args! {
157                                        "raw_error" => e.to_string()
158                                    },
159                                )
160                                .into_owned(),
161                            server::Error::StreamErr(e) => localized_strings
162                                .get_msg_ctx("main-servers-stream_error", &i18n::fluent_args! {
163                                    "raw_error" => e.to_string()
164                                })
165                                .into_owned(),
166                            server::Error::DatabaseErr(e) => localized_strings
167                                .get_msg_ctx("main-servers-database_error", &i18n::fluent_args! {
168                                    "raw_error" => e.to_string()
169                                })
170                                .into_owned(),
171                            server::Error::PersistenceErr(e) => localized_strings
172                                .get_msg_ctx(
173                                    "main-servers-persistence_error",
174                                    &i18n::fluent_args! {
175                                        "raw_error" => e.to_string()
176                                    },
177                                )
178                                .into_owned(),
179                            server::Error::RtsimError(e) => localized_strings
180                                .get_msg_ctx("main-servers-rtsim_error", &i18n::fluent_args! {
181                                    "raw_error" => e.to_string(),
182                                })
183                                .into_owned(),
184                            server::Error::Other(e) => localized_strings
185                                .get_msg_ctx("main-servers-other_error", &i18n::fluent_args! {
186                                    "raw_error" => e,
187                                })
188                                .into_owned(),
189                        };
190                        global_state.info_message = Some(
191                            localized_strings
192                                .get_msg_ctx(
193                                    "main-servers-singleplayer_error",
194                                    &i18n::fluent_args! {
195                                        "sp_error" => server_err
196                                    },
197                                )
198                                .into_owned(),
199                        );
200                    },
201                    Err(_) => (),
202                }
203            }
204        }
205        // Handle window events.
206        for event in events {
207            // Pass all events to the ui first.
208            if self.main_menu_ui.handle_event(event.clone()) {
209                continue;
210            }
211
212            match event {
213                Event::Close => return PlayStateResult::Shutdown,
214                // Ignore all other events.
215                _ => {},
216            }
217        }
218
219        if let Some(client_stage_update) = self.init.client().and_then(|init| init.stage_update()) {
220            self.main_menu_ui
221                .update_stage(DetailedInitializationStage::Client(client_stage_update));
222        }
223
224        // Poll client creation.
225        match self.init.client().and_then(|init| init.poll()) {
226            Some(InitMsg::Done(Ok(mut client))) => {
227                // load local plugins needed by the server
228                #[cfg(feature = "plugins")]
229                for path in client.take_local_plugins().drain(..) {
230                    if let Err(e) = client
231                        .state_mut()
232                        .ecs_mut()
233                        .write_resource::<PluginMgr>()
234                        .load_server_plugin(path)
235                    {
236                        tracing::error!(?e, "load local plugin");
237                    }
238                }
239                // Register voxygen components / resources
240                crate::ecs::init(client.state_mut().ecs_mut());
241                self.init = InitState::Pipeline(Box::new(client), hud::MessageBacklog::default());
242            },
243            Some(InitMsg::Done(Err(e))) => {
244                self.init = InitState::None;
245                error!(?e, "Client Init failed raw error");
246                let e = get_client_init_msg_error(e, &global_state.i18n);
247                // Log error for possible additional use later or in case that the error
248                // displayed is cut of.
249                error!(?e, "Client Init failed");
250                global_state.info_message = Some(
251                    localized_strings
252                        .get_msg_ctx("main-login-client_init_failed", &i18n::fluent_args! {
253                            "init_fail_reason" => e
254                        })
255                        .into_owned(),
256                );
257            },
258            Some(InitMsg::IsAuthTrusted(auth_server)) => {
259                if global_state
260                    .settings
261                    .networking
262                    .trusted_auth_servers
263                    .contains(&auth_server)
264                {
265                    // Can't fail since we just polled it, it must be Some
266                    self.init.client().unwrap().auth_trust(auth_server, true);
267                } else {
268                    // Show warning that auth server is not trusted and prompt for approval
269                    self.main_menu_ui.auth_trust_prompt(auth_server);
270                }
271            },
272            None => {},
273        }
274
275        // Tick the client to keep the connection alive if we are waiting on pipelines
276        if let InitState::Pipeline(client, _) = &mut self.init {
277            match client.tick(comp::ControllerInputs::default(), global_state.clock.dt()) {
278                Ok(events) => {
279                    for event in events {
280                        match event {
281                            client::Event::SetViewDistance(_vd) => {},
282                            client::Event::Disconnect => {
283                                global_state.info_message = Some(
284                                    localized_strings
285                                        .get_msg("main-login-server_shut_down")
286                                        .into_owned(),
287                                );
288                                self.init = InitState::None;
289                            },
290                            client::Event::Chat(m) => {
291                                if let InitState::Pipeline(client, message_backlog) = &mut self.init
292                                {
293                                    message_backlog.new_message(client, &global_state.profile, m)
294                                }
295                            },
296                            #[cfg_attr(not(feature = "plugins"), expect(unused_variables))]
297                            client::Event::PluginDataReceived(data) => {
298                                #[cfg(feature = "plugins")]
299                                {
300                                    tracing::info!("plugin data {}", data.len());
301                                    if let InitState::Pipeline(client, _) = &mut self.init {
302                                        let hash = client
303                                            .state()
304                                            .ecs()
305                                            .write_resource::<PluginMgr>()
306                                            .cache_server_plugin(&global_state.config_dir, data);
307                                        match hash {
308                                            Ok(hash) => {
309                                                if client.plugin_received(hash) == 0 {
310                                                    // now load characters (plugins might contain
311                                                    // items)
312                                                    client.load_character_list();
313                                                }
314                                            },
315                                            Err(e) => tracing::error!(?e, "cache_server_plugin"),
316                                        }
317                                    }
318                                }
319                            },
320                            _ => {},
321                        }
322                    }
323                },
324                Err(err) => {
325                    error!(?err, "[main menu] Failed to tick the client");
326                    global_state.info_message =
327                        Some(get_client_msg_error(err, None, &global_state.i18n.read()));
328                    self.init = InitState::None;
329                },
330            }
331        }
332
333        // Poll renderer pipeline creation
334        if let InitState::Pipeline(..) = &self.init {
335            if let Some((done, total)) = &global_state.window.renderer().pipeline_creation_status()
336            {
337                self.main_menu_ui.update_stage(
338                    DetailedInitializationStage::CreatingRenderPipeline(*done, *total),
339                );
340            // If complete go to char select screen
341            } else {
342                // Always succeeds since we check above
343                if let InitState::Pipeline(mut client, message_backlog) =
344                    core::mem::replace(&mut self.init, InitState::None)
345                {
346                    self.main_menu_ui.connected();
347
348                    // If the client cannot enter the game but spectate, skip from the character
349                    // menu directly to spectating.
350                    if client.client_type().can_spectate()
351                        && !client.client_type().can_enter_character()
352                    {
353                        client.request_spectate(global_state.settings.graphics.view_distances());
354
355                        return PlayStateResult::Push(Box::new(SessionState::new(
356                            global_state,
357                            UpdateCharacterMetadata::default(),
358                            Rc::new(RefCell::new(*client)),
359                            Rc::new(RefCell::new(message_backlog)),
360                        )));
361                    }
362
363                    let server_info = client.server_info().clone();
364                    let server_description = client.server_description().clone();
365
366                    let char_select = CharSelectionState::new(
367                        global_state,
368                        Rc::new(RefCell::new(*client)),
369                        Rc::new(RefCell::new(message_backlog)),
370                    );
371
372                    let new_state = ServerInfoState::try_from_server_info(
373                        global_state,
374                        self.main_menu_ui.bg_img_spec(),
375                        char_select,
376                        server_info,
377                        server_description,
378                        false,
379                    )
380                    .map(|s| Box::new(s) as _)
381                    .unwrap_or_else(|s| Box::new(s) as _);
382
383                    return PlayStateResult::Push(new_state);
384                }
385            }
386        }
387
388        // Maintain the UI.
389        for event in self
390            .main_menu_ui
391            .maintain(global_state, global_state.clock.dt())
392        {
393            match event {
394                MainMenuEvent::LoginAttempt {
395                    username,
396                    password,
397                    server_address,
398                } => {
399                    let net_settings = &mut global_state.settings.networking;
400                    let use_srv = net_settings.use_srv;
401                    let use_quic = net_settings.use_quic;
402                    let validate_tls = net_settings.validate_tls;
403                    net_settings.username.clone_from(&username);
404                    net_settings.default_server.clone_from(&server_address);
405                    if !server_address.is_empty() && !net_settings.servers.contains(&server_address)
406                    {
407                        net_settings.servers.push(server_address.clone());
408                    }
409                    global_state
410                        .settings
411                        .save_to_file_warn(&global_state.config_dir);
412
413                    let connection_args = if use_srv {
414                        ConnectionArgs::Srv {
415                            hostname: server_address,
416                            prefer_ipv6: false,
417                            validate_tls,
418                            use_quic,
419                        }
420                    } else if use_quic {
421                        ConnectionArgs::Quic {
422                            hostname: server_address,
423                            prefer_ipv6: false,
424                            validate_tls,
425                        }
426                    } else {
427                        ConnectionArgs::Tcp {
428                            hostname: server_address,
429                            prefer_ipv6: false,
430                        }
431                    };
432                    attempt_login(
433                        &mut global_state.info_message,
434                        username,
435                        password,
436                        connection_args,
437                        &mut self.init,
438                        &global_state.tokio_runtime,
439                        global_state
440                            .settings
441                            .language
442                            .send_to_server
443                            .then_some(global_state.settings.language.selected_language.clone()),
444                        &global_state.i18n,
445                        &global_state.config_dir,
446                        global_state.args.client_type.0,
447                    );
448                },
449                MainMenuEvent::CancelLoginAttempt => {
450                    // init contains InitState::Client(ClientInit), which spawns a thread which
451                    // contains a TcpStream::connect() call This call is
452                    // blocking TODO fix when the network rework happens
453                    #[cfg(feature = "singleplayer")]
454                    {
455                        global_state.singleplayer = SingleplayerState::None;
456                    }
457                    self.init = InitState::None;
458                    self.main_menu_ui.cancel_connection();
459                },
460                MainMenuEvent::ChangeLanguage(new_language) => {
461                    global_state.settings.language.selected_language =
462                        new_language.language_identifier;
463                    global_state.i18n = LocalizationHandle::load_expect(
464                        &global_state.settings.language.selected_language,
465                    );
466                    global_state
467                        .i18n
468                        .set_english_fallback(global_state.settings.language.use_english_fallback);
469                    self.main_menu_ui
470                        .update_language(global_state.i18n, &global_state.settings);
471                },
472                #[cfg(feature = "singleplayer")]
473                MainMenuEvent::StartSingleplayer => {
474                    global_state.singleplayer.run(&global_state.tokio_runtime);
475                },
476                #[cfg(feature = "singleplayer")]
477                MainMenuEvent::InitSingleplayer => {
478                    global_state.singleplayer = SingleplayerState::init();
479                },
480                #[cfg(feature = "singleplayer")]
481                MainMenuEvent::SinglePlayerChange(change) => {
482                    if let SingleplayerState::Init(ref mut init) = global_state.singleplayer {
483                        match change {
484                            ui::WorldsChange::SetActive(world) => init.current = world,
485                            ui::WorldsChange::Delete(world) => init.remove(world),
486                            ui::WorldsChange::Regenerate(world) => init.delete_map_file(world),
487                            ui::WorldsChange::AddNew => init.new_world(),
488                            ui::WorldsChange::CurrentWorldChange(change) => {
489                                if let Some(world) = init.current.map(|i| &mut init.worlds[i]) {
490                                    change.apply(world);
491                                    init.save_current_meta();
492                                }
493                            },
494                        }
495                    }
496                },
497                MainMenuEvent::Quit => return PlayStateResult::Shutdown,
498                // Note: Keeping in case we re-add the disclaimer
499                /*MainMenuEvent::DisclaimerAccepted => {
500                    global_state.settings.show_disclaimer = false
501                },*/
502                MainMenuEvent::AuthServerTrust(auth_server, trust) => {
503                    if trust {
504                        global_state
505                            .settings
506                            .networking
507                            .trusted_auth_servers
508                            .insert(auth_server.clone());
509                        global_state
510                            .settings
511                            .save_to_file_warn(&global_state.config_dir);
512                    }
513                    self.init
514                        .client()
515                        .map(|init| init.auth_trust(auth_server, trust));
516                },
517                MainMenuEvent::DeleteServer { server_index } => {
518                    let net_settings = &mut global_state.settings.networking;
519                    net_settings.servers.remove(server_index);
520
521                    global_state
522                        .settings
523                        .save_to_file_warn(&global_state.config_dir);
524                },
525            }
526        }
527
528        if let Some(info) = global_state.info_message.take() {
529            self.main_menu_ui.show_info(info);
530        }
531
532        PlayStateResult::Continue
533    }
534
535    fn name(&self) -> &'static str { "Title" }
536
537    fn capped_fps(&self) -> bool { true }
538
539    fn globals_bind_group(&self) -> &GlobalsBindGroup { self.scene.global_bind_group() }
540
541    fn render(&self, drawer: &mut Drawer<'_>, _: &Settings) {
542        // Draw the UI to the screen.
543        let mut third_pass = drawer.third_pass();
544        if let Some(mut ui_drawer) = third_pass.draw_ui() {
545            self.main_menu_ui.render(&mut ui_drawer);
546        };
547    }
548
549    fn egui_enabled(&self) -> bool { false }
550}
551
552pub(crate) fn get_client_msg_error(
553    error: client::Error,
554    mismatched_server_info: Option<ServerInfo>,
555    localization: &LocalizationGuard,
556) -> String {
557    // When a network error is received and there is a mismatch between the client
558    // and server version it is almost definitely due to this mismatch rather than
559    // a true networking error.
560    let net_error = |error: String, mismatched_server_info: Option<ServerInfo>| -> String {
561        if let Some(server_info) =
562            mismatched_server_info.filter(|info| info.git_hash != *common::util::GIT_HASH)
563        {
564            format!(
565                "{} {}: {} ({}) {}: {} ({})",
566                localization.get_msg("main-login-network_wrong_version"),
567                localization.get_msg("main-login-client_version"),
568                &*common::util::GIT_HASH,
569                &*common::util::GIT_DATE,
570                localization.get_msg("main-login-server_version"),
571                server_info.git_hash,
572                server_info.git_date,
573            )
574        } else {
575            format!(
576                "{}: {}",
577                localization.get_msg("main-login-network_error"),
578                error
579            )
580        }
581    };
582
583    use client::Error;
584    match error {
585        Error::SpecsErr(e) => {
586            format!(
587                "{}: {}",
588                localization.get_msg("main-login-internal_error"),
589                e
590            )
591        },
592        Error::AuthErr(e) => format!(
593            "{}: {}",
594            localization.get_msg("main-login-authentication_error"),
595            e
596        ),
597        Error::Kicked(reason) => localization
598            .get_msg_ctx("main-login-kicked", &fluent_args! {
599                "reason" => reason,
600            })
601            .into(),
602        Error::TooManyPlayers => localization.get_msg("main-login-server_full").into(),
603        Error::AuthServerNotTrusted => localization
604            .get_msg("main-login-untrusted_auth_server")
605            .into(),
606        Error::ServerTimeout => localization.get_msg("main-login-timeout").into(),
607        Error::ServerShutdown => localization.get_msg("main-login-server_shut_down").into(),
608        Error::NotOnWhitelist => localization.get_msg("main-login-not_on_whitelist").into(),
609        Error::Banned(ban_info) => if let Some(end_time) = ban_info
610            .until
611            .and_then(|timestamp| DateTime::<Utc>::from_timestamp(timestamp, 0))
612        {
613            let end_date = end_time.with_timezone(&Local);
614            let end_date_str = end_date.format("%Y-%m-%d %H:%M").to_string();
615
616            localization.get_msg_ctx("main-login-banned_until", &fluent_args! {
617                "reason" => ban_info.reason,
618                "end_date" => end_date_str,
619            })
620        } else {
621            localization.get_msg_ctx("main-login-banned", &fluent_args! {
622                "reason" => ban_info.reason
623            })
624        }
625        .into(),
626        Error::InvalidCharacter => localization.get_msg("main-login-invalid_character").into(),
627        Error::NetworkErr(NetworkError::ConnectFailed(NetworkConnectError::Handshake(
628            InitProtocolError::WrongVersion(_),
629        ))) => net_error(
630            localization
631                .get_msg("main-login-network_wrong_version")
632                .into_owned(),
633            mismatched_server_info,
634        ),
635        Error::NetworkErr(e) => net_error(e.to_string(), mismatched_server_info),
636        Error::ParticipantErr(e) => net_error(e.to_string(), mismatched_server_info),
637        Error::StreamErr(e) => net_error(e.to_string(), mismatched_server_info),
638        Error::HostnameLookupFailed(e) => {
639            format!(
640                "{}: {}",
641                localization.get_msg("main-login-server_not_found"),
642                e
643            )
644        },
645        Error::Other(e) => {
646            format!("{}: {}", localization.get_msg("common-error"), e)
647        },
648        Error::AuthClientError(e) => match e {
649            // TODO: remove parentheses
650            client::AuthClientError::RequestError(e) => format!(
651                "{}: {}",
652                localization.get_msg("main-login-failed_sending_request"),
653                e
654            ),
655            client::AuthClientError::ResponseError(e) => format!(
656                "{}: {}",
657                localization.get_msg("main-login-failed_sending_request"),
658                e
659            ),
660            client::AuthClientError::CertificateLoad(e) => format!(
661                "{}: {}",
662                localization.get_msg("main-login-failed_sending_request"),
663                e
664            ),
665            client::AuthClientError::JsonError(e) => format!(
666                "{}: {}",
667                localization.get_msg("main-login-failed_sending_request"),
668                e
669            ),
670            client::AuthClientError::InsecureSchema => localization
671                .get_msg("main-login-insecure_auth_scheme")
672                .into(),
673            client::AuthClientError::ServerError(_, e) => String::from_utf8_lossy(&e).into(),
674        },
675        Error::AuthServerUrlInvalid(e) => {
676            format!(
677                "{}: https://{}",
678                localization.get_msg("main-login-failed_auth_server_url_invalid"),
679                e
680            )
681        },
682    }
683}
684
685fn get_client_init_msg_error(
686    error: client_init::Error,
687    localized_strings: &LocalizationHandle,
688) -> String {
689    let localization = localized_strings.read();
690
691    match error {
692        InitError::ClientError {
693            error,
694            mismatched_server_info,
695        } => get_client_msg_error(error, mismatched_server_info, &localization),
696        InitError::ClientCrashed => localization.get_msg("main-login-client_crashed").into(),
697        InitError::ServerNotFound => localization.get_msg("main-login-server_not_found").into(),
698    }
699}
700
701fn attempt_login(
702    info_message: &mut Option<String>,
703    username: String,
704    password: String,
705    connection_args: ConnectionArgs,
706    init: &mut InitState,
707    runtime: &Arc<runtime::Runtime>,
708    locale: Option<String>,
709    localized_strings: &LocalizationHandle,
710    config_dir: &Path,
711    client_type: ClientType,
712) {
713    let localization = localized_strings.read();
714    if let Err(err) = comp::Player::alias_validate(&username) {
715        match err {
716            comp::AliasError::ForbiddenCharacters => {
717                *info_message = Some(
718                    localization
719                        .get_msg("main-login-username_bad_characters")
720                        .into_owned(),
721                );
722            },
723            comp::AliasError::TooLong => {
724                *info_message = Some(
725                    localization
726                        .get_msg_ctx("main-login-username_too_long", &i18n::fluent_args! {
727                            "max_len" => comp::MAX_ALIAS_LEN
728                        })
729                        .into_owned(),
730                );
731            },
732        }
733        return;
734    }
735
736    // Don't try to connect if there is already a connection in progress.
737    if let InitState::None = init {
738        *init = InitState::Client(ClientInit::new(
739            connection_args,
740            username,
741            password,
742            Arc::clone(runtime),
743            locale,
744            config_dir,
745            client_type,
746        ));
747    }
748}