filippodb/SchildiChat-android
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Some cleanup up

Browse Source
This commit is contained in:
Benoit Marty 2020-12-11 16:35:04 +01:00
parent 544345bbf3
commit 5461fd4060
13 changed files with 188 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/room/RoomService.kt
View File

@ -23,10 +23,10 @@ import org.matrix.android.sdk.api.session.room.members.ChangeMembershipState
import org.matrix.android.sdk.api.session.room.model.RoomMemberSummary
import org.matrix.android.sdk.api.session.room.model.RoomSummary
import org.matrix.android.sdk.api.session.room.model.create.CreateRoomParams
import org.matrix.android.sdk.api.session.room.peeking.PeekResult
import org.matrix.android.sdk.api.util.Cancelable
import org.matrix.android.sdk.api.util.Optional
import org.matrix.android.sdk.internal.session.room.alias.RoomAliasDescription
import org.matrix.android.sdk.internal.session.room.peeking.PeekResult
/**
* This interface defines methods to get rooms. It's implemented at the session level.
@ -167,6 +167,9 @@ interface RoomService {
*/
fun getRoomMemberLive(userId: String, roomId: String): LiveData<Optional<RoomMemberSummary>>
/**
* Get some state events about a room
*/
fun getRoomState(roomId: String, callback: MatrixCallback<List<Event>>)
/**

37
matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/room/peeking/PeekResult.kt Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright 2020 The Matrix.org Foundation C.I.C.
*
* 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
*
* 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.
*/
package org.matrix.android.sdk.api.session.room.peeking
sealed class PeekResult {
data class Success(
val roomId: String,
val alias: String?,
val name: String?,
val topic: String?,
val avatarUrl: String?,
val numJoinedMembers: Int?,
val viaServers: List<String>
) : PeekResult()
data class PeekingNotAllowed(
val roomId: String,
val alias: String?,
val viaServers: List<String>
) : PeekResult()
object UnknownAlias : PeekResult()
}

2
matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/DefaultRoomService.kt
View File

@ -28,6 +28,7 @@ import org.matrix.android.sdk.api.session.room.members.ChangeMembershipState
import org.matrix.android.sdk.api.session.room.model.RoomMemberSummary
import org.matrix.android.sdk.api.session.room.model.RoomSummary
import org.matrix.android.sdk.api.session.room.model.create.CreateRoomParams
import org.matrix.android.sdk.api.session.room.peeking.PeekResult
import org.matrix.android.sdk.api.util.Cancelable
import org.matrix.android.sdk.api.util.Optional
import org.matrix.android.sdk.api.util.toOptional
@ -41,7 +42,6 @@ import org.matrix.android.sdk.internal.session.room.create.CreateRoomTask
import org.matrix.android.sdk.internal.session.room.membership.RoomChangeMembershipStateDataSource
import org.matrix.android.sdk.internal.session.room.membership.RoomMemberHelper
import org.matrix.android.sdk.internal.session.room.membership.joining.JoinRoomTask
import org.matrix.android.sdk.internal.session.room.peeking.PeekResult
import org.matrix.android.sdk.internal.session.room.peeking.PeekRoomTask
import org.matrix.android.sdk.internal.session.room.peeking.ResolveRoomStateTask
import org.matrix.android.sdk.internal.session.room.read.MarkAllRoomsReadTask

14
matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/RoomAPI.kt
View File

@ -183,7 +183,7 @@ internal interface RoomAPI {
@Body body: ThreePidInviteBody): Call<Unit>
/**
* Send a generic state events
* Send a generic state event
*
* @param roomId the room id.
* @param stateEventType the state event type
@ -195,7 +195,7 @@ internal interface RoomAPI {
@Body params: JsonDict): Call<Unit>
/**
* Send a generic state events
* Send a generic state event
*
* @param roomId the room id.
* @param stateEventType the state event type
@ -208,6 +208,13 @@ internal interface RoomAPI {
@Path("state_key") stateKey: String,
@Body params: JsonDict): Call<Unit>
/**
* Get state events of a room
* Ref: https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-rooms-roomid-state
*/
@GET(NetworkConstants.URI_API_PREFIX_PATH_R0 + "rooms/{roomId}/state")
fun getRoomState(@Path("roomId") roomId: String) : Call<List<Event>>
/**
* Send a relation event to a room.
*
@ -354,7 +361,4 @@ internal interface RoomAPI {
fun deleteTag(@Path("userId") userId: String,
@Path("roomId") roomId: String,
@Path("tag") tag: String): Call<Unit>
@GET(NetworkConstants.URI_API_PREFIX_PATH_R0 + "rooms/{roomId}/state")
fun getRoomState(@Path("roomId") roomId: String) : Call<List<Event>>
}

4
matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/alias/GetRoomIdByAliasTask.kt
View File

@ -43,13 +43,13 @@ internal class DefaultGetRoomIdByAliasTask @Inject constructor(
) : GetRoomIdByAliasTask {
override suspend fun execute(params: GetRoomIdByAliasTask.Params): Optional<RoomAliasDescription> {
var roomId = Realm.getInstance(monarchy.realmConfiguration).use {
val roomId = Realm.getInstance(monarchy.realmConfiguration).use {
RoomSummaryEntity.findByAlias(it, params.roomAlias)?.roomId
}
return if (roomId != null) {
Optional.from(RoomAliasDescription(roomId))
} else if (!params.searchOnServer) {
Optional.from<RoomAliasDescription>(null)
Optional.from(null)
} else {
val description = tryOrNull("## Failed to get roomId from alias") {
executeRequest<RoomAliasDescription>(eventBus) {

75
matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/peeking/PeekRoomTask.kt
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2020 New Vector Ltd
* Copyright 2020 The Matrix.org Foundation C.I.C.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -26,32 +26,13 @@ import org.matrix.android.sdk.api.session.room.model.RoomNameContent
import org.matrix.android.sdk.api.session.room.model.RoomTopicContent
import org.matrix.android.sdk.api.session.room.model.roomdirectory.PublicRoomsFilter
import org.matrix.android.sdk.api.session.room.model.roomdirectory.PublicRoomsParams
import org.matrix.android.sdk.api.session.room.peeking.PeekResult
import org.matrix.android.sdk.internal.session.room.alias.GetRoomIdByAliasTask
import org.matrix.android.sdk.internal.session.room.directory.GetPublicRoomTask
import org.matrix.android.sdk.internal.session.room.directory.GetRoomDirectoryVisibilityTask
import org.matrix.android.sdk.internal.task.Task
import javax.inject.Inject
sealed class PeekResult {
data class Success(
val roomId: String,
val alias: String?,
val name: String?,
val topic: String?,
val avatarUrl: String?,
val numJoinedMembers: Int?,
val viaServers: List<String>
) : PeekResult()
data class PeekingNotAllowed(
val roomId: String,
val alias: String?,
val viaServers: List<String>
) : PeekResult()
object UnknownAlias : PeekResult()
}
internal interface PeekRoomTask : Task<PeekRoomTask.Params, PeekResult> {
data class Params(
val roomIdOrAlias: String
@ -66,11 +47,10 @@ internal class DefaultPeekRoomTask @Inject constructor(
) : PeekRoomTask {
override suspend fun execute(params: PeekRoomTask.Params): PeekResult {
val roomId: String?
val roomId: String
val serverList: List<String>
val isAlias: Boolean
if (MatrixPatterns.isRoomAlias(params.roomIdOrAlias)) {
isAlias = true
val isAlias = MatrixPatterns.isRoomAlias(params.roomIdOrAlias)
if (isAlias) {
// get alias description
val aliasDescription = getRoomIdByAliasTask
.execute(GetRoomIdByAliasTask.Params(params.roomIdOrAlias, true))
@ -80,7 +60,6 @@ internal class DefaultPeekRoomTask @Inject constructor(
roomId = aliasDescription.roomId
serverList = aliasDescription.servers
} else {
isAlias = false
roomId = params.roomIdOrAlias
serverList = emptyList()
}
@ -91,7 +70,7 @@ internal class DefaultPeekRoomTask @Inject constructor(
// We cannot resolve this room :/
null
}
RoomDirectoryVisibility.PUBLIC -> {
RoomDirectoryVisibility.PUBLIC -> {
// Try to find it in directory
val filter = if (isAlias) PublicRoomsFilter(searchTerm = params.roomIdOrAlias.substring(1))
else null
@ -121,34 +100,30 @@ internal class DefaultPeekRoomTask @Inject constructor(
// mm... try to peek state ? maybe the room is not public but yet allow guest to get events?
// this could be slow
try {
val stateEvents = resolveRoomStateTask
.execute(ResolveRoomStateTask.Params(roomId))
val name = stateEvents.lastOrNull {
it.type == EventType.STATE_ROOM_NAME
&& it.stateKey == ""
}?.let { it.content?.toModel<RoomNameContent>()?.name }
val stateEvents = resolveRoomStateTask.execute(ResolveRoomStateTask.Params(roomId))
val name = stateEvents
.lastOrNull { it.type == EventType.STATE_ROOM_NAME && it.stateKey == "" }
?.let { it.content?.toModel<RoomNameContent>()?.name }
val topic = stateEvents.lastOrNull {
it.type == EventType.STATE_ROOM_TOPIC
&& it.stateKey == ""
}?.let { it.content?.toModel<RoomTopicContent>()?.topic }
val topic = stateEvents
.lastOrNull { it.type == EventType.STATE_ROOM_TOPIC && it.stateKey == "" }
?.let { it.content?.toModel<RoomTopicContent>()?.topic }
val avatarUrl = stateEvents.lastOrNull {
it.type == EventType.STATE_ROOM_AVATAR
}?.let { it.content?.toModel<RoomAvatarContent>()?.avatarUrl }
val avatarUrl = stateEvents
.lastOrNull { it.type == EventType.STATE_ROOM_AVATAR }
?.let { it.content?.toModel<RoomAvatarContent>()?.avatarUrl }
val alias = stateEvents.lastOrNull {
it.type == EventType.STATE_ROOM_CANONICAL_ALIAS
}?.let {
it.content?.toModel<RoomCanonicalAliasContent>()?.canonicalAlias
?: it.content?.toModel<RoomCanonicalAliasContent>()?.alternativeAliases?.firstOrNull()
}
val alias = stateEvents
.lastOrNull { it.type == EventType.STATE_ROOM_CANONICAL_ALIAS }
?.let {
it.content?.toModel<RoomCanonicalAliasContent>()?.canonicalAlias
?: it.content?.toModel<RoomCanonicalAliasContent>()?.alternativeAliases?.firstOrNull()
}
// not sure if it's the right way to do that :/
val memberCount = stateEvents.filter {
it.type == EventType.STATE_ROOM_MEMBER
&& it.stateKey?.isNotEmpty() == true
}.distinctBy { it.stateKey }
val memberCount = stateEvents
.filter { it.type == EventType.STATE_ROOM_MEMBER && it.stateKey?.isNotEmpty() == true }
.distinctBy { it.stateKey }
.count()
return PeekResult.Success(

2
matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/peeking/ResolveRoomStateTask.kt
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2020 New Vector Ltd
* Copyright 2020 The Matrix.org Foundation C.I.C.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.

20
vector/src/main/AndroidManifest.xml
View File

@ -81,8 +81,9 @@
android:resource="@xml/shortcuts" />
</activity-alias>
<activity android:name=".features.home.HomeActivity"
android:launchMode="singleTask"/>
<activity
android:name=".features.home.HomeActivity"
android:launchMode="singleTask" />
<activity
android:name=".features.login.LoginActivity"
android:launchMode="singleTask"
@ -190,19 +191,24 @@
<activity
android:name=".features.signout.soft.SoftLogoutActivity"
android:windowSoftInputMode="adjustResize" />
<activity android:name=".features.permalink.PermalinkHandlerActivity" android:launchMode="singleTask">
<activity
android:name=".features.permalink.PermalinkHandlerActivity"
android:launchMode="singleTask">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data android:scheme="http" />
<data android:scheme="https" />
<data android:host="matrix.to" />
<data android:scheme="element"
android:host="user"/>
<data android:scheme="element"
android:host="room"/>
<data
android:host="user"
android:scheme="element" />
<data
android:host="room"
android:scheme="element" />
</intent-filter>
</activity>

55
vector/src/main/java/im/vector/app/features/home/HomeActivity.kt
View File

@ -126,9 +126,9 @@ class HomeActivity : VectorBaseActivity(), ToolbarConfigurable, UnknownDeviceDet
.observe()
.subscribe { sharedAction ->
when (sharedAction) {
is HomeActivitySharedAction.OpenDrawer -> drawerLayout.openDrawer(GravityCompat.START)
is HomeActivitySharedAction.OpenDrawer -> drawerLayout.openDrawer(GravityCompat.START)
is HomeActivitySharedAction.CloseDrawer -> drawerLayout.closeDrawer(GravityCompat.START)
is HomeActivitySharedAction.OpenGroup -> {
is HomeActivitySharedAction.OpenGroup -> {
drawerLayout.closeDrawer(GravityCompat.START)
replaceFragment(R.id.homeDetailFragmentContainer, HomeDetailFragment::class.java, allowStateLoss = true)
}
@ -145,9 +145,9 @@ class HomeActivity : VectorBaseActivity(), ToolbarConfigurable, UnknownDeviceDet
homeActivityViewModel.observeViewEvents {
when (it) {
is HomeActivityViewEvents.AskPasswordToInitCrossSigning -> handleAskPasswordToInitCrossSigning(it)
is HomeActivityViewEvents.OnNewSession -> handleOnNewSession(it)
HomeActivityViewEvents.PromptToEnableSessionPush -> handlePromptToEnablePush()
is HomeActivityViewEvents.OnCrossSignedInvalidated -> handleCrossSigningInvalidated(it)
is HomeActivityViewEvents.OnNewSession -> handleOnNewSession(it)
HomeActivityViewEvents.PromptToEnableSessionPush -> handlePromptToEnablePush()
is HomeActivityViewEvents.OnCrossSignedInvalidated -> handleCrossSigningInvalidated(it)
}.exhaustive
}
homeActivityViewModel.subscribe(this) { renderState(it) }
@ -162,29 +162,27 @@ class HomeActivity : VectorBaseActivity(), ToolbarConfigurable, UnknownDeviceDet
private fun handleIntent(intent: Intent?) {
intent?.dataString?.let { deepLink ->
val resolvedLink = if (deepLink.startsWith(PermalinkService.MATRIX_TO_URL_BASE)) {
deepLink
} else if (deepLink.startsWith(PermalinkService.MATRIX_TO_CUSTOM_SCHEME_URL_BASE)) {
// This is a bit hugly, but for now just convert to matrix.to link for compatibility
val service = activeSessionHolder.getSafeActiveSession()?.permalinkService()
val roomLinkPrefix = "${PermalinkService.MATRIX_TO_CUSTOM_SCHEME_URL_BASE}room/"
val userPrefix = "${PermalinkService.MATRIX_TO_CUSTOM_SCHEME_URL_BASE}user/"
when {
deepLink.startsWith(userPrefix) -> {
val userId = deepLink.substring(userPrefix.length)
service?.createPermalink(userId)
val resolvedLink = when {
deepLink.startsWith(PermalinkService.MATRIX_TO_URL_BASE) -> deepLink
deepLink.startsWith(PermalinkService.MATRIX_TO_CUSTOM_SCHEME_URL_BASE) -> {
// This is a bit ugly, but for now just convert to matrix.to link for compatibility
when {
deepLink.startsWith(USER_LINK_PREFIX) -> deepLink.substring(USER_LINK_PREFIX.length)
deepLink.startsWith(ROOM_LINK_PREFIX) -> deepLink.substring(ROOM_LINK_PREFIX.length)
else -> null
}?.let {
activeSessionHolder.getSafeActiveSession()?.permalinkService()?.createPermalink(it)
}
deepLink.startsWith(roomLinkPrefix) -> {
val param = deepLink.substring(roomLinkPrefix.length)
service?.createRoomPermalink(param)
}
else -> null
}
} else null
else -> null
}
permalinkHandler.launch(this, resolvedLink,
permalinkHandler.launch(
context = this,
deepLink = resolvedLink,
navigationInterceptor = this,
buildTask = true)
buildTask = true
)
// .delay(500, TimeUnit.MILLISECONDS)
.observeOn(AndroidSchedulers.mainThread())
.subscribe { isHandled ->
@ -198,7 +196,7 @@ class HomeActivity : VectorBaseActivity(), ToolbarConfigurable, UnknownDeviceDet
private fun renderState(state: HomeActivityViewState) {
when (val status = state.initialSyncProgressServiceStatus) {
is InitialSyncProgressService.Status.Idle -> {
is InitialSyncProgressService.Status.Idle -> {
waiting_view.isVisible = false
}
is InitialSyncProgressService.Status.Progressing -> {
@ -363,11 +361,11 @@ class HomeActivity : VectorBaseActivity(), ToolbarConfigurable, UnknownDeviceDet
bugReporter.openBugReportScreen(this, false)
return true
}
R.id.menu_home_filter -> {
R.id.menu_home_filter -> {
navigator.openRoomsFiltering(this)
return true
}
R.id.menu_home_setting -> {
R.id.menu_home_setting -> {
navigator.openSettings(this)
return true
}
@ -408,5 +406,8 @@ class HomeActivity : VectorBaseActivity(), ToolbarConfigurable, UnknownDeviceDet
putExtra(MvRx.KEY_ARG, args)
}
}
private const val ROOM_LINK_PREFIX = "${PermalinkService.MATRIX_TO_CUSTOM_SCHEME_URL_BASE}room/"
private const val USER_LINK_PREFIX = "${PermalinkService.MATRIX_TO_CUSTOM_SCHEME_URL_BASE}user/"
}
}

6
vector/src/main/java/im/vector/app/features/permalink/PermalinkHandler.kt
View File

@ -77,7 +77,7 @@ class PermalinkHandler @Inject constructor(private val activeSessionHolder: Acti
buildTask: Boolean
): Single<Boolean> {
return when (permalinkData) {
is PermalinkData.RoomLink -> {
is PermalinkData.RoomLink -> {
permalinkData.getRoomId()
.observeOn(AndroidSchedulers.mainThread())
.map {
@ -93,11 +93,11 @@ class PermalinkHandler @Inject constructor(private val activeSessionHolder: Acti
true
}
}
is PermalinkData.GroupLink -> {
is PermalinkData.GroupLink -> {
navigator.openGroupDetail(permalinkData.groupId, context, buildTask)
Single.just(true)
}
is PermalinkData.UserLink -> {
is PermalinkData.UserLink -> {
if (navigationInterceptor?.navToMemberProfile(permalinkData.userId, rawLink) != true) {
navigator.openRoomMemberProfile(userId = permalinkData.userId, roomId = null, context = context, buildTask = buildTask)
}

23
vector/src/main/java/im/vector/app/features/roomdirectory/roompreview/PeekingState.kt Normal file
View File

@ -0,0 +1,23 @@
/*
* Copyright (c) 2020 New Vector Ltd
*
* 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
*
* 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.
*/
package im.vector.app.features.roomdirectory.roompreview
enum class PeekingState {
FOUND,
NOT_FOUND,
NO_ACCESS
}

80
vector/src/main/java/im/vector/app/features/roomdirectory/roompreview/RoomPreviewViewModel.kt
View File

@ -36,8 +36,8 @@ import org.matrix.android.sdk.api.query.QueryStringValue
import org.matrix.android.sdk.api.session.Session
import org.matrix.android.sdk.api.session.room.members.ChangeMembershipState
import org.matrix.android.sdk.api.session.room.model.Membership
import org.matrix.android.sdk.api.session.room.peeking.PeekResult
import org.matrix.android.sdk.api.session.room.roomSummaryQueryParams
import org.matrix.android.sdk.internal.session.room.peeking.PeekResult
import org.matrix.android.sdk.internal.util.awaitCallback
import org.matrix.android.sdk.rx.rx
import timber.log.Timber
@ -66,46 +66,50 @@ class RoomPreviewViewModel @AssistedInject constructor(@Assisted private val ini
observeMembershipChanges()
if (initialState.shouldPeekFromServer) {
setState {
copy(peekingState = Loading())
peekRoomFromServer()
}
}
private fun peekRoomFromServer() {
setState {
copy(peekingState = Loading())
}
viewModelScope.launch(Dispatchers.IO) {
val peekResult = tryOrNull {
awaitCallback<PeekResult> {
session.peekRoom(initialState.roomAlias ?: initialState.roomId, it)
}
}
viewModelScope.launch(Dispatchers.IO) {
val peekResult = tryOrNull {
awaitCallback<PeekResult> {
session.peekRoom(initialState.roomAlias ?: initialState.roomId, it)
when (peekResult) {
is PeekResult.Success -> {
setState {
copy(
roomId = peekResult.roomId,
avatarUrl = peekResult.avatarUrl,
roomAlias = peekResult.alias ?: initialState.roomAlias,
roomTopic = peekResult.topic,
homeServers = peekResult.viaServers,
peekingState = Success(PeekingState.FOUND)
)
}
}
when (peekResult) {
is PeekResult.Success -> {
setState {
copy(
roomId = peekResult.roomId,
avatarUrl = peekResult.avatarUrl,
roomAlias = peekResult.alias ?: initialState.roomAlias,
roomTopic = peekResult.topic,
homeServers = peekResult.viaServers,
peekingState = Success(PeekingState.FOUND)
)
}
is PeekResult.PeekingNotAllowed -> {
setState {
copy(
roomId = peekResult.roomId,
roomAlias = peekResult.alias ?: initialState.roomAlias,
homeServers = peekResult.viaServers,
peekingState = Success(PeekingState.NO_ACCESS)
)
}
is PeekResult.PeekingNotAllowed -> {
setState {
copy(
roomId = peekResult.roomId,
roomAlias = peekResult.alias ?: initialState.roomAlias,
homeServers = peekResult.viaServers,
peekingState = Success(PeekingState.NO_ACCESS)
)
}
}
PeekResult.UnknownAlias,
null -> {
setState {
copy(
peekingState = Success(PeekingState.NOT_FOUND)
)
}
}
PeekResult.UnknownAlias,
null -> {
setState {
copy(
peekingState = Success(PeekingState.NOT_FOUND)
)
}
}
}
@ -136,7 +140,7 @@ class RoomPreviewViewModel @AssistedInject constructor(@Assisted private val ini
.subscribe {
val changeMembership = it[initialState.roomId] ?: ChangeMembershipState.Unknown
val joinState = when (changeMembership) {
is ChangeMembershipState.Joining -> JoinState.JOINING
is ChangeMembershipState.Joining -> JoinState.JOINING
is ChangeMembershipState.FailedJoining -> JoinState.JOINING_ERROR
// Other cases are handled by room summary
else -> null

8
vector/src/main/java/im/vector/app/features/roomdirectory/roompreview/RoomPreviewViewState.kt
View File

@ -22,15 +22,7 @@ import com.airbnb.mvrx.Uninitialized
import im.vector.app.features.roomdirectory.JoinState
import org.matrix.android.sdk.api.util.MatrixItem
enum class PeekingState {
UNKNOWN,
FOUND,
NOT_FOUND,
NO_ACCESS
}
data class RoomPreviewViewState(
val peekingState: Async<PeekingState> = Uninitialized,
// The room id
val roomId: String = "",