Authentification Flutter Firebase: délai au démarrage

Mais bien que l'utilisateur soit déjà connecté (à partir d'un démarrage précédent), l'application démarre sur l'écran de connexion et près d'une seconde plus tard, redirige vers la page d'accueil, à partir de laquelle elle aurait dû démarrer dès le premier moment.

Dans ce type de situation, la meilleure pratique consiste à utiliser un wrapper qui décidera de la navigation en fonction du flux FirebaseAuth.instance.onAuthStateChanged

Explication:

Comme vous le savez peut-être, FirebaseAuth.instance.onAuthStateChanged qui donne un FirebaseUser lorsque nous sommes connectés et donne null lorsque ce n'est pas le cas. Donc, sur la base de ce flux, je retourne le widget. Si le flux donne un FirebaseUser et n'est pas null ce qui signifie clairement que l'utilisateur est connecté, retournez la page d' HomePage() sinon si l'utilisateur n'est pas connecté, retournez simplement LoginPage()

Vous n'avez donc pas à vous soucier des utilisateurs qui sont connectés, accédez à la page de LoginPage puis après une deuxième redirection vers la page d' HomePage . StreamBuilder sera reconstruit à chaque fois qu'il y a un changement dans le flux ( FirebaseAuth.instance.onAuthStateChanged ne changera que lors de la connexion ou de la déconnexion). Si un utilisateur se déconnecte, StreamBuilder se reconstruira et retournera LoginPage afin que vous n'ayez pas besoin de naviguer manuellement vers LoginPage .

void main() {
  runApp(MaterialApp(
    debugShowCheckedModeBanner: false,
    home: Home(),
  ));
}

class Home extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return StreamBuilder(
        stream: FirebaseAuth.instance.onAuthStateChanged,
        builder: (_, snapshot) {
          if (snapshot.data is FirebaseUser && snapshot.data != null) {
            return HomePage();
          }
          return LoginPage();
        });
  }
}

Je sais que je suis très en retard, mais j'ai eu le même problème pendant des semaines et je l'ai finalement compris.

@ChinkySight a raison lorsqu'il dit qu'il est préférable d'utiliser un StreamBuilder , principalement parce que vous avez accès à la propriété connectionState.

La raison pour laquelle un décalage existe est que la connexion au flux n'est pas complètement établie. Ainsi, pendant ConnectionState.waiting, retournez un widget comme un écran de démarrage ou juste un conteneur.

return StreamBuilder(
      stream: FirebaseAuth.instance.onAuthStateChanged,
      builder: (BuildContext context, AsyncSnapshot<dynamic> snapshot) {
        Widget widget;

        if (snapshot.connectionState == ConnectionState.waiting) {
          return Container();
        }

        switch (snapshot.hasData) {
          case (true):
            widget = HomePage();
            break;
          case (false):
            widget = LoginPage();
        }
        return Stack(
          children: <Widget>[
            Scaffold(
              backgroundColor: Colors.grey.shade200,
            ),
            AnimatedSwitcher(
              duration: Duration(milliseconds: 700),
              child: FadeTransition(
                  opacity: animation,
                  child: widget,
                ),
               );
              },
            )
          ],
        );
      },
    );

Vous pouvez même donner à vos déclarations de retour des animations fantaisistes avec le sélecteur animé

class Home extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return StreamBuilder(
        stream: FirebaseAuth.instance.onAuthStateChanged,
        builder: (_, snapshot) {
          // Added this line
          if (snapshot.connectionState == ConnectionState.waiting) {
            return Container();
          }
          if (snapshot.data is FirebaseUser && snapshot.data != null) {
            return HomePage();
          }
          return LoginPage();
        });
  }
}

Cela fonctionne pour FlutterFire .

Firebase Auth vous permet de vous abonner en temps réel à cet état via un Stream. Une fois appelé, le flux fournit un événement immédiat de l'état d'authentification actuel de l'utilisateur, puis fournit des événements ultérieurs chaque fois que l'état d'authentification change. Pour vous abonner à ces modifications, appelez la méthode authStateChanges () sur votre instance FirebaseAuth:

import 'package:firebase_auth/firebase_auth.dart' as auth;
import 'package:flutter/material.dart';
import 'menu.dart';
import 'login.dart';
import 'dart:async';
import 'package:flutter/services.dart';
import 'package:firebase_core/firebase_core.dart';

Future main() async {
      WidgetsFlutterBinding.ensureInitialized();
      await Firebase.initializeApp();
      runApp(
          MyApp()
        );
}

class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    SystemChrome.setPreferredOrientations([DeviceOrientation.portraitUp, DeviceOrientation.portraitUp]);
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      title: 'TestApp',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: 
        StreamBuilder<auth.User>(
          stream: auth.FirebaseAuth.instance.authStateChanges(),
          builder: (BuildContext context, AsyncSnapshot<auth.User> snapshot) { 
            if(snapshot.hasData) {
              print("data exists");
              return HomePage();
            }
            else {
              return LoginPage();
            }
          },
        )
    );
  }
}