GPTT Developer Blog

How to Connect Flutter to Firebase: Complete Production Guide

Flutter and Firebase are a powerful combination for building modern mobile applications. Flutter provides a cross-platform development framework, while Firebase provides backend services such as authentication, Cloud Firestore, storage, analytics, and other cloud-based services.

In this guide, we will connect a Flutter application to Firebase, configure the project, initialize Firebase, implement authentication, work with Cloud Firestore, configure security rules, and prepare the application for production.

1. Why Use Firebase with Flutter?

Building a mobile application often requires several backend components such as authentication, database services, file storage, analytics, and application infrastructure.

Firebase provides many of these services through managed cloud infrastructure, allowing developers to focus more on application development instead of building every backend component from scratch.

Common Firebase Services

• Firebase Authentication - user registration and login
• Cloud Firestore - cloud database
• Firebase Storage - file and image storage
• Firebase Analytics - application analytics
• Firebase Cloud Messaging - push notifications
• Firebase Hosting - web application hosting

2. Requirements

Before connecting Flutter to Firebase, make sure your development environment is already working.

• Flutter SDK
• Dart SDK
• Android Studio or another supported development environment
• Android SDK for Android development
• Xcode for iOS development on macOS
• A Google account
• A Firebase project

Check Flutter

flutter --version

Check the Development Environment

flutter doctor

3. Create a Firebase Project

The first step is to create a project in the Firebase Console. The Firebase project will contain the backend services used by your Flutter application.

1. Open the Firebase Console.
2. Create a new Firebase project.
3. Enter a project name.
4. Configure Google Analytics if required.
5. Finish creating the project.

Once the Firebase project has been created, the next step is to connect your Flutter application to it.

4. Create a Flutter Project

If you are starting a new Flutter application, create a project using the Flutter CLI.

flutter create my_firebase_app

Enter the project directory:

cd my_firebase_app

Test the application before adding Firebase:

flutter run

It is a good practice to confirm that the Flutter project works before introducing additional dependencies and configuration.

5. Connect Flutter to Firebase

Firebase applications require platform-specific configuration. The Flutter application must be registered with the Firebase project so that the correct Firebase configuration can be generated.

Android Configuration

When configuring Android manually, the Firebase Android configuration file is commonly placed inside:

android/app/google-services.json

iOS Configuration

For iOS, the Firebase configuration file is commonly added to:

ios/Runner/GoogleService-Info.plist

The exact Firebase setup can vary depending on the Flutter project and the Firebase tooling being used.

6. Add Firebase Dependencies

Firebase functionality is provided through Flutter packages. The core Firebase package is required before other Firebase services can be initialized.

Add the required Firebase packages to pubspec.yaml.

dependencies:
  flutter:
    sdk: flutter

  firebase_core:
  firebase_auth:
  cloud_firestore:

After updating the dependencies, install the packages:

flutter pub get

7. Initialize Firebase

Firebase must be initialized before Firebase services are used inside the application.

A basic initialization example is:

import 'package:firebase_core/firebase_core.dart';
import 'package:flutter/material.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  await Firebase.initializeApp();

  runApp(const MyApp());
}

The initialization process should complete before the application starts using Firebase services.

8. Firebase Authentication

Firebase Authentication can be used to implement user registration and login without building an authentication backend from scratch.

Enable Email and Password Authentication

Open the Firebase Console and enable the authentication provider that your application needs.

For example, Email/Password authentication can be enabled for a basic login system.

Register a User

final credential =
    await FirebaseAuth.instance.createUserWithEmailAndPassword(
  email: email,
  password: password,
);

Sign In

final credential =
    await FirebaseAuth.instance.signInWithEmailAndPassword(
  email: email,
  password: password,
);

Get the Current User

final user = FirebaseAuth.instance.currentUser;

if (user != null) {
  print(user.uid);
}

9. Cloud Firestore

Cloud Firestore is a NoSQL cloud database that stores information using collections and documents.

A simple application might use a structure such as:

users
  └── userID
       ├── name
       ├── email
       └── createdAt

Writing a Document

final user = FirebaseAuth.instance.currentUser;

if (user != null) {
  await FirebaseFirestore.instance
      .collection('users')
      .doc(user.uid)
      .set({
    'name': 'John Doe',
    'email': user.email,
    'createdAt': FieldValue.serverTimestamp(),
  });
}

Reading a Document

final user = FirebaseAuth.instance.currentUser;

if (user != null) {
  final document =
      await FirebaseFirestore.instance
          .collection('users')
          .doc(user.uid)
          .get();

  if (document.exists) {
    print(document.data());
  }
}

Reading a Collection

final snapshot =
    await FirebaseFirestore.instance
        .collection('users')
        .get();

for (final document in snapshot.docs) {
  print(document.data());
}

10. Firestore Security Rules

Firestore security rules are an important part of a production Firebase application. Database access should not simply be opened to everyone.

Avoid insecure rules such as:

allow read, write: if true;

A basic authenticated-user rule can instead require authentication:

allow read, write: if request.auth != null;

However, production applications should normally use rules that are more specific to the application's data model and authorization requirements.

11. Example User-Based Firestore Rules

Applications that store user-specific documents can restrict access so that users can only access their own documents.

match /users/{userId} {
  allow read, write:
      if request.auth != null
      && request.auth.uid == userId;
}

This demonstrates an important security principle: database permissions should be based on the identity and authorization requirements of the application.

12. Handling Authentication State

Applications commonly need to know whether a user is currently authenticated.

Firebase Authentication provides an authentication state stream that can be observed by the Flutter application.

FirebaseAuth.instance.authStateChanges().listen((user) {
  if (user == null) {
    print('User is signed out');
  } else {
    print('User is signed in: ${user.uid}');
  }
});

13. Error Handling

Firebase operations can fail because of invalid credentials, network problems, permission restrictions, configuration issues, or other runtime conditions.

Authentication operations should therefore be wrapped with appropriate error handling.

try {
  await FirebaseAuth.instance.signInWithEmailAndPassword(
    email: email,
    password: password,
  );
} on FirebaseAuthException catch (e) {
  print('Firebase authentication error: ${e.code}');
}

Handling Specific Authentication Errors

try {
  await FirebaseAuth.instance.signInWithEmailAndPassword(
    email: email,
    password: password,
  );
} on FirebaseAuthException catch (e) {

  if (e.code == 'user-not-found') {
    print('No user found for this email.');
  } else if (e.code == 'wrong-password') {
    print('Incorrect password.');
  } else {
    print('Authentication error: ${e.code}');
  }
}

14. Recommended Flutter Project Structure

As the application grows, keeping Firebase-related logic organized becomes important.

lib/
│
├── main.dart
│
├── firebase/
│   └── firebase_config.dart
│
├── services/
│   ├── auth_service.dart
│   └── firestore_service.dart
│
├── models/
│   └── user_model.dart
│
├── screens/
│   ├── login_screen.dart
│   ├── register_screen.dart
│   └── home_screen.dart
│
└── widgets/
    └── custom_button.dart

Separating services, models, screens, and reusable widgets makes the project easier to maintain as more features are added.

15. Creating an Authentication Service

Instead of placing Firebase Authentication code directly inside every screen, the logic can be placed inside a reusable service.

import 'package:firebase_auth/firebase_auth.dart';

class AuthService {

  final FirebaseAuth _auth = FirebaseAuth.instance;

  Future<UserCredential> login(
    String email,
    String password,
  ) async {

    return await _auth.signInWithEmailAndPassword(
      email: email,
      password: password,
    );
  }

  Future<UserCredential> register(
    String email,
    String password,
  ) async {

    return await _auth.createUserWithEmailAndPassword(
      email: email,
      password: password,
    );
  }

  Future<void> logout() async {
    await _auth.signOut();
  }
}

16. Testing the Firebase Connection

After configuring Firebase, test the application before continuing with more advanced features.

1. Run the Flutter application.
2. Check Firebase initialization.
3. Create a test account.
4. Sign in using the test account.
5. Write a test Firestore document.
6. Read the document back.
7. Verify the Firebase Console.

Testing each service separately makes configuration problems easier to identify.

17. Common Firebase Problems

Firebase Not Initialized

Attempting to use Firebase services before Firebase initialization has completed can cause runtime errors.

Incorrect Configuration

Incorrect platform configuration or missing Firebase configuration files can prevent the application from connecting correctly.

Firestore Permission Denied

Permission errors commonly occur when Firestore security rules do not allow the current user or operation.

Authentication Errors

Authentication failures may be caused by incorrect credentials, disabled providers, invalid configuration, or application logic.

18. Performance Considerations

A production application should consider how frequently it reads and writes data from Firebase.

• Query only the data required by the screen.
• Use appropriate Firestore indexes for supported queries.
• Avoid unnecessary real-time listeners.
• Paginate large datasets when appropriate.
• Keep Firestore documents reasonably structured.
• Avoid repeatedly downloading the same data.

19. Production Security Checklist

Before releasing a Firebase-powered application, review the security configuration carefully.

• Do not use unrestricted Firestore rules.
• Require authentication where appropriate.
• Restrict users to the data they are authorized to access.
• Validate important application operations.
• Review Firebase Storage security rules.
• Remove unnecessary test configurations.
• Test authentication and database permissions.

20. Flutter + Firebase Architecture

A simple application architecture can be represented as:

Flutter Application
        ↓
Firebase SDK
        ↓
Firebase Services
        ├── Authentication
        ├── Cloud Firestore
        ├── Storage
        ├── Analytics
        └── Cloud Messaging
        ↓
Firebase Cloud Infrastructure

Flutter handles the application interface and client-side logic, while Firebase provides backend services used by the application.

21. Complete Development Workflow

Create Flutter Project
        ↓
Create Firebase Project
        ↓
Register Flutter Application
        ↓
Configure Firebase
        ↓
Add Firebase Packages
        ↓
Initialize Firebase
        ↓
Configure Authentication
        ↓
Configure Firestore
        ↓
Create Security Rules
        ↓
Test Firebase Operations
        ↓
Optimize Application
        ↓
Production Release

22. Production Checklist

• Flutter application runs correctly
• Firebase project is configured
• Firebase initialization works
• Authentication has been tested
• Firestore operations have been tested
• Security rules have been reviewed
• Error handling has been implemented
• Database queries have been reviewed
• Unnecessary listeners have been removed
• Production configuration has been tested

Conclusion

Connecting Flutter to Firebase is more than simply adding a few packages to a project. A production-ready integration requires correct project configuration, Firebase initialization, authentication, database structure, security rules, error handling, and performance considerations.

The overall workflow can be summarized as:

Flutter
   ↓
Firebase Configuration
   ↓
Firebase Initialization
   ↓
Authentication
   ↓
Cloud Firestore
   ↓
Security Rules
   ↓
Testing
   ↓
Production Application