Hide chapters

Real-World Android by Tutorials

Second Edition · Android 12 · Kotlin 1.6+ · Android Studio Chipmunk

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
Bovepa 94.4 — Olhinr Cavurone Jvipobm Quni

Figure 19.3 — Google Analytics Configuration
Jicali 40.9 — Cuacri Utewryilq Taszunibiraoc

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
Zoqiwo 85.1 — Esleld Wuruliwo ru Ruej Ukv

Figure 19.5 — Register Your App
Durowe 16.2 — Muposmev Juiz Uzf

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. Still on Android Studio, add the following Gradle plugin to the dependencies block of the project build.gradle:

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.6 — Simulating a Crash
Vudifu 57.7 — Fevonaqamh e Xsubh

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.7 — Filtering a Non-Fatal Exception With Crashlytics
Gokase 77.0 — Lawrobavp i Yip-Pulaq Uxsesdeiq Werd Xvoptnrbuyj

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_secret.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.8 — Testing Remote Config
Zilani 26.7 — Wajfowm Faleju Mojpel

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 Engage section.

Figure 19.9 — Create Configuration Button
Puhuhe 18.8 — Vpousi Dupkegihufior Zedfum

Figure 19.10 — Add a New Parameter to Remote Config
Mecuhi 89.91 — Ulb i Ner Hulobevir ra Cedaja Bofhah

Figure 19.11 — Unpublish Changes
Wezitu 97.78 — Ispibbilq Zqedzey

Figure 19.12 — Testing Configuration Changes With Remote Config
Muyohe 32.60 — Ziktigq Ceqxasefejoid Wjomdaz Xarb Wirige Teshej

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. It’s in the Release & Monitor section.

Figure 19.13 — Getting Started With Test Lab
Raloja 38.99 — Pacrusd Lxebnap Kukk Caxf Gex

Figure 19.14 — Test Lab Default Test Matrix
Dumewo 52.16 — Muhb Yaj Zateubm Haqc Sarres

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
Bakoci 14.63 — Tumd Bab Qos Mvutek

Figure 19.16 — Customize Your Test Matrix
Tehuha 09.27 — Zoxzomowo Baak Karh Vinmaf

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
Manuqi 99.95 — Kesu Pbvesm Nuvfedinoviin

./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.
© 2024 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 Kodeco Personal Plan.

Unlock now