126 lines
3.7 KiB
Rust
126 lines
3.7 KiB
Rust
// Copyright 2020 The Matrix.org Foundation C.I.C.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
use std::sync::{Arc, Mutex as SyncMutex};
|
|
|
|
use matrix_sdk_common::{
|
|
events::AnyStrippedStateEvent,
|
|
identifiers::{RoomId, UserId},
|
|
};
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::store::StateStore;
|
|
|
|
use super::BaseRoomInfo;
|
|
|
|
/// The underlying room data structure collecting state for invited rooms.
|
|
#[derive(Debug, Clone)]
|
|
pub struct StrippedRoom {
|
|
room_id: Arc<RoomId>,
|
|
own_user_id: Arc<UserId>,
|
|
inner: Arc<SyncMutex<StrippedRoomInfo>>,
|
|
store: Arc<Box<dyn StateStore>>,
|
|
}
|
|
|
|
impl StrippedRoom {
|
|
pub(crate) fn new(
|
|
own_user_id: &UserId,
|
|
store: Arc<Box<dyn StateStore>>,
|
|
room_id: &RoomId,
|
|
) -> Self {
|
|
let room_id = Arc::new(room_id.clone());
|
|
|
|
let info = StrippedRoomInfo {
|
|
room_id,
|
|
base_info: BaseRoomInfo::new(),
|
|
};
|
|
|
|
Self::restore(own_user_id, store, info)
|
|
}
|
|
|
|
pub(crate) fn restore(
|
|
own_user_id: &UserId,
|
|
store: Arc<Box<dyn StateStore>>,
|
|
room_info: StrippedRoomInfo,
|
|
) -> Self {
|
|
Self {
|
|
own_user_id: Arc::new(own_user_id.clone()),
|
|
room_id: room_info.room_id.clone(),
|
|
store,
|
|
inner: Arc::new(SyncMutex::new(room_info)),
|
|
}
|
|
}
|
|
|
|
async fn calculate_name(&self) -> String {
|
|
let inner = self.inner.lock().unwrap();
|
|
|
|
if let Some(name) = &inner.base_info.name {
|
|
let name = name.trim();
|
|
name.to_string()
|
|
} else if let Some(alias) = &inner.base_info.canonical_alias {
|
|
let alias = alias.alias().trim();
|
|
alias.to_string()
|
|
} else {
|
|
// TODO do the dance with room members to calculate the name
|
|
self.room_id.to_string()
|
|
}
|
|
}
|
|
|
|
/// Get the unique room id of the room.
|
|
pub fn room_id(&self) -> &RoomId {
|
|
&self.room_id
|
|
}
|
|
|
|
/// Get our own user id.
|
|
pub fn own_user_id(&self) -> &UserId {
|
|
&self.own_user_id
|
|
}
|
|
|
|
pub(crate) fn clone_info(&self) -> StrippedRoomInfo {
|
|
(*self.inner.lock().unwrap()).clone()
|
|
}
|
|
|
|
/// Is the room encrypted.
|
|
pub fn is_encrypted(&self) -> bool {
|
|
self.inner.lock().unwrap().base_info.encryption.is_some()
|
|
}
|
|
|
|
/// Calculate the canonical display name of the room, taking into account
|
|
/// its name, aliases and members.
|
|
///
|
|
/// The display name is calculated according to [this algorithm][spec].
|
|
///
|
|
/// [spec]: <https://matrix.org/docs/spec/client_server/latest#calculating-the-display-name-for-a-room>
|
|
pub async fn display_name(&self) -> String {
|
|
self.calculate_name().await
|
|
}
|
|
}
|
|
|
|
/// The underlying pure data structure for invited rooms.
|
|
///
|
|
/// Holds all the info needed to persist a room into the state store.
|
|
#[derive(Clone, Debug, Serialize, Deserialize)]
|
|
pub struct StrippedRoomInfo {
|
|
/// The unique room id of the room.
|
|
pub room_id: Arc<RoomId>,
|
|
/// Base room info which holds some basic event contents important for the
|
|
/// room state.
|
|
pub base_info: BaseRoomInfo,
|
|
}
|
|
|
|
impl StrippedRoomInfo {
|
|
pub(crate) fn handle_state_event(&mut self, event: &AnyStrippedStateEvent) -> bool {
|
|
self.base_info.handle_state_event(&event.content())
|
|
}
|
|
}
|