Share the screen

• ZEGO Express SDK: the real-time Audio and Video Call SDK provided by ZEGOCLOUD. It can help you provide audio and video services that feature convenient access, high-definition and fluency, cross-platform communication, low latency, and high concurrency.
• Stream publishing: the process of publishing the audio and video data streams that are captured and packaged to ZEGOCLOUD real-time audio and video cloud.
• Stream playing: the process of receiving and playing audio and video data streams from ZEGOCLOUD real-time audio and video cloud.
• Room: the service provided by ZEGOCLOUD for organizing user groups and allowing users in the same room to receive and send real-time audio, video, and messages to each other.
  1. Users can publish or play streams only after logging in to a room.
  2. Users can receive notifications about changes (such as users joining or leaving a room, and audio and video stream changes) in the room where they are in.

1. Open your project in Xcode, and select File > New > Target.
   

2. In the following window, select the Broadcast Upload Extension, and click Next.

   

3. Fill in items or choose options for your new target, such as fill in the Product Name as ScreenShare, and choose options for the Team, Language, and other required information, and then click Finish.

   Don't need to check the Include UI Extension option.

   

4. After you created the Broadcast Upload Extension, you will see a folder for this Extension in your project with a structure similar to the following. This folder is used to store the implementation codes for the screen sharing feature:

   

5. Add the ZegoExpressEngine.xcframework dependency.

   • Click the + button as shown in the following figure.

     

   • Select and add the ZegoExpressEngine.xcframework.

     

   • Set Embed to Do Not Embed.

     

6. Set the Extension version

You need to set the Minimum Deployment Version of the Extension to be consistent with the application, but the minimum version of the Extension should be iOS 12.

7. Replace the code in the SampleHandler file with the following code:

import ReplayKit
import ZegoExpressEngine

class SampleHandler: RPBroadcastSampleHandler {

    override func broadcastStarted(withSetupInfo setupInfo: [String : NSObject]?) {
        // User has requested to start the broadcast. Setup info from the UI extension can be supplied but optional.
        ZegoReplayKitExt.sharedInstance().setup(withDelegate: self)
    }

    override func broadcastPaused() {
        // User has requested to pause the broadcast. Samples will stop being delivered.
    }

    override func broadcastResumed() {
        // User has requested to resume the broadcast. Samples delivery will resume.
    }

    override func broadcastFinished() {
        // User has requested to finish the broadcast.
        ZegoReplayKitExt.sharedInstance().finished()
    }

    override func processSampleBuffer(_ sampleBuffer: CMSampleBuffer, with sampleBufferType: RPSampleBufferType) {
        ZegoReplayKitExt.sharedInstance().send(sampleBuffer, with: sampleBufferType)
    }
}

extension SampleHandler: ZegoReplayKitExtHandler {
    func broadcastFinished(_ broadcast: ZegoReplayKitExt, reason: ZegoReplayKitExtReason) {
        switch reason {
        case .hostStop:
            let userInfo = [NSLocalizedDescriptionKey: "Host app stop srceen capture"]
            let error = NSError(domain: NSCocoaErrorDomain, code: 0, userInfo: userInfo)
            finishBroadcastWithError(error)
        case .connectFail:
            let userInfo = [NSLocalizedDescriptionKey: "Connect host app fail need startScreenCapture in host app"]
            let error = NSError(domain: NSCocoaErrorDomain, code: 0, userInfo: userInfo)
            finishBroadcastWithError(error)
        case .disconnect:
            let userInfo = [NSLocalizedDescriptionKey: "disconnect with host app"]
            let error = NSError(domain: NSCocoaErrorDomain, code: 0, userInfo: userInfo)
            finishBroadcastWithError(error)
        @unknown default:
            break
        }
    }
}

let canvas = ZegoCanvas(view: streamView)
ZegoExpressEngine.shared().startPreview(canvas, channel: .aux)

In general, the type of stream can be agreed upon through the construction rules of stream ID, which is suitable for most scenarios:

1. You can configure the stream ID of the camera and microphone on ZegoPublishChannel.Main as "\(roomID)_\(userID)_live", and configure the stream ID of screen sharing on ZegoPublishChannel.Aux as "\(roomID)_\(userID)_screen".

2. When the callback on the stream added is received by the stream players, the stream type can be judged according to the stream ID rule.

3. The server callback can also judge the stream type according to the same rule.

If using stream ID to identify stream type is not suitable, you can use stream attachment information to mark stream type. See setStreamExtraInfo method for details.

In this case, publishing multiple streams is not required. You just need to replace the video source of the main channel with the screen sharing source:

1. Set video source and configure it to ZegoPublishChannel.Main, like this:

ZegoExpressEngine.shared().setVideoSource(.screenCapture, channel: .main)

let videoConfig = ZegoVideoConfig(preset: .preset720P)
videoConfig.fps = 10
ZegoExpressEngine.shared().setVideoConfig(videoConfig, channel: .main)

This way, the ZegoPublishChannel.Main channel will use screen sharing as the video source and use the microphone as the audio source.

2. Use ZegoPublishChannel.Main as the channel parameter in the following steps. Like this:

ZegoExpressEngine.shared().startPublishingStream(streamID, channel: .main);
ZegoExpressEngine.shared().stopPublishingStream(.main);