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()
    }
}