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

    }

}