WebRTC Streaming

// Initialize WebRTC adaptor for publishing
const webRTCAdaptor = new WebRTCAdaptor({
    websocket_url: "wss://your-server.com:5443/WebRTCAppEE/websocket",
    mediaConstraints: {
        video: true,
        audio: true
    },
    peerconnection_config: {
        iceServers: [{ urls: "stun:stun1.l.google.com:19302" }]
    },
    sdp_constraints: {
        OfferToReceiveAudio: false,
        OfferToReceiveVideo: false
    },
    callback: (info, obj) => {
        if (info === "initialized") {
            console.log("WebRTC adaptor initialized");
            webRTCAdaptor.publish("stream123");
        } else if (info === "publish_started") {
            console.log("Publishing started");
        } else if (info === "publish_finished") {
            console.log("Publishing finished");
        }
    },
    callbackError: (error, message) => {
        console.error("Error:", error, message);
    }
});

<!DOCTYPE html>
<html>
<head>
    <title>WebRTC Publisher</title>
    <script src="https://your-server.com:5443/WebRTCAppEE/js/webrtc_adaptor.js"></script>
</head>
<body>
    <video id="localVideo" autoplay muted></video>
    <button onclick="startPublishing()">Start Publishing</button>
    <button onclick="stopPublishing()">Stop Publishing</button>

    <script>
        let webRTCAdaptor;
        const streamId = "myStream_" + Math.floor(Math.random() * 1000000);

        function startPublishing() {
            webRTCAdaptor = new WebRTCAdaptor({
                websocket_url: "wss://your-server.com:5443/WebRTCAppEE/websocket",
                mediaConstraints: {
                    video: { width: 1280, height: 720 },
                    audio: true
                },
                localVideoId: "localVideo",
                callback: function(info, obj) {
                    if (info === "initialized") {
                        webRTCAdaptor.publish(streamId);
                    }
                }
            });
        }

        function stopPublishing() {
            webRTCAdaptor.stop(streamId);
        }
    </script>
</body>
</html>

import AntMediaSDK

class PublisherViewController: UIViewController {
    var client: AntMediaClient!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Initialize client
        client = AntMediaClient.init()
        client.delegate = self
        client.setOptions(
            url: "wss://your-server.com:5443/WebRTCAppEE/websocket",
            streamId: "stream123",
            token: "",
            mode: .publish
        )
        
        // Set video view
        client.setLocalView(container: localVideoView)
        
        // Start publishing
        client.start()
    }
}

extension PublisherViewController: AntMediaClientDelegate {
    func clientDidConnect(_ client: AntMediaClient) {
        print("Connected to server")
    }
    
    func clientDidDisconnect(_ client: AntMediaClient) {
        print("Disconnected from server")
    }
}

import io.antmedia.webrtcandroidframework.IWebRTCClient;
import io.antmedia.webrtcandroidframework.WebRTCClient;

public class PublisherActivity extends AppCompatActivity {
    private WebRTCClient webRTCClient;
    private String streamId = "stream123";
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_publisher);
        
        SurfaceViewRenderer localVideoView = findViewById(R.id.local_video_view);
        
        webRTCClient = new WebRTCClient(this, this);
        webRTCClient.setVideoRenderers(localVideoView, null);
        
        String serverUrl = "wss://your-server.com:5443/WebRTCAppEE/websocket";
        webRTCClient.init(serverUrl, streamId, "", 
            webRTCMode = IWebRTCClient.MODE_PUBLISH,
            "", // token
            this); // IWebRTCListener
    }
    
    public void startPublishing() {
        webRTCClient.startStream();
    }
    
    public void stopPublishing() {
        webRTCClient.stopStream();
    }
}

const webRTCAdaptor = new WebRTCAdaptor({
    websocket_url: "wss://your-server.com:5443/WebRTCAppEE/websocket",
    mediaConstraints: {
        video: false,
        audio: false
    },
    peerconnection_config: {
        iceServers: [{ urls: "stun:stun1.l.google.com:19302" }]
    },
    sdp_constraints: {
        OfferToReceiveAudio: true,
        OfferToReceiveVideo: true
    },
    remoteVideoId: "remoteVideo",
    callback: (info, obj) => {
        if (info === "initialized") {
            console.log("Initialized, now playing stream");
            webRTCAdaptor.play("stream123");
        } else if (info === "play_started") {
            console.log("Playback started");
        } else if (info === "play_finished") {
            console.log("Playback finished");
        }
    },
    callbackError: (error, message) => {
        console.error("Error:", error, message);
    }
});

<iframe 
    src="https://your-server.com:5443/WebRTCAppEE/play.html?name=stream123"
    width="100%" 
    height="500px" 
    frameborder="0" 
    allowfullscreen>
</iframe>

import asyncio
from aiortc import RTCPeerConnection, RTCSessionDescription
import websockets
import json

async def play_webrtc_stream():
    websocket_url = "wss://your-server.com:5443/WebRTCAppEE/websocket"
    stream_id = "stream123"
    
    pc = RTCPeerConnection()
    
    @pc.on("track")
    async def on_track(track):
        print(f"Receiving {track.kind} track")
        
        while True:
            frame = await track.recv()
            # Process video/audio frame
            
    async with websockets.connect(websocket_url) as websocket:
        # Send play command
        play_command = {
            "command": "play",
            "streamId": stream_id
        }
        await websocket.send(json.dumps(play_command))
        
        # Handle WebSocket messages
        async for message in websocket:
            data = json.loads(message)
            # Process SDP and ICE candidates

asyncio.run(play_webrtc_stream())