TheArchive/session-android
1
0
Fork 0
mirror of https://github.com/oxen-io/session-android.git synced 2025-12-03 12:32:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Clean

Browse Source
This commit is contained in:
nielsandriesse
2020-05-11 16:54:31 +10:00
parent ed2ab2d78a
commit 8e53383ab9
49 changed files with 188 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/org/thoughtcrime/securesms/loki/activities/HomeActivity.kt
View File

@@ -31,8 +31,9 @@ import org.thoughtcrime.securesms.conversation.ConversationActivity
import org.thoughtcrime.securesms.database.DatabaseFactory
import org.thoughtcrime.securesms.database.ThreadDatabase
import org.thoughtcrime.securesms.database.model.ThreadRecord
import org.thoughtcrime.securesms.loki.getColorWithID
import org.thoughtcrime.securesms.loki.dialogs.PNModeBottomSheet
import org.thoughtcrime.securesms.loki.getColorWithID
import org.thoughtcrime.securesms.loki.protocol.ClosedGroupsProtocol
import org.thoughtcrime.securesms.loki.utilities.push
import org.thoughtcrime.securesms.loki.utilities.show
import org.thoughtcrime.securesms.loki.views.ConversationView
@@ -41,7 +42,6 @@ import org.thoughtcrime.securesms.loki.views.SeedReminderViewDelegate
import org.thoughtcrime.securesms.mms.GlideApp
import org.thoughtcrime.securesms.mms.GlideRequests
import org.thoughtcrime.securesms.notifications.MessageNotifier
import org.thoughtcrime.securesms.util.GroupUtil
import org.thoughtcrime.securesms.util.TextSecurePreferences
import kotlin.math.abs
@@ -272,7 +272,7 @@ class HomeActivity : PassphraseRequiredActionBarActivity, ConversationClickListe
val isClosedGroup = recipient.address.isClosedGroup
// Send a leave group message if this is an active closed group
if (isClosedGroup && DatabaseFactory.getGroupDatabase(activity).isActive(recipient.address.toGroupString())) {
if (!GroupUtil.leaveGroup(activity, recipient)) {
if (!ClosedGroupsProtocol.leaveGroup(activity, recipient)) {
Toast.makeText(activity, "Couldn't leave group", Toast.LENGTH_LONG).show()
clearView(activity.recyclerView, viewHolder)
return@setPositiveButton

14
src/org/thoughtcrime/securesms/loki/activities/LinkedDevicesLoader.kt
View File

@@ -6,8 +6,8 @@ import org.thoughtcrime.securesms.devicelist.Device
import org.thoughtcrime.securesms.loki.utilities.MnemonicUtilities
import org.thoughtcrime.securesms.util.AsyncLoader
import org.thoughtcrime.securesms.util.TextSecurePreferences
import org.whispersystems.signalservice.loki.protocol.multidevice.LokiDeviceLinkUtilities
import org.whispersystems.signalservice.loki.crypto.MnemonicCodec
import org.whispersystems.signalservice.loki.protocol.multidevice.MultiDeviceProtocol
import java.io.File
class LinkedDevicesLoader(context: Context) : AsyncLoader<List<Device>>(context) {
@@ -19,12 +19,12 @@ class LinkedDevicesLoader(context: Context) : AsyncLoader<List<Device>>(context)
override fun loadInBackground(): List<Device>? {
try {
val userHexEncodedPublicKey = TextSecurePreferences.getLocalNumber(context)
val slaveDeviceHexEncodedPublicKeys = LokiDeviceLinkUtilities.getSlaveHexEncodedPublicKeys(userHexEncodedPublicKey).get()
return slaveDeviceHexEncodedPublicKeys.map { hexEncodedPublicKey ->
val shortID = MnemonicUtilities.getFirst3Words(mnemonicCodec, hexEncodedPublicKey)
val name = DatabaseFactory.getLokiUserDatabase(context).getDisplayName(hexEncodedPublicKey)
Device(hexEncodedPublicKey, shortID, name)
val userPublicKey = TextSecurePreferences.getLocalNumber(context)
val slaveDevices = MultiDeviceProtocol.shared.getSlaveDevices(userPublicKey)
return slaveDevices.map { device ->
val shortID = MnemonicUtilities.getFirst3Words(mnemonicCodec, device)
val name = DatabaseFactory.getLokiUserDatabase(context).getDisplayName(device)
Device(device, shortID, name)
}.sortedBy { it.name }
} catch (e: Exception) {
return null

2
src/org/thoughtcrime/securesms/loki/api/LokiPublicChatPoller.kt
View File

@@ -205,7 +205,7 @@ class LokiPublicChatPoller(private val context: Context, private val group: Loki
}
// If we got a message from our master device then make sure our mapping stays in sync
val recipient = Recipient.from(context, Address.fromSerialized(message.hexEncodedPublicKey), false)
if (recipient.isOurMasterDevice && message.profilePicture != null) {
if (recipient.isUserMasterDevice && message.profilePicture != null) {
val profileKey = message.profilePicture!!.profileKey
val url = message.profilePicture!!.url
if (recipient.profileKey == null || !MessageDigest.isEqual(recipient.profileKey, profileKey)) {

8
src/org/thoughtcrime/securesms/loki/protocol/ClosedGroupsProtocol.kt
View File

@@ -11,18 +11,18 @@ import org.thoughtcrime.securesms.util.TextSecurePreferences
object ClosedGroupsProtocol {
fun leaveGroup(context: Context, recipient: Recipient): Boolean {
if (!recipient.address.isClosedGroup) { return true }
if (!recipient.address.isClosedGroup) { return true }
val threadID = DatabaseFactory.getThreadDatabase(context).getThreadIdFor(recipient)
val message = GroupUtil.createGroupLeaveMessage(context, recipient)
if (threadID < 0 || !message.isPresent) { return false }
MessageSender.send(context, message.get(), threadID, false, null)
// Remove the *master* device from the group
val masterHexPublicKey = TextSecurePreferences.getMasterHexEncodedPublicKey(context)
val userPublicKey = masterHexPublicKey ?: TextSecurePreferences.getLocalNumber(context)
val masterPublicKey = TextSecurePreferences.getMasterHexEncodedPublicKey(context)
val publicKeyToUse = masterPublicKey ?: TextSecurePreferences.getLocalNumber(context)
val groupDatabase = DatabaseFactory.getGroupDatabase(context)
val groupID = recipient.address.toGroupString()
groupDatabase.setActive(groupID, false)
groupDatabase.remove(groupID, Address.fromSerialized(userPublicKey))
groupDatabase.remove(groupID, Address.fromSerialized(publicKeyToUse))
return true
}
}

25
src/org/thoughtcrime/securesms/loki/protocol/SessionManagementProtocol.kt Normal file
View File

@@ -0,0 +1,25 @@
package org.thoughtcrime.securesms.loki.protocol
import android.content.Context
import android.util.Log
import org.thoughtcrime.securesms.ApplicationContext
import org.thoughtcrime.securesms.crypto.IdentityKeyUtil
import org.thoughtcrime.securesms.crypto.PreKeyUtil
import org.thoughtcrime.securesms.jobs.CleanPreKeysJob
import org.thoughtcrime.securesms.util.TextSecurePreferences
object SessionManagementProtocol {
@JvmStatic
fun refreshSignedPreKey(context: Context) {
if (TextSecurePreferences.isSignedPreKeyRegistered(context)) {
Log.d("Loki", "Skipping signed pre key refresh; using existing signed pre key.")
} else {
Log.d("Loki", "Signed pre key refreshed successfully.")
val identityKeyPair = IdentityKeyUtil.getIdentityKeyPair(context)
PreKeyUtil.generateSignedPreKey(context, identityKeyPair, true)
TextSecurePreferences.setSignedPreKeyRegistered(context, true)
ApplicationContext.getInstance(context).jobManager.add(CleanPreKeysJob())
}
}
}

38
src/org/thoughtcrime/securesms/loki/protocol/SessionMetaProtocol.kt Normal file
View File

@@ -0,0 +1,38 @@
package org.thoughtcrime.securesms.loki.protocol
import android.content.Context
import org.thoughtcrime.securesms.database.Address
import org.thoughtcrime.securesms.database.DatabaseFactory
import org.thoughtcrime.securesms.recipients.Recipient
import org.whispersystems.signalservice.loki.protocol.multidevice.MultiDeviceProtocol
import org.whispersystems.signalservice.loki.protocol.todo.LokiThreadFriendRequestStatus
object SessionMetaProtocol {
@JvmStatic
fun canUserReplyToNotification(recipient: Recipient, context: Context): Boolean {
val isGroup = recipient.isGroupRecipient
if (isGroup) { return !recipient.address.isRSSFeed }
val linkedDevices = MultiDeviceProtocol.shared.getAllLinkedDevices(recipient.address.serialize())
return linkedDevices.any { device ->
val recipient = Recipient.from(context, Address.fromSerialized(device), false)
val threadID = DatabaseFactory.getThreadDatabase(context).getThreadIdFor(recipient)
DatabaseFactory.getLokiThreadDatabase(context).getFriendRequestStatus(threadID) == LokiThreadFriendRequestStatus.FRIENDS
}
}
@JvmStatic
fun shouldSendReadReceipt(publicKey: String, context: Context): Boolean {
val recipient = Recipient.from(context, Address.fromSerialized(publicKey),false)
val threadID = DatabaseFactory.getThreadDatabase(context).getThreadIdFor(recipient)
return DatabaseFactory.getLokiThreadDatabase(context).getFriendRequestStatus(threadID) == LokiThreadFriendRequestStatus.FRIENDS
}
@JvmStatic
fun shouldSendTypingIndicator(recipient: Recipient, context: Context): Boolean {
if (recipient.isGroupRecipient) { return false }
val recipient = Recipient.from(context, Address.fromSerialized(recipient.address.serialize()),false)
val threadID = DatabaseFactory.getThreadDatabase(context).getThreadIdFor(recipient)
return DatabaseFactory.getLokiThreadDatabase(context).getFriendRequestStatus(threadID) == LokiThreadFriendRequestStatus.FRIENDS
}
}

11
src/org/thoughtcrime/securesms/loki/protocol/SyncMessagesProtocol.kt Normal file
View File

@@ -0,0 +1,11 @@
package org.thoughtcrime.securesms.loki.protocol
import org.thoughtcrime.securesms.database.Address
object SyncMessagesProtocol {
@JvmStatic
fun shouldSyncReadReceipt(address: Address): Boolean {
return !address.isOpenGroup
}
}

18
src/org/thoughtcrime/securesms/loki/utilities/NotificationUtilities.kt Normal file
View File

@@ -0,0 +1,18 @@
@file:JvmName("NotificationUtilities")
package org.thoughtcrime.securesms.loki.utilities
import android.content.Context
import org.thoughtcrime.securesms.database.DatabaseFactory
import org.thoughtcrime.securesms.recipients.Recipient
fun getOpenGroupDisplayName(recipient: Recipient, threadRecipient: Recipient, context: Context): String {
val threadID = DatabaseFactory.getThreadDatabase(context).getThreadIdFor(threadRecipient)
val publicChat = DatabaseFactory.getLokiThreadDatabase(context).getPublicChat(threadID)
val hexEncodedPublicKey = recipient.address.toString()
val displayName = if (publicChat != null) {
DatabaseFactory.getLokiUserDatabase(context).getServerDisplayName(publicChat.id, hexEncodedPublicKey)
} else {
DatabaseFactory.getLokiUserDatabase(context).getDisplayName(hexEncodedPublicKey)
}
return displayName ?: hexEncodedPublicKey
}