Relocate files

Cargo.lock

@@ -826,7 +826,6 @@ dependencies = [
  "directories",
  "dirs",
  "either 1.5.99",
- "fractal-matrix-api",
  "fragile",
  "gdk",
  "gdk-pixbuf",
@@ -846,27 +845,18 @@ dependencies = [
  "libhandy",
  "log",
  "loggerv",
+ "matrix-sdk",
  "md5",
  "mdl",
  "pango",
  "rand 0.7.3",
  "regex",
+ "reqwest",
  "secret-service",
  "serde",
  "serde_json",
  "sourceview4",
  "tokio",
-]
-
-[[package]]
-name = "fractal-matrix-api"
-version = "4.4.0"
-dependencies = [
- "gio",
- "matrix-sdk",
- "reqwest",
- "serde",
- "serde_json",
  "url",
 ]
 

Cargo.toml

@@ -1,6 +1,5 @@
 [workspace]
 members = [
-    "fractal-matrix-api",
     "fractal-gtk",
 ]
 

fractal-gtk/Cargo.toml

@@ -50,10 +50,6 @@ features = ["png"]
 version = "0.4.10"
 features = ["serde"]
 
-[dependencies.fractal_api]
-path = "../fractal-matrix-api"
-package = "fractal-matrix-api"
-
 [dependencies.libhandy]
 version = "0.7.1"
 
@@ -82,3 +78,16 @@ features = ["serde_untagged"]
 [dependencies.tokio]
 version = "0.2.22"
 features = ["rt-threaded", "time"]
+
+[dependencies.reqwest]
+version = "0.10.3"
+features = ["blocking", "json", "gzip", "socks"]
+
+[dependencies.url]
+version = "2.1.1"
+features = ["serde"]
+
+[dependencies.matrix-sdk]
+git = "https://github.com/matrix-org/matrix-rust-sdk.git"
+rev = "0422bae92485b033d4f9b56f2331909653655609"
+features = ["unstable-synapse-quirks", "socks"]

fractal-gtk/src/actions/global.rs

@@ -9,11 +9,11 @@ use crate::model::message::Message;
 use crate::util::i18n::i18n;
 use crate::widgets::FileDialog::open;
 use crate::App;
-use fractal_api::identifiers::{EventId, RoomId};
 use gio::prelude::*;
 use gio::SimpleAction;
 use gtk::prelude::*;
 use libhandy::prelude::*;
+use matrix_sdk::identifiers::{EventId, RoomId};
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum AppState {

fractal-gtk/src/actions/message.rs

@@ -1,8 +1,8 @@
 use crate::backend::{dw_media, media, room, ContentType};
-use fractal_api::identifiers::RoomId;
-use fractal_api::Client as MatrixClient;
 use glib::clone;
 use log::error;
+use matrix_sdk::identifiers::RoomId;
+use matrix_sdk::Client as MatrixClient;
 use std::cell::RefCell;
 use std::fs;
 use std::process::Command;

fractal-gtk/src/actions/room_settings.rs

@@ -1,10 +1,10 @@
 use crate::backend::room;
-use fractal_api::identifiers::RoomId;
-use fractal_api::Client as MatrixClient;
 use gio::prelude::*;
 use gio::SimpleAction;
 use gio::SimpleActionGroup;
 use glib::clone;
+use matrix_sdk::identifiers::RoomId;
+use matrix_sdk::Client as MatrixClient;
 use std::convert::TryFrom;
 
 use crate::app::{App, RUNTIME};

fractal-gtk/src/api/mod.rs

@@ -0,0 +1,2 @@
+pub mod identity;
+pub mod r0;

fractal-gtk/src/api/r0.rs

@@ -73,15 +73,9 @@ impl<T: AsRef<str>> Serialize for HostAndPort<T> {
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct AccessToken(String);
 
-impl AccessToken {
-    pub fn into_string(self) -> String {
-        self.0
-    }
-}
-
 impl Display for AccessToken {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "{}", self.0)
+        self.0.fmt(f)
     }
 }
 

fractal-gtk/src/api/r0/account.rs

@@ -2,7 +2,7 @@ pub mod deactivate;
 pub mod login;
 pub mod logout;
 
-use crate::r0::{Medium, ThreePIDCredentials};
+use crate::api::r0::{Medium, ThreePIDCredentials};
 use serde::Serialize;
 
 #[derive(Clone, Debug, Serialize)]
@@ -12,6 +12,7 @@ pub enum UserIdentifier {
     User { user: String },
     #[serde(rename = "m.id.thirdparty")]
     ThirdParty { medium: Medium, address: String },
+    #[allow(dead_code)]
     #[serde(rename = "m.id.phone")]
     Phone { country: String, phone: String },
 }
@@ -59,6 +60,7 @@ impl Identifier {
     }
 }
 
+#[allow(dead_code)]
 #[derive(Clone, Debug, Serialize)]
 #[serde(tag = "type")]
 pub enum AuthenticationData {

fractal-gtk/src/api/r0/account/deactivate.rs

@@ -1,5 +1,5 @@
 use super::AuthenticationData;
-use crate::r0::AccessToken;
+use crate::api::r0::AccessToken;
 use reqwest::blocking::Client;
 use reqwest::blocking::Request;
 use reqwest::Error;

fractal-gtk/src/api/r0/account/login.rs

@@ -1,5 +1,5 @@
 use super::Identifier;
-use crate::r0::AccessToken;
+use crate::api::r0::AccessToken;
 use matrix_sdk::identifiers::DeviceId;
 use matrix_sdk::identifiers::UserId;
 use reqwest::blocking::Client;
@@ -25,6 +25,7 @@ pub struct Body {
 pub enum Auth {
     #[serde(rename = "m.login.password")]
     Password { password: String },
+    #[allow(dead_code)]
     #[serde(rename = "m.login.token")]
     Token { token: String },
 }

fractal-gtk/src/api/r0/account/logout.rs

@@ -1,4 +1,4 @@
-use crate::r0::AccessToken;
+use crate::api::r0::AccessToken;
 use reqwest::blocking::Client;
 use reqwest::blocking::Request;
 use reqwest::Error;

fractal-gtk/src/api/r0/contact/create.rs

@@ -1,5 +1,5 @@
-use crate::r0::AccessToken;
-use crate::r0::ThreePIDCredentials;
+use crate::api::r0::AccessToken;
+use crate::api::r0::ThreePIDCredentials;
 use reqwest::blocking::Client;
 use reqwest::blocking::Request;
 use reqwest::Error;

fractal-gtk/src/api/r0/contact/delete.rs

@@ -1,5 +1,5 @@
-use crate::r0::AccessToken;
-use crate::r0::Medium;
+use crate::api::r0::AccessToken;
+use crate::api::r0::Medium;
 use reqwest::blocking::Client;
 use reqwest::blocking::Request;
 use reqwest::Error;

fractal-gtk/src/appop/account.rs

@@ -14,8 +14,8 @@ use crate::widgets;
 use crate::widgets::AvatarExt;
 
 use crate::cache::{download_to_cache, remove_from_cache};
-use fractal_api::api::r0::contact::get_contacts::ThirdPartyIdentifier;
-use fractal_api::thirdparty::Medium;
+use matrix_sdk::api::r0::contact::get_contacts::ThirdPartyIdentifier;
+use matrix_sdk::thirdparty::Medium;
 
 use super::LoginData;
 

fractal-gtk/src/appop/directory.rs

@@ -9,8 +9,8 @@ use crate::widgets;
 
 use super::RoomSearchPagination;
 use crate::model::room::Room;
-use fractal_api::directory::RoomNetwork;
-use fractal_api::thirdparty::ProtocolInstance;
+use matrix_sdk::directory::RoomNetwork;
+use matrix_sdk::thirdparty::ProtocolInstance;
 
 impl AppOp {
     pub fn init_protocols(&self) {

fractal-gtk/src/appop/invite.rs

@@ -1,8 +1,8 @@
 use crate::util::i18n::{i18n, i18n_k};
 
 use crate::backend::room;
-use fractal_api::identifiers::{RoomId, UserId};
 use gtk::prelude::*;
+use matrix_sdk::identifiers::{RoomId, UserId};
 
 use crate::app::{App, RUNTIME};
 use crate::appop::member::SearchType;

fractal-gtk/src/appop/login.rs

@@ -1,11 +1,11 @@
 use log::error;
 
+use crate::api::r0::AccessToken;
 use crate::app::RUNTIME;
 use crate::backend::register;
-use fractal_api::identifiers::{DeviceId, UserId};
-use fractal_api::r0::AccessToken;
-use fractal_api::url::Url;
-use fractal_api::Session;
+use matrix_sdk::identifiers::{DeviceId, UserId};
+use matrix_sdk::Session;
+use url::Url;
 
 use crate::app::App;
 use crate::appop::AppOp;

fractal-gtk/src/appop/member.rs

@@ -1,15 +1,15 @@
 use crate::backend::{user, HandleError};
 use either::Either;
-use fractal_api::{
+use glib::clone;
+use gtk::prelude::*;
+use matrix_sdk::{
     events::{
         room::member::{MemberEventContent, MembershipState},
         StateEvent,
     },
     identifiers::{RoomId, UserId},
-    url::Url,
 };
-use glib::clone;
-use gtk::prelude::*;
+use url::Url;
 
 use std::collections::HashMap;
 use std::convert::TryFrom;

fractal-gtk/src/appop/message.rs

@@ -1,21 +1,21 @@
 use crate::backend::{room, HandleError};
 use crate::model::fileinfo::ExtraContent;
 use comrak::{markdown_to_html, ComrakOptions};
-use fractal_api::identifiers::{EventId, RoomId};
-use fractal_api::url::Url;
-use fractal_api::Client as MatrixClient;
 use gdk_pixbuf::Pixbuf;
 use gio::prelude::FileExt;
 use glib::source::Continue;
 use gtk::prelude::*;
 use lazy_static::lazy_static;
 use log::error;
+use matrix_sdk::identifiers::{EventId, RoomId};
+use matrix_sdk::Client as MatrixClient;
 use rand::Rng;
 use serde_json::json;
 use serde_json::Value as JsonValue;
 use std::env::temp_dir;
 use std::fs;
 use std::path::{Path, PathBuf};
+use url::Url;
 
 use crate::app::RUNTIME;
 use crate::appop::room::Force;

fractal-gtk/src/appop/mod.rs

@@ -5,14 +5,14 @@ use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
-use fractal_api::identifiers::{DeviceId, RoomId, UserId};
-use fractal_api::r0::AccessToken;
+use crate::api::r0::AccessToken;
+use matrix_sdk::identifiers::{DeviceId, RoomId, UserId};
 
-use fractal_api::Client as MatrixClient;
 use gtk::prelude::*;
+use matrix_sdk::Client as MatrixClient;
 
 use crate::cache::CacheMap;
-use fractal_api::url::Url;
+use url::Url;
 
 use crate::util::i18n;
 

fractal-gtk/src/appop/notifications.rs

@@ -1,5 +1,5 @@
 use crate::appop::AppOp;
-use fractal_api::identifiers::RoomId;
+use matrix_sdk::identifiers::RoomId;
 
 impl AppOp {
     pub fn clear_room_notifications(&mut self, room_id: RoomId) {

fractal-gtk/src/appop/notify.rs

@@ -1,11 +1,11 @@
 use crate::app::RUNTIME;
 use crate::backend::user;
-use fractal_api::identifiers::{EventId, RoomId};
 use gio::ApplicationExt;
 use gio::FileExt;
 use gio::Notification;
 use gtk::prelude::*;
 use log::info;
+use matrix_sdk::identifiers::{EventId, RoomId};
 use std::path::Path;
 
 use crate::util::i18n::i18n;

fractal-gtk/src/appop/room.rs

@@ -1,12 +1,12 @@
 use crate::backend::room;
 use crate::util::i18n::{i18n, i18n_k, ni18n_f};
-use fractal_api::events::EventType;
-use fractal_api::identifiers::RoomId;
-use fractal_api::url::Url;
 use log::{error, warn};
+use matrix_sdk::events::EventType;
+use matrix_sdk::identifiers::RoomId;
 use std::convert::TryInto;
 use std::fs::remove_file;
 use std::os::unix::fs;
+use url::Url;
 
 use gtk::prelude::*;
 

fractal-gtk/src/backend/directory.rs

@@ -1,8 +1,8 @@
-use fractal_api::identifiers::{Error as IdentifierError, ServerName};
-use fractal_api::url::ParseError as UrlError;
-use fractal_api::Client as MatrixClient;
-use fractal_api::Error as MatrixError;
+use matrix_sdk::identifiers::{Error as IdentifierError, ServerName};
+use matrix_sdk::Client as MatrixClient;
+use matrix_sdk::Error as MatrixError;
 use std::convert::{TryFrom, TryInto};
+use url::ParseError as UrlError;
 
 use crate::globals;
 
@@ -10,12 +10,12 @@ use crate::backend::MediaError;
 use crate::util::cache_dir_path;
 
 use crate::model::room::Room;
-use fractal_api::api::r0::directory::get_public_rooms_filtered::Request as PublicRoomsFilteredRequest;
-use fractal_api::api::r0::thirdparty::get_protocols::Request as GetProtocolsRequest;
-use fractal_api::assign;
-use fractal_api::directory::Filter as PublicRoomsFilter;
-use fractal_api::directory::RoomNetwork;
-use fractal_api::thirdparty::ProtocolInstance;
+use matrix_sdk::api::r0::directory::get_public_rooms_filtered::Request as PublicRoomsFilteredRequest;
+use matrix_sdk::api::r0::thirdparty::get_protocols::Request as GetProtocolsRequest;
+use matrix_sdk::assign;
+use matrix_sdk::directory::Filter as PublicRoomsFilter;
+use matrix_sdk::directory::RoomNetwork;
+use matrix_sdk::thirdparty::ProtocolInstance;
 
 use super::{dw_media, ContentType, HandleError};
 use crate::app::App;

fractal-gtk/src/backend/media.rs

@@ -1,15 +1,15 @@
 use super::MediaError;
 use crate::globals;
-use fractal_api::identifiers::{EventId, RoomId};
-use fractal_api::url::Url;
-use fractal_api::{Client as MatrixClient, Error as MatrixError};
+use matrix_sdk::identifiers::{EventId, RoomId};
+use matrix_sdk::{Client as MatrixClient, Error as MatrixError};
 use std::convert::TryInto;
 use std::path::PathBuf;
+use url::Url;
 
 use crate::model::message::Message;
-use fractal_api::api::r0::filter::{RoomEventFilter, UrlFilter};
-use fractal_api::api::r0::message::get_message_events::Request as GetMessagesEventsRequest;
-use fractal_api::assign;
+use matrix_sdk::api::r0::filter::{RoomEventFilter, UrlFilter};
+use matrix_sdk::api::r0::message::get_message_events::Request as GetMessagesEventsRequest;
+use matrix_sdk::assign;
 
 use super::{dw_media, get_prev_batch_from, ContentType};
 

fractal-gtk/src/backend/mod.rs

@@ -1,25 +1,25 @@
-use fractal_api::identifiers::{EventId, RoomId, ServerName};
-use fractal_api::url::Url;
-use fractal_api::{
+use lazy_static::lazy_static;
+use log::error;
+use matrix_sdk::identifiers::{EventId, RoomId, ServerName};
+use matrix_sdk::{
     api::{error::ErrorKind as RumaErrorKind, Error as RumaClientError},
     Client as MatrixClient, Error as MatrixError, FromHttpResponseError as RumaResponseError,
     ServerError,
 };
-use lazy_static::lazy_static;
-use log::error;
 use regex::Regex;
 use std::convert::TryFrom;
 use std::fmt::Debug;
 use std::io::Error as IoError;
 use std::path::PathBuf;
+use url::Url;
 
 use crate::client::ClientBlocking;
 use crate::util::cache_dir_path;
-use fractal_api::api::r0::context::get_context::Request as GetContextRequest;
-use fractal_api::api::r0::media::get_content::Request as GetContentRequest;
-use fractal_api::api::r0::media::get_content_thumbnail::Method;
-use fractal_api::api::r0::media::get_content_thumbnail::Request as GetContentThumbnailRequest;
-use fractal_api::assign;
+use matrix_sdk::api::r0::context::get_context::Request as GetContextRequest;
+use matrix_sdk::api::r0::media::get_content::Request as GetContentRequest;
+use matrix_sdk::api::r0::media::get_content_thumbnail::Method;
+use matrix_sdk::api::r0::media::get_content_thumbnail::Request as GetContentThumbnailRequest;
+use matrix_sdk::assign;
 
 pub mod directory;
 pub mod media;

fractal-gtk/src/backend/register.rs

@@ -1,22 +1,22 @@
-use fractal_api::identifiers::{DeviceId, UserId};
-use fractal_api::reqwest::Error as ReqwestError;
-use fractal_api::url::{ParseError as UrlError, Url};
+use matrix_sdk::identifiers::{DeviceId, UserId};
+use matrix_sdk::reqwest::Error as ReqwestError;
+use url::{ParseError as UrlError, Url};
 
 use crate::actions::AppState;
+use crate::api::r0::account::login::request as login_req;
+use crate::api::r0::account::login::Auth;
+use crate::api::r0::account::login::Body as LoginBody;
+use crate::api::r0::account::login::Response as LoginResponse;
+use crate::api::r0::account::logout::request as logout_req;
+use crate::api::r0::account::logout::Parameters as LogoutParameters;
+use crate::api::r0::account::Identifier;
+use crate::api::r0::account::UserIdentifier;
+use crate::api::r0::server::domain_info::request as domain_info;
+use crate::api::r0::server::domain_info::Response as DomainInfoResponse;
+use crate::api::r0::AccessToken;
+use crate::api::r0::Medium;
 use crate::backend::HTTP_CLIENT;
 use crate::globals;
-use fractal_api::r0::account::login::request as login_req;
-use fractal_api::r0::account::login::Auth;
-use fractal_api::r0::account::login::Body as LoginBody;
-use fractal_api::r0::account::login::Response as LoginResponse;
-use fractal_api::r0::account::logout::request as logout_req;
-use fractal_api::r0::account::logout::Parameters as LogoutParameters;
-use fractal_api::r0::account::Identifier;
-use fractal_api::r0::account::UserIdentifier;
-use fractal_api::r0::server::domain_info::request as domain_info;
-use fractal_api::r0::server::domain_info::Response as DomainInfoResponse;
-use fractal_api::r0::AccessToken;
-use fractal_api::r0::Medium;
 
 use super::HandleError;
 use crate::app::App;

fractal-gtk/src/backend/room.rs

@@ -1,16 +1,16 @@
 use log::error;
 use serde_json::json;
 
-use fractal_api::{
+use matrix_sdk::{
     api::error::ErrorKind as RumaErrorKind,
     identifiers::{EventId, RoomId, RoomIdOrAliasId, UserId},
-    url::{ParseError as UrlError, Url},
     Client as MatrixClient, Error as MatrixError, FromHttpResponseError as RumaResponseError,
     ServerError,
 };
 use serde::Serialize;
 use std::io::Error as IoError;
 use std::path::Path;
+use url::{ParseError as UrlError, Url};
 
 use std::convert::{TryFrom, TryInto};
 use std::time::Duration;
@@ -26,45 +26,45 @@ use crate::model::{
     message::Message,
     room::{Room, RoomMembership, RoomTag},
 };
-use fractal_api::api::r0::config::get_global_account_data::Request as GetGlobalAccountDataRequest;
-use fractal_api::api::r0::config::set_global_account_data::Request as SetGlobalAccountDataRequest;
-use fractal_api::api::r0::config::set_room_account_data::Request as SetRoomAccountDataRequest;
-use fractal_api::api::r0::filter::RoomEventFilter;
-use fractal_api::api::r0::media::create_content::Request as CreateContentRequest;
-use fractal_api::api::r0::media::create_content::Response as CreateContentResponse;
-use fractal_api::api::r0::membership::joined_members::Request as JoinedMembersRequest;
-use fractal_api::api::r0::message::get_message_events::Request as GetMessagesEventsRequest;
-use fractal_api::api::r0::push::delete_pushrule::Request as DeleteRoomRulesRequest;
-use fractal_api::api::r0::push::get_pushrule::Request as GetRoomRulesRequest;
-use fractal_api::api::r0::push::set_pushrule::Request as SetRoomRulesRequest;
-use fractal_api::api::r0::push::RuleKind;
-use fractal_api::api::r0::redact::redact_event::Request as RedactEventRequest;
-use fractal_api::api::r0::room::create_room::Request as CreateRoomRequest;
-use fractal_api::api::r0::room::create_room::RoomPreset;
-use fractal_api::api::r0::room::Visibility;
-use fractal_api::api::r0::state::get_state_events_for_key::Request as GetStateEventForKeyRequest;
-use fractal_api::api::r0::state::send_state_event_for_key::Request as SendStateEventForKeyRequest;
-use fractal_api::api::r0::tag::create_tag::Request as CreateTagRequest;
-use fractal_api::api::r0::tag::delete_tag::Request as DeleteTagRequest;
-use fractal_api::api::r0::typing::create_typing_event::Typing;
-use fractal_api::assign;
-use fractal_api::events::room::avatar::AvatarEventContent;
-use fractal_api::events::room::history_visibility::HistoryVisibility;
-use fractal_api::events::room::history_visibility::HistoryVisibilityEventContent;
-use fractal_api::events::room::message::MessageEventContent;
-use fractal_api::events::room::name::NameEventContent;
-use fractal_api::events::room::topic::TopicEventContent;
-use fractal_api::events::tag::TagInfo;
-use fractal_api::events::AnyBasicEventContent;
-use fractal_api::events::AnyInitialStateEvent;
-use fractal_api::events::AnyMessageEventContent;
-use fractal_api::events::AnyStateEventContent;
-use fractal_api::events::EventContent;
-use fractal_api::events::EventType;
-use fractal_api::events::InitialStateEvent;
-use fractal_api::events::InvalidInput as NameRoomEventInvalidInput;
-use fractal_api::push::Action;
-use fractal_api::push::Tweak;
+use matrix_sdk::api::r0::config::get_global_account_data::Request as GetGlobalAccountDataRequest;
+use matrix_sdk::api::r0::config::set_global_account_data::Request as SetGlobalAccountDataRequest;
+use matrix_sdk::api::r0::config::set_room_account_data::Request as SetRoomAccountDataRequest;
+use matrix_sdk::api::r0::filter::RoomEventFilter;
+use matrix_sdk::api::r0::media::create_content::Request as CreateContentRequest;
+use matrix_sdk::api::r0::media::create_content::Response as CreateContentResponse;
+use matrix_sdk::api::r0::membership::joined_members::Request as JoinedMembersRequest;
+use matrix_sdk::api::r0::message::get_message_events::Request as GetMessagesEventsRequest;
+use matrix_sdk::api::r0::push::delete_pushrule::Request as DeleteRoomRulesRequest;
+use matrix_sdk::api::r0::push::get_pushrule::Request as GetRoomRulesRequest;
+use matrix_sdk::api::r0::push::set_pushrule::Request as SetRoomRulesRequest;
+use matrix_sdk::api::r0::push::RuleKind;
+use matrix_sdk::api::r0::redact::redact_event::Request as RedactEventRequest;
+use matrix_sdk::api::r0::room::create_room::Request as CreateRoomRequest;
+use matrix_sdk::api::r0::room::create_room::RoomPreset;
+use matrix_sdk::api::r0::room::Visibility;
+use matrix_sdk::api::r0::state::get_state_events_for_key::Request as GetStateEventForKeyRequest;
+use matrix_sdk::api::r0::state::send_state_event_for_key::Request as SendStateEventForKeyRequest;
+use matrix_sdk::api::r0::tag::create_tag::Request as CreateTagRequest;
+use matrix_sdk::api::r0::tag::delete_tag::Request as DeleteTagRequest;
+use matrix_sdk::api::r0::typing::create_typing_event::Typing;
+use matrix_sdk::assign;
+use matrix_sdk::events::room::avatar::AvatarEventContent;
+use matrix_sdk::events::room::history_visibility::HistoryVisibility;
+use matrix_sdk::events::room::history_visibility::HistoryVisibilityEventContent;
+use matrix_sdk::events::room::message::MessageEventContent;
+use matrix_sdk::events::room::name::NameEventContent;
+use matrix_sdk::events::room::topic::TopicEventContent;
+use matrix_sdk::events::tag::TagInfo;
+use matrix_sdk::events::AnyBasicEventContent;
+use matrix_sdk::events::AnyInitialStateEvent;
+use matrix_sdk::events::AnyMessageEventContent;
+use matrix_sdk::events::AnyStateEventContent;
+use matrix_sdk::events::EventContent;
+use matrix_sdk::events::EventType;
+use matrix_sdk::events::InitialStateEvent;
+use matrix_sdk::events::InvalidInput as NameRoomEventInvalidInput;
+use matrix_sdk::push::Action;
+use matrix_sdk::push::Tweak;
 
 use serde_json::value::to_raw_value;
 use serde_json::Error as ParseJsonError;

fractal-gtk/src/backend/sync.rs

@@ -3,26 +3,26 @@ use crate::model::{
     member::Member,
     room::{Room, RoomMembership, RoomTag},
 };
-use fractal_api::api::r0::filter::Filter as EventFilter;
-use fractal_api::api::r0::filter::FilterDefinition;
-use fractal_api::api::r0::filter::LazyLoadOptions;
-use fractal_api::api::r0::filter::RoomEventFilter;
-use fractal_api::api::r0::filter::RoomFilter;
-use fractal_api::api::r0::sync::sync_events::Filter;
-use fractal_api::api::r0::sync::sync_events::UnreadNotificationsCount;
-use fractal_api::assign;
-use fractal_api::events::room::member::MemberEventContent;
-use fractal_api::events::AnyEphemeralRoomEventContent;
-use fractal_api::events::AnySyncMessageEvent;
-use fractal_api::events::AnySyncRoomEvent;
-use fractal_api::events::AnySyncStateEvent;
-use fractal_api::events::StateEvent;
-use fractal_api::SyncSettings;
-
-use fractal_api::identifiers::{EventId, RoomId, UserId};
-use fractal_api::Client as MatrixClient;
-use fractal_api::Error as MatrixError;
+use matrix_sdk::api::r0::filter::Filter as EventFilter;
+use matrix_sdk::api::r0::filter::FilterDefinition;
+use matrix_sdk::api::r0::filter::LazyLoadOptions;
+use matrix_sdk::api::r0::filter::RoomEventFilter;
+use matrix_sdk::api::r0::filter::RoomFilter;
+use matrix_sdk::api::r0::sync::sync_events::Filter;
+use matrix_sdk::api::r0::sync::sync_events::UnreadNotificationsCount;
+use matrix_sdk::assign;
+use matrix_sdk::events::room::member::MemberEventContent;
+use matrix_sdk::events::AnyEphemeralRoomEventContent;
+use matrix_sdk::events::AnySyncMessageEvent;
+use matrix_sdk::events::AnySyncRoomEvent;
+use matrix_sdk::events::AnySyncStateEvent;
+use matrix_sdk::events::StateEvent;
+use matrix_sdk::SyncSettings;
+
 use log::{error, warn};
+use matrix_sdk::identifiers::{EventId, RoomId, UserId};
+use matrix_sdk::Client as MatrixClient;
+use matrix_sdk::Error as MatrixError;
 use std::{collections::HashMap, time::Duration};
 
 use super::{get_ruma_client_error, remove_matrix_access_token_if_present, HandleError};

fractal-gtk/src/backend/user.rs

@@ -1,10 +1,10 @@
-use fractal_api::api::error::ErrorKind as RumaErrorKind;
-use fractal_api::identifiers::UserId;
-use fractal_api::reqwest::Error as ReqwestError;
-use fractal_api::url::{ParseError as UrlError, Url};
-use fractal_api::{Client as MatrixClient, Error as MatrixError};
+use matrix_sdk::api::error::ErrorKind as RumaErrorKind;
+use matrix_sdk::identifiers::UserId;
+use matrix_sdk::reqwest::Error as ReqwestError;
+use matrix_sdk::{Client as MatrixClient, Error as MatrixError};
 use std::collections::BTreeMap;
 use std::io::Error as IoError;
+use url::{ParseError as UrlError, Url};
 
 use super::MediaError;
 use crate::actions::global::activate_action;
@@ -16,37 +16,37 @@ use std::convert::TryInto;
 use std::path::PathBuf;
 
 use super::room::AttachedFileError;
+use crate::api::identity::association::msisdn::submit_token::request as submit_phone_token_req;
+use crate::api::identity::association::msisdn::submit_token::Body as SubmitPhoneTokenBody;
+use crate::api::identity::association::msisdn::submit_token::Response as SubmitPhoneTokenResponse;
+use crate::api::r0::account::deactivate::request as deactivate;
+use crate::api::r0::account::deactivate::Body as DeactivateBody;
+use crate::api::r0::account::deactivate::Parameters as DeactivateParameters;
+use crate::api::r0::account::AuthenticationData;
+use crate::api::r0::account::Identifier;
+use crate::api::r0::account::UserIdentifier;
+use crate::api::r0::contact::create::request as create_contact;
+use crate::api::r0::contact::create::Body as AddThreePIDBody;
+use crate::api::r0::contact::create::Parameters as AddThreePIDParameters;
+use crate::api::r0::contact::delete::request as delete_contact;
+use crate::api::r0::contact::delete::Body as DeleteThreePIDBody;
+use crate::api::r0::contact::delete::Parameters as DeleteThreePIDParameters;
+use crate::api::r0::AccessToken;
+use crate::api::r0::Medium;
+use crate::api::r0::ThreePIDCredentials;
 use crate::model::member::Member;
-use fractal_api::api::r0::account::change_password::Request as ChangePasswordRequest;
-use fractal_api::api::r0::account::request_3pid_management_token_via_email::Request as EmailTokenRequest;
-use fractal_api::api::r0::account::request_3pid_management_token_via_msisdn::Request as PhoneTokenRequest;
-use fractal_api::api::r0::contact::get_contacts::Request as GetContactsRequest;
-use fractal_api::api::r0::contact::get_contacts::ThirdPartyIdentifier;
-use fractal_api::api::r0::profile::get_display_name::Request as GetDisplayNameRequest;
-use fractal_api::api::r0::profile::get_profile::Request as GetProfileRequest;
-use fractal_api::api::r0::profile::set_avatar_url::Request as SetAvatarUrlRequest;
-use fractal_api::api::r0::profile::set_display_name::Request as SetDisplayNameRequest;
-use fractal_api::api::r0::uiaa::AuthData;
-use fractal_api::api::r0::user_directory::search_users::Request as UserDirectoryRequest;
-use fractal_api::assign;
-use fractal_api::identity::r0::association::msisdn::submit_token::request as submit_phone_token_req;
-use fractal_api::identity::r0::association::msisdn::submit_token::Body as SubmitPhoneTokenBody;
-use fractal_api::identity::r0::association::msisdn::submit_token::Response as SubmitPhoneTokenResponse;
-use fractal_api::r0::account::deactivate::request as deactivate;
-use fractal_api::r0::account::deactivate::Body as DeactivateBody;
-use fractal_api::r0::account::deactivate::Parameters as DeactivateParameters;
-use fractal_api::r0::account::AuthenticationData;
-use fractal_api::r0::account::Identifier;
-use fractal_api::r0::account::UserIdentifier;
-use fractal_api::r0::contact::create::request as create_contact;
-use fractal_api::r0::contact::create::Body as AddThreePIDBody;
-use fractal_api::r0::contact::create::Parameters as AddThreePIDParameters;
-use fractal_api::r0::contact::delete::request as delete_contact;
-use fractal_api::r0::contact::delete::Body as DeleteThreePIDBody;
-use fractal_api::r0::contact::delete::Parameters as DeleteThreePIDParameters;
-use fractal_api::r0::AccessToken;
-use fractal_api::r0::Medium;
-use fractal_api::r0::ThreePIDCredentials;
+use matrix_sdk::api::r0::account::change_password::Request as ChangePasswordRequest;
+use matrix_sdk::api::r0::account::request_3pid_management_token_via_email::Request as EmailTokenRequest;
+use matrix_sdk::api::r0::account::request_3pid_management_token_via_msisdn::Request as PhoneTokenRequest;
+use matrix_sdk::api::r0::contact::get_contacts::Request as GetContactsRequest;
+use matrix_sdk::api::r0::contact::get_contacts::ThirdPartyIdentifier;
+use matrix_sdk::api::r0::profile::get_display_name::Request as GetDisplayNameRequest;
+use matrix_sdk::api::r0::profile::get_profile::Request as GetProfileRequest;
+use matrix_sdk::api::r0::profile::set_avatar_url::Request as SetAvatarUrlRequest;
+use matrix_sdk::api::r0::profile::set_display_name::Request as SetDisplayNameRequest;
+use matrix_sdk::api::r0::uiaa::AuthData;
+use matrix_sdk::api::r0::user_directory::search_users::Request as UserDirectoryRequest;
+use matrix_sdk::assign;
 
 use super::{dw_media, ContentType};
 

fractal-gtk/src/cache/mod.rs

@@ -2,13 +2,13 @@ use crate::app::RUNTIME;
 use crate::appop::UserInfoCache;
 use crate::backend::user;
 use crate::util::cache_dir_path;
-use fractal_api::Client as MatrixClient;
 use gtk::LabelExt;
+use matrix_sdk::Client as MatrixClient;
 use serde::{Deserialize, Serialize};
 
 use crate::model::room::{Room, RoomList};
 use anyhow::Error;
-use fractal_api::identifiers::{DeviceId, UserId};
+use matrix_sdk::identifiers::{DeviceId, UserId};
 use std::collections::HashMap;
 use std::hash::Hash;
 use std::time::{Duration, Instant};

fractal-gtk/src/cache/state.rs

@@ -11,7 +11,7 @@ use std::sync::{Arc, Mutex, MutexGuard};
 
 use crate::model::{message::Message, room::Room};
 use crate::util::cache_dir_path;
-use fractal_api::identifiers::{DeviceId, UserId};
+use matrix_sdk::identifiers::{DeviceId, UserId};
 
 // Models
 

fractal-gtk/src/client.rs

@@ -2,13 +2,11 @@ use crate::error::Error;
 use crate::globals;
 use async_trait::async_trait;
 
-use fractal_api::reqwest;
-use fractal_api::url::Url;
-use fractal_api::HttpSend;
-use fractal_api::{
-    Client as MatrixClient, ClientConfig as MatrixClientConfig, Error as MatrixSdkError,
-};
 use gio::prelude::*;
+use matrix_sdk::{
+    Client as MatrixClient, ClientConfig as MatrixClientConfig, Error as MatrixSdkError, HttpSend,
+};
+use url::Url;
 
 use std::convert::TryInto;
 use std::sync::{Arc, Mutex};
@@ -51,8 +49,8 @@ impl ProxySettings {
 
     pub fn apply_to_blocking_client_builder(
         &self,
-        mut builder: fractal_api::reqwest::blocking::ClientBuilder,
-    ) -> fractal_api::reqwest::blocking::ClientBuilder {
+        mut builder: reqwest::blocking::ClientBuilder,
+    ) -> reqwest::blocking::ClientBuilder {
         // Reqwest only supports one proxy for each type
         if let Some(http_proxy) = self
             .http_proxy
@@ -76,8 +74,8 @@ impl ProxySettings {
 
     pub fn apply_to_client_builder(
         &self,
-        mut builder: fractal_api::reqwest::ClientBuilder,
-    ) -> fractal_api::reqwest::ClientBuilder {
+        mut builder: matrix_sdk::reqwest::ClientBuilder,
+    ) -> matrix_sdk::reqwest::ClientBuilder {
         // Reqwest only supports one proxy for each type
         if let Some(http_proxy) = self
             .http_proxy
@@ -108,7 +106,7 @@ thread_local! {
 
 #[derive(Debug)]
 struct ClientInner {
-    client: fractal_api::reqwest::Client,
+    client: matrix_sdk::reqwest::Client,
     proxy_settings: ProxySettings,
 }
 
@@ -121,20 +119,20 @@ impl Client {
     pub fn new() -> Self {
         Self {
             inner: Mutex::new(ClientInner {
-                client: Self::build(fractal_api::reqwest::Client::builder()),
+                client: Self::build(matrix_sdk::reqwest::Client::builder()),
                 proxy_settings: Default::default(),
             }),
         }
     }
 
-    pub fn get_client(&self) -> fractal_api::reqwest::Client {
+    pub fn get_client(&self) -> matrix_sdk::reqwest::Client {
         // Lock first so we don't overwrite proxy settings with outdated information
         let mut inner = self.inner.lock().unwrap();
 
         let new_proxy_settings = ProxySettings::current().unwrap_or_default();
 
         if inner.proxy_settings != new_proxy_settings {
-            let mut builder = fractal_api::reqwest::Client::builder();
+            let mut builder = matrix_sdk::reqwest::Client::builder();
             builder = new_proxy_settings.apply_to_client_builder(builder);
             let client = Self::build(builder);
 
@@ -145,7 +143,7 @@ impl Client {
         inner.client.clone()
     }
 
-    fn build(builder: fractal_api::reqwest::ClientBuilder) -> fractal_api::reqwest::Client {
+    fn build(builder: matrix_sdk::reqwest::ClientBuilder) -> matrix_sdk::reqwest::Client {
         builder
             .gzip(true)
             .timeout(globals::TIMEOUT)
@@ -159,7 +157,7 @@ impl HttpSend for Client {
     async fn send_request(
         &self,
         req: http::Request<Vec<u8>>,
-    ) -> fractal_api::Result<http::Response<Vec<u8>>> {
+    ) -> matrix_sdk::Result<http::Response<Vec<u8>>> {
         self.get_client().send_request(req).await
     }
 }
@@ -175,7 +173,7 @@ where
 
 #[derive(Debug)]
 struct ClientInnerBlocking {
-    client: fractal_api::reqwest::blocking::Client,
+    client: reqwest::blocking::Client,
     proxy_settings: ProxySettings,
 }
 
@@ -188,20 +186,20 @@ impl ClientBlocking {
     pub fn new() -> Self {
         Self {
             inner: Mutex::new(ClientInnerBlocking {
-                client: Self::build(fractal_api::reqwest::blocking::Client::builder()),
+                client: Self::build(reqwest::blocking::Client::builder()),
                 proxy_settings: Default::default(),
             }),
         }
     }
 
-    pub fn get_client(&self) -> fractal_api::reqwest::blocking::Client {
+    pub fn get_client(&self) -> reqwest::blocking::Client {
         // Lock first so we don't overwrite proxy settings with outdated information
         let mut inner = self.inner.lock().unwrap();
 
         let new_proxy_settings = ProxySettings::current().unwrap_or_default();
 
         if inner.proxy_settings != new_proxy_settings {
-            let mut builder = fractal_api::reqwest::blocking::Client::builder();
+            let mut builder = reqwest::blocking::Client::builder();
             builder = new_proxy_settings.apply_to_blocking_client_builder(builder);
             let client = Self::build(builder);
 
@@ -212,9 +210,7 @@ impl ClientBlocking {
         inner.client.clone()
     }
 
-    fn build(
-        builder: fractal_api::reqwest::blocking::ClientBuilder,
-    ) -> fractal_api::reqwest::blocking::Client {
+    fn build(builder: reqwest::blocking::ClientBuilder) -> reqwest::blocking::Client {
         builder
             .gzip(true)
             .timeout(globals::TIMEOUT)

fractal-gtk/src/error.rs

@@ -1,11 +1,11 @@
 #[derive(Debug)]
 pub enum Error {
     GlibError(glib::Error),
-    ReqwestError(fractal_api::reqwest::Error),
+    ReqwestError(matrix_sdk::reqwest::Error),
 }
 
-impl From<fractal_api::reqwest::Error> for Error {
-    fn from(err: fractal_api::reqwest::Error) -> Error {
+impl From<matrix_sdk::reqwest::Error> for Error {
+    fn from(err: matrix_sdk::reqwest::Error) -> Error {
         Error::ReqwestError(err)
     }
 }

fractal-gtk/src/globals.rs

@@ -1,8 +1,8 @@
 use directories::ProjectDirs;
-use fractal_api::url::Url;
 use lazy_static::lazy_static;
 use regex::Regex;
 use std::{path::PathBuf, time::Duration};
+use url::Url;
 
 pub const TIMEOUT: Duration = Duration::from_secs(80);
 pub const PAGE_LIMIT: u32 = 40;

fractal-gtk/src/main.rs

@@ -2,6 +2,7 @@
 #[macro_use]
 extern crate glib;
 
+mod api;
 mod backend;
 mod client;
 mod config;

fractal-gtk/src/meson.build

@@ -37,6 +37,21 @@ app_sources = files(
   'actions/message.rs',
   'actions/mod.rs',
   'actions/room_settings.rs',
+  'api/identity/association/msisdn/submit_token.rs',
+  'api/identity/association/msisdn.rs',
+  'api/identity/association.rs',
+  'api/r0/account/deactivate.rs',
+  'api/r0/account/login.rs',
+  'api/r0/account/logout.rs',
+  'api/r0/contact/create.rs',
+  'api/r0/contact/delete.rs',
+  'api/r0/server/domain_info.rs',
+  'api/r0/account.rs',
+  'api/r0/contact.rs',
+  'api/r0/server.rs',
+  'api/identity.rs',
+  'api/mod.rs',
+  'api/r0.rs',
   'app/connect/account.rs',
   'app/connect/autocomplete.rs',
   'app/connect/directory.rs',
@@ -128,7 +143,6 @@ cargo_release = custom_target('cargo-build',
                         build_by_default: true,
                         input: [
                           cargo_manifests,
-                          api_sources,
                           app_sources,
                         ],
                         depends: fractal_resources,

fractal-gtk/src/model/fileinfo.rs

@@ -1,6 +1,6 @@
-use fractal_api::url::Url;
 use serde::{Deserialize, Serialize};
 use serde_json::Value as JsonValue;
+use url::Url;
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Info {

fractal-gtk/src/model/member.rs

@@ -1,12 +1,12 @@
 use either::Either;
-use fractal_api::api::r0::membership::joined_members::RoomMember;
-use fractal_api::api::r0::user_directory::search_users::User;
-use fractal_api::identifiers::UserId;
-use fractal_api::url::{ParseError as UrlError, Url};
+use matrix_sdk::api::r0::membership::joined_members::RoomMember;
+use matrix_sdk::api::r0::user_directory::search_users::User;
+use matrix_sdk::identifiers::UserId;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::path::PathBuf;
+use url::{ParseError as UrlError, Url};
 
 // TODO: Make this non-(de)serializable
 #[derive(Debug, Clone, Serialize, Deserialize)]

fractal-gtk/src/model/message.rs

@@ -1,6 +1,6 @@
 use chrono::prelude::*;
 use chrono::DateTime;
-use fractal_api::{
+use matrix_sdk::{
     events::{
         room::message::{MessageEventContent, RedactedMessageEventContent, Relation},
         sticker::{RedactedStickerEventContent, StickerEventContent},
@@ -8,7 +8,6 @@ use fractal_api::{
         AnySyncMessageEvent, AnySyncRoomEvent, EventContent, MessageEvent, RedactedMessageEvent,
     },
     identifiers::{EventId, RoomId, UserId},
-    url::Url,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value as JsonValue;
@@ -16,6 +15,7 @@ use std::cmp::Ordering;
 use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::path::PathBuf;
+use url::Url;
 
 //FIXME make properties private
 #[derive(Debug, Clone, Serialize, Deserialize)]

fractal-gtk/src/model/room.rs

@@ -5,20 +5,20 @@ use anyhow::anyhow;
 use chrono::DateTime;
 use chrono::Utc;
 use either::Either;
-use fractal_api::api::r0::sync::sync_events::Response as SyncResponse;
-use fractal_api::directory::PublicRoomsChunk;
-use fractal_api::events::{
+use log::{debug, info, warn};
+use matrix_sdk::api::r0::sync::sync_events::Response as SyncResponse;
+use matrix_sdk::directory::PublicRoomsChunk;
+use matrix_sdk::events::{
     room::member::{MemberEventContent, MembershipState},
     AnyBasicEvent, AnyStrippedStateEvent, AnySyncEphemeralRoomEvent, AnySyncStateEvent,
     SyncStateEvent,
 };
-use fractal_api::identifiers::{EventId, RoomAliasId, RoomId, UserId};
-use fractal_api::url::{ParseError as UrlError, Url};
-use fractal_api::Raw;
-use log::{debug, info, warn};
+use matrix_sdk::identifiers::{EventId, RoomAliasId, RoomId, UserId};
+use matrix_sdk::Raw;
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::convert::{TryFrom, TryInto};
+use url::{ParseError as UrlError, Url};
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum RoomMembership {

fractal-gtk/src/passwd.rs

@@ -1,7 +1,7 @@
-use fractal_api::identifiers::{Error as IdError, UserId};
-use fractal_api::r0::AccessToken;
-use fractal_api::url::ParseError;
-use fractal_api::url::Url;
+use crate::api::r0::AccessToken;
+use matrix_sdk::identifiers::{Error as IdError, UserId};
+use url::ParseError;
+use url::Url;
 
 #[derive(Debug)]
 pub enum Error {
@@ -58,10 +58,10 @@ pub trait PasswordStorage {
 
 mod ss_storage {
     use super::Error;
-    use fractal_api::identifiers::UserId;
-    use fractal_api::r0::AccessToken;
-    use fractal_api::url::Url;
+    use crate::api::r0::AccessToken;
+    use matrix_sdk::identifiers::UserId;
     use std::convert::TryFrom;
+    use url::Url;
 
     use secret_service::{Collection, EncryptionType, SecretService, SsError};
 

fractal-gtk/src/uitypes.rs

@@ -2,11 +2,9 @@ use crate::model::message::Message;
 use crate::widgets;
 use chrono::prelude::DateTime;
 use chrono::prelude::Local;
-use fractal_api::{
-    identifiers::{EventId, UserId},
-    url::Url,
-};
+use matrix_sdk::identifiers::{EventId, UserId};
 use std::path::PathBuf;
+use url::Url;
 
 /* MessageContent contains all data needed to display one row
  * therefore it should contain only one Message body with one format

fractal-gtk/src/widgets/address.rs

@@ -1,13 +1,13 @@
+use crate::api::r0::AccessToken;
+use crate::api::r0::Medium;
 use crate::backend::user;
-use fractal_api::r0::AccessToken;
-use fractal_api::r0::Medium;
-use fractal_api::url::Url;
-use fractal_api::Client as MatrixClient;
 use glib::signal;
 use gtk::prelude::*;
+use matrix_sdk::Client as MatrixClient;
 use rand::distributions::Alphanumeric;
 use rand::{thread_rng, Rng};
 use std::thread;
+use url::Url;
 
 use crate::app::{App, RUNTIME};
 use crate::appop::AppOp;

fractal-gtk/src/widgets/image.rs

@@ -2,8 +2,6 @@ use crate::app::RUNTIME;
 use crate::backend::media;
 use crate::util::get_border_radius;
 use either::Either;
-use fractal_api::url::Url;
-use fractal_api::Client as MatrixClient;
 use gdk::prelude::GdkContextExt;
 use gdk_pixbuf::Pixbuf;
 use gdk_pixbuf::PixbufAnimation;
@@ -13,8 +11,10 @@ use glib::source::Continue;
 use gtk::prelude::*;
 use gtk::DrawingArea;
 use log::error;
+use matrix_sdk::Client as MatrixClient;
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
+use url::Url;
 
 #[derive(Clone, Debug)]
 pub struct Image {

fractal-gtk/src/widgets/inline_player.rs

@@ -40,8 +40,8 @@ use std::ops::Deref;
 use std::path::PathBuf;
 use std::rc::Rc;
 
-use fractal_api::url::Url;
-use fractal_api::Client as MatrixClient;
+use matrix_sdk::Client as MatrixClient;
+use url::Url;
 
 use crate::app::{App, RUNTIME};
 use crate::util::i18n::i18n;

fractal-gtk/src/widgets/login.rs

@@ -1,9 +1,9 @@
-use fractal_api::url::Url;
 use gio::prelude::*;
 use glib::clone;
 use gtk::prelude::*;
 use libhandy::prelude::*;
 use log::info;
+use url::Url;
 
 use crate::actions;
 use crate::actions::global::AppState;

fractal-gtk/src/widgets/media_viewer.rs

@@ -1,6 +1,6 @@
+use crate::api::r0::AccessToken;
 use crate::app::RUNTIME;
 use crate::backend::media;
-use fractal_api::r0::AccessToken;
 use glib::clone;
 
 use fragile::Fragile;
@@ -10,15 +10,15 @@ use std::rc::Rc;
 
 use crate::util::i18n::i18n;
 use either::Either;
-use fractal_api::identifiers::UserId;
-use fractal_api::url::Url;
-use fractal_api::Client as MatrixClient;
 use gdk::*;
 use glib::signal;
 use glib::source::Continue;
 use gtk::prelude::*;
 use gtk::Overlay;
 use libhandy::HeaderBarExt;
+use matrix_sdk::identifiers::UserId;
+use matrix_sdk::Client as MatrixClient;
+use url::Url;
 
 use crate::model::{message::Message, room::Room};
 

fractal-gtk/src/widgets/members_list.rs

@@ -1,5 +1,5 @@
-use fractal_api::identifiers::UserId;
 use glib::clone;
+use matrix_sdk::identifiers::UserId;
 use std::cell::RefCell;
 use std::collections::hash_map::HashMap;
 use std::rc::Rc;

fractal-gtk/src/widgets/message.rs

@@ -1,16 +1,16 @@
 use crate::util::i18n::i18n;
 use itertools::Itertools;
 
+use crate::api::r0::AccessToken;
 use crate::appop::UserInfoCache;
 use chrono::prelude::*;
 use either::Either;
-use fractal_api::r0::AccessToken;
-use fractal_api::url::Url;
-use fractal_api::Client as MatrixClient;
 use glib::clone;
 use gtk::{prelude::*, ButtonExt, ContainerExt, LabelExt, Overlay, WidgetExt};
+use matrix_sdk::Client as MatrixClient;
 use std::cmp::max;
 use std::rc::Rc;
+use url::Url;
 
 use crate::util::markup_text;
 

fractal-gtk/src/widgets/message_menu.rs

@@ -1,6 +1,6 @@
-use fractal_api::identifiers::EventId;
 use gdk::prelude::*;
 use gtk::prelude::*;
+use matrix_sdk::identifiers::EventId;
 
 use crate::uitypes::RowType;
 

fractal-gtk/src/widgets/room.rs

@@ -13,8 +13,8 @@ use crate::backend::HandleError;
 
 use crate::widgets;
 use crate::widgets::AvatarExt;
-use fractal_api::identifiers::{RoomAliasId, RoomIdOrAliasId};
 use gtk::WidgetExt;
+use matrix_sdk::identifiers::{RoomAliasId, RoomIdOrAliasId};
 
 const AVATAR_SIZE: i32 = 60;
 const JOIN_BUTTON_WIDTH: i32 = 84;

fractal-gtk/src/widgets/room_history.rs

@@ -13,12 +13,10 @@ use crate::uitypes::MessageContent;
 use crate::uitypes::RowType;
 use crate::util::i18n::i18n;
 
+use crate::api::r0::AccessToken;
 use crate::globals;
 use crate::widgets;
 use crate::widgets::{PlayerExt, VideoPlayerWidget};
-use fractal_api::identifiers::RoomId;
-use fractal_api::r0::AccessToken;
-use fractal_api::Client as MatrixClient;
 use gio::ActionMapExt;
 use gio::SimpleActionGroup;
 use glib::clone;
@@ -27,6 +25,8 @@ use glib::source::Continue;
 use glib::SignalHandlerId;
 use glib::Source;
 use gtk::prelude::*;
+use matrix_sdk::identifiers::RoomId;
+use matrix_sdk::Client as MatrixClient;
 
 struct List {
     /* With the exception of temporary widgets, only modify the fields list and listbox

fractal-gtk/src/widgets/room_settings.rs

@@ -1,15 +1,15 @@
+use crate::api::r0::AccessToken;
 use crate::backend::{room, HandleError};
-use fractal_api::identifiers::UserId;
-use fractal_api::r0::AccessToken;
-use fractal_api::Client as MatrixClient;
 use glib::clone;
+use matrix_sdk::identifiers::UserId;
+use matrix_sdk::Client as MatrixClient;
 use std::cell::RefCell;
 use std::rc::Rc;
 
 use crate::util::i18n::ni18n_f;
-use fractal_api::url::Url;
 use gio::prelude::*;
 use gtk::prelude::*;
+use url::Url;
 
 use crate::actions;
 use crate::actions::{ButtonState, StateExt};

fractal-gtk/src/widgets/roomlist.rs

@@ -1,11 +1,11 @@
 use crate::util::i18n::i18n;
-use fractal_api::identifiers::RoomId;
 use glib::clone;
+use matrix_sdk::identifiers::RoomId;
 
-use fractal_api::url::Url;
 use gtk::prelude::*;
 use log::info;
 use std::collections::HashMap;
+use url::Url;
 
 use crate::globals;
 use crate::model::room::{Room, RoomTag};

fractal-gtk/src/widgets/roomrow.rs

@@ -1,5 +1,5 @@
-use fractal_api::url::Url;
 use gtk::prelude::*;
+use url::Url;
 
 use crate::model::room::Room;
 

fractal-gtk/src/widgets/scroll_widget.rs

@@ -1,12 +1,12 @@
 use std::cell::Cell;
 use std::rc::Rc;
 
-use fractal_api::identifiers::RoomId;
 use gio::Action;
 use gio::ActionExt;
 use glib::clone;
 use glib::source::Continue;
 use gtk::prelude::*;
+use matrix_sdk::identifiers::RoomId;
 
 use libhandy::prelude::*;
 

fractal-matrix-api/Cargo.toml

@@ -1,37 +0,0 @@
-[package]
-authors = ["Daniel Garcia <danigm@wadobo.com>"]
-name = "fractal-matrix-api"
-version = "4.4.0"
-workspace = "../"
-edition = "2018"
-
-description = """
-Library to communicate with a Matrix.org server
-"""
-keywords = [
-    "matrix", "fractal"
-]
-license = "GPL-3.0"
-repository = "https://gitlab.gnome.org/GNOME/fractal"
-documentation = "https://gnome.pages.gitlab.gnome.org/fractal/fractal_matrix_api/index.html"
-
-[dependencies]
-gio = "0.9.0"
-serde_json = "1.0.48"
-
-[dependencies.serde]
-version = "1.0.104"
-features = ["derive"]
-
-[dependencies.reqwest]
-version = "0.10.3"
-features = ["blocking", "json", "gzip", "socks"]
-
-[dependencies.url]
-version = "2.1.1"
-features = ["serde"]
-
-[dependencies.matrix-sdk]
-git = "https://github.com/matrix-org/matrix-rust-sdk.git"
-rev = "0422bae92485b033d4f9b56f2331909653655609"
-features = ["unstable-synapse-quirks", "socks"]

fractal-matrix-api/src/identity.rs

@@ -1 +0,0 @@
-pub mod r0;

fractal-matrix-api/src/lib.rs

@@ -1,13 +0,0 @@
-pub mod identity;
-pub mod r0;
-
-pub use matrix_sdk::*;
-pub use url;
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
-    }
-}

fractal-matrix-api/src/meson.build

@@ -1,18 +0,0 @@
-api_sources = files(
-  'identity/r0/association/msisdn/submit_token.rs',
-  'identity/r0/association/msisdn.rs',
-  'identity/r0/association.rs',
-  'identity/r0.rs',
-  'r0/account/deactivate.rs',
-  'r0/account/login.rs',
-  'r0/account/logout.rs',
-  'r0/contact/create.rs',
-  'r0/contact/delete.rs',
-  'r0/server/domain_info.rs',
-  'r0/account.rs',
-  'r0/contact.rs',
-  'r0/server.rs',
-  'identity.rs',
-  'lib.rs',
-  'r0.rs',
-)

meson.build

@@ -73,10 +73,8 @@ cargo_manifests = files(
   'Cargo.toml',
   'Cargo.lock',
   'fractal-gtk/Cargo.toml',
-  'fractal-matrix-api/Cargo.toml'
 )
 
-subdir('fractal-matrix-api/src')
 subdir('fractal-gtk/src')
 
 meson.add_dist_script(