1358 lines
44 KiB
Rust
1358 lines
44 KiB
Rust
use std::sync::Mutex;
|
|
|
|
#[cfg(not(feature = "core-session"))]
|
|
use std::collections::HashMap;
|
|
|
|
#[cfg(feature = "core-session")]
|
|
use tele_core::session::{
|
|
CoreAuthState, CoreChatSummary, CoreDownloadedFile, CoreDraft, CoreEvent, CoreFolder,
|
|
CoreMedia, CoreMessage, CoreNetworkState, CoreProfile, CoreReaction, CoreSearchResult,
|
|
CoreSession,
|
|
};
|
|
#[cfg(feature = "core-session")]
|
|
use tele_core::tdlib::{ChatInfo, MessageBuilder, NetworkState, ProfileInfo};
|
|
#[cfg(feature = "core-session")]
|
|
use tele_core::test_support::FakeTdClient;
|
|
#[cfg(feature = "core-session")]
|
|
use tele_core::types::{ChatId, MessageId};
|
|
|
|
uniffi::setup_scaffolding!();
|
|
|
|
#[derive(Debug, thiserror::Error, uniffi::Error)]
|
|
pub enum IosFfiError {
|
|
#[error("{message}")]
|
|
Operation { message: String },
|
|
}
|
|
|
|
impl From<String> for IosFfiError {
|
|
fn from(message: String) -> Self {
|
|
Self::Operation { message }
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, uniffi::Record)]
|
|
pub struct IosSessionConfig {
|
|
pub account_id: String,
|
|
pub display_name: String,
|
|
pub database_path: String,
|
|
pub use_fake_tdlib: bool,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Enum)]
|
|
pub enum IosAuthState {
|
|
WaitTdlibParameters,
|
|
WaitPhoneNumber,
|
|
WaitCode,
|
|
WaitPassword,
|
|
Ready,
|
|
Closed,
|
|
Error { message: String },
|
|
}
|
|
|
|
#[cfg(feature = "core-session")]
|
|
impl From<CoreAuthState> for IosAuthState {
|
|
fn from(value: CoreAuthState) -> Self {
|
|
match value {
|
|
CoreAuthState::WaitTdlibParameters => Self::WaitTdlibParameters,
|
|
CoreAuthState::WaitPhoneNumber => Self::WaitPhoneNumber,
|
|
CoreAuthState::WaitCode => Self::WaitCode,
|
|
CoreAuthState::WaitPassword => Self::WaitPassword,
|
|
CoreAuthState::Ready => Self::Ready,
|
|
CoreAuthState::Closed => Self::Closed,
|
|
CoreAuthState::Error { message } => Self::Error { message },
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Enum)]
|
|
pub enum IosNetworkState {
|
|
WaitingForNetwork,
|
|
ConnectingToProxy,
|
|
Connecting,
|
|
Updating,
|
|
Ready,
|
|
}
|
|
|
|
#[cfg(feature = "core-session")]
|
|
impl From<CoreNetworkState> for IosNetworkState {
|
|
fn from(value: CoreNetworkState) -> Self {
|
|
match value {
|
|
CoreNetworkState::WaitingForNetwork => Self::WaitingForNetwork,
|
|
CoreNetworkState::ConnectingToProxy => Self::ConnectingToProxy,
|
|
CoreNetworkState::Connecting => Self::Connecting,
|
|
CoreNetworkState::Updating => Self::Updating,
|
|
CoreNetworkState::Ready => Self::Ready,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Enum)]
|
|
pub enum IosDownloadState {
|
|
NotDownloaded,
|
|
Downloading,
|
|
Downloaded { path: String },
|
|
Error { message: String },
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
|
|
pub struct IosFolder {
|
|
pub id: i32,
|
|
pub name: String,
|
|
}
|
|
|
|
#[cfg(feature = "core-session")]
|
|
impl From<CoreFolder> for IosFolder {
|
|
fn from(value: CoreFolder) -> Self {
|
|
Self { id: value.id, name: value.name }
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
|
|
pub struct IosDraft {
|
|
pub chat_id: i64,
|
|
pub text: String,
|
|
}
|
|
|
|
#[cfg(feature = "core-session")]
|
|
impl From<CoreDraft> for IosDraft {
|
|
fn from(value: CoreDraft) -> Self {
|
|
Self { chat_id: value.chat_id.as_i64(), text: value.text }
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
|
|
pub struct IosChatSummary {
|
|
pub id: i64,
|
|
pub title: String,
|
|
pub username: Option<String>,
|
|
pub last_message: String,
|
|
pub last_message_date: i32,
|
|
pub unread_count: i32,
|
|
pub unread_mention_count: i32,
|
|
pub is_pinned: bool,
|
|
pub order: i64,
|
|
pub last_read_outbox_message_id: i64,
|
|
pub folder_ids: Vec<i32>,
|
|
pub is_muted: bool,
|
|
pub draft: Option<IosDraft>,
|
|
}
|
|
|
|
#[cfg(feature = "core-session")]
|
|
impl From<CoreChatSummary> for IosChatSummary {
|
|
fn from(value: CoreChatSummary) -> Self {
|
|
Self {
|
|
id: value.id.as_i64(),
|
|
title: value.title,
|
|
username: value.username,
|
|
last_message: value.last_message,
|
|
last_message_date: value.last_message_date,
|
|
unread_count: value.unread_count,
|
|
unread_mention_count: value.unread_mention_count,
|
|
is_pinned: value.is_pinned,
|
|
order: value.order,
|
|
last_read_outbox_message_id: value.last_read_outbox_message_id.as_i64(),
|
|
folder_ids: value.folder_ids,
|
|
is_muted: value.is_muted,
|
|
draft: value.draft.map(IosDraft::from),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
|
|
pub struct IosReaction {
|
|
pub emoji: String,
|
|
pub count: i32,
|
|
pub is_chosen: bool,
|
|
}
|
|
|
|
#[cfg(feature = "core-session")]
|
|
impl From<CoreReaction> for IosReaction {
|
|
fn from(value: CoreReaction) -> Self {
|
|
Self {
|
|
emoji: value.emoji,
|
|
count: value.count,
|
|
is_chosen: value.is_chosen,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
|
|
pub struct IosReply {
|
|
pub message_id: i64,
|
|
pub sender_name: String,
|
|
pub text: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
|
|
pub struct IosForward {
|
|
pub sender_name: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
|
|
pub struct IosMedia {
|
|
pub kind: String,
|
|
pub file_id: i32,
|
|
pub width: Option<i32>,
|
|
pub height: Option<i32>,
|
|
pub duration: Option<i32>,
|
|
pub mime_type: Option<String>,
|
|
pub waveform: Option<String>,
|
|
pub download_state: IosDownloadState,
|
|
}
|
|
|
|
#[cfg(feature = "core-session")]
|
|
impl From<CoreMedia> for IosMedia {
|
|
fn from(value: CoreMedia) -> Self {
|
|
match value {
|
|
CoreMedia::Photo(photo) => Self {
|
|
kind: "photo".to_string(),
|
|
file_id: photo.file_id,
|
|
width: Some(photo.width),
|
|
height: Some(photo.height),
|
|
duration: None,
|
|
mime_type: None,
|
|
waveform: None,
|
|
download_state: match photo.download_state {
|
|
tele_core::session::CoreDownloadState::NotDownloaded => {
|
|
IosDownloadState::NotDownloaded
|
|
}
|
|
tele_core::session::CoreDownloadState::Downloading => {
|
|
IosDownloadState::Downloading
|
|
}
|
|
tele_core::session::CoreDownloadState::Downloaded { path } => {
|
|
IosDownloadState::Downloaded { path }
|
|
}
|
|
tele_core::session::CoreDownloadState::Error { message } => {
|
|
IosDownloadState::Error { message }
|
|
}
|
|
},
|
|
},
|
|
CoreMedia::Voice(voice) => Self {
|
|
kind: "voice".to_string(),
|
|
file_id: voice.file_id,
|
|
width: None,
|
|
height: None,
|
|
duration: Some(voice.duration),
|
|
mime_type: Some(voice.mime_type),
|
|
waveform: Some(voice.waveform),
|
|
download_state: match voice.download_state {
|
|
tele_core::session::CoreDownloadState::NotDownloaded => {
|
|
IosDownloadState::NotDownloaded
|
|
}
|
|
tele_core::session::CoreDownloadState::Downloading => {
|
|
IosDownloadState::Downloading
|
|
}
|
|
tele_core::session::CoreDownloadState::Downloaded { path } => {
|
|
IosDownloadState::Downloaded { path }
|
|
}
|
|
tele_core::session::CoreDownloadState::Error { message } => {
|
|
IosDownloadState::Error { message }
|
|
}
|
|
},
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
|
|
pub struct IosMessage {
|
|
pub id: i64,
|
|
pub sender_name: String,
|
|
pub date: i32,
|
|
pub edit_date: Option<i32>,
|
|
pub media_album_id: Option<i64>,
|
|
pub text: String,
|
|
pub media: Option<IosMedia>,
|
|
pub is_outgoing: bool,
|
|
pub is_read: bool,
|
|
pub can_be_edited: bool,
|
|
pub can_be_deleted_only_for_self: bool,
|
|
pub can_be_deleted_for_all_users: bool,
|
|
pub reply: Option<IosReply>,
|
|
pub forward: Option<IosForward>,
|
|
pub reactions: Vec<IosReaction>,
|
|
}
|
|
|
|
#[cfg(feature = "core-session")]
|
|
impl From<CoreMessage> for IosMessage {
|
|
fn from(value: CoreMessage) -> Self {
|
|
Self {
|
|
id: value.id.as_i64(),
|
|
sender_name: value.sender_name,
|
|
date: value.date,
|
|
edit_date: value.edit_date,
|
|
media_album_id: value.media_album_id,
|
|
text: value.text,
|
|
media: value.media.map(IosMedia::from),
|
|
is_outgoing: value.is_outgoing,
|
|
is_read: value.is_read,
|
|
can_be_edited: value.can_be_edited,
|
|
can_be_deleted_only_for_self: value.can_be_deleted_only_for_self,
|
|
can_be_deleted_for_all_users: value.can_be_deleted_for_all_users,
|
|
reply: value.reply.map(|reply| IosReply {
|
|
message_id: reply.message_id.as_i64(),
|
|
sender_name: reply.sender_name,
|
|
text: reply.text,
|
|
}),
|
|
forward: value
|
|
.forward
|
|
.map(|forward| IosForward { sender_name: forward.sender_name }),
|
|
reactions: value.reactions.into_iter().map(IosReaction::from).collect(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
|
|
pub struct IosSearchResult {
|
|
pub chat_id: i64,
|
|
pub message: IosMessage,
|
|
}
|
|
|
|
#[cfg(feature = "core-session")]
|
|
impl From<CoreSearchResult> for IosSearchResult {
|
|
fn from(value: CoreSearchResult) -> Self {
|
|
Self {
|
|
chat_id: value.chat_id.as_i64(),
|
|
message: IosMessage::from(value.message),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
|
|
pub struct IosProfile {
|
|
pub chat_id: i64,
|
|
pub title: String,
|
|
pub username: Option<String>,
|
|
pub bio: Option<String>,
|
|
pub phone_number: Option<String>,
|
|
pub chat_type: String,
|
|
pub member_count: Option<i32>,
|
|
pub description: Option<String>,
|
|
pub invite_link: Option<String>,
|
|
pub is_group: bool,
|
|
pub online_status: Option<String>,
|
|
}
|
|
|
|
#[cfg(feature = "core-session")]
|
|
impl From<CoreProfile> for IosProfile {
|
|
fn from(value: CoreProfile) -> Self {
|
|
Self {
|
|
chat_id: value.chat_id.as_i64(),
|
|
title: value.title,
|
|
username: value.username,
|
|
bio: value.bio,
|
|
phone_number: value.phone_number,
|
|
chat_type: value.chat_type,
|
|
member_count: value.member_count,
|
|
description: value.description,
|
|
invite_link: value.invite_link,
|
|
is_group: value.is_group,
|
|
online_status: value.online_status,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
|
|
pub struct IosDownloadedFile {
|
|
pub file_id: i32,
|
|
pub path: String,
|
|
}
|
|
|
|
#[cfg(feature = "core-session")]
|
|
impl From<CoreDownloadedFile> for IosDownloadedFile {
|
|
fn from(value: CoreDownloadedFile) -> Self {
|
|
Self { file_id: value.file_id, path: value.path }
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Enum)]
|
|
pub enum IosEvent {
|
|
AuthChanged {
|
|
state: IosAuthState,
|
|
},
|
|
ChatListChanged {
|
|
chats: Vec<IosChatSummary>,
|
|
},
|
|
FolderListChanged {
|
|
folders: Vec<IosFolder>,
|
|
},
|
|
MessageAdded {
|
|
chat_id: i64,
|
|
message: IosMessage,
|
|
},
|
|
MessageUpdated {
|
|
chat_id: i64,
|
|
message: IosMessage,
|
|
},
|
|
MessageDeleted {
|
|
chat_id: i64,
|
|
message_ids: Vec<i64>,
|
|
},
|
|
ReactionChanged {
|
|
chat_id: i64,
|
|
message_id: i64,
|
|
reactions: Vec<IosReaction>,
|
|
},
|
|
IncomingNotificationCandidate {
|
|
chat: IosChatSummary,
|
|
message: IosMessage,
|
|
sender_name: String,
|
|
},
|
|
NetworkChanged {
|
|
state: IosNetworkState,
|
|
},
|
|
DraftChanged {
|
|
draft: IosDraft,
|
|
},
|
|
ProfileLoaded {
|
|
profile: IosProfile,
|
|
},
|
|
MediaDownloadProgress {
|
|
file_id: i32,
|
|
downloaded_size: i64,
|
|
total_size: i64,
|
|
},
|
|
}
|
|
|
|
#[cfg(feature = "core-session")]
|
|
impl From<CoreEvent> for IosEvent {
|
|
fn from(value: CoreEvent) -> Self {
|
|
match value {
|
|
CoreEvent::AuthChanged(state) => Self::AuthChanged { state: state.into() },
|
|
CoreEvent::ChatListChanged(chats) => Self::ChatListChanged {
|
|
chats: chats.into_iter().map(IosChatSummary::from).collect(),
|
|
},
|
|
CoreEvent::FolderListChanged(folders) => Self::FolderListChanged {
|
|
folders: folders.into_iter().map(IosFolder::from).collect(),
|
|
},
|
|
CoreEvent::MessageAdded { chat_id, message } => {
|
|
Self::MessageAdded { chat_id: chat_id.as_i64(), message: message.into() }
|
|
}
|
|
CoreEvent::MessageUpdated { chat_id, message } => {
|
|
Self::MessageUpdated { chat_id: chat_id.as_i64(), message: message.into() }
|
|
}
|
|
CoreEvent::MessageDeleted { chat_id, message_ids } => Self::MessageDeleted {
|
|
chat_id: chat_id.as_i64(),
|
|
message_ids: message_ids.into_iter().map(|id| id.as_i64()).collect(),
|
|
},
|
|
CoreEvent::ReactionChanged { chat_id, message_id, reactions } => {
|
|
Self::ReactionChanged {
|
|
chat_id: chat_id.as_i64(),
|
|
message_id: message_id.as_i64(),
|
|
reactions: reactions.into_iter().map(IosReaction::from).collect(),
|
|
}
|
|
}
|
|
CoreEvent::IncomingNotificationCandidate(candidate) => {
|
|
Self::IncomingNotificationCandidate {
|
|
chat: candidate.chat.into(),
|
|
message: candidate.message.into(),
|
|
sender_name: candidate.sender_name,
|
|
}
|
|
}
|
|
CoreEvent::NetworkChanged(state) => Self::NetworkChanged { state: state.into() },
|
|
CoreEvent::DraftChanged(draft) => Self::DraftChanged { draft: draft.into() },
|
|
CoreEvent::ProfileLoaded(profile) => Self::ProfileLoaded { profile: profile.into() },
|
|
CoreEvent::MediaDownloadProgress { file_id, downloaded_size, total_size } => {
|
|
Self::MediaDownloadProgress { file_id, downloaded_size, total_size }
|
|
}
|
|
CoreEvent::TypingChanged(_) => Self::NetworkChanged { state: IosNetworkState::Ready },
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(uniffi::Object)]
|
|
#[cfg(feature = "core-session")]
|
|
pub struct SessionHandle {
|
|
session: Mutex<CoreSession<FakeTdClient>>,
|
|
runtime: tokio::runtime::Runtime,
|
|
}
|
|
|
|
#[uniffi::export]
|
|
#[cfg(feature = "core-session")]
|
|
pub fn create_session(config: IosSessionConfig) -> Result<SessionHandle, IosFfiError> {
|
|
if !config.use_fake_tdlib {
|
|
return Err(IosFfiError::Operation {
|
|
message: "real TDLib sessions are not exposed by the iOS FFI crate yet".to_string(),
|
|
});
|
|
}
|
|
|
|
let client = seeded_fake_client();
|
|
Ok(SessionHandle {
|
|
session: Mutex::new(CoreSession::new(client)),
|
|
runtime: tokio::runtime::Builder::new_multi_thread()
|
|
.enable_all()
|
|
.build()
|
|
.map_err(|error| IosFfiError::Operation { message: error.to_string() })?,
|
|
})
|
|
}
|
|
|
|
#[uniffi::export]
|
|
#[cfg(feature = "core-session")]
|
|
impl SessionHandle {
|
|
pub fn auth_state(&self) -> IosAuthState {
|
|
self.with_session(|session| session.auth_state().into())
|
|
}
|
|
|
|
pub fn poll_events(&self) -> Vec<IosEvent> {
|
|
self.with_session(|session| {
|
|
session.drain_client_events();
|
|
session
|
|
.poll_events()
|
|
.into_iter()
|
|
.map(IosEvent::from)
|
|
.collect()
|
|
})
|
|
}
|
|
|
|
pub fn send_phone_number(&self, phone: String) -> Result<(), IosFfiError> {
|
|
let session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.send_phone_number(phone))
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn send_code(&self, code: String) -> Result<(), IosFfiError> {
|
|
let session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.send_code(code))
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn send_password(&self, password: String) -> Result<(), IosFfiError> {
|
|
let session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.send_password(password))
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn load_chats(&self, limit: i32) -> Result<Vec<IosChatSummary>, IosFfiError> {
|
|
let mut session = self.session.lock().expect("session mutex poisoned");
|
|
let chats = self
|
|
.runtime
|
|
.block_on(session.client().load_chats(limit as usize))
|
|
.map_err(IosFfiError::from)?;
|
|
let core_chats: Vec<_> = chats.iter().map(CoreChatSummary::from).collect();
|
|
session.enqueue_event(CoreEvent::ChatListChanged(core_chats.clone()));
|
|
Ok(core_chats.into_iter().map(IosChatSummary::from).collect())
|
|
}
|
|
|
|
pub fn load_folders(&self) -> Vec<IosFolder> {
|
|
self.with_session(|session| {
|
|
session
|
|
.client()
|
|
.get_folders()
|
|
.into_iter()
|
|
.map(|folder| IosFolder::from(CoreFolder::from(&folder)))
|
|
.collect()
|
|
})
|
|
}
|
|
|
|
pub fn load_folder_chats(
|
|
&self,
|
|
folder_id: i32,
|
|
limit: i32,
|
|
) -> Result<Vec<IosChatSummary>, IosFfiError> {
|
|
let mut session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(
|
|
session
|
|
.client()
|
|
.load_folder_chats(folder_id, limit as usize),
|
|
)
|
|
.map_err(IosFfiError::from)?;
|
|
let chats: Vec<_> = session
|
|
.client()
|
|
.get_chats()
|
|
.into_iter()
|
|
.filter(|chat| chat.folder_ids.contains(&folder_id))
|
|
.map(|chat| CoreChatSummary::from(&chat))
|
|
.collect();
|
|
session.enqueue_event(CoreEvent::ChatListChanged(chats.clone()));
|
|
Ok(chats.into_iter().map(IosChatSummary::from).collect())
|
|
}
|
|
|
|
pub fn load_history(&self, chat_id: i64, limit: i32) -> Result<Vec<IosMessage>, IosFfiError> {
|
|
let mut session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.open_chat_history(ChatId::new(chat_id), limit))
|
|
.map(|messages| messages.into_iter().map(IosMessage::from).collect())
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn search_messages(
|
|
&self,
|
|
chat_id: i64,
|
|
query: String,
|
|
) -> Result<Vec<IosSearchResult>, IosFfiError> {
|
|
let session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.search_messages(ChatId::new(chat_id), &query))
|
|
.map(|results| results.into_iter().map(IosSearchResult::from).collect())
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn pinned_messages(&self, chat_id: i64) -> Result<Vec<IosMessage>, IosFfiError> {
|
|
let mut session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.pinned_messages(ChatId::new(chat_id)))
|
|
.map(|messages| messages.into_iter().map(IosMessage::from).collect())
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn open_profile(&self, chat_id: i64) -> Result<IosProfile, IosFfiError> {
|
|
let mut session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.open_profile(ChatId::new(chat_id)))
|
|
.map(IosProfile::from)
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn send_message(
|
|
&self,
|
|
chat_id: i64,
|
|
text: String,
|
|
reply_to_message_id: Option<i64>,
|
|
) -> Result<IosMessage, IosFfiError> {
|
|
let mut session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.send_text_message(
|
|
ChatId::new(chat_id),
|
|
text,
|
|
reply_to_message_id.map(MessageId::new),
|
|
None,
|
|
))
|
|
.map(IosMessage::from)
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn edit_message(
|
|
&self,
|
|
chat_id: i64,
|
|
message_id: i64,
|
|
text: String,
|
|
) -> Result<IosMessage, IosFfiError> {
|
|
let mut session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.edit_text_message(
|
|
ChatId::new(chat_id),
|
|
MessageId::new(message_id),
|
|
text,
|
|
))
|
|
.map(IosMessage::from)
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn delete_messages(
|
|
&self,
|
|
chat_id: i64,
|
|
message_ids: Vec<i64>,
|
|
revoke: bool,
|
|
) -> Result<(), IosFfiError> {
|
|
let mut session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.delete_messages(
|
|
ChatId::new(chat_id),
|
|
message_ids.into_iter().map(MessageId::new).collect(),
|
|
revoke,
|
|
))
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn forward_messages(
|
|
&self,
|
|
to_chat_id: i64,
|
|
from_chat_id: i64,
|
|
message_ids: Vec<i64>,
|
|
) -> Result<(), IosFfiError> {
|
|
let mut session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.forward_messages(
|
|
ChatId::new(to_chat_id),
|
|
ChatId::new(from_chat_id),
|
|
message_ids.into_iter().map(MessageId::new).collect(),
|
|
))
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn react(
|
|
&self,
|
|
chat_id: i64,
|
|
message_id: i64,
|
|
reaction: String,
|
|
) -> Result<Vec<IosReaction>, IosFfiError> {
|
|
let mut session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.toggle_reaction(
|
|
ChatId::new(chat_id),
|
|
MessageId::new(message_id),
|
|
reaction,
|
|
))
|
|
.map(|reactions| reactions.into_iter().map(IosReaction::from).collect())
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn set_draft(&self, chat_id: i64, text: String) -> Result<(), IosFfiError> {
|
|
let mut session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.set_draft(ChatId::new(chat_id), text))
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn copy_payload(&self, chat_id: i64, message_id: i64) -> Result<String, IosFfiError> {
|
|
let mut session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.copy_payload(ChatId::new(chat_id), MessageId::new(message_id)))
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn download_photo(&self, file_id: i32) -> Result<IosDownloadedFile, IosFfiError> {
|
|
let session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.download_photo(file_id))
|
|
.map(IosDownloadedFile::from)
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn download_voice(&self, file_id: i32) -> Result<IosDownloadedFile, IosFfiError> {
|
|
let session = self.session.lock().expect("session mutex poisoned");
|
|
self.runtime
|
|
.block_on(session.download_voice(file_id))
|
|
.map(IosDownloadedFile::from)
|
|
.map_err(IosFfiError::from)
|
|
}
|
|
|
|
pub fn simulate_incoming_message(&self, chat_id: i64, text: String, sender_name: String) {
|
|
self.with_session(|session| {
|
|
session
|
|
.client()
|
|
.simulate_incoming_message(ChatId::new(chat_id), text, &sender_name);
|
|
});
|
|
}
|
|
}
|
|
|
|
impl SessionHandle {
|
|
#[cfg(feature = "core-session")]
|
|
fn with_session<R>(&self, f: impl FnOnce(&mut CoreSession<FakeTdClient>) -> R) -> R {
|
|
let mut session = self.session.lock().expect("session mutex poisoned");
|
|
f(&mut session)
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "core-session")]
|
|
fn seeded_fake_client() -> FakeTdClient {
|
|
let chat = ChatInfo {
|
|
id: ChatId::new(1),
|
|
title: "Saved Messages".to_string(),
|
|
username: Some("saved".to_string()),
|
|
last_message: "Hello from fake TDLib".to_string(),
|
|
last_message_date: 1_700_000_000,
|
|
unread_count: 1,
|
|
unread_mention_count: 0,
|
|
is_pinned: true,
|
|
order: 1,
|
|
last_read_outbox_message_id: MessageId::new(1),
|
|
folder_ids: vec![0],
|
|
is_muted: false,
|
|
draft_text: None,
|
|
};
|
|
let message = MessageBuilder::new(MessageId::new(1))
|
|
.sender_name("Alice")
|
|
.text("Hello from fake TDLib")
|
|
.date(1_700_000_000)
|
|
.build();
|
|
let profile = ProfileInfo {
|
|
chat_id: chat.id,
|
|
title: chat.title.clone(),
|
|
username: chat.username.clone(),
|
|
bio: Some("Fake profile for iOS bridge tests".to_string()),
|
|
phone_number: None,
|
|
chat_type: "Private".to_string(),
|
|
member_count: None,
|
|
description: None,
|
|
invite_link: None,
|
|
is_group: false,
|
|
online_status: Some("online".to_string()),
|
|
};
|
|
|
|
let mut client = FakeTdClient::new()
|
|
.with_chat(chat.clone())
|
|
.with_message(chat.id.as_i64(), message.clone())
|
|
.with_profile(chat.id.as_i64(), profile)
|
|
.with_network_state(NetworkState::Ready)
|
|
.with_downloaded_file(100, "/tmp/fake-photo.jpg")
|
|
.with_downloaded_file(200, "/tmp/fake-voice.ogg");
|
|
client.set_current_pinned_message(Some(message));
|
|
client
|
|
}
|
|
|
|
#[derive(uniffi::Object)]
|
|
#[cfg(not(feature = "core-session"))]
|
|
pub struct SessionHandle {
|
|
state: Mutex<StandaloneFakeState>,
|
|
}
|
|
|
|
#[cfg(not(feature = "core-session"))]
|
|
struct StandaloneFakeState {
|
|
auth: IosAuthState,
|
|
chats: Vec<IosChatSummary>,
|
|
folders: Vec<IosFolder>,
|
|
messages: HashMap<i64, Vec<IosMessage>>,
|
|
profiles: HashMap<i64, IosProfile>,
|
|
events: Vec<IosEvent>,
|
|
downloaded_files: HashMap<i32, String>,
|
|
next_message_id: i64,
|
|
}
|
|
|
|
#[cfg(not(feature = "core-session"))]
|
|
impl StandaloneFakeState {
|
|
fn seeded() -> Self {
|
|
let chat = IosChatSummary {
|
|
id: 1,
|
|
title: "Saved Messages".to_string(),
|
|
username: Some("saved".to_string()),
|
|
last_message: "Hello from fake TDLib".to_string(),
|
|
last_message_date: 1_700_000_000,
|
|
unread_count: 1,
|
|
unread_mention_count: 0,
|
|
is_pinned: true,
|
|
order: 1,
|
|
last_read_outbox_message_id: 1,
|
|
folder_ids: vec![0],
|
|
is_muted: false,
|
|
draft: None,
|
|
};
|
|
let message = IosMessage {
|
|
id: 1,
|
|
sender_name: "Alice".to_string(),
|
|
date: 1_700_000_000,
|
|
edit_date: None,
|
|
media_album_id: None,
|
|
text: "Hello from fake TDLib".to_string(),
|
|
media: None,
|
|
is_outgoing: false,
|
|
is_read: false,
|
|
can_be_edited: false,
|
|
can_be_deleted_only_for_self: true,
|
|
can_be_deleted_for_all_users: false,
|
|
reply: None,
|
|
forward: None,
|
|
reactions: Vec::new(),
|
|
};
|
|
let profile = IosProfile {
|
|
chat_id: chat.id,
|
|
title: chat.title.clone(),
|
|
username: chat.username.clone(),
|
|
bio: Some("Fake profile for iOS bridge tests".to_string()),
|
|
phone_number: None,
|
|
chat_type: "Private".to_string(),
|
|
member_count: None,
|
|
description: None,
|
|
invite_link: None,
|
|
is_group: false,
|
|
online_status: Some("online".to_string()),
|
|
};
|
|
|
|
let mut messages = HashMap::new();
|
|
messages.insert(chat.id, vec![message]);
|
|
|
|
let mut profiles = HashMap::new();
|
|
profiles.insert(chat.id, profile);
|
|
|
|
let mut downloaded_files = HashMap::new();
|
|
downloaded_files.insert(100, "/tmp/fake-photo.jpg".to_string());
|
|
downloaded_files.insert(200, "/tmp/fake-voice.ogg".to_string());
|
|
|
|
Self {
|
|
auth: IosAuthState::WaitPhoneNumber,
|
|
chats: vec![chat.clone()],
|
|
folders: vec![IosFolder { id: 0, name: "All".to_string() }],
|
|
messages,
|
|
profiles,
|
|
events: vec![IosEvent::ChatListChanged { chats: vec![chat] }],
|
|
downloaded_files,
|
|
next_message_id: 2,
|
|
}
|
|
}
|
|
|
|
fn message_mut(
|
|
&mut self,
|
|
chat_id: i64,
|
|
message_id: i64,
|
|
) -> Result<&mut IosMessage, IosFfiError> {
|
|
self.messages
|
|
.get_mut(&chat_id)
|
|
.and_then(|messages| messages.iter_mut().find(|message| message.id == message_id))
|
|
.ok_or_else(|| IosFfiError::Operation { message: "message not found".to_string() })
|
|
}
|
|
}
|
|
|
|
#[uniffi::export]
|
|
#[cfg(not(feature = "core-session"))]
|
|
pub fn create_session(config: IosSessionConfig) -> Result<SessionHandle, IosFfiError> {
|
|
if !config.use_fake_tdlib {
|
|
return Err(IosFfiError::Operation {
|
|
message: "real TDLib sessions require the core-session build".to_string(),
|
|
});
|
|
}
|
|
|
|
Ok(SessionHandle { state: Mutex::new(StandaloneFakeState::seeded()) })
|
|
}
|
|
|
|
#[uniffi::export]
|
|
#[cfg(not(feature = "core-session"))]
|
|
impl SessionHandle {
|
|
pub fn auth_state(&self) -> IosAuthState {
|
|
self.state
|
|
.lock()
|
|
.expect("session mutex poisoned")
|
|
.auth
|
|
.clone()
|
|
}
|
|
|
|
pub fn poll_events(&self) -> Vec<IosEvent> {
|
|
let mut state = self.state.lock().expect("session mutex poisoned");
|
|
std::mem::take(&mut state.events)
|
|
}
|
|
|
|
pub fn send_phone_number(&self, _phone: String) -> Result<(), IosFfiError> {
|
|
let mut state = self.state.lock().expect("session mutex poisoned");
|
|
state.auth = IosAuthState::WaitCode;
|
|
let auth = state.auth.clone();
|
|
state.events.push(IosEvent::AuthChanged { state: auth });
|
|
Ok(())
|
|
}
|
|
|
|
pub fn send_code(&self, _code: String) -> Result<(), IosFfiError> {
|
|
let mut state = self.state.lock().expect("session mutex poisoned");
|
|
state.auth = IosAuthState::WaitPassword;
|
|
let auth = state.auth.clone();
|
|
state.events.push(IosEvent::AuthChanged { state: auth });
|
|
Ok(())
|
|
}
|
|
|
|
pub fn send_password(&self, _password: String) -> Result<(), IosFfiError> {
|
|
let mut state = self.state.lock().expect("session mutex poisoned");
|
|
state.auth = IosAuthState::Ready;
|
|
let auth = state.auth.clone();
|
|
state.events.push(IosEvent::AuthChanged { state: auth });
|
|
Ok(())
|
|
}
|
|
|
|
pub fn load_chats(&self, limit: i32) -> Result<Vec<IosChatSummary>, IosFfiError> {
|
|
let mut state = self.state.lock().expect("session mutex poisoned");
|
|
let chats: Vec<_> = state
|
|
.chats
|
|
.iter()
|
|
.take(limit.max(0) as usize)
|
|
.cloned()
|
|
.collect();
|
|
state
|
|
.events
|
|
.push(IosEvent::ChatListChanged { chats: chats.clone() });
|
|
Ok(chats)
|
|
}
|
|
|
|
pub fn load_folders(&self) -> Vec<IosFolder> {
|
|
self.state
|
|
.lock()
|
|
.expect("session mutex poisoned")
|
|
.folders
|
|
.clone()
|
|
}
|
|
|
|
pub fn load_folder_chats(
|
|
&self,
|
|
folder_id: i32,
|
|
limit: i32,
|
|
) -> Result<Vec<IosChatSummary>, IosFfiError> {
|
|
let mut state = self.state.lock().expect("session mutex poisoned");
|
|
let chats: Vec<_> = state
|
|
.chats
|
|
.iter()
|
|
.filter(|chat| chat.folder_ids.contains(&folder_id))
|
|
.take(limit.max(0) as usize)
|
|
.cloned()
|
|
.collect();
|
|
state
|
|
.events
|
|
.push(IosEvent::ChatListChanged { chats: chats.clone() });
|
|
Ok(chats)
|
|
}
|
|
|
|
pub fn load_history(&self, chat_id: i64, limit: i32) -> Result<Vec<IosMessage>, IosFfiError> {
|
|
let state = self.state.lock().expect("session mutex poisoned");
|
|
Ok(state
|
|
.messages
|
|
.get(&chat_id)
|
|
.cloned()
|
|
.unwrap_or_default()
|
|
.into_iter()
|
|
.take(limit.max(0) as usize)
|
|
.collect())
|
|
}
|
|
|
|
pub fn search_messages(
|
|
&self,
|
|
chat_id: i64,
|
|
query: String,
|
|
) -> Result<Vec<IosSearchResult>, IosFfiError> {
|
|
let state = self.state.lock().expect("session mutex poisoned");
|
|
Ok(state
|
|
.messages
|
|
.get(&chat_id)
|
|
.cloned()
|
|
.unwrap_or_default()
|
|
.into_iter()
|
|
.filter(|message| {
|
|
query.is_empty()
|
|
|| message.text.contains(&query)
|
|
|| message.sender_name.contains(&query)
|
|
})
|
|
.map(|message| IosSearchResult { chat_id, message })
|
|
.collect())
|
|
}
|
|
|
|
pub fn pinned_messages(&self, chat_id: i64) -> Result<Vec<IosMessage>, IosFfiError> {
|
|
let state = self.state.lock().expect("session mutex poisoned");
|
|
Ok(state
|
|
.messages
|
|
.get(&chat_id)
|
|
.cloned()
|
|
.unwrap_or_default()
|
|
.into_iter()
|
|
.take(1)
|
|
.collect())
|
|
}
|
|
|
|
pub fn open_profile(&self, chat_id: i64) -> Result<IosProfile, IosFfiError> {
|
|
let mut state = self.state.lock().expect("session mutex poisoned");
|
|
let profile = state
|
|
.profiles
|
|
.get(&chat_id)
|
|
.cloned()
|
|
.ok_or_else(|| IosFfiError::Operation { message: "profile not found".to_string() })?;
|
|
state
|
|
.events
|
|
.push(IosEvent::ProfileLoaded { profile: profile.clone() });
|
|
Ok(profile)
|
|
}
|
|
|
|
pub fn send_message(
|
|
&self,
|
|
chat_id: i64,
|
|
text: String,
|
|
reply_to_message_id: Option<i64>,
|
|
) -> Result<IosMessage, IosFfiError> {
|
|
let mut state = self.state.lock().expect("session mutex poisoned");
|
|
let message = IosMessage {
|
|
id: state.next_message_id,
|
|
sender_name: "Me".to_string(),
|
|
date: 1_700_000_001,
|
|
edit_date: None,
|
|
media_album_id: None,
|
|
text: text.clone(),
|
|
media: None,
|
|
is_outgoing: true,
|
|
is_read: true,
|
|
can_be_edited: true,
|
|
can_be_deleted_only_for_self: true,
|
|
can_be_deleted_for_all_users: true,
|
|
reply: reply_to_message_id.map(|message_id| IosReply {
|
|
message_id,
|
|
sender_name: "Alice".to_string(),
|
|
text: format!("Reply to #{message_id}"),
|
|
}),
|
|
forward: None,
|
|
reactions: Vec::new(),
|
|
};
|
|
state.next_message_id += 1;
|
|
state
|
|
.messages
|
|
.entry(chat_id)
|
|
.or_default()
|
|
.push(message.clone());
|
|
if let Some(chat) = state.chats.iter_mut().find(|chat| chat.id == chat_id) {
|
|
chat.last_message = text;
|
|
chat.draft = None;
|
|
}
|
|
state
|
|
.events
|
|
.push(IosEvent::MessageAdded { chat_id, message: message.clone() });
|
|
Ok(message)
|
|
}
|
|
|
|
pub fn edit_message(
|
|
&self,
|
|
chat_id: i64,
|
|
message_id: i64,
|
|
text: String,
|
|
) -> Result<IosMessage, IosFfiError> {
|
|
let mut state = self.state.lock().expect("session mutex poisoned");
|
|
let updated = {
|
|
let message = state.message_mut(chat_id, message_id)?;
|
|
message.text = text;
|
|
message.edit_date = Some(1_700_000_002);
|
|
message.clone()
|
|
};
|
|
state
|
|
.events
|
|
.push(IosEvent::MessageUpdated { chat_id, message: updated.clone() });
|
|
Ok(updated)
|
|
}
|
|
|
|
pub fn delete_messages(
|
|
&self,
|
|
chat_id: i64,
|
|
message_ids: Vec<i64>,
|
|
_revoke: bool,
|
|
) -> Result<(), IosFfiError> {
|
|
let mut state = self.state.lock().expect("session mutex poisoned");
|
|
state
|
|
.messages
|
|
.entry(chat_id)
|
|
.or_default()
|
|
.retain(|message| !message_ids.contains(&message.id));
|
|
state
|
|
.events
|
|
.push(IosEvent::MessageDeleted { chat_id, message_ids });
|
|
Ok(())
|
|
}
|
|
|
|
pub fn forward_messages(
|
|
&self,
|
|
to_chat_id: i64,
|
|
from_chat_id: i64,
|
|
message_ids: Vec<i64>,
|
|
) -> Result<(), IosFfiError> {
|
|
let mut state = self.state.lock().expect("session mutex poisoned");
|
|
let source_messages: Vec<_> = state
|
|
.messages
|
|
.get(&from_chat_id)
|
|
.cloned()
|
|
.unwrap_or_default()
|
|
.into_iter()
|
|
.filter(|message| message_ids.contains(&message.id))
|
|
.collect();
|
|
for source in source_messages {
|
|
let forwarded = IosMessage {
|
|
id: state.next_message_id,
|
|
sender_name: "Me".to_string(),
|
|
date: 1_700_000_003,
|
|
edit_date: None,
|
|
media_album_id: source.media_album_id,
|
|
text: source.text,
|
|
media: source.media,
|
|
is_outgoing: true,
|
|
is_read: true,
|
|
can_be_edited: true,
|
|
can_be_deleted_only_for_self: true,
|
|
can_be_deleted_for_all_users: true,
|
|
reply: None,
|
|
forward: Some(IosForward { sender_name: source.sender_name }),
|
|
reactions: Vec::new(),
|
|
};
|
|
state.next_message_id += 1;
|
|
state
|
|
.messages
|
|
.entry(to_chat_id)
|
|
.or_default()
|
|
.push(forwarded.clone());
|
|
state
|
|
.events
|
|
.push(IosEvent::MessageAdded { chat_id: to_chat_id, message: forwarded });
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn react(
|
|
&self,
|
|
chat_id: i64,
|
|
message_id: i64,
|
|
reaction: String,
|
|
) -> Result<Vec<IosReaction>, IosFfiError> {
|
|
let mut state = self.state.lock().expect("session mutex poisoned");
|
|
let reactions = {
|
|
let message = state.message_mut(chat_id, message_id)?;
|
|
if let Some(index) = message
|
|
.reactions
|
|
.iter()
|
|
.position(|item| item.emoji == reaction)
|
|
{
|
|
message.reactions.remove(index);
|
|
} else {
|
|
message
|
|
.reactions
|
|
.push(IosReaction { emoji: reaction, count: 1, is_chosen: true });
|
|
}
|
|
message.reactions.clone()
|
|
};
|
|
state.events.push(IosEvent::ReactionChanged {
|
|
chat_id,
|
|
message_id,
|
|
reactions: reactions.clone(),
|
|
});
|
|
Ok(reactions)
|
|
}
|
|
|
|
pub fn set_draft(&self, chat_id: i64, text: String) -> Result<(), IosFfiError> {
|
|
let mut state = self.state.lock().expect("session mutex poisoned");
|
|
let draft = IosDraft { chat_id, text };
|
|
if let Some(chat) = state.chats.iter_mut().find(|chat| chat.id == chat_id) {
|
|
chat.draft = Some(draft.clone());
|
|
}
|
|
state.events.push(IosEvent::DraftChanged { draft });
|
|
Ok(())
|
|
}
|
|
|
|
pub fn copy_payload(&self, chat_id: i64, message_id: i64) -> Result<String, IosFfiError> {
|
|
let state = self.state.lock().expect("session mutex poisoned");
|
|
state
|
|
.messages
|
|
.get(&chat_id)
|
|
.and_then(|messages| messages.iter().find(|message| message.id == message_id))
|
|
.map(|message| message.text.clone())
|
|
.ok_or_else(|| IosFfiError::Operation { message: "message not found".to_string() })
|
|
}
|
|
|
|
pub fn download_photo(&self, file_id: i32) -> Result<IosDownloadedFile, IosFfiError> {
|
|
self.standalone_download_file(file_id)
|
|
}
|
|
|
|
pub fn download_voice(&self, file_id: i32) -> Result<IosDownloadedFile, IosFfiError> {
|
|
self.standalone_download_file(file_id)
|
|
}
|
|
|
|
pub fn simulate_incoming_message(&self, chat_id: i64, text: String, sender_name: String) {
|
|
let mut state = self.state.lock().expect("session mutex poisoned");
|
|
let message = IosMessage {
|
|
id: state.next_message_id,
|
|
sender_name: sender_name.clone(),
|
|
date: 1_700_000_004,
|
|
edit_date: None,
|
|
media_album_id: None,
|
|
text: text.clone(),
|
|
media: None,
|
|
is_outgoing: false,
|
|
is_read: false,
|
|
can_be_edited: false,
|
|
can_be_deleted_only_for_self: true,
|
|
can_be_deleted_for_all_users: false,
|
|
reply: None,
|
|
forward: None,
|
|
reactions: Vec::new(),
|
|
};
|
|
state.next_message_id += 1;
|
|
state
|
|
.messages
|
|
.entry(chat_id)
|
|
.or_default()
|
|
.push(message.clone());
|
|
let notification_chat =
|
|
if let Some(chat) = state.chats.iter_mut().find(|chat| chat.id == chat_id) {
|
|
chat.last_message = text;
|
|
Some(chat.clone())
|
|
} else {
|
|
None
|
|
};
|
|
if let Some(chat) = notification_chat {
|
|
state.events.push(IosEvent::IncomingNotificationCandidate {
|
|
chat,
|
|
message: message.clone(),
|
|
sender_name,
|
|
});
|
|
}
|
|
state
|
|
.events
|
|
.push(IosEvent::MessageAdded { chat_id, message });
|
|
}
|
|
}
|
|
|
|
#[cfg(not(feature = "core-session"))]
|
|
impl SessionHandle {
|
|
fn standalone_download_file(&self, file_id: i32) -> Result<IosDownloadedFile, IosFfiError> {
|
|
let state = self.state.lock().expect("session mutex poisoned");
|
|
state
|
|
.downloaded_files
|
|
.get(&file_id)
|
|
.cloned()
|
|
.map(|path| IosDownloadedFile { file_id, path })
|
|
.ok_or_else(|| IosFfiError::Operation { message: "file not found".to_string() })
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn fake_session_can_load_send_react_search_and_poll_events() {
|
|
let session = create_session(IosSessionConfig {
|
|
account_id: "fake".to_string(),
|
|
display_name: "Fake".to_string(),
|
|
database_path: "/tmp/fake".to_string(),
|
|
use_fake_tdlib: true,
|
|
})
|
|
.unwrap();
|
|
|
|
let chats = session.load_chats(20).unwrap();
|
|
assert_eq!(chats.len(), 1);
|
|
|
|
let history = session.load_history(chats[0].id, 20).unwrap();
|
|
assert_eq!(history[0].text, "Hello from fake TDLib");
|
|
let pinned = session.pinned_messages(chats[0].id).unwrap();
|
|
assert_eq!(pinned[0].text, "Hello from fake TDLib");
|
|
assert_eq!(session.download_photo(100).unwrap().path, "/tmp/fake-photo.jpg");
|
|
assert_eq!(session.download_voice(200).unwrap().path, "/tmp/fake-voice.ogg");
|
|
session
|
|
.set_draft(chats[0].id, "Draft from Rust test".to_string())
|
|
.unwrap();
|
|
assert!(session.poll_events().iter().any(|event| matches!(
|
|
event,
|
|
IosEvent::DraftChanged { draft } if draft.text == "Draft from Rust test"
|
|
)));
|
|
|
|
let sent = session
|
|
.send_message(chats[0].id, "Hi from Swift".to_string(), None)
|
|
.unwrap();
|
|
assert_eq!(sent.text, "Hi from Swift");
|
|
assert_eq!(session.copy_payload(chats[0].id, sent.id).unwrap(), "Hi from Swift");
|
|
|
|
let reactions = session
|
|
.react(chats[0].id, sent.id, "👍".to_string())
|
|
.unwrap();
|
|
assert_eq!(reactions[0].emoji, "👍");
|
|
|
|
let results = session
|
|
.search_messages(chats[0].id, "Swift".to_string())
|
|
.unwrap();
|
|
assert_eq!(results.len(), 1);
|
|
|
|
session.simulate_incoming_message(chats[0].id, "Incoming".to_string(), "Bob".to_string());
|
|
let events = session.poll_events();
|
|
assert!(events
|
|
.iter()
|
|
.any(|event| matches!(event, IosEvent::MessageAdded { .. })));
|
|
assert!(events
|
|
.iter()
|
|
.any(|event| matches!(event, IosEvent::ReactionChanged { .. })));
|
|
assert!(events
|
|
.iter()
|
|
.any(|event| matches!(event, IosEvent::IncomingNotificationCandidate { .. })));
|
|
}
|
|
|
|
#[test]
|
|
fn real_tdlib_sessions_are_reported_as_not_yet_exposed() {
|
|
let error = match create_session(IosSessionConfig {
|
|
account_id: "real".to_string(),
|
|
display_name: "Real".to_string(),
|
|
database_path: "/tmp/tdlib".to_string(),
|
|
use_fake_tdlib: false,
|
|
}) {
|
|
Ok(_) => panic!("real TDLib session should not be exposed yet"),
|
|
Err(error) => error,
|
|
};
|
|
|
|
assert!(format!("{error}").contains("real TDLib sessions"));
|
|
}
|
|
}
|