What is a good way to make a chat application between two people using Objectify and Google Datastore?
The main question I have is how can you have a mobile client (iOS/Android) screen refresh itself when a new message is sent? Such as in the following screen:
The main option I see is to send a push notification to the client that a new message has been sent, so query the datastore for new messages.
Web-sockets don't seem to be supported on Google App Engine from what I read. Or if they are they seem buggy?
What other options are there?
It's technically possible, but it's a terrible idea. You would have to poll, which would scale poorly and kill your clients' battery life.
The datastore is the wrong tool for this job. Look for the highest level API that will do what you want, ideally something websocket-oriented like Firebase.
Related
I want my app to be able to listen to onSnapshot while it is in background , I know that I can use background task for this by I don't know how to set it up .
btw I'm trying to implment this so that my app can push a notification whenever a new doc is received while app is in the background .
Most mobile operating systems severely limit what the app can do while it is backgrounded. Keeping an active connection open to a server is one of those things that has never been allowed on iOS, and has gotten more restrictive with recent Android versions.
The better approach is to run the code that detects a relevant change on a server, and then use Firebase Cloud Messaging (or APNS directly if you're only targeting iOS) to send a notification to the user. When they they tap on that notification, your app is started and you can load the data from Firestore.
If you don't want to run your own server, Cloud Functions is a common alternative for this, as it has built in triggers that respond to changes in Firestore. For an example of this exact scenario, see the documentation on notify users when something interesting happens.
I'm at the beginning of spec'ing out a project to implement browser notifications. From a high level it appears like it will be something similar to:
Create a service worker which subscribes to a pubsub topic.
Leverage the Notifications API and WindowClient to publish a browser notification when an event happens and the window is in a non-foreground state.
Seems, straightforward enough. However, I'm getting a bit hung up from a mobile perspective. Namely, it seems to be the typical pattern that if a mobile device has both the mobile website open and an application installed, the native notification should take precedence and the browser notification should be silenced.
However, I can't seem to figure out how a service worker would inspect for the presence of a mobile application. It is entirely possible that I'm approaching this problem from the wrong perspective though, and the typical recipe for this is handled differently.
Brent, IIUC your question is a non-issue because topic-based subscription is simply not supported by either the W3C Push API or the IETF webpush protocol. I'm afraid that this is by design :-(
Therefore your native app will not be delivered the same broadcast message as your browser UA.
If OTOH you were talking about save-to-homescreen WebApp and a web-page running in a tab then, I believe, your service worker can choose which member of the active client collection to foreground (if necessary) but there will only be one toast message (if at all given rules governing blind/invisible notifications)
I am creating an app that involves sending and receiving settings... The desktop application is constantly sending information to a hosted MySQL database, and the Android app will query this same information. It is something similar to the whatsapp web (but in this case, I'll be using a desktop app instead of webpages).
Until this part, everything is working as I need... but, this same Android app will be used to send settings to the desktop app, and the desktop will read and change its settings according to what was just sent.
If I need to constantly query the hosted MySQL database and check if there is any kind of changes sent from the Android, I believe that I'll have a performance drop... each time a query loop is finished, I would have to query, check for any modifications and so on.
Is there a better or correct way to do this kind integration between two apps? I've read something about WebSockets, but I don't have much technical information about this, neither examples that I can use in this case.
Thank you very much for your knowledge sharing.
Here are some useful sites on WebSocket:
http://websocket.org
http://blog.kaazing.com/ [some useful blog posts]
http://www.html5rocks.com/en/tutorials/websockets/basics/
https://goo.gl/5OaJff [mozilla site]
You may want to consider the Observer/Observables pattern. The MYSQL is the Observable and your desktop app and Android app are Observers (and you can add other Observers in the future). Its a common pattern with lots of examples out there. But you'll need a centralized WebSocket server and an Observer/Observable coordination subsystem. You can setup a pub/sub message broker that uses WebSocket with a nice JMS, MQTT, etc, API to make your life easier. ActiveMQ, IBM MQ Lite, Kaazing JMS Edition... lots of options.
full disclosure. I work for Kaazing.
use case: 5 - 30 users simultaniously on a chat.
is it a good idea / is it possible to code this on google app engine?
Until the Channel API is released, you'll have to use polling to do this. When that API is released, App Engine will be (IMO, caveat that I work on the team) a great tool for this.
Note that with 1.3.6 you can use the Channel API for local development so you can at least get started implementing something, though it won't work in prod.
maybe it's a stupid question, but couldn't the GAE Application forward incoming messages to all known clients when they are posted to the server?
Why would that not work?
Laures
The XMPP service in GAE is great and all, but I'm really interested in when a user opens up a window to send a message, or when he/she starts typing. I think XMPP supports this, because Pidgin does this, as does Google Talk, so why not the XMPP/GAE service?
Unfortunately App Engine doesn't pass in Chat State notifications to the application, so you won't be able to receive notifications of a user typing a message ("composing") until they actually send it.