137fa9619f
This renames our sync methods so it's clearer which one the main one is. Syncing should be done with the sync method, if one wishes to sync only once the sync_method is provided. If one wishes to have a callback called with every sync the sync_with_callback method exists, the callback now returns a boolean that signals if the loop should be aborted. This does not mean that the current sync request will abort, a cancelable future is still needed for this.
77 lines
2.3 KiB
Rust
77 lines
2.3 KiB
Rust
use std::{env, process::exit};
|
|
use url::Url;
|
|
|
|
use matrix_sdk::{
|
|
self,
|
|
events::{
|
|
room::message::{MessageEventContent, TextMessageEventContent},
|
|
SyncMessageEvent,
|
|
},
|
|
Client, ClientConfig, EventEmitter, SyncRoom, SyncSettings,
|
|
};
|
|
use matrix_sdk_common_macros::async_trait;
|
|
|
|
struct EventCallback;
|
|
|
|
#[async_trait]
|
|
impl EventEmitter for EventCallback {
|
|
async fn on_room_message(&self, room: SyncRoom, event: &SyncMessageEvent<MessageEventContent>) {
|
|
if let SyncRoom::Joined(room) = room {
|
|
if let SyncMessageEvent {
|
|
content: MessageEventContent::Text(TextMessageEventContent { body: msg_body, .. }),
|
|
sender,
|
|
..
|
|
} = event
|
|
{
|
|
let name = {
|
|
// any reads should be held for the shortest time possible to
|
|
// avoid dead locks
|
|
let room = room.read().await;
|
|
let member = room.joined_members.get(&sender).unwrap();
|
|
member.name()
|
|
};
|
|
println!("{}: {}", name, msg_body);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn login(
|
|
homeserver_url: String,
|
|
username: &str,
|
|
password: &str,
|
|
) -> Result<(), matrix_sdk::Error> {
|
|
let client_config = ClientConfig::new()
|
|
.proxy("http://localhost:8080")?
|
|
.disable_ssl_verification();
|
|
let homeserver_url = Url::parse(&homeserver_url).expect("Couldn't parse the homeserver URL");
|
|
let mut client = Client::new_with_config(homeserver_url, client_config).unwrap();
|
|
|
|
client.add_event_emitter(Box::new(EventCallback)).await;
|
|
|
|
client
|
|
.login(username, password, None, Some("rust-sdk"))
|
|
.await?;
|
|
client.sync(SyncSettings::new()).await;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<(), matrix_sdk::Error> {
|
|
tracing_subscriber::fmt::init();
|
|
|
|
let (homeserver_url, username, password) =
|
|
match (env::args().nth(1), env::args().nth(2), env::args().nth(3)) {
|
|
(Some(a), Some(b), Some(c)) => (a, b, c),
|
|
_ => {
|
|
eprintln!(
|
|
"Usage: {} <homeserver_url> <username> <password>",
|
|
env::args().next().unwrap()
|
|
);
|
|
exit(1)
|
|
}
|
|
};
|
|
|
|
login(homeserver_url, &username, &password).await
|
|
}
|