Janne Mareike Koschinski
Trixnity Messenger

Repository

maven("https://gitlab.com/api/v4/projects/47538655/packages/maven")
implementation("de.connect2x:trixnity-messenger:<version>")
val matrixMessenger = MatrixMessenger.create()
application {
    Window("My App") {
        MyMatrixClient(matrixMessenger.createRoot())
    }
}
val matrixMultiMessenger = MatrixMultiMessenger.create()
// this code has to be called from a `suspend` function
rootViewModel.rootStack.toFlow()
    .mapLatest { it.active.instance }
    .collect { wrapper ->
        when (wrapper) {
            is RootRouter.RootWrapper.None -> {} // draw an empty UI
            is RootRouter.RootWrapper.MatrixClientInitialization -> {} // show initialization of the MatrixClient (aka loading screen)
            else -> {} // add more cases
        }
    }
val matrixMessenger = MatrixMessenger.create {
    appName = "Dino Messenger"
    // ... more config ...
}
  class MyAddMatrixAccountViewModel(
    viewModelContext: ViewModelContext,
    addMatrixAccountViewModel: AddMatrixAccountViewModelImpl,
) : ViewModelContext by viewModelContext, AddMatrixAccountViewModel by addMatrixAccountViewModel {

    private val isDemoVersion: Boolean = ... // this is computed from the config or a runtime parameter
    val canChangeServerUrl: Boolean = !isDemoVersion
    override val serverUrl: MutableStateFlow<String> =
        MutableStateFlow(if (isDemoVersion) "https://myUrl" else addMatrixAccountViewModel.serverUrl.value)
}
fun addMatrixAccountModule() = module {
    single<AddMatrixAccountViewModelFactory> {
        object : AddMatrixAccountViewModelFactory {
            override fun create(
                viewModelContext: ViewModelContext,
                onAddMatrixAccountMethod: (AddMatrixAccountMethod) -> Unit,
                onCancel: () -> Unit
            ): AddMatrixAccountViewModel {
                return MyAddMatrixAccountViewModel(
                    viewModelContext,
                    AddMatrixAccountViewModelImpl(viewModelContext, onAddMatrixAccountMethod, onCancel),
                )
            }
        }
    }
}
val matrixMessenger = MatrixMessenger.create {
    modules += addMatrixAccountModule()
}
val dragAndDropHandler = matrixMessenger.defaultDragAndDropHandler // helper extension
// call functions on dragAndDropHandler
val urlHandler = matrixMessenger.defaultUrlHandler // helper extension
// call functions on urlHandler depending on the platform (only on Android, iOS, JVM)
let matrixMessenger = MatrixMessenger.companion.create()
var body: some Scene {
    WindowGroup {
        RootView(matrixMessenger.createRoot())
    }
}
import Foundation
import trixnity_messenger

public class ObservableValue<T : AnyObject> : ObservableObject {
    private let observableValue: Value<T>

    @Published
    var value: T

    private var observer: ((T) -> Void)?

    init(_ value: Value<T>) {
        observableValue = value
        self.value = observableValue.value
        observer = { [weak self] value in self?.value = value }
        observableValue.subscribe(observer: observer!)
    }

    deinit {
        observableValue.unsubscribe(observer: self.observer!)
    }
}
import SwiftUI
import trixnity_messenger

@propertyWrapper struct StateValue<T : AnyObject>: DynamicProperty {
    @ObservedObject
    private var obj: ObservableValue<T>

    var wrappedValue: T { obj.value }

    init(_ value: Value<T>) {
        obj = ObservableValue(value)
    }
}
struct RootView: View {
    @StateValue
    private var stack: ChildStack<RootRouter.Config, RootRouter.RootWrapper>
    private var activeStack: RootRouter.RootWrapper { stack.active.instance }

    init(_ viewModel: RootViewModel) {
        _stack = StateValue(viewModel.rootStack)
    }

    // ...
}
func observe<T>(_ stateFlow: SkieSwiftStateFlow<T>, _ assign: (T) -> ()) async {
  for await value in stateFlow.map({$0}) {
      assign(value)
  }
}
class AddMatrixAccountViewModelSwift: ObservableObject {
    let delegate: AddMatrixAccountViewModel
    @Published private(set) var serverDiscoveryState: AddMatrixAccountViewModelServerDiscoveryState

    init(delegate: AddMatrixAccountViewModel) {
        self.delegate = delegate
        self.serverDiscoveryState = delegate.serverDiscoveryState.value
    }

    @MainActor
    func activate() async {
        await observe(delegate.serverDiscoveryState) { self.serverDiscoveryState = $0 }
    }
}
struct AddMatrixAccountView: View {

    @ObservedObject private var viewModel: AddMatrixAccountViewModelSwift

    init(_ addMatrixAccountViewModel: AddMatrixAccountViewModel) {
        viewModel = AddMatrixAccountViewModelSwift(delegate: addMatrixAccountViewModel)
    }

    // here you can access `viewModel.serverDiscoveryState` and always get the last value
}
.task { // this is important: activate the wrapper view model observation of the original view model
    await viewModel.activate()
}