Flutter 如何访问使用BloC with flatter登录时获得的身份验证令牌

我已经完成了下面的教程，虽然很有用，但我仍然不知道如何继续前进。我可以登录，用户详细信息通过UserRepository类保存到本地的sqlite数据库中，包括身份验证令牌，但我不知道在尝试向服务器重复请求数据时如何访问它。现有代码没有问题，但我将展示几页，以便您可以看到我所做的和正在尝试实现的，以及如何将其组合在一起

main.dart：

import 'package:flutter/material.dart';
import 'package:flutter/widgets.dart';
import 'package:bloc/bloc.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import './repository/user_repository.dart';

import './bloc/authentication/authentication_bloc.dart';
import './screens/splash_screen.dart';
import './screens/login/login_screen.dart';
import './screens/home_screen.dart';
import './widgets/loading_indicator.dart';
import './widgets/video_widget.dart';
import './screens/home_screen.dart';

const welcomeUrl = 'https://soundjudgement.github.io/static-sf/tour.mp4';
class SimpleBlocDelegate extends BlocDelegate {
  @override
  void onEvent(Bloc bloc, Object event) {
    super.onEvent(bloc, event);
    print(event);
  }

  @override
  void onTransition(Bloc bloc, Transition transition) {
    super.onTransition(bloc, transition);
    print(transition);
  }

  @override
  void onError(Bloc bloc, Object error, StackTrace stacktrace) {
    super.onError(bloc, error, stacktrace);
  }
}

void main() {
  BlocSupervisor.delegate = SimpleBlocDelegate();
  final userRepository = UserRepository();

  runApp(BlocProvider<AuthenticationBloc>(
    create: (context) {
      return AuthenticationBloc(userRepository: userRepository)
        ..add(AppStarted());
    },
    child: SundayFundayApp(userRepository: userRepository),
  ));
}

class SundayFundayApp extends StatelessWidget {
  // This widget is the root of your application.

  final UserRepository userRepository;

  SundayFundayApp({Key key, @required this.userRepository}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'The Yard Mobile App',
      theme: ThemeData(
        primarySwatch: Colors.yellow,
        visualDensity: VisualDensity.adaptivePlatformDensity,
      ),
      home: BlocBuilder<AuthenticationBloc, AuthenticationState>(
        builder: (context, state) {
          if (state is AuthenticationUnintialized) {
            return SplashPage();
          }
          if (state is AuthenticationAuthenticated) {
            return HomeScreen();
          }
          if (state is AuthenticationUnauthenticated) {
            return LogInScreen(
              userRepository: userRepository,
            );
          }
          if (state is AuthenticationLoading) {
            return LoadingIndicator();
          }
        },
      ),
    );
  }
}

导入“包装：颤振/材料.省道”；
导入“package:flatter/widgets.dart”；
导入“包：bloc/bloc.dart”；
进口“包装：颤振团/颤振团.飞镖”；
导入“./repository/user_repository.dart”；
导入“/bloc/authentication/authentication_bloc.dart”；
导入“/screens/splash_screen.dart”；
导入“./screens/login/login_screen.dart”；
导入“./screens/home_screen.dart”；
导入“./widgets/load_indicator.dart”；
导入“./widgets/video_widget.dart”；
导入“./screens/home_screen.dart”；
康斯特韦尔科默尔酒店https://soundjudgement.github.io/static-sf/tour.mp4';
类SimpleBlocDelegate扩展了BlocDelegate{
@凌驾
void onEvent（Bloc Bloc，Object事件）{
超级事件（集团、事件）；
印刷（活动）；
}
@凌驾
无效转换（集团、集团、过渡）{
超级转型（集团、转型）；
印刷（过渡）；
}
@凌驾
void onError（Bloc Bloc，对象错误，StackTrace StackTrace）{
super.onError（bloc、error、stacktrace）；
}
}
void main（）{
BlocSupervisor.delegate=SimpleBlocDelegate（）；
final userRepository=userRepository（）；
runApp（BlocProvider(
创建：（上下文）{
返回AuthenticationBloc（userRepository:userRepository）
…添加（AppStarted（））；
},
子项：SundayFundayApp（userRepository:userRepository），
));
}
SundayFundayApp类扩展了一个小部件{
//此小部件是应用程序的根。
最终用户存储库用户存储库；
SundayFundayApp（{Key-Key，@required this.userRepository}）：super（Key:Key）；
@凌驾
小部件构建（构建上下文）{
返回材料PP(
标题：“庭院移动应用程序”，
主题：主题数据(
主样本：颜色。黄色，
视觉密度：视觉密度。自适应平台密度，
),
主页：BlocBuilder(
生成器：（上下文、状态）{
如果（状态为AuthenticationUnInitialized）{
返回第页（）；
}
如果（状态为AuthenticationAuthenticated）{
返回主屏幕（）；
}
如果（状态为AuthenticationUnauthenticated）{
返回登录屏幕(
userRepository:userRepository，
);
}
如果（状态为AuthenticationLoading）{
返回LoadingIndicator（）；
}
},
),
);
}
}

user_repository.dart

import 'dart:async';
import '../models/user_model.dart';
import 'package:meta/meta.dart';
import '../models/api_model.dart';
import '../api_connection/api_connection.dart';
import '../dba/user_dba.dart';

class UserRepository {
  final userDao = UserDba();

  Future<User> authenticate({
    @required String username,
    @required String password,
  }) async {
    UserLogin userLogin = UserLogin(username: username, password: password);
    Token token = await getToken(userLogin);
    User user = User(
      id: 0,
      username: username,
      token: token.token,
    );
    return user;
  }

  Future<void> persistToken({@required User user}) async {
    // write token with the user to the database
    await userDao.createUser(user);
  }

  Future<void> deleteToken({@required int id}) async {
    await userDao.deleteUser(id);
  }

  Future<bool> hasToken() async {
    bool result = await userDao.checkUser(0);
    return result;
  }
}

导入'dart:async'；
导入“../models/user_model.dart”；
导入“package:meta/meta.dart”；
导入“../models/api_model.dart”；
导入“../api_connection/api_connection.dart”；
导入“../dba/user_dba.dart”；
类用户存储库{
final userDao=UserDba（）；
未来认证({
@必需的字符串用户名，
@必需的字符串密码，
})异步的{
UserLogin UserLogin=UserLogin（用户名：用户名，密码：密码）；
Token-Token=wait-getToken（userLogin）；
用户=用户(
id:0，
用户名：用户名，
token:token.token，
);
返回用户；
}
未来persistToken（{@required User}）异步{
//将用户的令牌写入数据库
等待userDao.createUser（用户）；
}
未来的deleteToken（{@required int id}）异步{
等待userDao.deleteUser（id）；
}
Future hasToken（）异步{
bool result=await userDao.checkUser（0）；
返回结果；
}
}

用户_dao.dart：

import '../database/user_database.dart';
import '../models/user_model.dart';

class UserDao {
  final dbProvider = DatabaseProvider.dbProvider;

  Future<int> createUser(User user) async {
    final db = await dbProvider.database;

    var result = db.insert(userTable, user.toDatabaseJson());
    return result;
  }

  Future<int> deleteUser(int id) async {
    final db = await dbProvider.database;
    var result = await db
        .delete(userTable, where: "id = ?", whereArgs: [id]);
    return result;
  }

  Future<bool> checkUser(int id) async {
    final db = await dbProvider.database;
    try {
      List<Map> users = await db
          .query(userTable, where: 'id = ?', whereArgs: [id]);
      if (users.length > 0) {
        return true;
      } else {
        return false;
      }
    } catch (error) {
      return false;
    }
  }
}

import'../database/user_database.dart'；
导入“../models/user_model.dart”；
类UserDao{
final dbProvider=DatabaseProvider.dbProvider；
未来createUser（用户用户）异步{
final db=await dbProvider.database；
var result=db.insert（userTable，user.toDatabaseJson（））；
返回结果；
}
未来删除用户（int-id）异步{
final db=await dbProvider.database；
var结果=等待db
.delete（userTable，其中：“id=？”，其中rgs:[id]）；
返回结果；
}
未来checkUser（int-id）异步{
final db=await dbProvider.database；
试一试{
列表用户=等待数据库
.query（userTable，其中：“id=？”，其中rgs:[id]）；
如果（users.length>0）{
返回true；
}否则{
返回false；
}
}捕获（错误）{
返回false；
}
}
}

登录\u screen.dart：

import 'package:flutter/material.dart';
import 'package:font_awesome_flutter/font_awesome_flutter.dart';
import '../../repository/user_repository.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import '../../bloc/authentication/authentication_bloc.dart';
import './bloc/login_bloc.dart';
import 'login_form.dart';

class LogInScreen extends StatelessWidget {

  final UserRepository userRepository;

  LogInScreen({Key key, @required this.userRepository})
      : assert(userRepository != null),
        super(key: key);

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        // Here we take the value from the MyHomePage object that was created by
        // the App.build method, and use it to set our appbar title.
        title: Text('The Yard App'),
      ),
      body:  Container(
        decoration: BoxDecoration(
          image: DecorationImage(
            image: AssetImage('assets/images/theyardbook.png'),
              fit: BoxFit.cover,
          )
        ),
      child: BlocProvider(
          create: (context) {
            return LoginBloc(
              authenticationBloc: BlocProvider.of<AuthenticationBloc>(context),
              userRepository: userRepository,
            );
          },
        child: Container(
           child: Scaffold(
            backgroundColor: Colors.transparent,
            body: Container(
              width: MediaQuery.of(context).size.width,
              decoration: BoxDecoration(
                borderRadius: BorderRadius.circular(20),
                color: Colors.transparent,
              ),
              child: Padding(
                padding: EdgeInsets.all(23),
                child:     LoginForm(),

                ),
              ),
            ),
          ),
        ),
      ),
    );
  }
}

导入“包装：颤振/材料.省道”；
导入“package:font_awesome_flatter/font_awesome_flatter.dart”；
导入“../repository/user_repository.dart”；
进口“包装：颤振团/颤振团.飞镖”；
导入“../bloc/authentication/authentication_bloc.dart”；
导入“./bloc/loginu bloc.dart”；
导入“login_form.dart”；
类LogInScreen扩展了无状态小部件{
最终用户存储库用户存储库；
LogInScreen（{Key，@required this.userRepository}）
：assert（userRepository！=null），
超级（键：键）；
@凌驾
小部件构建（构建上下文）{
返回脚手架(
appBar:appBar(
//在这里，我们从MyHomePage对象中获取由创建的值
//使用App.build方法，并使用它设置appbar标题。
标题：文本（“庭院应用程序”），
),
主体：容器(
装饰：盒子装饰(
图像：装饰图像(
image:AssetImage（'assets/images/theyardbook.png'），
适合：BoxFit.cover，
)
),
孩子：BlocProvider(
创建：（上下文）{
返回登录位置(
authenticationBloc:BlocProvider.of（contex
  Future<String> getUserToken(int id) async {
    final db = await dbProvider.database;
    try {
      var res = await db.rawQuery("SELECT token FROM userTable WHERE id=0");
      return res.isNotEmpty ? (User.fromDatabaseJson(res.first)).token : null;
    } catch (err) {
      return null;
    }
  }


import 'package:flutter/material.dart';
import 'package:flutter/widgets.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import '../widgets/logout_button.dart';
import '../repository/user_repository.dart';
import 'package:http/http.dart' as http;
import '../dao/user_dao.dart';
import '../api_connection/api_connection.dart';
import '../models/user_model.dart';

class UserScreen extends StatefulWidget {

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

class _UserScreenState extends State<UserScreen> {

  Future<User> futureUser;

  @override
  void initState() {
    super.initState();
    futureUser = getUser();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('The Yard Users'),
      ),
      body: Container(
        child: FutureBuilder( // use a future builder widget
          future: futureUser, // assign the future
          builder: (context, snapshot) {
            if (snapshot.hasData) {
              return Column(
                // show your layout if future is done
                mainAxisAlignment: MainAxisAlignment.center,
                crossAxisAlignment: CrossAxisAlignment.center,
                children: <Widget>[
                  Padding(
                    padding: EdgeInsets.only(left: 30.0),
                    child: Text(
                      'Username: ${snapshot.data.username}', // get the username from the snapshot
                      style: TextStyle(
                        fontSize: 24.0,
                      ),
                    ),
                  ),
                  // Logout button
                  Padding(
                    padding: EdgeInsets.fromLTRB(34.0, 20.0, 0.0, 0.0),
                    child: Container(
                        width: MediaQuery.of(context).size.width * 0.85,
                        height: MediaQuery.of(context).size.width * 0.16,
                        child: LogoutButton()
                    ),
                  ),
                ],
              );
            } else {
              return CircularProgressIndicator(); // show a progress indicator while future is executing
            }
          },
        ),
      ),
    );
  }
}