Struct Chat

pub struct Chat {
    pub id: ChatId,
    pub typ: Chattype,
    pub name: String,
    pub visibility: ChatVisibility,
    pub grpid: String,
    pub blocked: Blocked,
    pub param: Params,
    is_sending_locations: bool,
    pub mute_duration: MuteDuration,
    pub(crate) protected: ProtectionStatus,
}

An object representing a single chat in memory. Chat objects are created using eg. Chat::load_from_db and are not updated on database changes; if you want an update, you have to recreate the object.

Fields

id: ChatId

Database ID.

typ: Chattype

Chat type, e.g. 1:1 chat, group chat, mailing list.

name: String

Chat name.

visibility: ChatVisibility

Whether the chat is archived or pinned.

grpid: String

Group ID. For Chattype::Mailinglist – mailing list address. Empty for 1:1 chats and ad-hoc groups.

blocked: Blocked

Whether the chat is blocked, unblocked or a contact request.

param: Params

Additional chat parameters stored in the database.

is_sending_locations: bool

If location streaming is enabled in the chat.

mute_duration: MuteDuration

Duration of the chat being muted.

protected: ProtectionStatus

If the chat is protected (verified).

Implementations

impl Chat

pub async fn load_from_db(context: &Context, chat_id: ChatId) -> Result<Self>

Loads chat from the database by its ID.

pub fn is_self_talk(&self) -> bool

Returns whether this is the saved messages chat

pub fn is_device_talk(&self) -> bool

Returns true if chat is a device chat.

pub fn is_mailing_list(&self) -> bool

Returns true if chat is a mailing list.

pub(crate) async fn why_cant_send( &self, context: &Context, ) -> Result<Option<CantSendReason>>

Returns None if user can send messages to this chat.

Otherwise returns a reason useful for logging.

pub async fn can_send(&self, context: &Context) -> Result<bool>

Returns true if can send to the chat.

This function can be used by the UI to decide whether to display the input box.

pub(crate) async fn check_securejoin_wait( &self, context: &Context, timeout: u64, ) -> Result<u64>

Returns the remaining timeout for the 1:1 chat in-progress SecureJoin.

If the timeout has expired, notifies the user that sending messages is possible. See also CantSendReason::SecurejoinWait.

pub(crate) async fn is_self_in_chat(&self, context: &Context) -> Result<bool>

Checks if the user is part of a chat and has basically the permissions to edit the chat therefore. The function does not check if the chat type allows editing of concrete elements.

pub(crate) async fn update_param(&mut self, context: &Context) -> Result<()>

pub fn get_id(&self) -> ChatId

Returns chat ID.

pub fn get_type(&self) -> Chattype

Returns chat type.

pub fn get_name(&self) -> &str

Returns chat name.

pub fn get_mailinglist_addr(&self) -> Option<&str>

Returns mailing list address where messages are sent to.

pub async fn get_profile_image( &self, context: &Context, ) -> Result<Option<PathBuf>>

Returns profile image path for the chat.

pub async fn get_color(&self, context: &Context) -> Result<u32>

Returns chat avatar color.

For 1:1 chats, the color is calculated from the contact’s address. For group chats the color is calculated from the chat name.

pub async fn get_info(&self, context: &Context) -> Result<ChatInfo>

Returns a struct describing the current state of the chat.

This is somewhat experimental, even more so than the rest of deltachat, and the data returned is still subject to change.

pub fn get_visibility(&self) -> ChatVisibility

Returns chat visibilitiy, e.g. whether it is archived or pinned.

pub fn is_contact_request(&self) -> bool

Returns true if chat is a contact request.

Messages cannot be sent to such chat and read receipts are not sent until the chat is manually unblocked.

pub fn is_unpromoted(&self) -> bool

Returns true if the chat is not promoted.

pub fn is_promoted(&self) -> bool

Returns true if the chat is promoted. This means a message has been sent to it and it not only exists on the users device.

pub fn is_protected(&self) -> bool

Returns true if chat protection is enabled.

UI should display a green checkmark in the chat title, in the chat profile title and in the chatlist item if chat protection is enabled. UI should also display a green checkmark in the contact profile if 1:1 chat with this contact exists and is protected.

pub fn is_protection_broken(&self) -> bool

Returns true if the chat was protected, and then an incoming message broke this protection.

This function is only useful if the UI enabled the verified_one_on_one_chats feature flag, otherwise it will return false for all chats.

1:1 chats are automatically set as protected when a contact is verified. When a message comes in that is not encrypted / signed correctly, the chat is automatically set as unprotected again. is_protection_broken() will return true until chat_id.accept() is called.

The UI should let the user confirm that this is OK with a message like Bob sent a message from another device. Tap to learn more and then call chat_id.accept().

pub fn is_sending_locations(&self) -> bool

Returns true if location streaming is enabled in the chat.

pub fn is_muted(&self) -> bool

Returns true if the chat is currently muted.

async fn prepare_msg_raw( &mut self, context: &Context, msg: &mut Message, update_msg_id: Option<MsgId>, timestamp: i64, ) -> Result<MsgId>

Adds missing values to the msg object, writes the record to the database and returns its msg_id.

If update_msg_id is set, that record is reused; if update_msg_id is None, a new record is created.

pub(crate) async fn sync_contacts(&self, context: &Context) -> Result<()>

Sends a SyncAction synchronising chat contacts to other devices.

async fn get_sync_id(&self, context: &Context) -> Result<Option<SyncId>>

Returns chat id for the purpose of synchronisation across devices.

pub(crate) async fn sync( &self, context: &Context, action: SyncAction, ) -> Result<()>

Synchronises a chat action to other devices.

impl Chat

pub async fn get_last_reaction_if_newer_than( &self, context: &Context, timestamp: i64, ) -> Result<Option<(Message, ContactId, String)>>

Check if there is a reaction newer than the given timestamp.

If so, reaction details are returned and can be used to create a summary string.

Trait Implementations

impl Clone for Chat

fn clone(&self) -> Chat

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Chat

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Chat

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Chat

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.