Panoramica

Il Camo SDK di Reincubate offre la possibilità di inviare dati audiovisivi in tempo reale dalla tua applicazione a Camo Studio su macOS e Windows. Funziona tramite USB o in modalità wireless. La connessione USB è ottimizzata per bassa latenza e prestazioni, consumando il minor numero possibile di risorse nella tua app. La modalità wireless ti libera dai cavi.

Il Camo SDK è disponibile per partner commerciali e collaboratori. Per maggiori informazioni, contatta il nostro team all’indirizzo enterprise@reincubate.com.

Attualmente, l’SDK supporta solo applicazioni iOS in esecuzione su un dispositivo fisico iOS o iPadOS (esclusi simulatori e Mac Catalyst) con iOS 12 o versioni successive. Il Camo SDK non è compatibile con Objective-C di base, quindi se la tua app è principalmente in Objective-C potresti dover creare un wrapper.

Riferimento API

Se vuoi partire subito, puoi consultare il riferimento API completo, che documenta ogni simbolo fornito dal Camo SDK. In alternativa, questo documento ti guiderà attraverso un esempio di integrazione con l’SDK.

Installare il Camo SDK

Quando ricevi il Camo SDK, riceverai anche un file chiamato CamoProducerKit.xcframework. Questo framework autonomo contiene tutto il necessario senza dipendenze esterne, quindi l’installazione è semplice.

1. Seleziona il progetto della tua applicazione nel Project Navigator.
2. Scegli il target della tua applicazione dalla barra laterale dei target del progetto. Se non vedi una barra laterale, potrebbe trovarsi in un menu a discesa nella parte superiore della pagina.
3. Assicurati di essere nella scheda «General» e scorri fino all’intestazione «Frameworks, Libraries, and Embedded Content».
4. Trascina il file CamoProducerKit.xcframework e rilascialo nell’elenco dei file sotto quell’intestazione.
5. Assicurati che l’SDK sia impostato su «Embed & Sign».

Una volta terminato, dovresti vedere il framework come mostrato in figura:

Integrazione con la tua app

Controllare il servizio Camo

Al centro di CamoProducerKit si trova CamoController, che fornisce alla tua app un’unica interfaccia centralizzata per controllare il Camo SDK.

Nella tua app, dovresti inizializzare un’istanza di CamoController. Puoi scegliere di farlo all’avvio dell’app oppure rimandarlo. Finché non viene avviato esplicitamente con start(), il controller Camo utilizzerà pochissime risorse. Tuttavia, si preparerà per la codifica audio e video al momento dell’inizializzazione.

import CamoProducerKit

class MyVideoManager {
    let controller = CamoController()

    // ...
}

Quando vuoi attivare l’integrazione Camo nella tua app, avviando il servizio Camo per facilitare le connessioni, puoi chiamare start(). Una volta terminato, puoi interromperlo chiamando stop().

controller.start()
// ...
controller.stop()

Questo codice è un buon inizio, ma non è ancora in grado di accettare nuove connessioni da Camo Studio.

Rispondere alle nuove connessioni

Prima che la tua app possa accettare nuove connessioni da Camo Studio, dovrai implementare CamoControllerDelegate. Implementando questi due metodi delegati, potrai essere avvisato dei cambiamenti nello stato della connessione e decidere se accettare o rifiutare una connessione.

extension MyVideoManager: CamoControllerDelegate {
    // Upon receiving a connection request, you can decide whether or not to accept it.
    func camoControllerShouldAcceptIncomingConnection(_ controller: CamoController) -> Bool {
        // You could return false if you aren't ready to accept connections, such as during onboarding.
        return true
    }

    // Called whenever the connection state changes, such as if the Camo service starts or stops, or if a new connection is made.
    func camoController(_ controller: CamoController, stateDidChangeTo state: CamoControllerState?) {
        // From here, you can update your UI and other state
        print("New state:", state)
    }
}

Fatto questo, dovresti ora essere in grado di aprire la tua app, collegarti tramite USB e visualizzare il tuo dispositivo in Camo Studio.

Connessioni wireless

Per usare le connessioni wireless, gli utenti dovranno concedere l’accesso alla rete locale. I servizi Bonjour devono essere aggiunti come NSBonjourServices in Info.plist:

• _camo._tcp
• _camopairing._tcp

Quando chiami camoController.start(), l’SDK è pronto per l’associazione e per stabilire connessioni di rete con Camo Studio.

Associazione

Quando un utente fa clic sul pulsante «+» in Camo Studio, inizia il processo di associazione. Camo Studio mostra un codice QR che deve essere scansionato dal lato dell’app.

Passaggi per l’associazione:

1. Fai clic su «+» in Camo Studio per mostrare il codice QR
2. Scansiona il codice QR e ottieni i suoi dati come stringa
3. Passa quei dati all’SDK chiamando camoController.pairStudioWithQRCodeData(codeData) { success in }
4. Il metodo pairStudioWithQRCodeData ha un callback che ti indicherà se l’associazione è riuscita
5. L’SDK eseguirà l’associazione con Camo Studio e la connessione verrà stabilita automaticamente.

Se devi annullare l’associazione (ad esempio se l’utente ha chiuso lo scanner QR o l’app), dovresti chiamare camoController.cancelPairing()

L’associazione ha un timeout di 30 secondi. Il callback per il metodo pairStudioWithQRCodeData verrà chiamato con il valore success false se l’associazione non avviene entro 30 secondi dalla chiamata di pairStudioWithQRCodeData.

Dispositivi associati

Una volta completata l’associazione, l’SDK salverà i dati di associazione nell’elenco dei dispositivi associati. CamoController dispone di 2 metodi per lavorare con questo elenco:

• pairedDevices per ottenere l’elenco (se desideri mostrarlo nell’interfaccia)
• removePairedDevice per dimenticare il dispositivo

Per stabilire una connessione wireless con Camo Studio la volta successiva, ti basta fare clic sul pulsante «+» in Camo Studio e attendere che la connessione venga stabilita: non serve scansionare di nuovo il codice QR.

Determinare lo stato della connessione

CamoController fornisce una proprietà CamoControllerState, inclusa anche nel metodo delegato del cambio di stato visto sopra. Questo enum fornisce informazioni utili per la tua app, come il nome del computer connesso da mostrare nell’interfaccia.

Ecco un esempio di come potresti aggiornare l’interfaccia per riflettere lo stato della connessione:

func camoController(_ controller: CamoController, stateDidChangeTo state: CamoControllerState?) {
    let statusText = { () -> String in
        guard case let .running(serviceState) = state else {
            return "Camo service not running"
        }
        switch serviceState {
        case .active(let connection): return "Connected to \(connection.name)"
        case .paused(let connection): return "Paused, but connected to \(connection.name)"
        case .notConnected: return "Camo service running, but no connection"
        }
    }()

    DispatchQueue.main.async {
        self.statusTextLabel.text = statusText
    }
}

Inviare dati audiovisivi

Per offrire ai client la massima flessibilità possibile, il Camo SDK non fornisce né controlla alcuna acquisizione. Sei invece tu responsabile di fornire a CamoController i dati audio e video. Questo può essere fatto con due semplici chiamate API:

// upon receiving video from the camera or elsewhere
camoController.enqueueVideo(sampleBuffer: sampleBuffer)

// upon receiving audio from the microphone or elsewhere
camoController.enqueuePCMAudio(data: chunk)

Inviare video

Se hai accesso a un CMSampleBuffer nella tua pipeline video, è banale passare questi dati al Camo SDK.

Per questo motivo, configurarlo con un’AVCaptureSession video di base è estremamente semplice. Ecco un esempio in azione.

class CaptureController: AVCaptureVideoDataOutputSampleBufferDelegate {
    // ...

    func startSession() throws {
        guard let camera = AVCaptureDevice.default(for: .video) else { fatalError("No camera found") }

        let input = try AVCaptureDeviceInput(device: camera)
        captureSession.addInput(input)

        let output = AVCaptureVideoDataOutput()
        output.alwaysDiscardsLateVideoFrames = true
        output.setSampleBufferDelegate(self, queue: videoDataOutputQueue)
        captureSession.addOutput(output)

        captureSession.startRunning()
    }

    // ...

    func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
        camoController.enqueueVideo(sampleBuffer: sampleBuffer)
    }
}

Quando invii i fotogrammi video, assicurati che:

• La durata del fotogramma sia di 30 FPS.
• Il formato pixel sia kCVPixelFormatType_32BGRA.

Puoi trovare maggiori dettagli nel riferimento API.

Inviare audio

Inviare audio è simile all’invio del video, ma potrebbe richiedere qualche passaggio in più a seconda di come la tua applicazione lo riceve. Per un esempio di implementazione, consulta l’app dimostrativa inclusa con il Camo SDK.

Quando invii dati audio, assicurati che:

• La frequenza di campionamento sia di 48 kHz.
• Il codec audio sia LPCM.
• Il numero di canali sia 2.
• La profondità di bit sia 32.
• Il numero di campioni per pacchetto audio dipende da Studio (macOS o Windows); puoi ottenerlo da CamoController.audioSamplesRequired.

Puoi trovare maggiori dettagli nel riferimento API.