Firebase 吸气剂'；uid'；被调用为空

伙计们，我有一个带有电子邮件和密码的登录页面，当用户成功登录时，它会将用户带到聊天屏幕。在聊天屏幕上，我需要访问用户uid来检查谁在发送消息，但我得到的是“getter'uid'被调用为null”。我正在使用bloc模式使用验证器登录。我怎样才能解决这个问题

class LoginScreen extends StatefulWidget {
   FirebaseUser user;

   @override
   _LoginScreenState createState() => _LoginScreenState();
    }

   class _LoginScreenState extends State<LoginScreen> {

       final _loginBloc = LoginBloc();

    @override
      void initState() {
        super.initState();

       _loginBloc.outState.listen((state) async {
        switch (state) {
          case LoginState.SUCCESS:
            Navigator.of(context).pushReplacement(
               MaterialPageRoute(builder: (context) => ComercialUserScreen()));

            break;
            case LoginState.FAIL:
              showDialog(
           context: context,
           builder: (context) => AlertDialog(
                title: Text('Erro'),
                content: Text('Revise seu email e senha'),
              ));
         break;
       case LoginState.LOADING:
       case LoginState.IDLE:
      }
   });
  }

   @override
     Widget build(BuildContext context) {
      return Scaffold(
         body: StreamBuilder<LoginState>(
      stream: _loginBloc.outState,
      initialData: LoginState.LOADING,
      // ignore: missing_return
      builder: (context, snapshot) {
        print(snapshot.data);
        switch (snapshot.data) {
          case LoginState.LOADING:
            return Center(
              child: CircularProgressIndicator(),
            );
          case LoginState.FAIL:
          case LoginState.SUCCESS:
          case LoginState.IDLE:
            return Column(
              crossAxisAlignment: CrossAxisAlignment.stretch,
              children: <Widget>[
                InputField(
                  icon: Icons.person_outline,
                  hint: 'Usuário',
                  obscure: false,
                  stream: _loginBloc.outEmail,
                  onChanged: _loginBloc.changeEmail,
                ),
                InputField(
                  icon: Icons.lock_outline,
                  hint: 'Senha',
                  obscure: true,
                  stream: _loginBloc.outEmail,
                  onChanged: _loginBloc.changePassword,
                ),
                SizedBox(
                  height: 32,
                ),
                StreamBuilder<bool>(
                    stream: _loginBloc.outSubmitValid,
                    builder: (context, snapshot) {
                      return RaisedButton(
                        child: Text("Entrar"),
                        onPressed:
                            snapshot.hasData ? _loginBloc.submit : null,
                      );
                    })
              ],
            );
        }
      }),
    );
   }
  }

 class LoginBloc extends BlocBase with LoginValidators{

    FirebaseUser _currentUser;

    final _emailController = BehaviorSubject<String>();
    final _passwordController = BehaviorSubject<String>();
    final _stateController = BehaviorSubject<LoginState>();

    Stream<String> get outEmail => _emailController.stream.transform(validateEmail);
    Stream<String> get outPassword =>_passwordController.stream.transform(validatePassword);
    Stream<LoginState> get outState => _stateController.stream;

    Stream<bool> get outSubmitValid => Observable.combineLatest2(
    outEmail, outPassword, (a, b) => true);

    Function(String) get changeEmail => _emailController.sink.add;
    Function(String) get changePassword => _passwordController.sink.add;

    StreamSubscription _streamSubscription;

    LoginBloc(){
        _streamSubscription = FirebaseAuth.instance.onAuthStateChanged.listen((user) async {
          if(user != null) {
            if(await verifyAdmins(user)) {
             _stateController.add(LoginState.SUCCESS);

        } else {
           FirebaseAuth.instance.signOut();
          _stateController.add(LoginState.FAIL);
        }

       } else {
         _stateController.add(LoginState.IDLE);
         }
      });
     }

     void submit (){
     final email = _emailController.value;
     final password = _passwordController.value;

      _stateController.add(LoginState.LOADING);

      FirebaseAuth.instance.signInWithEmailAndPassword(
      email: email,
      password: password
       ).catchError((e) {
      _stateController.add(LoginState.FAIL);
    });
  }

   Future<bool> verifyAdmins (FirebaseUser user) async {
    return await Firestore.instance.collection('users').document(user.uid).get().then((doc) 
    {
    if(doc.data != null){
     return true;
     } else {
      return false;
     }
    }).catchError((e) {
   return false;
  });
 }




@override
 void dispose() {
  _emailController.close();
  _passwordController.close();
  _stateController.close();

  _streamSubscription.cancel();
  // TODO: implement dispose
 }
}


 class _AdminChatState extends State<AdminChat> {

    bool _isLoading = false;

    void _sendMessage({String text, File imgFile}) async {

     DocumentSnapshot snapshot;

     FirebaseUser user = await FirebaseAuth.instance.currentUser();

     Map<String, dynamic> data = {
       "uid" : user.uid,
       'name' : user.displayName,
       'photo' : user.photoUrl,
       'time' : Timestamp.now()
      };

      if (imgFile != null){
         StorageUploadTask task = FirebaseStorage.instance.ref().child('users').child(
         DateTime.now().millisecondsSinceEpoch.toString()
       ).putFile(imgFile);

        setState(() {
        _isLoading = true;
         });

         StorageTaskSnapshot taskSnapshot = await task.onComplete;
         String url = await taskSnapshot.ref.getDownloadURL();
         data['imgUrl'] = url;

         setState(() {
          _isLoading = false;
         });
         }


      if(text != null) data["text"] = text;


       Firestore.instance.collection("users").document(snapshot.documentID)
       .collection('messages').add(data);

      }



     @override
      Widget build(BuildContext context) {
       return Scaffold(
         appBar: AppBar(
           title: Text('hello'),

         ),
          body: Column(
           children: <Widget>[
            Expanded(
             child: StreamBuilder<QuerySnapshot>(
               stream: 
       Firestore.instance.collection('users').document(widget.snapshot.documentID)
       .collection('messages').orderBy('time').snapshots(),
              builder: (context, snapshot){
               switch(snapshot.connectionState) {
                  case ConnectionState.none:
                  case ConnectionState.waiting:
                   return Center(
                     child: CircularProgressIndicator(),
                    );
                  default:
                    List<DocumentSnapshot> documents =
                    snapshot.data.documents.reversed.toList();

                return ListView.builder(
                    itemCount: documents.length,
                    reverse: true,
                    itemBuilder: (context, index){
                      // ignore: unrelated_type_equality_checks
                      return ChatMessage(documents[index].data, true);
                    });
            }
          },

          ),
         ),
      _isLoading ? LinearProgressIndicator() : Container(),
      TextComposer(_sendMessage),
    ],
   ),
  );
 }
 }

class LoginScreen扩展StatefulWidget{
FirebaseUser用户；
@凌驾
_LoginsScreenState createState（）=>\u LoginsScreenState（）；
}
类_LoginScreenState扩展状态{
最终_loginBloc=loginBloc（）；
@凌驾
void initState（）{
super.initState（）；
_loginBloc.outState.listen（（状态）异步{
开关（状态）{
case LoginState.SUCCESS：
导航器.of（上下文）.pushReplacement(
MaterialPage路由（生成器：（上下文）=>ComercialUserScreen（））；
打破
case LoginState.FAIL：
显示对话框(
上下文：上下文，
生成器：（上下文）=>AlertDialog(
标题：文本（“Erro”），
内容：文本（“修订seu电子邮件e senha”），
));
打破
case LoginState.LOADING：
case LoginState.IDLE：
}
});
}
@凌驾
小部件构建（构建上下文）{
返回脚手架(
正文：StreamBuilder(
流：_loginBloc.outState，
initialData:LoginState.LOADING，
//忽略：缺少返回
生成器：（上下文，快照）{
打印（快照数据）；
交换机（snapshot.data）{
case LoginState.LOADING：
返回中心(
子对象：CircularProgressIndicator（），
);
case LoginState.FAIL：
case LoginState.SUCCESS：
case LoginState.IDLE：
返回列(
crossAxisAlignment:crossAxisAlignment.stretch，
儿童：[
输入字段(
图标：Icons.person\u轮廓，
提示：“Usuário”，
模糊：错，
流：_loginBloc.outEmail，
一旦更改：_loginBloc.changemail，
),
输入字段(
图标：Icons.lock_轮廓，
提示：“Senha”，
莫名其妙：是的，
流：_loginBloc.outEmail，
一旦更改：_loginBloc.changePassword，
),
大小盒子(
身高：32，
),
StreamBuilder(
流：_loginBloc.outSubmitValid，
生成器：（上下文，快照）{
返回上升按钮(
子项：文本（“entra”），
按下按钮：
snapshot.hasData？\u loginBloc.submit:null，
);
})
],
);
}
}),
);
}
}
类LoginBloc使用LoginValidator扩展BlocBase{
FirebaseUser\u currentUser；
final _emailController=BehaviorSubject（）；
final _passwordController=BehaviorSubject（）；
最终_stateController=行为主体（）；
Stream get outEmail=>\u emailController.Stream.transform（validateEmail）；
Stream get outPassword=>\u passwordController.Stream.transform（validatePassword）；
Stream get outState=>\u stateController.Stream；
Stream get outSubmitValid=>Observable.CombineRelatest2(
outEmail，outPassword，（a，b）=>true）；
函数（字符串）get-changeEmail=>\u-emailController.sink.add；
函数（字符串）get changePassword=>\u passwordController.sink.add；
StreamSubscription\u StreamSubscription；
LoginBloc（）{
_streamSubscription=FirebaseAuth.instance.onAuthStateChanged.listen（（用户）异步{
如果（用户！=null）{
if（等待验证管理员（用户））{
_stateController.add（LoginState.SUCCESS）；
}否则{
FirebaseAuth.instance.signOut（）；
_stateController.add（LoginState.FAIL）；
}
}否则{
_stateController.add（LoginState.IDLE）；
}
});
}
作废提交（）{
最终电子邮件=_emailController.value；
最终密码=_passwordController.value；
_stateController.add（LoginState.LOADING）；
FirebaseAuth.instance.signInWithEmailAndPassword(
电邮:电邮,，
密码：密码
).catchError（（e）{
_stateController.add（LoginState.FAIL）；
});
}
未来的verifyAdmins（FirebaseUser用户）异步{
return wait Firestore.instance.collection（'users'）.document（user.uid）.get（）.then（（doc）
{
如果（doc.data！=null）{
返回true；
}否则{
返回false；
}
}).catchError（（e）{
返回false；
});
}
@凌驾
无效处置（）{
_emailController.close（）；
_passwordController.close（）；
_stateController.close（）；
_streamSubscription.cancel（）；
//TODO:实现dispose
}
}
类\u AdminChatState扩展状态{
bool_isLoading=false；
void_sendMessage（{String text，File imgFile}）异步{
文档快照；
FirebaseUser=等待FirebaseAuth.instance.currentUser（）；
地图数据={
“uid”：user.uid，
“名称”：user.displayName，
“照片”：user.photoUrl，
“时间”：Timestamp.now（）
};
if（imgFile！=null）{
StorageUploadTask任务=FirebaseStorage.instance.ref（）.child（'users'）.child(
DateTime.now（）.millissecondssinceepoch.toString（）
).putFile（imgFile）；
设置状态（）{
_isLoading=true；
});
StorageTaskSnapshot taskSnapshot=wait task.onComplete；
字符串url=await taskSnapshot.ref.getDownloadURL（）；
数据['imgUrl']=url；
设置状态（）{
_isLoading=false；
});
}
如果（text！=null）数据[“text”]=text；
Firestore.instance.collection（“用户”）.document（snapshot.documentID）