2019-01-18 10:12:08 +00:00
|
|
|
/*
|
2019-01-25 13:04:59 +00:00
|
|
|
* Copyright 2019 New Vector Ltd
|
2019-01-18 10:12:08 +00:00
|
|
|
*
|
2019-01-25 13:04:59 +00:00
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
2019-01-18 10:12:08 +00:00
|
|
|
*
|
2019-01-25 13:04:59 +00:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
2019-01-18 10:12:08 +00:00
|
|
|
*/
|
|
|
|
|
2018-10-08 15:52:45 +00:00
|
|
|
package im.vector.matrix.android.internal.session
|
|
|
|
|
2019-05-16 08:23:57 +00:00
|
|
|
import android.content.Context
|
2018-10-16 13:52:30 +00:00
|
|
|
import android.os.Looper
|
2019-01-16 18:25:43 +00:00
|
|
|
import androidx.annotation.MainThread
|
2019-01-23 15:25:24 +00:00
|
|
|
import androidx.lifecycle.LiveData
|
2019-02-26 18:32:01 +00:00
|
|
|
import com.zhuinden.monarchy.Monarchy
|
2019-04-03 14:36:45 +00:00
|
|
|
import im.vector.matrix.android.api.MatrixCallback
|
2018-12-12 20:15:01 +00:00
|
|
|
import im.vector.matrix.android.api.auth.data.SessionParams
|
2019-05-16 08:23:57 +00:00
|
|
|
import im.vector.matrix.android.api.listeners.ProgressListener
|
2018-10-09 10:30:01 +00:00
|
|
|
import im.vector.matrix.android.api.session.Session
|
2019-04-17 13:48:59 +00:00
|
|
|
import im.vector.matrix.android.api.session.cache.CacheService
|
2019-04-05 16:21:45 +00:00
|
|
|
import im.vector.matrix.android.api.session.content.ContentUploadStateTracker
|
2019-01-23 15:25:24 +00:00
|
|
|
import im.vector.matrix.android.api.session.content.ContentUrlResolver
|
2019-05-16 08:23:57 +00:00
|
|
|
import im.vector.matrix.android.api.session.crypto.keysbackup.KeysBackupService
|
|
|
|
import im.vector.matrix.android.api.session.crypto.keyshare.RoomKeysRequestListener
|
|
|
|
import im.vector.matrix.android.api.session.crypto.sas.SasVerificationService
|
2019-05-21 13:42:09 +00:00
|
|
|
import im.vector.matrix.android.api.session.events.model.Content
|
2019-05-16 08:23:57 +00:00
|
|
|
import im.vector.matrix.android.api.session.events.model.Event
|
2018-11-05 16:39:07 +00:00
|
|
|
import im.vector.matrix.android.api.session.group.Group
|
|
|
|
import im.vector.matrix.android.api.session.group.GroupService
|
|
|
|
import im.vector.matrix.android.api.session.group.model.GroupSummary
|
2018-10-17 16:21:09 +00:00
|
|
|
import im.vector.matrix.android.api.session.room.Room
|
2019-05-24 09:35:46 +00:00
|
|
|
import im.vector.matrix.android.api.session.room.RoomDirectoryService
|
2018-10-17 16:21:09 +00:00
|
|
|
import im.vector.matrix.android.api.session.room.RoomService
|
2018-10-23 16:25:28 +00:00
|
|
|
import im.vector.matrix.android.api.session.room.model.RoomSummary
|
2019-04-05 15:04:25 +00:00
|
|
|
import im.vector.matrix.android.api.session.room.model.create.CreateRoomParams
|
2019-05-24 09:35:46 +00:00
|
|
|
import im.vector.matrix.android.api.session.room.model.roomdirectory.PublicRoomsParams
|
|
|
|
import im.vector.matrix.android.api.session.room.model.roomdirectory.PublicRoomsResponse
|
2019-05-24 13:00:43 +00:00
|
|
|
import im.vector.matrix.android.api.session.room.model.thirdparty.ThirdPartyProtocol
|
2019-04-03 14:36:45 +00:00
|
|
|
import im.vector.matrix.android.api.session.signout.SignOutService
|
2019-04-12 13:51:20 +00:00
|
|
|
import im.vector.matrix.android.api.session.sync.FilterService
|
2019-06-11 14:54:44 +00:00
|
|
|
import im.vector.matrix.android.api.session.sync.SyncState
|
2019-02-25 20:55:33 +00:00
|
|
|
import im.vector.matrix.android.api.session.user.UserService
|
|
|
|
import im.vector.matrix.android.api.session.user.model.User
|
2019-05-24 09:35:46 +00:00
|
|
|
import im.vector.matrix.android.api.util.Cancelable
|
2019-04-17 13:48:59 +00:00
|
|
|
import im.vector.matrix.android.api.util.MatrixCallbackDelegate
|
2019-05-21 13:42:09 +00:00
|
|
|
import im.vector.matrix.android.internal.crypto.CryptoManager
|
2019-05-16 08:23:57 +00:00
|
|
|
import im.vector.matrix.android.internal.crypto.CryptoModule
|
|
|
|
import im.vector.matrix.android.internal.crypto.MXEventDecryptionResult
|
|
|
|
import im.vector.matrix.android.internal.crypto.model.ImportRoomKeysResult
|
|
|
|
import im.vector.matrix.android.internal.crypto.model.MXDeviceInfo
|
2019-05-21 13:42:09 +00:00
|
|
|
import im.vector.matrix.android.internal.crypto.model.MXEncryptEventContentResult
|
2019-06-12 16:32:24 +00:00
|
|
|
import im.vector.matrix.android.internal.crypto.model.MXUsersDevicesMap
|
2019-05-16 08:23:57 +00:00
|
|
|
import im.vector.matrix.android.internal.crypto.model.rest.DevicesListResponse
|
2019-05-21 13:42:09 +00:00
|
|
|
import im.vector.matrix.android.internal.crypto.model.rest.RoomKeyRequestBody
|
2018-11-07 19:36:19 +00:00
|
|
|
import im.vector.matrix.android.internal.database.LiveEntityObserver
|
2018-12-20 14:44:01 +00:00
|
|
|
import im.vector.matrix.android.internal.di.MatrixKoinComponent
|
|
|
|
import im.vector.matrix.android.internal.di.MatrixKoinHolder
|
2019-04-05 16:21:45 +00:00
|
|
|
import im.vector.matrix.android.internal.session.content.ContentModule
|
2018-11-05 16:39:07 +00:00
|
|
|
import im.vector.matrix.android.internal.session.group.GroupModule
|
2018-10-18 16:38:11 +00:00
|
|
|
import im.vector.matrix.android.internal.session.room.RoomModule
|
2019-04-03 14:36:45 +00:00
|
|
|
import im.vector.matrix.android.internal.session.signout.SignOutModule
|
2018-10-17 16:21:09 +00:00
|
|
|
import im.vector.matrix.android.internal.session.sync.SyncModule
|
|
|
|
import im.vector.matrix.android.internal.session.sync.job.SyncThread
|
2019-02-26 18:32:01 +00:00
|
|
|
import im.vector.matrix.android.internal.session.user.UserModule
|
2018-10-08 15:52:45 +00:00
|
|
|
import org.koin.core.scope.Scope
|
|
|
|
import org.koin.standalone.inject
|
2019-06-13 08:58:45 +00:00
|
|
|
import timber.log.Timber
|
2018-10-08 15:52:45 +00:00
|
|
|
|
2018-10-17 11:59:21 +00:00
|
|
|
|
2019-02-25 20:55:33 +00:00
|
|
|
internal class DefaultSession(override val sessionParams: SessionParams) : Session, MatrixKoinComponent {
|
2018-10-16 13:52:30 +00:00
|
|
|
companion object {
|
|
|
|
const val SCOPE: String = "session"
|
|
|
|
}
|
|
|
|
|
|
|
|
private lateinit var scope: Scope
|
|
|
|
|
2019-02-26 18:32:01 +00:00
|
|
|
private val monarchy by inject<Monarchy>()
|
2018-11-07 19:36:19 +00:00
|
|
|
private val liveEntityUpdaters by inject<List<LiveEntityObserver>>()
|
2019-01-14 15:18:39 +00:00
|
|
|
private val sessionListeners by inject<SessionListeners>()
|
2018-10-17 16:21:09 +00:00
|
|
|
private val roomService by inject<RoomService>()
|
2019-05-24 09:35:46 +00:00
|
|
|
private val roomDirectoryService by inject<RoomDirectoryService>()
|
2018-11-05 16:39:07 +00:00
|
|
|
private val groupService by inject<GroupService>()
|
2019-02-25 20:55:33 +00:00
|
|
|
private val userService by inject<UserService>()
|
2019-04-12 13:51:20 +00:00
|
|
|
private val filterService by inject<FilterService>()
|
2019-04-17 13:48:59 +00:00
|
|
|
private val cacheService by inject<CacheService>()
|
2019-04-03 14:36:45 +00:00
|
|
|
private val signOutService by inject<SignOutService>()
|
2019-05-16 08:23:57 +00:00
|
|
|
private val cryptoService by inject<CryptoManager>()
|
2018-10-17 11:59:21 +00:00
|
|
|
private val syncThread by inject<SyncThread>()
|
2019-01-23 15:25:24 +00:00
|
|
|
private val contentUrlResolver by inject<ContentUrlResolver>()
|
2019-04-05 16:21:45 +00:00
|
|
|
private val contentUploadProgressTracker by inject<ContentUploadStateTracker>()
|
2018-10-16 13:52:30 +00:00
|
|
|
private var isOpen = false
|
2018-10-08 15:52:45 +00:00
|
|
|
|
2018-10-16 13:52:30 +00:00
|
|
|
@MainThread
|
|
|
|
override fun open() {
|
2018-12-12 20:15:01 +00:00
|
|
|
assertMainThread()
|
2018-10-16 13:52:30 +00:00
|
|
|
assert(!isOpen)
|
|
|
|
isOpen = true
|
2018-12-12 20:15:01 +00:00
|
|
|
val sessionModule = SessionModule(sessionParams).definition
|
|
|
|
val syncModule = SyncModule().definition
|
|
|
|
val roomModule = RoomModule().definition
|
|
|
|
val groupModule = GroupModule().definition
|
2019-04-03 14:36:45 +00:00
|
|
|
val signOutModule = SignOutModule().definition
|
2019-02-26 18:32:01 +00:00
|
|
|
val userModule = UserModule().definition
|
2019-04-05 16:21:45 +00:00
|
|
|
val contentModule = ContentModule().definition
|
2019-05-16 08:23:57 +00:00
|
|
|
val cryptoModule = CryptoModule().definition
|
|
|
|
MatrixKoinHolder.instance.loadModules(listOf(sessionModule,
|
2019-06-07 14:01:24 +00:00
|
|
|
syncModule,
|
|
|
|
roomModule,
|
|
|
|
groupModule,
|
|
|
|
userModule,
|
|
|
|
signOutModule,
|
|
|
|
contentModule,
|
|
|
|
cryptoModule))
|
2018-10-11 07:58:28 +00:00
|
|
|
scope = getKoin().getOrCreateScope(SCOPE)
|
2019-02-26 18:32:01 +00:00
|
|
|
if (!monarchy.isMonarchyThreadOpen) {
|
|
|
|
monarchy.openManually()
|
|
|
|
}
|
2018-11-07 19:36:19 +00:00
|
|
|
liveEntityUpdaters.forEach { it.start() }
|
2019-04-12 13:51:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
@MainThread
|
2019-04-16 13:36:29 +00:00
|
|
|
override fun startSync() {
|
2019-04-12 13:51:20 +00:00
|
|
|
assert(isOpen)
|
2018-10-17 11:59:21 +00:00
|
|
|
syncThread.start()
|
2018-10-08 15:52:45 +00:00
|
|
|
}
|
|
|
|
|
2019-04-12 13:51:20 +00:00
|
|
|
@MainThread
|
2019-04-16 13:36:29 +00:00
|
|
|
override fun stopSync() {
|
2019-04-12 13:51:20 +00:00
|
|
|
assert(isOpen)
|
|
|
|
syncThread.kill()
|
|
|
|
}
|
2018-10-15 17:42:13 +00:00
|
|
|
|
2018-10-16 13:52:30 +00:00
|
|
|
@MainThread
|
2018-10-08 15:52:45 +00:00
|
|
|
override fun close() {
|
2018-12-12 20:15:01 +00:00
|
|
|
assertMainThread()
|
2018-10-16 13:52:30 +00:00
|
|
|
assert(isOpen)
|
2018-11-07 19:36:19 +00:00
|
|
|
liveEntityUpdaters.forEach { it.dispose() }
|
2019-05-16 08:23:57 +00:00
|
|
|
cryptoService.close()
|
2019-02-26 18:32:01 +00:00
|
|
|
if (monarchy.isMonarchyThreadOpen) {
|
|
|
|
monarchy.closeManually()
|
|
|
|
}
|
2018-10-08 15:52:45 +00:00
|
|
|
scope.close()
|
2018-10-16 13:52:30 +00:00
|
|
|
isOpen = false
|
2018-10-08 15:52:45 +00:00
|
|
|
}
|
|
|
|
|
2019-06-11 14:54:44 +00:00
|
|
|
override fun syncState(): LiveData<SyncState> {
|
|
|
|
return syncThread.liveState()
|
|
|
|
}
|
|
|
|
|
2019-04-03 14:36:45 +00:00
|
|
|
@MainThread
|
|
|
|
override fun signOut(callback: MatrixCallback<Unit>) {
|
2019-06-13 08:58:45 +00:00
|
|
|
Timber.w("SIGN_OUT: start")
|
|
|
|
|
2019-04-03 14:36:45 +00:00
|
|
|
assert(isOpen)
|
2019-06-13 08:58:45 +00:00
|
|
|
Timber.w("SIGN_OUT: kill sync thread")
|
2019-04-17 13:48:59 +00:00
|
|
|
syncThread.kill()
|
|
|
|
|
2019-06-13 08:58:45 +00:00
|
|
|
Timber.w("SIGN_OUT: call webservice")
|
2019-04-03 14:36:45 +00:00
|
|
|
return signOutService.signOut(object : MatrixCallback<Unit> {
|
|
|
|
override fun onSuccess(data: Unit) {
|
2019-06-13 08:58:45 +00:00
|
|
|
Timber.w("SIGN_OUT: call webservice -> SUCCESS: clear cache")
|
|
|
|
|
2019-04-17 13:48:59 +00:00
|
|
|
// Clear the cache
|
2019-06-13 08:58:45 +00:00
|
|
|
cacheService.clearCache(object : MatrixCallback<Unit> {
|
|
|
|
override fun onSuccess(data: Unit) {
|
|
|
|
Timber.w("SIGN_OUT: clear cache -> SUCCESS: clear crypto cache")
|
|
|
|
cryptoService.clearCryptoCache(MatrixCallbackDelegate(callback))
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun onFailure(failure: Throwable) {
|
|
|
|
// ignore error
|
|
|
|
Timber.e("SIGN_OUT: clear cache -> ERROR: ignoring")
|
|
|
|
onSuccess(Unit)
|
|
|
|
}
|
|
|
|
})
|
2019-04-03 14:36:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun onFailure(failure: Throwable) {
|
2019-04-17 13:48:59 +00:00
|
|
|
// Ignore failure
|
2019-06-13 08:58:45 +00:00
|
|
|
Timber.e("SIGN_OUT: call webservice -> ERROR: ignoring")
|
2019-04-17 13:48:59 +00:00
|
|
|
onSuccess(Unit)
|
2019-04-03 14:36:45 +00:00
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2019-01-23 15:25:24 +00:00
|
|
|
override fun contentUrlResolver(): ContentUrlResolver {
|
|
|
|
return contentUrlResolver
|
|
|
|
}
|
|
|
|
|
2019-04-05 16:21:45 +00:00
|
|
|
override fun contentUploadProgressTracker(): ContentUploadStateTracker {
|
|
|
|
return contentUploadProgressTracker
|
|
|
|
}
|
|
|
|
|
2019-01-14 15:18:39 +00:00
|
|
|
override fun addListener(listener: Session.Listener) {
|
|
|
|
sessionListeners.addListener(listener)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun removeListener(listener: Session.Listener) {
|
|
|
|
sessionListeners.removeListener(listener)
|
|
|
|
}
|
|
|
|
|
2018-10-17 16:21:09 +00:00
|
|
|
// ROOM SERVICE
|
|
|
|
|
2019-04-05 15:04:25 +00:00
|
|
|
override fun createRoom(createRoomParams: CreateRoomParams, callback: MatrixCallback<String>) {
|
|
|
|
assert(isOpen)
|
|
|
|
return roomService.createRoom(createRoomParams, callback)
|
|
|
|
}
|
|
|
|
|
2018-10-17 16:21:09 +00:00
|
|
|
override fun getRoom(roomId: String): Room? {
|
2018-11-02 09:30:50 +00:00
|
|
|
assert(isOpen)
|
2018-10-17 16:21:09 +00:00
|
|
|
return roomService.getRoom(roomId)
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-10-23 16:25:28 +00:00
|
|
|
override fun liveRoomSummaries(): LiveData<List<RoomSummary>> {
|
2018-11-02 09:30:50 +00:00
|
|
|
assert(isOpen)
|
2018-10-23 16:25:28 +00:00
|
|
|
return roomService.liveRoomSummaries()
|
|
|
|
}
|
|
|
|
|
2019-05-24 09:35:46 +00:00
|
|
|
// ROOM DIRECTORY SERVICE
|
|
|
|
|
|
|
|
override fun getPublicRooms(server: String?, publicRoomsParams: PublicRoomsParams, callback: MatrixCallback<PublicRoomsResponse>): Cancelable {
|
|
|
|
assert(isOpen)
|
|
|
|
return roomDirectoryService.getPublicRooms(server, publicRoomsParams, callback)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun joinRoom(roomId: String, callback: MatrixCallback<Unit>) {
|
|
|
|
assert(isOpen)
|
|
|
|
return roomDirectoryService.joinRoom(roomId, callback)
|
|
|
|
}
|
|
|
|
|
2019-05-24 13:00:43 +00:00
|
|
|
override fun getThirdPartyProtocol(callback: MatrixCallback<Map<String, ThirdPartyProtocol>>) {
|
|
|
|
assert(isOpen)
|
|
|
|
return roomDirectoryService.getThirdPartyProtocol(callback)
|
|
|
|
}
|
|
|
|
|
2018-11-05 16:39:07 +00:00
|
|
|
// GROUP SERVICE
|
|
|
|
|
|
|
|
override fun getGroup(groupId: String): Group? {
|
|
|
|
assert(isOpen)
|
|
|
|
return groupService.getGroup(groupId)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun liveGroupSummaries(): LiveData<List<GroupSummary>> {
|
|
|
|
assert(isOpen)
|
|
|
|
return groupService.liveGroupSummaries()
|
|
|
|
}
|
|
|
|
|
2019-04-12 13:51:20 +00:00
|
|
|
override fun setFilter(filterPreset: FilterService.FilterPreset) {
|
|
|
|
assert(isOpen)
|
|
|
|
return filterService.setFilter(filterPreset)
|
|
|
|
}
|
|
|
|
|
2019-04-17 13:48:59 +00:00
|
|
|
override fun clearCache(callback: MatrixCallback<Unit>) {
|
|
|
|
assert(isOpen)
|
|
|
|
syncThread.pause()
|
|
|
|
cacheService.clearCache(object : MatrixCallbackDelegate<Unit>(callback) {
|
|
|
|
override fun onSuccess(data: Unit) {
|
|
|
|
// Restart the sync
|
|
|
|
syncThread.restart()
|
|
|
|
|
|
|
|
super.onSuccess(data)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2019-02-25 20:55:33 +00:00
|
|
|
// USER SERVICE
|
|
|
|
|
|
|
|
override fun getUser(userId: String): User? {
|
|
|
|
assert(isOpen)
|
|
|
|
return userService.getUser(userId)
|
|
|
|
}
|
|
|
|
|
2019-05-16 17:14:02 +00:00
|
|
|
override fun observeUser(userId: String): LiveData<User?> {
|
|
|
|
assert(isOpen)
|
|
|
|
return userService.observeUser(userId)
|
|
|
|
}
|
|
|
|
|
2019-05-16 08:23:57 +00:00
|
|
|
// CRYPTO SERVICE
|
|
|
|
|
|
|
|
override fun setDeviceName(deviceId: String, deviceName: String, callback: MatrixCallback<Unit>) {
|
|
|
|
cryptoService.setDeviceName(deviceId, deviceName, callback)
|
|
|
|
}
|
|
|
|
|
2019-06-17 15:32:35 +00:00
|
|
|
override fun deleteDevice(deviceId: String, callback: MatrixCallback<Unit>) {
|
|
|
|
cryptoService.deleteDevice(deviceId, callback)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun deleteDeviceWithUserPassword(deviceId: String, authSession: String?, password: String, callback: MatrixCallback<Unit>) {
|
|
|
|
cryptoService.deleteDeviceWithUserPassword(deviceId, authSession, password, callback)
|
2019-05-16 08:23:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun getCryptoVersion(context: Context, longFormat: Boolean): String {
|
|
|
|
return cryptoService.getCryptoVersion(context, longFormat)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun isCryptoEnabled(): Boolean {
|
|
|
|
return cryptoService.isCryptoEnabled()
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getSasVerificationService(): SasVerificationService {
|
|
|
|
return cryptoService.getSasVerificationService()
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getKeysBackupService(): KeysBackupService {
|
|
|
|
return cryptoService.getKeysBackupService()
|
|
|
|
}
|
|
|
|
|
2019-05-17 13:05:07 +00:00
|
|
|
override fun isRoomBlacklistUnverifiedDevices(roomId: String?): Boolean {
|
|
|
|
return cryptoService.isRoomBlacklistUnverifiedDevices(roomId)
|
2019-05-16 08:23:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun setWarnOnUnknownDevices(warn: Boolean) {
|
|
|
|
cryptoService.setWarnOnUnknownDevices(warn)
|
|
|
|
}
|
|
|
|
|
2019-05-17 13:05:07 +00:00
|
|
|
override fun setDeviceVerification(verificationStatus: Int, deviceId: String, userId: String) {
|
|
|
|
cryptoService.setDeviceVerification(verificationStatus, deviceId, userId)
|
2019-05-16 08:23:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun getUserDevices(userId: String): MutableList<MXDeviceInfo> {
|
|
|
|
return cryptoService.getUserDevices(userId)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun setDevicesKnown(devices: List<MXDeviceInfo>, callback: MatrixCallback<Unit>?) {
|
|
|
|
cryptoService.setDevicesKnown(devices, callback)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun deviceWithIdentityKey(senderKey: String, algorithm: String): MXDeviceInfo? {
|
|
|
|
return cryptoService.deviceWithIdentityKey(senderKey, algorithm)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getMyDevice(): MXDeviceInfo {
|
|
|
|
return cryptoService.getMyDevice()
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getDevicesList(callback: MatrixCallback<DevicesListResponse>) {
|
|
|
|
cryptoService.getDevicesList(callback)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun inboundGroupSessionsCount(onlyBackedUp: Boolean): Int {
|
|
|
|
return cryptoService.inboundGroupSessionsCount(onlyBackedUp)
|
|
|
|
}
|
|
|
|
|
2019-05-17 13:05:07 +00:00
|
|
|
override fun getGlobalBlacklistUnverifiedDevices(): Boolean {
|
|
|
|
return cryptoService.getGlobalBlacklistUnverifiedDevices()
|
2019-05-16 08:23:57 +00:00
|
|
|
}
|
|
|
|
|
2019-05-17 13:05:07 +00:00
|
|
|
override fun setGlobalBlacklistUnverifiedDevices(block: Boolean) {
|
|
|
|
cryptoService.setGlobalBlacklistUnverifiedDevices(block)
|
2019-05-16 08:23:57 +00:00
|
|
|
}
|
|
|
|
|
2019-05-17 13:05:07 +00:00
|
|
|
override fun setRoomUnBlacklistUnverifiedDevices(roomId: String) {
|
|
|
|
cryptoService.setRoomUnBlacklistUnverifiedDevices(roomId)
|
2019-05-16 08:23:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun getDeviceTrackingStatus(userId: String): Int {
|
|
|
|
return cryptoService.getDeviceTrackingStatus(userId)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun importRoomKeys(roomKeysAsArray: ByteArray, password: String, progressListener: ProgressListener?, callback: MatrixCallback<ImportRoomKeysResult>) {
|
|
|
|
cryptoService.importRoomKeys(roomKeysAsArray, password, progressListener, callback)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun exportRoomKeys(password: String, callback: MatrixCallback<ByteArray>) {
|
|
|
|
cryptoService.exportRoomKeys(password, callback)
|
|
|
|
}
|
|
|
|
|
2019-05-17 13:05:07 +00:00
|
|
|
override fun setRoomBlacklistUnverifiedDevices(roomId: String) {
|
|
|
|
cryptoService.setRoomBlacklistUnverifiedDevices(roomId)
|
2019-05-16 08:23:57 +00:00
|
|
|
}
|
|
|
|
|
2019-05-21 13:42:09 +00:00
|
|
|
override fun isRoomEncrypted(roomId: String): Boolean {
|
|
|
|
return cryptoService.isRoomEncrypted(roomId)
|
|
|
|
}
|
|
|
|
|
2019-05-27 17:13:42 +00:00
|
|
|
override fun encryptEventContent(eventContent: Content, eventType: String, roomId: String, callback: MatrixCallback<MXEncryptEventContentResult>) {
|
|
|
|
cryptoService.encryptEventContent(eventContent, eventType, roomId, callback)
|
2019-05-21 13:42:09 +00:00
|
|
|
}
|
|
|
|
|
2019-05-17 13:05:07 +00:00
|
|
|
override fun getDeviceInfo(userId: String, deviceId: String?): MXDeviceInfo? {
|
|
|
|
return cryptoService.getDeviceInfo(userId, deviceId)
|
2019-05-16 08:23:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun reRequestRoomKeyForEvent(event: Event) {
|
|
|
|
cryptoService.reRequestRoomKeyForEvent(event)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun cancelRoomKeyRequest(requestBody: RoomKeyRequestBody) {
|
|
|
|
cryptoService.cancelRoomKeyRequest(requestBody)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun addRoomKeysRequestListener(listener: RoomKeysRequestListener) {
|
|
|
|
cryptoService.addRoomKeysRequestListener(listener)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun decryptEvent(event: Event, timeline: String): MXEventDecryptionResult? {
|
|
|
|
return cryptoService.decryptEvent(event, timeline)
|
|
|
|
}
|
|
|
|
|
2019-06-07 14:01:24 +00:00
|
|
|
override fun decryptEventAsync(event: Event, timeline: String, callback: MatrixCallback<MXEventDecryptionResult?>) {
|
|
|
|
return cryptoService.decryptEventAsync(event, timeline, callback)
|
|
|
|
}
|
|
|
|
|
2019-05-21 13:42:09 +00:00
|
|
|
override fun getEncryptionAlgorithm(roomId: String): String? {
|
|
|
|
return cryptoService.getEncryptionAlgorithm(roomId)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun shouldEncryptForInvitedMembers(roomId: String): Boolean {
|
|
|
|
return cryptoService.shouldEncryptForInvitedMembers(roomId)
|
|
|
|
}
|
|
|
|
|
2019-06-12 16:32:24 +00:00
|
|
|
override fun downloadKeys(userIds: List<String>, forceDownload: Boolean, callback: MatrixCallback<MXUsersDevicesMap<MXDeviceInfo>>) {
|
|
|
|
cryptoService.downloadKeys(userIds, forceDownload, callback)
|
|
|
|
}
|
|
|
|
|
2019-06-13 08:58:45 +00:00
|
|
|
override fun clearCryptoCache(callback: MatrixCallback<Unit>) {
|
|
|
|
cryptoService.clearCryptoCache(callback)
|
|
|
|
}
|
|
|
|
|
2018-10-17 11:59:21 +00:00
|
|
|
// Private methods *****************************************************************************
|
|
|
|
|
2018-12-12 20:15:01 +00:00
|
|
|
private fun assertMainThread() {
|
|
|
|
if (Looper.getMainLooper().thread !== Thread.currentThread()) {
|
|
|
|
throw IllegalStateException("This method can only be called on the main thread!")
|
2018-10-16 13:52:30 +00:00
|
|
|
}
|
2018-10-08 15:52:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|