Struct Worker

pub struct Worker<A, S>
where
    A: AuthStateHandler + Send + Sync + 'static,
    S: TdLibClient + Send + Sync + Clone + 'static,
{ /* private fields */ }

The main object in all interactions. You have to start worker and bind each client with worker using auth_client.

Implementations

impl Worker<ConsoleAuthStateHandler, TdJson>

pub fn builder() -> WorkerBuilder<ConsoleAuthStateHandler, TdJson>

impl<A, T> Worker<A, T>

where A: AuthStateHandler + Send + Sync + 'static, T: TdLibClient + Send + Sync + Clone + 'static,

pub async fn get_client_state( &self, client: &Client<T>, ) -> Result<(ClientState, AuthorizationState)>

Returns state of the client.

pub async fn reset_auth(&mut self, client: &mut Client<T>) -> Result<()>

Drops authorized client. After method call you cannot interact with TDLib by the client.

pub async fn wait_auth_state_change( &self, client: &Client<T>, ) -> Result<Result<ClientState, (Error, UpdateAuthorizationState)>>

Method waits for client state changes. If an error occured during authorization flow, you receive AuthorizationState on which it happened. You have to setup channel by call Client::builder().with_auth_state_channel(…)

pub async fn wait_client_state(&self, client: &Client<T>) -> Result<ClientState>

Method waits for client state changes. It differ from wait_auth_state_change by error type: you won’t receive (AuthorizationState)[crate::types::authorization_state::AuthorizationState] when error occured. Method may be useful if client already authorized on, for example, previous application startup.

pub async fn bind_client(&mut self, client: Client<T>) -> Result<Client<T>>

Binds client with worker and runs authorization routines. Method returns error if worker is not running or client already bound

pub async fn reload_client(&mut self, client: Client<T>) -> Result<Client<T>>

pub fn is_running(&self) -> bool

Determines that the worker is running.

pub fn start(&mut self) -> JoinHandle<()>

Starts interaction with TDLib. It returns JoinHandle which allows you to handle worker state: if it yields - so worker is definitely stopped.

pub fn stop(&self)

Stops the client. You may want to await JoinHandle retrieved with client.start().await after calling stop.

pub async fn handle_auth_state( &self, auth_state: &AuthorizationState, client: &Client<T>, ) -> Result<()>

Trait Implementations

impl<A, S> Clone for Worker<A, S>

where A: AuthStateHandler + Send + Sync + 'static + Clone, S: TdLibClient + Send + Sync + Clone + 'static + Clone,

fn clone(&self) -> Worker<A, S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A, S> Debug for Worker<A, S>

where A: AuthStateHandler + Send + Sync + 'static + Debug, S: TdLibClient + Send + Sync + Clone + 'static + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A, S> Drop for Worker<A, S>

where A: AuthStateHandler + Send + Sync + 'static, S: TdLibClient + Send + Sync + Clone + 'static,

fn drop(&mut self)

Executes the destructor for this type.