HLS Streaming

HLS can be started in two ways depending on the level of customization you need.

1. Default View: The simplest view to just begin a stream with default UI and parameters.
2. Custom Views: To use your own UI for HLS streaming, you need to provide your own web-app URL for our bot to join and stream.

Default View

Begins a stream with default parameters.

hmsSDK.startHLSStreaming() { didStart, error in
    print(didStart, error)
}

Custom View

To use your own web-app UI for HLS, you'll need to pass in a meeting URL. The 100ms bot will open this URL to join your room, so it must allow access without any user level interaction. In the future it'll be possible to start HLS for multiple such URLs for the same room.

For this purpose the API supports taking in an array, although currently only the first element of the array will be used. To distinguish between multiple urls an additional field metadata can be optionally passed. The meetingURL and metadata are clubbed together to form what we'll call a variant.

You can call hmsSDK.startHLSStreaming with HMSHLSConfig having an array of such variants. HMSHlsRecordingConfig is optional.

let config = HMSHLSConfig(variants: [HMSHLSMeetingURLVariant(meetingURL: meetingURL, metadata: "tag for reference")])
hmsSDK.startHLSStreaming(config: config) { didStart, error in
    print(didStart, error)
}

Optional HLS Recording

Optionally to record the HLS stream you may specify an HMSHLSRecordingConfig within the HMSHLSConfig.

Here's what the HMSHlsRecordingConfig looks like

class HMSHLSRecordingConfig {
    let singleFilePerLayer: Bool
    let enableVOD: Bool
}

1. singleFilePerLayer if the desired end result is a mp4 file per HLS layer, false by default.
2. enableVOD if the desired end result is a zip of m3u8 and all the chunks, false by default.

Here's an example of how to create a recording config:

// Optional recording config
let recordConfig = HMSHLSRecordingConfig(singleFilePerLayer: true, enableVOD: false)
let config = HMSHLSConfig(variants: [variant], recording: recordConfig)

Stopping HLS

You can call hmsSDK.stopHLSStreaming to stop HLS Streaming which will stop all the variants.

hmsSDK.stopHLSStreaming() { didStop, error in
    ...
}

Current Room Status

The current status for the room is always reflected in the HMSRoom object.

Here are the relevant properties inside the HMSRoom object which you can read to get the current hls streaming status of the room namely: hlsStreamingState.

The object contains a boolean running which lets you know if it's active on the room right now as well as list of active variants.

1. hlsStreamingState an instance of HMSHLSStreamingState, which looks like:

@objcMembers public class HMSHLSStreamingState : NSObject {
    public let running: Bool
    public let variants: [HMSHLSVariant]
}

This represents a livestream to one or more HLS urls.

The room status should be checked in following two places -

1. In the onJoin(room: HMSRoom) callback of HMSUpdateListener The properties mentioned above will be on the HMSRoom object.
2. In the on(room: HMSRoom, update: HMSRoomUpdate) callback of HMSUpdateListener. The HMSRoomUpdate type will be hlsStreamingStateUpdated.

You can call startStreaming method on HMSRoomModel instance to start streaming the room.

try await roomModel.startStreaming()

How to stop streaming

To stop streaming the room, call stopStreaming method.

try await roomModel.stopStreaming()

How to know when room is getting streamed

Check the isBeingStreamed on HMSRoomModel instance to know if room is getting streamed.

roomModel.isBeingStreamed

How to play the hls stream from the room on viewer side

You instantiate HMSHLSPlayerView() instance to render the HLS stream from the room you are in.

HMSHLSPlayerView()

import SwiftUI
import HMSRoomModels

struct MeetingView: View {
    
    @ObservedObject var roomModel = HMSRoomModel(roomCode: "qde-mik-seb")
    
    var body: some View {
        
        switch roomModel.roomState {
        case .notJoined, .leftMeeting:
            // Button to join the room
            Button {
                Task {
                    try await roomModel.joinSession(userName: "iOS User")
                }
            } label: {
                Text("Join")
            }
        case .inMeeting:
            VStack {
                // Show HLS stream from the room
                if roomModel.hlsVariants.first?.url != nil {
                    HMSHLSPlayerView()
                        .onResolutionChanged { size in
                            print("resolution: \(size)")
                        }
                        .onPlaybackFailure { error in
                            print("hlsError: \(error.localizedDescription)")
                        }
                }
                else {
                    // view to show when stream is yet to start
                }
                
                HStack {
                    
                    // Button to leave the room
                    Image(systemName: "phone.down.fill")
                        .onTapGesture {
                            Task {
                                try await roomModel.leaveSession()
                            }
                        }
                }
            }
        }
    }
}