Struct ruma_client::Client

pub struct Client<C>(_);

A client for the Matrix client-server API.

Implementations

impl<C: HttpClient> Client<C>

Client-API specific functionality of Client.

pub async fn log_in(
    &self,
    user: &str,
    password: &str,
    device_id: Option<&DeviceId>,
    initial_device_display_name: Option<&str>
) -> Result<Response, Error<C::Error, Error>>

This is supported on crate feature client-api only.

Log in with a username and password.

In contrast to send_request, this method stores the access token returned by the endpoint in this client, in addition to returning it.

pub async fn register_guest(
    &self
) -> Result<Response, Error<C::Error, UiaaResponse>>

This is supported on crate feature client-api only.

Register as a guest.

In contrast to send_request, this method stores the access token returned by the endpoint in this client, in addition to returning it.

pub async fn register_user(
    &self,
    username: Option<&str>,
    password: &str
) -> Result<Response, Error<C::Error, UiaaResponse>>

This is supported on crate feature client-api only.

Register as a new user on this server.

In contrast to send_request, this method stores the access token returned by the endpoint in this client, in addition to returning it.

The username is the local part of the returned user_id. If it is omitted from this request, the server will generate one.

pub fn sync<'a>(
    &'a self,
    filter: Option<&'a Filter<'a>>,
    since: String,
    set_presence: &'a PresenceState,
    timeout: Option<Duration>
) -> impl Stream<Item = Result<Response, Error<C::Error, Error>>> + 'a

This is supported on crate feature client-api only.

Convenience method that represents repeated calls to the sync_events endpoint as a stream.

Example:

use std::time::Duration;

let mut sync_stream = Box::pin(client.sync(
    None,
    next_batch_token,
    &PresenceState::Online,
    Some(Duration::from_secs(30)),
));
while let Some(response) = sync_stream.try_next().await? {
    // Do something with the data in the response...
}

impl<C> Client<C>

pub fn with_http_client(
    http_client: C,
    homeserver_url: String,
    access_token: Option<String>
) -> Self

Creates a new client using the given underlying HTTP client.

This allows the user to configure the details of HTTP as desired.

pub fn access_token(&self) -> Option<String>

Get a copy of the current access_token, if any.

Useful for serializing and persisting the session to be restored later.

impl<C: DefaultConstructibleHttpClient> Client<C>

pub fn new(homeserver_url: String, access_token: Option<String>) -> Self

Creates a new client based on a default-constructed hyper HTTP client.

impl<C: HttpClient> Client<C>

pub async fn send_request<R: OutgoingRequest>(
    &self,
    request: R
) -> ResponseResult<C, R>

Makes a request to a Matrix API endpoint.

pub async fn send_customized_request<R, F>(
    &self,
    request: R,
    customize: F
) -> ResponseResult<C, R> where
    R: OutgoingRequest,
    F: FnOnce(&mut Request<C::RequestBody>) -> Result<(), ResponseError<C, R>>, 

Makes a request to a Matrix API endpoint including additional URL parameters.

pub async fn send_request_as<R: OutgoingRequest>(
    &self,
    user_id: &UserId,
    request: R
) -> ResponseResult<C, R>

Makes a request to a Matrix API endpoint as a virtual user.

This method is meant to be used by application services when interacting with the client-server API.

Trait Implementations

impl<C: Clone> Clone for Client<C>

fn clone(&self) -> Client<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Debug> Debug for Client<C>

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

Formats the value using the given formatter.