org.kurento.client.IceCandidate Java Examples

private void handleAddIceCandidate(final WebSocketSession session,
    JsonObject jsonMessage)
{
  String sessionId = session.getId();
  UserSession user = users.get(sessionId);

  if (user != null) {
    JsonObject jsonCandidate = jsonMessage.get("candidate").getAsJsonObject();
    IceCandidate candidate =
        new IceCandidate(jsonCandidate.get("candidate").getAsString(),
        jsonCandidate.get("sdpMid").getAsString(),
        jsonCandidate.get("sdpMLineIndex").getAsInt());

    WebRtcEndpoint webRtcEp = user.getWebRtcEndpoint();
    webRtcEp.addIceCandidate(candidate);
  }
}
 

private void internalAddIceCandidate(IceCandidate candidate) throws OpenViduException {
	if (webEndpoint == null) {
		throw new OpenViduException(Code.MEDIA_WEBRTC_ENDPOINT_ERROR_CODE,
				"Can't add existing ICE candidates to null WebRtcEndpoint (ep: " + endpointName + ")");
	}
	this.receivedCandidateList.add(candidate);
	this.webEndpoint.addIceCandidate(candidate, new Continuation<Void>() {
		@Override
		public void onSuccess(Void result) throws Exception {
			log.trace("Ice candidate \"{}\" added to the internal endpoint", candidate.getCandidate());
		}

		@Override
		public void onError(Throwable cause) throws Exception {
			log.warn("EP {}: Failed to add ice candidate \"{}\" to the internal endpoint: {}", endpointName,
					candidate.getCandidate(), cause.getMessage());
		}
	});
}
 

private void handleAddIceCandidate(final WebSocketSession session,
    JsonObject jsonMessage)
{
  final String sessionId = session.getId();
  if (!users.containsKey(sessionId)) {
    log.warn("[Handler::handleAddIceCandidate] Skip, unknown user, id: {}",
        sessionId);
    return;
  }

  final UserSession user = users.get(sessionId);
  final JsonObject jsonCandidate =
      jsonMessage.get("candidate").getAsJsonObject();
  final IceCandidate candidate =
      new IceCandidate(jsonCandidate.get("candidate").getAsString(),
      jsonCandidate.get("sdpMid").getAsString(),
      jsonCandidate.get("sdpMLineIndex").getAsInt());

  WebRtcEndpoint webRtcEp = user.getWebRtcEndpoint();
  webRtcEp.addIceCandidate(candidate);
}
 

private void internalAddIceCandidate(IceCandidate candidate) throws RoomException {
  if (webEndpoint == null) {
    throw new RoomException(Code.MEDIA_WEBRTC_ENDPOINT_ERROR_CODE,
        "Can't add existing ICE candidates to null WebRtcEndpoint (ep: " + endpointName + ")");
  }
  this.webEndpoint.addIceCandidate(candidate, new Continuation<Void>() {
    @Override
    public void onSuccess(Void result) throws Exception {
      log.trace("Ice candidate added to the internal endpoint");
    }

    @Override
    public void onError(Throwable cause) throws Exception {
      log.warn("EP {}: Failed to add ice candidate to the internal endpoint", endpointName, cause);
    }
  });
}
 

@Override
public void onIceCandidate(Participant participant, String endpointName, String candidate, int sdpMLineIndex,
		String sdpMid, Integer transactionId) {
	try {
		KurentoParticipant kParticipant = (KurentoParticipant) participant;
		log.debug("Request [ICE_CANDIDATE] endpoint={} candidate={} " + "sdpMLineIdx={} sdpMid={} ({})",
				endpointName, candidate, sdpMLineIndex, sdpMid, participant.getParticipantPublicId());
		kParticipant.addIceCandidate(endpointName, new IceCandidate(candidate, sdpMid, sdpMLineIndex));
		sessionEventsHandler.onRecvIceCandidate(participant, transactionId, null);
	} catch (OpenViduException e) {
		log.error("PARTICIPANT {}: Error receiving ICE " + "candidate (epName={}, candidate={})",
				participant.getParticipantPublicId(), endpointName, candidate, e);
		sessionEventsHandler.onRecvIceCandidate(participant, transactionId, e);
	}
}
 

public void addCandidate(IceCandidate candidate) {
  if (this.webRtcEndpoint != null) {
    this.webRtcEndpoint.addIceCandidate(candidate);
  } else {
    candidateList.add(candidate);
  }

  if (this.playingWebRtcEndpoint != null) {
    this.playingWebRtcEndpoint.addIceCandidate(candidate);
  }
}
 

public void setWebRtcEndpoint(WebRtcEndpoint webRtcEndpoint) {
  this.webRtcEndpoint = webRtcEndpoint;

  if (this.webRtcEndpoint != null) {
    for (IceCandidate e : candidateList) {
      this.webRtcEndpoint.addIceCandidate(e);
    }
    this.candidateList.clear();
  }
}
 

@Override
public void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
  final JsonObject jsonMessage = gson.fromJson(message.getPayload(), JsonObject.class);

  final UserSession user = registry.getBySession(session);

  if (user != null) {
    log.debug("Incoming message from user '{}': {}", user.getName(), jsonMessage);
  } else {
    log.debug("Incoming message from new user: {}", jsonMessage);
  }

  switch (jsonMessage.get("id").getAsString()) {
    case "joinRoom":
      joinRoom(jsonMessage, session);
      break;
    case "receiveVideoFrom":
      final String senderName = jsonMessage.get("sender").getAsString();
      final UserSession sender = registry.getByName(senderName);
      final String sdpOffer = jsonMessage.get("sdpOffer").getAsString();
      user.receiveVideoFrom(sender, sdpOffer);
      break;
    case "leaveRoom":
      leaveRoom(user);
      break;
    case "onIceCandidate":
      JsonObject candidate = jsonMessage.get("candidate").getAsJsonObject();

      if (user != null) {
        IceCandidate cand = new IceCandidate(candidate.get("candidate").getAsString(),
            candidate.get("sdpMid").getAsString(), candidate.get("sdpMLineIndex").getAsInt());
        user.addCandidate(cand, jsonMessage.get("name").getAsString());
      }
      break;
    default:
      break;
  }
}
 

public void addCandidate(IceCandidate candidate, String name) {
  if (this.name.compareTo(name) == 0) {
    outgoingMedia.addIceCandidate(candidate);
  } else {
    WebRtcEndpoint webRtc = incomingMedia.get(name);
    if (webRtc != null) {
      webRtc.addIceCandidate(candidate);
    }
  }
}
 

public void setWebRtcEndpoint(WebRtcEndpoint webRtcEndpoint) {
  this.webRtcEndpoint = webRtcEndpoint;

  for (IceCandidate e : candidateList) {
    this.webRtcEndpoint.addIceCandidate(e);
  }
  this.candidateList.clear();
}
 

public void addCandidate(IceCandidate candidate) {
  if (this.webRtcEndpoint != null) {
    this.webRtcEndpoint.addIceCandidate(candidate);
  } else {
    candidateList.add(candidate);
  }
}
 

/**
 * Add a new {@link IceCandidate} received gathered by the remote peer of this
 * {@link WebRtcEndpoint}.
 *
 * @param candidate
 *          the remote candidate
 */
public synchronized void addIceCandidate(IceCandidate candidate) throws RoomException {
  if (!this.isWeb()) {
    throw new RoomException(Code.MEDIA_NOT_A_WEB_ENDPOINT_ERROR_CODE, "Operation not supported");
  }
  if (webEndpoint == null) {
    candidates.addLast(candidate);
  } else {
    internalAddIceCandidate(candidate);
  }
}
 

public void setWebRtcEndpoint(WebRtcEndpoint webRtcEndpoint) {
  this.webRtcEndpoint = webRtcEndpoint;

  if (this.webRtcEndpoint != null) {
    for (IceCandidate e : candidateList) {
      this.webRtcEndpoint.addIceCandidate(e);
    }
    this.candidateList.clear();
  }
}
 

public void addIceCandidate(String endpointName, IceCandidate iceCandidate) {
  if (this.name.equals(endpointName)) {
    this.publisher.addIceCandidate(iceCandidate);
  } else {
    this.getNewOrExistingSubscriber(endpointName).addIceCandidate(iceCandidate);
  }
}
 

public void addCandidate(IceCandidate candidate) {
  if (this.webRtcEndpoint != null) {
    this.webRtcEndpoint.addIceCandidate(candidate);
  } else {
    candidateList.add(candidate);
  }

  if (this.playingWebRtcEndpoint != null) {
    this.playingWebRtcEndpoint.addIceCandidate(candidate);
  }
}
 

public void addCandidate(IceCandidate candidate, String uid) {
	if (this.uid.equals(uid)) {
		outgoingMedia.addIceCandidate(candidate);
	} else {
		WebRtcEndpoint endpoint = listeners.get(uid);
		log.debug("Add candidate for {}, listener found ? {}", uid, endpoint != null);
		if (endpoint != null) {
			endpoint.addIceCandidate(candidate);
		}
	}
}
 

@Override
public void onIceCandidate(String roomName, String participantId, String endpointName,
    IceCandidate candidate) {
  JsonObject params = new JsonObject();
  params.addProperty(ProtocolElements.ICECANDIDATE_EPNAME_PARAM, endpointName);
  params.addProperty(ProtocolElements.ICECANDIDATE_SDPMLINEINDEX_PARAM,
      candidate.getSdpMLineIndex());
  params.addProperty(ProtocolElements.ICECANDIDATE_SDPMID_PARAM, candidate.getSdpMid());
  params.addProperty(ProtocolElements.ICECANDIDATE_CANDIDATE_PARAM, candidate.getCandidate());
  notifService.sendNotification(participantId, ProtocolElements.ICECANDIDATE_METHOD, params);
}
 

public void onIceCandidate(String roomName, String participantPrivateId, String senderPublicId, String endpointName,
		IceCandidate candidate) {
	JsonObject params = new JsonObject();

	params.addProperty(ProtocolElements.ICECANDIDATE_SENDERCONNECTIONID_PARAM, senderPublicId);
	params.addProperty(ProtocolElements.ICECANDIDATE_EPNAME_PARAM, endpointName);
	params.addProperty(ProtocolElements.ICECANDIDATE_SDPMLINEINDEX_PARAM, candidate.getSdpMLineIndex());
	params.addProperty(ProtocolElements.ICECANDIDATE_SDPMID_PARAM, candidate.getSdpMid());
	params.addProperty(ProtocolElements.ICECANDIDATE_CANDIDATE_PARAM, candidate.getCandidate());
	rpcNotificationService.sendNotification(participantPrivateId, ProtocolElements.ICECANDIDATE_METHOD, params);
}
 

private void addIceListener(IWsClient inClient) {
	webRtcEndpoint.addIceCandidateFoundListener(evt -> {
			IceCandidate cand = evt.getCandidate();
			WebSocketHelper.sendClient(inClient, newTestKurentoMsg()
					.put("id", "iceCandidate")
					.put(PARAM_CANDIDATE, new JSONObject()
							.put(PARAM_CANDIDATE, cand.getCandidate())
							.put("sdpMid", cand.getSdpMid())
							.put("sdpMLineIndex", cand.getSdpMLineIndex())));
		});
}
 

void onMessage(IWsClient c, final String cmdId, JSONObject msg) {
	KTestStream user = getByUid(c.getUid());
	switch (cmdId) {
		case "wannaRecord":
			WebSocketHelper.sendClient(c, newTestKurentoMsg()
					.put("id", "canRecord")
					.put(PARAM_ICE, kHandler.getTurnServers(null, true))
					);
			break;
		case "record":
			if (user != null) {
				user.release(this);
			}
			user = new KTestStream(c, msg, createTestPipeline());
			streamByUid.put(c.getUid(), user);
			break;
		case "iceCandidate":
			JSONObject candidate = msg.getJSONObject(PARAM_CANDIDATE);
			if (user != null) {
				IceCandidate cand = new IceCandidate(candidate.getString(PARAM_CANDIDATE),
						candidate.getString("sdpMid"), candidate.getInt("sdpMLineIndex"));
				user.addCandidate(cand);
			}
			break;
		case "wannaPlay":
			WebSocketHelper.sendClient(c, newTestKurentoMsg()
					.put("id", "canPlay")
					.put(PARAM_ICE, kHandler.getTurnServers(null, true))
					);
			break;
		case "play":
			if (user != null) {
				user.play(c, msg, createTestPipeline());
			}
			break;
		default:
			//no-op
			break;
	}
}
 

/**
 * If supported, it registers a listener for when a new {@link IceCandidate} is
 * gathered by the internal endpoint ({@link WebRtcEndpoint}) and sends it to
 * the remote User Agent as a notification using the messaging capabilities of
 * the {@link Participant}.
 *
 * @see WebRtcEndpoint#addOnIceCandidateListener(org.kurento.client.EventListener)
 * @see Participant#sendIceCandidate(String, IceCandidate)
 * @throws OpenViduException if thrown, unable to register the listener
 */
protected void registerOnIceCandidateEventListener(String senderPublicId) throws OpenViduException {
	if (!this.isWeb()) {
		return;
	}
	if (webEndpoint == null) {
		throw new OpenViduException(Code.MEDIA_WEBRTC_ENDPOINT_ERROR_CODE,
				"Can't register event listener for null WebRtcEndpoint (ep: " + endpointName + ")");
	}
	webEndpoint.addIceCandidateFoundListener(event -> {
		final IceCandidate candidate = event.getCandidate();
		gatheredCandidateList.add(candidate);
		owner.sendIceCandidate(senderPublicId, endpointName, candidate);
	});
}
 

public void addIceCandidate(String endpointName, IceCandidate iceCandidate) {
	if (this.getParticipantPublicId().equals(endpointName)) {
		this.publisher.addIceCandidate(iceCandidate);
	} else {
		this.getNewOrExistingSubscriber(endpointName).addIceCandidate(iceCandidate);
	}
}
 

/**
 * Add a new {@link IceCandidate} received gathered by the remote peer of this
 * {@link WebRtcEndpoint}.
 *
 * @param candidate the remote candidate
 */
public synchronized void addIceCandidate(IceCandidate candidate) throws OpenViduException {
	if (!this.isWeb()) {
		throw new OpenViduException(Code.MEDIA_NOT_A_WEB_ENDPOINT_ERROR_CODE, "Operation not supported");
	}
	if (webEndpoint == null) {
		candidates.addLast(candidate);
	} else {
		internalAddIceCandidate(candidate);
	}
}
 

private void onIceCandidate(String sessionId, JsonObject jsonMessage) {
  UserSession user = users.get(sessionId);

  if (user != null) {
    JsonObject jsonCandidate = jsonMessage.get("candidate").getAsJsonObject();
    IceCandidate candidate =
        new IceCandidate(jsonCandidate.get("candidate").getAsString(), jsonCandidate
            .get("sdpMid").getAsString(), jsonCandidate.get("sdpMLineIndex").getAsInt());
    user.getWebRtcEndpoint().addIceCandidate(candidate);
  }
}
 

public void addCandidate(IceCandidate candidate) {
  webRtcEndpoint.addIceCandidate(candidate);
}
 

@Override
public void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
  JsonObject jsonMessage = gson.fromJson(message.getPayload(), JsonObject.class);
  UserSession user = registry.getBySession(session);

  if (user != null) {
    log.debug("Incoming message from user '{}': {}", user.getName(), jsonMessage);
  } else {
    log.debug("Incoming message from new user: {}", jsonMessage);
  }

  switch (jsonMessage.get("id").getAsString()) {
    case "register":
      register(session, jsonMessage);
      break;
    case "call":
      call(user, jsonMessage);
      break;
    case "incomingCallResponse":
      incomingCallResponse(user, jsonMessage);
      break;
    case "play":
      play(user, jsonMessage);
      break;
    case "onIceCandidate": {
      JsonObject candidate = jsonMessage.get("candidate").getAsJsonObject();

      if (user != null) {
        IceCandidate cand =
            new IceCandidate(candidate.get("candidate").getAsString(), candidate.get("sdpMid")
                .getAsString(), candidate.get("sdpMLineIndex").getAsInt());
        user.addCandidate(cand);
      }
      break;
    }
    case "stop":
      stop(session);
      releasePipeline(user);
      break;
    case "stopPlay":
      releasePipeline(user);
      break;
    default:
      break;
  }
}
 

public void addCandidate(IceCandidate candidate) {
  webRtcEndpoint.addIceCandidate(candidate);
}
 

public void addCandidate(IceCandidate candidate) {
  webRtcEndpoint.addIceCandidate(candidate);
}
 

@Override
public void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
  JsonObject jsonMessage = gson.fromJson(message.getPayload(), JsonObject.class);

  log.debug("Incoming message: {}", jsonMessage);

  UserSession user = registry.getBySession(session);
  if (user != null) {
    log.debug("Incoming message from user '{}': {}", user.getId(), jsonMessage);
  } else {
    log.debug("Incoming message from new user: {}", jsonMessage);
  }

  switch (jsonMessage.get("id").getAsString()) {
    case "start":
      start(session, jsonMessage);
      break;
    case "stop":
    case "stopPlay":
      if (user != null) {
        user.release();
      }
      break;
    case "play":
      play(user, session, jsonMessage);
      break;
    case "onIceCandidate": {
      JsonObject jsonCandidate = jsonMessage.get("candidate").getAsJsonObject();

      if (user != null) {
        IceCandidate candidate = new IceCandidate(jsonCandidate.get("candidate").getAsString(),
            jsonCandidate.get("sdpMid").getAsString(),
            jsonCandidate.get("sdpMLineIndex").getAsInt());
        user.addCandidate(candidate);
      }
      break;
    }
    default:
      sendError(session, "Invalid message with id " + jsonMessage.get("id").getAsString());
      break;
  }
}
 

public void addCandidate(IceCandidate candidate) {
  webRtcEndpoint.addIceCandidate(candidate);
}