Fixes to call creation process

app/src/main/java/com/nextcloud/talk/application/NextcloudTalkApplication.kt

@@ -49,9 +49,7 @@ import com.nextcloud.talk.models.ExternalSignalingServer
 import com.nextcloud.talk.models.database.UserEntity
 import com.nextcloud.talk.models.json.capabilities.Capabilities
 import com.nextcloud.talk.models.json.push.PushConfigurationState
-import com.nextcloud.talk.newarch.di.module.CommunicationModule
+import com.nextcloud.talk.newarch.di.module.*
-import com.nextcloud.talk.newarch.di.module.NetworkModule
-import com.nextcloud.talk.newarch.di.module.StorageModule
 import com.nextcloud.talk.newarch.features.conversationsList.di.module.ConversationsListModule
 import com.nextcloud.talk.newarch.local.dao.UsersDao
 import com.nextcloud.talk.newarch.local.models.UserNgEntity
@@ -165,13 +163,13 @@ class NextcloudTalkApplication : Application(), LifecycleObserver {
         val signalingSettingsWork = OneTimeWorkRequest.Builder(SignalingSettingsWorker::class.java)
                 .build()
 
-        WorkManager.getInstance()
+        WorkManager.getInstance(this)
                 .enqueue(pushRegistrationWork)
-        WorkManager.getInstance()
+        WorkManager.getInstance(this)
                 .enqueue(accountRemovalWork)
-        WorkManager.getInstance()
+        WorkManager.getInstance(this)
                 .enqueue(signalingSettingsWork)
-        WorkManager.getInstance()
+        WorkManager.getInstance(this)
                 .enqueueUniquePeriodicWork(
                         "DailyCapabilitiesUpdateWork", ExistingPeriodicWorkPolicy.REPLACE,
                         periodicCapabilitiesUpdateWork
@@ -195,7 +193,7 @@ class NextcloudTalkApplication : Application(), LifecycleObserver {
         startKoin {
             androidContext(this@NextcloudTalkApplication)
             androidLogger()
-            modules(listOf(CommunicationModule, StorageModule, NetworkModule, ConversationsListModule))
+            modules(listOf(CommunicationModule, StorageModule, NetworkModule, ConversationsModule, ConversationsListModule, ManagementModule))
         }
     }
 

app/src/main/java/com/nextcloud/talk/controllers/ChatController.kt

@@ -123,7 +123,7 @@ class ChatController(args: Bundle) : BaseController(), MessagesListAdapter
     @BindView(R.id.smileyButton)
     @JvmField
     var smileyButton: ImageButton? = null
-    @BindView(R.id.lobby_view)
+    @BindView(R.id.lobbyView)
     @JvmField
     var lobbyView: RelativeLayout? = null
     @BindView(R.id.lobbyTextView)

app/src/main/java/com/nextcloud/talk/controllers/bottomsheet/OperationsMenuController.kt

@@ -61,6 +61,10 @@ import io.reactivex.Observer
 import io.reactivex.android.schedulers.AndroidSchedulers
 import io.reactivex.disposables.Disposable
 import io.reactivex.schedulers.Schedulers
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import org.koin.android.ext.android.inject
 import org.parceler.Parcels
 import retrofit2.HttpException
@@ -150,147 +154,74 @@ class OperationsMenuController(args: Bundle) : BaseController() {
     }
 
     private fun processOperation() {
-        currentUser = usersRepository.getActiveUser()
+        GlobalScope.launch {
-        val operationsObserver = OperationsObserver()
+            currentUser = usersRepository.getActiveUser()
+            val operationsObserver = OperationsObserver()
 
-        if (!TextUtils.isEmpty(callUrl) && callUrl.contains("/call")) {
+            if (!TextUtils.isEmpty(callUrl) && callUrl.contains("/call")) {
-            conversationToken = callUrl.substring(callUrl.lastIndexOf("/") + 1)
+                conversationToken = callUrl.substring(callUrl.lastIndexOf("/") + 1)
-            if (callUrl.contains("/index.php")) {
+                if (callUrl.contains("/index.php")) {
-                baseUrl = callUrl.substring(0, callUrl.indexOf("/index.php"))
+                    baseUrl = callUrl.substring(0, callUrl.indexOf("/index.php"))
-            } else {
+                } else {
-                baseUrl = callUrl.substring(0, callUrl.indexOf("/call"))
+                    baseUrl = callUrl.substring(0, callUrl.indexOf("/call"))
-            }
+                }
-        }
-
-        if (currentUser != null) {
-            credentials = currentUser!!.getCredentials()
-
-            if (!TextUtils.isEmpty(baseUrl) && baseUrl != currentUser!!.baseUrl) {
-                credentials = null
             }
 
-            when (operationCode) {
+            if (currentUser != null) {
-                2 -> ncApi.renameRoom(credentials,
+                credentials = currentUser!!.getCredentials()
-                        ApiUtils.getRoom(currentUser!!.baseUrl, conversation!!.token),
+
-                        conversation!!.name)
+                if (!TextUtils.isEmpty(baseUrl) && baseUrl != currentUser!!.baseUrl) {
-                        .subscribeOn(Schedulers.io())
+                    credentials = null
-                        .observeOn(AndroidSchedulers.mainThread())
+                }
-                        .retry(1)
+
-                        .subscribe(operationsObserver)
+                when (operationCode) {
-                3 -> ncApi.makeRoomPublic(credentials,
+                    2 -> ncApi.renameRoom(credentials,
-                        ApiUtils.getUrlForRoomVisibility(currentUser!!.baseUrl, conversation!!
+                            ApiUtils.getRoom(currentUser!!.baseUrl, conversation!!.token),
-                                .token))
+                            conversation!!.name)
-                        .subscribeOn(Schedulers.io())
-                        .observeOn(AndroidSchedulers.mainThread())
-                        .retry(1)
-                        .subscribe(operationsObserver)
-                4, 5, 6 -> {
-                    var pass: String? = ""
-                    if (conversation!!.password != null) {
-                        pass = conversation!!.password
-                    }
-                    ncApi.setPassword(credentials, ApiUtils.getUrlForPassword(currentUser!!.baseUrl,
-                            conversation!!.token), pass)
                             .subscribeOn(Schedulers.io())
                             .observeOn(AndroidSchedulers.mainThread())
                             .retry(1)
                             .subscribe(operationsObserver)
-                }
+                    3 -> ncApi.makeRoomPublic(credentials,
-                7 -> {
+                            ApiUtils.getUrlForRoomVisibility(currentUser!!.baseUrl, conversation!!
-                }
+                                    .token))
-                8 -> ncApi.makeRoomPrivate(credentials,
+                            .subscribeOn(Schedulers.io())
-                        ApiUtils.getUrlForRoomVisibility(currentUser!!.baseUrl, conversation!!
+                            .observeOn(AndroidSchedulers.mainThread())
-                                .token))
+                            .retry(1)
-                        .subscribeOn(Schedulers.io())
+                            .subscribe(operationsObserver)
-                        .observeOn(AndroidSchedulers.mainThread())
+                    4, 5, 6 -> {
-                        .retry(1)
+                        var pass: String? = ""
-                        .subscribe(operationsObserver)
+                        if (conversation!!.password != null) {
-                10 -> ncApi.getRoom(credentials, ApiUtils.getRoom(baseUrl, conversationToken))
+                            pass = conversation!!.password
-                        .subscribeOn(Schedulers.io())
-                        .observeOn(AndroidSchedulers.mainThread())
-                        .retry(1)
-                        .subscribe(object : Observer<RoomOverall> {
-                            override fun onSubscribe(d: Disposable) {
-                                disposable = d
-                            }
-
-                            override fun onNext(roomOverall: RoomOverall) {
-                                conversation = roomOverall.ocs.data
-                                fetchCapabilities(credentials)
-                            }
-
-                            override fun onError(e: Throwable) {
-                                showResultImage(false, false)
-                                dispose()
-                            }
-
-                            override fun onComplete() {
-                                dispose()
-                            }
-                        })
-                11 -> {
-                    val retrofitBucket: RetrofitBucket
-                    var isGroupCallWorkaround = false
-                    var invite: String? = null
-
-                    if (invitedGroups!!.size > 0) {
-                        invite = invitedGroups!![0]
-                    }
-
-                    if (conversationType == Conversation.ConversationType.PUBLIC_CONVERSATION || !currentUser!!.hasSpreedFeatureCapability("empty-group-room")) {
-                        retrofitBucket = ApiUtils.getRetrofitBucketForCreateRoom(currentUser!!.baseUrl,
-                                "3", invite, conversationName)
-                    } else {
-                        var roomType = "2"
-                        if (!currentUser!!.hasSpreedFeatureCapability("empty-group-room")) {
-                            isGroupCallWorkaround = true
-                            roomType = "3"
                         }
-
+                        ncApi.setPassword(credentials, ApiUtils.getUrlForPassword(currentUser!!.baseUrl,
-                        retrofitBucket = ApiUtils.getRetrofitBucketForCreateRoom(currentUser!!.baseUrl,
+                                conversation!!.token), pass)
-                                roomType, invite, conversationName)
+                                .subscribeOn(Schedulers.io())
+                                .observeOn(AndroidSchedulers.mainThread())
+                                .retry(1)
+                                .subscribe(operationsObserver)
                     }
-
+                    7 -> {
-                    val isGroupCallWorkaroundFinal = isGroupCallWorkaround
+                    }
-                    ncApi.createRoom(credentials, retrofitBucket.url, retrofitBucket.queryMap)
+                    8 -> ncApi.makeRoomPrivate(credentials,
+                            ApiUtils.getUrlForRoomVisibility(currentUser!!.baseUrl, conversation!!
+                                    .token))
+                            .subscribeOn(Schedulers.io())
+                            .observeOn(AndroidSchedulers.mainThread())
+                            .retry(1)
+                            .subscribe(operationsObserver)
+                    10 -> ncApi.getRoom(credentials, ApiUtils.getRoom(baseUrl, conversationToken))
                             .subscribeOn(Schedulers.io())
                             .observeOn(AndroidSchedulers.mainThread())
                             .retry(1)
                             .subscribe(object : Observer<RoomOverall> {
                                 override fun onSubscribe(d: Disposable) {
-
+                                    disposable = d
                                 }
 
                                 override fun onNext(roomOverall: RoomOverall) {
                                     conversation = roomOverall.ocs.data
-
+                                    fetchCapabilities(credentials)
-                                    ncApi.getRoom(credentials,
-                                            ApiUtils.getRoom(currentUser!!.baseUrl, conversation!!.token))
-                                            .subscribeOn(Schedulers.io())
-                                            .observeOn(AndroidSchedulers.mainThread())
-                                            .subscribe(object : Observer<RoomOverall> {
-                                                override fun onSubscribe(d: Disposable) {
-
-                                                }
-
-                                                override fun onNext(roomOverall: RoomOverall) {
-                                                    conversation = roomOverall.ocs.data
-                                                    if (conversationType == Conversation.ConversationType.PUBLIC_CONVERSATION && isGroupCallWorkaroundFinal) {
-                                                        performGroupCallWorkaround(credentials)
-                                                    } else {
-                                                        inviteUsersToAConversation()
-                                                    }
-                                                }
-
-                                                override fun onError(e: Throwable) {
-                                                    showResultImage(false, false)
-                                                    dispose()
-                                                }
-
-                                                override fun onComplete() {
-
-                                                }
-                                            })
                                 }
 
                                 override fun onError(e: Throwable) {
@@ -302,34 +233,110 @@ class OperationsMenuController(args: Bundle) : BaseController() {
                                     dispose()
                                 }
                             })
-                }
+                    11 -> {
-                97, 98 -> if (operationCode == 97) {
+                        val retrofitBucket: RetrofitBucket
-                    ncApi.removeConversationFromFavorites(credentials,
+                        var isGroupCallWorkaround = false
-                            ApiUtils.getUrlForConversationFavorites(currentUser!!.baseUrl,
+                        var invite: String? = null
-                                    conversation!!.token))
+
+                        if (invitedGroups!!.size > 0) {
+                            invite = invitedGroups!![0]
+                        }
+
+                        if (conversationType == Conversation.ConversationType.PUBLIC_CONVERSATION || !currentUser!!.hasSpreedFeatureCapability("empty-group-room")) {
+                            retrofitBucket = ApiUtils.getRetrofitBucketForCreateRoom(currentUser!!.baseUrl,
+                                    "3", invite, conversationName)
+                        } else {
+                            var roomType = "2"
+                            if (!currentUser!!.hasSpreedFeatureCapability("empty-group-room")) {
+                                isGroupCallWorkaround = true
+                                roomType = "3"
+                            }
+
+                            retrofitBucket = ApiUtils.getRetrofitBucketForCreateRoom(currentUser!!.baseUrl,
+                                    roomType, invite, conversationName)
+                        }
+
+                        val isGroupCallWorkaroundFinal = isGroupCallWorkaround
+                        ncApi.createRoom(credentials, retrofitBucket.url, retrofitBucket.queryMap)
+                                .subscribeOn(Schedulers.io())
+                                .observeOn(AndroidSchedulers.mainThread())
+                                .retry(1)
+                                .subscribe(object : Observer<RoomOverall> {
+                                    override fun onSubscribe(d: Disposable) {
+
+                                    }
+
+                                    override fun onNext(roomOverall: RoomOverall) {
+                                        conversation = roomOverall.ocs.data
+
+                                        ncApi.getRoom(credentials,
+                                                ApiUtils.getRoom(currentUser!!.baseUrl, conversation!!.token))
+                                                .subscribeOn(Schedulers.io())
+                                                .observeOn(AndroidSchedulers.mainThread())
+                                                .subscribe(object : Observer<RoomOverall> {
+                                                    override fun onSubscribe(d: Disposable) {
+
+                                                    }
+
+                                                    override fun onNext(roomOverall: RoomOverall) {
+                                                        conversation = roomOverall.ocs.data
+                                                        if (conversationType == Conversation.ConversationType.PUBLIC_CONVERSATION && isGroupCallWorkaroundFinal) {
+                                                            performGroupCallWorkaround(credentials)
+                                                        } else {
+                                                            inviteUsersToAConversation()
+                                                        }
+                                                    }
+
+                                                    override fun onError(e: Throwable) {
+                                                        showResultImage(false, false)
+                                                        dispose()
+                                                    }
+
+                                                    override fun onComplete() {
+
+                                                    }
+                                                })
+                                    }
+
+                                    override fun onError(e: Throwable) {
+                                        showResultImage(false, false)
+                                        dispose()
+                                    }
+
+                                    override fun onComplete() {
+                                        dispose()
+                                    }
+                                })
+                    }
+                    97, 98 -> if (operationCode == 97) {
+                        ncApi.removeConversationFromFavorites(credentials,
+                                ApiUtils.getUrlForConversationFavorites(currentUser!!.baseUrl,
+                                        conversation!!.token))
+                                .subscribeOn(Schedulers.io())
+                                .observeOn(AndroidSchedulers.mainThread())
+                                .retry(1)
+                                .subscribe(operationsObserver)
+                    } else {
+                        ncApi.addConversationToFavorites(credentials,
+                                ApiUtils.getUrlForConversationFavorites(currentUser!!.baseUrl,
+                                        conversation!!.token))
+                                .subscribeOn(Schedulers.io())
+                                .observeOn(AndroidSchedulers.mainThread())
+                                .retry(1)
+                                .subscribe(operationsObserver)
+                    }
+                    99 -> ncApi.joinRoom(credentials,
+                            ApiUtils.getUrlForSettingMyselfAsActiveParticipant(baseUrl, conversationToken),
+                            callPassword)
                             .subscribeOn(Schedulers.io())
                             .observeOn(AndroidSchedulers.mainThread())
                             .retry(1)
                             .subscribe(operationsObserver)
-                } else {
+                    else -> {
-                    ncApi.addConversationToFavorites(credentials,
+                    }
-                            ApiUtils.getUrlForConversationFavorites(currentUser!!.baseUrl,
+                }// Operation 7 is sharing, so we handle this differently
-                                    conversation!!.token))
+            }
-                            .subscribeOn(Schedulers.io())
+
-                            .observeOn(AndroidSchedulers.mainThread())
-                            .retry(1)
-                            .subscribe(operationsObserver)
-                }
-                99 -> ncApi.joinRoom(credentials,
-                        ApiUtils.getUrlForSettingMyselfAsActiveParticipant(baseUrl, conversationToken),
-                        callPassword)
-                        .subscribeOn(Schedulers.io())
-                        .observeOn(AndroidSchedulers.mainThread())
-                        .retry(1)
-                        .subscribe(operationsObserver)
-                else -> {
-                }
-            }// Operation 7 is sharing, so we handle this differently
         }
     }
 
@@ -400,6 +407,7 @@ class OperationsMenuController(args: Bundle) : BaseController() {
             okButton!!.visibility = View.VISIBLE
         }
     }
+    }
 
     private fun dispose() {
         if (disposable != null && !disposable!!.isDisposed) {

app/src/main/java/com/nextcloud/talk/newarch/di/module/ConversationsModule.kt

@@ -0,0 +1,62 @@
+package com.nextcloud.talk.newarch.di.module
+
+import android.app.Application
+import com.nextcloud.talk.newarch.data.source.remote.ApiErrorHandler
+import com.nextcloud.talk.newarch.domain.repository.offline.ConversationsRepository
+import com.nextcloud.talk.newarch.domain.repository.offline.MessagesRepository
+import com.nextcloud.talk.newarch.domain.repository.online.NextcloudTalkRepository
+import com.nextcloud.talk.newarch.domain.usecases.*
+import com.nextcloud.talk.newarch.features.chat.ChatViewModelFactory
+import com.nextcloud.talk.newarch.utils.ConversationsManager
+import org.koin.dsl.module
+
+val ConversationsModule = module {
+    single { createGetConversationsUseCase(get(), get()) }
+    single { createSetConversationFavoriteValueUseCase(get(), get()) }
+    single { createLeaveConversationUseCase(get(), get()) }
+    single { createDeleteConversationUseCase(get(), get()) }
+    single { createJoinConversationUseCase(get(), get()) }
+    single { createExitConversationUseCase(get(), get()) }
+
+    factory { createChatViewModelFactory(get(), get(), get(), get(), get(), get()) }
+}
+
+
+fun createSetConversationFavoriteValueUseCase(
+        nextcloudTalkRepository: NextcloudTalkRepository,
+        apiErrorHandler: ApiErrorHandler
+): SetConversationFavoriteValueUseCase {
+    return SetConversationFavoriteValueUseCase(nextcloudTalkRepository, apiErrorHandler)
+}
+
+fun createGetConversationsUseCase(
+        nextcloudTalkRepository: NextcloudTalkRepository,
+        apiErrorHandler: ApiErrorHandler
+): GetConversationsUseCase {
+    return GetConversationsUseCase(nextcloudTalkRepository, apiErrorHandler)
+}
+
+fun createLeaveConversationUseCase(
+        nextcloudTalkRepository: NextcloudTalkRepository,
+        apiErrorHandler: ApiErrorHandler
+): LeaveConversationUseCase {
+    return LeaveConversationUseCase(nextcloudTalkRepository, apiErrorHandler)
+}
+
+fun createDeleteConversationUseCase(
+        nextcloudTalkRepository: NextcloudTalkRepository,
+        apiErrorHandler: ApiErrorHandler
+): DeleteConversationUseCase {
+    return DeleteConversationUseCase(nextcloudTalkRepository, apiErrorHandler)
+}
+
+fun createJoinConversationUseCase(nextcloudTalkRepository: NextcloudTalkRepository, apiErrorHandler: ApiErrorHandler): JoinConversationUseCase {
+    return JoinConversationUseCase(nextcloudTalkRepository, apiErrorHandler)
+}
+
+fun createExitConversationUseCase(nextcloudTalkRepository: NextcloudTalkRepository, apiErrorHandler: ApiErrorHandler): ExitConversationUseCase {
+    return ExitConversationUseCase(nextcloudTalkRepository, apiErrorHandler)
+}
+fun createChatViewModelFactory(application: Application, joinConversationUseCase: JoinConversationUseCase, exitConversationUseCase: ExitConversationUseCase, conversationsRepository: ConversationsRepository, messagesRepository: MessagesRepository, conversationsManager: ConversationsManager): ChatViewModelFactory {
+    return ChatViewModelFactory(application, joinConversationUseCase, exitConversationUseCase, conversationsRepository, messagesRepository, conversationsManager)
+}

app/src/main/java/com/nextcloud/talk/newarch/di/module/ManagementModule.kt

@@ -0,0 +1,38 @@
+/*
+ * Nextcloud Talk application
+ *
+ * @author Mario Danic
+ * Copyright (C) 2017-2019 Mario Danic <mario@lovelyhq.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.nextcloud.talk.newarch.di.module
+
+import com.nextcloud.talk.newarch.domain.repository.offline.ConversationsRepository
+import com.nextcloud.talk.newarch.domain.repository.offline.UsersRepository
+import com.nextcloud.talk.newarch.domain.usecases.GetConversationUseCase
+import com.nextcloud.talk.newarch.domain.usecases.JoinConversationUseCase
+import com.nextcloud.talk.newarch.utils.ConversationsManager
+import okhttp3.OkHttpClient
+import org.koin.dsl.module
+import java.net.CookieManager
+
+val ManagementModule = module {
+    single{ createConversationsManager(get(), get(), get(), get(), get(), get()) }
+}
+
+fun createConversationsManager(usersRepository: UsersRepository, cookieManager: CookieManager, okHttpClient: OkHttpClient, conversationsRepository: ConversationsRepository, getConversationUseCase: GetConversationUseCase, joinConversationUseCase: JoinConversationUseCase): ConversationsManager {
+    return ConversationsManager(usersRepository, cookieManager, okHttpClient, conversationsRepository, joinConversationUseCase, getConversationUseCase)
+}

app/src/main/java/com/nextcloud/talk/newarch/features/chat/ChatViewModel.kt

@@ -15,6 +15,7 @@ import com.nextcloud.talk.newarch.domain.usecases.ExitConversationUseCase
 import com.nextcloud.talk.newarch.domain.usecases.JoinConversationUseCase
 import com.nextcloud.talk.newarch.domain.usecases.base.UseCaseResponse
 import com.nextcloud.talk.newarch.local.models.UserNgEntity
+import com.nextcloud.talk.newarch.utils.ConversationsManager
 import kotlinx.coroutines.launch
 import org.koin.core.parameter.parametersOf
 
@@ -22,7 +23,8 @@ class ChatViewModel constructor(application: Application,
                                 private val joinConversationUseCase: JoinConversationUseCase,
                                 private val exitConversationUseCase: ExitConversationUseCase,
                                 private val conversationsRepository: ConversationsRepository,
-                                private val messagesRepository: MessagesRepository) : BaseViewModel<ChatView>(application) {
+                                private val messagesRepository: MessagesRepository,
+                                private val conversationsManager: ConversationsManager) : BaseViewModel<ChatView>(application) {
     lateinit var user: UserNgEntity
     val conversation: MutableLiveData<Conversation?> = MutableLiveData()
     val messagesLiveData = Transformations.switchMap(conversation) {

app/src/main/java/com/nextcloud/talk/newarch/features/chat/ChatViewModelFactory.kt

@@ -7,18 +7,20 @@ import com.nextcloud.talk.newarch.domain.repository.offline.ConversationsReposit
 import com.nextcloud.talk.newarch.domain.repository.offline.MessagesRepository
 import com.nextcloud.talk.newarch.domain.usecases.ExitConversationUseCase
 import com.nextcloud.talk.newarch.domain.usecases.JoinConversationUseCase
+import com.nextcloud.talk.newarch.utils.ConversationsManager
 
 class ChatViewModelFactory constructor(
         private val application: Application,
         private val joinConversationUseCase: JoinConversationUseCase,
         private val exitConversationUseCase: ExitConversationUseCase,
         private val conversationsRepository: ConversationsRepository,
-        private val messagesRepository: MessagesRepository
+        private val messagesRepository: MessagesRepository,
+        private val conversationsManager: ConversationsManager
 ) : ViewModelProvider.Factory {
 
     override fun <T : ViewModel?> create(modelClass: Class<T>): T {
         return ChatViewModel(
-                application, joinConversationUseCase, exitConversationUseCase, conversationsRepository, messagesRepository
+                application, joinConversationUseCase, exitConversationUseCase, conversationsRepository, messagesRepository, conversationsManager
         ) as T
     }
 }

app/src/main/java/com/nextcloud/talk/newarch/features/conversationsList/di/module/ConversationsListModule.kt

@@ -34,10 +34,6 @@ import org.koin.android.ext.koin.androidApplication
 import org.koin.dsl.module
 
 val ConversationsListModule = module {
-    single { createGetConversationsUseCase(get(), get()) }
-    single { createSetConversationFavoriteValueUseCase(get(), get()) }
-    single { createLeaveConversationUseCase(get(), get()) }
-    single { createDeleteConversationuseCase(get(), get()) }
     //viewModel { ConversationsListViewModel(get(), get()) }
     factory {
         createConversationListViewModelFactory(
@@ -47,34 +43,6 @@ val ConversationsListModule = module {
     }
 }
 
-fun createSetConversationFavoriteValueUseCase(
-        nextcloudTalkRepository: NextcloudTalkRepository,
-        apiErrorHandler: ApiErrorHandler
-): SetConversationFavoriteValueUseCase {
-    return SetConversationFavoriteValueUseCase(nextcloudTalkRepository, apiErrorHandler)
-}
-
-fun createGetConversationsUseCase(
-        nextcloudTalkRepository: NextcloudTalkRepository,
-        apiErrorHandler: ApiErrorHandler
-): GetConversationsUseCase {
-    return GetConversationsUseCase(nextcloudTalkRepository, apiErrorHandler)
-}
-
-fun createLeaveConversationUseCase(
-        nextcloudTalkRepository: NextcloudTalkRepository,
-        apiErrorHandler: ApiErrorHandler
-): LeaveConversationUseCase {
-    return LeaveConversationUseCase(nextcloudTalkRepository, apiErrorHandler)
-}
-
-fun createDeleteConversationuseCase(
-        nextcloudTalkRepository: NextcloudTalkRepository,
-        apiErrorHandler: ApiErrorHandler
-): DeleteConversationUseCase {
-    return DeleteConversationUseCase(nextcloudTalkRepository, apiErrorHandler)
-}
-
 fun createConversationListViewModelFactory(
         application: Application,
         getConversationsUseCase:

app/src/main/java/com/nextcloud/talk/newarch/utils/ConversationsManager.kt

@@ -42,7 +42,7 @@ class ConversationsManager constructor(usersRepository: UsersRepository,
                                        okHttpClient: OkHttpClient,
                                        private val conversationsRepository: ConversationsRepository,
                                        private val joinConversationUseCase: JoinConversationUseCase,
-                                       private val getConversationUseCase: GetConversationUseCase): KoinComponent {
+                                       private val getConversationUseCase: GetConversationUseCase) : KoinComponent {
     private val applicationScope = CoroutineScope(Dispatchers.Default)
     private val previousUser: UserNgEntity? = null
     private val currentUserLiveData: LiveData<UserNgEntity> = usersRepository.getActiveUserLiveData()
@@ -50,9 +50,11 @@ class ConversationsManager constructor(usersRepository: UsersRepository,
 
     init {
         currentUserLiveData.observeForever { user ->
-            cookieManager.cookieStore.removeAll()
+            if (user.id != previousUser?.id) {
-            okHttpClient.dispatcher().cancelAll()
+                cookieManager.cookieStore.removeAll()
-            currentConversation = null
+                //okHttpClient.dispatcher().cancelAll()
+                currentConversation = null
+            }
         }
     }
 

app/src/main/java/com/nextcloud/talk/newarch/utils/ConversationsManagerInterface.kt

@@ -24,5 +24,6 @@ import com.nextcloud.talk.models.json.conversations.Conversation
 import com.nextcloud.talk.newarch.local.models.UserNgEntity
 
 interface ConversationsManagerInterface  {
+    fun gotConversationInfoForuser(userNgEntity: UserNgEntity, conversation: Conversation?)
     fun joinedConversationForUser(userNgEntity: UserNgEntity, conversation: Conversation?)
 }