Firebase Crashlytics

50% of one-star reviews in the Play Store has something to do with stability and bugs on the other hand 60% of five-star reviews make a mention of speed, design, or usability.So your end users really feel it when your experience is performant and is stable.Once you ship your app into the wild you have real users using your app, Firebase has tools such as Performance Monitoring and Crashlytics that allow you to understand the end user experience in production.

Firebase Crashlytics is now available to all Firebase developers.So if you’re an existing Firebase developer, you test out Crashlytics and upgrade.

Let’s talk a little bit about what that means for Crashlytics be available on Firebase.Because, as many of you know, Crashlytics is the market leader for crash reporting used by hundreds of thousands of developers their applications and installed in over 2.5 billion devices but what Firebase able to do now if bring Crashlytics into one unified console so it can truly work better together with all the other Firebase products.Firebase made sure to keep the install process amazingly simple.So whether you’re using Gradle on Android or CocoaPods on IOS, and you want to install the SDK manually, you can use you’re existing Google Services file and get up and running in a matter of minutes, just like any other Firebase SDK.

As a developer, you want to get the bottom of the crash and before using a crash reporting solution like Crashlytics, you actually know how to plug your phone into your Mac and find where they hide this crash report in Android Studio,you’re going to be looking at the stack trace.

 Firebase Crashlytics

What you really want is a crash reporting tool that can take that crash, along with all the other crashes that are happening in the wild, group them, prioritize them, give you an idea of how your app is doing stability-wise, release over release.


One great measure of that is looking at your crash-per-users statistic.So Firebase has a lot of customers who use this as a key performance indicator to know if their apps are getting more stable or less stable release over release and all these crashes prioritize them into issues and issues are ranked by the number of times they are occurring and the number of devices that they are occurring on.

Issues list

You can clearly see here the line of code that crashed, the file name, and even do things like call up interesting bits of information, like maybe this crash is only occurring on ios 11.So maybe that’s indicative of something changing in the latest release, maybe deprecated API that you’re not supposed to be using anymore.It lets you know that maybe this crash is only occurring on rooted or jailbroken devices.That could indicate that someone’s using your app in a way that you didn’t intend.So maybe you don’t want to fix this crash.Just a couple of quick things there to really help you know that just to get a better idea of what you’re going to be getting into in solving this crash.

Issues Detail

Now, diving even deeper, you’ll see that you get this Issue detail now you can see the full, now symbolicated or unobfuscated stack’ll see how the crash has been trending, version by version.You can see an operating system or device breakdown.
Realtime alerting emailThe console isn’t the only place you can find out about crashes.Firebase will alert you in real time, via email, the second a new issue arises.Firebase’ll let you know when a new issue arises not only new issues but also regressed issues.So if you close an issue, you think you’re all good and then we see that pop up on a new version, Firebase’ll let you know immediately about that.Velocity alerts are when one issue is causing a statistically significant portion of all sessions to crash.So this may indicate that you need to issue a hotfix right away or roll back because something really wrong is happening with your application and you get all this out of the box.This is with crash reporting.

Get started with Firebase Crashlytics

Firebase Crashlytics can work with the very little setup on your part—as soon as you add the SDK, Crashlytics gets to work sending crash reports to the Firebase console.

To get started with Firebase Crashlytics, you need an app with Firebase enabled.

  • Click Tools > Firebase to open the Assistant window.
  • Click to expand one of the listed features (for example, Analytics), then click the provided tutorial link (for example, Log an Analytics event).
  • Click the Connect to Firebase button to connect to Firebase and add the necessary code to your app.


 Enabled Firebase in android app

Add the Crashlytics SDK to your project

1.Add the Crashlytics repositories and dependency to your project-level build.gradle file:

2.Add the Crashlytics dependencies to your app-level build.gradle:

Customize your Firebase Crashlytics crash reports

For more fine-grained control of your crash reports, customize your Crashlytics SDK configuration. For example, you can add logs to track down pesky bugs, and more.

1.Retracing a user’s steps with logs

If I’m lucky, I may be able to look at the stack trace, see the line of code that crashed, and know exactly how to fix that.But If I don’t, I’m going to want to reproduce that crash.The great way to retrace a user’s steps is with custom logs.So from the issue Detail Page ,you can see the Logs tab and diving into that.

On Android, use Crashlytics.log to help pinpoint issues.

Crashlytics.log can write logs to a crash report and with Log.println(), or just to the next crash report:

  • Crash report and Log.println:

  • Crash report only:

Crashlytics limits logs to 64kB. Crashlytics deletes older log entries if a session’s logs go over that limit.

2.Finding Contextual cues with keys

Sometimes it’s not just about the order of operations that causes the crash.It’s actually the context that the user is in.You could imagine, maybe it’s the size of the file they have that they’re trying to upload maybe it’s how many items they have in their shopping cart, the level they are on a game.So here’s an example where I’m recording the key value.

Re-setting a key updates its value, for example:

Crashlytics supports a maximum of 64 key/value pairs. Once you reach this threshold, additional values are not saved. Each key/value pair can be up to 1 kB in size.

Log non-fatal exceptions

Crashlytics lets you log non-fatal exceptions.On Android, that means you can log caught exceptions in your app’s catch blocks:

All logged exceptions appear as non-fatal issues in the Firebase console. The issue summary contains all the state information you normally get from crashes, along with breakdowns by Android version and hardware device.

Crashlytics processes exceptions on a dedicated background thread, so the performance impact to your app is minimal. To reduce your users’ network traffic, Crashlytics batches logged exceptions together and sends them the next time the app launches.

Crashlytics only stores the most recent 8 exceptions in a given app session. If your app throws more than 8 exceptions in a session, older exceptions are lost.

Set user IDs

To diagnose an issue, it’s often helpful to know which of your users experienced a given crash. Crashlytics includes a way to anonymously identify users in your crash reports.

To add user IDs to your reports, assign each user a unique identifier in the form of an ID number, token, or hashed value:

If you need to clear a user identifier after you set it, reset the value to a blank string.

So these are a few tips with Crashlytics and how you can get the most out of crash reporting.

Related Post

Firebase Performance Monitoring for Android


Cloud Firestore Database for Web Application

Cloud Firestore is hot new document database in the cloud for mobile and web app for saving our data to the cloud.I want to create a little web app where we can store an Inspirational quote.My web app here consists of a text field, where I can enter my inspirational quote.We’ve got a save button, where we’re going to save whatever inspiring message our user has entered to the cloud.Later on, we’ll load whatever data our user has saved to the cloud and display it at H1 tag, so we can see the latest inspirational quote that we’ve entered.

If you want to follow along, go ahead and create your own version of this app.It really is nothing more than these UI elements here.Just make sure you have some InputText for the text fields and the label and create a button.

Getting Started with Cloud Firestore on Web

Let’s take a closer look at what I’ve got set up.So here’s index.html page, where I’ve got all my elements created.I’m loading the Firebase library.

Then, over here is my app.js file, where I’m configuring my Firebase project with the values that I got from the Firebase Console.

I’ve already created IDs for my header, my text field, and my button.So first things  I’m going to jump into my app.js file and create a few variables to hold references to these elements.I’ll do that just by calling querySelector.

Next up, I’m going to create a click event listener for the save button.Now I’ll grab the text that I want to save from my inputTextField.value and let’s log it to confirm.Let’s log it to confirm we have some actual data.

Initialize Cloud Firestore

Initialize Cloud Firestore through Firebase.

Now, I just need to save it to the cloud and to do that, I need to specify in which document I want to put this data.We do that through something known as a document reference.

I’ll be using the same reference a few times throughout this project.So I’m actually going to define it top of the script.
Firestore Database Pathyou’re always going to be alternating between collections and documents.

Now, I’ve specified my document, let’s go back to my event listener, where I’m going to call set on this document reference. Now, this will take in a JavaScript object to represent the data that we want to save for this document inspirationalQuote as textToSave that’s all I really need.This will replace my current document if it exists, and it will create it if it doesn’t.It also conveniently creates the samples collection too.So I don’t need to worry about whether or not that exists.

Now, the set function, as with most Firestore functions, returns a promise, which means it’s pretty easy to note when this call is I’ll attach a then callback at the end here, and print out a little success message, and come to think of it, I’ll add a catch here to print out any errors.

Error: Missing or insufficient permissions.

Cloud Firestore implementation contains a set of security rules that determine whether or not a certain action is permitted.The proper solution would be to add some sign-in using Firebase Auth and then create some proper, well thought out security rules, base on what information. I’m willing to share to each individual user.So I’m going to do a bit of a hack here and make anything in my samples collection open to the public.

Cloud Firestore Security Rules

So let’s head on over to the Firebase Console, make sure you’ve got your project selected, and I’m in the database section and then here, I’ll make sure cloud Firestore is selected for my list of database options.And then, I will click on the rule tab.Next, I’m going to add this here to allow reading and writing that’s part of my samples collection.

Time to load up our page and give this a try.

Cloud Firestore For web

I can verify this by going back to the Firebase console.We’ll select the Data tab to view our data.We’ll select our samples collection and sure enough, looks like we’ve saved our thought.

Get Data with Cloud Firestore

It’s great that we can see this data in the Firebase Console, we need to show this important information to our users too.So next up, let’s learn how to grab this data from the cloud and put it into our H1 tag.

Now, like the Realtime Database, Cloud FIrestore lets me listen to changes in the database and update my app in real-time.However, I know that for some of you out there, the idea of creating a real-time listener for all your data is weird and strange.Sometimes, you just want a basic fetch call to get your data, right? So I’m going to show you how to do that first and then, we can talk about getting fancy with our real-time listeners.

Now, getting this function to work is actually quite easy.I’m going to take that same document reference we created earlier and, instead of calling set on it, I’m just going to call get instead.This returns a promise.So I can attach a then callback to it, which will run when this get call is complete.Note that, this takes in a documented snapshot that I’m just calling doc here.A document snapshot is basically an object that represents your document. You can find out its ID, read some metadata about it, make sure the underlying document it represents really exists, and more importantly, grab the data that it contains by calling data on it.So we’ll see if this snapshot exists and if it does, we will call data to extract the contents of that document as an object.Then, I can set the text of our big output header to my data.inspirationalQuote.And as long as we’re here, let’s add a catch at the end to catch any error that might come up.

So let’s run this.I can still save our latest quotes to the world. Now, I’ll click the Load button to load it and there it is on our page.
Cloud Firestore Web Get Data

Get Realtime Updates with Cloud Firestore

So this is great.We’ve got our data successfully saved and loaded from cloud Firestore.But what if you are interested in getting your data in real time? What if this explicit fetching seems quaint and old-fashioned to you? Well, let’s show you how to get your data in real-time as well.

Basically, the process is going to work nearly the same.Let’s create a function called getRealtimeUpdates and in there,I’m going to bring up my document reference.But then instead of calling get, I’m going to use the onSnapshot.This will fire the first time I call it.But then, it will also fire any time thereafter when my data changes.Now, this call takes in a callback function, which accepts the document snapshot as an argument, essentially just like my get call.So in fact, I’m just to copy the exact same code for my get call into here to update my label.Well, that’s it.We’ll call getRealtimeUpdates at the bottom of our script.That should be all we need.Here, let’s reload the page.

Now you can see that my text automatically gets updated with current save Quote the value that was in the cloud previously.I hit save and you can see that my label gets updated automatically without my having to even touch that load button, that was fast.In fact, maybe too fast, right? It looks like my label got updated before that data was even saved.How’d that happen?

Cloud Firestore for web real-time update

Well, what’s happening is that cloud Firestore is making my app run as speedy as possible, by notifying me of changes as if they had happened on the server.But in the meantime, It’s still going ahead and updating that data remotely in the background.

Download this project from GitHub


Related Post

Firestore Document Database Data Model.


Firestore Security With Firebase Authentication

Cloud Firestore Security Rules are used to determine who has read and write access to collections and documents stored in Cloud Firestore, as well as how documents are structured and what fields and values they contain.

In this tutorial, We will learn how to secure your data using Firebase Authentication and Cloud Firestore Security Rules to handle serverless authentication, authorization, and data validation.

To set up and deploy your first set of rules, open the Rules tab in the Cloud Firestore section of the Firebase console.

Cloud Firestore populates a default rule, denying read and write access to everyone on all data:

Working with Security Rule

Cloud Firestore stores its data in a hierarchy of collections, documents, and subcollections, and you’ll often be working to secure data that is several layers deep in the hierarchy. Therefore it’s important to understand how to best work with this hierarchical data.

All documents in Cloud Firestore are stored in a path that begins with /databases/database name/documents — this path is generally not visible to clients working with Cloud Firestore. A client might be writing data to the employees/stanley document, but from the perspective of the Cloud Firestore Security Rules, this write is occurring at databases/database name/documents/employees/stanley.

Match Path

Rules match paths representing a document or collection in Cloud Firestore. Rules may match one or more paths and more than one rule can match the document name in a given request.

The basic type of rule is the allow rule, which allows read and write operations if an optionally specified condition is met.

In most cases, you’ll want to write rules that apply to any document within a collection, not just a specific one. In these situations, you can use wildcards to specify any element within a path. A wildcard is created by adding curly brackets around a string.

Apply rules to multiple documents or collections with wildcards. Wildcards represent the document or collection ID in the match path as a string between curly brackets. Add =** to the end of your wildcard string to apply the wildcard to all documents and subcollections in the path.

The request variable

The request variable is a map that contains information about the request that’s coming in from the client. You can view the reference documentation for a full list of fields, but two fields you’ll frequently be working with are the auth field, which contains information from Firebase Authentication about the currently signed-in user, and the resource field, which contains information about the document being submitted.

Common use cases for the request object include:

  • Confirming that request.auth is not null to ensure that a user is signed in
  • Using the value of request.auth.uid to get the user’s ID, as verified by Firebase Authentication
  • Using to ensure the value being submitted for a document write meets a particular format. This is most common way to perform data validation within your database.

For example

Resource  vs Request.resource variable

The resource variable is similar to the request.resource variable, but it refers to the document that already exists in the database. In the case of a read operation, this is the document that is about to be read, while in a write operation, this is the old document that is about to be updated or altered.

Both the resource and request.resource objects are maps. Each contains a __name__ property indicating the document name, and a data property where all user-defined properties are declared. By accessing keys within the data property of these maps, you can get the values of the various fields belonging to the document being referenced. For example, is mapped to the value of the kesselRun field within the document represented by the resource variable.

Examples using the resource object.

Get Document From Database

Using the resource variable will let you evaluate the current document that is about to be accessed, but sometimes you will want to evaluate other documents in other parts of the database.
You can do so by calling the get() function with the document path in the database. This will retrieve the current document, which will allow you to access custom fields through the data property, just like the resource object.
One very common use of this function is to evaluate an access control list and determine if the userID of the current user is part of that list.
The exists() function can also be used to determine if a document already exists.

When entering a path into the exists or get function, you do not include quotes. If you want to include a variable in the path name, you should enclose the variable in parenthesis and preface it with a dollar sign.

For example:

Add Firestore Security Rules with Android Example

In previous tutorial we build a ‘MyThought’ application using Firestore which use for saving thought in Firestore database.In this tutorial we use same project to add firebase security rule.

Add Firebase Authentication

In the Authentication tab of the Firebase console go to the Sign-in Method page and enable ‘Google’
Firebase Enable Login With Google

Add Dependency

Add following dependency in your app.gradle file.

Add FirebaseUI

FirebaseUI has separate modules for using Firebase Realtime Database, Cloud Firestore, Firebase Auth, and Cloud Storage. To get started, see the individual instructions for each module.

Security Rules

Add the following security rules to your project in the: rules tab:

  • Rule 1: Only authorized users can create, read them.
  • Rule 2: Only the user who Creates the Thought can delete it. Thought can never be updated.


Download this project from GitHub


Related Post

Firestore Document Database Data Model.
Firebase Firestore Database for Android Application.


Firestore Document Database Data Model

We’ve all done things in relational databases for many many years and we’ve become really good at doing that.When we come across the document databases we have to retrain our brain. We have to think slightly differently when we do this otherwise we may run into some challenges.

If you think in the world of relational data you always had a model first. You thought about your tables and thought about what went in and you built your schema.So just because we’re in a document database that doesn’t mean we don’t model .we’re still modeling as just as in a relational database. It’s a little bit different where the relational data engine typically enforcing your schema or in a document database engine typically it’s the developer that’s enforcing that schema.So you build your models it’s usually built from some use case that you’re working on and driven from your code on down to the database.

Set the context how fundamentally different the approaches are. I’m going to find a scenario quickly and then to two extreme scenarios one on either end of the spectrum but it should give a good idea of the difference between the two approaches.

Let’s say I’m building an application that deals with Motor Vehicles. I want to display a motor vehicle on the screen.I may use some kind of ORM or some kind of mapping tool or some kind of middleware that takes my app and changes the format and then store it in the database separately.In a relational database, you may actually take the motor vehicle and break it up into component parts and store each one of those component parts in their own kind of table.I may store all wheels together and all engine blocks together and you get the idea very extreme.You probably wouldn’t model a database quite as extreme as the picture but you know you get the idea and then when you want to display the vehicle again on the page you write a bunch of code either in the database or in this middle tier or in your application to take all of these parts reassemble it back to a motor vehicle and then present the motor vehicle on the page.

Document vs Relational database

The other side of the spectrum in a document database is, you have a motor vehicle and you send that over the wire as it is and you persist that whole motor vehicle as a motor vehicle object in the database and when you want to display that motor vehicle on the page you do a query for the motor vehicle you bring it down to the page over the wire and you display it on the page.Those are the two different kinds of extremes.

If we take a look at a more realistic data modelling example a person and a person has contact details a contact detail has a type and we split these up into separate tables, we use foreign keys to kind of you know to break this up and reassemble the object and that ‘s what it would look like in a relational world.

Relational database

A document world we take a document called the person and we have attributes and on that, we may actually go and embed in and address a contact detail or multiple contact details and this is what the same thing would look like in a JSON document.

Document Database

Why we need  Document Database?

The document database is expressive, efficient, and flexible. Create shallow queries to retrieve data at the document level without needing to retrieve the entire collection or any nested subcollections.

Firestore Document Database

Cloud Firestore is a flexible, scalable database for APP.It keeps your data in sync across client apps through realtime listeners and offers offline support for mobile and web so you can build responsive apps that work regardless of network latency or Internet connectivity. Cloud Firestore also offers seamless integration with other Firebase and Google Cloud Platform products, including Cloud Functions.

How does it work?

Cloud Firestore is a  NoSQL database that your apps can access directly via native SDKs.

Firestore Document Database Structure

Following Cloud Firestore’s NoSQL data model, you store data in documents that contain fields mapping to values. These documents are stored in collections, which are containers for your documents that you can use to organize your data and build queries. Documents support many different data types, from simple strings and numbers, to complex, nested objects. You can also create subcollections within documents and build hierarchical data structures that scale as your database grows.

Add, sorting, filtering, and limits to your queries or cursors to paginate your results. To keep data in your apps current, without retrieving your entire database each time an update happens, add realtime listeners. Adding realtime listeners to your app notifies you with a data snapshot whenever the data your client apps are listening to changes, retrieving only the new changes.

Firestore Data Model

Firestore is a document database that means it kind of stores your data in a big tree like structure kind of like the original real-time database but everything is placed into documents and collections.

Document Database Database


You can think of a document is something kind of like a map it’s got key-value pairs which is the Firestone folks like to refer to as fields and the values of these things can be any number of things from strings to numbers to binary values to little small maps that are kind of JSON looking objects.

Firestore Document


The collection is basically well collections of documents.

Firestore Collection

There are a few rules around the use of this thing.

Rule 1: Collections can only contain documents nothing else no collections of strings or binary or anything else.

Rule 2: Documents can’t contain other documents but they can point to sub collections so it’s very common to see a collection containing a bunch documents which then point to sub-collections that contain other documents and so on in a user workout app for instance.

Firestore Document Database Example

I might have a users collection and this collection would contain a document for each user and then each of those documents might point to a workout subcollection that in turn contains a document for each different type of workout that this user is performed and then maybe each one of these has a history sub-collection that keeps track of every time the user performed one of these workouts may be along with like some average heart rate data or some other stuff like that.

Rule 3: The root of your database can only consist of the collection now in a normal production app this is going to feel pretty natural.

Firestore Rule #3


If you’re coming from real-time database land this kind of deep nesting might be giving you heart palpitations but don’t worry this kind of data structure is completely normal in the cloud Firestore world where queries are shallow meaning that when you grab data from a document you’ll garb just that document not any of the documents contained in any of the sub-collections below which nice.


Related Post

Firebase Firestore Database for Android Application.
Cloud Firestore Database for Web Application.
Firestore Security With Firebase Authentication

Firebase Firestore Database for Android Application

No matter what kind of app you’re developing these days, there’s a good chance
you’ll want to store data in the cloud.Because your user wants to assess their data from more than one device.

Cloud Firestore lets you store your data in the cloud, so you can sync it across all your devices or share them with multiple users.It comes with all the conveniences you’d expect from a firebase product, like robust client libraries, full support for offline mode so your app will continue to work just fine whether you’re connected or not– even on the web– a comprehensive set of security rules to help you manage access and sleep at night and an easy-to-use data browsing tool.It also lets you structure your data in ways that make sense to you thanks to its powerful querying and fetching capabilities.

Cloud Firestore works in near real time, automatically fetching changes from your database as they happen, or you can request and fetch data manually.It’s completely up to you.

Firestore integrates with other Firebase products, including firebase Authentication for easy sign-in and Cloud Functions, which lets you run all sorts of server-side logic in response to changes in your database, all of which means you get a truly serverless development experience.That means you can spend less time on infrastructure issues and more time building your app.

Getting Started with Cloud Firestore on Android

So I’m working a little app here that lets me store a thought.

My App consists of an EditText view where I can enter my thought and then the second one here where I can enter the publisher’s name and  then I have Publish button where we’re gonna save whatever thought our user has entered into the cloud so later we’ll load whatever data our users saved to the cloud and display it with a big Listview or something

Enable Firestore in Firebase

In order access to Firestore you need to enable Firestore in Firebase Console.

Enable Firestore

Add Firebase to your Android project

Create a Firebase project in the firebase console and configure the Google services plug-in with JSON file.

Add Firebase to your Android project


Firestore is a Document Database

Let’s take a moment to understand how cloud Firestore generally works frankly this could be the subject of its own separate post and it probably will be one day but here is the executive summary.

Document Database Database
Firestore is a document database that means it kind of stores your data in a big tree like structure kind of like the original real-time database but everything is placed into documents and collections
Firestore Document
You can think of a document is something kind of like a map it’s got key-value pairs which is the Firestone folks like to refer to as fields and the values of these things can be any number of things from strings to numbers to binary values to little small maps that are kind of JSON looking objects.

Firestore Collection
The collection is basically well collections of documents so there are a few rules around the use of this thing.

Rule 1: Collections can only contain documents nothing else no collections of strings or binary or anything else.

Rule 2: Documents can’t contain other documents but they can point to sub collections so it’s very common to see a collection containing a bunch documents which then point to sub-collections that contain other documents and so on in a user workout app for instance.

Firestore Document Database Example

I might have a users collection and this collection would contain a document for each user and then each of those documents might point to a workout subcollection that in turn contains a document for each different type of workout that this user is performed and then maybe each one of these has a history sub-collection that keeps track of every time the user performed one of these workouts may be along with like some average heart rate data or some other stuff like that.

If you’re coming from real-time database land this kind of deep nesting might be giving you heart palpitations but don’t worry this kind of data structure is completely normal in the cloud Firestore world where queries are shallow meaning that when you grab data from a document you’ll garb just that document not any of the documents contained in any of the sub-collections below which nice.

Rule 3: The root of your database can only consist of the collection now in a normal production app this is going to feel pretty natural.
Firestore Rule #3

When you’re creating a little test app like ours and you just want to save like two string so looking at app at the top level I’m gonna starting with a collection that I’m calling “lifethought ” this will then contain one single document called “publicThought” this document will contain subcollections and this subcollection contain individual call “thought”  which is identified by unique id.

Add Firestore Dependency to your app

Let’s start building so first thing you need to make sure you have Firestore installed and so you’ll go into your app.gradle file and add Firestore to your project.

We’re good, so next in my main activity here I’m gonna head on down to my publishThought call.

Cloud Firestore also supports writing your own Java objects with custom classes. Cloud Firestore will internally convert the objects to supported data types.Each custom class must have a public constructor that takes no arguments. In addition, the class must include a public getter for each property.

Now you just need to save this to the cloud and to do that you need to specify in which document you want to put this data so you do that through an object known as a DocumentReference let’s initialized it up.

I pass along a slash-separated string as our path so in our case, the path would be “thought/lifeThought

Just remember that in your path you’re always going to be alternating between collections documents collection document and so on.Firestore Database Path

so now that I’ve specified my document. In my publishThought() method where I’m going to call set on the document reference and that will take in the data. I created above as the contents of my document this call will replace my current document if it exists and created if it doesn’t it also conveniently create the sample data collection too so I don’t need to worry about that not existing now I’m going to chain on an addOnSuccessListener like so where we can print a debug message. And then we can add an addOnFailureListener listener where we can print out any error messages.

For those of you who are all about fewer listener in your call, you could also handle this with a single OnCompleteListener like and then just check in here to see if your task is successful either way works and honestly it’s just really up to you which method you prefer.

Error on Document Writing PERMISSION_DENIED: Missing or insufficient permissions.

Just like the real-time database cloud, Firestore implementation contains a set of security rules that determine whether or not a certain action will be permitted.By default they’re set up that nobody can read or write to the database.I’m willing to share with each particular user.So I’m just going to do a bit a hack here and make my sample data documents open to the public.

Set Firestore rules

I’ll select my project go to database selection and then make sure I select cloud Firestore for my list of database options then I will click the rules tab and then I’m going to add these lines here to allows reading and writing to anything that’s part of my sample data collection now this a pretty terrible idea from a security perspective but at least I’ve contained the damage to just what’s in my sample data collection so I’ll publish that and we are done.

So I’m going to start up my app, and I am going to enter thought in the text field and I hit publish button.

Firestore Database on android

I can verify this by going back to the Firebase console we’ll select the data tab and then I can look at our data collection find our document and sure enough look likes we’ve saved our inspiring thought to the world.

Firebase Cloud Firestore Database

Get Data with Cloud Firestore

We need to show our users this inspirational thought by grabbing that data from the cloud and populating in some kind of list view with it now like the real-time database cloud Firestore lets me listen to changes in the database and update my app in real time.

So let’s create a Thought List  I’m  gonna add a Recyclerview in the middle of my screen that has a TextView where I can display the thought and publisher name.

I already have my document reference.

Perform Simple Query in Cloud Firestore

Cloud Firestore provides powerful query functionality for specifying which documents you want to retrieve from a collection. These queries can also be used with either get() or addSnapshotListener().

Get Realtime Updates with Cloud Firestore

You can listen to a document with the onSnapshot() method. An initial call using the callback you provide creates a document snapshot immediately with the current contents of the single document. Then, each time the contents change, another call updates the document snapshot.

When I publish thought now my callback is getting called twice once for the change in my local cache and then once on the server.This is because of an important feature called latency compensation.

Download this project from GitHub


Related Post

Firestore Document Database Data Model.
Firestore Security With Firebase Authentication

Firebase Performance Monitoring for Android

Waiting for things to load is part of everyone’s mobile app experience.But it’s never a good experience for your user and how would you even know what the experience is? Your user is on a wide variety of devices, in a wide variety of networks, in a wide variety of locations all over the world.If you want to optimize the performance of your app, you metrics that tell you exactly what’s happening during the critical moments of your app’s use.You need that information to come directly from users.Now, You can get using Firebase Performance Monitoring.By integrating the SDK into your app, and without writing any code, your performance dashboard in the Firebase console will collect information about your app’s performance, as seen by your users.You’ll get data about your app’s startup time and details about its HTTP transactions.Using the provided API, you can instrument your app to measure those critical moments that you want to understand and improve.Then, in the dashboard, you can break down the data by Country, Version, Device, OS, Radio, Carrier, MIME type.

Install Firebase SDK in APP

This guide shows you how to use Firebase Performance Monitoring with your app.

1 Prerequisites

You need a few things set up in your environment:

  • A device running Android 4.0 +, and Google Play services 11.0.4 +
  • The Google Play services SDK from the Google Repository, available in the Android SDK Manager
  • The latest version of Android Studio 2.2+

2 Add Firebase to your Android project

Add Firebase to your app from Android Studio using the Firebase Assistant.To open the Firebase Assistant in Android Studio:

  1. Click Tools > Firebase to open the Assistant window.
  2. Click to expand one of the listed features (for example, Analytics), then click the provided tutorial link (for example, Log an Analytics event).
  3. Click the Connect to Firebase button to connect to Firebase and add the necessary code to your app.

Firebase Performance Monitor

3 Add Performance Monitoring to your app

  • Add the following dependencies project-level build.gradle :

Add the following dependencies app-level build.gradle :

  1. Below apply plugin: '', add the following line:
  2. Add the following to the dependencies section:
  3. If your app uses other Firebase SDKs, you should also change the version to 11.0.4 for those SDKs.


Recompile your app. Automatic traces and HTTP/S network requests are now monitored.

If you just install the SDK, you still get a few out-of-the box traces, the most important one being app start.This is the time between the app code start loading until the app is responsive to the user.Firebase also has a trace that monitors the foreground session so anytime the app is available to the user.and we do the same for the background as well.

Performance issues that can impact you as a developer falls under one of two buckets.The first one has to do with your app code performance.

So this is a thing like what kind of delays your user see as they interact with the app, or how much frame drops they see in the animation to monitor that Firebase built feature called Traces.

The other category of issues is about network activity between your app and the backends that it uses for that Firebase monitor network requests.


The easiest way to define a trace is its performance report between two points in your app.Imagine you have a record button and a stop button, and in between those two points you just pick up metrics, So these two points can be anything in your app, anything that you care about and you think is worth monitoring.So it could be something like the time between the user taps on one of the shoes until they see the full product details page.It could be as fine grained as a database fetch to get a piece of string and put it on the screen or it could be as long as the full checkout flow.

All you need to do is create a trace name or a trace object, give it a name, start it and stop it.That name you give it becomes your context.

Add the @AddTrace annotation to trace specific methods

You can add the @AddTrace annotation to methods in your app and provide a string to identify the resulting trace. This causes a trace to start at the beginning of this method, and to stop when the method completes. Traces created in this way do not have counters available.

Trace Metrics

In terms of metrics, by default you get the trace duration, so how much time took place between the start from the stop.So essentially, you can use it a time.But it’s actually more than that because you can attach custom metrics using counter API.which you see an example of here.So here think any example of countable events that are relevant to your performance how many times you called the local disk, how many times you called the GPS, how many times you dropped a frame, how many times you made a network call, and so on.


Any one of these events you can just give it a name, You can count it increment it and we’ll tally up those events and report them as custom metrics attached to your trace.

Network Monitor

An HTTP/S network request is a report that captures the time between when your app issues a request to a service endpoint and when the response from that endpoint is complete. For any endpoint that your app makes a request to, the SDK will capture several metrics:

  • Response time: Time between when the request is made and when the response is fully received
  • Payload size: Byte size of the network payload downloaded and uploaded by the app
  • Success rate: Percentage of successful responses compared to total responses (to measure network or server failures)


Disable the Firebase Performance Monitoring SDK

You can disable the Performance Monitoring SDK when building your app with the option to re-enable it at runtime, or build your app with Performance Monitoring enabled and then have the option to disable it at runtime using Firebase Remote Config. You can also completely deactivate Performance Monitoring, with no option to enable it at runtime.

Disable during your app build process

Disabling Performance Monitoring during your app build process could be useful is to avoid reporting performance data from a pre-release version of your app during app development and testing.

Add the following property to your app’s file to disable automatic traces and HTTP/S network request monitoring (but not custom traces) at build time:

Changing this property to true re-enables automatic traces and HTTP/S network request monitoring.

Allow your app to enable it at runtime, by adding a <meta-data> element to the <application> element of your app’s AndroidManifest.xml file, as follows:

To completely deactivate Performance Monitoring with no option to enable it at runtime, add a <meta-data>element to the <application> element of your app’s AndroidManifest.xml file, as follows:


Related Post

Phone Number Authentication with Firebase Auth

Firebase Crashlytics

Memory Leak


Phone Number Authentication with Firebase Auth

Growing Globally with Phone Number identity

Identity is a really important part of growth.If people can’t or won’t login to your app, then you don’t get a user.You don’t have growth.

Why phone numbers?

Using phone number as an effective identity for growth.Sign-in is such an important part of your growth funnel.Over 90% of people who have issue login into an app is going to leave.

1.They’re global.

Every single person in the world who has a smartphone has a phone number that they have memorized.

2 Actually, in a lot of emerging markets, We’ve learned that people prefer to use their phone as their identity instead of an email address or another form of identification.

3 Phone numbers are higher quality.They give you higher quality users.Because they’re more expensive to mass produce, they’re naturally resistant to the kinds of abuse and fraud you might see more often in another type of identification.Most importantly very low-friction sign-in for apps.

Why is login so hard to use?

We know as developers that passwords don’t increase security as much as they frustration and friction.

As a developer, we know that login is harder than it needs to be dealing with login is hard.There are UX implications.There are security implications.

Firebase Phone Auth

Today’s apps need to be able to support high-quality,low-friction authentication and engage with them in new ways.That makes phone number auth really valuable.

A lot of the apps that actually don’t have phone number authentication today, bBuilding it in the first place can be a real struggle.The first thing you’ll need to do is integrate with an SMS provider, and get coverage with carriers to send SMS.Then,you’re going to want to expand your offering globally to support all the different areas that your user might come from, making sure you’re perfectly localized along the way.

After all of that, you need to build secure authentication.That means generating a one time code, verifying it from a user, minting cryptographically signed tokens, persisting session, writing your anti-abuse logic. Firebase launched its phone authentication APIs.

The first thing that Firebase allow is it enables basic sign-in and sign-up flows. On Android Firebase actually, allow a few and built in enhancements.In the previous post you understand about the SMS retriever API, which actually increases overall conversion from users, SO they don’t have to end up with the SMS app and parsing it.This is going to come built into firebase Android APIs.Finally, Firebase has a really new cool piece of functionality called instant verification on Android.

Firebase enables basic sign-in and sign-up flows.

The first thing that Firebase want to make sure enable your app to do is allow you to sign in and sign up your users.All a user would need to do is enter their phone number, and you can go ahead and pass it over to Firebase.

Firebase will validate the phone number, handle any normalization logic that needs to happen, if this is a new user, or a returning one, and go ahead and generate a one-time code associated with this request.

The new user will simply pass back the code into your application, and which you would just pass right back on to Firebase, and Firebase will verify it.Firebase will handle any of the complex logic, and deduplication, if you send multiple SMS by mistake or any of the other edge cases that might arise.The user will go ahead and enter their code.Firebase will validate it.Firebase will go ahead and mint cryptographically signed tokens, persist sessions the whole authentication.You won’t have to worry about how any of it.


Auto-retrieval works very similarly to we discussed in the previous post.It’s comes built in the user phone auth APIs.For auto retrieval, if the user goes ahead and click sign with the phone number.This time they can actually select their phone number if you integrate with hint selector.It’ll be auto-populated into the application.Firebase will validate it once more. Firebase will generate the code.But this time, when firebase actually sends the code in the SMS, Firebase will be able to pick it up from the background.Firebase auto-retrieve it directly, parse it out and populate it into the application.The best part of all of this is your user never actually had to leave your application, go to an SMS tab, wait for it and then copy and paste the code into your UI.They stayed in your application the entire time.It’s a really seamless experience for them overall.That’s all that you ever to do.All this powerful functionality is also really easy to use.


As a pre-requisite, ensure your application is configured for use with Firebase.

Then, add the FirebaseUI auth library dependency.

The second thing you need to do is just enable phone auth within your project in the Firebase console.


Enable Firebase Phone Auth

Now Firebase headless APIs don’t enforce any UI, so they give you programmatic access to our underlying infrastructure that you can use in any way that you choose.It’s really easy to use.On Android, in order to get all the awesome functionality the actual ability to generate and send codes, the auto-retrieval, even instant verification, comes down to just one single API call, and the implementation of the callbacks that you care about.

What’s about UI?

Building authentication UI can be pretty complex.You need to handle all sorts of edge cases across all the different platforms your application might support.You want to make sure that your login UI is actually high performance.That will give you good conversion rates.FirebaseUI wrote out all the code for different phone authentication flows that.


The first thing you’ll notice is Firebase UI integrates with hint selector directly.So I didn’t write any additional code for this.It’s able to pick up user’s phone number from the device, and I can just simply enter it directly into the app.

Now when you hit verify phone number, it’ll go ahead and send a code which will directly get right off the SMS.The code was sent to your device immediately written from the SIM.All I did was really tap my phone number and everything else was taken for me.The SMS was delivered.It was passed.It was taken.I never left the app.

Instant Verification

Instant verification works exactly like it sounds like.It allows you to verify the phone number without sending an SMS to the user, it appears instantly.Let’s How it works?

1.User Select Number

This time, When they enter their phone number, and you call APIs, Firebase is going to do the first check.That check will go ahead and see if firebase has verified this phone number on the device recently.If it has, it can actually instantly verify the phone number the next time around without needing to send any additional SMS.It thinks that this means there is no wait time, on SMS, or anything else, just pure simplicity verify.


Imagine that user coming back to the application, maybe after a week or two.This time user going to instant verification.When the user goes to the application, let’s sign in with a phone number again.It’ll pull up the phone number for user device just like last time.The user just going to do single tap log-in.Where I go ahead and select a phone number, It sees that I’d already been verified in the past and that It’s.No SMS was sent, nothing else.But instead, Firebase was able to just validate that we verified it, and logged them in directly into te application.


Related Post

SMS Retriever API

SMS Retriever API

Automatic SMS Verification with the Phone Selector and SMS Retriever API

Enable to support phone numbers for authentication, if you have an existing backend infrastructure that you are already using for verifying the phone numbers.

Using SMS Retriever API, you can perform SMS-based verification in your app automatically, without requiring the user to manually type verification codes, and without requiring any extra app permissions.

Most apps perform verification by sending an SMS to the user’s device with a one-time verification code that the application that verifies.So the app has to get the phone number of the device and then read the verification code from the SMS.

The Google Play Services SDK(10.2 and newer) offering you to enable read the phone number and the verification SMS automatically without requiring these extra permissions.

For reading the phone number, Android has the Phone Selector API.For verifying the phone number, Android has the SMS Retriever API.These APIs are part of the Google Play Service SDK.

1.Getting the phone number of the device

Don’t ask the user to enter these values.Manually inputting the phone number is painful.It adds a lot of friction for the user to provide a phone number to your app.It’s also error-prone.

Phone Selector API

Phone Selector API provides the Phone number to your app with a much better user experience and no extra permissions.Using this API, you can launch a dialogue, which shows the phone numbers on the device to the user.

Phone Number HintSelector

First, you create a hint request object and set the phone number identifier supported field to true.

Then, you get a pending intent from that hint request for the phone number selector dialogue.

Once the user selects the phone number, that phone number is returned to your app in the onActivityResult().

2.Reading the verification code automatically using SMS retriever API

SMS Retriever API provides you the message content to your app without requiring any extra permissions.The key part is that it provides you only the message targeted your app.You have to verification code in your SMS message and include app-specific hash.This app-specific hash is a static hash that you can just include in the SMS template without requiring many code changes.

SMS Retriever API

Start the SMS retriever

This makes it wait for one matching SMS, which includes the app-specific hash.

Once the SMS with the app-specific hash is received on the device, it is provided to your app via broadcast.

In your broadcast receiver, you can get the message content from the extras.Once you have the message content, you can extract the verification code, and verify the code just like you would normally do.

Register this BroadcastReceiver with the intent filter.

After starting the SMS retriever, you can just send the SMS with the verification code and the app-specific hash to the phone using any backend infrastructure of yours.

3.Construct a verification message

Construct the verification message that you will send to the user’s device. This message must:

  • Be no longer than 140 bytes
  • Begin with one of the following strings:
    • [#]
    • Two consecutive zero-width space characters (U+200B)
  • End with an 11-character hash string that identifies your app

Otherwise, the contents of the verification message can be whatever you choose. It is helpful to create a message from which you can easily extract the one-time code later on. For example, a valid verification message might look like the following:

Computing your app’s hash string

ou can get your app’s hash string with the AppSignatureHelper class from the SMS retriever sample app. However, if you use the helper class, be sure to remove it from your app after you get the hash string. Do not use hash strings dynamically computed on the client in your verification messages.


Related Post