Proyectos de Subversion Iphone Microlearning - Nuevo Interface

//

//  VideoPlayerView.swift

//  twogetskills

//

//  Created by Efrain Yanez Recanatini on 4/24/22.

//

import Foundation

import SwiftUI

import AVKit

struct VideoPlayerView: View {

    @EnvironmentObject private var appNavigation : AppNavigation

    @State private var timerActive : Bool = false

    @State private var isCompleted : Bool = false

    private let appData = AppData.sharedInstance

    //@State private var backToGallery : Bool = false

    private let timer = Timer.publish(every: 1, on: .main, in: .common).autoconnect()

    private var playerItem : AVPlayerItem

    private var player : AVPlayer

    private var slideModel : SlideModel

    private var slideTitle : String

    //@State private var goToGallery : Bool = false

    init()

    {

        let slideDao = SlideDao.sharedInstance

        self.slideModel = slideDao.selectByUuid(uuid: appData.slideUuidActive)

        if self.slideModel.name.count > Constants.APP_BAR_TITLE_MAX_LENGTH {

            slideTitle = String(Array(self.slideModel.name)[0...Constants.APP_BAR_TITLE_MAX_LENGTH]) + "..."

        } else {

            slideTitle = self.slideModel.name

        }

        /*

        let sURL = "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"

        let videoUrl = URL(string: sURL)

*/

        let videoUrl = URL(string: slideModel.file)

        let headerSecurity = HeaderSecurity()

        let headers: [String: String] = [

            Constants.HTTP_HEADER_ACCEPT: Constants.HTTP_HEADER_ACCEPT_VALUE,

            Constants.HTTP_HEADER_SECURITY_RAND: String(headerSecurity.rand),

            Constants.HTTP_HEADER_SECURITY_TOKEN: appData.deviceUuid,

            Constants.HTTP_HEADER_SECURITY_CREATED: String(headerSecurity.created) ,

            Constants.HTTP_HEADER_SECURITY_SECRET: headerSecurity.secret,

        ]

        let assets = AVURLAsset(url: videoUrl!, options: ["AVURLAssetHTTPHeaderFieldsKey": headers])

        playerItem = AVPlayerItem(asset: assets)

        /*

        let assets = AVURLAsset(url: videoUrl!)

        playerItem = AVPlayerItem(asset: assets)

        */

        let newTime : CMTime = CMTimeMakeWithSeconds(0, preferredTimescale:1)

        player = AVPlayer(playerItem: playerItem)

        player.seek(to: newTime)

        self.timerActive = true

    }

    var body: some View {

        VStack(spacing: 0) {

            HStack {

                Button(action: {

                    let dataService = DataService()

                    if self.isCompleted {

                        dataService.completeSlide(slide: slideModel)

                    } else {

                        dataService.incompleteSlide(slide: slideModel)

                    }

                    if self.timerActive {

                        self.timer.upstream.connect().cancel()

                    }

                    AppDelegate.orientationLock = UIInterfaceOrientationMask.portrait

                    UIDevice.current.setValue(UIInterfaceOrientation.portrait.rawValue, forKey: "orientation")

                    UIViewController.attemptRotationToDeviceOrientation()

                    withAnimation {

                        appNavigation.subpageActive = .gallery

                    }

                }, label: {

                    Image(systemName: "chevron.backward")

                    .frame(width: 32, height: 32, alignment: /*@START_MENU_TOKEN@*/.center/*@END_MENU_TOKEN@*/)

                    .aspectRatio(contentMode: .fit)

                    .foregroundColor(Color("color_app_bar_foreground"))

                })

                .padding(.leading, 16)

                Text(self.slideTitle)

                .font(Font.custom(Config.FONT_NAME_REGULAR, size: Config.FONT_SIZE_APP_BAR_HEAD1 ))

                .foregroundColor(Color("color_app_bar_foreground"))

                    .padding(.leading, 4)

                Spacer()

            }

            .background(Color("color_app_bar_background"))

            .edgesIgnoringSafeArea(.top)

            .frame(height: 50)

            Divider()

            VideoPlayer(player: player)

                .onAppear() {

                    player.play()

                }

                .onDisappear() {

                    player.pause()

                }

                .onChange(of: player.currentTime(), perform: { value in

                    if let currentItem = player.currentItem {

                        let duration = currentItem.asset.duration

                            print("duration : \(duration)")

                            print("value : \(value)")

                        }

                    })

                    .onReceive(timer, perform: { _ in

                        print("onReceive")

                        let duration =  CMTimeGetSeconds(playerItem.asset.duration)

                        let currentTime =  CMTimeGetSeconds(playerItem.currentTime())

                        let diference = duration - currentTime

                        if diference < 10 {

                            self.isCompleted = true;

                            self.timer.upstream.connect().cancel()

                            timerActive = false

                        }

                    })

                    //.frame(width: geometry.size.width, height: geometry.size.height, alignment: /*@START_MENU_TOKEN@*/.center/*@END_MENU_TOKEN@*/)

        }

    }

}

struct VideoPlayerView_Previews: PreviewProvider {

    static var previews: some View {

        VideoPlayerView()

    }

}