Sinch seems to serve the purpose find for sending messages but is there an example, perhaps using Parse, where missed messages accumulate in an inbox and allow for responding to the missed message and keeping the thread of messages?
The messages will be delivered to the client as soon as you launch the app, then you can save it to parse if you like.
Related
From the docs it is clear that message delivery is not guaranteed by django-channels. I want to implement a way in my chat app so that there is a guarantee that messages are delivered to the client.
I am using redis, if that matter. When I say messages I don't mean chat text messages. I haven't implemented that part and don't need that for now. I just have video call feature. What gets lost sometimes is when users join the room the room members list doesn't reach them. So I want to do something like:
Client connects.
Servers creates a record of the event in step 3 below.
Server sends the list of room members event to the client.
Client process and acknowledges the list.
Server on receiving the acknowledgment from the client marks the list sent event as SUCCESS or something.
My questions are.
Is this approach good?
And should I use a new model to store the message events so that server can know which messages to sent and which have been already sent successfully or is there anyway to do it in redis db?
I am new to this so I maybe overlooking something that you as experienced guys know of. Please guide me with your precious inputs.
Thanks
I'm learning to use iron.io MQ push queues. I'm pushing some messages with Laravel php framework and everything works. However, just to round up my knowledge, I would like to see the raw contents of these messages. In my iron.io account I can see the total number of messages sent, but I can't find a place where to inspect individual messages and their contents. I'm wondering weather Laravel is sending some ID's or anything like that..
Laravel is using IronMQ's Push Queues and since push queues are delivered immediately, they don't stick around upon successful delivery. Although, you can create an error queue to inspect messages that can't be delivered successfully.
So our team has recently implemented torquebox into our jruby on rails applications. The purpose of this was to be able to receive queue/topic messages from an outside source which is streaming live data.
We have setup our queues/topics and they are receiving the messages without an issue. The next step we want to take is to get these messages on the browser.
So we started to look into leveraging the power of stomp. But we have come across some issues with this. It seems from the documentation that the purpose of using stomp + websockets is to receive messages from the client-side and push those messages to other clients. But we want to receive messages on our queues, and then push these messages to the client-side using websockets. Is this possible? Or would we have to implement a different technology such as Pusher or socket.io to get the queue/topic messages to the browser?
Thanks.
I think stomplets is good solution for this task. In rails application you should use ruby base stomp client, in browser javascript base stomp client. In rails just send data, and in browser just receive.
More detail how do it you can find in torquebox documentation
http://torquebox.org/documentation/2.0.0/stomp.html
It is indeed possible to push messages straight from the server to clients. It took me quite a bit of digging to find it as it is not listed in the documentation directly. Their blog lists it in their example of how to build a chat client using websockets.
http://torquebox.org/news/2011/08/23/stomp-chat-demo-part3/
Basically you use the inject method to choose which channel you're publishing to, and then use the publish method on the returned object to actually send the message. This code excerpt from the article should get you pointed in the right direction.
inject( '/topics/chat' ).publish( message,
:properties=>{
:recipient=>username,
:sender=>'system'
} )
It looks like :properties is the same thing as message headers. I'll be giving this a go over the next couple of days to see how well this works in Rails.
I have a simple messaging system on my site. I would like to implement limits on messages. For basic users, users can have store a maximum of 250 messages in their inbox and supporters can store a maximum of 3000 messages.
My question is about the UI aspects.
If a basic user already has 250 messages:
would you block another user from being able to send them a message until they have deleted some messages?
Or would you put the new message in a queue and not show it until a user has deleted some messages?
Would you tell them they have new messages waiting but they can't read them until they've deleted some messages?
What would be your approach?
I would suggest an automatic delete that the oldest messages are automatically removed when newer messages arrive.
Edit: See comment below.
Also, besides this method, you could make a way to save some messages or make them favorite to prevent auto-deleting them.
In a project I'm currently working on, we send some small info across the wire to WP7 device when we send a raw notification.
When the application is in a tombstone state and the user receives the toast message, we can't add the extra baggage in the toast. So we figured we need a way to resend the notification once the user entered the application again.
Anybody has any experience or possible solution for this problem. We are currently looking at a sort of handshaking between client and server. But it all seems a bit drastic for me.
Kind regards,
Tom
I would suggest to stop using rawNotifications and use only toast.
To handle the case when the app has been started using a toast notification, query the server at app startup to check if there's pending data.
For notifications sent while the app is running, you can detect them using the ShellToastNotificationReceived event of your channel. When the event is triggered, query the server to retrieve the payload.