Übersicht

Das Camo SDK von Reincubate ermöglicht es, audiovisuelle Daten in Echtzeit von deiner Anwendung an Camo Studio auf macOS und Windows zu senden. Es funktioniert über USB oder kabellos. USB ist auf niedrige Latenz und Leistung optimiert und verbraucht dabei so wenig Ressourcen wie möglich in deiner App. Kabellos verschafft dir Freiheit von Kabeln.

Das Camo SDK steht kommerziellen Partnern und Mitarbeitern zur Nutzung zur Verfügung. Für weitere Informationen wende dich an unser Team unter enterprise@reincubate.com.

Derzeit unterstützt das SDK nur iOS-Anwendungen, die auf einem physischen iOS- oder iPadOS-Gerät (ohne Simulatoren und Mac Catalyst) unter iOS 12 oder höher laufen. Das Camo SDK bietet von Haus aus keine Objective-C-Kompatibilität. Wenn deine App hauptsächlich in Objective-C geschrieben ist, musst du möglicherweise einen Wrapper erstellen.

API-Referenz

Wenn du direkt loslegen möchtest, kannst du die vollständige API-Referenz einsehen, die jedes vom Camo SDK bereitgestellte Symbol dokumentiert. Andernfalls führt dich dieses Dokument durch eine Beispielintegration mit dem SDK.

Das Camo SDK installieren

Wenn du das Camo SDK erhältst, bekommst du auch eine Datei namens CamoProducerKit.xcframework. Dieses eigenständige Framework enthält alles, was du brauchst, ohne externe Abhängigkeiten – die Installation ist daher einfach.

1. Wähle das Projekt deiner Anwendung im Project Navigator aus.
2. Wähle das Target deiner Anwendung in der Target-Seitenleiste des Projekts aus. Wenn du keine Seitenleiste siehst, befindet sie sich möglicherweise in einem Dropdown-Menü oben auf der Seite.
3. Stelle sicher, dass du dich im Tab „General“ befindest, und scrolle nach unten zum Abschnitt „Frameworks, Libraries, and Embedded Content“.
4. Ziehe die CamoProducerKit.xcframework-Datei und lege sie in der Dateiliste unter diesem Abschnitt ab.
5. Stelle sicher, dass das SDK auf „Embed & Sign“ eingestellt ist.

Wenn du fertig bist, solltest du das Framework wie abgebildet sehen:

Integration in deine App

Den Camo-Dienst steuern

Im Zentrum von CamoProducerKit steht der CamoController, der deiner App eine zentrale Schnittstelle zur Steuerung des Camo SDK bietet.

In deiner App solltest du eine Instanz des CamoController initialisieren. Das kannst du beim App-Start tun oder für später aufheben. Bis er explizit mit start() gestartet wird, verbraucht der Camo-Controller nur sehr wenige Ressourcen. Bei der Initialisierung bereitet er sich jedoch bereits auf die Audio- und Videokodierung vor.

import CamoProducerKit

class MyVideoManager {
    let controller = CamoController()

    // ...
}

Wenn du die Camo-Integration in deiner App aktivieren und den Camo-Dienst starten möchtest, um Verbindungen zu ermöglichen, kannst du start() aufrufen. Sobald du fertig bist, kannst du ihn durch Aufrufen von stop() beenden.

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

Dieser Code ist ein Anfang, kann aber noch keine neuen Verbindungen von Camo Studio annehmen.

Auf neue Verbindungen reagieren

Bevor deine App neue Verbindungen von Camo Studio annehmen kann, musst du das CamoControllerDelegate implementieren. Durch die Implementierung dieser beiden Delegate-Methoden wirst du über Änderungen des Verbindungsstatus benachrichtigt und kannst entscheiden, ob du eine Verbindung annimmst oder ablehnst.

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

Damit solltest du nun in der Lage sein, deine App zu öffnen, per USB zu verbinden und dein Gerät in Camo Studio zu sehen.

Kabellose Verbindungen

Um kabellose Verbindungen zu nutzen, müssen Nutzer den Zugriff auf das lokale Netzwerk gewähren. Bonjour-Dienste sollten als NSBonjourServices in der Info.plist hinzugefügt werden:

• _camo._tcp
• _camopairing._tcp

Wenn du camoController.start() aufrufst, ist das SDK bereit für die Kopplung und den Aufbau von Netzwerkverbindungen mit Camo Studio.

Kopplung

Wenn ein Nutzer auf die Schaltfläche „+“ in Camo Studio klickt, beginnt der Kopplungsvorgang. Camo Studio zeigt einen QR-Code an, der auf der App-Seite gescannt werden sollte.

Schritte zur Kopplung:

1. Klicke in Camo Studio auf „+“, um den QR-Code anzuzeigen
2. Scanne den QR-Code und erhalte seine Daten als String
3. Übergib diese Daten an das SDK, indem du camoController.pairStudioWithQRCodeData(codeData) { success in } aufrufst
4. Die Methode pairStudioWithQRCodeData hat einen Callback, der dir mitteilt, ob die Kopplung erfolgreich war
5. Das SDK führt die Kopplung mit Camo Studio durch, und die Verbindung wird automatisch hergestellt.

Wenn du die Kopplung abbrechen musst (zum Beispiel, wenn der Nutzer den QR-Scanner oder die App geschlossen hat), solltest du camoController.cancelPairing() aufrufen

Die Kopplung hat ein Timeout von 30 Sekunden. Der Callback für die Methode pairStudioWithQRCodeData wird mit dem Wert success false aufgerufen, wenn die Kopplung nicht innerhalb von 30 Sekunden nach dem Aufruf von pairStudioWithQRCodeData erfolgt ist.

Gekoppelte Geräte

Nach Abschluss der Kopplung speichert das SDK die Kopplungsdaten in der Liste der gekoppelten Geräte. CamoController verfügt über 2 Methoden zur Arbeit mit dieser Liste:

• pairedDevices, um die Liste abzurufen (wenn du sie in der Benutzeroberfläche anzeigen möchtest)
• removePairedDevice, um das Gerät zu vergessen

Um beim nächsten Mal eine kabellose Verbindung zu Camo Studio herzustellen, klicke einfach auf die Schaltfläche „+“ in Camo Studio und warte, bis die Verbindung hergestellt ist – ein erneutes Scannen des QR-Codes ist nicht nötig.

Verbindungsstatus ermitteln

Der CamoController bietet eine CamoControllerState-Eigenschaft, die auch in der oben gezeigten Delegate-Methode für Statusänderungen enthalten ist. Dieses Enum liefert für deine App nützliche Informationen, etwa den Namen des verbundenen Computers zur Anzeige in der Benutzeroberfläche.

Hier ist ein Beispiel, wie du deine Benutzeroberfläche aktualisieren könntest, um den Verbindungsstatus widerzuspiegeln:

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
    }
}

Audiovisuelle Daten übertragen

Um Clients so viel Flexibilität wie möglich zu bieten, stellt das Camo SDK keine Aufnahme bereit und steuert auch keine. Stattdessen bist du dafür verantwortlich, dem CamoController Audio- und Videodaten bereitzustellen. Das lässt sich mit zwei einfachen API-Aufrufen erledigen:

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

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

Video senden

Wenn du in deiner Video-Pipeline Zugriff auf einen CMSampleBuffer hast, ist es denkbar einfach, diese Daten an das Camo SDK zu übergeben.

Deshalb ist die Einrichtung mit einer einfachen AVCaptureSession für Video extrem einfach. Hier ist ein Beispiel dazu.

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

Achte beim Senden von Videoframes auf Folgendes:

• Die Framedauer entspricht 30 FPS.
• Das Pixelformat ist kCVPixelFormatType_32BGRA.

Weitere Details findest du in der API-Referenz.

Audio senden

Das Senden von Audio ähnelt dem von Video, kann je nach Art des Empfangs in deiner Anwendung aber ein paar zusätzliche Schritte erfordern. Eine Beispielimplementierung findest du in der Demo-App, die dem Camo SDK beiliegt.

Achte beim Senden von Audiodaten auf Folgendes:

• Deine Abtastrate beträgt 48 kHz.
• Der Audiocodec ist LPCM.
• Die Anzahl der Kanäle beträgt 2.
• Die Bittiefe beträgt 32.
• Die Anzahl der Samples pro Audiopaket hängt von Studio (macOS oder Windows) ab; du kannst sie über CamoController.audioSamplesRequired abrufen.

Weitere Details findest du in der API-Referenz.