Android 如何使在Flatter应用程序中播放的视频在再次打开应用程序后从最后一站开始播放？

我有一个Flitter应用程序，可以在线和离线观看视频，但问题是，在线观看视频时，我必须保存其最后一次暂停状态，并在用户再次打开应用程序后将其显示为“继续观看”

简而言之，如果用户退出应用程序，则在观看视频时，如果用户再次进入应用程序，则应显示上次播放的视频及其观看时间

我用的是颤振咀嚼包

下面是我的代码。谁能帮我一下吗

import 'dart:convert';
import 'dart:io';
import 'package:flutter/services.dart';
import 'package:nexthour/apidata/apidata.dart';
import 'package:nexthour/custom_player/chewie.dart';
import 'package:flutter/material.dart';
import 'package:nexthour/ui/multi_screen_page.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:video_player/video_player.dart';
import 'package:wakelock/wakelock.dart';
import 'package:http/http.dart' as http;
import '../global.dart';

class MyCustomPlayer extends StatefulWidget 
{
   MyCustomPlayer({this.title, this.url, this.downloadStatus});

   final String title;
   final String url;
   final int downloadStatus;

   @override
   State<StatefulWidget> createState() 
   {
       return _MyCustomPlayerState();
   }
}

class _MyCustomPlayerState extends State<MyCustomPlayer> with WidgetsBindingObserver 
{
   TargetPlatform _platform;
   VideoPlayerController _videoPlayerController1;
   VideoPlayerController _videoPlayerController2;
   ChewieController _chewieController;
   DateTime currentBackPressTime;


   void stopScreenLock() async
   {
       Wakelock.enable();
   }

   saveNewToken(token) async 
   {
       prefs = await SharedPreferences.getInstance();
       prefs.setString('token', "$token");
   }

   getNewToken() async 
   {
       prefs = await SharedPreferences.getInstance();
       prefs.getString('token');
       nToken = prefs.getString('token');
   }

   updateScreens(screen, count) async 
   {
       final updateScreensResponse = await http.post(APIData.updateScreensApi, body: 
       {
           "macaddress": '$ip',
           "screen": '$screen',
           "count": '$count',
           }, 
           headers: 
           {
               // ignore: deprecated_member_use
               HttpHeaders.AUTHORIZATION: nToken == null ? fullData : nToken
           });
       print(updateScreensResponse.statusCode);
       print(fullData);
       print(updateScreensResponse.body);
       if (updateScreensResponse.statusCode == 200) 
       {
           print(updateScreensResponse.body);
       }
   }   

   //  Handle back press
   Future<bool> onWillPopS() 
   {
       print("Back Pressed");
       if(userPaymentType != "Free")
       {
           screenLogout();
       }
       SystemChrome.setPreferredOrientations([DeviceOrientation.portraitUp]);
       Navigator.pop(context);
       return Future.value(true);
   }

   screenLogout() async 
   {
       Wakelock.disable();
       final screenLogOutResponse = await http.post( APIData.screenLogOutApi, body: 
       {
           "screen": '$myActiveScreen',
           "count": '${fileContent['screenCount']}',
       }, 
       headers: 
       {
           HttpHeaders.authorizationHeader: nToken == null ? fullData : nToken
       });
       print(screenLogOutResponse.statusCode);
       print(screenLogOutResponse.body);

       final accessToken = await http.post(APIData.tokenApi, body: 
       {
           "email": fileContent['user'],
           "password": fileContent['pass'],
       });


       if(accessToken.statusCode == 200)
       {
           print("Logged In");
           var user = json.decode(accessToken.body);
           var newToken = "Bearer ${user['access_token']}";
           saveNewToken(newToken);
           getNewToken();
       }
   }

   Future<void> didChangeAppLifecycleState(AppLifecycleState state) async 
   {
       switch(state)
       {
           case AppLifecycleState.inactive:
               _chewieController.pause();
               debugPrint("Inactive");
               break;
           case AppLifecycleState.resumed:
               _chewieController.pause();
               if(userPaymentType != "Free")
               {
                   updateScreens(myActiveScreen, fileContent["screenCount"]);
               }
               break;
           case AppLifecycleState.paused:
               _chewieController.pause();
               if(userPaymentType != "Free")
               {
                   screenLogout();
               }
               break;
           case AppLifecycleState.detached:
               break;
       }
   }

   @override
   void initState()
   {
       super.initState();
       this.stopScreenLock();
       setState(()
       {
           playerTitle = widget.title;
           SystemChrome.setEnabledSystemUIOverlays([]);
           SystemChrome.setPreferredOrientations([DeviceOrientation.landscapeLeft]);

       });

       WidgetsBinding.instance.addObserver(this);

       _videoPlayerController1 = VideoPlayerController.network(widget.url);
       _videoPlayerController2 = VideoPlayerController.network(widget.url);
       
       _chewieController = ChewieController
       (
           videoPlayerController: _videoPlayerController1,
           aspectRatio: 3/2,
           autoPlay: true,
           looping: true,
           // deviceOrientationsAfterFullScreen: ,
           materialProgressColors: ChewieProgressColors
           (
               playedColor: Colors.red,
               handleColor: Colors.red,
               backgroundColor: Colors.white.withOpacity(0.6),
               bufferedColor: Colors.white,
           ),
           placeholder: Container
           (
               color: Colors.black,
           ),
           // autoInitialize: true,
       );

       var r = _videoPlayerController1.value.aspectRatio;
       print("neeraj $r");
       String os = Platform.operatingSystem;
       
       if(os == 'android')
       {
           setState(()
           {
               _platform = TargetPlatform.android;
           });
       }
       else
       {
           setState(()
           {
               _platform = TargetPlatform.iOS;
           });
       }

   }

   @override
   void dispose() 
   {
       _videoPlayerController1.dispose();
       _videoPlayerController2.dispose();
       _chewieController.dispose();
       super.dispose();
   }

   @override
   Widget build(BuildContext context)
   {
       print("inside m player.dart");
       return WillPopScope
       (
           child: Scaffold
           (
               body: SafeArea
               (
                   top: true,
                   child: Column
                   (
                       children: <Widget>
                       [
                           Expanded
                           (
                               child: Center
                               (
                                   child: Chewie
                                   (
                                       controller: _chewieController,
                                       title: widget.title,
                                       downloadStatus: widget.downloadStatus,
                                   ),
                               ),
                           ),
                       ],
                   ),
               ),
           ),
           onWillPop: onWillPopS
       );
   }
}

导入'dart:convert'；
导入“dart:io”；
导入“包：flifter/services.dart”；
导入“package:nexthour/apidata/apidata.dart”；
导入“包：下一个/custom_player/chuie.dart”；
进口“包装：颤振/材料.省道”；
导入“package:nexthour/ui/multi_screen_page.dart”；
导入“package:shared_preferences/shared_preferences.dart”；
导入“package:video_player/video_player.dart”；
导入“包：wakelock/wakelock.dart”；
将“package:http/http.dart”导入为http；
导入“../global.dart”；
类MyCustomPlayer扩展StatefulWidget
{
MyCustomPlayer（{this.title，this.url，this.downloadStatus}）；
最后的字符串标题；
最终字符串url；
最终int下载状态；
@凌驾
状态createState（）
{
返回_MyCustomPlayerState（）；
}
}
类_MyCustomPlayerState使用WidgetsBindingObserver扩展状态
{
目标平台(TargetPlatform);；
视频播放控制器\u视频播放控制器1；
视频播放控制器\u视频播放控制器2；
咀嚼控制器；
DateTime currentBackPressTime；
void stopScreenLock（）异步
{
Wakelock.enable（）；
}
saveNewToken（令牌）异步
{
prefs=等待SharedReferences.getInstance（）；
prefs.setString（'token'，“$token”）；
}
getNewToken（）异步
{
prefs=等待SharedReferences.getInstance（）；
prefs.getString（'token'）；
nToken=prefs.getString（'token'）；
}
更新屏幕（屏幕、计数）异步
{
final updateScreensResponse=等待http.post（APIData.updateScreensApi，正文：
{
“macaddress”：“$ip”，
“屏幕”：“$screen”，
“计数”：“$count”，
}, 
标题：
{
//忽略：不推荐的\u成员\u使用
HttpHeaders.AUTHORIZATION:nToken==null？fullData:nToken
});
打印（更新筛选响应状态代码）；
打印（完整数据）；
打印（updateScreensResponse.body）；
如果（updateScreensResponse.statusCode==200）
{
打印（updateScreensResponse.body）；
}
}   
//背压手柄
未来的未来
{
打印（“反压”）；
如果（userPaymentType！=“免费”）
{
屏幕注销（）；
}
SystemChrome.setPreferredOrientations（[DeviceOrientation.GraphicUp]）；
Navigator.pop（上下文）；
返回未来值（true）；
}
screenLogout（）异步
{
Wakelock.disable（）；
final screenLogOutResponse=等待http.post（APIData.screenLogOutApi，正文：
{
“屏幕”：“$myActiveScreen”，
“计数”：“${fileContent['screenCount']}”，
}, 
标题：
{
HttpHeaders.authorizationHeader:nToken==null？完整数据：nToken
});
打印（屏幕标识响应状态代码）；
打印（屏幕标识或响应正文）；
final accessToken=wait http.post（APIData.tokenApi，正文：
{
“电子邮件”：fileContent['user']，
“密码”：fileContent['pass']，
});
如果（accessToken.statusCode==200）
{
打印（“登录”）；
var user=json.decode（accessToken.body）；
var newToken=“Bearer${user['access\u token']}”；
saveNewToken（newToken）；
getNewToken（）；
}
}
Future didChangeAppLifecycleState（AppLifecycleState状态）异步
{
开关（状态）
{
案例AppLifecycleState.inactive：
_chouicontroller.pause（）；
调试打印（“非活动”）；
打破
案例AppLifecycleState.resumed：
_chouicontroller.pause（）；
如果（userPaymentType！=“免费”）
{
更新屏幕（myActiveScreen，fileContent[“screenCount”]）；
}
打破
案例AppLifecycleState.paused：
_chouicontroller.pause（）；
如果（userPaymentType！=“免费”）
{
屏幕注销（）；
}
打破
案例AppLifecycleState.0：
打破
}
}
@凌驾
void initState（）
{
super.initState（）；
这个.stopScreenLock（）；
设置状态（）
{
playerTitle=widget.title；
SystemChrome.SetEnabledSystemEmioVerlays（[]）；
SystemChrome.setPreferredOrientations（[DeviceOrientation.landscapeLeft]）；
});
WidgetsBinding.instance.addObserver（这个）；
_VideoPlayerController 1=VideoPlayerController.network（widget.url）；
_VideoPlayerController 2=VideoPlayerController.network（widget.url）；
_咀嚼控制器=咀嚼控制器
(
videoPlayerController:\u videoPlayerController 1，
方面：3/2，
自动播放：对，
循环：对，
//全屏显示后的设备方向：，
MaterialProgressColor:ChewieProgressColor
(
播放颜色：Colors.red，
手颜色：颜色。红色，
背景颜色：颜色。白色。不透明度（0.6），
bufferedColor:Colors.white，
),
占位符：容器
(
颜色：颜色，黑色，
),
//自动初始化：true，
);
var r=\u VideoPlayerController 1.value.aspectRatio；
印刷品