org.kurento.client.HttpPostEndpoint Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of kurento-client Show documentation
Kurento Client The Kurento Client project allows server applications to control media server resources.
There is a newer version: 7.1.0
/**
 * This file is generated with Kurento-maven-plugin.
 * Please don't edit.
 */
package org.kurento.client;


/**
 *
 * An {@link module:elements.HttpPostEndpoint HttpPostEndpoint} contains SINK pads for AUDIO and VIDEO, which provide access to an HTTP file upload function
 *    This type of endpoint provide unidirectional communications. Its :rom:cls:`MediaSources ` are accessed through the HTTP POST method.
 *
 **/
@org.kurento.client.internal.RemoteClass
public interface HttpPostEndpoint extends HttpEndpoint {


    /**
     * Add a {@link EventListener} for event {@link EndOfStreamEvent}. Synchronous call.
     *
     * @param  listener Listener to be called on EndOfStreamEvent
     * @return ListenerSubscription for the given Listener
     *
     **/
    @org.kurento.client.internal.server.EventSubscription(EndOfStreamEvent.class)
    ListenerSubscription addEndOfStreamListener(EventListener listener);
    /**
     * Add a {@link EventListener} for event {@link EndOfStreamEvent}. Asynchronous call.
     * Calls Continuation<ListenerSubscription> when it has been added.
     *
     * @param listener Listener to be called on EndOfStreamEvent
     * @param cont     Continuation to be called when the listener is registered
     *
     **/
    @org.kurento.client.internal.server.EventSubscription(EndOfStreamEvent.class)
    void addEndOfStreamListener(EventListener listener, Continuation cont);
    
	/**
     * Remove a {@link ListenerSubscription} for event {@link EndOfStreamEvent}. Synchronous call.
     *
     * @param listenerSubscription Listener subscription to be removed
     *
     **/
    @org.kurento.client.internal.server.EventSubscription(EndOfStreamEvent.class)
    void removeEndOfStreamListener(ListenerSubscription listenerSubscription);
    /**
     * Remove a {@link ListenerSubscription} for event {@link EndOfStreamEvent}. Asynchronous call.
     * Calls Continuation<Void> when it has been removed.
     *
     * @param listenerSubscription Listener subscription to be removed
     * @param cont                 Continuation to be called when the listener is removed
     *
     **/
    @org.kurento.client.internal.server.EventSubscription(EndOfStreamEvent.class)
    void removeEndOfStreamListener(ListenerSubscription listenerSubscription, Continuation cont);
    



    public class Builder extends AbstractBuilder {

/**
 *
 * Creates a Builder for HttpPostEndpoint
 *
 **/
    public Builder(org.kurento.client.MediaPipeline mediaPipeline){

      super(HttpPostEndpoint.class,mediaPipeline);

      props.add("mediaPipeline",mediaPipeline);
    }

	public Builder withProperties(Properties properties) {
    	return (Builder)super.withProperties(properties);
  	}

	public Builder with(String name, Object value) {
		return (Builder)super.with(name, value);
	}
	
/**
 *
 * Sets a value for disconnectionTimeout in Builder for HttpPostEndpoint.
 *
 * @param disconnectionTimeout
 *       This is the time that an http endpoint will wait for a reconnection, in case an HTTP connection is lost.
 *
 **/
    public Builder withDisconnectionTimeout(int disconnectionTimeout){
      props.add("disconnectionTimeout",disconnectionTimeout);
      return this;
    }
/**
 *
 * Feed the input stream as-is to the media pipeline, instead of first decoding it.
 *               By default, the input media gets decoded into a raw format before being processed by the media pipeline, because this allows Kurento to keep track of lost keyframes among other quality-control measurements. This of course has a cost in terms of processing power, but ensures that the output streaming will be robust and reliable. It is possible to disable this behavior by using this method, and in that case the encoded stream will be provided directly to the media pipeline, without prior decoding. Enabling this could have a severe effect on stability, because lost video keyframes will not be regenerated; however, this can be very useful to improve performance by greatly reducing the processing load.
 *               Keep in mind that if this option is enabled, the source media and target media MUST share the same format and codec configurations.
 *               We strongly recommend to avoid using this option, because correct behavior cannot be guaranteed.
 *
 **/
    public Builder useEncodedMedia(){
      props.add("useEncodedMedia",Boolean.TRUE);
      return this;
    }
    }


}