audio preview support, camera capture, minor tweaks

Author: raluaces

Django Files/Views/AlbumList.swift

@@ -106,7 +106,6 @@ struct AlbumListView: View {
                             await refreshAlbumsAsync()
                         }
                     }
-                    .listStyle(.plain)
                     .navigationTitle(server.wrappedValue != nil ? "Albums (\(URL(string: server.wrappedValue!.url)?.host ?? "unknown"))" : "Albums")
                     .toolbar {
                         ToolbarItem(placement: .navigationBarTrailing) {

Django Files/Views/FileUploadView.swift

@@ -8,6 +8,7 @@
 import SwiftUI
 import PhotosUI
 import UniformTypeIdentifiers
+import AVFoundation
 
 struct FileUploadView: View {
     let server: DjangoFilesSession
@@ -17,14 +18,48 @@ struct FileUploadView: View {
     @State private var isUploading: Bool = false
     @State private var uploadProgress: Double = 0.0
     @State private var showingFilePicker: Bool = false
+    @State private var showingCamera: Bool = false
+    @State private var capturedImage: UIImage?
 
     @State private var uploadPrivate: Bool = false
 
+    // Audio recording states
+    @State private var audioRecorder: AVAudioRecorder?
+    @State private var isRecording: Bool = false
+    @State private var recordingURL: URL?
+    
     var body: some View {
         NavigationView {
             VStack(spacing: 20) {
                 Toggle("Make Private", isOn: $uploadPrivate)
 
+                // Audio Recording Button
+                Button(action: {
+                    if isRecording {
+                        stopRecording()
+                    } else {
+                        startRecording()
+                    }
+                }) {
+                    Label(isRecording ? "Stop Recording" : "Record Audio", systemImage: isRecording ? "stop.circle.fill" : "mic.circle.fill")
+                        .frame(maxWidth: .infinity)
+                        .padding()
+                        .background(isRecording ? Color.red : Color.accentColor)
+                        .foregroundColor(.white)
+                        .cornerRadius(10)
+                }
+
+                // Camera Button
+                Button(action: {
+                    showingCamera = true
+                }) {
+                    Label("Take Photo", systemImage: "camera")
+                        .frame(maxWidth: .infinity)
+                        .padding()
+                        .background(Color.accentColor)
+                        .foregroundColor(.white)
+                        .cornerRadius(10)
+                }
 
                 // Photo Picker
                 PhotosPicker(
@@ -67,6 +102,17 @@ struct FileUploadView: View {
                     }
                 }
             }
+            .sheet(isPresented: $showingCamera) {
+                ImagePicker(image: $capturedImage)
+                    .ignoresSafeArea()
+            }
+            .onChange(of: capturedImage) { _, newImage in
+                if let image = newImage {
+                    Task {
+                        await uploadCapturedImage(image)
+                    }
+                }
+            }
             .fileImporter(
                 isPresented: $showingFilePicker,
                 allowedContentTypes: [.item],
@@ -90,6 +136,26 @@ struct FileUploadView: View {
         }
     }
 
+    private func uploadCapturedImage(_ image: UIImage) async {
+        isUploading = true
+        uploadProgress = 0.0
+        
+        if let imageData = image.jpegData(compressionQuality: 0.8),
+           let tempURL = saveTemporaryFile(data: imageData, filename: "ios_photo.jpg") {
+            let api = DFAPI(url: URL(string: server.url)!, token: server.token)
+            let delegate = UploadProgressDelegate { progress in
+                uploadProgress = progress
+            }
+            
+            _ = await api.uploadFile(url: tempURL, privateUpload: uploadPrivate, taskDelegate: delegate)
+            try? FileManager.default.removeItem(at: tempURL)
+        }
+        
+        isUploading = false
+        capturedImage = nil
+        dismiss()
+    }
+    
     private func uploadPhotos(_ items: [PhotosPickerItem]) async {
         isUploading = true
         uploadProgress = 0.0
@@ -143,6 +209,60 @@ struct FileUploadView: View {
             return nil
         }
     }
+    
+    private func startRecording() {
+        let audioSession = AVAudioSession.sharedInstance()
+        
+        do {
+            try audioSession.setCategory(.playAndRecord, mode: .default)
+            try audioSession.setActive(true)
+            
+            let documentsPath = FileManager.default.temporaryDirectory
+            let audioFilename = documentsPath.appendingPathComponent("recording.m4a")
+            recordingURL = audioFilename
+            
+            let settings = [
+                AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
+                AVSampleRateKey: 44100,
+                AVNumberOfChannelsKey: 2,
+                AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue
+            ]
+            
+            audioRecorder = try AVAudioRecorder(url: audioFilename, settings: settings)
+            audioRecorder?.record()
+            isRecording = true
+        } catch {
+            print("Recording failed: \(error)")
+        }
+    }
+    
+    private func stopRecording() {
+        audioRecorder?.stop()
+        isRecording = false
+        
+        if let url = recordingURL {
+            Task {
+                await uploadAudioRecording(url)
+            }
+        }
+    }
+    
+    private func uploadAudioRecording(_ url: URL) async {
+        isUploading = true
+        uploadProgress = 0.0
+        
+        let api = DFAPI(url: URL(string: server.url)!, token: server.token)
+        let delegate = UploadProgressDelegate { progress in
+            uploadProgress = progress
+        }
+        
+        _ = await api.uploadFile(url: url, privateUpload: uploadPrivate, taskDelegate: delegate)
+        try? FileManager.default.removeItem(at: url)
+        
+        isUploading = false
+        recordingURL = nil
+        dismiss()
+    }
 }
 
 class UploadProgressDelegate: NSObject, URLSessionTaskDelegate {

Django Files/Views/ImagePicker.swift

@@ -0,0 +1,39 @@
+import SwiftUI
+import UIKit
+
+struct ImagePicker: UIViewControllerRepresentable {
+    @Binding var image: UIImage?
+    @Environment(\.dismiss) private var dismiss
+    
+    func makeUIViewController(context: Context) -> UIImagePickerController {
+        let picker = UIImagePickerController()
+        picker.delegate = context.coordinator
+        picker.sourceType = .camera
+        return picker
+    }
+    
+    func updateUIViewController(_ uiViewController: UIImagePickerController, context: Context) {}
+    
+    func makeCoordinator() -> Coordinator {
+        Coordinator(self)
+    }
+    
+    class Coordinator: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
+        let parent: ImagePicker
+        
+        init(_ parent: ImagePicker) {
+            self.parent = parent
+        }
+        
+        func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
+            if let image = info[.originalImage] as? UIImage {
+                parent.image = image
+            }
+            parent.dismiss()
+        }
+        
+        func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
+            parent.dismiss()
+        }
+    }
+} 

Django Files/Views/Preview.swift

@@ -50,17 +50,16 @@ struct ContentPreview: View {
                 imagePreview
             } else if mimeType.starts(with: "video/") {
                 videoPreview
+            } else if mimeType.starts(with: "audio/") {
+                audioPreview
             } else {
                 genericFilePreview
             }
         }
         .sheet(isPresented: showFileInfo, onDismiss: { showFileInfo.wrappedValue = false }) {
             PreviewFileInfo(file: file)
                 .presentationBackground(.ultraThinMaterial)
-
         }
-
-        
     }
 
     // Text Preview
@@ -94,6 +93,12 @@ struct ContentPreview: View {
             .aspectRatio(contentMode: .fit)
     }
 
+    // Audio Preview
+    private var audioPreview: some View {
+        AudioPlayerView(url: fileURL)
+            .padding()
+    }
+    
     // Generic File Preview
     private var genericFilePreview: some View {
         VStack {
@@ -114,8 +119,8 @@ struct ContentPreview: View {
     private func loadContent() {
         isLoading = true
 
-        // For video, we don't need to download the content as we'll use the URL directly
-        if mimeType.starts(with: "video/") {
+        // For video, audio, and audio, we don't need to download the content as we'll use the URL directly
+        if mimeType.starts(with: "video/") || mimeType.starts(with: "audio/") {
             isLoading = false
             return
         }
@@ -303,3 +308,136 @@ class CustomScrollView: UIScrollView {
         }
     }
 }
+
+// Custom Audio Player View
+struct AudioPlayerView: View {
+    let url: URL
+    @StateObject private var playerViewModel = AudioPlayerViewModel()
+    
+    var body: some View {
+        VStack(spacing: 20) {
+            Image(systemName: "waveform")
+                .font(.system(size: 50))
+                .foregroundColor(.gray)
+                .padding(.bottom)
+            
+            // Time and Progress
+            HStack {
+                Text(playerViewModel.currentTimeString)
+                    .font(.caption)
+                    .monospacedDigit()
+                
+                Slider(value: $playerViewModel.progress, in: 0...1) { editing in
+                    if !editing {
+                        playerViewModel.seek(to: playerViewModel.progress)
+                    }
+                }
+                
+                Text(playerViewModel.durationString)
+                    .font(.caption)
+                    .monospacedDigit()
+            }
+            .padding(.horizontal)
+            
+            // Playback Controls
+            HStack(spacing: 30) {
+                Button(action: { playerViewModel.skipBackward() }) {
+                    Image(systemName: "gobackward.15")
+                        .font(.title2)
+                }
+                
+                Button(action: { playerViewModel.togglePlayback() }) {
+                    Image(systemName: playerViewModel.isPlaying ? "pause.circle.fill" : "play.circle.fill")
+                        .font(.system(size: 44))
+                }
+                
+                Button(action: { playerViewModel.skipForward() }) {
+                    Image(systemName: "goforward.15")
+                        .font(.title2)
+                }
+            }
+        }
+        .onAppear {
+            playerViewModel.setupPlayer(with: url)
+        }
+        .onDisappear {
+            playerViewModel.cleanup()
+        }
+    }
+}
+
+// Audio Player View Model
+class AudioPlayerViewModel: ObservableObject {
+    private var player: AVPlayer?
+    private var timeObserver: Any?
+    
+    @Published var isPlaying = false
+    @Published var progress: Double = 0
+    @Published var currentTimeString = "00:00"
+    @Published var durationString = "00:00"
+    
+    func setupPlayer(with url: URL) {
+        player = AVPlayer(url: url)
+        
+        // Add periodic time observer
+        timeObserver = player?.addPeriodicTimeObserver(forInterval: CMTime(seconds: 0.5, preferredTimescale: 600), queue: .main) { [weak self] time in
+            guard let self = self,
+                  let duration = self.player?.currentItem?.duration.seconds,
+                  !duration.isNaN else { return }
+            
+            let currentTime = time.seconds
+            self.progress = currentTime / duration
+            self.currentTimeString = self.formatTime(currentTime)
+            self.durationString = self.formatTime(duration)
+        }
+        
+        // Update duration when item is ready
+        player?.currentItem?.asset.loadValuesAsynchronously(forKeys: ["duration"]) {
+            DispatchQueue.main.async {
+                if let duration = self.player?.currentItem?.duration.seconds,
+                   !duration.isNaN {
+                    self.durationString = self.formatTime(duration)
+                }
+            }
+        }
+    }
+    
+    func togglePlayback() {
+        if isPlaying {
+            player?.pause()
+        } else {
+            player?.play()
+        }
+        isPlaying.toggle()
+    }
+    
+    func seek(to progress: Double) {
+        guard let duration = player?.currentItem?.duration else { return }
+        let time = CMTime(seconds: progress * duration.seconds, preferredTimescale: 600)
+        player?.seek(to: time)
+    }
+    
+    func skipForward() {
+        guard let currentTime = player?.currentTime().seconds else { return }
+        seek(to: (currentTime + 15) / (player?.currentItem?.duration.seconds ?? currentTime + 15))
+    }
+    
+    func skipBackward() {
+        guard let currentTime = player?.currentTime().seconds else { return }
+        seek(to: (currentTime - 15) / (player?.currentItem?.duration.seconds ?? currentTime))
+    }
+    
+    func cleanup() {
+        if let timeObserver = timeObserver {
+            player?.removeTimeObserver(timeObserver)
+        }
+        player?.pause()
+        player = nil
+    }
+    
+    private func formatTime(_ timeInSeconds: Double) -> String {
+        let minutes = Int(timeInSeconds / 60)
+        let seconds = Int(timeInSeconds.truncatingRemainder(dividingBy: 60))
+        return String(format: "%02d:%02d", minutes, seconds)
+    }
+}