I'd like to know if the HotJar supports PWA - when a user is offline, will HotJar collect the data and send it after reconnecting?
Related
I need to run background service to listen to firebase realtime database and trigger local notifications on change in flutter app
Native mobile platform such as iOS and Android, actively work against such background listeners as they drain the battery in a way that the OS can't control (on behalf of the user). So while you may be able to start listening in a background process, the OS will kill the socket connection used for that listener quickly (in 5m on recent Android versions).
The proper way to notify the user of activity in the database while they're not actively using the app is to set a listener in an always-on environment, and then use Firebase Cloud Messaging and/or APNS to send a notification to the affected user(s).
If you don't have a server you control yet, you can use Cloud Functions through Firebase to get started. For an example of this, see the notifying the user when something interesting happens use-case in the Firebase docs and the code sample linked from there.
The function triggers on writes to the Realtime Database path where followers are stored.
The function composes a message to send via FCM.
FCM sends the notification message to the user's device.
I want to create an application just like Uber using Firebase. I do not under stand how I can show the nearest application user on google map using costume markers and how I can send the request to the all nearest application users at same time just like Uber do.
Since you're already using Firebase, you can use Firebase Cloud Messaging. This is obviously a rather big feature that will envolve lots of sub-tasks, but here's a simplified overview of how it could be:
You have three players involved:
the "Uber user" client app
the "Uber driver" client app
your app server (which could be Firebase Cloud Functions, for a serverless backend)
The data flow could be as follows:
"Drivers" open their apps. This establishes a connection with the server, and keeps the server constantly updated with their geolocation.
A "user" opens his app. This triggers a request to the server sending the user's geolocation.
The server (which knows the realtime location of all drivers) calculates which drivers are near the user, and responds the user request with this data. The user client app can now render a map widget with the drivers locations (for this, you'll probably use a package like google_maps_flutter).
The user clicks a button to request a ride. This again triggers a request to the server.
The server receives the request, and notifies the nearby drivers using Cloud Messaging. FCM has a message type called Data message which is well suited for this; you can send custom data, and the client app will process it however it wants.
The drivers' apps receives this Data Message and render the UI showing there's a ride available. If the driver accepts the ride, this sends a request to the server.
Once the server sees the "accepted ride" request, it sends another message to all other drivers informing the ride is no longer available, as well as sends a message to the user informing the ride has been accepted.
As I said, this is not a simple feature. There are several tricky parts, such as race conditions, and making sure only a single driver accepts a ride. But this should be a high-level overview of how it can be done.
Finally, this schema is a quite technology agnostic; it isn't specific to Flutter. The architecture to have that feature could be implemented like this in pretty much any modern mobile framework - Flutter is just a UI framework.
I work for a tv/radio broadcasting company, and we stream live content through various devices through a web-based API, and we also stream through internet radio (such as iHeartRadio, Tunein, etc.). The API can also return things like show titles and descriptions.
I've been tasked with creating a Google Action that can be used to retrieve information from the API such as what's playing, what's coming up next, what shows are available, etc. It would be fantastic if Google Actions supported live-streamed content, but I believe they do not.
Since we DO stream through internet radio, I would like to create an intent that allows the user to be redirected from my action to the internet radio stream for our station. How would I go about doing that? I could simply tell the user to start a new conversation (e.g., "Say, OK Google, play 'My-Awesome-Radio'"), but it would be more user-friendly not to have to start a new conversation.
We are developing a consumer hardware product. Each device is registered on a central webserver and the owner also have a user account to which the device is linked. The owner may also choose to share the device with other users.
Now, to solve the problem of getting through firewalls etc we are using XMPP: the user access his/her devices using an iOS/Android app. The app connects to the XMPP-server and so does the hardware devices. So the app can access the devices by sending custom XMPP stanzas.
Currently the device and the mobile app use the same JID, so the device will allow messages only from the same bare JID as itself uses. To allow for sharing devices we are planning to use the roster instead: the device will get its own JID ("hw381983829#thexmppserver.com") and will accept stanzas from all JID's in its roster.
The problem I'm having is that the users, devices and device-sharing data are stored on the webserver. I would like to use this same information on the XMPP-server: all users and devices on the webserver are allowed to login to XMPP and the roster of a device is the same as the users that may access it. This information can be accessed through a JSON API.
One way would be to mirror changes as they happen, but I don't like that idea since there are too many steps that could go wrong.
The best solution I can think of is to let the XMPP server use the JSON API instead of its builtin database. It would be read-only, but that is not a problem since all registration and sharing should be done on the webserver.
Any ideas on how to proceed? The functionality described above is more or less all that we need: we don't need S2S, offline messages, etc. We are currently using Ejabberd, but Prosody or Openfire are perhaps better alternatives?
For authentication, it looks like this ejabberd contribution does exactly what you need:
https://github.com/processone/ejabberd-contrib/tree/master/ejabberd_auth_http
For roster, it is easy to write a custom roster module that will be hitting your HTTP backend instead of query the database thanks to ejabberd API.
You can have a look at mod_roster as a guide to implement the methods: https://github.com/processone/ejabberd/blob/master/src/mod_roster.erl
The API clearly says that all user types can listen to full streams of tracks(Content Access Rules) in a Radio/ SmartRadio, I only get previews though when I pull an artist's radio track list...am I missing something?
Full track streaming is only available through the SDKs (Javascript, iOS or Android), for authenticated users. You'll have to use one of the playRadio methods available there.
Full track streaming - only available for authenticated users.
1) Would authenticated users need to individually sign up
2) and would they need to pay any subscription fees for playing (unlimited songs)?
Thanks