2021-07-09 03:14:21 +02:00
|
|
|
package org.thoughtcrime.securesms.home
|
2019-12-17 14:27:59 +01:00
|
|
|
|
2020-02-19 05:34:02 +01:00
|
|
|
import android.app.AlertDialog
|
2020-07-16 04:49:37 +02:00
|
|
|
import android.content.BroadcastReceiver
|
|
|
|
import android.content.Context
|
2019-12-17 15:15:13 +01:00
|
|
|
import android.content.Intent
|
2020-07-16 04:49:37 +02:00
|
|
|
import android.content.IntentFilter
|
2019-12-19 11:49:23 +01:00
|
|
|
import android.database.Cursor
|
2019-12-17 14:27:59 +01:00
|
|
|
import android.os.Bundle
|
2020-01-09 01:35:43 +01:00
|
|
|
import android.text.Spannable
|
|
|
|
import android.text.SpannableString
|
|
|
|
import android.text.style.ForegroundColorSpan
|
2020-02-19 05:34:02 +01:00
|
|
|
import android.widget.Toast
|
2021-12-16 05:47:26 +01:00
|
|
|
import androidx.core.os.bundleOf
|
2021-07-29 09:02:58 +02:00
|
|
|
import androidx.core.view.isVisible
|
2020-09-03 14:15:03 +02:00
|
|
|
import androidx.lifecycle.Observer
|
2020-11-23 06:59:44 +01:00
|
|
|
import androidx.lifecycle.lifecycleScope
|
2020-09-03 14:15:03 +02:00
|
|
|
import androidx.loader.app.LoaderManager
|
|
|
|
import androidx.loader.content.Loader
|
|
|
|
import androidx.localbroadcastmanager.content.LocalBroadcastManager
|
2021-10-04 09:51:19 +02:00
|
|
|
import dagger.hilt.android.AndroidEntryPoint
|
2020-11-23 06:59:44 +01:00
|
|
|
import kotlinx.coroutines.Dispatchers
|
2022-01-14 06:56:15 +01:00
|
|
|
import kotlinx.coroutines.flow.filter
|
2020-11-23 06:59:44 +01:00
|
|
|
import kotlinx.coroutines.launch
|
2021-07-29 09:02:58 +02:00
|
|
|
import kotlinx.coroutines.withContext
|
2019-12-17 14:27:59 +01:00
|
|
|
import network.loki.messenger.R
|
2022-01-14 06:56:15 +01:00
|
|
|
import network.loki.messenger.databinding.ActivityHomeBinding
|
|
|
|
import network.loki.messenger.databinding.SeedReminderStubBinding
|
2021-03-03 01:33:35 +01:00
|
|
|
import org.greenrobot.eventbus.EventBus
|
|
|
|
import org.greenrobot.eventbus.Subscribe
|
|
|
|
import org.greenrobot.eventbus.ThreadMode
|
2021-03-17 01:30:03 +01:00
|
|
|
import org.session.libsession.messaging.jobs.JobQueue
|
2021-03-31 06:15:50 +02:00
|
|
|
import org.session.libsession.messaging.sending_receiving.MessageSender
|
2022-01-14 06:56:15 +01:00
|
|
|
import org.session.libsession.utilities.GroupUtil
|
|
|
|
import org.session.libsession.utilities.ProfilePictureModifiedEvent
|
|
|
|
import org.session.libsession.utilities.TextSecurePreferences
|
2022-01-16 18:02:39 +01:00
|
|
|
import org.session.libsignal.utilities.ThreadUtils
|
2021-06-09 07:56:20 +02:00
|
|
|
import org.session.libsignal.utilities.toHexString
|
2019-12-17 14:27:59 +01:00
|
|
|
import org.thoughtcrime.securesms.ApplicationContext
|
2021-07-20 08:06:59 +02:00
|
|
|
import org.thoughtcrime.securesms.MuteDialog
|
2019-12-17 14:27:59 +01:00
|
|
|
import org.thoughtcrime.securesms.PassphraseRequiredActionBarActivity
|
2021-05-31 06:29:11 +02:00
|
|
|
import org.thoughtcrime.securesms.conversation.v2.ConversationActivityV2
|
2021-07-20 08:06:59 +02:00
|
|
|
import org.thoughtcrime.securesms.conversation.v2.utilities.NotificationUtils
|
2021-07-08 05:38:14 +02:00
|
|
|
import org.thoughtcrime.securesms.crypto.IdentityKeyUtil
|
2021-10-04 09:51:19 +02:00
|
|
|
import org.thoughtcrime.securesms.database.GroupDatabase
|
|
|
|
import org.thoughtcrime.securesms.database.RecipientDatabase
|
|
|
|
import org.thoughtcrime.securesms.database.ThreadDatabase
|
2019-12-17 15:15:13 +01:00
|
|
|
import org.thoughtcrime.securesms.database.model.ThreadRecord
|
2021-10-04 09:51:19 +02:00
|
|
|
import org.thoughtcrime.securesms.dependencies.DatabaseComponent
|
2021-07-09 05:56:38 +02:00
|
|
|
import org.thoughtcrime.securesms.dms.CreatePrivateChatActivity
|
2021-07-09 03:14:21 +02:00
|
|
|
import org.thoughtcrime.securesms.groups.CreateClosedGroupActivity
|
2021-07-09 05:56:38 +02:00
|
|
|
import org.thoughtcrime.securesms.groups.JoinPublicChatActivity
|
2021-07-09 05:25:57 +02:00
|
|
|
import org.thoughtcrime.securesms.groups.OpenGroupManager
|
2019-12-19 11:15:58 +01:00
|
|
|
import org.thoughtcrime.securesms.mms.GlideApp
|
|
|
|
import org.thoughtcrime.securesms.mms.GlideRequests
|
2022-01-16 18:02:39 +01:00
|
|
|
import org.thoughtcrime.securesms.notifications.MarkReadReceiver
|
2021-07-09 03:14:21 +02:00
|
|
|
import org.thoughtcrime.securesms.onboarding.SeedActivity
|
2021-07-20 08:06:59 +02:00
|
|
|
import org.thoughtcrime.securesms.onboarding.SeedReminderViewDelegate
|
2021-07-09 03:14:21 +02:00
|
|
|
import org.thoughtcrime.securesms.preferences.SettingsActivity
|
2022-01-14 06:56:15 +01:00
|
|
|
import org.thoughtcrime.securesms.util.ConfigurationMessageUtilities
|
|
|
|
import org.thoughtcrime.securesms.util.IP2Country
|
|
|
|
import org.thoughtcrime.securesms.util.disableClipping
|
|
|
|
import org.thoughtcrime.securesms.util.getColorWithID
|
|
|
|
import org.thoughtcrime.securesms.util.push
|
|
|
|
import org.thoughtcrime.securesms.util.show
|
2020-09-11 01:03:57 +02:00
|
|
|
import java.io.IOException
|
2021-10-04 09:51:19 +02:00
|
|
|
import javax.inject.Inject
|
2019-12-17 14:27:59 +01:00
|
|
|
|
2021-10-04 09:51:19 +02:00
|
|
|
@AndroidEntryPoint
|
2021-12-10 00:18:56 +01:00
|
|
|
class HomeActivity : PassphraseRequiredActionBarActivity(), ConversationClickListener,
|
|
|
|
SeedReminderViewDelegate, NewConversationButtonSetViewDelegate, LoaderManager.LoaderCallbacks<Cursor> {
|
2022-01-14 06:56:15 +01:00
|
|
|
|
|
|
|
private lateinit var binding: ActivityHomeBinding
|
2019-12-19 11:15:58 +01:00
|
|
|
private lateinit var glide: GlideRequests
|
2020-07-16 04:49:37 +02:00
|
|
|
private var broadcastReceiver: BroadcastReceiver? = null
|
2019-12-17 14:27:59 +01:00
|
|
|
|
2021-10-04 09:51:19 +02:00
|
|
|
@Inject lateinit var threadDb: ThreadDatabase
|
|
|
|
@Inject lateinit var recipientDatabase: RecipientDatabase
|
|
|
|
@Inject lateinit var groupDatabase: GroupDatabase
|
|
|
|
|
2020-07-15 06:26:20 +02:00
|
|
|
private val publicKey: String
|
2021-05-27 07:00:16 +02:00
|
|
|
get() = TextSecurePreferences.getLocalNumber(this)!!
|
2020-01-06 04:26:52 +01:00
|
|
|
|
2022-01-14 06:56:15 +01:00
|
|
|
private val homeAdapter: HomeAdapter by lazy {
|
|
|
|
HomeAdapter(context = this, cursor = threadDb.conversationList, listener = this)
|
2021-12-10 00:18:56 +01:00
|
|
|
}
|
|
|
|
|
2019-12-18 11:36:09 +01:00
|
|
|
// region Lifecycle
|
2019-12-17 14:27:59 +01:00
|
|
|
override fun onCreate(savedInstanceState: Bundle?, isReady: Boolean) {
|
|
|
|
super.onCreate(savedInstanceState, isReady)
|
|
|
|
// Set content view
|
2022-01-14 06:56:15 +01:00
|
|
|
binding = ActivityHomeBinding.inflate(layoutInflater)
|
|
|
|
setContentView(binding.root)
|
2020-01-07 02:00:30 +01:00
|
|
|
// Set custom toolbar
|
2022-01-14 06:56:15 +01:00
|
|
|
setSupportActionBar(binding.toolbar)
|
2019-12-19 11:15:58 +01:00
|
|
|
// Set up Glide
|
|
|
|
glide = GlideApp.with(this)
|
2020-01-06 02:07:55 +01:00
|
|
|
// Set up toolbar buttons
|
2022-01-14 06:56:15 +01:00
|
|
|
binding.profileButton.glide = glide
|
|
|
|
binding.profileButton.setOnClickListener { openSettings() }
|
|
|
|
binding.pathStatusViewContainer.disableClipping()
|
|
|
|
binding.pathStatusViewContainer.setOnClickListener { showPath() }
|
2020-01-09 01:35:43 +01:00
|
|
|
// Set up seed reminder view
|
|
|
|
val hasViewedSeed = TextSecurePreferences.getHasViewedSeed(this)
|
2021-02-18 05:12:30 +01:00
|
|
|
if (!hasViewedSeed) {
|
2022-01-14 06:56:15 +01:00
|
|
|
binding.seedReminderStub.setOnInflateListener { _, inflated ->
|
|
|
|
val stubBinding = SeedReminderStubBinding.bind(inflated)
|
2021-07-29 09:02:58 +02:00
|
|
|
val seedReminderViewTitle = SpannableString("You're almost finished! 80%") // Intentionally not yet translated
|
|
|
|
seedReminderViewTitle.setSpan(ForegroundColorSpan(resources.getColorWithID(R.color.accent, theme)), 24, 27, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
|
2022-01-14 06:56:15 +01:00
|
|
|
stubBinding.seedReminderView.title = seedReminderViewTitle
|
|
|
|
stubBinding.seedReminderView.subtitle = resources.getString(R.string.view_seed_reminder_subtitle_1)
|
|
|
|
stubBinding.seedReminderView.setProgress(80, false)
|
|
|
|
stubBinding.seedReminderView.delegate = this@HomeActivity
|
2021-07-29 09:02:58 +02:00
|
|
|
}
|
2022-01-14 06:56:15 +01:00
|
|
|
binding.seedReminderStub.inflate()
|
2020-01-09 01:35:43 +01:00
|
|
|
} else {
|
2022-01-14 06:56:15 +01:00
|
|
|
binding.seedReminderStub.isVisible = false
|
2020-01-09 01:35:43 +01:00
|
|
|
}
|
2019-12-17 14:27:59 +01:00
|
|
|
// Set up recycler view
|
2021-02-04 06:57:24 +01:00
|
|
|
homeAdapter.setHasStableIds(true)
|
2019-12-19 11:15:58 +01:00
|
|
|
homeAdapter.glide = glide
|
2022-01-14 06:56:15 +01:00
|
|
|
binding.recyclerView.adapter = homeAdapter
|
2020-04-20 03:54:56 +02:00
|
|
|
// Set up empty state view
|
2022-01-14 06:56:15 +01:00
|
|
|
binding.createNewPrivateChatButton.setOnClickListener { createNewPrivateChat() }
|
2021-07-30 05:42:39 +02:00
|
|
|
IP2Country.configureIfNeeded(this@HomeActivity)
|
2019-12-19 11:49:23 +01:00
|
|
|
// This is a workaround for the fact that CursorRecyclerViewAdapter doesn't actually auto-update (even though it says it will)
|
2021-12-10 00:18:56 +01:00
|
|
|
LoaderManager.getInstance(this).restartLoader(0, null, this)
|
2020-03-16 05:35:14 +01:00
|
|
|
// Set up new conversation button set
|
2022-01-14 06:56:15 +01:00
|
|
|
binding.newConversationButtonSet.delegate = this
|
2020-07-16 04:49:37 +02:00
|
|
|
// Observe blocked contacts changed events
|
|
|
|
val broadcastReceiver = object : BroadcastReceiver() {
|
|
|
|
|
|
|
|
override fun onReceive(context: Context, intent: Intent) {
|
2022-01-14 06:56:15 +01:00
|
|
|
binding.recyclerView.adapter!!.notifyDataSetChanged()
|
2020-07-16 04:49:37 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
this.broadcastReceiver = broadcastReceiver
|
|
|
|
LocalBroadcastManager.getInstance(this).registerReceiver(broadcastReceiver, IntentFilter("blockedContactsChanged"))
|
2021-07-30 03:00:53 +02:00
|
|
|
lifecycleScope.launchWhenStarted {
|
2021-07-29 09:02:58 +02:00
|
|
|
launch(Dispatchers.IO) {
|
|
|
|
// Double check that the long poller is up
|
|
|
|
(applicationContext as ApplicationContext).startPollingIfNeeded()
|
|
|
|
// update things based on TextSecurePrefs (profile info etc)
|
|
|
|
// Set up typing observer
|
|
|
|
withContext(Dispatchers.Main) {
|
|
|
|
ApplicationContext.getInstance(this@HomeActivity).typingStatusRepository.typingThreads.observe(this@HomeActivity, Observer<Set<Long>> { threadIDs ->
|
2022-01-14 06:56:15 +01:00
|
|
|
val adapter = binding.recyclerView.adapter as HomeAdapter
|
2021-07-29 09:02:58 +02:00
|
|
|
adapter.typingThreadIDs = threadIDs ?: setOf()
|
|
|
|
})
|
|
|
|
updateProfileButton()
|
|
|
|
TextSecurePreferences.events.filter { it == TextSecurePreferences.PROFILE_NAME_PREF }.collect {
|
|
|
|
updateProfileButton()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Set up remaining components if needed
|
|
|
|
val application = ApplicationContext.getInstance(this@HomeActivity)
|
|
|
|
application.registerForFCMIfNeeded(false)
|
|
|
|
val userPublicKey = TextSecurePreferences.getLocalNumber(this@HomeActivity)
|
|
|
|
if (userPublicKey != null) {
|
|
|
|
OpenGroupManager.startPolling()
|
|
|
|
JobQueue.shared.resumePendingJobs()
|
|
|
|
}
|
2021-03-01 07:16:15 +01:00
|
|
|
}
|
|
|
|
}
|
2021-03-03 01:33:35 +01:00
|
|
|
EventBus.getDefault().register(this@HomeActivity)
|
2019-12-17 14:27:59 +01:00
|
|
|
}
|
2019-12-18 15:25:23 +01:00
|
|
|
|
2021-12-10 00:18:56 +01:00
|
|
|
override fun onCreateLoader(id: Int, bundle: Bundle?): Loader<Cursor> {
|
|
|
|
return HomeLoader(this@HomeActivity)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun onLoadFinished(loader: Loader<Cursor>, cursor: Cursor?) {
|
|
|
|
homeAdapter.changeCursor(cursor)
|
|
|
|
updateEmptyState()
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun onLoaderReset(cursor: Loader<Cursor>) {
|
|
|
|
homeAdapter.changeCursor(null)
|
|
|
|
}
|
|
|
|
|
2020-01-09 01:35:43 +01:00
|
|
|
override fun onResume() {
|
|
|
|
super.onResume()
|
2021-07-13 08:31:16 +02:00
|
|
|
ApplicationContext.getInstance(this).messageNotifier.setHomeScreenVisible(true)
|
2021-06-09 07:56:20 +02:00
|
|
|
if (TextSecurePreferences.getLocalNumber(this) == null) { return; } // This can be the case after a secondary device is auto-cleared
|
|
|
|
IdentityKeyUtil.checkUpdate(this)
|
2022-01-14 06:56:15 +01:00
|
|
|
binding.profileButton.recycle() // clear cached image before update tje profilePictureView
|
|
|
|
binding.profileButton.update()
|
2020-01-09 01:35:43 +01:00
|
|
|
val hasViewedSeed = TextSecurePreferences.getHasViewedSeed(this)
|
2021-02-18 05:12:30 +01:00
|
|
|
if (hasViewedSeed) {
|
2022-01-14 06:56:15 +01:00
|
|
|
binding.seedReminderStub.isVisible = false
|
2020-01-09 01:35:43 +01:00
|
|
|
}
|
2021-03-04 04:19:07 +01:00
|
|
|
if (TextSecurePreferences.getConfigurationMessageSynced(this)) {
|
2021-03-04 04:43:02 +01:00
|
|
|
lifecycleScope.launch(Dispatchers.IO) {
|
2021-07-09 05:01:16 +02:00
|
|
|
ConfigurationMessageUtilities.syncConfigurationIfNeeded(this@HomeActivity)
|
2021-03-04 04:43:02 +01:00
|
|
|
}
|
2021-03-04 04:19:07 +01:00
|
|
|
}
|
2021-01-13 06:13:49 +01:00
|
|
|
}
|
|
|
|
|
2021-07-13 08:31:16 +02:00
|
|
|
override fun onPause() {
|
|
|
|
super.onPause()
|
|
|
|
ApplicationContext.getInstance(this).messageNotifier.setHomeScreenVisible(false)
|
|
|
|
}
|
|
|
|
|
2020-03-12 01:16:07 +01:00
|
|
|
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
|
|
|
|
super.onActivityResult(requestCode, resultCode, data)
|
2020-08-18 00:55:17 +02:00
|
|
|
if (resultCode == CreateClosedGroupActivity.closedGroupCreatedResultCode) {
|
2020-03-12 05:57:53 +01:00
|
|
|
createNewPrivateChat()
|
2020-03-12 01:16:07 +01:00
|
|
|
}
|
|
|
|
}
|
2020-07-16 04:49:37 +02:00
|
|
|
|
|
|
|
override fun onDestroy() {
|
|
|
|
val broadcastReceiver = this.broadcastReceiver
|
|
|
|
if (broadcastReceiver != null) {
|
|
|
|
LocalBroadcastManager.getInstance(this).unregisterReceiver(broadcastReceiver)
|
|
|
|
}
|
|
|
|
super.onDestroy()
|
2021-03-03 01:33:35 +01:00
|
|
|
EventBus.getDefault().unregister(this)
|
2020-07-16 04:49:37 +02:00
|
|
|
}
|
2020-01-09 01:35:43 +01:00
|
|
|
// endregion
|
|
|
|
|
2020-04-20 03:54:56 +02:00
|
|
|
// region Updating
|
|
|
|
private fun updateEmptyState() {
|
2022-01-14 06:56:15 +01:00
|
|
|
val threadCount = (binding.recyclerView.adapter as HomeAdapter).itemCount
|
|
|
|
binding.emptyStateContainer.isVisible = threadCount == 0
|
2020-04-20 03:54:56 +02:00
|
|
|
}
|
2021-03-01 07:16:15 +01:00
|
|
|
|
2021-03-03 01:33:35 +01:00
|
|
|
@Subscribe(threadMode = ThreadMode.MAIN)
|
|
|
|
fun onUpdateProfileEvent(event: ProfilePictureModifiedEvent) {
|
|
|
|
if (event.recipient.isLocalNumber) {
|
|
|
|
updateProfileButton()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-01 07:16:15 +01:00
|
|
|
private fun updateProfileButton() {
|
2022-01-14 06:56:15 +01:00
|
|
|
binding.profileButton.publicKey = publicKey
|
|
|
|
binding.profileButton.displayName = TextSecurePreferences.getProfileName(this)
|
|
|
|
binding.profileButton.recycle()
|
|
|
|
binding.profileButton.update()
|
2021-03-01 07:16:15 +01:00
|
|
|
}
|
2020-04-20 03:54:56 +02:00
|
|
|
// endregion
|
|
|
|
|
|
|
|
// region Interaction
|
2020-01-09 01:35:43 +01:00
|
|
|
override fun handleSeedReminderViewContinueButtonTapped() {
|
|
|
|
val intent = Intent(this, SeedActivity::class.java)
|
|
|
|
show(intent)
|
|
|
|
}
|
|
|
|
|
2022-01-14 06:56:15 +01:00
|
|
|
override fun onConversationClick(thread: ThreadRecord) {
|
|
|
|
val intent = Intent(this, ConversationActivityV2::class.java)
|
|
|
|
intent.putExtra(ConversationActivityV2.THREAD_ID, thread.threadId)
|
|
|
|
push(intent)
|
2019-12-17 15:15:13 +01:00
|
|
|
}
|
|
|
|
|
2022-01-14 06:56:15 +01:00
|
|
|
override fun onLongConversationClick(thread: ThreadRecord) {
|
2020-07-16 03:58:11 +02:00
|
|
|
val bottomSheet = ConversationOptionsBottomSheet()
|
2021-12-10 00:18:56 +01:00
|
|
|
bottomSheet.thread = thread
|
2020-09-07 02:57:25 +02:00
|
|
|
bottomSheet.onViewDetailsTapped = {
|
|
|
|
bottomSheet.dismiss()
|
|
|
|
val userDetailsBottomSheet = UserDetailsBottomSheet()
|
2021-12-16 05:47:26 +01:00
|
|
|
val bundle = bundleOf(
|
|
|
|
UserDetailsBottomSheet.ARGUMENT_PUBLIC_KEY to thread.recipient.address.toString(),
|
|
|
|
UserDetailsBottomSheet.ARGUMENT_THREAD_ID to thread.threadId
|
|
|
|
)
|
2020-09-07 07:20:32 +02:00
|
|
|
userDetailsBottomSheet.arguments = bundle
|
2020-09-07 02:57:25 +02:00
|
|
|
userDetailsBottomSheet.show(supportFragmentManager, userDetailsBottomSheet.tag)
|
|
|
|
}
|
2020-08-21 07:06:39 +02:00
|
|
|
bottomSheet.onBlockTapped = {
|
|
|
|
bottomSheet.dismiss()
|
|
|
|
if (!thread.recipient.isBlocked) {
|
|
|
|
blockConversation(thread)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bottomSheet.onUnblockTapped = {
|
2020-07-16 03:58:11 +02:00
|
|
|
bottomSheet.dismiss()
|
|
|
|
if (thread.recipient.isBlocked) {
|
|
|
|
unblockConversation(thread)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bottomSheet.onDeleteTapped = {
|
|
|
|
bottomSheet.dismiss()
|
|
|
|
deleteConversation(thread)
|
|
|
|
}
|
2021-07-20 08:06:59 +02:00
|
|
|
bottomSheet.onSetMuteTapped = { muted ->
|
|
|
|
bottomSheet.dismiss()
|
|
|
|
setConversationMuted(thread, muted)
|
|
|
|
}
|
|
|
|
bottomSheet.onNotificationTapped = {
|
|
|
|
bottomSheet.dismiss()
|
|
|
|
NotificationUtils.showNotifyDialog(this, thread.recipient) { notifyType ->
|
|
|
|
setNotifyType(thread, notifyType)
|
|
|
|
}
|
|
|
|
}
|
2021-12-10 00:18:56 +01:00
|
|
|
bottomSheet.onPinTapped = {
|
|
|
|
bottomSheet.dismiss()
|
2022-01-14 06:56:15 +01:00
|
|
|
setConversationPinned(thread.threadId, true)
|
2021-12-10 00:18:56 +01:00
|
|
|
}
|
|
|
|
bottomSheet.onUnpinTapped = {
|
|
|
|
bottomSheet.dismiss()
|
2022-01-14 06:56:15 +01:00
|
|
|
setConversationPinned(thread.threadId, false)
|
2021-12-10 00:18:56 +01:00
|
|
|
}
|
2022-01-16 18:02:39 +01:00
|
|
|
bottomSheet.onMarkAllAsReadTapped = {
|
|
|
|
bottomSheet.dismiss()
|
|
|
|
markAllAsRead(thread)
|
|
|
|
}
|
2020-07-16 03:58:11 +02:00
|
|
|
bottomSheet.show(supportFragmentManager, bottomSheet.tag)
|
|
|
|
}
|
|
|
|
|
|
|
|
private fun blockConversation(thread: ThreadRecord) {
|
|
|
|
AlertDialog.Builder(this)
|
2021-03-03 01:33:35 +01:00
|
|
|
.setTitle(R.string.RecipientPreferenceActivity_block_this_contact_question)
|
|
|
|
.setMessage(R.string.RecipientPreferenceActivity_you_will_no_longer_receive_messages_and_calls_from_this_contact)
|
|
|
|
.setNegativeButton(android.R.string.cancel, null)
|
|
|
|
.setPositiveButton(R.string.RecipientPreferenceActivity_block) { dialog, _ ->
|
2022-01-14 06:56:15 +01:00
|
|
|
lifecycleScope.launch(Dispatchers.IO) {
|
2021-10-04 09:51:19 +02:00
|
|
|
recipientDatabase.setBlocked(thread.recipient, true)
|
2022-01-14 06:56:15 +01:00
|
|
|
withContext(Dispatchers.Main) {
|
|
|
|
binding.recyclerView.adapter!!.notifyDataSetChanged()
|
2021-03-03 01:33:35 +01:00
|
|
|
dialog.dismiss()
|
|
|
|
}
|
2020-07-16 03:58:11 +02:00
|
|
|
}
|
2021-03-03 01:33:35 +01:00
|
|
|
}.show()
|
2020-07-16 03:58:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private fun unblockConversation(thread: ThreadRecord) {
|
|
|
|
AlertDialog.Builder(this)
|
2021-03-03 01:33:35 +01:00
|
|
|
.setTitle(R.string.RecipientPreferenceActivity_unblock_this_contact_question)
|
|
|
|
.setMessage(R.string.RecipientPreferenceActivity_you_will_once_again_be_able_to_receive_messages_and_calls_from_this_contact)
|
|
|
|
.setNegativeButton(android.R.string.cancel, null)
|
|
|
|
.setPositiveButton(R.string.RecipientPreferenceActivity_unblock) { dialog, _ ->
|
2022-01-14 06:56:15 +01:00
|
|
|
lifecycleScope.launch(Dispatchers.IO) {
|
2021-10-04 09:51:19 +02:00
|
|
|
recipientDatabase.setBlocked(thread.recipient, false)
|
2022-01-14 06:56:15 +01:00
|
|
|
withContext(Dispatchers.Main) {
|
|
|
|
binding.recyclerView.adapter!!.notifyDataSetChanged()
|
2021-03-03 01:33:35 +01:00
|
|
|
dialog.dismiss()
|
|
|
|
}
|
2020-07-16 03:58:11 +02:00
|
|
|
}
|
2021-03-03 01:33:35 +01:00
|
|
|
}.show()
|
2020-07-16 03:58:11 +02:00
|
|
|
}
|
|
|
|
|
2021-07-20 08:06:59 +02:00
|
|
|
private fun setConversationMuted(thread: ThreadRecord, isMuted: Boolean) {
|
|
|
|
if (!isMuted) {
|
2022-01-14 06:56:15 +01:00
|
|
|
lifecycleScope.launch(Dispatchers.IO) {
|
2021-10-04 09:51:19 +02:00
|
|
|
recipientDatabase.setMuted(thread.recipient, 0)
|
2022-01-14 06:56:15 +01:00
|
|
|
withContext(Dispatchers.Main) {
|
|
|
|
binding.recyclerView.adapter!!.notifyDataSetChanged()
|
2021-07-20 08:06:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
MuteDialog.show(this) { until: Long ->
|
2022-01-14 06:56:15 +01:00
|
|
|
lifecycleScope.launch(Dispatchers.IO) {
|
2021-10-04 09:51:19 +02:00
|
|
|
recipientDatabase.setMuted(thread.recipient, until)
|
2022-01-14 06:56:15 +01:00
|
|
|
withContext(Dispatchers.Main) {
|
|
|
|
binding.recyclerView.adapter!!.notifyDataSetChanged()
|
2021-07-20 08:06:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private fun setNotifyType(thread: ThreadRecord, newNotifyType: Int) {
|
2022-01-14 06:56:15 +01:00
|
|
|
lifecycleScope.launch(Dispatchers.IO) {
|
2021-10-04 09:51:19 +02:00
|
|
|
recipientDatabase.setNotifyType(thread.recipient, newNotifyType)
|
2022-01-14 06:56:15 +01:00
|
|
|
withContext(Dispatchers.Main) {
|
|
|
|
binding.recyclerView.adapter!!.notifyDataSetChanged()
|
2021-07-20 08:06:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-14 06:56:15 +01:00
|
|
|
private fun setConversationPinned(threadId: Long, pinned: Boolean) {
|
|
|
|
lifecycleScope.launch(Dispatchers.IO) {
|
|
|
|
threadDb.setPinned(threadId, pinned)
|
|
|
|
withContext(Dispatchers.Main) {
|
|
|
|
LoaderManager.getInstance(this@HomeActivity).restartLoader(0, null, this@HomeActivity)
|
2021-12-10 00:18:56 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-16 18:02:39 +01:00
|
|
|
private fun markAllAsRead(thread: ThreadRecord) {
|
|
|
|
ThreadUtils.queue {
|
|
|
|
threadDb.markAllAsRead(thread.threadId, thread.recipient.isOpenGroupRecipient)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-16 03:58:11 +02:00
|
|
|
private fun deleteConversation(thread: ThreadRecord) {
|
|
|
|
val threadID = thread.threadId
|
|
|
|
val recipient = thread.recipient
|
2022-01-14 06:56:15 +01:00
|
|
|
val message = if (recipient.isGroupRecipient) {
|
2021-10-04 09:51:19 +02:00
|
|
|
val group = groupDatabase.getGroup(recipient.address.toString()).orNull()
|
2021-01-15 05:36:30 +01:00
|
|
|
if (group != null && group.admins.map { it.toString() }.contains(TextSecurePreferences.getLocalNumber(this))) {
|
2022-01-14 06:56:15 +01:00
|
|
|
"Because you are the creator of this group it will be deleted for everyone. This cannot be undone."
|
2021-01-13 06:13:49 +01:00
|
|
|
} else {
|
2022-01-14 06:56:15 +01:00
|
|
|
resources.getString(R.string.activity_home_leave_group_dialog_message)
|
2021-01-13 06:13:49 +01:00
|
|
|
}
|
|
|
|
} else {
|
2022-01-14 06:56:15 +01:00
|
|
|
resources.getString(R.string.activity_home_delete_conversation_dialog_message)
|
2021-01-13 06:13:49 +01:00
|
|
|
}
|
2020-07-16 03:58:11 +02:00
|
|
|
val dialog = AlertDialog.Builder(this)
|
2021-05-14 05:13:02 +02:00
|
|
|
dialog.setMessage(message)
|
2021-03-03 01:33:35 +01:00
|
|
|
dialog.setPositiveButton(R.string.yes) { _, _ ->
|
|
|
|
lifecycleScope.launch(Dispatchers.Main) {
|
|
|
|
val context = this@HomeActivity as Context
|
2021-05-14 05:13:02 +02:00
|
|
|
// Cancel any outstanding jobs
|
2021-10-04 09:51:19 +02:00
|
|
|
DatabaseComponent.get(context).sessionJobDatabase().cancelPendingMessageSendJobs(threadID)
|
2021-03-03 01:33:35 +01:00
|
|
|
// Send a leave group message if this is an active closed group
|
2021-10-04 09:51:19 +02:00
|
|
|
if (recipient.address.isClosedGroup && DatabaseComponent.get(context).groupDatabase().isActive(recipient.address.toGroupString())) {
|
2021-03-03 01:33:35 +01:00
|
|
|
var isClosedGroup: Boolean
|
|
|
|
var groupPublicKey: String?
|
|
|
|
try {
|
|
|
|
groupPublicKey = GroupUtil.doubleDecodeGroupID(recipient.address.toString()).toHexString()
|
2021-10-04 09:51:19 +02:00
|
|
|
isClosedGroup = DatabaseComponent.get(context).lokiAPIDatabase().isClosedGroup(groupPublicKey)
|
2021-03-03 01:33:35 +01:00
|
|
|
} catch (e: IOException) {
|
|
|
|
groupPublicKey = null
|
|
|
|
isClosedGroup = false
|
|
|
|
}
|
|
|
|
if (isClosedGroup) {
|
2021-03-26 05:46:37 +01:00
|
|
|
MessageSender.explicitLeave(groupPublicKey!!, false)
|
2021-03-03 01:33:35 +01:00
|
|
|
}
|
2020-07-16 03:58:11 +02:00
|
|
|
}
|
2021-05-14 05:13:02 +02:00
|
|
|
// Delete the conversation
|
2021-10-04 09:51:19 +02:00
|
|
|
val v2OpenGroup = DatabaseComponent.get(this@HomeActivity).lokiThreadDatabase().getOpenGroupChat(threadID)
|
2021-05-21 07:02:34 +02:00
|
|
|
if (v2OpenGroup != null) {
|
2021-05-19 03:12:29 +02:00
|
|
|
OpenGroupManager.delete(v2OpenGroup.server, v2OpenGroup.room, this@HomeActivity)
|
2021-05-14 05:13:02 +02:00
|
|
|
} else {
|
2022-01-14 06:56:15 +01:00
|
|
|
lifecycleScope.launch(Dispatchers.IO) {
|
2021-10-04 09:51:19 +02:00
|
|
|
threadDb.deleteConversation(threadID)
|
2021-05-20 05:35:43 +02:00
|
|
|
}
|
2020-07-16 03:58:11 +02:00
|
|
|
}
|
2021-05-14 05:13:02 +02:00
|
|
|
// Update the badge count
|
|
|
|
ApplicationContext.getInstance(context).messageNotifier.updateNotification(context)
|
2021-03-03 01:33:35 +01:00
|
|
|
// Notify the user
|
|
|
|
val toastMessage = if (recipient.isGroupRecipient) R.string.MessageRecord_left_group else R.string.activity_home_conversation_deleted_message
|
|
|
|
Toast.makeText(context, toastMessage, Toast.LENGTH_LONG).show()
|
|
|
|
}
|
|
|
|
}
|
2020-07-16 03:58:11 +02:00
|
|
|
dialog.setNegativeButton(R.string.no) { _, _ ->
|
|
|
|
// Do nothing
|
|
|
|
}
|
|
|
|
dialog.create().show()
|
2019-12-17 15:15:13 +01:00
|
|
|
}
|
|
|
|
|
2020-01-06 02:07:55 +01:00
|
|
|
private fun openSettings() {
|
2020-01-06 04:26:52 +01:00
|
|
|
val intent = Intent(this, SettingsActivity::class.java)
|
2021-03-01 07:16:15 +01:00
|
|
|
show(intent, isForResult = true)
|
2020-01-06 02:07:55 +01:00
|
|
|
}
|
|
|
|
|
2020-05-28 08:43:37 +02:00
|
|
|
private fun showPath() {
|
|
|
|
val intent = Intent(this, PathActivity::class.java)
|
|
|
|
show(intent)
|
|
|
|
}
|
|
|
|
|
2020-03-12 05:57:53 +01:00
|
|
|
override fun createNewPrivateChat() {
|
2019-12-18 15:25:23 +01:00
|
|
|
val intent = Intent(this, CreatePrivateChatActivity::class.java)
|
2020-01-08 05:16:34 +01:00
|
|
|
show(intent)
|
2019-12-17 15:15:13 +01:00
|
|
|
}
|
2019-12-18 15:25:23 +01:00
|
|
|
|
2020-03-12 05:57:53 +01:00
|
|
|
override fun createNewClosedGroup() {
|
2020-01-31 03:57:24 +01:00
|
|
|
val intent = Intent(this, CreateClosedGroupActivity::class.java)
|
2020-03-12 01:16:07 +01:00
|
|
|
show(intent, true)
|
2020-01-31 03:57:24 +01:00
|
|
|
}
|
|
|
|
|
2020-03-12 05:57:53 +01:00
|
|
|
override fun joinOpenGroup() {
|
2019-12-18 15:25:23 +01:00
|
|
|
val intent = Intent(this, JoinPublicChatActivity::class.java)
|
2020-01-08 05:16:34 +01:00
|
|
|
show(intent)
|
2019-12-18 15:25:23 +01:00
|
|
|
}
|
|
|
|
// endregion
|
2021-05-20 07:41:16 +02:00
|
|
|
}
|