srctree

import javax.inject.Inject

import javax.inject.Singleton

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.delay

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

@Singleton

class CallManager @Inject constructor(

private val tox: Tox,

context: Context,

private val _inCall = MutableStateFlow<CallState>(CallState.NotInCall)

val inCall: StateFlow<CallState> get() = _inCall

 

set(value) { audioManager?.isSpeakerphoneOn = value }

 

private fun startAudioSender(recorder: AudioCapture, to: PublicKey) {

recorder.start()

_sendingAudio.value = true

while (inCall.value is CallState.InCall && sendingAudio.value) {

 

import javax.inject.Inject

import javax.inject.Singleton

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.flow.first

import kotlinx.coroutines.launch

import ltd.evilcorp.core.repository.ContactRepository

 

@Singleton

class ChatManager @Inject constructor(

private val contactRepository: ContactRepository,

private val messageRepository: MessageRepository,

private val tox: Tox

var activeChat = ""

set(value) {

field = value

contactRepository.setHasUnreadMessages(value, false)

}

}

fun messagesFor(publicKey: PublicKey) = messageRepository.get(publicKey.string())

 

fun sendMessage(publicKey: PublicKey, message: String, type: MessageType = MessageType.Normal) =

if (contactRepository.get(publicKey.string()).first().connectionStatus == ConnectionStatus.None) {

queueMessage(publicKey, message, type)

return@launch

private fun queueMessage(publicKey: PublicKey, message: String, type: MessageType) =

messageRepository.add(Message(publicKey.string(), message, Sender.Sent, type, Int.MIN_VALUE))

 

for (message in messages) {

val msgs = message.message.chunked(MAX_MESSAGE_LENGTH)

 

}

}

 

messageRepository.deleteMessage(id)

}

 

messageRepository.delete(publicKey.string())

contactRepository.setLastMessage(publicKey.string(), 0)

}

 

//

// SPDX-License-Identifier: GPL-3.0-only

 

 

import javax.inject.Inject

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.launch

import ltd.evilcorp.core.repository.ContactRepository

import ltd.evilcorp.core.vo.Contact

import ltd.evilcorp.domain.tox.ToxID

 

class ContactManager @Inject constructor(

private val contactRepository: ContactRepository,

private val tox: Tox

fun get(publicKey: PublicKey) = contactRepository.get(publicKey.string())

fun getAll() = contactRepository.getAll()

 

tox.addContact(toxID, message)

contactRepository.add(Contact(toxID.toPublicKey().string()))

}

 

tox.deleteContact(publicKey)

contactRepository.delete(Contact(publicKey.string()))

}

 

contactRepository.setDraftMessage(pk.string(), draft)

}

}

 

import javax.inject.Inject

import javax.inject.Singleton

import kotlin.random.Random

import kotlinx.coroutines.flow.collect

import kotlinx.coroutines.flow.take

import kotlinx.coroutines.launch

 

@Singleton

class FileTransferManager @Inject constructor(

private val context: Context,

private val resolver: ContentResolver,

private val contactRepository: ContactRepository,

 

fun reset() {

fileTransfers.clear()

fileTransferRepository.resetTransientData()

}

}

 

//

// SPDX-License-Identifier: GPL-3.0-only

 

 

import javax.inject.Inject

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.flow.Flow

import kotlinx.coroutines.launch

import ltd.evilcorp.core.repository.ContactRepository

import ltd.evilcorp.domain.tox.Tox

 

class FriendRequestManager @Inject constructor(

private val contactRepository: ContactRepository,

private val friendRequestRepository: FriendRequestRepository,

private val tox: Tox

fun getAll(): Flow<List<FriendRequest>> = friendRequestRepository.getAll()

fun get(id: PublicKey): Flow<FriendRequest> = friendRequestRepository.get(id.string())

 

tox.acceptFriendRequest(PublicKey(friendRequest.publicKey))

contactRepository.add(Contact(friendRequest.publicKey))

friendRequestRepository.delete(friendRequest)

}

 

}

 

 

import javax.inject.Inject

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.launch

import ltd.evilcorp.core.repository.UserRepository

import ltd.evilcorp.core.vo.User

import ltd.evilcorp.domain.tox.Tox

 

class UserManager @Inject constructor(

private val userRepository: UserRepository,

private val tox: Tox

fun get(publicKey: PublicKey) = userRepository.get(publicKey.string())

 

userRepository.add(user)

tox.setName(user.name)

tox.setStatusMessage(user.statusMessage)

}

 

if (!userRepository.exists(publicKey.string())) {

val name = tox.getName()

val statusMessage = tox.getStatusMessage()

}

}

 

tox.setName(name)

userRepository.updateName(tox.publicKey.string(), name)

}

 

tox.setStatusMessage(statusMessage)

userRepository.updateStatusMessage(tox.publicKey.string(), statusMessage)

}

 

tox.setStatus(status)

userRepository.updateStatus(tox.publicKey.string(), status)

}

 

import javax.inject.Singleton

import kotlin.random.Random

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.delay

import kotlinx.coroutines.launch

import kotlinx.coroutines.sync.Mutex

 

@Singleton

class Tox @Inject constructor(

private val contactRepository: ContactRepository,

private val userRepository: UserRepository,

private val saveManager: SaveManager,

private val nodeRegistry: BootstrapNodeRegistry,

val toxId: ToxID get() = tox.getToxId()

val publicKey: PublicKey by lazy { tox.getPublicKey() }

var nospam: Int

this.password = password

started = true

 

contactRepository.resetTransientData()

 

for ((publicKey, _) in tox.getContacts()) {

}

}

 

toxAvRunning = true

while (running) {

tox.iterateAv()

toxAvRunning = false

}

 

running = true

userRepository.updateConnection(publicKey.string(), ConnectionStatus.None)

while (running || toxAvRunning) {

iterateForeverAv()

}

 

running = false

while (started) delay(10)

save().join()

}

 

private val saveMutex = Mutex()

saveMutex.withLock {

val passkey = passkey

saveManager.save(