org.kurento.client.ListenerSubscription Java Examples

private void addFilterEventListenerInPublisher(KurentoParticipant kParticipant, String eventType)
		throws OpenViduException {
	PublisherEndpoint pub = kParticipant.getPublisher();
	if (!pub.isListenerAddedToFilterEvent(eventType)) {
		final String sessionId = kParticipant.getSessionId();
		final String connectionId = kParticipant.getParticipantPublicId();
		final String streamId = kParticipant.getPublisherStreamId();
		final String filterType = kParticipant.getPublisherMediaOptions().getFilter().getType();
		try {
			ListenerSubscription listener = pub.getFilter().addEventListener(eventType, event -> {
				sessionEventsHandler.onFilterEventDispatched(sessionId, connectionId, streamId, filterType, event,
						kParticipant.getSession().getParticipants(),
						kParticipant.getPublisher().getPartipantsListentingToFilterEvent(eventType));
			});
			pub.storeListener(eventType, listener);
		} catch (Exception e) {
			log.error("Request to addFilterEventListener to stream {} gone wrong. Error: {}", streamId,
					e.getMessage());
			throw new OpenViduException(Code.FILTER_EVENT_LISTENER_NOT_FOUND,
					"Request to addFilterEventListener to stream " + streamId + " gone wrong: " + e.getMessage());
		}
	}
}
 

public void stop() {
  if (recorderEndpoint != null) {
    final CountDownLatch stoppedCountDown = new CountDownLatch(1);
    ListenerSubscription subscriptionId = recorderEndpoint
        .addStoppedListener(new EventListener<StoppedEvent>() {

          @Override
          public void onEvent(StoppedEvent event) {
            stoppedCountDown.countDown();
          }
        });
    recorderEndpoint.stop();
    try {
      if (!stoppedCountDown.await(5, TimeUnit.SECONDS)) {
        log.error("Error waiting for recorder to stop");
      }
    } catch (InterruptedException e) {
      log.error("Exception while waiting for state change", e);
    }
    recorderEndpoint.removeStoppedListener(subscriptionId);
  }
}
 

/**
 * Registers a listener for when the {@link MediaElement} triggers an
 * {@link ErrorEvent}. Notifies the owner with the error.
 *
 * @param element the {@link MediaElement}
 * @return {@link ListenerSubscription} that can be used to deregister the
 *         listener
 */
protected ListenerSubscription registerElemErrListener(MediaElement element) {
	return element.addErrorListener(new EventListener<ErrorEvent>() {
		@Override
		public void onEvent(ErrorEvent event) {
			owner.sendMediaError(event);
		}
	});
}
 

/**
 * Registers a listener for when the {@link MediaElement} triggers an {@link ErrorEvent}. Notifies
 * the owner with the error.
 *
 * @param element
 *          the {@link MediaElement}
 * @return {@link ListenerSubscription} that can be used to deregister the listener
 */
protected ListenerSubscription registerElemErrListener(MediaElement element) {
  return element.addErrorListener(new EventListener<ErrorEvent>() {
    @Override
    public void onEvent(ErrorEvent event) {
      owner.sendMediaError(event);
    }
  });
}
 

public boolean storeListener(String eventType, ListenerSubscription listener) {
	return (this.filterListeners.putIfAbsent(eventType, listener) == null);
}
 

public ListenerSubscription removeListener(String eventType) {
	// Clean all participant subscriptions to this event
	this.subscribersToFilterEvents.remove(eventType);
	// Clean ListenerSubscription object for this event
	return this.filterListeners.remove(eventType);
}
 

void addSampleListener(EventListener<SampleEvent> listener,
Continuation<ListenerSubscription> cont);
 

@Test
public void testEventEndOfStream() throws InterruptedException {

  AsyncResultManager<ListenerSubscription> asyncListener =
      new AsyncResultManager<>("EndOfStream Listener registration");

  AsyncEventManager<EndOfStreamEvent> asyncEvent = new AsyncEventManager<>("EndOfStream event");

  player.addEndOfStreamListener(asyncEvent.getMediaEventListener(),
      asyncListener.getContinuation());

  asyncListener.waitForResult();

  player.play();

  asyncEvent.waitForResult();
}
 

/**
 * Unregisters the error listener from the media element using the provided
 * subscription.
 *
 * @param element      the {@link MediaElement}
 * @param subscription the associated {@link ListenerSubscription}
 */
protected void unregisterElementErrListener(MediaElement element, final ListenerSubscription subscription) {
	if (element == null || subscription == null) {
		return;
	}
	element.removeErrorListener(subscription);
}
 

/**
 * Unregisters the error listener from the media element using the provided subscription.
 *
 * @param element
 *          the {@link MediaElement}
 * @param subscription
 *          the associated {@link ListenerSubscription}
 */
protected void unregisterElementErrListener(MediaElement element,
    final ListenerSubscription subscription) {
  if (element == null || subscription == null) {
    return;
  }
  element.removeErrorListener(subscription);
}
 

ListenerSubscription addSampleListener(EventListener<SampleEvent> listener);