Getting Started with Publishing

import MillicastSDK

// Configure the audio session for capturing
let session = AVAudioSession.sharedInstance()
try session.setCategory(
    .playAndRecord,
    mode: .videoChat,
    options: [.mixWithOthers, .allowBluetooth, .allowBluetoothA2DP]
)
try session.setActive(true)

// Create an audio track
var audioTrack : MCAudioTrack? = nil
if
    let audioSources = MCMedia.getAudioSources(), // Get an array of audio sources
    !audioSources.isEmpty // There is at least one audio source
{
    // Choose the preferred audio source and start capturing
    let audioSource = audioSources[0]
    audioTrack = audioSource.startCapture() as? MCAudioTrack
}

// Create a video track
var videoTrack : MCVideoTrack? = nil
if
    let videoSources = MCMedia.getVideoSources(), // Get an array of available video sources
    !videoSources.isEmpty // There is at least one video source
{
    // Choose the preferred video source
    let videoSource = videoSources[0];
    
    // Get capabilities of the available video sources, such as
    // width, height, and frame rate of the video sources
    guard let capabilities = videoSource.getCapabilities() else {
        fatalError("No capability is available!") // In production replace with a throw
    }
    
    let capability = capabilities[0]; // Get the first capability
    videoSource.setCapability(capability);
    
    // Start video recording and create a video track
    videoTrack = videoSource.startCapture() as? MCVideoTrack
}

let publisher = MCPublisher()

// Get the credentials structure from your publisher instance, fill it in,
// and set the modified credentials
let credentials = MCPublisherCredentials()
credentials.streamName = "streamName"; // The name of the stream you want to publish
credentials.token = "aefea56153765316754fe"; // The publishing token
credentials.apiUrl
    = "https://director.millicast.com/api/director/publish"; // The publish API URL

do {
  try await publisher.setCredentials(credentials);
} catch MCGenericError.noCredentials {
  // You have provided incomplete credentials
  // such as an empty streamName, token, or url
}   

await publisher.addTrack(with: audioTrack)
await publisher.addTrack(with: videoTrack)

let publisherOptions = MCClientOptions()

// Get a list of supported codecs
if let audioCodecs = MCMedia.getSupportedAudioCodecs() {
    // Choose the preferred audio codec
    publisherOptions.audioCodec = audioCodecs[0]
    
} else {
    print("No audio codecs available!") // In production, replace it with proper error handling
}

if let videoCodecs = MCMedia.getSupportedVideoCodecs() {
    // Choose the preferred video codec
    publisherOptions.videoCodec = videoCodecs[0]
    
} else {
    print("No video codecs available!") // In production, replace it with proper error handling
}

// To use multi-source, set a source ID of the publisher and
// enable discontinuous transmission
publisherOptions.sourceId = "MySource"
publisherOptions.dtx = true

// Enable stereo
publisherOptions.stereo = true

do {
  try await publisher.connect()
  // using publisherOptions from step 2.4
  try await publisher.publish(with: publisherOptions)
} catch MCGenericError.restAPIError {
  // Handle invalid credentials passed to the publisher
}

Task {
  // Assuming you have a publisher instantiated before
  for await state in publisher.state() {
    switch(state) {
    case .connected:
      // Invoked when you are connected to the Millicast service
    case .publishing:
      // Invoked when you are currently publishing media
    case .disconnected:
      // Invoked when you are disconnected from the Millicast service
    case .connectionError(let status: Int32, let reason: String):
      // Invoked when an error occurs during a REST API call or a WebSocket establishment
      // error occurs
    case .signalingError(let message):
      // Invoked when an error occurs during the establishment of the 
      // WebRTC peer connection and is returned by the Media Server
      // due to a configuration error
    }
  }
}

Task {
  // Assuming you have a publisher instantiated before
  // Similar to state(), activity(), and all other async streams create new ones every time
  for await activity in publisher.activity() {
    switch(activity) {
    case .active:
      // Invoked when the first viewer connects to the stream
    case .inactive:
      // Invoked when the last viewer disconnects from the stream
    }
  }
}

Task {
  // Assuming you have a publisher instantiated before
  for await viewerCount in publisher.viewerCount() {
    // do something with viewerCount
  }
}

class PublisherDelegate: NSObject, MCPublisherDelegate {
  func onPublishing() {}
  func onConnected() {}
  func onDisconnected() {}
  func onActive() {}
  func onInactive() {}
  func onViewerCount(_ count: Int32) {}
  func onSignalingError(_ message: String) {}
  func onConnectionError(_ status: Int32, withReason reason: String) {}
  func onStatsReport(_ report: MCStatsReport) {}
  func onTransformableFrame(_ data: NSMutableArray, withSsrc ssrc: Int32, withTimestamp timestamp: Int32) {}
}

let publisherDelegate = PublisherDelegate()
let publisher = MCPublisher(delegate: publisherDelegate)

await publisher.enableStats(true)

Task {
  for await statsReport in publisher.statsReport() {
    // Here for example we are querying the codec statistics
    let codecStatsList = statsReport.getStatsOf(MCCodecsStats.get_type()) as? [MCCodecsStats]
    if let codecStatsList = codecStatsList {
      // Do something with the statistics
    }   
  }
}

let connectionOptions = MCConnectionOptions()
connectionOptions.autoReconnect = false

do {
  try await publisher.connect(with: connectionOptions)
} catch error {
  //...
}

Task {
  for await state in publisher.state() {
    if case .connectionError(let status, let reason) = state {
      try await publisher.disconnect()    
    }
  }
}

do {
  try await publisher.connect(with: connectionOptions)
} catch MCAsyncOperationCancelledError.aborted {
  // The operation has been aborted by the disconnect call above
}