~~Title: Efl.Net.Dialer_Websocket~~
====== Efl.Net.Dialer_Websocket (class) ======

===== Description =====

%%WebSocket Dialer (Client).%%

%%The WebSocket Protocol (https://tools.ietf.org/html/rfc6455) is a message-based protocol over HTTP, this allows it to leverage on authentication, cookies, proxies and SSL/TLS.%%

%%Although it uses the HTTP dialer, it's not a subclass and thus not all HTTP features are exposed as the WebSocket has strict requirements that must be respected.%%

%%If the proxy is %%''NULL''%% (default), then the system proxy will be used. On UNIX that's the environment variable %%''http_proxy''%% (or '%%''all_proxy''%%') is used if the given address doesn't match %%''no_proxy''%% patterns. To disable the proxy use an empty string. If provided, the proxy must be one of the following protocols:%%

%%- http://username:password@proxyserver:port - http://username@proxyserver:port - http://proxyserver:port - http://proxyserver  (default port 1080) - socks5://username:password@proxyserver:port (SOCKSv5) - socks5h://username@proxyserver:port (let socks server to resolve domain) - socks5://proxyserver:port - socks5://proxyserver (default port 1080) - socks4a://proxyserver:port (SOCKSv4 and let socks server to resolve domain) - socks4://proxyserver:port (SOCKSv4)%%

{{page>:develop:api-include:efl:net:dialer_websocket:description&nouser&nolink&nodate}}

===== Inheritance =====

 => [[:develop:api:efl:loop_consumer|Efl.Loop_Consumer]] //(class)// => [[:develop:api:efl:object|Efl.Object]] //(class)//
++++ Full hierarchy |

  * [[:develop:api:efl:loop_consumer|Efl.Loop_Consumer]] //(class)//
    * [[:develop:api:efl:object|Efl.Object]] //(class)//
  * [[:develop:api:efl:net:dialer|Efl.Net.Dialer]] //(interface)//
    * [[:develop:api:efl:net:socket|Efl.Net.Socket]] //(interface)//
      * [[:develop:api:efl:io:reader|Efl.Io.Reader]] //(interface)//
      * [[:develop:api:efl:io:writer|Efl.Io.Writer]] //(interface)//
      * [[:develop:api:efl:io:closer|Efl.Io.Closer]] //(interface)//


++++
===== Members =====

**[[:develop:api:efl:net:dialer_websocket:property:address_dial|address_dial]]** //**(get, set)**// ''protected set''// [Overridden from [[:develop:api:efl:net:dialer|Efl.Net.Dialer]]]//\\
> %%Returns the address given to %%[[:develop:api:efl:net:dialer:method:dial|Efl.Net.Dialer.dial]]%%.%%
<code c>
const char *efl_net_dialer_address_dial_get(const Eo *obj);
void efl_net_dialer_address_dial_set(Eo *obj, const char *address);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:address_local|address_local]]** //**(get, set)**// ''protected set''// [Overridden from [[:develop:api:efl:net:socket|Efl.Net.Socket]]]//\\
> %%The local address, similar to getsockname().%%
<code c>
const char *efl_net_socket_address_local_get(const Eo *obj);
void efl_net_socket_address_local_set(Eo *obj, const char *address);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:address_remote|address_remote]]** //**(get, set)**// ''protected set''// [Overridden from [[:develop:api:efl:net:socket|Efl.Net.Socket]]]//\\
> %%The remote address, similar to getpeername().%%
<code c>
const char *efl_net_socket_address_remote_get(const Eo *obj);
void efl_net_socket_address_remote_set(Eo *obj, const char *address);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:allow_redirects|allow_redirects]]** //**(get, set)**//\\
> %%Allows HTTP redirects to be followed.%%
<code c>
Eina_Bool efl_net_dialer_websocket_allow_redirects_get(const Eo *obj);
void efl_net_dialer_websocket_allow_redirects_set(Eo *obj, Eina_Bool allow_redirects);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:authentication|authentication]]** //**(get, set)**//\\
> %%HTTP authentication to use.%%
<code c>
void efl_net_dialer_websocket_authentication_get(const Eo *obj, const char **username, const char **password, Efl_Net_Http_Authentication_Method *method, Eina_Bool *restricted);
void efl_net_dialer_websocket_authentication_set(Eo *obj, const char *username, const char *password, Efl_Net_Http_Authentication_Method method, Eina_Bool restricted);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:binary_send|binary_send]]**\\
> %%Sends a binary blob (opcode=0x2) to the server.%%
<code c>
void efl_net_dialer_websocket_binary_send(Eo *obj, const Eina_Slice blob);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:can_read|can_read]]** //**(get, set)**// ''protected set''// [Overridden from [[:develop:api:efl:io:reader|Efl.Io.Reader]]]//\\
> %%If %%''true''%% will notify %%[[:develop:api:efl:io:reader:method:read|Efl.Io.Reader.read]]%% can be called without blocking or failing.%%
<code c>
Eina_Bool efl_io_reader_can_read_get(const Eo *obj);
void efl_io_reader_can_read_set(Eo *obj, Eina_Bool can_read);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:can_write|can_write]]** //**(get, set)**// ''protected set''// [Overridden from [[:develop:api:efl:io:writer|Efl.Io.Writer]]]//\\
> %%If %%''true''%% will notify %%[[:develop:api:efl:io:writer:method:write|Efl.Io.Writer.write]]%% can be called without blocking or failing.%%
<code c>
Eina_Bool efl_io_writer_can_write_get(const Eo *obj);
void efl_io_writer_can_write_set(Eo *obj, Eina_Bool can_write);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:close|close]]**// [Overridden from [[:develop:api:efl:io:closer|Efl.Io.Closer]]]//\\
> %%Closes the Input/Output object.%%
<code c>
Eina_Error efl_io_closer_close(Eo *obj);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:close_on_exec|close_on_exec]]** //**(get, set)**//// [Overridden from [[:develop:api:efl:io:closer|Efl.Io.Closer]]]//\\
> %%If true will automatically close resources on exec() calls.%%
<code c>
Eina_Bool efl_io_closer_close_on_exec_get(const Eo *obj);
Eina_Bool efl_io_closer_close_on_exec_set(Eo *obj, Eina_Bool close_on_exec);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:close_on_invalidate|close_on_invalidate]]** //**(get, set)**//// [Overridden from [[:develop:api:efl:io:closer|Efl.Io.Closer]]]//\\
> %%If true will automatically close() on object invalidate.%%
<code c>
Eina_Bool efl_io_closer_close_on_invalidate_get(const Eo *obj);
void efl_io_closer_close_on_invalidate_set(Eo *obj, Eina_Bool close_on_invalidate);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:close_request|close_request]]**\\
> %%Requests (opcode=0x8) the server to terminate the connection.%%
<code c>
void efl_net_dialer_websocket_close_request(Eo *obj, Efl_Net_Dialer_Websocket_Close_Reason reason, const char *message);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:closed|closed]]** //**(get)**//// [Overridden from [[:develop:api:efl:io:closer|Efl.Io.Closer]]]//\\
> 
<code c>
Eina_Bool efl_io_closer_closed_get(const Eo *obj);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:connected|connected]]** //**(get, set)**// ''protected set''// [Overridden from [[:develop:api:efl:net:dialer|Efl.Net.Dialer]]]//\\
> %%Returns whenever the socket is connected or not.%%
<code c>
Eina_Bool efl_net_dialer_connected_get(const Eo *obj);
void efl_net_dialer_connected_set(Eo *obj, Eina_Bool connected);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:constructor|constructor]]**// [Overridden from [[:develop:api:efl:object|Efl.Object]]]//\\
> %%Implement this method to provide optional initialization code for your object.%%
<code c>
Efl_Object *efl_constructor(Eo *obj);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:cookie_jar|cookie_jar]]** //**(get, set)**//\\
> %%This property sets the filename where to read and write cookies.%%
<code c>
const char *efl_net_dialer_websocket_cookie_jar_get(const Eo *obj);
void efl_net_dialer_websocket_cookie_jar_set(Eo *obj, const char *path);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:destructor|destructor]]**// [Overridden from [[:develop:api:efl:object|Efl.Object]]]//\\
> %%Implement this method to provide deinitialization code for your object if you need it.%%
<code c>
void efl_destructor(Eo *obj);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:dial|dial]]**// [Overridden from [[:develop:api:efl:net:dialer|Efl.Net.Dialer]]]//\\
> %%Dials to the remote peer.%%
<code c>
Eina_Error efl_net_dialer_dial(Eo *obj, const char *address);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:eos|eos]]** //**(get, set)**// ''protected set''// [Overridden from [[:develop:api:efl:io:reader|Efl.Io.Reader]]]//\\
> %%If %%''true''%% will notify end of stream.%%
<code c>
Eina_Bool efl_io_reader_eos_get(const Eo *obj);
void efl_io_reader_eos_set(Eo *obj, Eina_Bool is_eos);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:invalidate|invalidate]]**// [Overridden from [[:develop:api:efl:object|Efl.Object]]]//\\
> %%Implement this method to perform special actions when your object loses its parent, if you need to.%%
<code c>
void efl_invalidate(Eo *obj);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:ping|ping]]**\\
> %%Sends a PING (opcode=0x9) to the server.%%
<code c>
void efl_net_dialer_websocket_ping(Eo *obj, const char *reason);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:proxy|proxy]]** //**(get, set)**//// [Overridden from [[:develop:api:efl:net:dialer|Efl.Net.Dialer]]]//\\
> %%Controls/retrieves if the dialer should use a proxy.%%
<code c>
const char *efl_net_dialer_proxy_get(const Eo *obj);
void efl_net_dialer_proxy_set(Eo *obj, const char *proxy_url);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:read|read]]**// [Overridden from [[:develop:api:efl:io:reader|Efl.Io.Reader]]]//\\
> %%Reads data into a pre-allocated buffer.%%
<code c>
Eina_Error efl_io_reader_read(Eo *obj, Eina_Rw_Slice rw_slice);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:request_header_add|request_header_add]]**\\
> %%Adds a HTTP request header 'key: value'.%%
<code c>
void efl_net_dialer_websocket_request_header_add(Eo *obj, const char *key, const char *value);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:request_headers_clear|request_headers_clear]]**\\
> %%Clears all request headers.%%
<code c>
void efl_net_dialer_websocket_request_headers_clear(Eo *obj);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:request_headers_get|request_headers_get]]**\\
> %%Returns an iterator to the key-value pairs for request headers%%
<code c>
Eina_Iterator *efl_net_dialer_websocket_request_headers_get(Eo *obj);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:request_protocol_add|request_protocol_add]]**\\
> %%Adds a new WebSocket protocol to the request.%%
<code c>
void efl_net_dialer_websocket_request_protocol_add(Eo *obj, const char *protocol);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:request_protocols_clear|request_protocols_clear]]**\\
> %%Clears all request protocols%%
<code c>
void efl_net_dialer_websocket_request_protocols_clear(Eo *obj);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:request_protocols_get|request_protocols_get]]**\\
> %%Returns an iterator to the requested WebSocket protocols%%
<code c>
Eina_Iterator *efl_net_dialer_websocket_request_protocols_get(Eo *obj);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:response_protocols_get|response_protocols_get]]**\\
> %%Returns an iterator to the server-replied (response) WebSocket protocols it supports%%
<code c>
Eina_Iterator *efl_net_dialer_websocket_response_protocols_get(Eo *obj);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:streaming_mode|streaming_mode]]** //**(get, set)**//\\
> %%Configures how to map streaming APIs to WebSocket.%%
<code c>
Efl_Net_Dialer_Websocket_Streaming_Mode efl_net_dialer_websocket_streaming_mode_get(const Eo *obj);
void efl_net_dialer_websocket_streaming_mode_set(Eo *obj, Efl_Net_Dialer_Websocket_Streaming_Mode streaming_mode);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:text_send|text_send]]**\\
> %%Sends an UTF-8 TEXT (opcode=0x1) to the server.%%
<code c>
void efl_net_dialer_websocket_text_send(Eo *obj, const char *text);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:timeout_dial|timeout_dial]]** //**(get, set)**//// [Overridden from [[:develop:api:efl:net:dialer|Efl.Net.Dialer]]]//\\
> %%The timeout in seconds to use for dialing/connecting.%%
<code c>
double efl_net_dialer_timeout_dial_get(const Eo *obj);
void efl_net_dialer_timeout_dial_set(Eo *obj, double seconds);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:property:user_agent|user_agent]]** //**(get, set)**//\\
> %%The User-Agent to specify.%%
<code c>
const char *efl_net_dialer_websocket_user_agent_get(const Eo *obj);
void efl_net_dialer_websocket_user_agent_set(Eo *obj, const char *user_agent);
</code>
\\
**[[:develop:api:efl:net:dialer_websocket:method:write|write]]**// [Overridden from [[:develop:api:efl:io:writer|Efl.Io.Writer]]]//\\
> %%Writes data from a pre-populated buffer.%%
<code c>
Eina_Error efl_io_writer_write(Eo *obj, Eina_Slice slice, Eina_Slice *remaining);
</code>
\\

==== Inherited ====

^ [[:develop:api:efl:loop_consumer|Efl.Loop_Consumer]] ^^^
|  | **[[:develop:api:efl:loop_consumer:method:future_rejected|future_rejected]]** | %%Creates a new future that is already rejected to a specified error using the %%[[:develop:api:efl:loop_consumer:property:loop|Efl.Loop_Consumer.loop.get]]%%.%% |
|  | **[[:develop:api:efl:loop_consumer:method:future_resolved|future_resolved]]** | %%Creates a new future that is already resolved to a value.%% |
|  | **[[:develop:api:efl:loop_consumer:property:loop|loop]]** //**(get)**// |  |
|  | **[[:develop:api:efl:loop_consumer:property:parent|parent]]** //**(get, set)**// | %%The parent of an object.%% |
|  | **[[:develop:api:efl:loop_consumer:method:promise_new|promise_new]]** | %%Create a new promise with the scheduler coming from the loop provided by this object.%% |
^ [[:develop:api:efl:object|Efl.Object]] ^^^
|  | **[[:develop:api:efl:object:property:allow_parent_unref|allow_parent_unref]]** //**(get, set)**// | %%Allow an object to be deleted by unref even if it has a parent.%% |
|  | **[[:develop:api:efl:object:method:children_iterator_new|children_iterator_new]]** | %%Get an iterator on all children.%% |
|  | **[[:develop:api:efl:object:property:comment|comment]]** //**(get, set)**// | %%A human readable comment for the object.%% |
|  | **[[:develop:api:efl:object:method:composite_attach|composite_attach]]** | %%Make an object a composite object of another.%% |
|  | **[[:develop:api:efl:object:method:composite_detach|composite_detach]]** | %%Detach a composite object from another object.%% |
|  | **[[:develop:api:efl:object:method:composite_part_is|composite_part_is]]** | %%Check if an object is part of a composite object.%% |
|  | **[[:develop:api:efl:object:method:debug_name_override|debug_name_override]]** | %%Build a read-only name for this object used for debugging.%% |
|  | **[[:develop:api:efl:object:method:event_callback_forwarder_del|event_callback_forwarder_del]]** | %%Remove an event callback forwarder for a specified event and object.%% |
|  | **[[:develop:api:efl:object:method:event_callback_forwarder_priority_add|event_callback_forwarder_priority_add]]** | %%Add an event callback forwarder that will make this object emit an event whenever another object (%%''source''%%) emits it. The event is said to be forwarded from %%''source''%% to this object.%% |
|  | **[[:develop:api:efl:object:method:event_callback_stop|event_callback_stop]]** | %%Stop the current callback call.%% |
|  | **[[:develop:api:efl:object:method:event_freeze|event_freeze]]** | %%Freeze events of this object.%% |
|  | **[[:develop:api:efl:object:property:event_freeze_count|event_freeze_count]]** //**(get)**// |  |
|  ''static'' | **[[:develop:api:efl:object:method:event_global_freeze|event_global_freeze]]** | %%Globally freeze events for ALL EFL OBJECTS.%% |
|  ''static'' | **[[:develop:api:efl:object:property:event_global_freeze_count|event_global_freeze_count]]** //**(get)**// |  |
|  ''static'' | **[[:develop:api:efl:object:method:event_global_thaw|event_global_thaw]]** | %%Globally thaw events for ALL EFL OBJECTS.%% |
|  | **[[:develop:api:efl:object:method:event_thaw|event_thaw]]** | %%Thaw events of object.%% |
|  | **[[:develop:api:efl:object:method:finalize|finalize]]** | %%Implement this method to finish the initialization of your object after all (if any) user-provided configuration methods have been executed.%% |
|  | **[[:develop:api:efl:object:property:finalized|finalized]]** //**(get)**// |  |
|  | **[[:develop:api:efl:object:property:invalidated|invalidated]]** //**(get)**// |  |
|  | **[[:develop:api:efl:object:property:invalidating|invalidating]]** //**(get)**// |  |
|  | **[[:develop:api:efl:object:property:name|name]]** //**(get, set)**// | %%The name of the object.%% |
|  | **[[:develop:api:efl:object:method:name_find|name_find]]** | %%Find a child object with the given name and return it.%% |
|  | **[[:develop:api:efl:object:method:provider_find|provider_find]]** | %%Searches upwards in the object tree for a provider which knows the given class/interface.%% |
|  | **[[:develop:api:efl:object:method:provider_register|provider_register]]** | %%Will register a manager of a specific class to be answered by %%[[:develop:api:efl:object:method:provider_find|Efl.Object.provider_find]]%%.%% |
|  | **[[:develop:api:efl:object:method:provider_unregister|provider_unregister]]** | %%Will unregister a manager of a specific class that was previously registered and answered by %%[[:develop:api:efl:object:method:provider_find|Efl.Object.provider_find]]%%.%% |

===== Events =====

**[[:develop:api:efl:net:dialer_websocket:event:closed_reason|closed,reason]]**\\
> %%Received a request to close the connection. It may be a reply/confirmation from a local request, see %%[[:develop:api:efl:net:dialer_websocket:method:close_request|Efl.Net.Dialer_Websocket.close_request]]%%, or some server-generated reason. After this point, no more messages are allowed to be sent and no more will be received. %%[[:develop:api:efl:io:closer:method:close|Efl.Io.Closer.close]]%% will be called.%%
<code c>
EFL_NET_DIALER_WEBSOCKET_EVENT_CLOSED_REASON(Efl_Net_Dialer_Websocket_Closed_Reason)
</code>
\\ **[[:develop:api:efl:net:dialer_websocket:event:message_binary|message,binary]]**\\
> %%Received a binary message (opcode=0x2)%%
<code c>
EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_BINARY(const Eina_Slice *)
</code>
\\ **[[:develop:api:efl:net:dialer_websocket:event:message_text|message,text]]**\\
> %%Received a text string message (opcode=0x1)%%
<code c>
EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_TEXT(const char *)
</code>
\\ **[[:develop:api:efl:net:dialer_websocket:event:pong|pong]]**\\
> %%Received a pong (opcode=0xA) with optional message/reason%%
<code c>
EFL_NET_DIALER_WEBSOCKET_EVENT_PONG(const char *)
</code>
\\ ==== Inherited ====

^ [[:develop:api:efl:io:closer|Efl.Io.Closer]] ^^^
|  | **[[:develop:api:efl:io:closer:event:closed|closed]]** | %%Notifies closed, when property is marked as true%% |
^ [[:develop:api:efl:io:reader|Efl.Io.Reader]] ^^^
|  | **[[:develop:api:efl:io:reader:event:can_read_changed|can_read,changed]]** | %%Notifies can_read property changed.%% |
|  | **[[:develop:api:efl:io:reader:event:eos|eos]]** | %%Notifies end of stream, when property is marked as true.%% |
^ [[:develop:api:efl:io:writer|Efl.Io.Writer]] ^^^
|  | **[[:develop:api:efl:io:writer:event:can_write_changed|can_write,changed]]** | %%Notifies can_write property changed.%% |
^ [[:develop:api:efl:net:dialer|Efl.Net.Dialer]] ^^^
|  | **[[:develop:api:efl:net:dialer:event:dialer_connected|dialer,connected]]** | %%Notifies the socket is connected to the remote peer.%% |
|  | **[[:develop:api:efl:net:dialer:event:dialer_error|dialer,error]]** | %%Some error happened and the socket stopped working.%% |
|  | **[[:develop:api:efl:net:dialer:event:dialer_resolved|dialer,resolved]]** | %%Notifies %%[[:develop:api:efl:net:dialer:property:address_dial|Efl.Net.Dialer.address_dial]]%% was resolved to %%[[:develop:api:efl:net:socket:property:address_remote|Efl.Net.Socket.address_remote]]%%.%% |
^ [[:develop:api:efl:object|Efl.Object]] ^^^
|  | **[[:develop:api:efl:object:event:del|del]]** | %%Object is being deleted. See %%[[:develop:api:efl:object:method:destructor|Efl.Object.destructor]]%%.%% |
|  | **[[:develop:api:efl:object:event:destruct|destruct]]** | %%Object has been fully destroyed. It can not be used beyond this point. This event should only serve to clean up any reference you keep to the object.%% |
|  | **[[:develop:api:efl:object:event:invalidate|invalidate]]** | %%Object is being invalidated and losing its parent. See %%[[:develop:api:efl:object:method:invalidate|Efl.Object.invalidate]]%%.%% |
|  | **[[:develop:api:efl:object:event:noref|noref]]** | %%Object has lost its last reference, only parent relationship is keeping it alive. Advanced usage.%% |
|  | **[[:develop:api:efl:object:event:ownership_shared|ownership,shared]]** | %%Object has acquired a second reference. It has multiple owners now. Triggered whenever increasing the refcount from one to two, it will not trigger by further increasing the refcount beyond two.%% |
|  | **[[:develop:api:efl:object:event:ownership_unique|ownership,unique]]** | %%Object has lost a reference and only one is left. It has just one owner now. Triggered whenever the refcount goes from two to one.%% |