trixnity-client/net.folivo.trixnity.client.store

Package-level declarations

Types

@Serializable

data class Account(val olmPickleKey: String, val baseUrl: String, val userId: UserId, val deviceId: String, val accessToken: String?, val refreshToken: String?, val syncBatchToken: String?, val filterId: String?, val backgroundFilterId: String?, val displayName: String?, val avatarUrl: String?, val isLocked: Boolean = false)

AccountStore

class AccountStore(repository: AccountRepository, tm: RepositoryTransactionManager, statisticCollector: ObservableCacheStatisticCollector, storeScope: CoroutineScope, clock: Clock) : Store

GlobalAccountDataStore

class GlobalAccountDataStore(globalAccountDataRepository: GlobalAccountDataRepository, tm: RepositoryTransactionManager, contentMappings: EventContentSerializerMappings, config: MatrixClientConfiguration, statisticCollector: ObservableCacheStatisticCollector, storeScope: CoroutineScope, clock: Clock) : Store

KeyChainLink

data class KeyChainLink(val signingUserId: UserId, val signingKey: Key.Ed25519Key, val signedUserId: UserId, val signedKey: Key.Ed25519Key)

KeySignatureTrustLevel

@Serializable

sealed interface KeySignatureTrustLevel

KeyStore

class KeyStore(outdatedKeysRepository: OutdatedKeysRepository, deviceKeysRepository: DeviceKeysRepository, crossSigningKeysRepository: CrossSigningKeysRepository, keyVerificationStateRepository: KeyVerificationStateRepository, keyChainLinkRepository: KeyChainLinkRepository, secretsRepository: SecretsRepository, secretKeyRequestRepository: SecretKeyRequestRepository, roomKeyRequestRepository: RoomKeyRequestRepository, tm: RepositoryTransactionManager, config: MatrixClientConfiguration, statisticCollector: ObservableCacheStatisticCollector, storeScope: CoroutineScope, clock: Clock) : Store

KeyVerificationState

@Serializable

sealed interface KeyVerificationState

MediaCacheMapping

@Serializable

data class MediaCacheMapping(val cacheUri: String, val mxcUri: String? = null, val size: Long = 0, val contentType: String? = ContentType.Application.OctetStream.toString())

MediaCacheMappingStore

class MediaCacheMappingStore(mediaCacheMappingRepository: MediaCacheMappingRepository, tm: RepositoryTransactionManager, config: MatrixClientConfiguration, statisticCollector: ObservableCacheStatisticCollector, storeScope: CoroutineScope, clock: Clock) : Store

OlmCryptoStore

class OlmCryptoStore(olmAccountRepository: OlmAccountRepository, olmForgetFallbackKeyAfterRepository: OlmForgetFallbackKeyAfterRepository, olmSessionRepository: OlmSessionRepository, inboundMegolmSessionRepository: InboundMegolmSessionRepository, inboundMegolmMessageIndexRepository: InboundMegolmMessageIndexRepository, outboundMegolmSessionRepository: OutboundMegolmSessionRepository, tm: RepositoryTransactionManager, config: MatrixClientConfiguration, statisticCollector: ObservableCacheStatisticCollector, storeScope: CoroutineScope, clock: Clock) : Store

Room

@Serializable

data class Room(val roomId: RoomId, val createEventContent: CreateEventContent? = null, val name: RoomDisplayName? = null, val avatarUrl: String? = null, val isDirect: Boolean = false, val lastEventId: EventId? = null, val lastRelevantEventId: EventId? = null, val lastRelevantEventTimestamp: Instant? = null, val unreadMessageCount: Long = 0, val encrypted: Boolean = false, val membership: Membership = Membership.JOIN, val membersLoaded: Boolean = false, val nextRoomId: RoomId? = null, val markedUnread: Boolean = false)

RoomAccountDataStore

class RoomAccountDataStore(roomAccountDataRepository: RoomAccountDataRepository, tm: RepositoryTransactionManager, contentMappings: EventContentSerializerMappings, config: MatrixClientConfiguration, statisticCollector: ObservableCacheStatisticCollector, storeScope: CoroutineScope, clock: Clock) : Store

RoomDisplayName

@Serializable

data class RoomDisplayName(val explicitName: String? = null, val heroes: List<UserId> = emptyList(), val otherUsersCount: Int = 0, val isEmpty: Boolean = false, summary: Sync.Response.Rooms.JoinedRoom.RoomSummary?)

RoomOutboxMessage

@Serializable

data class RoomOutboxMessage<T : MessageEventContent>(val roomId: RoomId, val transactionId: String, val content: T, val createdAt: Instant, val sentAt: Instant? = null, val eventId: EventId? = null, val sendError: RoomOutboxMessage.SendError? = null, val keepMediaInCache: Boolean = true)

RoomOutboxMessageStore

class RoomOutboxMessageStore(roomOutboxMessageRepository: RoomOutboxMessageRepository, tm: RepositoryTransactionManager, config: MatrixClientConfiguration, statisticCollector: ObservableCacheStatisticCollector, storeScope: CoroutineScope, clock: Clock) : Store

RoomStateStore

class RoomStateStore(roomStateRepository: RoomStateRepository, tm: RepositoryTransactionManager, contentMappings: EventContentSerializerMappings, config: MatrixClientConfiguration, statisticCollector: ObservableCacheStatisticCollector, storeScope: CoroutineScope, clock: Clock) : Store

RoomStore

class RoomStore(roomRepository: RoomRepository, tm: RepositoryTransactionManager, config: MatrixClientConfiguration, statisticCollector: ObservableCacheStatisticCollector, storeScope: CoroutineScope, clock: Clock) : Store

RoomTimelineStore

class RoomTimelineStore(timelineEventRepository: TimelineEventRepository, timelineEventRelationRepository: TimelineEventRelationRepository, tm: RepositoryTransactionManager, config: MatrixClientConfiguration, statisticCollector: ObservableCacheStatisticCollector, storeScope: CoroutineScope, clock: Clock) : Store

RoomUser

@Serializable

data class RoomUser(val roomId: RoomId, val userId: UserId, val name: String, val event: ClientEvent.StateBaseEvent<MemberEventContent>)

RoomUserReceipts

@Serializable

data class RoomUserReceipts(val roomId: RoomId, val userId: UserId, val receipts: Map<ReceiptType, RoomUserReceipts.Receipt> = mapOf())

RoomUserStore

class RoomUserStore(roomUserRepository: RoomUserRepository, roomUserReceiptsRepository: RoomUserReceiptsRepository, tm: RepositoryTransactionManager, config: MatrixClientConfiguration, statisticCollector: ObservableCacheStatisticCollector, storeScope: CoroutineScope, clock: Clock) : Store

RootStore

class RootStore(stores: List<Store>) : Store

ServerData

@Serializable

data class ServerData(val versions: GetVersions.Response, val mediaConfig: GetMediaConfig.Response, val capabilities: GetCapabilities.Response? = GetCapabilities.Response(Capabilities(setOf())))

ServerDataStore

class ServerDataStore(repository: ServerDataRepository, tm: RepositoryTransactionManager, statisticCollector: ObservableCacheStatisticCollector, storeScope: CoroutineScope, clock: Clock) : Store

Store

interface Store

StoredCrossSigningKeys

@Serializable

data class StoredCrossSigningKeys(val value: SignedCrossSigningKeys, val trustLevel: KeySignatureTrustLevel)

StoredDeviceKeys

@Serializable

data class StoredDeviceKeys(val value: SignedDeviceKeys, val trustLevel: KeySignatureTrustLevel)

StoredRoomKeyRequest

@Serializable

data class StoredRoomKeyRequest(val content: RoomKeyRequestEventContent, val receiverDeviceIds: Set<String>, val createdAt: Instant)

StoredSecret

@Serializable

data class StoredSecret(val event: ClientEvent.GlobalAccountDataEvent<out SecretEventContent>, val decryptedPrivateKey: String)

StoredSecretKeyRequest

@Serializable

data class StoredSecretKeyRequest(val content: SecretKeyRequestEventContent, val receiverDeviceIds: Set<String>, val createdAt: Instant)

TimelineEvent

data class TimelineEvent(val event: ClientEvent.RoomEvent<*>, val content: Result<RoomEventContent>? = if (event.isEncrypted) null else Result.success(event.content), val previousEventId: EventId?, val nextEventId: EventId?, val gap: TimelineEvent.Gap?)

TimelineEventRelation

@Serializable

data class TimelineEventRelation(val roomId: RoomId, val eventId: EventId, val relationType: RelationType, val relatedEventId: EventId)

TimelineEventSerializer

class TimelineEventSerializer(mappings: Set<EventContentSerializerMapping<out RoomEventContent>>, storeTimelineEventContentUnencrypted: Boolean) : KSerializer<TimelineEvent>

Transaction

class Transaction : CoroutineContext.Element

TransactionManager

interface TransactionManager

TransactionManagerImpl

class TransactionManagerImpl(repositoryTransactionManager: RepositoryTransactionManager) : TransactionManager

Properties

avatarUrl

val RoomUser.avatarUrl: String?

creator

val Room.~~creator~~: UserId?

eventId

val TimelineEvent.eventId: EventId

federate

val Room.federate: Boolean?

hasBeenReplaced

val Room.hasBeenReplaced: Boolean

invitedMemberCount

val Room.invitedMemberCount: Long?

isEncrypted

val TimelineEvent.isEncrypted: Boolean

val ClientEvent.RoomEvent<*>.isEncrypted: Boolean

isFirst

val TimelineEvent.isFirst: Boolean

Returns true, when this is the first event of the room (not including room upgrades).

isLast

val TimelineEvent.isLast: Boolean

Returns true, when this is the last known event of the room (not including room upgrades).

isReplaced

val TimelineEvent.isReplaced: Boolean

isReplacing

val TimelineEvent.isReplacing: Boolean

isVerified

val KeySignatureTrustLevel.isVerified: Boolean

joinedMemberCount

val Room.joinedMemberCount: Long?

membership

val RoomUser.membership: Membership

originalName

val RoomUser.originalName: String?

originTimestamp

val TimelineEvent.originTimestamp: Long

previousRoomId

val Room.previousRoomId: RoomId?

relatesTo

val TimelineEvent.relatesTo: RelatesTo?

roomId

val TimelineEvent.roomId: RoomId

sender

val TimelineEvent.sender: UserId

type

val Room.type: CreateEventContent.RoomType?

unsigned

val TimelineEvent.unsigned: UnsignedRoomEventData?

version

val Room.version: String?

Functions

createStoreModule

fun createStoreModule(): Module

encryptedJoinedRooms

suspend fun RoomStore.encryptedJoinedRooms(): Set<RoomId>

get

inline fun <C : GlobalAccountDataEventContent> GlobalAccountDataStore.get(key: String = ""): Flow<ClientEvent.GlobalAccountDataEvent<C>?>

inline fun <C : StateEventContent> RoomStateStore.get(roomId: RoomId): Flow<Map<String, Flow<ClientEvent.StateBaseEvent<C>?>>>

inline fun <C : RoomAccountDataEventContent> RoomAccountDataStore.get(roomId: RoomId, key: String = ""): Flow<ClientEvent.RoomAccountDataEvent<C>?>

getByRooms

inline suspend fun <C : StateEventContent> RoomStateStore.getByRooms(roomIds: Set<RoomId>, stateKey: String = ""): List<ClientEvent.StateBaseEvent<C>>

getByStateKey

inline fun <C : StateEventContent> RoomStateStore.getByStateKey(roomId: RoomId, stateKey: String = ""): Flow<ClientEvent.StateBaseEvent<C>?>

getContentByStateKey

inline fun <C : StateEventContent> RoomStateStore.getContentByStateKey(roomId: RoomId, stateKey: String = ""): Flow<C?>

getNext

fun RoomTimelineStore.getNext(event: TimelineEvent): Flow<TimelineEvent?>?

getPrevious

suspend fun RoomTimelineStore.getPrevious(event: TimelineEvent): TimelineEvent?

members

suspend fun RoomStateStore.members(roomId: RoomId, memberships: Set<Membership>): Set<UserId>

membersCount

suspend fun RoomStateStore.membersCount(roomId: RoomId, membership: Membership, vararg moreMemberships: Membership): Long

waitForInboundMegolmSession

suspend fun OlmCryptoStore.waitForInboundMegolmSession(roomId: RoomId, sessionId: String, firstKnownIndexLessThen: Long? = null, onNotExisting: suspend CoroutineScope.() -> Unit? = null)