Struct EventCache 

pub struct EventCache { /* private fields */ }

An event cache, providing lots of useful functionality for clients.

Cloning is shallow, and thus is cheap to do.

See also the module-level comment.

Implementations

impl EventCache

pub fn request_decryption(&self, request: DecryptionRetryRequest)

Available on crate feature e2e-encryption only.

Explicitly request the redecryption of a set of events.

The redecryption logic in the event cache might sometimes miss that a room key has become available and that a certain set of events has become decryptable.

This might happen because some room keys might arrive in a separate process handling push notifications or if a room key arrives but the process shuts down before we could have decrypted the events.

For this reason it is useful to tell the event cache explicitly that some events should be retried to be redecrypted.

This method allows you to do so. The events that get decrypted, if any, will be advertised over the usual event cache subscription mechanism which can be accessed using the RoomEventCache::subscribe() method.

Examples

let event_cache = client.event_cache();
let room_id = owned_room_id!("!my_room:localhost");

let request = DecryptionRetryRequest {
    room_id,
    utd_session_ids: BTreeSet::from(["session_id".into()]),
    refresh_info_session_ids: BTreeSet::new(),
};

event_cache.request_decryption(request);

pub fn subscribe_to_decryption_reports( &self, ) -> impl Stream<Item = Result<RedecryptorReport, BroadcastStreamRecvError>>

Available on crate feature e2e-encryption only.

Subscribe to reports that the redecryptor generates.

The redecryption logic in the event cache might sometimes miss that a room key has become available and that a certain set of events has become decryptable.

This might happen because some room keys might arrive in a separate process handling push notifications or if room keys arrive faster than we can handle them.

This stream can be used to get notified about such situations as well as a general channel where the event cache reports which events got successfully redecrypted.

Examples

let event_cache = client.event_cache();

let mut stream = event_cache.subscribe_to_decryption_reports();

while let Some(Ok(report)) = stream.next().await {
    match report {
        RedecryptorReport::Lagging => {
            // The event cache might have missed to redecrypt some events. We should tell
            // it which events we care about, i.e. which events we're displaying to the
            // user, and let it redecrypt things with an explicit request.
        }
        RedecryptorReport::ResolvedUtds { .. } => {
            // This may be interesting for statistical reasons or in case we'd like to
            // fetch and inspect these events in some manner.
        }
    }
}

impl EventCache

pub fn subscribe(&self) -> Result<()>

Starts subscribing the EventCache to sync responses, if not done before.

Re-running this has no effect if we already subscribed before, and is cheap.

pub fn has_subscribed(&self) -> bool

Check whether EventCache::subscribe has been called.

pub async fn clear_all_rooms(&self) -> Result<()>

Cleanly clear all the rooms’ event caches.

This will notify any live observers that the room has been cleared.

pub fn subscribe_to_room_generic_updates( &self, ) -> Receiver<RoomEventCacheGenericUpdate>

Subscribe to room generic updates.

If one wants to listen what has changed in a specific room, the RoomEventCache::subscribe is recommended. However, the RoomEventCacheSubscriber type triggers side-effects.

If one wants to get a high-overview, generic, updates for rooms, and without side-effects, this method is recommended. Also, dropping the receiver of this channel will not trigger any side-effect.

Trait Implementations

impl Clone for EventCache

fn clone(&self) -> EventCache

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventCache

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

Formats the value using the given formatter.