session.h

Go to the documentation of this file.

#ifndef SESSION_H
#define SESSION_H

#include "capabilities.h"
#include "config.h"
#include "publisher.h"
#include "subscriber.h"
#include "stream.h"

OTC_BEGIN_DECL

#ifdef DOXYGEN_OTC_SESSION_TYPEDEF

typedef struct otc_session otc_session;
#endif

#ifndef OTC_SESSION_FWD_DECL
#define OTC_SESSION_FWD_DECL
typedef struct otc_session otc_session;
#endif

typedef struct otc_session_settings otc_session_settings;

#define ENCRYPTION_SECRET_MINIMUM_LENGTH 8
#define ENCRYPTION_SECRET_MAXIMUM_LENGTH 256

enum otc_session_error_code {
  OTC_SESSION_AUTHORIZATION_FAILURE =
      1004, 
  OTC_SESSION_BLOCKED_COUNTRY =
      1026, 
  OTC_SESSION_CONNECTION_DROPPED =
      1022, 
  OTC_SESSION_CONNECTION_FAILED =
      1006, 
  OTC_SESSION_CONNECTION_LIMIT_EXCEEDED =
      1027, 
  OTC_SESSION_CONNECTION_REFUSED =
      1023, 
  OTC_SESSION_CONNECTION_TIMED_OUT =
      1021, 
  OTC_SESSION_FORCE_UNPUBLISH_OR_INVALID_STREAM = 1535, 
  OTC_SESSION_ILLEGAL_STATE =
      1015, 
  OTC_SESSION_INTERNAL_ERROR =
      2000, 
  OTC_SESSION_INVALID_SESSION =
      1005, 
  OTC_SESSION_INVALID_SIGNAL_TYPE =
      1461, 
  OTC_SESSION_NOT_CONNECTED =
      1010, 
  OTC_SESSION_NO_MESSAGING_SERVER =
      1503, 
  OTC_SESSION_NULL_OR_INVALID_PARAMETER =
      1011, 
  OTC_SESSION_PUBLISHER_NOT_FOUND =
      1113, 
  OTC_SESSION_SIGNAL_DATA_TOO_LONG =
      1413, 
  OTC_SESSION_SIGNAL_TYPE_TOO_LONG =
      1414, 
  OTC_SESSION_STATE_FAILED = 1020, 
  OTC_SESSION_SUBSCRIBER_NOT_FOUND =
      1112, 
  OTC_SESSION_UNEXPECTED_GET_SESSION_INFO_REPONSE =
      2001, 
  OTC_SESSION_ENCRYPTION_SECRET_MISSING =
      6000, 
  OTC_SESSION_INVALID_ENCRYPTION_SECRET =
      6004, 
};

struct otc_session_capabilities {
  otc_bool publish; 
  otc_bool subscribe; 
  otc_bool force_mute; 
};

struct otc_custom_ice_config {
  int num_ice_servers; 
  char** ice_url;  
  char** ice_user; 
  char** ice_credential; 
  otc_bool force_turn;   
  otc_bool use_custom_turn_only; 
};

struct otc_signal_options {
  otc_bool retry_after_reconnect;
};

struct otc_session_callbacks {
  void (*on_connected)(otc_session* session, void* user_data);

  void (*on_disconnected)(otc_session* session, void* user_data);

  void (*on_connection_created)(otc_session* session,
                                void* user_data,
                                const otc_connection* connection);

  void (*on_connection_dropped)(otc_session* session,
                                void* user_data,
                                const otc_connection* connection);

  void (*on_stream_received)(otc_session* session,
                             void* user_data,
                             const otc_stream* stream);

  void (*on_stream_dropped)(otc_session* session,
                            void* user_data,
                            const otc_stream* stream);
  void (*on_stream_has_audio_changed)(otc_session* session,
                                      void* user_data,
                                      const otc_stream* stream,
                                      otc_bool has_audio);

  void (*on_stream_has_video_changed)(otc_session* session,
                                      void* user_data,
                                      const otc_stream* stream,
                                      otc_bool has_video);
  void (*on_stream_has_captions_changed)(otc_session* session,
                                         void* user_data,
                                         const otc_stream* stream,
                                         otc_bool has_captions);

  void (*on_stream_video_dimensions_changed)(otc_session* session,
                                             void* user_data,
                                             const otc_stream* stream,
                                             int width,
                                             int height);

  void (*on_stream_video_type_changed)(otc_session* session,
                                       void* user_data,
                                       const otc_stream* stream,
                                       enum otc_stream_video_type type);
  void (*on_signal_received)(otc_session* session,
                             void* user_data,
                             const char* type,
                             const char* signal,
                             const otc_connection* connection);

  void (*on_reconnection_started)(otc_session* session, void* user_data);

  void (*on_reconnected)(otc_session* session, void* user_data);

  void (*on_archive_started)(otc_session* session,
                             void* user_data,
                             const char* archive_id,
                             const char* name);

  void (*on_archive_stopped)(otc_session* session,
                             void* user_data,
                             const char* archive_id);
  void (*on_error)(otc_session* session,
                   void* user_data,
                   const char* error_string,
                   enum otc_session_error_code error);

  void (*on_mute_forced)(otc_session *session,
                        void *user_data,
                        otc_on_mute_forced_info *mute_info);

  void* user_data;

  void* reserved;
};

OTC_DECL(otc_session*)
otc_session_new(const char* apikey,
                const char* session_id,
                const struct otc_session_callbacks* callbacks);

OTC_DECL(otc_session_settings*) otc_session_settings_new(void);

OTC_DECL(otc_status)
otc_session_settings_set_connection_events_suppressed(
    otc_session_settings* settings,
    otc_bool suppress);

OTC_DECL(otc_status)
otc_session_settings_set_custom_ice_config(
    otc_session_settings* settings,
    const struct otc_custom_ice_config* custom_ice_config);

OTC_DECL(otc_status)
otc_session_settings_set_proxy_url(otc_session_settings* settings,
                                   const char* proxy_url);

OTC_DECL(otc_status)
otc_session_settings_set_ip_whitelist(otc_session_settings* settings,
                                      otc_bool ip_whitelist);

OTC_DECL(otc_status)
otc_session_settings_set_single_peer_connection(otc_session_settings* settings,
                                                otc_bool enable);

OTC_DECL(otc_status)
otc_session_settings_delete(otc_session_settings* settings);

OTC_DECL(otc_session*)
otc_session_new_with_settings(const char* apikey,
                              const char* session_id,
                              const struct otc_session_callbacks* callbacks,
                              otc_session_settings* settings);

OTC_DECL(otc_status) otc_session_delete(otc_session* session);

OTC_DECL(otc_status)
otc_session_connect(otc_session* session, const char* token);

OTC_DECL(otc_status) otc_session_disconnect(otc_session* session);

OTC_DECL(otc_status)
otc_session_publish(otc_session* session, otc_publisher* publisher);

OTC_DECL(otc_status)
otc_session_unpublish(otc_session* session, otc_publisher* publisher);

OTC_DECL(otc_status)
otc_session_subscribe(otc_session* session, otc_subscriber* subscriber);

OTC_DECL(otc_status)
otc_session_unsubscribe(otc_session* session, otc_subscriber* subscriber);

OTC_DECL(otc_status)
otc_session_send_signal(otc_session* session,
                        const char* type,
                        const char* signal);

OTC_DECL(otc_status)
otc_session_force_mute_all(otc_session *session,
                           const char** excluded_streams_ids,
                           const int excluded_streams_len);

OTC_DECL(otc_status)
otc_session_disable_force_mute(otc_session *session);


OTC_DECL(otc_status)
otc_session_force_mute_stream(const otc_session *session,
                              const char *stream_id_to_mute);


OTC_DECL(otc_status)
otc_session_send_signal_to_connection(otc_session* session,
                                      const char* type,
                                      const char* signal,
                                      const otc_connection* connection);

OTC_DECL(otc_status)
otc_session_send_signal_with_options(otc_session* session,
                                     const char* type,
                                     const char* signal,
                                     struct otc_signal_options signal_options);

OTC_DECL(otc_status)
otc_session_send_signal_to_connection_with_options(
    otc_session* session,
    const char* type,
    const char* signal,
    const otc_connection* connection,
    struct otc_signal_options signal_options);

OTC_DECL(otc_status)
otc_session_report_issue(struct otc_session* session,
                         const char* issue_description,
                         char** issue_id);

OTC_DECL(char*) otc_session_get_id(const otc_session* session);

OTC_DECL(otc_connection*)
otc_session_get_connection(const otc_session* session);

OTC_DECL(struct otc_session_capabilities)
otc_session_get_capabilities(const otc_session* session);

OTC_DECL(void*) otc_session_get_user_data(const otc_session* session);

OTC_DECL(otc_status)
otc_session_set_encryption_secret(otc_session* session, const char* secret);

OTC_END_DECL

#endif  // SESSION_H