Room 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 roomExpress = PhenixRoomExpressFactory.createRoomExpress(roomExpressOptions)

import PhenixSdk
 
let roomExpress: PhenixRoomExpress = ...  // previously obtained
 
let joinRoomOptions = PhenixRoomExpressFactory.createJoinRoomOptionsBuilder()
    .withStreamToken("stream token")
    .buildJoinRoomOptions()
 
roomExpress.joinRoom(joinRoomOptions, { (status: PhenixRequestStatus, roomService: PhenixRoomService?) in
    if status == .ok {
      // Hold on to roomService reference for as long as you wish to stay in the room
    } else {
      // Handle error
    }
  })
 
// With optional member update notification:
roomExpress.joinRoom(
    joinRoomOptions,
    { (status: PhenixRequestStatus, roomService: PhenixRoomService?) in
      if status == .ok {
        // Hold on to roomService reference for as long as you wish to stay in the room
      } else {
        // Handle error
      }
    },
    { (members: [PhenixMember]?) in
      // Do something with room members
    })

import PhenixSdk
 
let roomExpress: PhenixRoomExpress = ... // previously obtained
let room: PhenixImmutableRoom = ...  // previously obtained
let renderLayer: CALayer = ...  // previously obtained
 
// Just an example showing how to get a stream from a member.
// In a real-world app you would want to subscribe to the room-members-observable on the room
// to receive updates when the list of members changes, and then subscribe to the streams-observable
// on each member to access their streams.
let member = room.getObservableMembers().getValue()[0] as! PhenixMember
let memberStream = member.getObservableStreams().getValue[0] as! PhenixStream
 
let options = PhenixRoomExpressFactory.createSubscribeToMemberStreamOptionsBuilder()
    .withStreamToken("DIGEST:eyJhc...")
    .withRenderer(renderLayer)
    .buildSubscribeToMemberStreamOptions()
 
roomExpress.subscribe(
    toMemberStream: memberStream,
    options,
    { [weak self] (
        status: PhenixRequestStatus,
        subscriber: PhenixExpressSubscriber?,
        renderer: PhenixRenderer?) in
      guard status == .ok, let strongSelf = self else {
        // Handle subscribe error
        return
      }
 
      // Important: Store subscriber reference, otherwise we will stop subscription immediately:
      strongSelf.currentSubscriber = subscriber
    })

import PhenixSdk
 
let roomExpress: PhenixRoomExpress = ... // previously obtained
 
let mediaConstraints = PhenixUserMediaOptions()
// Customize constraints if needed
 
let localPublishOptions = PhenixPCastExpressFactory.createPublishOptionsBuilder()
    .withStreamToken("DIGEST:eyJhc...")
    .withMediaConstraints(mediaConstraints)
    .buildPublishOptions()
 
let localPublishToRoomOptions = PhenixRoomExpressFactory.createPublishToRoomOptionsBuilder()
    .withStreamType(.user)
    .withMemberRole(.participant)
    .withPublishOptions(localPublishOptions)
    .buildPublishToRoomOptions()
 
roomExpress.publish(
    toRoom: localPublishToRoomOptions,
    withCallback: { [weak self] (
        status: PhenixRequestStatus,
        roomService: PhenixRoomService?,
        publisher: PhenixExpressPublisher?) in
      guard status == .ok, let strongSelf = self else {
        // Handle publish error
        return
      }
 
      // Important: Store publisher reference, otherwise we will stop publisher immediately:
      strongSelf.currentPublisher = publisher
    })
 

import PhenixSdk
 
let roomExpress: PhenixRoomExpress = ...  // previously obtained
 
let pcastExpress = roomExpress.pcastExpress