mirror of
https://github.com/nextcloud/talk-android
synced 2025-06-19 19:49:33 +01:00
563 lines
23 KiB
Kotlin
563 lines
23 KiB
Kotlin
/*
|
|
* Nextcloud Talk application
|
|
*
|
|
* @author Mario Danic
|
|
* Copyright (C) 2017-2018 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.controllers
|
|
|
|
import android.content.Context
|
|
import android.graphics.drawable.Drawable
|
|
import android.graphics.drawable.LayerDrawable
|
|
import android.os.Bundle
|
|
import android.text.TextUtils
|
|
import android.view.LayoutInflater
|
|
import android.view.MenuItem
|
|
import android.view.View
|
|
import android.view.ViewGroup
|
|
import android.widget.ProgressBar
|
|
import android.widget.TextView
|
|
import androidx.appcompat.widget.SwitchCompat
|
|
import androidx.recyclerview.widget.RecyclerView
|
|
import androidx.work.Data
|
|
import androidx.work.OneTimeWorkRequest
|
|
import androidx.work.WorkManager
|
|
import autodagger.AutoInjector
|
|
import butterknife.BindView
|
|
import butterknife.OnClick
|
|
import com.afollestad.materialdialogs.LayoutMode.WRAP_CONTENT
|
|
import com.afollestad.materialdialogs.MaterialDialog
|
|
import com.afollestad.materialdialogs.bottomsheets.BottomSheet
|
|
import com.afollestad.materialdialogs.datetime.dateTimePicker
|
|
import com.bluelinelabs.conductor.changehandler.HorizontalChangeHandler
|
|
import com.facebook.drawee.backends.pipeline.Fresco
|
|
import com.facebook.drawee.view.SimpleDraweeView
|
|
import com.nextcloud.talk.R
|
|
import com.nextcloud.talk.adapters.items.UserItem
|
|
import com.nextcloud.talk.api.NcApi
|
|
import com.nextcloud.talk.application.NextcloudTalkApplication
|
|
import com.nextcloud.talk.controllers.base.BaseController
|
|
import com.nextcloud.talk.jobs.DeleteConversationWorker
|
|
import com.nextcloud.talk.jobs.LeaveConversationWorker
|
|
import com.nextcloud.talk.models.database.UserEntity
|
|
import com.nextcloud.talk.models.json.conversations.Conversation
|
|
import com.nextcloud.talk.models.json.conversations.RoomOverall
|
|
import com.nextcloud.talk.models.json.converters.EnumNotificationLevelConverter
|
|
import com.nextcloud.talk.models.json.generic.GenericOverall
|
|
import com.nextcloud.talk.models.json.participants.Participant
|
|
import com.nextcloud.talk.models.json.participants.ParticipantsOverall
|
|
import com.nextcloud.talk.utils.ApiUtils
|
|
import com.nextcloud.talk.utils.DateUtils
|
|
import com.nextcloud.talk.utils.DisplayUtils
|
|
import com.nextcloud.talk.utils.bundle.BundleKeys
|
|
import com.nextcloud.talk.utils.preferences.preferencestorage.DatabaseStorageModule
|
|
import com.yarolegovich.lovelydialog.LovelySaveStateHandler
|
|
import com.yarolegovich.lovelydialog.LovelyStandardDialog
|
|
import com.yarolegovich.mp.*
|
|
import eu.davidea.flexibleadapter.FlexibleAdapter
|
|
import eu.davidea.flexibleadapter.common.SmoothScrollLinearLayoutManager
|
|
import eu.davidea.flexibleadapter.items.AbstractFlexibleItem
|
|
import io.reactivex.Observer
|
|
import io.reactivex.android.schedulers.AndroidSchedulers
|
|
import io.reactivex.disposables.Disposable
|
|
import io.reactivex.schedulers.Schedulers
|
|
import java.util.*
|
|
import javax.inject.Inject
|
|
|
|
|
|
@AutoInjector(NextcloudTalkApplication::class)
|
|
class ConversationInfoController(args: Bundle) : BaseController(args) {
|
|
|
|
@BindView(R.id.notification_settings)
|
|
lateinit var notificationsPreferenceScreen: MaterialPreferenceScreen
|
|
@BindView(R.id.progressBar)
|
|
lateinit var progressBar: ProgressBar
|
|
@BindView(R.id.conversation_info_message_notifications)
|
|
lateinit var messageNotificationLevel: MaterialChoicePreference
|
|
@BindView(R.id.webinar_settings)
|
|
lateinit var conversationInfoWebinar: MaterialPreferenceScreen
|
|
@BindView(R.id.conversation_info_lobby)
|
|
lateinit var conversationInfoLobby: MaterialSwitchPreference
|
|
@BindView(R.id.conversation_info_name)
|
|
lateinit var nameCategoryView: MaterialPreferenceCategory
|
|
@BindView(R.id.start_time_preferences)
|
|
lateinit var startTimeView: MaterialStandardPreference
|
|
@BindView(R.id.avatar_image)
|
|
lateinit var conversationAvatarImageView: SimpleDraweeView
|
|
@BindView(R.id.display_name_text)
|
|
lateinit var conversationDisplayName: TextView
|
|
@BindView(R.id.participants_list_category)
|
|
lateinit var participantsListCategory: MaterialPreferenceCategory
|
|
@BindView(R.id.recycler_view)
|
|
lateinit var recyclerView: RecyclerView
|
|
@BindView(R.id.deleteConversationAction)
|
|
lateinit var deleteConversationAction: MaterialStandardPreference
|
|
@BindView(R.id.leaveConversationAction)
|
|
lateinit var leaveConversationAction: MaterialStandardPreference
|
|
@BindView(R.id.ownOptions)
|
|
lateinit var ownOptionsCategory: MaterialPreferenceCategory
|
|
@BindView(R.id.muteCalls)
|
|
lateinit var muteCalls: MaterialSwitchPreference
|
|
|
|
@set:Inject
|
|
lateinit var ncApi: NcApi
|
|
@set:Inject
|
|
lateinit var context: Context
|
|
|
|
private val conversationToken: String?
|
|
private val conversationUser: UserEntity?
|
|
private val credentials: String?
|
|
private var roomDisposable: Disposable? = null
|
|
private var participantsDisposable: Disposable? = null
|
|
|
|
private var databaseStorageModule: DatabaseStorageModule? = null
|
|
private var conversation: Conversation? = null
|
|
|
|
private var adapter: FlexibleAdapter<AbstractFlexibleItem<*>>? = null
|
|
private var recyclerViewItems: MutableList<AbstractFlexibleItem<*>> = ArrayList()
|
|
|
|
private var saveStateHandler: LovelySaveStateHandler? = null
|
|
|
|
private val workerData: Data?
|
|
get() {
|
|
if (!TextUtils.isEmpty(conversationToken) && conversationUser != null) {
|
|
val data = Data.Builder()
|
|
data.putString(BundleKeys.KEY_ROOM_TOKEN, conversationToken)
|
|
data.putLong(BundleKeys.KEY_INTERNAL_USER_ID, conversationUser.id)
|
|
return data.build()
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
init {
|
|
setHasOptionsMenu(true)
|
|
NextcloudTalkApplication.sharedApplication?.componentApplication?.inject(this)
|
|
conversationUser = args.getParcelable(BundleKeys.KEY_USER_ENTITY)
|
|
conversationToken = args.getString(BundleKeys.KEY_ROOM_TOKEN)
|
|
credentials = ApiUtils.getCredentials(conversationUser!!.username, conversationUser.token)
|
|
}
|
|
|
|
override fun onOptionsItemSelected(item: MenuItem): Boolean {
|
|
when (item.itemId) {
|
|
android.R.id.home -> {
|
|
router.popCurrentController()
|
|
return true
|
|
}
|
|
else -> return super.onOptionsItemSelected(item)
|
|
}
|
|
}
|
|
|
|
override fun inflateView(inflater: LayoutInflater, container: ViewGroup): View {
|
|
return inflater.inflate(R.layout.controller_conversation_info, container, false)
|
|
}
|
|
|
|
override fun onAttach(view: View) {
|
|
super.onAttach(view)
|
|
if (databaseStorageModule == null) {
|
|
databaseStorageModule = DatabaseStorageModule(conversationUser!!, conversationToken)
|
|
}
|
|
|
|
notificationsPreferenceScreen.setStorageModule(databaseStorageModule)
|
|
conversationInfoWebinar.setStorageModule(databaseStorageModule)
|
|
}
|
|
|
|
override fun onViewBound(view: View) {
|
|
super.onViewBound(view)
|
|
|
|
if (saveStateHandler == null) {
|
|
saveStateHandler = LovelySaveStateHandler()
|
|
}
|
|
|
|
if (adapter == null) {
|
|
fetchRoomInfo()
|
|
} else {
|
|
loadConversationAvatar()
|
|
notificationsPreferenceScreen.visibility = View.VISIBLE
|
|
nameCategoryView.visibility = View.VISIBLE
|
|
participantsListCategory.visibility = View.VISIBLE
|
|
progressBar.visibility = View.GONE
|
|
conversationDisplayName.text = conversation!!.displayName
|
|
|
|
setupWebinaryView()
|
|
setupAdapter()
|
|
}
|
|
}
|
|
|
|
private fun setupWebinaryView() {
|
|
if (conversationUser!!.hasSpreedFeatureCapability("webinary-lobby") && (conversation!!.type
|
|
== Conversation.ConversationType.ROOM_GROUP_CALL || conversation!!.type ==
|
|
Conversation.ConversationType.ROOM_PUBLIC_CALL) && conversation!!.canModerate(conversationUser)) {
|
|
conversationInfoWebinar.visibility = View.VISIBLE
|
|
|
|
val isLobbyOpenToModeratorsOnly = conversation!!.lobbyState == Conversation.LobbyState.LOBBY_STATE_MODERATORS_ONLY
|
|
(conversationInfoLobby.findViewById<View>(R.id.mp_checkable) as SwitchCompat)
|
|
.isChecked = isLobbyOpenToModeratorsOnly
|
|
|
|
reconfigureLobbyTimerView()
|
|
|
|
startTimeView.setOnClickListener {
|
|
MaterialDialog(activity!!, BottomSheet(WRAP_CONTENT)).show {
|
|
val currentTimeCalendar = Calendar.getInstance()
|
|
if (conversation!!.lobbyTimer != null && conversation!!.lobbyTimer != 0L) {
|
|
currentTimeCalendar.timeInMillis = conversation!!.lobbyTimer * 1000
|
|
}
|
|
|
|
dateTimePicker(minDateTime = Calendar.getInstance(), requireFutureDateTime =
|
|
true, currentDateTime = currentTimeCalendar, dateTimeCallback = { _,
|
|
dateTime ->
|
|
reconfigureLobbyTimerView(dateTime)
|
|
submitLobbyChanges()
|
|
})
|
|
}
|
|
}
|
|
|
|
(conversationInfoLobby.findViewById<View>(R.id.mp_checkable) as SwitchCompat).setOnCheckedChangeListener { _, _ ->
|
|
reconfigureLobbyTimerView()
|
|
submitLobbyChanges()
|
|
}
|
|
} else {
|
|
conversationInfoWebinar.visibility = View.GONE
|
|
}
|
|
}
|
|
|
|
fun reconfigureLobbyTimerView(dateTime: Calendar? = null) {
|
|
val isChecked = (conversationInfoLobby.findViewById<View>(R.id.mp_checkable) as SwitchCompat).isChecked
|
|
|
|
if (dateTime != null && isChecked) {
|
|
conversation!!.lobbyTimer = (dateTime.timeInMillis - (dateTime.time.seconds * 1000)) / 1000
|
|
} else if (!isChecked) {
|
|
conversation!!.lobbyTimer = 0
|
|
}
|
|
|
|
conversation!!.lobbyState = if (isChecked) Conversation.LobbyState
|
|
.LOBBY_STATE_MODERATORS_ONLY else Conversation.LobbyState.LOBBY_STATE_ALL_PARTICIPANTS
|
|
|
|
if (conversation!!.lobbyTimer != null && conversation!!.lobbyTimer != java.lang.Long.MIN_VALUE && conversation!!.lobbyTimer != 0L) {
|
|
startTimeView.setSummary(DateUtils.getLocalDateStringFromTimestampForLobby(conversation!!.lobbyTimer))
|
|
} else {
|
|
startTimeView.setSummary(R.string.nc_manual)
|
|
}
|
|
|
|
if (isChecked) {
|
|
startTimeView.visibility = View.VISIBLE
|
|
} else {
|
|
startTimeView.visibility = View.GONE
|
|
}
|
|
}
|
|
|
|
fun submitLobbyChanges() {
|
|
val state = if ((conversationInfoLobby.findViewById<View>(R.id
|
|
.mp_checkable) as SwitchCompat).isChecked) 1 else 0
|
|
ncApi.setLobbyForConversation(ApiUtils.getCredentials(conversationUser!!.username,
|
|
conversationUser.token), ApiUtils.getUrlForLobbyForConversation
|
|
(conversationUser.baseUrl, conversation!!.token), state, conversation!!.lobbyTimer)
|
|
.subscribeOn(Schedulers.io())
|
|
.observeOn(AndroidSchedulers.mainThread())
|
|
.subscribe(object : Observer<GenericOverall> {
|
|
override fun onComplete() {
|
|
}
|
|
|
|
override fun onSubscribe(d: Disposable) {
|
|
}
|
|
|
|
override fun onNext(t: GenericOverall) {
|
|
}
|
|
|
|
override fun onError(e: Throwable) {
|
|
}
|
|
|
|
})
|
|
}
|
|
|
|
private fun showLovelyDialog(dialogId: Int, savedInstanceState: Bundle) {
|
|
when (dialogId) {
|
|
ID_DELETE_CONVERSATION_DIALOG -> showDeleteConversationDialog(savedInstanceState)
|
|
else -> {
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private fun showDeleteConversationDialog(savedInstanceState: Bundle?) {
|
|
if (activity != null) {
|
|
LovelyStandardDialog(activity, LovelyStandardDialog.ButtonLayout.HORIZONTAL)
|
|
.setTopColorRes(R.color.nc_darkRed)
|
|
.setIcon(DisplayUtils.getTintedDrawable(context!!.resources,
|
|
R.drawable.ic_delete_black_24dp, R.color.bg_default))
|
|
.setPositiveButtonColor(context!!.resources.getColor(R.color.nc_darkRed))
|
|
.setTitle(R.string.nc_delete_call)
|
|
.setMessage(conversation!!.deleteWarningMessage)
|
|
.setPositiveButton(R.string.nc_delete) { deleteConversation() }
|
|
.setNegativeButton(R.string.nc_cancel, null)
|
|
.setInstanceStateHandler(ID_DELETE_CONVERSATION_DIALOG, saveStateHandler!!)
|
|
.setSavedInstanceState(savedInstanceState)
|
|
.show()
|
|
}
|
|
}
|
|
|
|
override fun onSaveViewState(view: View, outState: Bundle) {
|
|
saveStateHandler!!.saveInstanceState(outState)
|
|
super.onSaveViewState(view, outState)
|
|
}
|
|
|
|
override fun onRestoreViewState(view: View, savedViewState: Bundle) {
|
|
super.onRestoreViewState(view, savedViewState)
|
|
if (LovelySaveStateHandler.wasDialogOnScreen(savedViewState)) {
|
|
//Dialog won't be restarted automatically, so we need to call this method.
|
|
//Each dialog knows how to restore its state
|
|
showLovelyDialog(LovelySaveStateHandler.getSavedDialogId(savedViewState), savedViewState)
|
|
}
|
|
}
|
|
|
|
private fun setupAdapter() {
|
|
if (activity != null) {
|
|
if (adapter == null) {
|
|
adapter = FlexibleAdapter(recyclerViewItems, activity, true)
|
|
}
|
|
|
|
val layoutManager = SmoothScrollLinearLayoutManager(activity)
|
|
recyclerView.layoutManager = layoutManager
|
|
recyclerView.setHasFixedSize(true)
|
|
recyclerView.adapter = adapter
|
|
}
|
|
}
|
|
|
|
private fun handleParticipants(participants: List<Participant>) {
|
|
var userItem: UserItem
|
|
var participant: Participant
|
|
|
|
recyclerViewItems = ArrayList()
|
|
var ownUserItem: UserItem? = null
|
|
|
|
for (i in participants.indices) {
|
|
participant = participants[i]
|
|
userItem = UserItem(participant, conversationUser, null)
|
|
userItem.isEnabled = participant.sessionId != "0"
|
|
if (!TextUtils.isEmpty(participant.userId) && participant.userId == conversationUser!!.userId) {
|
|
ownUserItem = userItem
|
|
userItem.model.sessionId = "-1"
|
|
userItem.isEnabled = true
|
|
} else {
|
|
recyclerViewItems.add(userItem)
|
|
}
|
|
}
|
|
|
|
|
|
if (ownUserItem != null) {
|
|
recyclerViewItems.add(0, ownUserItem)
|
|
}
|
|
|
|
setupAdapter()
|
|
|
|
participantsListCategory.visibility = View.VISIBLE
|
|
adapter!!.notifyDataSetChanged()
|
|
}
|
|
|
|
override fun getTitle(): String? {
|
|
return resources!!.getString(R.string.nc_conversation_menu_conversation_info)
|
|
}
|
|
|
|
private fun getListOfParticipants() {
|
|
ncApi.getPeersForCall(credentials, ApiUtils.getUrlForParticipants(conversationUser!!.baseUrl, conversationToken))
|
|
.subscribeOn(Schedulers.io())
|
|
.observeOn(AndroidSchedulers.mainThread())
|
|
.subscribe(object : Observer<ParticipantsOverall> {
|
|
override fun onSubscribe(d: Disposable) {
|
|
participantsDisposable = d
|
|
}
|
|
|
|
override fun onNext(participantsOverall: ParticipantsOverall) {
|
|
handleParticipants(participantsOverall.ocs.data)
|
|
}
|
|
|
|
override fun onError(e: Throwable) {
|
|
|
|
}
|
|
|
|
override fun onComplete() {
|
|
participantsDisposable!!.dispose()
|
|
}
|
|
})
|
|
|
|
}
|
|
|
|
@OnClick(R.id.leaveConversationAction)
|
|
internal fun leaveConversation() {
|
|
workerData?.let {
|
|
WorkManager.getInstance().enqueue(OneTimeWorkRequest.Builder
|
|
(LeaveConversationWorker::class
|
|
.java).setInputData(it).build()
|
|
)
|
|
popTwoLastControllers()
|
|
}
|
|
}
|
|
|
|
private fun deleteConversation() {
|
|
workerData?.let {
|
|
WorkManager.getInstance().enqueue(OneTimeWorkRequest.Builder
|
|
(DeleteConversationWorker::class.java).setInputData(it).build())
|
|
popTwoLastControllers()
|
|
}
|
|
}
|
|
|
|
@OnClick(R.id.deleteConversationAction)
|
|
internal fun deleteConversationClick() {
|
|
showDeleteConversationDialog(null)
|
|
}
|
|
|
|
private fun popTwoLastControllers() {
|
|
var backstack = router.backstack
|
|
backstack = backstack.subList(0, backstack.size - 2)
|
|
router.setBackstack(backstack, HorizontalChangeHandler())
|
|
}
|
|
|
|
private fun fetchRoomInfo() {
|
|
ncApi.getRoom(credentials, ApiUtils.getRoom(conversationUser!!.baseUrl, conversationToken))
|
|
.subscribeOn(Schedulers.io())
|
|
.observeOn(AndroidSchedulers.mainThread())
|
|
.subscribe(object : Observer<RoomOverall> {
|
|
override fun onSubscribe(d: Disposable) {
|
|
roomDisposable = d
|
|
}
|
|
|
|
override fun onNext(roomOverall: RoomOverall) {
|
|
conversation = roomOverall.ocs.data
|
|
|
|
if (isAttached && (!isBeingDestroyed || !isDestroyed)) {
|
|
ownOptionsCategory.visibility = View.VISIBLE
|
|
|
|
setupWebinaryView()
|
|
|
|
if (!conversation!!.canLeave(conversationUser)) {
|
|
leaveConversationAction.visibility = View.GONE
|
|
} else {
|
|
leaveConversationAction.visibility = View.VISIBLE
|
|
}
|
|
|
|
if (!conversation!!.canModerate(conversationUser)) {
|
|
deleteConversationAction.visibility = View.GONE
|
|
} else {
|
|
deleteConversationAction.visibility = View.VISIBLE
|
|
}
|
|
|
|
if (Conversation.ConversationType.ROOM_SYSTEM == conversation!!.type) {
|
|
muteCalls.visibility = View.GONE
|
|
}
|
|
|
|
getListOfParticipants()
|
|
|
|
progressBar.visibility = View.GONE
|
|
|
|
nameCategoryView.visibility = View.VISIBLE
|
|
|
|
conversationDisplayName.text = conversation!!.displayName
|
|
|
|
|
|
loadConversationAvatar()
|
|
adjustNotificationLevelUI()
|
|
|
|
notificationsPreferenceScreen.visibility = View.VISIBLE
|
|
}
|
|
}
|
|
|
|
override fun onError(e: Throwable) {
|
|
|
|
}
|
|
|
|
override fun onComplete() {
|
|
roomDisposable!!.dispose()
|
|
}
|
|
})
|
|
}
|
|
|
|
private fun adjustNotificationLevelUI() {
|
|
if (conversation != null) {
|
|
if (conversationUser != null && conversationUser.hasSpreedFeatureCapability("notification-levels")) {
|
|
messageNotificationLevel.isEnabled = true
|
|
messageNotificationLevel.alpha = 1.0f
|
|
|
|
if (conversation!!.notificationLevel != Conversation.NotificationLevel.DEFAULT) {
|
|
val stringValue: String = when (EnumNotificationLevelConverter().convertToInt(conversation!!.notificationLevel)) {
|
|
1 -> "always"
|
|
2 -> "mention"
|
|
3 -> "never"
|
|
else -> "mention"
|
|
}
|
|
|
|
messageNotificationLevel.value = stringValue
|
|
} else {
|
|
setProperNotificationValue(conversation)
|
|
}
|
|
} else {
|
|
messageNotificationLevel.isEnabled = false
|
|
messageNotificationLevel.alpha = 0.38f
|
|
setProperNotificationValue(conversation)
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun setProperNotificationValue(conversation: Conversation?) {
|
|
if (conversation!!.type == Conversation.ConversationType.ROOM_TYPE_ONE_TO_ONE_CALL) {
|
|
// hack to see if we get mentioned always or just on mention
|
|
if (conversationUser!!.hasSpreedFeatureCapability("mention-flag")) {
|
|
messageNotificationLevel.value = "always"
|
|
} else {
|
|
messageNotificationLevel.value = "mention"
|
|
}
|
|
} else {
|
|
messageNotificationLevel.value = "mention"
|
|
}
|
|
}
|
|
|
|
private fun loadConversationAvatar() {
|
|
when (conversation!!.type) {
|
|
Conversation.ConversationType.ROOM_TYPE_ONE_TO_ONE_CALL -> if (!TextUtils.isEmpty
|
|
(conversation!!.name)) {
|
|
val draweeController = Fresco.newDraweeControllerBuilder()
|
|
.setOldController(conversationAvatarImageView.controller)
|
|
.setAutoPlayAnimations(true)
|
|
.setImageRequest(DisplayUtils.getImageRequestForUrl(ApiUtils.getUrlForAvatarWithName(conversationUser!!.baseUrl,
|
|
conversation!!.name, R.dimen.avatar_size_big), null))
|
|
.build()
|
|
conversationAvatarImageView.controller = draweeController
|
|
}
|
|
Conversation.ConversationType.ROOM_GROUP_CALL -> conversationAvatarImageView.hierarchy.setPlaceholderImage(DisplayUtils
|
|
.getRoundedBitmapDrawableFromVectorDrawableResource(resources,
|
|
R.drawable.ic_people_group_white_24px))
|
|
Conversation.ConversationType.ROOM_PUBLIC_CALL -> conversationAvatarImageView.hierarchy.setPlaceholderImage(DisplayUtils
|
|
.getRoundedBitmapDrawableFromVectorDrawableResource(resources,
|
|
R.drawable.ic_link_white_24px))
|
|
Conversation.ConversationType.ROOM_SYSTEM -> {
|
|
val layers = arrayOfNulls<Drawable>(2)
|
|
layers[0] = context.getDrawable(R.drawable.ic_launcher_background)
|
|
layers[1] = context.getDrawable(R.drawable.ic_launcher_foreground)
|
|
val layerDrawable = LayerDrawable(layers)
|
|
conversationAvatarImageView.hierarchy.setPlaceholderImage(DisplayUtils.getRoundedDrawable(layerDrawable))
|
|
}
|
|
|
|
else -> {
|
|
}
|
|
}
|
|
}
|
|
|
|
companion object {
|
|
|
|
private const val ID_DELETE_CONVERSATION_DIALOG = 0
|
|
}
|
|
}
|