Proyectos de Subversion Iphone Microlearning - Inconcert

//
//  VideoPlayerView.swift
//  twogetskills
//
//  Created by Efrain Yanez Recanatini on 4/24/22.
//
import Foundation
import SwiftUI
import AVKit
import Network
import Alamofire
import SwiftyJSON

struct VideoPlayerView: View {
    @EnvironmentObject private var appNavigation : AppNavigation
    @State private var timerActive : Bool = false
    @State private var isCompleted : Bool = false

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

    private var slideModel : SlideModel
    private var slideTitle : String
    
    
    private var url : URL?
    private var playerItem : AVPlayerItem
    private var player : AVPlayer
    private var appData = Environment(\.appData).wrappedValue

    init()
    {
        print("urlExternalDownloaded : \(appData.urlExternalDownloaded)")
        self.url = URL(string: appData.urlExternalDownloaded)
        
        let slideDao = SlideDao()
        self.slideModel = slideDao.selectByUuid(uuid: appData.slideUuidActive)

        print("videoplayer appData slideUuid : \(appData.slideUuidActive)")
        print("videoplayer slideModel slideUuid : \(self.slideModel.uuid)")
        
        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 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: self.url!, options: ["AVURLAssetHTTPHeaderFieldsKey": headers])
        
        playerItem = AVPlayerItem(asset: assets)

        
        let newTime : CMTime = CMTimeMakeWithSeconds(0, preferredTimescale:1)
        
        player = AVPlayer(playerItem: playerItem)
        player.seek(to: newTime)

    }
    
 
    
    var body: some View {
        VStack(spacing: 0) {
            
            
            HStack {
                Button(action: {
                    
                    
                    
                    backToGallery()
                }, 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()
            

            GeometryReader { geometry in
                
                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
                                 
                        print("duration: \(duration) currentTime : \(currentTime) diference: \(diference) ")
                        
                            if diference < 10 {
                                self.isCompleted = true;
                            } else if diference <= 2 {
                               
                                self.timer.upstream.connect().cancel()
                                timerActive = false
                                backToGallery()
                            }
                        
                        
                        }
                    })
            }
        }.onReceive(NotificationCenter.default.publisher(for: NSNotification.Name.AVPlayerItemDidPlayToEndTime), perform: { data in
            
            self.isCompleted = true;
            self.timer.upstream.connect().cancel()
            timerActive = false
            
            backToGallery()
        })
    }
    
    private func backToGallery()
    {
        if self.url != nil {
            do {
                try FileManager.default.removeItem(at: self.url!)
                       print("Video temporal borrado")
             } catch {
                print(error)
            }
        }
        
        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()
        

        appNavigation.pageActive = .home
    }
}


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