Wakelock not function about media-kit HOT 3 OPEN

  ` import 'dart:async';
  
  import 'package:animeTv/models/episode_page.dart';
  import 'package:animeTv/screens/video-player/fullscreen_episodes_screen.dart';
  import 'package:animeTv/util/constants.dart';
  import 'package:animeTv/widgets/custom-player/base_player.dart';
  import "package:flutter/material.dart";
  import 'package:flutter/services.dart';
  import 'package:flutter_spinkit/flutter_spinkit.dart';
  import 'package:media_kit/media_kit.dart';
  import 'package:media_kit_video/media_kit_video.dart';
  
  class CustomPlayer extends StatefulWidget {
    final GlobalKey<VideoState> videoKey;
    final VideoController controller;
    final bool fromDownload;
    final EpisodePage? episode;
    final Function callback;
    final int initialPosition;
    final VoidCallback nextEpisode;
    final Function(String episodeLink) startEpisode;
    final List<EpisodeInList>? episodes;
  
    const CustomPlayer({
      super.key,
      required this.videoKey,
      required this.controller,
      required this.fromDownload,
      required this.episode,
      required this.callback,
      required this.initialPosition,
      required this.nextEpisode,
      required this.startEpisode,
      this.episodes,
    });
  
    @override
    State<CustomPlayer> createState() => _CustomPlayerState();
  }
  
  class _CustomPlayerState extends State<CustomPlayer> {
    bool hasLoaded = false;
    bool hasError = false;
  
    void initController() {
      if (!widget.fromDownload) {
        widget.controller.player.stream.position.listen(
          (Duration position) {
            widget.callback(position);
          },
        );
      }
    }
  
    void loadVideo(Duration position, String url) async {
      await widget.controller.player.open(Media(url));
      widget.controller.player.stream.duration.listen((event) async {
        if (event.inSeconds > 0) {
          await widget.controller.player.seek(position);
        }
      });
    }
  
    void _moveSeconds(String moveType) async {
      final currentDuration = widget.controller.player.state.position;
      //aggiungo o sottraggo 10 secondi alla durata iniziale
      final newDuration =
          currentDuration + Duration(seconds: moveType == "forward" ? 10 : -10);
  
      await widget.controller.player.seek(newDuration);
    }
  
    void _onClosePlayer() {
      //se sono nei download  chiudo la pagina completamente e torno a quella precedente
      if (widget.fromDownload) {
        Navigator.of(context).popUntil((route) => route.isFirst);
      } else {
        Constants.navigatorKey.currentState?.pop();
      }
  
      SystemChrome.setPreferredOrientations([
        DeviceOrientation.portraitUp,
        DeviceOrientation.portraitDown,
      ]);
  
      SystemChrome.setEnabledSystemUIMode(SystemUiMode.manual, overlays: [SystemUiOverlay.top, SystemUiOverlay.bottom]);
    }
  
    void _openEpisodes() {
      widget.controller.player.pause();
      Constants.navigatorKey.currentState!
          .push(MaterialPageRoute(builder: (context) {
        return FullscreenEpisodesScreen(
          allEpisodes: widget.episodes!,
          startEpisode: (String episodeLink) {
            widget.startEpisode(episodeLink);
          },
          onClose: () {
            widget.controller.player.play();
          },
        );
      }));
    }
  
    Future<void> initPlayer({
      required Duration position,
    }) async {
      loadVideo(position, widget.episode!.videoUrl);
    }
  
    initAll() async {
      initController();
      initPlayer(position: Duration(seconds: widget.initialPosition));
  
      setState(() {
        hasLoaded = true;
      });
    }
  
    @override
    void initState() {
      initAll();
      super.initState();
    }
  
    @override
    Widget build(BuildContext context) {
      return BasePlayer(
        controller: widget.controller,
        nextEpisode: widget.nextEpisode,
        moveSeconds: (String type) {
          _moveSeconds(type);
        },
        onClosePlayer: () {
          _onClosePlayer();
        },
        openEpisodes: widget.episodes != null ? _openEpisodes : null,
        fromDownload: widget.fromDownload,
        body: hasError
            ? Container(
                alignment: Alignment.center,
                color: Theme.of(context).colorScheme.background,
                child: const Text(
                  "Sembra che il video sia ancora in fase di elaborazione,\n riprova più tardi",
                  textAlign: TextAlign.center,
                ),
              )
            : hasLoaded
                ? Video(
                    key: widget.videoKey,
                    controller: widget.controller,
                    controls: MaterialVideoControls,
                    onEnterFullscreen: () async {
                      await defaultEnterNativeFullscreen();
                    },
                    onExitFullscreen: () async {
                      _onClosePlayer();
                    },
                  )
                : Flexible(
                    child: Center(
                      child: SpinKitThreeInOut(
                        color: Theme.of(context).colorScheme.primary,
                        size: 30,
                      ),
                    ),
                  ),
      );
    }
  }`