SegmentedRecorder

Gerencia a gravação de múltiplos segmentos de vídeo independentes, cada um em um arquivo temporário separado.

Arquivo: SegmentedRecorder.swift

📋 Visão Geral

O SegmentedRecorder permite:

Gravar múltiplos takes independentes
Armazenar cada segmento em arquivo .mov temporário
Notificar via delegate quando gravação termina
Gerenciar orientação dinâmica

🏗️ Protocol Delegate

protocol SegmentedRecorderDelegate: AnyObject {
    func recorder(_ recorder: SegmentedRecorder, didFinishSegment url: URL)
    func recorder(_ recorder: SegmentedRecorder, didFailWith error: Error)
}

Uso:

extension CameraViewModel: SegmentedRecorderDelegate {
    func recorder(_ recorder: SegmentedRecorder, didFinishSegment url: URL) {
        // Gerar thumbnail
        // Adicionar a segments array
    }
    
    func recorder(_ recorder: SegmentedRecorder, didFailWith error: Error) {
        // Mostrar erro
        // Resetar UI
    }
}

🔧 Métodos Principais

Inicialização

init(output: AVCaptureMovieFileOutput, delegate: SegmentedRecorderDelegate)

Parâmetros:

output: Referência ao AVCaptureMovieFileOutput da session
delegate: Objeto que receberá callbacks

Iniciar Segmento

func startNewSegment()

Comportamento:

Cria URL temporário: NSTemporaryDirectory() + "segment_\(UUID()).mov"
Define orientação via updateOrientation(from:)
Chama output.startRecording(to: url, recordingDelegate: self)

Exemplo:

// Usuário aperta botão de gravar
recorder.startNewSegment()

Parar Segmento

func stopCurrentSegment()

Comportamento:

Chama output.stopRecording()
AVFoundation chama delegate didFinishRecordingTo quando pronto
Delegate do SegmentedRecorder é notificado

Exemplo:

// Usuário aperta botão de parar
recorder.stopCurrentSegment()

Atualizar Orientação

func updateOrientation(from deviceOrientation: UIDeviceOrientation)

Descrição: Atualiza orientação para próximas gravações.

Uso: Chamado quando UIDevice.orientationDidChangeNotification dispara.

🎬 Fluxo de Gravação

┌─────────────────────────────────────────────────────────────┐
│                     User Action                             │
│              toggleRecording() pressed                       │
└────────────────────┬────────────────────────────────────────┘
                     │
         ┌───────────▼──────────┐
         │  isRecording == false │
         └───────────┬───────────┘
                     │
         ┌───────────▼──────────────────────────┐
         │  startNewSegment()                   │
         │  1. Create temp URL                  │
         │  2. Set video orientation            │
         │  3. output.startRecording(to:)       │
         └───────────┬──────────────────────────┘
                     │
         ┌───────────▼──────────────────────────┐
         │  Recording in progress...            │
         │  isRecording = true                  │
         └───────────┬──────────────────────────┘
                     │
         ┌───────────▼──────────┐
         │  User stops recording│
         └───────────┬───────────┘
                     │
         ┌───────────▼──────────────────────────┐
         │  stopCurrentSegment()                │
         │  output.stopRecording()              │
         └───────────┬──────────────────────────┘
                     │
         ┌───────────▼──────────────────────────────────┐
         │  AVCaptureFileOutputRecordingDelegate        │
         │  fileOutput(_:didFinishRecordingTo:...)      │
         └───────────┬──────────────────────────────────┘
                     │
         ┌───────────▼──────────────────────────┐
         │  delegate.recorder(didFinishSegment:)│
         │  CameraViewModel receives URL         │
         └──────────────────────────────────────┘

🔗 AVCaptureFileOutputRecordingDelegate

extension SegmentedRecorder: AVCaptureFileOutputRecordingDelegate {
    func fileOutput(
        _ output: AVCaptureFileOutput,
        didFinishRecordingTo outputFileURL: URL,
        from connections: [AVCaptureConnection],
        error: Error?
    ) {
        if let error = error {
            delegate?.recorder(self, didFailWith: error)
        } else {
            delegate?.recorder(self, didFinishSegment: outputFileURL)
        }
    }
}

📁 Gerenciamento de Arquivos

Criação de Arquivo Temporário

let tempDir = NSTemporaryDirectory()
let filename = "segment_\(UUID().uuidString).mov"
let url = URL(fileURLWithPath: tempDir).appendingPathComponent(filename)

Exemplo de path:

/var/mobile/Containers/Data/Application/.../tmp/segment_12345678-1234-1234-1234-123456789abc.mov

Cleanup

Arquivos temporários são removidos após concatenação:

// No CameraViewModel, após salvar vídeo final
for segment in segments {
    try? FileManager.default.removeItem(at: segment.url)
}
segments.removeAll()

🎯 Casos de Uso

Gravação Simples (1 Segmento)

// Iniciar
recorder.startNewSegment()

// ... usuário grava ...

// Parar
recorder.stopCurrentSegment()

// Delegate recebe
func recorder(_ recorder: SegmentedRecorder, didFinishSegment url: URL) {
    print("Segment saved at: \(url)")
}

Gravação Múltipla (3 Segmentos)

// Segmento 1
recorder.startNewSegment()
// ... grava ...
recorder.stopCurrentSegment()

// Segmento 2
recorder.startNewSegment()
// ... grava ...
recorder.stopCurrentSegment()

// Segmento 3
recorder.startNewSegment()
// ... grava ...
recorder.stopCurrentSegment()

// Todos os 3 URLs são recebidos via delegate
// CameraViewModel armazena em segments array

⚙️ Configuração

saveToPhotoLibrary

var saveToPhotoLibrary: Bool = false

Descrição: Se true, cada segmento é salvo individualmente na galeria.

Uso Típico: false (salvamos apenas o vídeo final concatenado).

🧵 Threading

Callbacks

Delegates são chamados na thread onde o output foi configurado (tipicamente main thread ou sessionQueue).

Best Practice: Sempre dispatch para main thread antes de atualizar UI:

func recorder(_ recorder: SegmentedRecorder, didFinishSegment url: URL) {
    DispatchQueue.global(qos: .userInitiated).async {
        let thumbnail = generateThumbnail(for: url)
        
        DispatchQueue.main.async {
            self.segments.append(RecordedSegment(url: url, thumbnail: thumbnail))
        }
    }
}

🐛 Troubleshooting

Segmento não grava

Sintomas: didFinishSegment nunca é chamado.

Causas:

Session não está rodando
Output não está conectado
Permissões de escrita

Solução:

// Verificar session
print("Session running: \(session.isRunning)")

// Verificar connections
print("Output connections: \(output.connections)")

// Verificar permissões
let tempURL = URL(fileURLWithPath: NSTemporaryDirectory())
print("Can write to temp: \(FileManager.default.isWritableFile(atPath: tempURL.path))")

Erro “Recording already in progress”

Sintomas: Crash ao chamar startNewSegment() duas vezes.

Solução:

guard !output.isRecording else {
    print("Already recording")
    return
}
output.startRecording(to: url, recordingDelegate: self)

📚 Ver Também

CameraViewModel - Coordenação e concatenação
Guia de Gravação - Tutorial completo
Fluxo de Dados - Como os dados fluem

← CaptureSessionController

Teleprompter →