Hi <a class="user-mention notranslate" data-hovercard-type="user" data-hovercard-url="

some messages gets lost on poor connection about atox HOT 2 OPEN

readyblue commented on August 13, 2024

some messages gets lost on poor connection

from atox.

Comments (2)

readyblue commented on August 13, 2024 2

With all due respect, there may be a reason why it might be a good idea to keep message delivery in order, like:

from atox.

robinlinden commented on August 13, 2024

Hi @readyblue!

While TOX implements read receipts, would be possible to implement mechanism that sends message only after the read receipts gets delivered from previous message?

aTox should already be resending all undelivered messages in the correct order, but we don't wait for one message to be acknowledged before sending the next, ~~so I guess in theory a message could get lost a second time, and then we'd end up with out-of-order problems. If you feel like having a look at making a PR for this, it'd be very welcome. :)~~ After speaking to a friend, this shouldn't be able to happen either. Have you had messages delivered out-of-order from aTox to aTox, uTox, Toxic, or qTox?

See:

aTox/domain/src/main/kotlin/feature/ChatManager.kt

Lines 88 to 101 in b3684d8

    
           fun resend(messages: List<Message>) = scope.launch { 
        
               for (message in messages) { 
        
                   val msgs = message.message.chunked(MAX_MESSAGE_LENGTH) 
        
                   while (msgs.size > 1) { 
        
                       tox.sendMessage(PublicKey(message.publicKey), msgs.removeFirst(), message.type) 
        
                   } 
        
                   messageRepository.setCorrelationId( 
        
                       message.id, 
        
                       tox.sendMessage(PublicKey(message.publicKey), msgs.first(), message.type), 
        
                   ) 
        
               } 
        
           }

aTox/atox/src/main/kotlin/tox/EventListenerCallbacks.kt

Lines 96 to 103 in b3684d8

    
           friendConnectionStatusHandler = { publicKey, status -> 
        
               contactRepository.setConnectionStatus(publicKey, status) 
        
               if (status != ConnectionStatus.None) { 
        
                   scope.launch { 
        
                       val pending = messageRepository.getPending(publicKey) 
        
                       if (pending.isNotEmpty()) { 
        
                           chatManager.resend(pending) 
        
                       }

And also display this event in the chat log window so that it will be possible to resend the message without read receipts delivered?

aTox already resends all messages that it doesn't get read-receipts for, so if aTox doesn't display "sending" under a message, the Tox client on the other side has sent a read-receipt. Are you sure it's not the other side dropping the messages after receiving them and sending a read-receipt?

See:

aTox/domain/src/main/kotlin/feature/ChatManager.kt

Lines 62 to 83 in b3684d8

    
           fun sendMessage(publicKey: PublicKey, message: String, type: MessageType = MessageType.Normal) = 
        
               scope.launch { 
        
                   if (contactRepository.get(publicKey.string()).first().connectionStatus == ConnectionStatus.None) { 
        
                       queueMessage(publicKey, message, type) 
        
                       return@launch 
        
                   } 
        
                   val msgs = message.chunked(MAX_MESSAGE_LENGTH) 
        
                   while (msgs.size > 1) { 
        
                       tox.sendMessage(publicKey, msgs.removeFirst(), type) 
        
                   } 
        
                   messageRepository.add( 
        
                       Message( 
        
                           publicKey.string(), 
        
                           message, 
        
                           Sender.Sent, 
        
                           type, 
        
                           tox.sendMessage(publicKey, msgs.first(), type), 
        
                       ), 
        
                   ) 
        
               }

aTox/atox/src/main/kotlin/tox/EventListenerCallbacks.kt

Lines 88 to 90 in b3684d8

    
           friendReadReceiptHandler = { publicKey, messageId -> 
        
               messageRepository.setReceipt(publicKey, messageId, Date().time) 
        
           }

aTox/atox/src/main/kotlin/ui/chat/ChatAdapter.kt

Lines 138 to 144 in b3684d8

    
           val unsent = message.timestamp == 0L 
        
           vh.message.text = message.message 
        
           vh.timestamp.text = if (!unsent) { 
        
               timeFormatter.format(message.timestamp) 
        
           } else { 
        
               resources.getText(R.string.sending) 
        
           }

Thank you for getting in touch! Always nice to hear from people using aTox!

from atox.

some messages gets lost on poor connection about atox HOT 2 OPEN

Comments (2)

Related Issues (20)

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent

	fun resend(messages: List<Message>) = scope.launch {
	for (message in messages) {
	val msgs = message.message.chunked(MAX_MESSAGE_LENGTH)

	while (msgs.size > 1) {
	tox.sendMessage(PublicKey(message.publicKey), msgs.removeFirst(), message.type)
	}

	messageRepository.setCorrelationId(
	message.id,
	tox.sendMessage(PublicKey(message.publicKey), msgs.first(), message.type),
	)
	}
	}

	friendConnectionStatusHandler = { publicKey, status ->
	contactRepository.setConnectionStatus(publicKey, status)
	if (status != ConnectionStatus.None) {
	scope.launch {
	val pending = messageRepository.getPending(publicKey)
	if (pending.isNotEmpty()) {
	chatManager.resend(pending)
	}

	fun sendMessage(publicKey: PublicKey, message: String, type: MessageType = MessageType.Normal) =
	scope.launch {
	if (contactRepository.get(publicKey.string()).first().connectionStatus == ConnectionStatus.None) {
	queueMessage(publicKey, message, type)
	return@launch
	}

	val msgs = message.chunked(MAX_MESSAGE_LENGTH)
	while (msgs.size > 1) {
	tox.sendMessage(publicKey, msgs.removeFirst(), type)
	}

	messageRepository.add(
	Message(
	publicKey.string(),
	message,
	Sender.Sent,
	type,
	tox.sendMessage(publicKey, msgs.first(), type),
	),
	)
	}

	friendReadReceiptHandler = { publicKey, messageId ->
	messageRepository.setReceipt(publicKey, messageId, Date().time)
	}

	val unsent = message.timestamp == 0L
	vh.message.text = message.message
	vh.timestamp.text = if (!unsent) {
	timeFormatter.format(message.timestamp)
	} else {
	resources.getText(R.string.sending)
	}