commonMain.net.folivo.trixnity.client.defaultModules.kt Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of trixnity-client-jvm Show documentation
Multiplatform Kotlin SDK for matrix-protocol
There is a newer version: 4.7.1
package net.folivo.trixnity.client

import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.datetime.Clock
import kotlinx.serialization.json.Json
import kotlinx.serialization.modules.SerializersModule
import kotlinx.serialization.modules.contextual
import net.folivo.trixnity.client.crypto.createCryptoModule
import net.folivo.trixnity.client.key.KeyBackupService
import net.folivo.trixnity.client.key.KeyService
import net.folivo.trixnity.client.key.OutgoingRoomKeyRequestEventHandler
import net.folivo.trixnity.client.key.createKeyModule
import net.folivo.trixnity.client.media.MediaService
import net.folivo.trixnity.client.media.createMediaModule
import net.folivo.trixnity.client.notification.NotificationService
import net.folivo.trixnity.client.notification.createNotificationModule
import net.folivo.trixnity.client.room.*
import net.folivo.trixnity.client.room.outbox.OutboxMessageMediaUploaderMappings
import net.folivo.trixnity.client.room.outbox.defaultOutboxMessageMediaUploaderMappings
import net.folivo.trixnity.client.store.RoomUser
import net.folivo.trixnity.client.store.TimelineEvent
import net.folivo.trixnity.client.store.TimelineEventSerializer
import net.folivo.trixnity.client.store.createStoreModule
import net.folivo.trixnity.client.user.*
import net.folivo.trixnity.client.verification.VerificationService
import net.folivo.trixnity.client.verification.createVerificationModule
import net.folivo.trixnity.clientserverapi.client.SyncApiClient
import net.folivo.trixnity.core.EventHandler
import net.folivo.trixnity.core.model.EventId
import net.folivo.trixnity.core.model.RoomId
import net.folivo.trixnity.core.model.UserId
import net.folivo.trixnity.core.model.events.m.PresenceEventContent
import net.folivo.trixnity.core.model.events.m.TypingEventContent
import net.folivo.trixnity.core.serialization.createMatrixEventJson
import net.folivo.trixnity.core.serialization.events.DefaultEventContentSerializerMappings
import net.folivo.trixnity.core.serialization.events.EventContentSerializerMappings
import org.koin.core.module.dsl.bind
import org.koin.core.module.dsl.named
import org.koin.core.module.dsl.singleOf
import org.koin.core.qualifier.named
import org.koin.dsl.module

fun createClockModule() = module {
    single { Clock.System }
}

fun createDefaultEventContentSerializerMappingsModule() = module {
    single { DefaultEventContentSerializerMappings }
}

fun createDefaultOutboxMessageMediaUploaderMappingsModule() = module {
    single { defaultOutboxMessageMediaUploaderMappings }
}

fun createDefaultMatrixJsonModule() = module {
    single {
        val mappings = get()
        val config = get()
        createMatrixEventJson(mappings, customModule = SerializersModule {
            contextual(
                TimelineEventSerializer(
                    mappings.message + mappings.state,
                    config.storeTimelineEventContentUnencrypted
                )
            )
        })
    }
}

fun createDefaultTrixnityModules() = listOf(
    createClockModule(),
    createDefaultEventContentSerializerMappingsModule(),
    createDefaultOutboxMessageMediaUploaderMappingsModule(),
    createDefaultMatrixJsonModule(),
    createStoreModule(),
    createRoomModule(),
    createUserModule(),
    createKeyModule(),
    createCryptoModule(),
    createVerificationModule(),
    createMediaModule(),
    createNotificationModule(),
)

@Deprecated("use createDefaultTrixnityModules instead", ReplaceWith("createDefaultTrixnityModules()"))
fun createDefaultModules() = createDefaultTrixnityModules()

/**
 * Use this module, if you want to create a bot with basic functionality. You don't have access to some data usually provided
 * by Trixnity (for example [RoomUser] or [TimelineEvent]).
 *
 * Instead, you need to manually listen to the sync events via [SyncApiClient] (can be received via [MatrixClient.api]).
 * You can encrypt and decrypt events by iterating through all [RoomEventEncryptionService] (can be received via [MatrixClient.roomEventEncryptionServices])
 * and use the first non-null result. For sending events asynchronously you can still use the outbox.
 *
 */
fun createTrixnityBotModules() = listOf(
    createClockModule(),
    createDefaultEventContentSerializerMappingsModule(),
    createDefaultOutboxMessageMediaUploaderMappingsModule(),
    createDefaultMatrixJsonModule(),
    createStoreModule(),
    createKeyModule(),
    createCryptoModule(),
    createMediaModule(),
    module {
        singleOf(::RoomListHandler) {
            bind()
            named()
        }
        singleOf(::RoomStateEventHandler) {
            bind()
            named()
        }
        singleOf(::RoomAccountDataEventHandler) {
            bind()
            named()
        }
        singleOf(::GlobalAccountDataEventHandler) {
            bind()
            named()
        }
        singleOf(::DirectRoomEventHandler) {
            bind()
            named()
        }
        singleOf(::RoomUpgradeHandler) {
            bind()
            named()
        }
        singleOf(::ForgetRoomServiceImpl) {
            bind()
        }
        single {
            LoadMembersServiceImpl(
                roomStore = get(),
                lazyMemberEventHandlers = getAll(),
                currentSyncState = get(),
                api = get(),
                scope = get(),
            )
        }
        single(named()) {
            MegolmRoomEventEncryptionService(
                roomStore = get(),
                loadMembersService = get(),
                roomStateStore = get(),
                olmCryptoStore = get(),
                keyBackupService = get(named()),
                outgoingRoomKeyRequestEventHandler = get(named()),
                olmEncryptionService = get(),
            )
        }
        singleOf(::UnencryptedRoomEventEncryptionService) {
            bind()
            named()
        }
        single(named()) {
            OutboxMessageEventHandler(
                config = get(),
                api = get(),
                roomEventEncryptionServices = getAll(),
                mediaService = get(),
                roomOutboxMessageStore = get(),
                outboxMessageMediaUploaderMappings = get(),
                currentSyncState = get(),
                tm = get(),
                clock = get(),
            )
        }
        single {
            RoomServiceImpl(
                api = get(),
                roomStore = get(),
                roomStateStore = get(),
                roomAccountDataStore = get(),
                roomTimelineStore = get(),
                roomOutboxMessageStore = get(),
                roomEventEncryptionServices = getAll(),
                forgetRoomService = get(),
                mediaService = get(),
                userInfo = get(),
                timelineEventHandler = object : TimelineEventHandler {
                    override suspend fun unsafeFillTimelineGaps(
                        startEventId: EventId,
                        roomId: RoomId,
                        limit: Long
                    ): Result {
                        throw IllegalStateException("TimelineEvents are not supported in bot mode")
                    }
                },
                typingEventHandler = object : TypingEventHandler {
                    override val usersTyping: StateFlow> = MutableStateFlow(mapOf())
                },
                currentSyncState = get(),
                scope = get(),
                config = get(),
            )
        }
        single {
            UserServiceImpl(
                roomStore = get(),
                roomUserStore = get(),
                roomStateStore = get(),
                roomTimelineStore = get(),
                globalAccountDataStore = get(),
                loadMembersService = get(),
                presenceEventHandler = object : PresenceEventHandler {
                    override val userPresence: StateFlow> = MutableStateFlow(mapOf())
                },
                userInfo = get(),
                mappings = get(),
            )
        }
    }
)

val MatrixClient.room
    get() = di.get()

val MatrixClient.user
    get() = di.get()

val MatrixClient.media
    get() = di.get()

val MatrixClient.verification
    get() = di.get()

val MatrixClient.key
    get() = di.get()

val MatrixClient.notification
    get() = di.get()

val MatrixClient.roomEventEncryptionServices
    get() = di.getAll()