@rentlydev/rently-tuya 0.1.0

package/ios/dashboard/Playback.swift

@@ -0,0 +1,543 @@
+import SwiftUI
+import ThingSmartCameraBase
+import ThingSmartDeviceKit
+import Combine
+
+struct Playback: View {
+    
+    @ObservedObject var tuya = Tuya.shared
+    @State var selectedDate: Date = Date()
+    @Binding var isDatePickerVisible: Bool
+    
+    @State private var isSliderVisible: Bool = false
+    @State private var currentSliderValue: Double = 0
+    @State private var isEditingSlider: Bool = false
+    @State private var timer: Timer? = nil
+    @EnvironmentObject var orientationManager: OrientationManager
+    
+    @State private var lastMoveOutDate: Date? = {
+        let dateFormatter = ISO8601DateFormatter()
+        return Tuya.shared.lastMoveoutAt.flatMap { dateFormatter.date(from: $0) }
+    }()
+    
+    var body: some View {
+        VStack {
+            if !orientationManager.isLandscape {
+                VideoPlayerView(
+                    isSliderVisible: $isSliderVisible,
+                    currentSliderValue: $currentSliderValue,
+                    isEditingSlider: $isEditingSlider,
+                    showSlider: showSlider,
+                    removeSlider: removeSlider
+                )
+                
+                PlaybackList(
+                    currentSliderValue: $currentSliderValue,
+                    showSlider: showSlider
+                )
+                
+                PlaybackBottomBar(
+                    currentSliderValue: $currentSliderValue
+                )
+                    .alert(
+                        isPresented: $tuya.isScreenshotSuccess,
+                        content: {
+                            getSuccessAlert(
+                                title: "A screenshot has been saved to your photo gallery."
+                            )
+                        })
+            } else {
+                VideoPlayerView(
+                    isSliderVisible: $isSliderVisible,
+                    currentSliderValue: $currentSliderValue,
+                    isEditingSlider: $isEditingSlider,
+                    showSlider: showSlider,
+                    removeSlider: removeSlider
+                )
+                .edgesIgnoringSafeArea(/*@START_MENU_TOKEN@*/.all/*@END_MENU_TOKEN@*/)
+            }
+        }
+        .onChange(of: orientationManager.isLandscape) { _ in
+            if orientationManager.isLandscape && isDatePickerVisible {
+                isDatePickerVisible = false
+            }
+        }
+        .onAppear {
+            print("Tuya: Harish \(String(describing: lastMoveOutDate))")
+            showSlider()
+            let calendar = Calendar.current
+            let year = calendar.component(.year, from: selectedDate)
+            let month = calendar.component(.month, from: selectedDate)
+            tuya.getAvailableDays(year: UInt(year), month: UInt(month))
+            
+            tuya.enableMute(enable: true, type: .preview)
+            if tuya.isPreviewing {
+                tuya.stopPreview()
+            }
+            fetchVideos()
+            tuya.enableMute(enable: false, type: .playback)
+            setupTimer()
+        }
+        .onDisappear {
+            timer?.invalidate()
+            tuya.playbackVideoList = nil
+            isDatePickerVisible = false
+        }
+            
+        if tuya.playbackLoader {
+            ProgressView()
+                .progressViewStyle(CircularProgressViewStyle(tint: LocalColor.Monochrome.black))
+        }
+                
+        CustomDatePicker(
+            isVisible: $isDatePickerVisible,
+            selectedDate: $selectedDate,
+            availableDays: tuya.recordDays ?? [],
+            minDate: lastMoveOutDate
+        ) { date in
+            } onMonthChanged: { date in
+                tuya.getAvailableDays(
+                    year: UInt(Calendar.current.component(.year, from: date)),
+                    month: UInt(Calendar.current.component(.month, from: date))
+                )
+            } onCancel: {
+                isDatePickerVisible = false
+            } onOk: {
+                isDatePickerVisible = false
+                currentSliderValue = 0
+                fetchVideos()
+            } onAppear: {
+                tuya.getAvailableDays(
+                    year: UInt(Calendar.current.component(.year, from: selectedDate)),
+                    month: UInt(Calendar.current.component(.month, from: selectedDate))
+                )
+            }
+        }
+    
+    private func setupTimer() {
+        timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { _ in
+            updateCurrentSliderValue()
+        }
+    }
+    
+    private func updateCurrentSliderValue() {
+        guard let selectedItem = tuya.selectedItem,
+              let startTime = selectedItem["startTime"] as? Int,
+              let endTime = selectedItem["endTime"] as? Int else { return }
+        
+        if tuya.isPlaybacking && !tuya.isPaused && !tuya.playbackLoader && !isEditingSlider {
+            if currentSliderValue < Double(endTime - startTime) {
+                currentSliderValue += 1
+            } else {
+                tuya.pausePlayback()
+            }
+        }
+    }
+    
+    private func fetchVideos() {
+        guard Tuya.shared.isConnected else {
+            tuya.isPlaybacking = false
+            print("Tuya: Camera is not connected, hence unable to get the video list and start the playback")
+            return
+        }
+        
+        let calendar = Calendar.current
+        let year = calendar.component(.year, from: selectedDate)
+        let month = calendar.component(.month, from: selectedDate)
+        let day = calendar.component(.day, from: selectedDate)
+                
+        Tuya.shared.getVideoList(year: UInt(year), month: UInt(month), day: UInt(day))
+    }
+    
+    private func showSlider() {
+        withAnimation(.easeInOut(duration: 0.3)) {
+            isSliderVisible = true
+        }
+        
+        removeSlider()
+    }
+    
+    private func removeSlider() {
+        DispatchQueue.main.asyncAfter(deadline: .now() + 8) {
+            if !isEditingSlider {
+                withAnimation(.easeInOut(duration: 0.3)) {
+                    isSliderVisible = false
+                }
+            }
+        }
+    }
+}
+
+struct VideoPlayerView: View {
+    
+    @ObservedObject var tuya = Tuya.shared
+    @Binding var isSliderVisible: Bool
+    @Binding var currentSliderValue: Double
+    @Binding var isEditingSlider: Bool
+    var showSlider: () -> Void
+    var removeSlider: () -> Void
+    @EnvironmentObject var orientationManager: OrientationManager
+    
+    var body: some View {
+        ZStack {
+            if tuya.isPlaybacking {
+                if tuya.selectedItem == nil {
+                    Rectangle()
+                        .fill(LocalColor.Monochrome.black)
+                        .frame(maxWidth: .infinity, maxHeight: .infinity)
+                } else {
+                    PreviewView()
+                    
+                    if isSliderVisible {
+                        SliderView(
+                            currentSliderValue: $currentSliderValue,
+                            isEditingSlider: $isEditingSlider,
+                            removeSlider: removeSlider
+                        )
+                    }
+                }
+            } else {
+                Rectangle()
+                    .fill(LocalColor.Monochrome.black)
+                    .frame(maxWidth: .infinity, maxHeight: .infinity)
+            }
+        }
+        .onTapGesture {
+            showSlider()
+        }
+        .frame(
+            maxWidth: .infinity,
+            maxHeight: orientationManager.isLandscape ? .infinity : 250
+        )
+        .edgesIgnoringSafeArea(/*@START_MENU_TOKEN@*/.all/*@END_MENU_TOKEN@*/)
+        .alert(
+            isPresented: $tuya.isRecordingFailure,
+            content: {
+                getSuccessAlert(
+                    title: "Failed to save the recording to your photo gallery."
+                )
+            })
+    }
+}
+
+struct SliderView: View {
+    
+    @ObservedObject var tuya = Tuya.shared
+    @Binding var currentSliderValue: Double
+    @Binding var isEditingSlider: Bool
+    var removeSlider: () -> Void
+    
+    var body: some View {
+        VStack {
+            Spacer()
+            
+            if let selectedItem = tuya.selectedItem,
+               let startTime = selectedItem["startTime"] as? Int,
+               let endTime = selectedItem["endTime"] as? Int {
+                
+                let duration = calculateVideoDuration(from: startTime, to: endTime)
+                
+                HStack {
+                    Label(
+                        title: "\(formatTime(from: currentSliderValue)) / \(duration)",
+                        m: true,
+                        white: true,
+                        left: true
+                    )
+                    
+                    Spacer()
+                }
+                .padding(.leading, 4)
+                
+                Slider(
+                    value: $currentSliderValue,
+                    in: 0...Double(endTime - startTime),
+                    onEditingChanged: { editing in
+                        isEditingSlider = editing
+                        if !editing {
+                            let playTime = startTime + Int(currentSliderValue)
+                            startPlayback(playTime: playTime, startTime: startTime, endTime: endTime)
+                            
+                            removeSlider()
+                        }
+                    }
+                )
+                .accentColor(LocalColor.Primary.medium)
+            }
+        }
+        .padding()
+        .background(Color.black.opacity(0.4))
+        .frame(maxWidth: .infinity)
+    }
+    
+    private func formatTime(from seconds: Double) -> String {
+        let hours = Int(seconds) / 3600
+        let minutes = (Int(seconds) % 3600) / 60
+        let secs = Int(seconds) % 60
+        return String(format: "%02d:%02d:%02d", hours, minutes, secs)
+    }
+}
+
+struct PlaybackList: View {
+    
+    @ObservedObject var tuya = Tuya.shared
+    @Binding var currentSliderValue: Double
+    var showSlider: () -> Void
+    
+    var body: some View {
+        VStack {
+            if tuya.playbackVideoList == nil || tuya.playbackVideoList?.isEmpty == true {
+                VStack {
+                    Spacer()
+                    Label(
+                        id: "noPlaybackVideos",
+                        title: "No Playback videos available at the moment.",
+                        xl18: true,
+                        black: true,
+                        semiBold: true,
+                        center: true
+                    )
+                    .padding(.horizontal, 30)
+                    Spacer()
+                }
+            } else {
+                ScrollView {
+                    if let playbackList = tuya.playbackVideoList, !playbackList.isEmpty {
+                        ForEach(0..<playbackList.count, id: \.self) { index in
+                            VideoItem(
+                                item: playbackList[index],
+                                currentSliderValue: $currentSliderValue,
+                                showSlider: showSlider
+                            )
+                        }
+                    }
+                }
+                .background(LocalColor.Main.light)
+            }
+        }
+        .frame(maxWidth: .infinity)
+        .background(LocalColor.Main.light)
+        .alert(
+            isPresented: $tuya.isRecordingSuccess,
+            content: {
+                getSuccessAlert(
+                    title: "A recording has been saved to your photo gallery."
+                )
+            })
+    }
+}
+
+struct VideoItem: View {
+    
+    @ObservedObject var tuya = Tuya.shared
+    var item: [AnyHashable: Any]
+    @Binding var currentSliderValue: Double
+    var showSlider: () -> Void
+    
+    var body: some View {
+        let isSelected = (tuya.selectedItem?["startTime"] as? Int) == (item["startTime"] as? Int)
+        
+        HStack {
+            VStack(alignment: .leading, spacing: 5) {
+                Label(
+                    title: "\(convertTimestampToTime(item["startTime"] as? Int))",
+                    l: true,
+                    primary: true,
+                    bold: true,
+                    left: true
+                )
+                
+                Label(
+                    title: ("Duration: \(calculateVideoDuration(from: item["startTime"] as? Int, to: item["endTime"] as? Int))"),
+                    m: true,
+                    secondary: true,
+                    left: true
+                )
+                .padding(.top, 5)
+            }
+            .padding(15)
+            
+            Spacer()
+        }
+        .frame(maxWidth: /*@START_MENU_TOKEN@*/.infinity/*@END_MENU_TOKEN@*/)
+        .background(isSelected ? LocalColor.Secondary.light : LocalColor.Monochrome.white)
+        .cornerRadius(5)
+        .padding(.top, 8)
+        .padding(.horizontal, 10)
+        .onTapGesture {
+            tuya.selectedItem = item
+            currentSliderValue = 0
+            startPlayback(
+                playTime: item["startTime"] as? Int,
+                startTime: item["startTime"] as? Int,
+                endTime: item["endTime"] as? Int
+            )
+            showSlider()
+        }
+    }
+    
+    private func convertTimestampToTime(_ timestamp: Int?) -> String {
+        guard let timestamp = timestamp else { return "Invalid Time" }
+        let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
+        let formatter = DateFormatter()
+        formatter.dateFormat = "hh:mm a"
+        return formatter.string(from: date)
+    }
+}
+
+private func startPlayback(playTime: Int?, startTime: Int?, endTime: Int?) {
+    
+    guard let startTime = startTime, let endTime = endTime, let playTime = playTime else {
+        print("Tuya: Invalid start/end/play time")
+        return
+    }
+    
+    if Tuya.shared.isConnected {
+        Tuya.shared.startPlayback(
+            playTime: playTime,
+            startTime: startTime,
+            stopTime: endTime
+        )
+    } else {
+        Tuya.shared.isPlaybacking = false
+        print("Tuya: Camera is disconnected, hence unable to start the video")
+    }
+}
+
+func calculateVideoDuration(from startTime: Int?, to endTime: Int?) -> String {
+    guard let startTime = startTime, let endTime = endTime else { return "Invalid Duration" }
+    let durationInSeconds = TimeInterval(endTime - startTime)
+    let hours = Int(durationInSeconds) / 3600
+    let minutes = (Int(durationInSeconds) % 3600) / 60
+    let seconds = Int(durationInSeconds) % 60
+    
+    return String(format: "%02d:%02d:%02d", hours, minutes, seconds)
+}
+
+struct PlaybackBottomBar: View {
+
+    @ObservedObject var tuya = Tuya.shared
+    @Binding var currentSliderValue: Double
+
+    var body: some View {
+        HStack {
+            Spacer()
+            
+            IconButton(
+                imageName: tuya.isPlaybackMuted ? "keyless_sound_off" : "keyless_sound_on",
+                event: tuya.isPlaybackMuted ? "Playback Speaker On" : "Playback Speaker Off",
+                size: tuya.isPlaybackMuted ? 28 : 40,
+                action: {
+                    guard tuya.isConnected else {
+                        print("Tuya: Camera not connected. Speaker action disabled.")
+                        return
+                    }
+                    
+                    guard tuya.isPlaybacking else {
+                        print("Tuya: Playback not started. Speaker action disabled.")
+                        return
+                    }
+                    
+                    if (tuya.isPlaybackMuted) {
+                        tuya.enableMute(enable: false, type: .playback)
+                    } else {
+                        tuya.enableMute(enable: true, type: .playback)
+                    }
+                }
+            )
+            
+            Spacer()
+            
+            IconButton(
+                imageName: tuya.isRecording ? "keyless_record_on" : "keyless_record",
+                event: tuya.isRecording ? "Playback Recording Off" : "Playback Recording On",
+                size: tuya.isRecording ? 40 : 28,
+                action: {
+                    guard tuya.isConnected else {
+                        print("Tuya: Camera not connected. Start/Stop recording action disabled.")
+                        return
+                    }
+                    
+                    guard tuya.isPlaybacking else {
+                        print("Tuya: Playback not started. Start/Stop recording action disabled.")
+                        return
+                    }
+                    
+                    tuya.isRecording ? tuya.stopRecording() : tuya.startRecording()
+                }
+            )
+            
+            Spacer()
+            
+            IconButton(
+                imageName: tuya.isPaused ? "keyless_play_playback" : "keyless_pause",
+                event: tuya.isPaused ? "Resume Playback" : "Pause Playback",
+                size: 45,
+                action: {
+                    guard tuya.isConnected else {
+                        print("Tuya: Camera not connected. Resume/Pause action disabled.")
+                        return
+                    }
+                    
+                    guard tuya.isPlaybacking else {
+                        print("Tuya: Playback is not started. Resume/Pause action disabled.")
+                        return
+                    }
+                    
+                    if tuya.isPaused {
+                        guard let selectedItem = tuya.selectedItem,
+                              let startTime = selectedItem["startTime"] as? Int,
+                              let endTime = selectedItem["endTime"] as? Int else { return }
+                        
+                        let videoDuration = Double(endTime - startTime)
+                        
+                        if currentSliderValue >= videoDuration {
+                            // If playback is completed then Restart from the beginning
+                            currentSliderValue = 0
+                            tuya.startPlayback(
+                                playTime: startTime,
+                                startTime: startTime,
+                                stopTime: endTime
+                            )
+                        } else {
+                            tuya.resumePlayback()
+                        }
+                        
+                    } else {
+                        tuya.pausePlayback()
+                    }
+                }
+            )
+            
+            Spacer()
+            
+            IconButton(
+                imageName: "keyless_photo",
+                event: "Playback Screenshot",
+                size: 28,
+                action: {
+                    guard tuya.isConnected else {
+                        print("Tuya: Camera not connected. Screenshot action disabled.")
+                        return
+                    }
+                    
+                    guard tuya.isPlaybacking else {
+                        print("Tuya: Playback is not started. Screenshot action disabled.")
+                        return
+                    }
+                    
+                    tuya.screenshot()
+                }
+            )
+            
+            Spacer()
+        }
+       .padding(.top)
+       .padding(.horizontal)
+       .frame(height: 70)
+       .padding(.bottom, 15)
+       .background(LocalColor.Monochrome.grey)
+       .edgesIgnoringSafeArea(.horizontal)
+    }
+}
+

package/ios/dashboard/PreviewManager.swift

@@ -0,0 +1,117 @@
+import SwiftUI
+import ThingSmartCameraBase
+
+struct PreviewView: UIViewRepresentable {
+
+    class Coordinator: NSObject, UIScrollViewDelegate {
+        var scrollView: UIScrollView?
+
+        override init() {
+            super.init()
+
+            UIDevice.current.beginGeneratingDeviceOrientationNotifications()
+            NotificationCenter.default.addObserver(self, selector: #selector(orientationChanged), name: UIDevice.orientationDidChangeNotification, object: nil)
+            NotificationCenter.default.addObserver(self, selector: #selector(orientationChanged), name: OrientationManager.orientationDidChangeNotification, object: nil)
+        }
+
+        deinit {
+            UIDevice.current.endGeneratingDeviceOrientationNotifications()
+            NotificationCenter.default.removeObserver(self, name: UIDevice.orientationDidChangeNotification, object: nil)
+            NotificationCenter.default.removeObserver(self, name: OrientationManager.orientationDidChangeNotification, object: nil)
+        }
+
+        func viewForZooming(in scrollView: UIScrollView) -> UIView? {
+            return scrollView.subviews.first
+        }
+
+        func scrollViewDidZoom(_ scrollView: UIScrollView) {
+            guard let zoomView = scrollView.subviews.first else { return }
+
+            let offsetX = max((scrollView.bounds.size.width - zoomView.frame.size.width) * 0.5, 0)
+            let offsetY = max((scrollView.bounds.size.height - zoomView.frame.size.height) * 0.5, 0)
+
+            zoomView.center = CGPoint(x: scrollView.contentSize.width * 0.5 + offsetX,
+                                      y: scrollView.contentSize.height * 0.5 + offsetY)
+        }
+
+        func resetZoom() {
+            guard let scrollView = scrollView else { return }
+            scrollView.setZoomScale(1.0, animated: true)
+            scrollView.setContentOffset(CGPoint.zero, animated: true)
+        }
+
+        @objc func orientationChanged() {
+            resetZoom()
+        }
+    }
+
+    func makeUIView(context: Context) -> UIView {
+        let containerView = UIView()
+        let scrollView = UIScrollView()
+        scrollView.translatesAutoresizingMaskIntoConstraints = false
+        scrollView.minimumZoomScale = 1.0
+        scrollView.maximumZoomScale = 4.0
+        scrollView.delegate = context.coordinator
+        scrollView.bounces = false
+        scrollView.showsVerticalScrollIndicator = false
+        scrollView.showsHorizontalScrollIndicator = false
+        scrollView.clipsToBounds = true
+
+        containerView.addSubview(scrollView)
+
+       
+        NSLayoutConstraint.activate([
+            scrollView.leadingAnchor.constraint(equalTo: containerView.leadingAnchor),
+            scrollView.trailingAnchor.constraint(equalTo: containerView.trailingAnchor),
+            scrollView.topAnchor.constraint(equalTo: containerView.topAnchor),
+            scrollView.bottomAnchor.constraint(equalTo: containerView.bottomAnchor)
+        ])
+
+        if let videoView = Tuya.shared.cameraType?.videoView() {
+            videoView.contentMode = .scaleAspectFit
+            scrollView.addSubview(videoView)
+            videoView.translatesAutoresizingMaskIntoConstraints = false
+
+            NSLayoutConstraint.activate([
+                videoView.centerXAnchor.constraint(equalTo: scrollView.centerXAnchor),
+                videoView.centerYAnchor.constraint(equalTo: scrollView.centerYAnchor),
+                videoView.widthAnchor.constraint(equalTo: scrollView.widthAnchor, multiplier: 1.0),
+                videoView.heightAnchor.constraint(equalTo: scrollView.heightAnchor, multiplier: 1.0)
+            ])
+        } else {
+            print("Tuya: Video view is nil")
+        }
+
+        context.coordinator.scrollView = scrollView
+        context.coordinator.resetZoom()
+        return containerView
+    }
+
+    func updateUIView(_ uiView: UIView, context: Context) {
+        guard let scrollView = context.coordinator.scrollView else { return }
+        if let videoView = Tuya.shared.cameraType?.videoView() {
+            videoView.setNeedsDisplay()
+            context.coordinator.resetZoom()
+        } else {
+            print("Tuya: Video view is nil in updateUIView")
+        }
+    }
+
+    func makeCoordinator() -> Coordinator {
+        Coordinator()
+    }
+}
+
+func openLivePreview(appFlavor: String) {
+    
+    DispatchQueue.main.async {
+        Themes.configureTheme(for: appFlavor)
+        let orientationManager = OrientationManager()
+        let dashboardView = NavigationController().environmentObject(orientationManager)
+        let hostingController = UIHostingController(rootView: dashboardView)
+        hostingController.modalPresentationStyle = .fullScreen
+        if let rootVC = UIApplication.shared.windows.first?.rootViewController {
+            rootVC.present(hostingController, animated: true, completion: nil)
+        }
+    }
+}