Channel Express

import PhenixSdk
 
let pcastExpressOptions = PhenixPCastExpressFactory.createPCastExpressOptionsBuilder(unrecoverableErrorCallback: { status, errorDescription in
          // Best option is to try rebuilding the ChannelExpress instance and/or quit your app
    })
     .buildPCastExpressOptions()
 
 
let roomExpressOptions = PhenixRoomExpressFactory.createRoomExpressOptionsBuilder()
    .withPCastExpressOptions(pcastExpressOptions)
    .buildRoomExpressOptions()
 
let channelExpressOptions = PhenixChannelExpressFactory.createChannelExpressOptionsBuilder()
    .withRoomExpressOptions(roomExpressOptions)
    .buildChannelExpressOptions()
 
let channelExpress = PhenixChannelExpressFactory.createChannelExpress(channelExpressOptions)

import PhenixSdk
 
let channelExpress: PhenixChannelExpress = ...  // previously obtained
let renderLayer: CALayer = ...  // previously obtained
 
// Just an example (you can omit renderer options if defaults are ok)
let rendererOptions = PhenixRendererOptions()
options.aspectRatioMode = .letterbox
 
let joinChannelOptions = PhenixChannelExpressFactory.createJoinChannelOptionsBuilder()
    .withStreamToken("DIGEST:eyJhc...")
    .withStreamSelectionStrategy(.mostRecent)
    .withRenderer(renderLayer)
    .withRendererOptions(rendererOptions)
    .buildJoinChannelOptions()
 
channelExpress.joinChannel(
    joinChannelOptions,
    { [weak self] (requestStatus: PhenixRequestStatus, roomService: PhenixRoomService?) in
      guard requestStatus == .ok, let strongSelf = self else {
        // Handle channel join error
        return
      }
 
      // Important: Store room service reference, otherwise we will leave channel again immediately:
      strongSelf.currentRoomService = roomService
    },
    { [weak self]
        (requestStatus: PhenixRequestStatus,
         expressSubscriber: PhenixExpressSubscriber?,
         renderer: PhenixRenderer?) in
      guard let strongSelf = self else {
        return
      }
      if (requestStatus == .ok) {
        // Successfully subscribed to a stream. No need to hold on to any references
      } else if (requestStatus == .noStreamPlaying) {
        // No stream playing in channel, update UI accordingy
      } else {
        // We failed to subscribe and retry attempts must have failed
      }
    });

import PhenixSdk
 
let channelExpress: PhenixChannelExpress = ...  // previously obtained
 
// Example constraints. Audio and video are enabled by default
let mediaConstraints = PhenixUserMediaOptions()
mediaConstraints.video.capabilityConstraints[PhenixDeviceCapability.facingMode.rawValue] =
    [PhenixDeviceConstraint.initWith(.user)]
mediaConstraints.video.capabilityConstraints[PhenixDeviceCapability.frameRate.rawValue] =
    [PhenixDeviceConstraint.initWith(15)]
mediaConstraints.video.capabilityConstraints[PhenixDeviceCapability.height.rawValue] =
    [PhenixDeviceConstraint.initWith(720)]
mediaConstraints.video.capabilityConstraints[PhenixDeviceCapability.width.rawValue] =
    [PhenixDeviceConstraint.initWith(1280)]
 
mediaConstraints.audio.capabilityConstraints[PhenixDeviceCapability.audioEchoCancellationMode.rawValue] =
    [PhenixDeviceConstraint.initWith(PhenixAudioEchoCancellationMode.on)]
 
let publishOptions = PhenixPCastExpressFactory.createPublishOptionsBuilder()
    .withStreamToken("DIGEST:eyJhc...")
    .withMediaConstraints(mediaConstraints)
    .buildPublishOptions()
 
let publishToChannelOptions = PhenixChannelExpressFactory.createPublishToChannelOptionsBuilder()
    .withPublishOptions(publishOptions)
    .buildPublishToChannelOptions()
 
channelExpress.publish(
    toChannel: publishToChannelOptions,
    withCallback: { [weak self] (
        status: PhenixRequestStatus,
        roomService: PhenixRoomService?,
        publisher: PhenixExpressPublisher?) in
      guard status == .ok, let strongSelf = self else {
        // Handle channel publish error
        return
      }
 
      // Important: Store publisher reference, otherwise we will stop publishing again immediately:
      strongSelf.currentPublisher = publisher
    })