2021-01-13 07:11:30 +01:00
|
|
|
package org.thoughtcrime.securesms.database
|
|
|
|
|
|
|
|
import android.content.Context
|
|
|
|
import android.net.Uri
|
|
|
|
import com.google.protobuf.ByteString
|
|
|
|
import org.session.libsession.messaging.StorageProtocol
|
|
|
|
import org.session.libsession.messaging.jobs.AttachmentUploadJob
|
|
|
|
import org.session.libsession.messaging.jobs.Job
|
2021-01-28 05:24:27 +01:00
|
|
|
import org.session.libsession.messaging.jobs.JobQueue
|
2021-01-13 07:11:30 +01:00
|
|
|
import org.session.libsession.messaging.jobs.MessageSendJob
|
|
|
|
import org.session.libsession.messaging.messages.visible.Attachment
|
|
|
|
import org.session.libsession.messaging.messages.visible.VisibleMessage
|
|
|
|
import org.session.libsession.messaging.opengroups.OpenGroup
|
|
|
|
import org.session.libsession.messaging.sending_receiving.attachments.AttachmentId
|
2021-02-11 05:00:27 +01:00
|
|
|
import org.session.libsession.messaging.sending_receiving.attachments.PointerAttachment
|
|
|
|
import org.session.libsession.messaging.sending_receiving.attachments.SessionServiceAttachment
|
2021-01-13 07:11:30 +01:00
|
|
|
import org.session.libsession.messaging.sending_receiving.linkpreview.LinkPreview
|
|
|
|
import org.session.libsession.messaging.sending_receiving.quotes.QuoteModel
|
|
|
|
import org.session.libsession.messaging.threads.Address
|
|
|
|
import org.session.libsession.messaging.threads.GroupRecord
|
|
|
|
import org.session.libsession.messaging.threads.recipients.Recipient
|
2021-01-18 23:12:44 +01:00
|
|
|
import org.session.libsession.utilities.GroupUtil
|
2021-01-19 07:06:02 +01:00
|
|
|
import org.session.libsession.utilities.TextSecurePreferences
|
2021-01-14 01:42:26 +01:00
|
|
|
import org.session.libsignal.libsignal.ecc.ECKeyPair
|
2021-01-13 07:11:30 +01:00
|
|
|
import org.session.libsignal.libsignal.util.KeyHelper
|
|
|
|
import org.session.libsignal.libsignal.util.guava.Optional
|
2021-01-19 07:06:02 +01:00
|
|
|
import org.session.libsignal.service.api.messages.SignalServiceAttachment
|
2021-01-13 07:11:30 +01:00
|
|
|
import org.session.libsignal.service.api.messages.SignalServiceAttachmentPointer
|
|
|
|
import org.session.libsignal.service.api.messages.SignalServiceGroup
|
|
|
|
import org.session.libsignal.service.internal.push.SignalServiceProtos
|
2021-02-08 06:44:26 +01:00
|
|
|
import org.session.libsignal.service.loki.api.opengroups.PublicChat
|
2021-02-11 05:00:27 +01:00
|
|
|
import org.session.libsignal.utilities.logging.Log
|
2021-01-13 07:11:30 +01:00
|
|
|
import org.thoughtcrime.securesms.crypto.IdentityKeyUtil
|
2021-01-14 03:26:53 +01:00
|
|
|
import org.thoughtcrime.securesms.database.helpers.SQLCipherOpenHelper
|
|
|
|
import org.thoughtcrime.securesms.loki.database.LokiThreadDatabase
|
2021-02-16 05:24:21 +01:00
|
|
|
import org.thoughtcrime.securesms.loki.protocol.SessionMetaProtocol
|
2021-02-09 03:16:33 +01:00
|
|
|
import org.thoughtcrime.securesms.loki.utilities.OpenGroupUtilities
|
2021-01-14 03:26:53 +01:00
|
|
|
import org.thoughtcrime.securesms.loki.utilities.get
|
|
|
|
import org.thoughtcrime.securesms.loki.utilities.getString
|
2021-01-19 07:06:02 +01:00
|
|
|
import org.thoughtcrime.securesms.mms.IncomingMediaMessage
|
2021-01-13 07:11:30 +01:00
|
|
|
import org.thoughtcrime.securesms.mms.OutgoingGroupMediaMessage
|
2021-02-11 05:00:27 +01:00
|
|
|
import org.thoughtcrime.securesms.mms.OutgoingMediaMessage
|
2021-01-13 07:11:30 +01:00
|
|
|
import org.thoughtcrime.securesms.mms.PartAuthority
|
|
|
|
import org.thoughtcrime.securesms.sms.IncomingGroupMessage
|
|
|
|
import org.thoughtcrime.securesms.sms.IncomingTextMessage
|
2021-02-11 05:00:27 +01:00
|
|
|
import org.thoughtcrime.securesms.sms.OutgoingTextMessage
|
2021-01-13 07:11:30 +01:00
|
|
|
|
2021-01-14 03:26:53 +01:00
|
|
|
class Storage(context: Context, helper: SQLCipherOpenHelper) : Database(context, helper), StorageProtocol {
|
2021-01-13 07:11:30 +01:00
|
|
|
override fun getUserPublicKey(): String? {
|
|
|
|
return TextSecurePreferences.getLocalNumber(context)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getUserKeyPair(): Pair<String, ByteArray>? {
|
|
|
|
val userPublicKey = TextSecurePreferences.getLocalNumber(context) ?: return null
|
|
|
|
val userPrivateKey = IdentityKeyUtil.getIdentityKeyPair(context).privateKey.serialize()
|
|
|
|
return Pair(userPublicKey, userPrivateKey)
|
|
|
|
}
|
|
|
|
|
2021-01-14 01:42:26 +01:00
|
|
|
override fun getUserX25519KeyPair(): ECKeyPair {
|
|
|
|
return DatabaseFactory.getLokiAPIDatabase(context).getUserX25519KeyPair()
|
|
|
|
}
|
|
|
|
|
2021-01-13 07:11:30 +01:00
|
|
|
override fun getUserDisplayName(): String? {
|
|
|
|
return TextSecurePreferences.getProfileName(context)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getUserProfileKey(): ByteArray? {
|
|
|
|
val profileKey = TextSecurePreferences.getProfileKey(context) ?: return null
|
|
|
|
return profileKey.toByteArray()
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getUserProfilePictureURL(): String? {
|
|
|
|
return TextSecurePreferences.getProfilePictureURL(context)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getProfileKeyForRecipient(recipientPublicKey: String): ByteArray? {
|
|
|
|
val address = Address.fromSerialized(recipientPublicKey)
|
|
|
|
val recipient = Recipient.from(context, address, false)
|
|
|
|
return recipient.profileKey
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getOrGenerateRegistrationID(): Int {
|
|
|
|
var registrationID = TextSecurePreferences.getLocalRegistrationId(context)
|
|
|
|
if (registrationID == null) {
|
|
|
|
registrationID = KeyHelper.generateRegistrationId(false)
|
|
|
|
TextSecurePreferences.setLocalRegistrationId(context, registrationID)
|
|
|
|
}
|
|
|
|
return registrationID
|
|
|
|
}
|
|
|
|
|
2021-01-29 01:16:53 +01:00
|
|
|
override fun persistAttachments(messageId: Long, attachments: List<Attachment>): List<Long> {
|
|
|
|
val database = DatabaseFactory.getAttachmentDatabase(context)
|
|
|
|
val databaseAttachments = attachments.map { it.toDatabaseAttachment() }
|
|
|
|
return database.insertAttachments(messageId, databaseAttachments)
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun persist(message: VisibleMessage, quotes: QuoteModel?, linkPreview: List<LinkPreview?>, groupPublicKey: String?, openGroupID: String?): Long? {
|
2021-01-19 07:06:02 +01:00
|
|
|
var messageID: Long? = null
|
2021-02-11 05:00:27 +01:00
|
|
|
val senderAddress = Address.fromSerialized(message.sender!!)
|
|
|
|
val senderRecipient = Recipient.from(context, senderAddress, false)
|
2021-01-19 07:06:02 +01:00
|
|
|
var group: Optional<SignalServiceGroup> = Optional.absent()
|
|
|
|
if (openGroupID != null) {
|
|
|
|
group = Optional.of(SignalServiceGroup(openGroupID.toByteArray(), SignalServiceGroup.GroupType.PUBLIC_CHAT))
|
|
|
|
} else if (groupPublicKey != null) {
|
|
|
|
group = Optional.of(SignalServiceGroup(groupPublicKey.toByteArray(), SignalServiceGroup.GroupType.SIGNAL))
|
|
|
|
}
|
|
|
|
if (message.isMediaMessage()) {
|
|
|
|
val quote: Optional<QuoteModel> = if (quotes != null) Optional.of(quotes) else Optional.absent()
|
|
|
|
val linkPreviews: Optional<List<LinkPreview>> = if (linkPreview.isEmpty()) Optional.absent() else Optional.of(linkPreview.mapNotNull { it!! })
|
|
|
|
val mmsDatabase = DatabaseFactory.getMmsDatabase(context)
|
|
|
|
mmsDatabase.beginTransaction()
|
2021-02-11 05:00:27 +01:00
|
|
|
val insertResult = if (message.sender == getUserPublicKey()) {
|
|
|
|
val targetAddress = if (message.syncTarget != null) {
|
|
|
|
Address.fromSerialized(message.syncTarget!!)
|
|
|
|
} else {
|
|
|
|
if (group.isPresent) {
|
|
|
|
Address.fromSerialized(GroupUtil.getEncodedId(group.get()))
|
|
|
|
} else {
|
|
|
|
Log.d("Loki", "Cannot handle message from self.")
|
|
|
|
return null
|
|
|
|
}
|
|
|
|
}
|
|
|
|
val attachments = message.attachmentIDs.mapNotNull {
|
|
|
|
DatabaseFactory.getAttachmentProvider(context).getSignalAttachmentPointer(it)
|
|
|
|
}.mapNotNull {
|
|
|
|
PointerAttachment.forPointer(Optional.of(it)).orNull()
|
|
|
|
}
|
|
|
|
val mediaMessage = OutgoingMediaMessage.from(message, Recipient.from(context, targetAddress, false), attachments, quote.orNull(), linkPreviews.orNull())
|
|
|
|
mmsDatabase.insertSecureDecryptedMessageOutbox(mediaMessage, message.threadID ?: -1, message.sentTimestamp!!)
|
2021-01-19 07:06:02 +01:00
|
|
|
} else {
|
2021-02-11 05:00:27 +01:00
|
|
|
// It seems like we have replaced SignalServiceAttachment with SessionServiceAttachment
|
|
|
|
val attachments: Optional<List<SignalServiceAttachment>> = Optional.of(message.attachmentIDs.mapNotNull {
|
|
|
|
DatabaseFactory.getAttachmentProvider(context).getSignalAttachmentPointer(it)
|
|
|
|
})
|
|
|
|
val mediaMessage = IncomingMediaMessage.from(message, senderAddress, senderRecipient.expireMessages * 1000L, group, attachments, quote, linkPreviews)
|
|
|
|
if (group.isPresent) {
|
|
|
|
mmsDatabase.insertSecureDecryptedMessageInbox(mediaMessage, message.threadID ?: -1, message.sentTimestamp!!)
|
|
|
|
} else {
|
|
|
|
mmsDatabase.insertSecureDecryptedMessageInbox(mediaMessage, message.threadID ?: -1)
|
|
|
|
}
|
2021-01-19 07:06:02 +01:00
|
|
|
}
|
|
|
|
if (insertResult.isPresent) {
|
|
|
|
mmsDatabase.setTransactionSuccessful()
|
|
|
|
messageID = insertResult.get().messageId
|
|
|
|
}
|
|
|
|
mmsDatabase.endTransaction()
|
|
|
|
} else {
|
|
|
|
val smsDatabase = DatabaseFactory.getSmsDatabase(context)
|
2021-02-11 05:00:27 +01:00
|
|
|
val insertResult = if (message.sender == getUserPublicKey()) {
|
|
|
|
val targetAddress = if (message.syncTarget != null) {
|
|
|
|
Address.fromSerialized(message.syncTarget!!)
|
|
|
|
} else {
|
|
|
|
if (group.isPresent) {
|
|
|
|
Address.fromSerialized(GroupUtil.getEncodedId(group.get()))
|
|
|
|
} else {
|
|
|
|
Log.d("Loki", "Cannot handle message from self.")
|
|
|
|
return null
|
|
|
|
}
|
|
|
|
}
|
|
|
|
val textMessage = OutgoingTextMessage.from(message, Recipient.from(context, targetAddress, false))
|
|
|
|
smsDatabase.insertMessageOutbox(message.threadID ?: -1, textMessage, message.sentTimestamp!!)
|
|
|
|
} else {
|
|
|
|
val textMessage = IncomingTextMessage.from(message, senderAddress, group, senderRecipient.expireMessages * 1000L)
|
|
|
|
if (group.isPresent) {
|
|
|
|
smsDatabase.insertMessageInbox(textMessage, message.sentTimestamp!!)
|
|
|
|
} else {
|
|
|
|
smsDatabase.insertMessageInbox(textMessage)
|
|
|
|
}
|
|
|
|
}
|
2021-01-19 07:06:02 +01:00
|
|
|
if (insertResult.isPresent) {
|
|
|
|
messageID = insertResult.get().messageId
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return messageID
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
2021-01-28 05:24:27 +01:00
|
|
|
// JOBS
|
2021-01-29 01:16:53 +01:00
|
|
|
override fun persistJob(job: Job) {
|
2021-01-28 05:24:27 +01:00
|
|
|
DatabaseFactory.getSessionJobDatabase(context).persistJob(job)
|
|
|
|
}
|
|
|
|
|
2021-01-13 07:11:30 +01:00
|
|
|
override fun markJobAsSucceeded(job: Job) {
|
2021-01-28 05:24:27 +01:00
|
|
|
DatabaseFactory.getSessionJobDatabase(context).markJobAsSucceeded(job)
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun markJobAsFailed(job: Job) {
|
2021-01-28 05:24:27 +01:00
|
|
|
DatabaseFactory.getSessionJobDatabase(context).markJobAsFailed(job)
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun getAllPendingJobs(type: String): List<Job> {
|
2021-01-28 05:24:27 +01:00
|
|
|
return DatabaseFactory.getSessionJobDatabase(context).getAllPendingJobs(type)
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun getAttachmentUploadJob(attachmentID: Long): AttachmentUploadJob? {
|
2021-01-28 05:24:27 +01:00
|
|
|
return DatabaseFactory.getSessionJobDatabase(context).getAttachmentUploadJob(attachmentID)
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun getMessageSendJob(messageSendJobID: String): MessageSendJob? {
|
2021-01-28 05:24:27 +01:00
|
|
|
return DatabaseFactory.getSessionJobDatabase(context).getMessageSendJob(messageSendJobID)
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun resumeMessageSendJobIfNeeded(messageSendJobID: String) {
|
2021-01-28 05:24:27 +01:00
|
|
|
val job = DatabaseFactory.getSessionJobDatabase(context).getMessageSendJob(messageSendJobID) ?: return
|
|
|
|
job.delegate = JobQueue.shared
|
|
|
|
job.execute()
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun isJobCanceled(job: Job): Boolean {
|
2021-01-28 05:24:27 +01:00
|
|
|
return DatabaseFactory.getSessionJobDatabase(context).isJobCanceled(job)
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
2021-01-28 05:24:27 +01:00
|
|
|
// Authorization
|
|
|
|
|
2021-01-13 07:11:30 +01:00
|
|
|
override fun getAuthToken(server: String): String? {
|
|
|
|
return DatabaseFactory.getLokiAPIDatabase(context).getAuthToken(server)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun setAuthToken(server: String, newValue: String?) {
|
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).setAuthToken(server, newValue)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun removeAuthToken(server: String) {
|
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).setAuthToken(server, null)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getOpenGroup(threadID: String): OpenGroup? {
|
2021-01-14 03:26:53 +01:00
|
|
|
if (threadID.toInt() < 0) { return null }
|
|
|
|
val database = databaseHelper.readableDatabase
|
2021-01-19 07:06:02 +01:00
|
|
|
return database.get(LokiThreadDatabase.publicChatTable, "${LokiThreadDatabase.threadID} = ?", arrayOf(threadID)) { cursor ->
|
2021-01-14 03:26:53 +01:00
|
|
|
val publicChatAsJSON = cursor.getString(LokiThreadDatabase.publicChat)
|
|
|
|
OpenGroup.fromJSON(publicChatAsJSON)
|
|
|
|
}
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
2021-01-14 03:26:53 +01:00
|
|
|
override fun getThreadID(openGroupID: String): String {
|
|
|
|
val address = Address.fromSerialized(openGroupID)
|
|
|
|
val recipient = Recipient.from(context, address, false)
|
|
|
|
return DatabaseFactory.getThreadDatabase(context).getOrCreateThreadIdFor(recipient).toString()
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun getOpenGroupPublicKey(server: String): String? {
|
2021-01-14 06:33:03 +01:00
|
|
|
return DatabaseFactory.getLokiAPIDatabase(context).getOpenGroupPublicKey(server)
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun setOpenGroupPublicKey(server: String, newValue: String) {
|
2021-01-14 06:33:03 +01:00
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).setOpenGroupPublicKey(server, newValue)
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun setOpenGroupDisplayName(publicKey: String, channel: Long, server: String, displayName: String) {
|
2021-01-14 06:33:03 +01:00
|
|
|
val groupID = "$server.$channel"
|
|
|
|
DatabaseFactory.getLokiUserDatabase(context).setServerDisplayName(groupID, publicKey, displayName)
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun getOpenGroupDisplayName(publicKey: String, channel: Long, server: String): String? {
|
2021-01-14 06:33:03 +01:00
|
|
|
val groupID = "$server.$channel"
|
|
|
|
return DatabaseFactory.getLokiUserDatabase(context).getServerDisplayName(groupID, publicKey)
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun getLastMessageServerID(group: Long, server: String): Long? {
|
|
|
|
return DatabaseFactory.getLokiAPIDatabase(context).getLastMessageServerID(group, server)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun setLastMessageServerID(group: Long, server: String, newValue: Long) {
|
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).setLastMessageServerID(group, server, newValue)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun removeLastMessageServerID(group: Long, server: String) {
|
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).removeLastMessageServerID(group, server)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getLastDeletionServerID(group: Long, server: String): Long? {
|
|
|
|
return DatabaseFactory.getLokiAPIDatabase(context).getLastDeletionServerID(group, server)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun setLastDeletionServerID(group: Long, server: String, newValue: Long) {
|
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).setLastDeletionServerID(group, server, newValue)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun removeLastDeletionServerID(group: Long, server: String) {
|
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).removeLastDeletionServerID(group, server)
|
|
|
|
}
|
|
|
|
|
2021-02-16 05:24:21 +01:00
|
|
|
override fun isMessageDuplicated(timestamp: Long, sender: String): Boolean {
|
|
|
|
val database = DatabaseFactory.getMmsSmsDatabase(context)
|
|
|
|
return if (sender.isEmpty()) {
|
|
|
|
database.getMessageForTimestamp(timestamp) != null
|
|
|
|
} else {
|
|
|
|
database.getMessageFor(timestamp, sender) != null
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-13 07:11:30 +01:00
|
|
|
override fun setUserCount(group: Long, server: String, newValue: Int) {
|
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).setUserCount(group, server, newValue)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun setOpenGroupProfilePictureURL(group: Long, server: String, newValue: String) {
|
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).setOpenGroupProfilePictureURL(group, server, newValue)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getOpenGroupProfilePictureURL(group: Long, server: String): String? {
|
|
|
|
return DatabaseFactory.getLokiAPIDatabase(context).getOpenGroupProfilePictureURL(group, server)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun updateTitle(groupID: String, newValue: String) {
|
|
|
|
DatabaseFactory.getGroupDatabase(context).updateTitle(groupID, newValue)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun updateProfilePicture(groupID: String, newValue: ByteArray) {
|
|
|
|
DatabaseFactory.getGroupDatabase(context).updateProfilePicture(groupID, newValue)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getReceivedMessageTimestamps(): Set<Long> {
|
2021-02-16 05:24:21 +01:00
|
|
|
return SessionMetaProtocol.getTimestamps()
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun addReceivedMessageTimestamp(timestamp: Long) {
|
2021-02-16 05:24:21 +01:00
|
|
|
SessionMetaProtocol.addTimestamp(timestamp)
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
2021-02-16 05:24:21 +01:00
|
|
|
// override fun removeReceivedMessageTimestamps(timestamps: Set<Long>) {
|
|
|
|
// TODO("Not yet implemented")
|
|
|
|
// }
|
2021-02-11 06:09:59 +01:00
|
|
|
|
2021-01-20 06:29:52 +01:00
|
|
|
override fun getMessageIdInDatabase(timestamp: Long, author: String): Long? {
|
|
|
|
val database = DatabaseFactory.getMmsSmsDatabase(context)
|
|
|
|
val address = Address.fromSerialized(author)
|
|
|
|
return database.getMessageFor(timestamp, address)?.getId()
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
2021-01-20 06:29:52 +01:00
|
|
|
override fun setOpenGroupServerMessageID(messageID: Long, serverID: Long) {
|
|
|
|
DatabaseFactory.getLokiMessageDatabase(context).setServerID(messageID, serverID)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun markAsSent(messageID: Long) {
|
|
|
|
val database = DatabaseFactory.getMmsSmsDatabase(context)
|
|
|
|
val messageRecord = database.getMessageFor(messageID)!!
|
|
|
|
if (messageRecord.isMms) {
|
|
|
|
val mmsDatabase = DatabaseFactory.getMmsDatabase(context)
|
|
|
|
mmsDatabase.markAsSent(messageRecord.getId(), true)
|
|
|
|
} else {
|
|
|
|
val smsDatabase = DatabaseFactory.getSmsDatabase(context)
|
|
|
|
smsDatabase.markAsSent(messageRecord.getId(), true)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun markUnidentified(messageID: Long) {
|
|
|
|
val database = DatabaseFactory.getMmsSmsDatabase(context)
|
|
|
|
val messageRecord = database.getMessageFor(messageID)!!
|
|
|
|
if (messageRecord.isMms) {
|
|
|
|
val mmsDatabase = DatabaseFactory.getMmsDatabase(context)
|
|
|
|
mmsDatabase.markUnidentified(messageRecord.getId(), true)
|
|
|
|
} else {
|
|
|
|
val smsDatabase = DatabaseFactory.getSmsDatabase(context)
|
|
|
|
smsDatabase.markUnidentified(messageRecord.getId(), true)
|
|
|
|
}
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
2021-01-20 06:37:02 +01:00
|
|
|
override fun setErrorMessage(messageID: Long, error: Exception) {
|
|
|
|
val database = DatabaseFactory.getMmsSmsDatabase(context)
|
|
|
|
val messageRecord = database.getMessageFor(messageID) ?: return
|
|
|
|
if (messageRecord.isMms) {
|
|
|
|
val mmsDatabase = DatabaseFactory.getMmsDatabase(context)
|
|
|
|
mmsDatabase.markAsSentFailed(messageID)
|
|
|
|
} else {
|
|
|
|
val smsDatabase = DatabaseFactory.getSmsDatabase(context)
|
|
|
|
smsDatabase.markAsSentFailed(messageID)
|
|
|
|
}
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun getGroup(groupID: String): GroupRecord? {
|
|
|
|
val group = DatabaseFactory.getGroupDatabase(context).getGroup(groupID)
|
|
|
|
return if (group.isPresent) { group.get() } else null
|
|
|
|
}
|
|
|
|
|
2021-02-16 01:14:27 +01:00
|
|
|
override fun createGroup(groupId: String, title: String?, members: List<Address>, avatar: SignalServiceAttachmentPointer?, relay: String?, admins: List<Address>, formationTimestamp: Long) {
|
|
|
|
DatabaseFactory.getGroupDatabase(context).create(groupId, title, members, avatar, relay, admins, formationTimestamp)
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun setActive(groupID: String, value: Boolean) {
|
|
|
|
DatabaseFactory.getGroupDatabase(context).setActive(groupID, value)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun removeMember(groupID: String, member: Address) {
|
|
|
|
DatabaseFactory.getGroupDatabase(context).removeMember(groupID, member)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun updateMembers(groupID: String, members: List<Address>) {
|
|
|
|
DatabaseFactory.getGroupDatabase(context).updateMembers(groupID, members)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun insertIncomingInfoMessage(context: Context, senderPublicKey: String, groupID: String, type0: SignalServiceProtos.GroupContext.Type, type1: SignalServiceGroup.Type, name: String, members: Collection<String>, admins: Collection<String>) {
|
|
|
|
val groupContextBuilder = SignalServiceProtos.GroupContext.newBuilder()
|
2021-01-22 00:33:19 +01:00
|
|
|
.setId(ByteString.copyFrom(GroupUtil.getDecodedGroupIDAsData(groupID)))
|
2021-01-13 07:11:30 +01:00
|
|
|
.setType(type0)
|
|
|
|
.setName(name)
|
|
|
|
.addAllMembers(members)
|
|
|
|
.addAllAdmins(admins)
|
2021-01-22 00:33:19 +01:00
|
|
|
val group = SignalServiceGroup(type1, GroupUtil.getDecodedGroupIDAsData(groupID), SignalServiceGroup.GroupType.SIGNAL, name, members.toList(), null, admins.toList())
|
2021-01-13 07:11:30 +01:00
|
|
|
val m = IncomingTextMessage(Address.fromSerialized(senderPublicKey), 1, System.currentTimeMillis(), "", Optional.of(group), 0, true)
|
|
|
|
val infoMessage = IncomingGroupMessage(m, groupContextBuilder.build(), "")
|
|
|
|
val smsDB = DatabaseFactory.getSmsDatabase(context)
|
|
|
|
smsDB.insertMessageInbox(infoMessage)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun insertOutgoingInfoMessage(context: Context, groupID: String, type: SignalServiceProtos.GroupContext.Type, name: String, members: Collection<String>, admins: Collection<String>, threadID: Long) {
|
|
|
|
val recipient = Recipient.from(context, Address.fromSerialized(groupID), false)
|
|
|
|
val groupContextBuilder = SignalServiceProtos.GroupContext.newBuilder()
|
2021-01-22 00:33:19 +01:00
|
|
|
.setId(ByteString.copyFrom(GroupUtil.getDecodedGroupIDAsData(groupID)))
|
2021-01-13 07:11:30 +01:00
|
|
|
.setType(type)
|
|
|
|
.setName(name)
|
|
|
|
.addAllMembers(members)
|
|
|
|
.addAllAdmins(admins)
|
2021-02-11 04:01:31 +01:00
|
|
|
val infoMessage = OutgoingGroupMediaMessage(recipient, groupContextBuilder.build(), null, 0, null, listOf(), listOf())
|
2021-01-13 07:11:30 +01:00
|
|
|
val mmsDB = DatabaseFactory.getMmsDatabase(context)
|
|
|
|
val infoMessageID = mmsDB.insertMessageOutbox(infoMessage, threadID, false, null)
|
|
|
|
mmsDB.markAsSent(infoMessageID, true)
|
|
|
|
}
|
|
|
|
|
2021-01-14 01:42:26 +01:00
|
|
|
override fun isClosedGroup(publicKey: String): Boolean {
|
2021-02-18 04:14:05 +01:00
|
|
|
val isClosedGroup = DatabaseFactory.getLokiAPIDatabase(context).isClosedGroup(publicKey)
|
2021-01-20 00:04:14 +01:00
|
|
|
val address = Address.fromSerialized(publicKey)
|
2021-02-18 04:14:05 +01:00
|
|
|
return address.isClosedGroup || isClosedGroup
|
2021-01-14 01:42:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun getClosedGroupEncryptionKeyPairs(groupPublicKey: String): MutableList<ECKeyPair> {
|
2021-01-20 01:18:00 +01:00
|
|
|
return DatabaseFactory.getLokiAPIDatabase(context).getClosedGroupEncryptionKeyPairs(groupPublicKey).toMutableList()
|
2021-01-14 01:42:26 +01:00
|
|
|
}
|
|
|
|
|
2021-01-20 01:18:00 +01:00
|
|
|
override fun getLatestClosedGroupEncryptionKeyPair(groupPublicKey: String): ECKeyPair? {
|
|
|
|
return DatabaseFactory.getLokiAPIDatabase(context).getLatestClosedGroupEncryptionKeyPair(groupPublicKey)
|
2021-01-14 03:20:18 +01:00
|
|
|
}
|
|
|
|
|
2021-02-08 06:44:26 +01:00
|
|
|
override fun getAllClosedGroupPublicKeys(): Set<String> {
|
2021-02-18 04:14:05 +01:00
|
|
|
return DatabaseFactory.getLokiAPIDatabase(context).getAllClosedGroupPublicKeys()
|
2021-02-08 06:44:26 +01:00
|
|
|
}
|
|
|
|
|
2021-02-09 01:45:38 +01:00
|
|
|
override fun addClosedGroupPublicKey(groupPublicKey: String) {
|
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).addClosedGroupPublicKey(groupPublicKey)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun removeClosedGroupPublicKey(groupPublicKey: String) {
|
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).removeClosedGroupPublicKey(groupPublicKey)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun addClosedGroupEncryptionKeyPair(encryptionKeyPair: ECKeyPair, groupPublicKey: String) {
|
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).addClosedGroupEncryptionKeyPair(encryptionKeyPair, groupPublicKey)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun removeAllClosedGroupEncryptionKeyPairs(groupPublicKey: String) {
|
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).removeAllClosedGroupEncryptionKeyPairs(groupPublicKey)
|
|
|
|
}
|
|
|
|
|
2021-02-08 06:44:26 +01:00
|
|
|
override fun getAllOpenGroups(): Map<Long, PublicChat> {
|
|
|
|
return DatabaseFactory.getLokiThreadDatabase(context).getAllPublicChats()
|
|
|
|
}
|
|
|
|
|
2021-02-09 03:16:33 +01:00
|
|
|
override fun addOpenGroup(server: String, channel: Long) {
|
|
|
|
OpenGroupUtilities.addGroup(context, server, channel)
|
|
|
|
}
|
|
|
|
|
2021-02-05 06:35:15 +01:00
|
|
|
override fun getAllGroups(): List<GroupRecord> {
|
|
|
|
return DatabaseFactory.getGroupDatabase(context).allGroups
|
|
|
|
}
|
|
|
|
|
2021-01-13 07:11:30 +01:00
|
|
|
override fun setProfileSharing(address: Address, value: Boolean) {
|
|
|
|
val recipient = Recipient.from(context, address, false)
|
|
|
|
DatabaseFactory.getRecipientDatabase(context).setProfileSharing(recipient, value)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getOrCreateThreadIdFor(address: Address): Long {
|
|
|
|
val recipient = Recipient.from(context, address, false)
|
|
|
|
return DatabaseFactory.getThreadDatabase(context).getOrCreateThreadIdFor(recipient)
|
|
|
|
}
|
|
|
|
|
2021-01-20 00:04:14 +01:00
|
|
|
override fun getOrCreateThreadIdFor(publicKey: String, groupPublicKey: String?, openGroupID: String?): Long {
|
|
|
|
val database = DatabaseFactory.getThreadDatabase(context)
|
2021-01-19 07:06:02 +01:00
|
|
|
if (!openGroupID.isNullOrEmpty()) {
|
2021-01-20 00:04:14 +01:00
|
|
|
val recipient = Recipient.from(context, Address.fromSerialized(openGroupID), false)
|
|
|
|
return database.getOrCreateThreadIdFor(recipient)
|
2021-01-19 07:06:02 +01:00
|
|
|
} else if (!groupPublicKey.isNullOrEmpty()) {
|
2021-01-20 00:04:14 +01:00
|
|
|
val recipient = Recipient.from(context, Address.fromSerialized(groupPublicKey), false)
|
|
|
|
return database.getOrCreateThreadIdFor(recipient)
|
2021-01-19 07:06:02 +01:00
|
|
|
} else {
|
2021-01-20 00:04:14 +01:00
|
|
|
val recipient = Recipient.from(context, Address.fromSerialized(publicKey), false)
|
|
|
|
return database.getOrCreateThreadIdFor(recipient)
|
2021-01-19 07:06:02 +01:00
|
|
|
}
|
2021-01-13 07:11:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun getThreadIdFor(address: Address): Long? {
|
|
|
|
val recipient = Recipient.from(context, address, false)
|
|
|
|
val threadID = DatabaseFactory.getThreadDatabase(context).getThreadIdIfExistsFor(recipient)
|
|
|
|
return if (threadID < 0) null else threadID
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getSessionRequestSentTimestamp(publicKey: String): Long? {
|
|
|
|
return DatabaseFactory.getLokiAPIDatabase(context).getSessionRequestSentTimestamp(publicKey)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun setSessionRequestSentTimestamp(publicKey: String, newValue: Long) {
|
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).setSessionRequestSentTimestamp(publicKey, newValue)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getSessionRequestProcessedTimestamp(publicKey: String): Long? {
|
|
|
|
return DatabaseFactory.getLokiAPIDatabase(context).getSessionRequestProcessedTimestamp(publicKey)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun setSessionRequestProcessedTimestamp(publicKey: String, newValue: Long) {
|
|
|
|
DatabaseFactory.getLokiAPIDatabase(context).setSessionRequestProcessedTimestamp(publicKey, newValue)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getDisplayName(publicKey: String): String? {
|
|
|
|
return DatabaseFactory.getLokiUserDatabase(context).getDisplayName(publicKey)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getServerDisplayName(serverID: String, publicKey: String): String? {
|
|
|
|
return DatabaseFactory.getLokiUserDatabase(context).getServerDisplayName(serverID, publicKey)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getProfilePictureURL(publicKey: String): String? {
|
|
|
|
return DatabaseFactory.getLokiUserDatabase(context).getProfilePictureURL(publicKey)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getRecipientSettings(address: Address): Recipient.RecipientSettings? {
|
|
|
|
val recipientSettings = DatabaseFactory.getRecipientDatabase(context).getRecipientSettings(address)
|
|
|
|
return if (recipientSettings.isPresent) { recipientSettings.get() } else null
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getAttachmentDataUri(attachmentId: AttachmentId): Uri {
|
|
|
|
return PartAuthority.getAttachmentDataUri(attachmentId)
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun getAttachmentThumbnailUri(attachmentId: AttachmentId): Uri {
|
|
|
|
return PartAuthority.getAttachmentThumbnailUri(attachmentId)
|
|
|
|
}
|
|
|
|
}
|