Hide chapters

Real-World Android by Tutorials

Section I: Developing Real World Apps

Section 1: 7 chapters
Show chapters Hide chapters

19. Firebase Integration
Written by Subhrajyoti Sen

Heads up... You're reading this book for free, with parts of this chapter shown beyond this point as scrambled text.

Building and releasing an app is quite a feat, but you soon realize that it’s just the first step of the process. You need to monitor how your app performs for different users and how your users interact with the app, among other factors, so you can offer the best possible experience.

Traditionally, you’d need different tools for each of these tasks, and building and integrating everything would be tedious. Google addressed those problems by introducing Firebase, a complete suite of services that can help you build your app faster, monitor it in the real world and better engage your users.

In this section, you’ll learn how to use:

  1. The Firebase Console to set up Firebase for your project.
  2. Crashlytics to detect and understand app crashes.
  3. Remote Config to add dynamic content to your app.
  4. Test Lab to perform different tests across a wide range of devices.

You’ll start at the beginning: getting Firebase ready to use.

Setting up Firebase

To set up Firebase, you first need to create a new project at Log in using a Google Account and you’ll see the Firebase Console. Firebase will prompt you to create a new project, as shown below:

Figure 19.1 — Creating a Firebase Project
Figure 19.1 — Creating a Firebase Project

Creating a Firebase project

Clicking Create a project will bring you to the Create a project page. You’ll see a prompt to provide a project name, as shown below. Enter PetSave.

Figure 19.2 — Insert Firebase Project Name
Gosate 76.1 — Axyopb Kumuriqu Sfilacn Vafa

Figure 19.3 — Google Analytics Configuration
Zivaye 06.2 — Heindo Upufwdahs Beslalejajaoz

Registering an app

Now that you’ve created your project, you’ll see an option to add Firebase to your app, as shown below:

Figure 19.4 — Adding Firebase to Your App
Qafaju 40.5 — Idqovc Siyekewu ja Taiv Ulf

Figure 19.5 — Register Your App
Judifi 10.8 — Vozohhes Veub Ald

classpath ''
apply plugin: ''
implementation platform('')


App crashes are among the things developers dread the most. Not only do they prevent the users from using one of the app’s features, but they also create a negative impression. Having a high crash rate leads to lower ratings on the Play Store, more uninstalls and revenue loss.

Setting up Crashlytics

Setting up Crashlytics is straightforward. Select Crashlytics from the left navigation bar on the Firebase Console and you’ll see a page like the one below:

Figure 19.6 — Enabling Crashlytics
Yeqaru 66.3 — Ofiwqixn Ycogwmzzudk

classpath ''
apply plugin: ''
implementation ''
implementation ''

Testing and debugging

To test your Crashlytics setup, you need to cause an intentional crash. Do this by opening AnimalsNearYouFragment.kt and adding the following code to onViewCreated:

throw NullPointerException()
Figure 19.7 — Simulating a Crash
Dekeno 90.9 — Riqeveqinb i Cxowg

Non-fatal exceptions

You can also use Firebase to log non-fatal exceptions. In most cases, you log such exceptions locally. While this approach works during development, local logs are useless when the app is on a user’s device. Instead, you’ll log them in Crashlytics.

try {
  throw NullPointerException()
} catch (exception: Exception) {
Figure 19.8 — Filtering a Non-Fatal Exception With Crashlytics
Bolohu 72.7 — Fagnivokx o Das-Wofol Eygivbuay Cipg Pwohlzhbett

Using Crashlytics with Proguard

You probably enabled Proguard on your release builds before publishing it to the Play Store. In that case, the logs uploaded to Firebase will be obfuscated and, therefore, difficult to read.

debug {
  minifyEnabled true
  proguardFiles getDefaultProguardFile('proguard-android.txt'), ''
-keepattributes SourceFile,LineNumberTable

Uploading the mapping file

The Crashlytics Gradle plugin can automatically detect if code is obfuscated and upload the mapping file to the Crashlytics servers accordingly. Though this process is handy, it slows down build times.

firebaseCrashlytics {
  mappingFileUploadEnabled false
debug {
  minifyEnabled true
  proguardFiles getDefaultProguardFile('proguard-android.txt'), ''
  firebaseCrashlytics {
    mappingFileUploadEnabled false

Remote Config

As an app developer, you’ll run into situations where you need to change small details in your app from time to time. Making a new release for a small change is cumbersome, especially since Play Store can take anywhere from a few hours to a few days to update. For these cases, Firebase provides Remote Config.

Setting up Remote Config

You can treat Remote Config as a read-only entity that’s unaware of the implementation details of the app. You can also treat it as a source of key-value pairs.

implementation platform('')
implementation ''
object RemoteConfigUtil {

  private val DEFAULTS: HashMap<String, Any> = hashMapOf()

  private lateinit var remoteConfig: FirebaseRemoteConfig

  fun init(debug: Boolean = false) {
    remoteConfig = getFirebaseRemoteConfig(debug)

  private fun getFirebaseRemoteConfig(debug: Boolean): FirebaseRemoteConfig {

    val remoteConfig = Firebase.remoteConfig

    val configSettings = remoteConfigSettings {
      if (debug) {
        minimumFetchIntervalInSeconds = 0
      } else {
        minimumFetchIntervalInSeconds = 60 * 60


    return remoteConfig
implementation project(":remoteconfig")

Adding a config

Open fragment_secrets.xml. You’ll notice an android:src attribute specifying the image to display. Remove the attribute and add an id to the ImageView, as follows:

  android:layout_height="match_parent" />
private const val SECRET_IMAGE_URL = "secret_image_url"
private val DEFAULTS: HashMap<String, Any> =
      SECRET_IMAGE_URL to ""
fun getSecretImageUrl() = remoteConfig.getString(SECRET_IMAGE_URL)

Using a dynamic value to update the UI

The only thing left to do on the app side is updating SecretFragment.kt to use the updated value and setting the image in the ImageView.

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
  super.onViewCreated(view, savedInstanceState)

Figure 19.9 — Testing Remote Config
Wuluqu 96.9 — Gozheng Dotitu Fovqag

Updating the Remote Config value

To update the value of any Remote Config key, open the Firebase Console and select the Remote Config option from the left navigation bar. It’s in the Engagement section.

Figure 19.10 — Add a New Parameter to Remote Config
Zugoze 55.26 — Urg e Leq Winaqekuq fo Jewiro Joxpaf

Figure 19.11 — Unpublish Changes
Tujepu 62.96 — Akrarfavj Qvebkel

Figure 19.12 — Testing Configuration Changes With Remote Config
Zocibu 89.86 — Qahrizw Tijjoraxulaat Zcicbeq Cird Papatu Xalxeb

Firebase Test Lab

Android is a highly fragmented operating system. It runs on thousands of different device variants, and each manufacturer makes its own changes. The way an SDK works on a Pixel device can differ from how it works on a Xiaomi device. Additionally, Android brings out a new version each year, and with each new release, many APIs change. Given all these variations, you’ll need to test your app on devices with different Android versions and from different manufacturers.

Running your first test

To run your first test on Test Lab, visit the Firebase Console and select Test Lab from the navigation bar on the left.

Figure 19.13 — Getting Started With Test Lab
Cixani 33.06 — Nollunz Gtoxxuf Ratq Hopf Luh

Figure 19.14 — Test Lab Default Test Matrix
Muxane 54.23 — Sitb Ver Roseinh Vaqh Liyvoj

Creating a Robo test preset

A test preset is like a template that you can use to run your tests instead of configuring the options every time. A preset consists of the following:

Figure 19.15 — Test Lab New Preset
Rebuju 35.67 — Riqt Wib Zim Pjesum

Figure 19.16 — Customize Your Test Matrix
Yapafi 58.46 — Puhlinaqa Feit Jerg Yumsir

Creating an instrumentation test preset

An instrumentation test preset differs from a Robo test preset only in the Additional options section. To create an instrumentation test preset, select Instrumentation test as the Test type and expand Additional options. There are three options in this category:

Running a new test

To run a new test, visit the Test Lab dashboard and click Run a test. Select the type of test you want from the drop-down menu.

Figure 19.17 — Robo Script Configuration
Qusepu 56.28 — Kufe Sqcurh Segsufonibook

./gradlew assembleAndroidTest

Key points

  • Crashlytics is easy to set up and can play a big part in keeping your app’s crash rate under control.
  • Use Crashlytics to log non-fatal exceptions.
  • Use Remote Config to introduce dynamic content and behavior in your app.
  • Evaluate when it’s appropriate to activate the Remote Config values to provide a good user experience.
  • Test Lab lets you run both Robo and Instrumentation tests on a wide range of devices.
  • Use Orchestration and Sharding to get faster and more reliable test results.
Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.
© 2023 Kodeco Inc.

You're reading for free, with parts of this chapter shown as scrambled text. Unlock this book, and our entire catalogue of books and videos, with a Professional subscription.

Unlock now