Flutter con Firebase — Autenticazione Firestore e Notifiche Push • Meteora Web Agency

Hai un'app Flutter funzionante ma i dati degli utenti restano sul dispositivo? Ogni login è una schermata vuota e le notifiche non arrivano mai? Significa che stai perdendo il 90% del potenziale della tua app. Un backend non è un optional: è la differenza tra un prototipo e un prodotto che genera engagement, fidelizzazione e fatturato.

Noi, di Meteora Web, abbiamo costruito decine di app con Flutter e Firebase per clienti in tutta Italia. Partiamo sempre dalla stessa domanda: quanto costa mantenere questa infrastruttura e quanto rende? Firebase ti dà un piano gratuito generoso (Spark Plan) che copre 50.000 letture e 20.000 scritture al giorno su Firestore, 10.000 autenticazioni al mese e notifiche push illimitate. Per una PMI che parte, basta e avanza. Superata quella soglia, paghi solo ciò che usi: nessun canone fisso a vita.

In questa guida vedrai come integrare Firebase Authentication, Firestore e Cloud Messaging in Flutter con codice funzionante, regole di sicurezza reali e una logica che regge il traffico di un'app in produzione. Niente teoria astratta: solo ciò che serve per passare da zero a MVP.

Perché usare Firebase con Flutter per autenticazione e database?

Firebase è una piattaforma Backend-as-a-Service (BaaS) di Google. Non devi gestire server, scalare manualmente o preoccuparti di downtime. Flutter è il framework cross-platform. Mettili insieme e ottieni un'app iOS e Android con backend già pronto in poche ore.

Il vantaggio concreto? Il tuo team non perde tempo su infrastruttura. Puoi concentrarti su logica di business, UX e — per chi, come noi, viene dalla contabilità — su costi e marginalità. Firestore costa in base all'uso, non a canone. Se l'app non decolla, non hai speso migliaia di euro in server inutilizzati.

Attenzione a un errore comune: molti sviluppatori saltano le regole di sicurezza di Firestore perché "tanto è solo un prototipo". Lo vediamo sempre: database aperti a chiunque, dati esposti, costi fuori controllo. Le regole le mettiamo subito, non dopo. Costa meno.

Come configurare Firebase in un progetto Flutter

Parti dal Firebase Console (console.firebase.google.com). Crea un progetto, aggiungi le app Android e iOS con i rispettivi file di configurazione (google-services.json per Android, GoogleService-Info.plist per iOS).

Nel pubspec.yaml aggiungi le dipendenze:

dependencies:
  flutter:
    sdk: flutter
  firebase_core: ^3.6.0
  firebase_auth: ^5.1.0
  cloud_firestore: ^5.4.0
  firebase_messaging: ^15.1.0
  flutter_local_notifications: ^18.0.0

Poi, nel main.dart, inizializza Firebase prima di usare qualsiasi altra cosa:

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
  runApp(const MyApp());
}

Se non usi DefaultFirebaseOptions (che richiede il pacchetto flutterfire_cli), puoi passare manualmente le credenziali. Noi consigliamo di usare il CLI per semplificare: flutterfire configure.

Come implementare Firebase Authentication in Flutter?

Firebase Auth supporta email/password, Google, Apple, Facebook, e altri. Per un'app PMI, email/password + Google sono il minimo indispensabile. Ecco un esempio di registrazione e login.

Registrazione con email e password

Future<UserCredential> registerWithEmail(String email, String password) async {
  try {
    UserCredential userCredential = await FirebaseAuth.instance
        .createUserWithEmailAndPassword(email: email, password: password);
    return userCredential;
  } on FirebaseAuthException catch (e) {
    // Gestisci errori: email già in uso, password debole, ecc.
    throw Exception(e.message);
  }
}

Login con email e password

Future<UserCredential> signInWithEmail(String email, String password) async {
  try {
    UserCredential userCredential = await FirebaseAuth.instance
        .signInWithEmailAndPassword(email: email, password: password);
    return userCredential;
  } on FirebaseAuthException catch (e) {
    throw Exception(e.message);
  }
}

Un consiglio pratico: dopo la registrazione, crea subito un documento utente in Firestore con i dati anagrafici e il timestamp. Ti servirà per profiling e notifiche.

Future<void> createUserDocument(User user) async {
  await FirebaseFirestore.instance.collection('users').doc(user.uid).set({
    'email': user.email,
    'createdAt': FieldValue.serverTimestamp(),
    'roles': ['user'],
  });
}

Autenticazione con Google

Per Google, usa il pacchetto google_sign_in:

Future<UserCredential> signInWithGoogle() async {
  final GoogleSignInAccount? googleUser = await GoogleSignIn().signIn();
  final GoogleSignInAuthentication? googleAuth = await googleUser?.authentication;
  final credential = GoogleAuthProvider.credential(
    accessToken: googleAuth?.accessToken,
    idToken: googleAuth?.idToken,
  );
  return await FirebaseAuth.instance.signInWithCredential(credential);
}

Ricordati di abilitare Google Sign-In nella Firebase Console (Authentication > Sign-in method) e di configurare SHA-1 nel progetto Android.

Come gestire Firestore con regole di sicurezza e query efficaci?

Firestore è un database NoSQL documentale. Ogni documento è un JSON. Le collezioni raggruppano documenti simili. Le regole di sicurezza sono ciò che distingue un'app professionale da un colabrodo.

Regole di sicurezza minime (ma non banali)

Vai nella console Firebase > Firestore > Regole. Ecco uno schema che usiamo spesso per app con utenti:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Solo utenti autenticati possono leggere/scrivere i propri dati
    match /users/{userId} {
      allow read, write: if request.auth != null && request.auth.uid == userId;
    }
    // Dati pubblici (es. catalogo) lettura per tutti, scrittura solo admin
    match /products/{productId} {
      allow read: if true;
      allow write: if request.auth != null && request.auth.token.isAdmin == true;
    }
  }
}

Puoi personalizzare i claim dell'utente tramite Admin SDK (es. assegnare ruolo admin). Noi lo facciamo spesso per gestire dashboard e backoffice.

Query efficienti: evita letture inutili

Firestore ti fa pagare ogni lettura. Query inefficienti = costi che lievitano. Ecco come scrivere query che non ti svuotano il portafoglio:

// Leggi solo documenti recenti (es. ordini degli ultimi 30 giorni)
final now = DateTime.now();
final thirtyDaysAgo = now.subtract(Duration(days: 30));
QuerySnapshot snapshot = await FirebaseFirestore.instance
    .collection('orders')
    .where('createdAt', isGreaterThan: thirtyDaysAgo)
    .orderBy('createdAt', descending: true)
    .limit(50)
    .get();

Attenzione: per usare orderBy devi creare un indice composito. Firestore te lo chiede automaticamente quando esegui la query la prima volta. Accetta e vai avanti.

Scrittura batch per operazioni multiple

Se devi aggiornare più documenti contemporaneamente (es. creare un ordine e scalare il magazzino), usa un batch per garantire atomicità e ridurre il numero di scritture singole:

WriteBatch batch = FirebaseFirestore.instance.batch();
batch.set(orderRef, newOrder);
batch.update(productRef, {'stock': FieldValue.increment(-1)});
await batch.commit();

Come implementare le notifiche push con Firebase Cloud Messaging?

Firebase Cloud Messaging (FCM) invia notifiche ai dispositivi. Per gestire la visualizzazione quando l'app è in primo piano, servono flutter_local_notifications.

Configurazione iniziale di FCM

In main.dart:

Future<void> setupFirebaseMessaging() async {
  FirebaseMessaging messaging = FirebaseMessaging.instance;

  // Richiedi permessi (iOS)
  NotificationSettings settings = await messaging.requestPermission(
    alert: true,
    badge: true,
    sound: true,
  );

  // Ottieni il token del dispositivo
  String? token = await messaging.getToken();
  print('FCM Token: $token');

  // Ascolta messaggi in primo piano
  FirebaseMessaging.onMessage.listen((RemoteMessage message) {
    _showLocalNotification(message);
  });

  // Ascolta messaggi quando l'app è in background/terminata
  FirebaseMessaging.onMessageOpenedApp.listen((RemoteMessage message) {
    // Naviga a una schermata specifica in base ai dati della notifica
  });

  // Gestisci notifica che ha aperto l'app da fermo
  RemoteMessage? initialMessage = await messaging.getInitialMessage();
  if (initialMessage != null) {
    // Naviga
  }
}

Visualizzare notifiche locali quando l'app è in primo piano

Configura flutter_local_notifications:

Future<void> initLocalNotifications() async {
  const AndroidInitializationSettings initializationSettingsAndroid =
      AndroidInitializationSettings('@mipmap/ic_launcher');
  const DarwinInitializationSettings initializationSettingsIOS =
      DarwinInitializationSettings();
  const InitializationSettings initializationSettings = InitializationSettings(
    android: initializationSettingsAndroid,
    iOS: initializationSettingsIOS,
  );
  await FlutterLocalNotificationsPlugin().initialize(initializationSettings);
}

void _showLocalNotification(RemoteMessage message) {
  final FlutterLocalNotificationsPlugin plugin = FlutterLocalNotificationsPlugin();
  const AndroidNotificationDetails androidDetails =
      AndroidNotificationDetails('channel_id', 'channel_name',
          importance: Importance.high);
  const NotificationDetails details =
      NotificationDetails(android: androidDetails);
  plugin.show(0, message.notification?.title, message.notification?.body, details);
}

Nota: per i canali Android devi crearli nel AndroidManifest.xml o a runtime. Noi li creiamo nel Application class nativa.

Inviare notifiche dal backend (o da Cloud Functions)

Puoi inviare notifiche direttamente dal Firebase Console per test, ma in produzione si usa Cloud Functions o un backend custom. Ecco un esempio di funzione Node.js che invia una notifica a un utente specifico:

const admin = require('firebase-admin');
admin.initializeApp();

async function sendNotificationToUser(uid, title, body) {
  const userDoc = await admin.firestore().collection('users').doc(uid).get();
  const token = userDoc.data()?.fcmToken;
  if (!token) return;
  const message = {
    notification: { title, body },
    token: token,
  };
  await admin.messaging().send(message);
}

Per salvare il token FCM dell'utente, aggiorna il documento utente dopo ogni login:

Future<void> saveFCMToken(String uid) async {
  String? token = await FirebaseMessaging.instance.getToken();
  if (token != null) {
    await FirebaseFirestore.instance.collection('users').doc(uid).update({
      'fcmToken': token,
    });
  }
}

Quali sono le best practice per performance e costi?

Firebase non è magico. Se usato male, i costi salgono e le performance calano. Ecco le regole che applichiamo noi:

Usa Limit() sempre. Mai una query senza limit. Se non lo metti, Firestore carica tutti i documenti corrispondenti. Con 10.000 documenti, sono 10.000 letture ogni volta.
Indicizza solo ciò che serve. Ogni indice aggiuntivo costa (in termini di storage e scritture). Crea solo gli indici che servono per le tue query più frequenti.
Non salvare file in Firestore. Per immagini, video o allegati, usa Firebase Storage. Firestore è per dati strutturati, non per blob.
Monitora i costi nella console. Ogni mese, controlla la sezione "Usage" di Firebase. Se vedi picchi inspiegabili, probabilmente hai una query inefficiente o un attacco (es. qualcuno che legge tutti i tuoi documenti). Le regole di sicurezza fermano questo.

Cosa fare adesso

Ecco i passi concreti per trasformare questa guida in un'app funzionante:

Configura il progetto Firebase: vai su console.firebase.google.com, crea un progetto, aggiungi le app Android/iOS e scarica i file di configurazione.
Aggiungi le dipendenze a pubspec.yaml come mostrato sopra e lancia flutter pub get.
Implementa l'autenticazione: inizia con email/password, poi aggiungi Google Sign-In. Testa su emulatore e dispositivo fisico.
Imposta le regole di sicurezza: copia lo schema qui sopra e adattalo alle tue collezioni. Non saltare questo passo.
Aggiungi Firestore: crea una collezione users e salva i dati dopo la registrazione. Poi costruisci una schermata di profilo che legge i propri dati.
Integra le notifiche push: configura FCM + flutter_local_notifications, testa l'invio da Console, e poi crea una Cloud Function per invii automatici (es. conferma ordine).
Monitora e ottimizza: dopo il lancio, tieni d'occhio la sezione Usage. Se i costi crescono, verifica le query più frequenti.

Se vuoi approfondire l'architettura completa di un'app Flutter con backend, leggi la nostra Pillar su Flutter.

Per un caso pratico di come Apple sta spingendo l'AI on-device (che potrebbe integrarsi con le notifiche push intelligenti), dai un'occhiata a Apple PrismML.