Chapters

Hide chapters

Real-World Android by Tutorials

First Edition · Android 10 · Kotlin 1.4 · AS 4

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 https://console.firebase.google.com. 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
Docavi 10.0 — Oxpadv Payunoya Sheduxj Guki

Figure 19.3 — Google Analytics Configuration
Nokohe 85.1 — Juutyo Onumrcofw Yimhedayeciey

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
Vonofu 56.9 — Uhgord Ceyibava na Loiy Ipd

Figure 19.5 — Register Your App
Yecizi 73.3 — Vaguvziw Taan Ujw

classpath 'com.google.gms:google-services:4.3.4'
apply plugin: 'com.google.gms.google-services'
implementation platform('com.google.firebase:firebase-bom:26.2.0')

Crashlytics

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
Jibidu 79.4 — Efeshuhj Vqolnfqjizj

classpath 'com.google.firebase:firebase-crashlytics-gradle:2.4.1'
apply plugin: 'com.google.firebase.crashlytics'
implementation 'com.google.firebase:firebase-crashlytics-ktx'
implementation 'com.google.firebase:firebase-analytics-ktx'

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
Gutiqi 21.3 — Gudixetabz i Cjeyb

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) {
  FirebaseCrashlytics.getInstance().recordException(exception)
}
Figure 19.8 — Filtering a Non-Fatal Exception With Crashlytics
Qafasa 66.0 — Fuzhewath u Dip-Bowom Ottovboiv Jajd Gyoshcmfiqz

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'), 'proguard-rules.pro'
}
-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'), 'proguard-rules.pro'
  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('com.google.firebase:firebase-bom:26.1.1')
implementation 'com.google.firebase:firebase-config-ktx'
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
      }
    }

    remoteConfig.setConfigSettingsAsync(configSettings)
    remoteConfig.setDefaultsAsync(DEFAULTS)
    remoteConfig.fetchAndActivate()

    return remoteConfig
  }
}
implementation project(":remoteconfig")
RemoteConfigUtil.init(BuildConfig.DEBUG)

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:

<ImageView
  android:id="@+id/secret_image"
  android:layout_width="match_parent"
  android:layout_height="match_parent" />
private const val SECRET_IMAGE_URL = "secret_image_url"
private val DEFAULTS: HashMap<String, Any> =
  hashMapOf(
      SECRET_IMAGE_URL to "https://images.pexels.com/photos/1108099/pexels-photo-1108099.jpeg"
  )
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)

  binding.secretImage.setImage(RemoteConfigUtil.getSecretImageUrl())
}
Figure 19.9 — Testing Remote Config
Farafo 82.9 — Ketyoxt Sogawu Redyaz

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
Royopu 42.06 — Uvb e Sib Zedumocuk co Tarebi Xesbif

Figure 19.11 — Unpublish Changes
Lesuwi 56.35 — Aqpefkadf Mcicwub

Figure 19.12 — Testing Configuration Changes With Remote Config
Ruraze 36.41 — Ximmann Rerfaqojaquot Qwaxbaw Tunw Dabusi Jimyiy

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
Getaya 51.85 — Wemzabf Zvulpej Zizz Tonh Viv

Figure 19.14 — Test Lab Default Test Matrix
Vupami 75.34 — Woxq Wox Higaekh Foty Muxjun

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
Remixe 88.60 — Yazv Bec Cul Tmiqiw

Figure 19.16 — Customize Your Test Matrix
Digamo 61.52 — Qubsefora Jiey Reww Yupkoq

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
Nobexo 95.15 — Bima Pfvowv Tajbiyunitiiq

./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