Android WebRTC推流至Web的实现疑问及SDP传输相关咨询

Hi there! Let's work through your WebRTC questions step by step, using the Android code you've shared as a starting point.

1. Sending WebRTC Video to a Backend #

WebRTC is built for peer-to-peer communication, but for live streaming to a web audience, you have two practical options depending on your latency and scalability needs:

Option 1: Capture & Upload Encoded Media (For Low-Scale/On-Demand) #

If ultra-low latency isn't critical, you can capture your local WebRTC stream with a media recorder, then upload the recorded file or real-time chunks to your backend. Use WebRTC's built-in MediaRecorder (distinct from Android's native version) for this:

// Get your local media stream from the peer connection
MediaStream localStream = localPeer.getLocalStreams().get(0);

MediaRecorder mediaRecorder = new MediaRecorder(peerConnectionFactory);
mediaRecorder.setMediaStream(localStream);
mediaRecorder.setOutputFile(getExternalFilesDir(null).getAbsolutePath() + "/live_stream.mp4");
mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
mediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);

try {
    mediaRecorder.start();
    // Read the file in chunks and upload to your backend via HTTP/HTTPS
} catch (IllegalStateException e) {
    e.printStackTrace();
    showToast("Failed to start recording");
}

Note: This approach has higher latency and isn't ideal for real-time live streaming.

Option 2: Use an SFU (Recommended for Live Streaming) #

For low-latency, scalable live streaming, deploy a Selective Forwarding Unit (SFU) on your backend (examples: Janus, Mediasoup, Jitsi Videobridge). Here's how it works:

• Your Android app establishes a PeerConnection with the SFU and pushes your local stream to it.
• Web viewers create their own PeerConnections with the SFU to pull the stream.
• The SFU efficiently routes streams to multiple viewers without overwhelming your Android device.

Your existing WebRTC setup can be adapted to connect to the SFU—you'll just exchange SDP/ICE candidates with the SFU via your backend's API instead of a direct peer.

2. Calling the POST "offer" Endpoint with SDP Details #

You already generate an Offer SDP in your doCall() method—now you just need to package that SDP into a JSON payload and send it to your backend using an HTTP client like OkHttp.

Step 1: Add OkHttp Dependency #

First, add OkHttp to your app's module-level build.gradle:

implementation 'com.squareup.okhttp3:okhttp:4.11.0'

Step 2: Modify Your Offer Success Handler #

Update the onCreateSuccess method in your CustomSdpObserver to send the SDP to your backend:

@Override
public void onCreateSuccess(SessionDescription sessionDescription) {
    super.onCreateSuccess(sessionDescription);
    localPeer.setLocalDescription(new CustomSdpObserver("localSetLocalDesc"), sessionDescription);
    Log.d("onCreateSuccess", "Preparing to send offer");

    // Package SDP into a JSON payload
    JSONObject offerPayload = new JSONObject();
    try {
        offerPayload.put("type", sessionDescription.type.canonicalForm());
        offerPayload.put("sdp", sessionDescription.description);
        // Add metadata like room ID or user identifier if needed
        offerPayload.put("room_id", "your_live_stream_room");
        offerPayload.put("sender", "android_client");
    } catch (JSONException e) {
        e.printStackTrace();
        showToast("Failed to format offer data");
        return;
    }

    // Send POST request to your backend
    OkHttpClient client = new OkHttpClient();
    RequestBody requestBody = RequestBody.create(
        offerPayload.toString(),
        MediaType.parse("application/json; charset=utf-8")
    );

    Request request = new Request.Builder()
        .url("https://your-backend-domain/api/offer") // Replace with your actual endpoint
        .post(requestBody)
        .build();

    client.newCall(request).enqueue(new Callback() {
        @Override
        public void onFailure(Call call, IOException e) {
            e.printStackTrace();
            runOnUiThread(() -> showToast("Failed to send offer to backend"));
        }

        @Override
        public void onResponse(Call call, Response response) throws IOException {
            if (response.isSuccessful()) {
                // Parse the backend's Answer SDP and set it to your local peer
                String responseJson = response.body().string();
                try {
                    JSONObject answerObj = new JSONObject(responseJson);
                    SessionDescription answer = new SessionDescription(
                        SessionDescription.Type.fromCanonicalForm(answerObj.getString("type")),
                        answerObj.getString("sdp")
                    );
                    localPeer.setRemoteDescription(new CustomSdpObserver("localSetRemoteDesc"), answer);
                    runOnUiThread(() -> showToast("Offer sent, answer received"));
                } catch (JSONException e) {
                    e.printStackTrace();
                    runOnUiThread(() -> showToast("Failed to parse answer"));
                }
            } else {
                runOnUiThread(() -> showToast("Backend rejected offer: " + response.code()));
            }
        }
    });
}

Step 3: Handle ICE Candidates #

Don't forget to send ICE candidates to your backend—these are required for the SFU or web peer to establish a connection. Update your onIceCandidateReceived method:

public void onIceCandidateReceived(IceCandidate iceCandidate) {
    JSONObject icePayload = new JSONObject();
    try {
        icePayload.put("candidate", iceCandidate.sdp);
        icePayload.put("sdpMid", iceCandidate.sdpMid);
        icePayload.put("sdpMLineIndex", iceCandidate.sdpMLineIndex);
        icePayload.put("room_id", "your_live_stream_room");
    } catch (JSONException e) {
        e.printStackTrace();
        return;
    }

    OkHttpClient client = new OkHttpClient();
    RequestBody requestBody = RequestBody.create(
        icePayload.toString(),
        MediaType.parse("application/json; charset=utf-8")
    );

    Request request = new Request.Builder()
        .url("https://your-backend-domain/api/ice-candidate")
        .post(requestBody)
        .build();

    client.newCall(request).enqueue(new Callback() {
        @Override
        public void onFailure(Call call, IOException e) {
            e.printStackTrace();
        }

        @Override
        public void onResponse(Call call, Response response) throws IOException {
            // No action needed unless your backend requires confirmation
        }
    });
}

3. Quick Optimizations for Your Existing Code #

• Initialize remotePeer properly: In your current code, remotePeer is declared but never initialized. For SFU streaming, create this PeerConnection once you receive the SFU's Answer SDP.
• Improve permission handling: Instead of calling finish() if permissions are denied, show a toast explaining that camera/audio permissions are required for the app to function.
• Clean up resources: In onDestroy(), ensure you stop video capture, close PeerConnections, and release resources to avoid memory leaks:

  @Override
  protected void onDestroy() {
      super.onDestroy();
      if (videoCapturerAndroid != null) {
          videoCapturerAndroid.stopCapture();
          videoCapturerAndroid.dispose();
      }
      if (localPeer != null) {
          localPeer.close();
      }
      if (remotePeer != null) {
          remotePeer.close();
      }
      if (surfaceTextureHelper != null) {
          surfaceTextureHelper.dispose();
      }
  }
  

内容的提问来源于stack exchange，提问作者Shweta Chauhan