Not able to stream in newly created channel

[iosfitness]

I am trying to dynamically create a channel and publish but its not sending stream on audience Apps

Below is the code snippet

import UIKit
import AgoraRtcKit
import AgoraRtmKit


enum LoginStatus {
    case online, offline
}

class AgoraRtm: NSObject {
		static let kit = AgoraRtmKit(appId: "cb9d6201ddbb4cf4845b67385508dd68", delegate: nil)
    static var current: String? = "random"
    static var status: LoginStatus = .offline
    static func updateKit(delegate: AgoraRtmDelegate) {
        guard let kit = kit else {
            return
        }
        kit.agoraRtmDelegate = delegate
    }
}

protocol ShowAlertProtocol: UIViewController {
    func showAlert(_ message: String, handler: ((UIAlertAction) -> Void)?)
    func showAlert(_ message: String)
}

extension ShowAlertProtocol {
    func showAlert(_ message: String, handler: ((UIAlertAction) -> Void)?) {
        view.endEditing(true)
        let alert = UIAlertController(title: nil, message: message, preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "OK", style: .default, handler: handler))
        present(alert, animated: true, completion: nil)
    }
    
    func showAlert(_ message: String) {
        showAlert(message, handler: nil)
    }
}

class AgoraVideoViewController: UIViewController, ShowAlertProtocol {

    @IBOutlet weak var localVideoView: UIView!
    @IBOutlet weak var muteButton: UIButton!
    @IBOutlet weak var hangUpButton: UIButton!

    @IBOutlet weak var txtMessage: UITextField!

    let appID = "cb9d6201ddbb4cf4845b67385508dd68"
    var agoraKit: AgoraRtcEngineKit?
        var agoraChatKit: AgoraRtmKit?
    let tempToken: String? = nil
    var userID: UInt = 0
    var userName: String? = nil
    var channelName = "default"
	  //var channelRTM = "default"
    var remoteUserIDs: [UInt] = []
	
		var rtmChannel: AgoraRtmChannel?
    var rtcChannel: AgoraRtcChannel!
	
    let isBroadcaster = false //TODO: Hardik : Get this role in login API
    
    var muted = false {
        didSet {
            if muted {
                muteButton.setTitle("Unmute", for: .normal)
            } else {
                muteButton.setTitle("Mute", for: .normal)
            }
        }
    }
	

	private func getAgoraEngine() -> AgoraRtcEngineKit {
			if agoraKit == nil {
					agoraKit = AgoraRtcEngineKit.sharedEngine(withAppId: appID, delegate: self)
			}
			return agoraKit!
	}
	
    
	override func viewDidLoad() {
		super.viewDidLoad()
		
		channelName = "default"
		userName = ToolsAndFunctions.randomString(length: 10)
		
		// Do any additional setup after loading the view.
		//RTC
		setUpVideo()
		joinChannel()
		
		
		//RTM
		login()
		
		
	}
    
    /*func getResourceID(){
        var jsonDict = [String : Any]()
        
        let clientRequestJsonDict = [String : Any]()
        
        jsonDict.updateValue("tt", forKey: "cname")
        jsonDict.updateValue("123456", forKey: "uid")
        jsonDict.updateValue(clientRequestJsonDict, forKey: "clientRequest")
        
        httHelper.getResourceIdAPI(_for: "https://api.agora.io/v1/apps/\(appID)/cloud_recording/acquire", jsonBody: jsonDict)
    }*/
	
//MARK: =================RTC WORKING=============================
	func setUpVideo() {
		getAgoraEngine().enableVideo()
		getAgoraEngine().enableAudio()
		
		getAgoraEngine().setChannelProfile(.liveBroadcasting)
		
		//Warning: only enable dual stream mode if there will be more than one broadcaster in the channel
		//getAgoraEngine().enableDualStreamMode(true)
		
		if isBroadcaster{
			
			let videoCanvas = AgoraRtcVideoCanvas()
			videoCanvas.uid = userID
			videoCanvas.view = localVideoView
			videoCanvas.renderMode = .fit
			
			getAgoraEngine().startPreview()
			getAgoraEngine().muteLocalAudioStream(false)
			getAgoraEngine().muteLocalVideoStream(false)
			
			getAgoraEngine().setClientRole(.broadcaster)
			getAgoraEngine().setupLocalVideo(videoCanvas)
			
		}
		else{
			getAgoraEngine().setClientRole(.audience)
			getAgoraEngine().muteLocalAudioStream(true)
			getAgoraEngine().muteLocalVideoStream(true)
			
		}
		
		//Configuration
		getAgoraEngine().setVideoEncoderConfiguration(
							 AgoraVideoEncoderConfiguration(
								size: AgoraVideoDimension640x480,
									 frameRate: .fps30,
									 bitrate: AgoraVideoBitrateStandard,
									 orientationMode: .adaptative
							 )
					 )
		
	}
    
	func joinChannel() {
		//TODO: JB : Call API HERE
		localVideoView.isHidden = false
		//TODO: What is this check for userName
		// What is tempToken. Check and explain over call. How can I stop live-streaming
		
		        let options = AgoraRtcChannelMediaOptions()
						options.autoSubscribeAudio = true
						options.autoSubscribeVideo = true
						if (rtcChannel != nil) {
								rtcChannel.destroy()
						}
						rtcChannel = getAgoraEngine().createRtcChannel("Test123213")
						rtcChannel.setRtcChannelDelegate(self)
	        	rtcChannel.publish()
						let success = rtcChannel.join(byToken: nil, info: nil, uid: 0, options: options)
		
		        print(success)
		
			//APPROACH FROM https://docs.agora.io/en/Interactive%20Broadcast/start_live_ios?platform=iOS
		/*if let name = userName {
			let channelCode = 	getAgoraEngine().joinChannel(byUserAccount: name, token: tempToken, channelId: channelName) { [weak self] (sid, uid, elapsed) in
				//TODO: Hardik : Call API HERE for join
				self?.userID = uid
			}
			print("RTC---",channelCode)
		} else {
			let channelCode = 	getAgoraEngine().joinChannel(byToken: tempToken, channelId:channelName, info: nil, uid: userID) { [weak self] (sid, uid, elapsed) in
				//TODO: Hardik : Call API HERE for join
				self?.userID = uid
				
			}
			print("RTC---",channelCode)
		}*/
		
		
		
	}
	
   
    
    /*@IBAction func didToggleMute(_ sender: Any) {
        if muted {
            getAgoraEngine().muteLocalAudioStream(false)
        } else {
            getAgoraEngine().muteLocalAudioStream(true)
        }
        muted = !muted
    }
    
 */
	@IBAction func didTapHangUp(_ sender: Any) {
        leaveChannel()
        
    }

      @IBAction func btnSendMsgTapped(_ sender: Any) {
        send(message: txtMessage.text!)
    }
	
    
	func leaveChannel() {
		//TODO: Hardik : Call API HERE for leave
		getAgoraEngine().leaveChannel(nil)
		leaveRtmChannel()
		// Stop preview after leave channel
		if isBroadcaster{
			getAgoraEngine().stopPreview()
		}
		
			localVideoView.isHidden = true
			remoteUserIDs.removeAll()

		 setIdleTimerActive(true)
		
		 logout()
		
	}
	
	
	func setIdleTimerActive(_ active: Bool) {
		UIApplication.shared.isIdleTimerDisabled = !active
	}
    
    /*
    // MARK: - Navigation

    // In a storyboard-based application, you will often want to do a little preparation before navigation
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        // Get the new view controller using segue.destination.
        // Pass the selected object to the new view controller.
    }
    */

}

extension AgoraVideoViewController: AgoraRtcEngineDelegate {
    func rtcEngine(_ engine: AgoraRtcEngineKit, didJoinedOfUid uid: UInt, elapsed: Int) {
			//Get count of user's joined
          remoteUserIDs.append(uid)
        
    }
    
    //Sometimes, user info isn't immediately available when a remote user joins - if we get it later, reload their nameplate.
    func rtcEngine(_ engine: AgoraRtcEngineKit, didUpdatedUserInfo userInfo: AgoraUserInfo, withUid uid: UInt) {
        if let index = remoteUserIDs.first(where: { $0 == uid }) {
           // collectionView.reloadItems(at: [IndexPath(item: Int(index), section: 0)])
					
					//TODO: Check this. Retrieve name from AgoraUserInfo
            
            if let userInfo = getAgoraEngine().getUserInfo(byUid: index, withError: nil),
                           let username = userInfo.userAccount {
                          self.view.makeToast(username, duration: 0.5, position: .top)
                       }
					
					
        }
    }
    
    func rtcEngine(_ engine: AgoraRtcEngineKit, didOfflineOfUid uid: UInt, reason: AgoraUserOfflineReason) {
        if let index = remoteUserIDs.firstIndex(where: { $0 == uid }) {
            remoteUserIDs.remove(at: index)
           
        }
    }
	
	// first remote video frame
	func rtcEngine(_ engine: AgoraRtcEngineKit, firstRemoteVideoDecodedOfUid uid: UInt, size: CGSize, elapsed: Int) {
		
		if !isBroadcaster{
			let videoCanvas = AgoraRtcVideoCanvas()
			videoCanvas.uid = uid
			videoCanvas.view = localVideoView
			videoCanvas.renderMode = .fit
			getAgoraEngine().setupRemoteVideo(videoCanvas)
		}
		
		
	}
}



//MARK: =================RTM WORKING=============================


 private extension AgoraVideoViewController {
	
	 private func getAgoraChatEngine() -> AgoraRtmKit {
					 if agoraChatKit == nil {
							 agoraChatKit = AgoraRtmKit(appId: appID, delegate: self)
					 }
					 return agoraChatKit!
			 }
	
     func createChannel(_ channel: String) {
         let errorHandle = { [weak self] (action: UIAlertAction) in
             guard let strongSelf = self else {
                 return
             }
             strongSelf.navigationController?.popViewController(animated: true)
         }
         
         guard let rtmChannel = AgoraRtm.kit?.createChannel(withId: channel, delegate: self) else {
             showAlert("join channel fail", handler: errorHandle)
             return
         }
         
         rtmChannel.join { [weak self] (error) in
             if error != .channelErrorOk, let strongSelf = self {
                 strongSelf.showAlert("join channel error: \(error.rawValue)", handler: errorHandle)
             }
         }
         
         self.rtmChannel = rtmChannel
     }
     
     func leaveRtmChannel() {
         rtmChannel?.leave { (error) in
             print("leave channel error: \(error.rawValue)")
         }
     }
 }

// MARK: Chat Channel
 // MARK: Send Message
 private extension AgoraVideoViewController {
    
    func login() {
           guard let account = userName, account.count > 0 else{
               return
           }
           
           AgoraRtm.updateKit(delegate: self)
           AgoraRtm.current = account
//           AgoraRtm.oneToOneMessageType = enableOneToOneSwitch.isOn ? .offline : .normal

           AgoraRtm.kit?.login(byToken: nil, user: account) { [unowned self] (errorCode) in
               guard errorCode == .ok else {
                   self.showAlert("login error: \(errorCode.rawValue)")
                   return
               }
               
               AgoraRtm.status = .online
                    DispatchQueue.main.async {
                self.createChannel(self.channelName)
                         print("Loggef in")
            }
           
           }
       }
    
    func logout() {
        guard AgoraRtm.status == .online else {
            return
        }
        
        AgoraRtm.kit?.logout(completion: { (error) in
            guard error == .ok else {
                return
            }
            
            AgoraRtm.status = .offline
        })
    }
    
     func send(message: String) {

			//TODO: Send a json string here
         let rtmMessage = AgoraRtmMessage(text: message)
         
        
             rtmChannel?.send(rtmMessage) { (error) in
                print(error.rawValue)
             
         }
     }
 }

 // MARK: AgoraRtmDelegate
 extension AgoraVideoViewController: AgoraRtmDelegate {
     func rtmKit(_ kit: AgoraRtmKit, connectionStateChanged state: AgoraRtmConnectionState, reason: AgoraRtmConnectionChangeReason) {
         showAlert("connection state changed: \(state.rawValue)") { [weak self] (_) in
             if reason == .remoteLogin, let strongSelf = self {
                 strongSelf.navigationController?.popToRootViewController(animated: true)
             }
         }
     }
     
     func rtmKit(_ kit: AgoraRtmKit, messageReceived message: AgoraRtmMessage, fromPeer peerId: String) {
//         appendMessage(user: peerId, content: message.text)
        print(message.text, peerId)
     }
 }

 // MARK: AgoraRtmChannelDelegate
 extension AgoraVideoViewController: AgoraRtmChannelDelegate {
     func channel(_ channel: AgoraRtmChannel, memberJoined member: AgoraRtmMember) {
         DispatchQueue.main.async { [unowned self] in
             self.showAlert("\(member.userId) join")
         }
     }
     
     func channel(_ channel: AgoraRtmChannel, memberLeft member: AgoraRtmMember) {
         DispatchQueue.main.async { [unowned self] in
             self.showAlert("\(member.userId) left")
         }
     }
     
     func channel(_ channel: AgoraRtmChannel, messageReceived message: AgoraRtmMessage, from member: AgoraRtmMember) {
//         appendMessage(user: member.userId, content: message.text)
        print(message.text, member.userId)
     }
 }
extension AgoraVideoViewController: AgoraRtcChannelDelegate {
    func rtcChannelDidJoin(_ rtcChannel: AgoraRtcChannel, withUid uid: UInt, elapsed: Int) {
        
			if !isBroadcaster{
				let videoCanvas = AgoraRtcVideoCanvas()
				videoCanvas.uid = uid
				videoCanvas.view = localVideoView
				videoCanvas.renderMode = .fit
				getAgoraEngine().setupRemoteVideo(videoCanvas)
			}
    }
 
    func rtcChannel(_ rtcChannel: AgoraRtcChannel, didJoinedOfUid uid: UInt, elapsed: Int) {
       
    }
 
    func rtcChannel(_ rtcChannel: AgoraRtcChannel, didOfflineOfUid uid: UInt, reason: AgoraUserOfflineReason) {
        
    }

    
    func rtcChannelDidLeave(_ rtcChannel: AgoraRtcChannel, with stats: AgoraChannelStats) {
        
    }
 
    func rtcChannel(_ rtcChannel: AgoraRtcChannel, didOccurWarning warningCode: AgoraWarningCode) {
       
    }
 
    func rtcChannel(_ rtcChannel: AgoraRtcChannel, didOccurError errorCode: AgoraErrorCode) {
        
    }

}

Can anyone please suggest the right approach to do it?. My requirement is to create a channel when the host/broadcaster joins it. Reference :

https://docs.agora.io/en/Interactive%20Broadcast/start_live_ios?platform=iOS https://github.com/AgoraIO-Usecase/Breakout-Class/blob/master/breakout-ios/AgoraDualChannels/AgoraDualChannels/Controllers/LiveRoomViewController.swift

[plutoless]

i'm not sure if i understand your requirements correctly. A channel will be automatically created when you host/audience joins, you do not need to manually create it. And if you want an audience to switch to host and stream out video, you will need to call setClientRole in the channel.