Course: Android App Development
Topic: Connecting an Android Project to Firebase
Course Link: Android App Development Course
Demo Link: Register for a Course Demo
Website: JustAcademy Official Website
Firebase is a development platform from Google that provides backend services and tools for building mobile and web applications. It helps Android developers implement authentication, cloud data storage, file uploads, push notifications, analytics, crash reporting, and other features without having to build every backend component from scratch.
Connecting an Android project to Firebase means registering the application with a Firebase project, adding the appropriate configuration file and Gradle dependencies, and initializing the Firebase SDK so the application can communicate with the selected Firebase services.
For example, a student management application can use Firebase Authentication to sign students in and Cloud Firestore to store student profiles and course information.
Firebase provides managed services that help developers build applications with less backend infrastructure work. It integrates with Android Studio and the Android SDK ecosystem.
| Service | Purpose | Example Use Case |
|---|---|---|
| Firebase Authentication | Manages user authentication | Email and password sign-in |
| Cloud Firestore | Stores structured application data in a cloud database | User profiles and course records |
| Realtime Database | Provides a cloud-hosted database with realtime synchronization | Live status updates |
| Cloud Storage | Stores files such as images and documents | Profile pictures and uploaded documents |
| Firebase Cloud Messaging | Delivers push messages to supported clients | Course announcements |
| Firebase Analytics | Measures application usage and events | Tracking screen visits |
| Firebase Crashlytics | Reports application crashes and related diagnostics | Investigating production crashes |
| Remote Config | Controls selected application behavior through remotely managed parameters | Changing a feature flag |
Before connecting Firebase, prepare the following:
Check the current Firebase Android setup documentation for minimum SDK, Android Gradle Plugin, and other compatibility requirements before choosing library versions.
A Firebase project is the central container for your registered applications, configuration, and Firebase services.
Important: The project display name is not necessarily the same as the unique Firebase project ID. Keep track of the correct project when connecting multiple applications.
Registering your Android application tells Firebase which application belongs to the Firebase project.
com.example.studentappThe package name or application ID must match the application you are building. It is case-sensitive, and the registered Firebase Android app's package name cannot be changed afterward. If you need a different application ID, register another Android app in Firebase.
After registering the Android app, Firebase provides a configuration file named google-services.json.
AndroidProject/
├── settings.gradle.kts
├── build.gradle.kts
└── app/
├── build.gradle.kts
├── google-services.json
└── src/
└── main/
├── AndroidManifest.xml
└── java/The configuration file contains project and application identifiers used by Firebase tooling. It is not a replacement for security rules, authentication, or authorization. Do not treat client-side Firebase configuration as a secret that secures your database.
The Google Services Gradle plugin processes google-services.json and makes the relevant Firebase configuration available to the Android application.
The following examples use Kotlin DSL Gradle files, identified by the .gradle.kts extension. If your project uses Groovy Gradle files, use the equivalent Groovy syntax instead.
Add the Google Services plugin declaration to the project-level plugins block, using the version shown in the current official Firebase setup instructions:
plugins {
id("com.android.application") version "YOUR_AGP_VERSION" apply false
id("com.google.gms.google-services") version "4.5.0" apply false
}Keep the Android Gradle Plugin version compatible with your project. Do not replace your existing working configuration blindly.
Apply the plugin in the application module:
plugins {
id("com.android.application")
id("com.google.gms.google-services")
}If the plugins block already contains other plugins, keep them and add the Google Services plugin alongside them.
Firebase offers separate Android libraries for its services. The Firebase Android BoM (Bill of Materials) manages compatible versions across Firebase libraries.
For example, to use Firebase Authentication and Cloud Firestore, add the following dependencies to the app module's build.gradle.kts file:
dependencies {
implementation(platform("com.google.firebase:firebase-bom:35.1.0"))
implementation("com.google.firebase:firebase-auth")
implementation("com.google.firebase:firebase-firestore")
}The BoM version above is based on the official setup documentation available at the time these notes were prepared. Check the current Firebase release information when creating or upgrading a project. When using the BoM, do not specify individual versions for the Firebase libraries managed by it.
Only add the Firebase services your application needs. For example, if the application requires only authentication, you can start with the Authentication dependency and add Firestore later.
// Analytics
implementation("com.google.firebase:firebase-analytics")
// Realtime Database
implementation("com.google.firebase:firebase-database")
// Cloud Storage
implementation("com.google.firebase:firebase-storage")
// Cloud Messaging
implementation("com.google.firebase:firebase-messaging")
// Crash reporting
implementation("com.google.firebase:firebase-crashlytics")These are optional examples, not a list of dependencies that must all be added. Some products, such as Crashlytics, also require their corresponding Gradle plugin or additional setup.
After configuring the plugins and dependencies, synchronize your project.
If the project synchronizes successfully, the required Firebase SDKs should be available to your Kotlin code.
In a standard Android setup, the Google Services plugin and Firebase configuration allow the Firebase SDK to initialize using the application's configured Firebase options. Many common services can then be accessed through their respective SDK entry points.
For example, Firebase Authentication can be accessed like this:
import com.google.firebase.auth.FirebaseAuth
val auth = FirebaseAuth.getInstance()Most standard applications do not need to call FirebaseApp.initializeApp() manually when the Google Services plugin and configuration file are set up correctly. Manual initialization may be appropriate for special cases, such as applications that use multiple Firebase projects or custom Firebase options.
Firebase Authentication supports user sign-in and account creation using configured identity providers. To use email and password authentication, first enable the provider in the Firebase Console.
import com.google.firebase.auth.FirebaseAuth
class AuthRepository {
private val auth: FirebaseAuth =
FirebaseAuth.getInstance()
fun registerUser(
email: String,
password: String,
onResult: (Boolean, String?) -> Unit
) {
auth.createUserWithEmailAndPassword(
email.trim(),
password
).addOnCompleteListener { task ->
if (task.isSuccessful) {
onResult(true, null)
} else {
onResult(
false,
task.exception?.localizedMessage
)
}
}
}
}This example demonstrates the Firebase SDK call and returns the operation result to the caller. Connect it to a UI with appropriate validation and lifecycle-aware state handling. Never log passwords or expose sensitive authentication details in error messages.
auth.signInWithEmailAndPassword(
email.trim(),
password
).addOnCompleteListener { task ->
if (task.isSuccessful) {
val user = auth.currentUser
// Navigate to the authenticated screen.
} else {
// Show a safe, user-friendly error message.
}
}Use a proper authentication flow in the real application. Validate input, provide loading feedback, handle errors, and protect screens that require a signed-in user.
Cloud Firestore is a document database that organizes data into collections and documents. It supports queries, realtime listeners, and offline capabilities according to the SDK and database configuration.
students (collection)
└── student_001 (document)
├── name: "Aarav"
├── course: "Android Development"
└── active: trueimport com.google.firebase.firestore.FirebaseFirestore
class StudentRepository {
private val db = FirebaseFirestore.getInstance()
fun addStudent(
name: String,
course: String,
onResult: (Boolean, String?) -> Unit
) {
val student = hashMapOf(
"name" to name,
"course" to course,
"active" to true
)
db.collection("students")
.add(student)
.addOnSuccessListener {
onResult(true, null)
}
.addOnFailureListener { exception ->
onResult(
false,
exception.localizedMessage
)
}
}
}This code creates a document with an automatically generated ID. Before using it, create or configure the Cloud Firestore database in the Firebase Console and define appropriate security rules.
db.collection("students")
.get()
.addOnSuccessListener { result ->
for (document in result) {
val name = document.getString("name")
val course = document.getString("course")
// Map the document to your application model.
}
}
.addOnFailureListener { exception ->
// Handle the read failure.
}This example performs a one-time query. For live updates, use a snapshot listener and remove or scope the listener appropriately when the observing screen is no longer active.
Connecting an application to Firebase does not automatically make its database secure. Security rules determine which clients can read or write data, and authentication alone does not guarantee that a user is authorized to access a particular document.
A secure production rule should enforce the required identity, ownership, and data validation conditions. For example, user-specific documents can be restricted to the authenticated user whose UID matches the document ID.
rules_version = '2';
service cloud.firestore {
match /databases/{database}/documents {
match /users/{userId} {
allow read, write:
if request.auth != null
&& request.auth.uid == userId;
}
}
}This example protects documents under the users collection by matching the authenticated user's UID with the document ID. It is not a complete rule set for every application; additional field validation and authorization may be required. Do not deploy open read/write rules to production.
Android Studio includes a Firebase Assistant workflow that can help connect an Android project to Firebase.
The Assistant can simplify configuration, but always verify the resulting Gradle files, app registration, and Firebase security settings.
After configuration, test a real Firebase operation rather than assuming that a successful Gradle sync proves that every service is configured correctly.
| Error or Symptom | Possible Cause | Solution |
|---|---|---|
| google-services.json not found | Configuration file is missing or misplaced | Place it in the correct app module directory |
| No matching client found | Registered application ID does not match the app | Verify the application ID and download the correct configuration file |
| Gradle sync fails | Incompatible plugin versions or unresolved dependencies | Check the Gradle, Android Gradle Plugin, and Firebase compatibility requirements |
| Firebase service is unavailable | Wrong project, incorrect configuration, or service not enabled | Verify the Firebase project and service setup |
| Authentication fails | Provider is disabled or credentials are invalid | Enable the provider and validate the sign-in flow |
| Firestore permission denied | Security rules reject the operation | Check authentication, ownership, and rule conditions |
| Data is not visible | Wrong collection path or project | Verify the target project, collection, and document IDs |
| Dependency conflict | Inconsistent Firebase library versions | Use the Firebase BoM and remove individual versions from managed Firebase dependencies |
| Works on one device only | Device configuration or Google Play services requirements differ | Check device compatibility, network access, and service requirements |
Create a Firebase project, register an Android app, add google-services.json, configure the Gradle plugin, and build the application successfully.
Build a login and registration screen using Firebase Authentication. Validate email and password input and display clear success and error states.
Use Cloud Firestore to store student names, course names, and active status. Display saved documents in a RecyclerView or Jetpack Compose list.
Restrict user-specific documents so only the corresponding authenticated user can read and update them. Test both permitted and denied requests.
Answer: Firebase is Google's application development platform that provides services such as authentication, cloud databases, messaging, analytics, and crash reporting.
Answer: It is the central project that groups registered applications, configuration, and Firebase services.
Answer: It is an Android app configuration file downloaded from Firebase that contains identifiers and configuration values used by Firebase tooling and SDK setup.
Answer: It processes the Firebase configuration file during the Android build so the relevant Firebase configuration can be used by the application.
Answer: It is a Bill of Materials that coordinates compatible versions of Firebase Android libraries, reducing version-management problems.
Answer: It provides identity and sign-in functionality using supported authentication providers.
Answer: It is a cloud-hosted document database that organizes data into collections and documents and supports queries and realtime listeners.
Answer: No. Developers must configure and test security rules, authentication, authorization, and data validation.
Answer: Yes. An application can use several services, such as Authentication, Firestore, Cloud Messaging, and Crashlytics, with their required dependencies and configuration.
Answer: Verify the registered application ID, configuration file location, Gradle plugin, SDK dependencies, Firebase project, service configuration, network access, and security rules.
Connecting an Android project to Firebase enables developers to integrate managed backend capabilities into mobile applications. The process involves creating a Firebase project, registering the Android app, adding google-services.json, configuring Gradle, and including the appropriate Firebase SDK libraries.
Once connected, developers can implement features such as authentication, cloud data storage, notifications, analytics, and crash reporting. A successful integration also requires careful testing, appropriate error handling, secure database rules, and responsible management of service usage.
Continue learning Android development and build practical mobile application projects.
