From 2e591db2e9c2d27fa1b95c81bcb5163a16f35872 Mon Sep 17 00:00:00 2001 From: Marcel Hibbe Date: Wed, 6 Nov 2024 15:03:22 +0100 Subject: [PATCH] use repository in MessageInputViewModel instead datasource (as datasources should be only used in repositories) use coroutines instead RxJava for api calls triggered by MessageInputViewModel Signed-off-by: Marcel Hibbe --- .../java/com/nextcloud/talk/api/NcApi.java | 6 -- .../com/nextcloud/talk/api/NcApiCoroutines.kt | 21 +++++ .../com/nextcloud/talk/chat/ChatActivity.kt | 25 +++-- .../talk/chat/data/ChatMessageRepository.kt | 13 +++ .../data/network/ChatNetworkDataSource.kt | 4 +- .../network/OfflineFirstChatRepository.kt | 46 ++++++++++ .../chat/data/network/RetrofitChatNetwork.kt | 14 +-- .../chat/viewmodels/MessageInputViewModel.kt | 82 +++++++---------- .../OfflineFirstConversationsRepository.kt | 3 +- .../talk/dagger/modules/RepositoryModule.kt | 91 +++++++------------ 10 files changed, 165 insertions(+), 140 deletions(-) diff --git a/app/src/main/java/com/nextcloud/talk/api/NcApi.java b/app/src/main/java/com/nextcloud/talk/api/NcApi.java index 5ed659da7..679baeaff 100644 --- a/app/src/main/java/com/nextcloud/talk/api/NcApi.java +++ b/app/src/main/java/com/nextcloud/talk/api/NcApi.java @@ -353,12 +353,6 @@ public interface NcApi { @Field("referenceId") String referenceId ); - @FormUrlEncoded - @PUT - Observable editChatMessage(@Header("Authorization") String authorization, - @Url String url, - @Field("message") String message); - @GET Observable> getSharedItems( @Header("Authorization") String authorization, diff --git a/app/src/main/java/com/nextcloud/talk/api/NcApiCoroutines.kt b/app/src/main/java/com/nextcloud/talk/api/NcApiCoroutines.kt index 3bbdf0f90..c2cc6bd6e 100644 --- a/app/src/main/java/com/nextcloud/talk/api/NcApiCoroutines.kt +++ b/app/src/main/java/com/nextcloud/talk/api/NcApiCoroutines.kt @@ -8,6 +8,7 @@ package com.nextcloud.talk.api import com.nextcloud.talk.models.json.autocomplete.AutocompleteOverall +import com.nextcloud.talk.models.json.chat.ChatOverallSingleMessage import com.nextcloud.talk.models.json.conversations.RoomOverall import com.nextcloud.talk.models.json.generic.GenericOverall import com.nextcloud.talk.models.json.participants.AddParticipantOverall @@ -121,6 +122,26 @@ interface NcApiCoroutines { @DELETE suspend fun unarchiveConversation(@Header("Authorization") authorization: String, @Url url: String): GenericOverall + @FormUrlEncoded + @POST + suspend fun sendChatMessage( + @Header("Authorization") authorization: String, + @Url url: String, + @Field("message") message: CharSequence, + @Field("actorDisplayName") actorDisplayName: String, + @Field("replyTo") replyTo: Int, + @Field("silent") sendWithoutNotification: Boolean, + @Field("referenceId") referenceId: String + ): ChatOverallSingleMessage + + @FormUrlEncoded + @PUT + suspend fun editChatMessage( + @Header("Authorization") authorization: String, + @Url url: String, + @Field("message") message: String + ): ChatOverallSingleMessage + @FormUrlEncoded @POST suspend fun banActor( diff --git a/app/src/main/java/com/nextcloud/talk/chat/ChatActivity.kt b/app/src/main/java/com/nextcloud/talk/chat/ChatActivity.kt index 4689d35e2..47a959bb3 100644 --- a/app/src/main/java/com/nextcloud/talk/chat/ChatActivity.kt +++ b/app/src/main/java/com/nextcloud/talk/chat/ChatActivity.kt @@ -200,7 +200,6 @@ import kotlinx.coroutines.launch import kotlinx.coroutines.withContext import org.greenrobot.eventbus.Subscribe import org.greenrobot.eventbus.ThreadMode -import retrofit2.HttpException import java.io.File import java.io.IOException import java.net.HttpURLConnection @@ -791,18 +790,18 @@ class ChatActivity : } is MessageInputViewModel.SendChatMessageErrorState -> { - if (state.e is HttpException) { - val code = state.e.code() - if (code.toString().startsWith("2")) { - myFirstMessage = state.message - - if (binding.unreadMessagesPopup.isShown) { - binding.unreadMessagesPopup.visibility = View.GONE - } - - binding.messagesListView.smoothScrollToPosition(0) - } - } + // if (state.e is HttpException) { + // val code = state.e.code() + // if (code.toString().startsWith("2")) { + // myFirstMessage = state.message + // + // if (binding.unreadMessagesPopup.isShown) { + // binding.unreadMessagesPopup.visibility = View.GONE + // } + // + // binding.messagesListView.smoothScrollToPosition(0) + // } + // } } else -> {} diff --git a/app/src/main/java/com/nextcloud/talk/chat/data/ChatMessageRepository.kt b/app/src/main/java/com/nextcloud/talk/chat/data/ChatMessageRepository.kt index 5cbf39efe..010e18d7c 100644 --- a/app/src/main/java/com/nextcloud/talk/chat/data/ChatMessageRepository.kt +++ b/app/src/main/java/com/nextcloud/talk/chat/data/ChatMessageRepository.kt @@ -11,6 +11,7 @@ import android.os.Bundle import com.nextcloud.talk.chat.data.io.LifecycleAwareManager import com.nextcloud.talk.chat.data.model.ChatMessage import com.nextcloud.talk.models.domain.ConversationModel +import com.nextcloud.talk.models.json.chat.ChatOverallSingleMessage import kotlinx.coroutines.Job import kotlinx.coroutines.flow.Flow @@ -75,4 +76,16 @@ interface ChatMessageRepository : LifecycleAwareManager { * Destroys unused resources. */ fun handleChatOnBackPress() + + suspend fun sendChatMessage( + credentials: String, + url: String, + message: CharSequence, + displayName: String, + replyTo: Int, + sendWithoutNotification: Boolean, + referenceId: String + ): Flow> + + suspend fun editChatMessage(credentials: String, url: String, text: String): Flow> } diff --git a/app/src/main/java/com/nextcloud/talk/chat/data/network/ChatNetworkDataSource.kt b/app/src/main/java/com/nextcloud/talk/chat/data/network/ChatNetworkDataSource.kt index 079523e69..ae1865511 100644 --- a/app/src/main/java/com/nextcloud/talk/chat/data/network/ChatNetworkDataSource.kt +++ b/app/src/main/java/com/nextcloud/talk/chat/data/network/ChatNetworkDataSource.kt @@ -49,7 +49,7 @@ interface ChatNetworkDataSource { ): Observable fun leaveRoom(credentials: String, url: String): Observable - fun sendChatMessage( + suspend fun sendChatMessage( credentials: String, url: String, message: CharSequence, @@ -57,7 +57,7 @@ interface ChatNetworkDataSource { replyTo: Int, sendWithoutNotification: Boolean, referenceId: String - ): Observable + ): ChatOverallSingleMessage fun pullChatMessages(credentials: String, url: String, fieldMap: HashMap): Observable> fun deleteChatMessage(credentials: String, url: String): Observable diff --git a/app/src/main/java/com/nextcloud/talk/chat/data/network/OfflineFirstChatRepository.kt b/app/src/main/java/com/nextcloud/talk/chat/data/network/OfflineFirstChatRepository.kt index bf3a9f7fa..7f382eb2c 100644 --- a/app/src/main/java/com/nextcloud/talk/chat/data/network/OfflineFirstChatRepository.kt +++ b/app/src/main/java/com/nextcloud/talk/chat/data/network/OfflineFirstChatRepository.kt @@ -24,6 +24,7 @@ import com.nextcloud.talk.data.user.model.User import com.nextcloud.talk.models.domain.ConversationModel import com.nextcloud.talk.models.json.chat.ChatMessageJson import com.nextcloud.talk.models.json.chat.ChatOverall +import com.nextcloud.talk.models.json.chat.ChatOverallSingleMessage import com.nextcloud.talk.utils.bundle.BundleKeys import com.nextcloud.talk.utils.database.user.CurrentUserProviderNew import com.nextcloud.talk.utils.preferences.AppPreferences @@ -37,6 +38,7 @@ import kotlinx.coroutines.delay import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.MutableSharedFlow import kotlinx.coroutines.flow.first +import kotlinx.coroutines.flow.flow import kotlinx.coroutines.flow.map import kotlinx.coroutines.launch import javax.inject.Inject @@ -739,6 +741,50 @@ class OfflineFirstChatRepository @Inject constructor( scope.cancel() } + override suspend fun sendChatMessage( + credentials: String, + url: String, + message: CharSequence, + displayName: String, + replyTo: Int, + sendWithoutNotification: Boolean, + referenceId: String + ): Flow> = + flow { + try { + val response = network.sendChatMessage( + credentials, + url, + message, + displayName, + replyTo, + sendWithoutNotification, + referenceId + ) + emit(Result.success(response)) + } catch (e: Exception) { + emit(Result.failure(e)) + } + } + + override suspend fun editChatMessage( + credentials: String, + url: String, + text: String + ): Flow> = + flow { + try { + val response = network.editChatMessage( + credentials, + url, + text + ) + emit(Result.success(response)) + } catch (e: Exception) { + emit(Result.failure(e)) + } + } + companion object { val TAG = OfflineFirstChatRepository::class.simpleName private const val HTTP_CODE_OK: Int = 200 diff --git a/app/src/main/java/com/nextcloud/talk/chat/data/network/RetrofitChatNetwork.kt b/app/src/main/java/com/nextcloud/talk/chat/data/network/RetrofitChatNetwork.kt index 5a9f9fd50..9733a890a 100644 --- a/app/src/main/java/com/nextcloud/talk/chat/data/network/RetrofitChatNetwork.kt +++ b/app/src/main/java/com/nextcloud/talk/chat/data/network/RetrofitChatNetwork.kt @@ -7,6 +7,7 @@ package com.nextcloud.talk.chat.data.network import com.nextcloud.talk.api.NcApi +import com.nextcloud.talk.api.NcApiCoroutines import com.nextcloud.talk.data.user.model.User import com.nextcloud.talk.models.domain.ConversationModel import com.nextcloud.talk.models.json.capabilities.SpreedCapability @@ -20,7 +21,8 @@ import com.nextcloud.talk.utils.message.SendMessageUtils import io.reactivex.Observable import retrofit2.Response -class RetrofitChatNetwork(private val ncApi: NcApi) : ChatNetworkDataSource { +class RetrofitChatNetwork(private val ncApi: NcApi, private val ncApiCoroutines: NcApiCoroutines) : + ChatNetworkDataSource { override fun getRoom(user: User, roomToken: String): Observable { val credentials: String = ApiUtils.getCredentials(user.username, user.token)!! val apiVersion = ApiUtils.getConversationApiVersion(user, intArrayOf(ApiUtils.API_V4, ApiUtils.API_V3, 1)) @@ -136,7 +138,7 @@ class RetrofitChatNetwork(private val ncApi: NcApi) : ChatNetworkDataSource { it } - override fun sendChatMessage( + override suspend fun sendChatMessage( credentials: String, url: String, message: CharSequence, @@ -144,8 +146,8 @@ class RetrofitChatNetwork(private val ncApi: NcApi) : ChatNetworkDataSource { replyTo: Int, sendWithoutNotification: Boolean, referenceId: String - ): Observable = - ncApi.sendChatMessage( + ): ChatOverallSingleMessage = + ncApiCoroutines.sendChatMessage( credentials, url, message, @@ -153,9 +155,7 @@ class RetrofitChatNetwork(private val ncApi: NcApi) : ChatNetworkDataSource { replyTo, sendWithoutNotification, referenceId - ).map { - it - } + ) override fun pullChatMessages( credentials: String, diff --git a/app/src/main/java/com/nextcloud/talk/chat/viewmodels/MessageInputViewModel.kt b/app/src/main/java/com/nextcloud/talk/chat/viewmodels/MessageInputViewModel.kt index 191006d86..4f2331547 100644 --- a/app/src/main/java/com/nextcloud/talk/chat/viewmodels/MessageInputViewModel.kt +++ b/app/src/main/java/com/nextcloud/talk/chat/viewmodels/MessageInputViewModel.kt @@ -15,6 +15,8 @@ import androidx.lifecycle.LiveData import androidx.lifecycle.MutableLiveData import androidx.lifecycle.ViewModel import androidx.lifecycle.asLiveData +import androidx.lifecycle.viewModelScope +import com.nextcloud.talk.chat.data.ChatMessageRepository import com.nextcloud.talk.chat.data.io.AudioFocusRequestManager import com.nextcloud.talk.chat.data.io.AudioRecorderManager import com.nextcloud.talk.chat.data.io.MediaPlayerManager @@ -24,17 +26,15 @@ import com.nextcloud.talk.models.json.chat.ChatOverallSingleMessage import com.nextcloud.talk.utils.message.SendMessageUtils import com.nextcloud.talk.utils.preferences.AppPreferences import com.stfalcon.chatkit.commons.models.IMessage -import io.reactivex.Observer -import io.reactivex.android.schedulers.AndroidSchedulers import io.reactivex.disposables.Disposable -import io.reactivex.schedulers.Schedulers import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.update +import kotlinx.coroutines.launch import java.lang.Thread.sleep import javax.inject.Inject class MessageInputViewModel @Inject constructor( - private val chatNetworkDataSource: ChatNetworkDataSource, + private val chatRepository: ChatMessageRepository, private val audioRecorderManager: AudioRecorderManager, private val mediaPlayerManager: MediaPlayerManager, private val audioFocusRequestManager: AudioFocusRequestManager, @@ -107,7 +107,7 @@ class MessageInputViewModel @Inject constructor( sealed interface ViewState object SendChatMessageStartState : ViewState class SendChatMessageSuccessState(val message: CharSequence) : ViewState - class SendChatMessageErrorState(val e: Throwable, val message: CharSequence) : ViewState + class SendChatMessageErrorState(val message: CharSequence) : ViewState private val _sendChatMessageViewState: MutableLiveData = MutableLiveData(SendChatMessageStartState) val sendChatMessageViewState: LiveData get() = _sendChatMessageViewState @@ -161,59 +161,41 @@ class MessageInputViewModel @Inject constructor( return } - chatNetworkDataSource.sendChatMessage( - credentials, - url, - message, - displayName, - replyTo, - sendWithoutNotification, - referenceId - ).subscribeOn(Schedulers.io()) - ?.observeOn(AndroidSchedulers.mainThread()) - ?.subscribe(object : Observer { - override fun onSubscribe(d: Disposable) { - disposableSet.add(d) - } + viewModelScope.launch { + chatRepository.sendChatMessage( + credentials, + url, + message, + displayName, + replyTo, + sendWithoutNotification, + referenceId + ).collect { result -> + if (result.isSuccess) { + Log.d(TAG, "received ref id: " + (result.getOrNull()?.ocs?.data?.referenceId ?: "none")) - override fun onError(e: Throwable) { - _sendChatMessageViewState.value = SendChatMessageErrorState(e, message) - } - - override fun onComplete() { - // unused atm - } - - override fun onNext(t: ChatOverallSingleMessage) { - Log.d(TAG, "received ref id: " + (t.ocs?.data?.referenceId ?: "none")) - // TODO check ref id and replace temp message _sendChatMessageViewState.value = SendChatMessageSuccessState(message) + } else { + _sendChatMessageViewState.value = SendChatMessageErrorState(message) } - }) + } + } } fun editChatMessage(credentials: String, url: String, text: String) { - chatNetworkDataSource.editChatMessage(credentials, url, text) - .subscribeOn(Schedulers.io()) - ?.observeOn(AndroidSchedulers.mainThread()) - ?.subscribe(object : Observer { - override fun onSubscribe(d: Disposable) { - disposableSet.add(d) - } - - override fun onError(e: Throwable) { - Log.e(TAG, "failed to edit message", e) + viewModelScope.launch { + chatRepository.editChatMessage( + credentials, + url, + text + ).collect { result -> + if (result.isSuccess) { + _editMessageViewState.value = EditMessageSuccessState(result.getOrNull()!!) + } else { _editMessageViewState.value = EditMessageErrorState } - - override fun onComplete() { - // unused atm - } - - override fun onNext(messageEdited: ChatOverallSingleMessage) { - _editMessageViewState.value = EditMessageSuccessState(messageEdited) - } - }) + } + } } fun reply(message: IMessage?) { diff --git a/app/src/main/java/com/nextcloud/talk/conversationlist/data/network/OfflineFirstConversationsRepository.kt b/app/src/main/java/com/nextcloud/talk/conversationlist/data/network/OfflineFirstConversationsRepository.kt index f2d30a83b..8a68e366a 100644 --- a/app/src/main/java/com/nextcloud/talk/conversationlist/data/network/OfflineFirstConversationsRepository.kt +++ b/app/src/main/java/com/nextcloud/talk/conversationlist/data/network/OfflineFirstConversationsRepository.kt @@ -10,7 +10,6 @@ package com.nextcloud.talk.conversationlist.data.network import android.util.Log import com.nextcloud.talk.chat.data.network.ChatNetworkDataSource -import com.nextcloud.talk.chat.data.network.OfflineFirstChatRepository import com.nextcloud.talk.conversationlist.data.OfflineConversationsRepository import com.nextcloud.talk.data.database.dao.ConversationsDao import com.nextcloud.talk.data.database.mappers.asEntity @@ -107,7 +106,7 @@ class OfflineFirstConversationsRepository @Inject constructor( var conversationsFromSync: List? = null if (!monitor.isOnline.first()) { - Log.d(OfflineFirstChatRepository.TAG, "Device is offline, can't load conversations from server") + Log.d(TAG, "Device is offline, can't load conversations from server") return null } diff --git a/app/src/main/java/com/nextcloud/talk/dagger/modules/RepositoryModule.kt b/app/src/main/java/com/nextcloud/talk/dagger/modules/RepositoryModule.kt index b33c9ffbb..b81a1604b 100644 --- a/app/src/main/java/com/nextcloud/talk/dagger/modules/RepositoryModule.kt +++ b/app/src/main/java/com/nextcloud/talk/dagger/modules/RepositoryModule.kt @@ -74,87 +74,66 @@ class RepositoryModule { ncApi: NcApi, ncApiCoroutines: NcApiCoroutines, userProvider: CurrentUserProviderNew - ): ConversationsRepository { - return ConversationsRepositoryImpl(ncApi, ncApiCoroutines, userProvider) - } + ): ConversationsRepository = ConversationsRepositoryImpl(ncApi, ncApiCoroutines, userProvider) @Provides - fun provideSharedItemsRepository(ncApi: NcApi, dateUtils: DateUtils): SharedItemsRepository { - return SharedItemsRepositoryImpl(ncApi, dateUtils) - } + fun provideSharedItemsRepository(ncApi: NcApi, dateUtils: DateUtils): SharedItemsRepository = + SharedItemsRepositoryImpl(ncApi, dateUtils) @Provides - fun provideUnifiedSearchRepository(ncApi: NcApi, userProvider: CurrentUserProviderNew): UnifiedSearchRepository { - return UnifiedSearchRepositoryImpl(ncApi, userProvider) - } + fun provideUnifiedSearchRepository(ncApi: NcApi, userProvider: CurrentUserProviderNew): UnifiedSearchRepository = + UnifiedSearchRepositoryImpl(ncApi, userProvider) @Provides - fun provideDialogPollRepository(ncApi: NcApi, userProvider: CurrentUserProviderNew): PollRepository { - return PollRepositoryImpl(ncApi, userProvider) - } + fun provideDialogPollRepository(ncApi: NcApi, userProvider: CurrentUserProviderNew): PollRepository = + PollRepositoryImpl(ncApi, userProvider) @Provides fun provideRemoteFileBrowserItemsRepository( okHttpClient: OkHttpClient, userProvider: CurrentUserProviderNew - ): RemoteFileBrowserItemsRepository { - return RemoteFileBrowserItemsRepositoryImpl(okHttpClient, userProvider) - } + ): RemoteFileBrowserItemsRepository = RemoteFileBrowserItemsRepositoryImpl(okHttpClient, userProvider) @Provides - fun provideUsersRepository(database: TalkDatabase): UsersRepository { - return UsersRepositoryImpl(database.usersDao()) - } + fun provideUsersRepository(database: TalkDatabase): UsersRepository = UsersRepositoryImpl(database.usersDao()) @Provides - fun provideArbitraryStoragesRepository(database: TalkDatabase): ArbitraryStoragesRepository { - return ArbitraryStoragesRepositoryImpl(database.arbitraryStoragesDao()) - } + fun provideArbitraryStoragesRepository(database: TalkDatabase): ArbitraryStoragesRepository = + ArbitraryStoragesRepositoryImpl(database.arbitraryStoragesDao()) @Provides fun provideReactionsRepository( ncApi: NcApi, userProvider: CurrentUserProviderNew, dao: ChatMessagesDao - ): ReactionsRepository { - return ReactionsRepositoryImpl(ncApi, userProvider, dao) - } + ): ReactionsRepository = ReactionsRepositoryImpl(ncApi, userProvider, dao) @Provides - fun provideCallRecordingRepository(ncApi: NcApi, userProvider: CurrentUserProviderNew): CallRecordingRepository { - return CallRecordingRepositoryImpl(ncApi, userProvider) - } + fun provideCallRecordingRepository(ncApi: NcApi, userProvider: CurrentUserProviderNew): CallRecordingRepository = + CallRecordingRepositoryImpl(ncApi, userProvider) @Provides fun provideRequestAssistanceRepository( ncApi: NcApi, userProvider: CurrentUserProviderNew - ): RequestAssistanceRepository { - return RequestAssistanceRepositoryImpl(ncApi, userProvider) - } + ): RequestAssistanceRepository = RequestAssistanceRepositoryImpl(ncApi, userProvider) @Provides fun provideOpenConversationsRepository( ncApi: NcApi, userProvider: CurrentUserProviderNew - ): OpenConversationsRepository { - return OpenConversationsRepositoryImpl(ncApi, userProvider) - } + ): OpenConversationsRepository = OpenConversationsRepositoryImpl(ncApi, userProvider) @Provides - fun translateRepository(ncApi: NcApi): TranslateRepository { - return TranslateRepositoryImpl(ncApi) - } + fun translateRepository(ncApi: NcApi): TranslateRepository = TranslateRepositoryImpl(ncApi) @Provides - fun provideChatNetworkDataSource(ncApi: NcApi): ChatNetworkDataSource { - return RetrofitChatNetwork(ncApi) - } + fun provideChatNetworkDataSource(ncApi: NcApi, ncApiCoroutines: NcApiCoroutines): ChatNetworkDataSource = + RetrofitChatNetwork(ncApi, ncApiCoroutines) @Provides - fun provideConversationsNetworkDataSource(ncApi: NcApi): ConversationsNetworkDataSource { - return RetrofitConversationsNetwork(ncApi) - } + fun provideConversationsNetworkDataSource(ncApi: NcApi): ConversationsNetworkDataSource = + RetrofitConversationsNetwork(ncApi) @Provides fun provideConversationInfoEditRepository( @@ -166,14 +145,11 @@ class RepositoryModule { } @Provides - fun provideConversationRepository(ncApi: NcApi, userProvider: CurrentUserProviderNew): ConversationRepository { - return ConversationRepositoryImpl(ncApi, userProvider) - } + fun provideConversationRepository(ncApi: NcApi, userProvider: CurrentUserProviderNew): ConversationRepository = + ConversationRepositoryImpl(ncApi, userProvider) @Provides - fun provideInvitationsRepository(ncApi: NcApi): InvitationsRepository { - return InvitationsRepositoryImpl(ncApi) - } + fun provideInvitationsRepository(ncApi: NcApi): InvitationsRepository = InvitationsRepositoryImpl(ncApi) @Provides fun provideOfflineFirstChatRepository( @@ -183,8 +159,8 @@ class RepositoryModule { appPreferences: AppPreferences, networkMonitor: NetworkMonitor, userProvider: CurrentUserProviderNew - ): ChatMessageRepository { - return OfflineFirstChatRepository( + ): ChatMessageRepository = + OfflineFirstChatRepository( chatMessagesDao, chatBlocksDao, dataSource, @@ -192,7 +168,6 @@ class RepositoryModule { networkMonitor, userProvider ) - } @Provides fun provideOfflineFirstConversationsRepository( @@ -201,26 +176,22 @@ class RepositoryModule { chatNetworkDataSource: ChatNetworkDataSource, networkMonitor: NetworkMonitor, currentUserProviderNew: CurrentUserProviderNew - ): OfflineConversationsRepository { - return OfflineFirstConversationsRepository( + ): OfflineConversationsRepository = + OfflineFirstConversationsRepository( dao, dataSource, chatNetworkDataSource, networkMonitor, currentUserProviderNew ) - } @Provides - fun provideContactsRepository(ncApiCoroutines: NcApiCoroutines, userManager: UserManager): ContactsRepository { - return ContactsRepositoryImpl(ncApiCoroutines, userManager) - } + fun provideContactsRepository(ncApiCoroutines: NcApiCoroutines, userManager: UserManager): ContactsRepository = + ContactsRepositoryImpl(ncApiCoroutines, userManager) @Provides fun provideConversationCreationRepository( ncApiCoroutines: NcApiCoroutines, userManager: UserManager - ): ConversationCreationRepository { - return ConversationCreationRepositoryImpl(ncApiCoroutines, userManager) - } + ): ConversationCreationRepository = ConversationCreationRepositoryImpl(ncApiCoroutines, userManager) }