The Firebase Blog

Realtime Analytics For Everyone

March 1, 2017

Steve Ganem

Product Manager

Back in November we launched real-time conversions. This meant that your most important events were delivered immediately from end-user devices. Around the same time, we also launched real-time export to BigQuery, so that your client events could be analyzed within BigQuery as soon as they were sent to our servers.
But for those of you not using BigQuery, you'd often have to wait several hours before you could start to see any meaningful results from Firebase Analytics. And when it comes to tasks like debugging analytics within your app, or just getting a quick snapshot of how your community is reacting to your latest changes, those hours can feel realllly long.
To address those needs, we are pleased to announce that StreamView and DebugView from Firebase Analytics are being rolled out to the general public.
StreamView visualizes events as they flow into Firebase Analytics, and gives you a general sense of how your users are interacting with your app. With StreamView you can find out if a brand new feature is as well-received as you were hoping, watch the roll-out of the latest version of your app, or gauge the response to your latest re-engagement efforts - all in real-time as events are received by Firebase Analytics.
StreamView can give you a sense of where in the world people are using your app, right down to the city level…

...or what user properties are most common among your users….

You can also get an overview of what kind of events are being triggered in your app, and for any of those events, you can see a breakdown of all the custom event parameters you've been recording...

...and you can use all of these values as report filters to see where in the world certain events are occurring or certain products are popular, and you can see what user properties or events are common among users in certain countries or cities.
One unique feature available in StreamView is the User Snapshot. This will give you a live stream of the events from a random user. You can use the view to gain insight into the individual user journeys within your app.

Within the User Snapshot view you can see the set user properties, the user's device and location, and drill into the parameters of the events they're sending. You can filter the users included by their location and app version.

While you may still need to use BigQuery to get full and complete reports, or cross-reference certain sets data against others, there's a surprising amount you can learn about your app just by following the events as they happen in StreamView. The Santa Tracker team was an early customer of StreamView and they've assured me that it's (and this is a direct quote), "Pretty bad-ass."
You can can check out StreamView right away in our Demo Project!
While StreamView is a great real-time picture of your app once it's gone out to the general public, event delivery from device is still batched. This is great for users and battery optimization, but difficult when you're developing your app and need to check right away if your analytics setup is correct!
With DebugView, you can immediately see which events are being reported to Firebase Analytics. This will be activated for any device for which you've turned on Analytics Debugging, and is great for making sure you're logging the right events with the right parameters while you're building your app.

DebugView shows you events, parameters and user properties for any individual development device. It can also highlight any events that contain invalid parameters, so that you can get those fixed before you publish your app.

To get started yourself, take a look at our documentation on DebugView, or just look for these features in your own project console in the coming days and try them out!

Supercharge your games with Firebase for Unity and C++

February 27, 2017

Stewart Miles
Staff Software Engineer

Game Developers ConferenceGeneral AvailabilitysupportedAdMobUnity/C++.Analytics UnityC++Realtime DatabaseUnityC++Dynamic LinksUnityC++AuthenticationUnityC++Cloud MessagingUnityC++Remote ConfigUnityC++StorageUnityC++

getting started guide new samplessupport teamStack Overflowfirebase-talk

Email Verification in Firebase Auth

February 21, 2017

Laurence Moroney
Developer Advocate

Email Verification

Exploring Email Verification

https://github.com/firebase/quickstart-android

This email is shown on the Email Templates tab in the Authentication section of the Firebase console. From here you can edit the action link, or the reply address so that it appears to be from your domain, instead of authui-xxxx.firebaseapp.com as shown above.

Here you can see what happens once the account is verified and I sign in again.

You'll also see that this identity is present as a user in the Firebase console. You can manage them from there -- including changing their password or removing them from your app altogether.

Coding for Email Verification

Details on coding for email verification can be found in the Manage Users section of the Firebase documentation (Android, iOS, Web). For the rest of this post, I'll be looking at the Android code, but the implementation on the other platforms is very similar.

The core functionality is found on the FirebaseUser object. On it is a sendEmailVerification() method, which returns as Task used to asynchronously send the email, and report on the status. If the task is successful, you know the email was sent. Here's an example:

final FirebaseUser user = mAuth.getCurrentUser();
        user.sendEmailVerification()
                .addOnCompleteListener(this, new OnCompleteListener() {
                    @Override
                    public void onComplete(@NonNull Task task) {
                        // Re-enable button
                        findViewById(R.id.verify_email_button).setEnabled(true);

                        if (task.isSuccessful()) {
                            Toast.makeText(EmailPasswordActivity.this,
                                    "Verification email sent to " + user.getEmail(),
                                    Toast.LENGTH_SHORT).show();
                        } else {
                            Log.e(TAG, "sendEmailVerification", task.getException());
                            Toast.makeText(EmailPasswordActivity.this,
                                    "Failed to send verification email.",
                                    Toast.LENGTH_SHORT).show();
                        }
                    }
                });

In this case, the user is retrieved from mAuth.getCurrentUser(), and the sendEmailVerification() method is called on it. This gets Firebase to send the mail -- and if the task was successful, you'll see that a toast will pop up showing that it happened.
After the user clicks the link in the email, subsequent calls to user.isEmailVerified() will return true. Here's how it is used in the sample app:

mStatusTextView.setText(getString(R.string.emailpassword_status_fmt,
                    user.getEmail(), user.isEmailVerified()));

Do note that the FirebaseUser object is cached within an app session, so if you want to check on the verification state of a user, it's a good idea to call .getCurrentUser().reload() for an update.

In the sample app it just shows on the activity if the user's email address is verified or not. For your app you could limit functionality based on this state -- even to the extent of denying them access to the signed in section of the app.

You can learn more about Firebase Auth, including sign-in with other providers such as Google, Facebook, Twitter and more on the Firebase developers site.

Top sessions for mobile developers at Google Cloud Next 17

February 17, 2017

James Tamplin
Product Manager

If you're a mobile development rookie, your first stop should be "What to consider when developing mobile apps," in which Laurence Moroney, Google staff developer advocate, surfaces some of the gotchas of developing for mobile devices such as poor connectivity and offline devices, access control and battery life.

Then, march on over to "Zero to App: Live coding an app with Firebase and GCP," which will be a very cool live demo. Watch in awe as Googlers Mike McDonald, Jen Tong and Frank van Puffelen do simultaneous live coding of an app across both iOS and Android. You'll leave with an appreciation of how easy it is to code with Firebase, and how easy it is to scale with GCP.

For mobile devs that just want to focus on delivering a great UX, "serverless" development helps remove a big set of concerns from their plate. If that describes you, go see "Google Cloud Functions and Firebase," with Firebase team members Thomas Bouldin, software engineer and Brendan Lim, product manager, who will show you how to extend Firebase backend services with Google Cloud Functions to make the next generation of mobile and web apps.

Once you've built that awesome mobile app, you'll want analytics to understand how people use it. But building analytics infrastructure can be painful, and the same goes for log ingestion pipelines, and managing a data warehouse. We've got you covered. In "Gaining deeper insights from Firebase Analytics with Google BigQuery," Google developer advocates Todd Kerpelman and Arun Venkatesan will show you how to use Firebase Analytics and augment it with BigQuery and data visualization tools like Data Studio.

Of course, that's just the tip of the iceberg. For the full story, check out the schedule for a full listing of the keynotes, bootcamps and over 200 breakout sessions. Hope to see you there!

"How do I add Firebase Analytics to an app that's already using Google Analytics?"

February 16, 2017

Todd Kerpelman
Developer Advocate

Remote Config targeting First, Let's Talk Eventsfunc recordGameOver() { let tracker = GAI.sharedInstance().defaultTracker let gameOverEvent = GAIDictionaryBuilder.createEvent(withCategory: "gameOver", action: "totalScore", label: "", value: myGameStats.totalScore as NSNumber) let enemiesBeatenEvent = GAIDictionaryBuilder.createEvent(withCategory: "gameOver", action: "enemiesBeaten", label: "", value: myGameStats.enemiesBeaten as NSNumber) let roundsSurvivedEvent = GAIDictionaryBuilder.createEvent(withCategory: "gameOver", action: "roundsSurvived", label: "", value: myGameStats.roundsSurvived as NSNumber) tracker?.send(gameOverEvent.build() as [NSObject: AnyObject]) tracker?.send(enemiesBeatenEvent.build() as [NSObject: AnyObject]) tracker?.send(roundsSurvivedEvent.build() as [NSObject: AnyObject]) } FIRAnalytics.logEvent(withName: "gameOverTotalScore", parameters: [kFIRParameterValue: myGameStats.totalScore as NSObject]) FIRAnalytics.logEvent(withName: "gameOverEnemiesBeaten", parameters: [kFIRParameterValue: myGameStats.totalScore as NSObject]) FIRAnalytics.logEvent(withName: "gameOverTotalScore", parameters: [kFIRParameterValue: myGameStats.totalScore as NSObject]) let finalStats = ["totalScore": myGameStats.totalScore as NSObject, "enemiesBeaten": myGameStats.enemiesBeaten as NSObject, "roundsSurvived": myGameStats.roundsSurvived as NSObject] FIRAnalytics.logEvent(withName: "gameOver", parameters: finalStats) whole video Adding Firebase the Correct WayGoogleService-info.plistGoogleService-info.plistGoogleService-info

What you'll get back will be a superset of the plist file you'd get from both Firebase Analytics and Google Analytics -- if you examine its contents, you should see a TRACKING_ID entry equal to your Google Analytics tracking ID, along will a whole bunch of new Firebase info. Replace your old GoogleService-info file with this new one, go through the rest of the Firebase installation process, and you're ready to go. Option 1: Just Use Two Analytics SDKsfunc recordGameOver() { // All the old code you had previously to record Google Analytics // … // … So much code … // … // Now add the Firebase stuff let finalStats = ["totalScore": myGameStats.totalScore as NSObject, "enemiesBeaten": myGameStats.enemiesBeaten as NSObject, "roundsSurvived": myGameStats.roundsSurvived as NSObject] FIRAnalytics.logEvent(withName: "gameOver", parameters: finalStats) }

But this solution has a few drawbacks. For starters, you're now sending down data to two different analytics packages, which generally means that your client is making more network calls then before, and that means your app is using more of your user's mobile data and negatively impacting their battery life. On the other hand, Firebase Analytics tends to be quite conservative when it comes to making network calls, so we're only looking at a minor bump on top of your Google Analytics traffic. Option 2: Use Google Tag Manager to Report Events Everywhere

The nice part about this solution is that you only need one set of analytics-reporting code on your client. In our example, we would have a much simpler implementation where we could completely eliminate the Google Analytics calls:func recordGameOver() { let finalStats = ["totalScore": myGameStats.totalScore as NSObject, "enemiesBeaten": myGameStats.enemiesBeaten as NSObject, "roundsSurvived": myGameStats.roundsSurvived as NSObject] FIRAnalytics.logEvent(withName: "gameOver", parameters: finalStats) // That's it! }

Next, you'll create a trigger for each Firebase Analytics events you want to correspond to. In our case, we'd want to create a trigger that fires whenever we see an event name called "gameOver"

Finally, you'll create tags where you respond to these triggers by sending off events to Google Analytics (referred to as Universal Analytics within Google Tag Manager). You can also send off events to services such as AppsFlyer, Kochava, Tune, and others.

Now I like this approach because, frankly, any opportunity you get to write less code is usually a good thing. This also gives you the flexibility to report some events to Google Analytics but not others, (if you wanted to start reporting some events exclusively to Firebase Analytics), or change how you're reporting your Firebase Analytics events to Google Analytics, even after the app has shipped!

Option 3: Use BigQuery to Merge Everything

Now, granted, this solution only really makes sense if you're already a Google Analytics 360 customer and are currently using BigQuery to drive most of your custom reports. If this sounds like you, then updating your BigQuery queries to grab data from both data sources may be a reasonable option.

SELECT AVG(hit.eventInfo.eventValue) FROM `my_awesome_app.ga_sessions_20170123`, UNNEST(hits) AS hit WHERE hit.eventInfo.eventCategory = "gameOver" AND hit.eventInfo.eventAction = "totalScore" func recordGameOver() { let finalStats = ["totalScore": myGameStats.totalScore as NSObject, "enemiesBeaten": myGameStats.enemiesBeaten as NSObject, "roundsSurvived": myGameStats.roundsSurvived as NSObject] FIRAnalytics.logEvent(withName: "gameOver", parameters: finalStats) // That's it! } SELECT COUNT(*), AVG(total_score) AS average FROM ( SELECT event_param.value.int_value AS total_score FROM `firebase-project.com_example_awesome_app.app_events_20170123`, UNNEST(event_dim) AS event, UNNEST(event.params) AS event_param WHERE event.name = "gameOver" AND event_param.key = "totalScore" UNION ALL SELECT hit.eventInfo.eventValue AS total_score FROM `my_awesome_app.ga_sessions_20170123`, UNNEST(hits) AS hit WHERE hit.eventInfo.eventCategory = "gameOver" AND hit.eventInfo.eventAction = "totalScore" ) Google Cloud Big Data Blog

So there ya go, folks; a few pointers on how to add Firebase Analytics to your app that's already set up for Google Analytics. (Or, for that manner, any other analytics platform.) Once you've gotten that set up, I recommend trying out some Firebase features that make use of Firebase Analytics data: deliver a new Remote Config setup to users with a specific user property, or send a Notification to a Firebase Analytics Audience that you've created. And feel free to start tracking more Firebase Analytics events -- remember, it's free and unlimited, no matter how many users your app might have. There's a lot more exciting tools and features coming out for Firebase Analytics over the next year, so it's never too early to start adding Firebase Analytics to your mobile app. Give it a try!