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
import NavigationStack

struct VideoPlayerView: View {
    @State private var timerActive : Bool = false
    @State private var isCompleted : Bool = false
    @State private var backToGallery : Bool = false
  
    private let timer = Timer.publish(every: 1, on: .main, in: .common).autoconnect()
    private let appDao = AppDao.sharedInstance
   
    private var playerItem : AVPlayerItem
    private var player : AVPlayer
    private var slideModel : SlideModel
    private var slideTitle : String

    init(slideUuid : String)
    {
        let appData = appDao.selectOne()
        let slideDao = SlideDao.sharedInstance
        self.slideModel = slideDao.selectByUuid(uuid: slideUuid)

        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 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 newTime : CMTime = CMTimeMakeWithSeconds(0, preferredTimescale:1)
        
        player = AVPlayer(playerItem: playerItem)
        player.seek(to: newTime)
      
      
        self.timerActive = true
        


    }
    
    var body: some View {
        VStack(spacing: 0) {
            PopView(
                destination: .root,
                isActive: self.$backToGallery,
                label: {
                    Text("")
                    
                }
            ).frame( height: 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()
                    

                    self.backToGallery.toggle()
                    
                    
               
                }, 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()
            }
            .onReceive(timer, perform: { _ in
                let duration =  CMTimeGetSeconds(playerItem.asset.duration)
                if duration > 0 {

                    let currentTime =  CMTimeGetSeconds(playerItem.currentTime())
                    let diference = duration - currentTime
                       
                    if diference < 10 {
                        self.isCompleted = true;
                        self.timer.upstream.connect().cancel()
                        timerActive = false
                    }
                }
            })
        }
    }
    
    

    
}


struct VideoPlayerView_Previews: PreviewProvider {
    static var previews: some View {
        VideoPlayerView(slideUuid: "")
    }
}