OpenMediacenterMobileFlutter/lib/video_screen/videoscreen_desktop.dart

import 'dart:async';
import 'dart:convert';
import 'dart:math';

import 'package:chewie/chewie.dart';
import "package:dart_vlc/dart_vlc.dart";
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:openmediacentermobile/preview/preview_tile.dart';
import 'package:openmediacentermobile/screen_loading.dart';
import 'package:openmediacentermobile/video_screen/actor_view.dart';
import 'package:video_player/video_player.dart';

import '../api/api.dart';
import '../api/token.dart';
import '../platform.dart';
import '../types/video_data.dart';

class VideoScreen extends StatefulWidget {
  const VideoScreen({Key? key, required this.metaData}) : super(key: key);
  final VideoT metaData;

  @override
  State<VideoScreen> createState() => _VideoScreenState();
}

class _VideoScreenState extends State<VideoScreen> {
  Player? _player =
      isDesktop() ? Player(id: Random().nextInt(0x7fffffff)) : null;
  ChewieController? _chewieController;

  bool _appBarVisible = true;
  Timer? _appBarTimer;
  late Future<VideoData> _videoData;

  Future<VideoData> loadVideoData() async {
    final data =
        await API.query("video", "loadVideo", {'MovieId': widget.metaData.id});

    final d = jsonDecode(data);
    final video = VideoData.fromJson(d);
    return video;
  }

  void initPlayer() async {
    final videodata = await _videoData;

    final token = await Token.getInstance().getToken();
    if (token == null) return;

    final baseurl = token.domain;
    // todo not static middle path
    final path = baseurl + "/videos/vids/" + videodata.movieUrl;

    if (isDesktop()) {
      final media2 = Media.network(path);

      _player?.open(
        media2,
        autoStart: true, // default
      );
    } else {
      final VideoPlayerController _controller =
          VideoPlayerController.network(path);
      await _controller.initialize();

      _chewieController = ChewieController(
          videoPlayerController: _controller,
          autoPlay: true,
          looping: true,
          allowFullScreen: true,
          allowMuting: true,
          allowPlaybackSpeedChanging: true,
          zoomAndPan: true);

      setState(() {});
    }
  }

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

    _videoData = loadVideoData();
    initPlayer();

    if (isDesktop()) {
      RawKeyboard.instance.addListener((value) {
        if (value.logicalKey == LogicalKeyboardKey.arrowRight) {
          _player
              ?.seek(_player!.position.position! + const Duration(seconds: 5));
        } else if (value.logicalKey == LogicalKeyboardKey.arrowLeft) {
          _player
              ?.seek(_player!.position.position! + const Duration(seconds: -5));
        }
      });
    }

    _setAppBarTimer();
  }

  @override
  void dispose() {
    if (isDesktop()) {
      _player?.dispose();
    } else {
      _chewieController?.videoPlayerController.dispose();
      _chewieController?.dispose();
    }
    _controller.dispose();
    _appBarTimer?.cancel();
    super.dispose();
  }

  void _setAppBarTimer() {
    _appBarTimer?.cancel();
    _appBarTimer = Timer(
      Duration(seconds: 3),
      () {
        setState(() {
          _appBarVisible = false;
        });
      },
    );
  }

  PageController _controller = PageController(
    initialPage: 0,
  );

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: FutureBuilder(
        future: _videoData,
        builder: (context, AsyncSnapshot<VideoData> snapshot) {
          if (snapshot.hasError) {
            return Text("Error");
          } else if (snapshot.hasData) {
            return MouseRegion(
              onHover: (PointerEvent event) async {
                if (event.delta.dx != 0 || event.delta.dy != 0) {
                  if (_appBarVisible) {
                    await Future.delayed(Duration(milliseconds: 100));
                    setState(() {
                      _appBarVisible = false;
                    });
                  } else {
                    setState(() {
                      _appBarVisible = true;
                    });
                    _setAppBarTimer();
                  }
                }
              },
              child: Stack(children: [
                PageView(
                    scrollDirection: Axis.vertical,
                    controller: _controller,
                    children: [
                      Center(
                          child:
                              isDesktop() ? videoDesktop() : videoNotDesktop()),
                      ActorView(
                        vdata: snapshot.data!,
                      )
                    ]),
                if (_appBarVisible)
                  new Positioned(
                    top: 0.0,
                    left: 0.0,
                    right: 0.0,
                    child: AppBar(
                      title: Text(widget.metaData.title),
                      leading: new IconButton(
                        icon:
                            new Icon(Icons.arrow_back_ios, color: Colors.grey),
                        onPressed: () => Navigator.of(context).pop(),
                      ),
                      backgroundColor:
                          Theme.of(context).primaryColor.withOpacity(0.3),
                      elevation: 0.0,
                    ),
                  ),
              ]),
            );
          } else {
            return ScreenLoading();
          }
        },
      ),
    );
  }

  Widget videoDesktop() {
    return Video(
      player: _player,
      scale: 1.0, // default
      showControls: true,
      playlistLength: 1,
    );
  }

  Widget videoNotDesktop() {
    if (_chewieController == null) {
      return Column(
        crossAxisAlignment: CrossAxisAlignment.center,
        mainAxisAlignment: MainAxisAlignment.center,
        children: const [CircularProgressIndicator(), Text("loading...")],
      );
    }
    return Chewie(
      controller: _chewieController!,
    );
  }
}