agora_rtc_api.h

Go to the documentation of this file.

/*************************************************************
 *
 * This is a part of the Agora RTC Service SDK.
 * Copyright (C) 2020 Agora IO
 * All rights reserved.
 *
 *************************************************************/
 
#ifndef __AGORA_RTC_API_H__
#define __AGORA_RTC_API_H__
 
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if defined(_MSC_VER)
#if defined(__BUILDING_AGORA_SDK__)
#define __agora_api__ __declspec(dllexport)
#else
#define __agora_api__ __declspec(dllimport)
#endif
#else
#define __agora_api__
#endif
 
#define AGORA_RTC_CHANNEL_NAME_MAX_LEN (64)
#define AGORA_RTC_PRODUCT_ID_MAX_LEN (63)
#define AGORA_RTC_USER_ACCOUNT_MAX_LEN (256)
#define AGORA_RTC_DATA_STREAM_MAX_LEN (1024)
#define AGORA_RTM_UID_MAX_LEN (64)
#define AGORA_RTM_DATA_MAX_LEN (31 * 1024)
#define AGORA_CREDENTIAL_MAX_LEN (256)
#define AGORA_CERTIFICATE_MAX_LEN (1024)
#define AGORA_LICENSE_VALUE_LEN (32)
typedef enum {
/******************************************************************************|
|                               Common(0~99)                                   |
*******************************************************************************/
#if 1 // Common Start
  ERR_OKAY = 0,
  ERR_FAILED = 1,
  ERR_INVALID_PARAM = 2,
  ERR_INVALID_STATE = 3,
  ERR_NOT_SUPPORTED = 4,
  ERR_NOT_IN_CHANNEL = 6,
  ERR_NOT_INITIALIZED = 7,
  ERR_NOT_EXIST_CONNECTION = 8,
  ERR_TIMEDOUT = 10,
  ERR_NO_MEMORY = 11,
  ERR_CALL_FAILED = 12,
  ERR_NET_DOWN = 14,
  ERR_JOIN_CHANNEL_REJECTED = 17,
  ERR_LEAVE_CHANNEL_REJECTED = 18,
  ERR_LICENSE_VERIFICATION_FAILURE = 23,
  ERR_ENCRYPTION = 30,
  ERR_DECRYPTION = 31,
  // Custom packet length failed
  ERR_CUSTOM_PACKET_LENGTH_FAILED = 32,
 
#endif // Common End
 
/******************************************************************************|
|                               RTN(100~199)                                   |
*******************************************************************************/
#if 1 // RTN Start
  ERR_INVALID_APP_ID = 101,
  ERR_INVALID_CHANNEL_NAME = 102,
  ERR_NO_SERVER_RESOURCES = 103,
  ERR_LOOKUP_CHANNEL_REJECTED = 105,
  ERR_OPEN_CHANNEL_REJECTED = 107,
  ERR_TOKEN_EXPIRED = 109,
  ERR_INVALID_TOKEN = 110,
  ERR_DYNAMIC_TOKEN_BUT_USE_STATIC_KEY = 115,
  ERR_SET_CLIENT_ROLE_NOT_AUTHORIZED = 119,
  ERR_DECRYPTION_FAILED = 120,
  ERR_OPEN_CHANNEL_INVALID_TICKET = 121,
  ERR_OPEN_CHANNEL_TRY_NEXT_VOS = 122,
  ERR_CLIENT_IS_BANNED_BY_SERVER = 123,
#endif // RTN End
 
/******************************************************************************|
|                               Audio(200~299)                                 |
*******************************************************************************/
#if 1 // Audio Start
  ERR_AUDIO_CODEC_NOT_SUPPORT = 200,
  ERR_AUDIO_INVALID_PCM_LEN = 201,
  ERR_AUDIO_INVALID_CODEC_PARAM = 202,
#endif // Audio End
 
/******************************************************************************|
|                               Video(300~399)                                 |
*******************************************************************************/
#if 1 // Video Start
  ERR_VIDEO_SEND_OVER_BANDWIDTH_LIMIT = 300,
  ERR_VIDEO_SEND_PACKETIZE_FAILED = 301,
#endif // Video End
 
/******************************************************************************|
|                               RDT(600~620)                                   |
*******************************************************************************/
#if 1 // RDT Start
  ERR_RDT_USER_NOT_EXIST = 600,
  ERR_RDT_USER_NOT_READY = 601,
  ERR_RDT_DATA_BLOCKED = 602,
  ERR_RDT_CMD_EXCEED_LIMIT = 603,
  ERR_RDT_DATA_EXCEED_LIMIT = 604,
#endif // RDT End
 
/******************************************************************************|
|                               DataStream(621~630)                            |
*******************************************************************************/
#if 1 // DataStream Start
  ERR_TOO_MANY_DATA_STREAMS = 621,
  ERR_DATA_STREAM_SIZE_TOO_LARGE = 622,
  ERR_NOT_EXIST_STREAM_ID = 623,
  ERR_DATA_STREAM_BITRATE_LIMIT = 624,
  ERR_DATA_STREAM_SEND_TOO_OFTEN = 625,
  ERR_DATA_STREAM_TIME_OUT = 626,
#endif // DataStream End
 
/******************************************************************************|
|                               RTM(1000~1099)                                 |
*******************************************************************************/
#if 1 // RTM Start
  ERR_RTM_NOT_LOGINED = 1001,
  ERR_RTM_HAD_LOGINED = 1002,
  ERR_RTM_SEND_TO_SELF = 1003,
  ERR_RTM_EXCEED_MSG_SIZE = 1004,
  ERR_RTM_EXCEED_MSG_CNT = 1005,
  ERR_RTM_EXCEED_SND_BUFFER = 1006,
#endif // RTM End
 
} agora_err_code_e;

typedef enum {
  ERR_LICENSE_INVALID = 1,
  ERR_LICENSE_EXPIRE = 2,
  ERR_LICENSE_MINUTES_EXCEED = 3,
  ERR_LICENSE_LIMITED_PERIOD = 4,
  ERR_LICENSE_DIFF_DEVICES = 5,
  ERR_LICENSE_INTERNAL = 99,
} license_err_reason_e;

typedef enum {
  USER_OFFLINE_QUIT = 0,
  USER_OFFLINE_DROPPED = 1,
  USER_OFFLINE_BECOME_AUDIENCE = 2,
} user_offline_reason_e;

typedef enum {
  VIDEO_DATA_TYPE_YUV420 = 0,
  VIDEO_DATA_TYPE_H264 = 2,
  VIDEO_DATA_TYPE_H265 = 3,
  VIDEO_DATA_TYPE_GENERIC = 6,
  VIDEO_DATA_TYPE_GENERIC_JPEG = 20,
} video_data_type_e;

typedef enum {
  VIDEO_FRAME_AUTO_DETECT = 0,
  VIDEO_FRAME_KEY = 3,
  VIDEO_FRAME_DELTA = 4,
} video_frame_type_e;

typedef uint16_t video_frame_rate_e;

typedef enum {
  VIDEO_STREAM_HIGH = 0,
  VIDEO_STREAM_LOW = 1,
} video_stream_type_e;

typedef enum {
  VIDEO_ORIENTATION_0 = 0,
  VIDEO_ORIENTATION_90 = 1,
  VIDEO_ORIENTATION_180 = 2,
  VIDEO_ORIENTATION_270 = 3
} video_orientation_e;

typedef struct {
  video_data_type_e data_type;
  video_stream_type_e stream_type;
  video_frame_type_e frame_type;
  video_frame_rate_e frame_rate;
  video_orientation_e rotation;
} video_frame_info_t;

typedef enum {
  AUDIO_CODEC_DISABLED = 0,
  AUDIO_CODEC_TYPE_OPUS = 1,
  AUDIO_CODEC_TYPE_G722 = 2,
  AUDIO_CODEC_TYPE_G711A = 3,
  AUDIO_CODEC_TYPE_G711U = 4,
} audio_codec_type_e;

typedef enum {
  AUDIO_DATA_TYPE_OPUS = 1,
  AUDIO_DATA_TYPE_OPUSFB = 2,
  AUDIO_DATA_TYPE_PCMA = 3,
  AUDIO_DATA_TYPE_PCMU = 4,
  AUDIO_DATA_TYPE_G722 = 5,
  AUDIO_DATA_TYPE_AACLC_8K = 6,
  AUDIO_DATA_TYPE_AACLC_16K = 7,
  AUDIO_DATA_TYPE_AACLC = 8,
  AUDIO_DATA_TYPE_HEAAC = 9,
  AUDIO_DATA_TYPE_HEAAC2 = 10,
  AUDIO_DATA_TYPE_AACLC_8K_2CH = 11,
  AUDIO_DATA_TYPE_AACLC_16K_2CH = 12,
  AUDIO_DATA_TYPE_AACLC_2CH = 13,
  AUDIO_DATA_TYPE_HEAAC_2CH = 14,
  AUDIO_DATA_TYPE_HEAAC2_2CH = 15,
  AUDIO_DATA_TYPE_AACLC1 = 16,
  AUDIO_DATA_TYPE_AACLC1_2CH = 17,
  AUDIO_DATA_TYPE_HWAAC = 18,
  AUDIO_DATA_TYPE_OPUSSWB = 20,
  AUDIO_DATA_TYPE_OPUSFB_2CH = 21,
  AUDIO_DATA_TYPE_PCM = 100,
  AUDIO_DATA_TYPE_GENERIC = 253,
  AUDIO_DATA_TYPE_UNKNOW = 254,
} audio_data_type_e;

typedef struct {
  audio_data_type_e data_type;
} audio_frame_info_t;

typedef enum {
  RTC_LOG_DEFAULT = 0,
  RTC_LOG_EMERG,
  RTC_LOG_ALERT,
  RTC_LOG_CRIT, // critical information
  RTC_LOG_ERROR,
  RTC_LOG_WARNING,
  RTC_LOG_NOTICE, // default log level is notice
  RTC_LOG_INFO,
  RTC_LOG_DEBUG,
} rtc_log_level_e;

typedef enum {
  AREA_CODE_DEFAULT = 0x00000000,
  AREA_CODE_CN = 0x00000001,
  AREA_CODE_NA = 0x00000002,
  AREA_CODE_EU = 0x00000004,
  AREA_CODE_AS = 0x00000008,
  AREA_CODE_JP = 0x00000010,
  AREA_CODE_IN = 0x00000020,
  AREA_CODE_GLOB = (0xFFFFFFFF),
 
} area_code_e;
 


typedef enum {
  /* Oceania */
  AREA_CODE_OC = 0x00000040,
  /* South-American */
  AREA_CODE_SA = 0x00000080,
  /* Africa */
  AREA_CODE_AF = 0x00000100,
  /* South Korea */
  AREA_CODE_KR = 0x00000200,
  /* Hong Kong and Macou */
  AREA_CODE_HKMC = 0x00000400,
  /* United States */
  AREA_CODE_US = 0x00000800,
  /* Russia */
  AREA_CODE_RU = 0x00001000,
  /* The global area (except China) */
  AREA_CODE_OVS = 0xFFFFFFFE,
} area_code_ex_e;

typedef struct {
  bool log_disable;
  bool log_disable_desensitize;
  rtc_log_level_e log_level;
  const char *log_path;
  const char *log_tag;
  int (*log_printf)(const char *fmt, ...);
} log_config_t;

typedef struct {
  uint32_t area_code;
  char product_id[AGORA_RTC_PRODUCT_ID_MAX_LEN + 1];
  log_config_t log_cfg;
  char license_value[AGORA_LICENSE_VALUE_LEN + 1];
  bool domain_limit;
  
#ifdef CONFIG_RTC_STRING_UID
  bool use_string_uid;
#endif
} rtc_service_option_t;

typedef struct {
  audio_codec_type_e audio_codec_type;
  int pcm_sample_rate;
  int pcm_channel_num;
  int pcm_duration;
} audio_codec_option_t;
 
#ifdef CONFIG_RTC_CRYPT
typedef enum {
  AES_128_XTS = 1,
  AES_128_ECB = 2,
  AES_256_XTS = 3,
  SM4_128_ECB = 4,
  AES_128_GCM = 5,
  AES_256_GCM = 6,
  AES_128_GCM2 = 7, // C has no default value; the Java default is AES_128_GCM2.
  AES_256_GCM2 = 8,
  CRYPTO_MODE_END,
} crypto_mode_e;

typedef struct {
  bool enable;
  crypto_mode_e mode;
  char key[128 + 1];
  uint8_t salt[32];
} crypto_option_t;
 
#endif // End CONFIG_RTC_CRYPT


typedef enum {
  // 1: audio packet type.
  RTC_PACKET_TYPE_AUDIO = 1,
  // 2: video packet type.
  RTC_PACKET_TYPE_VIDEO,
  // 3: rdt packet type.
  RTC_PACKET_TYPE_RDT,
  // 4. rtm packet type
  RTC_PACKET_TYPE_RTM,
  // 5. stream message type
  RTC_PACKET_TYPE_STREAM_MESSAGE,
} rtc_packet_type_e;

typedef struct {
  rtc_packet_type_e type;
  // The packet data. [in/out]
  void *data;
  // The packet data size. [in/out]
  uint16_t size;
} rtc_packet_info_t;


typedef struct {
  bool auto_subscribe_audio;
  bool auto_subscribe_video;
  bool enable_audio_jitter_buffer;
  bool enable_audio_mixer;
  bool enable_audio_decode;
 
  bool enable_audio_ai_qos;

  bool enable_audio_downlink_aec;
  bool enable_audio_downlink_aec_pcm_dump;
  audio_codec_option_t audio_codec_opt;
 
#ifdef CONFIG_RTC_CRYPT
  crypto_option_t crypto_opt;
#endif
 
#ifdef CONFIG_RDT
  bool enable_rdt;
#endif

#ifdef CONFIG_RTC_P2P
  // whether to enable lan accelerate feature
  bool enable_lan_accelerate;
#endif
 
} rtc_channel_options_t;

#ifdef CONFIG_RTC_PROXY
typedef enum {
  CLOUD_PROXY_NONE = 0,
  CLOUD_PROXY_UDP = 1,
  CLOUD_PROXY_TCP = 3,
  CLOUD_PROXY_AUTO = 100,
} cloud_proxy_type_e;
#endif

typedef enum {
  NETWORK_EVENT_DOWN = 0,
  NETWORK_EVENT_UP,
  NETWORK_EVENT_CHANGE,
} network_event_e;
 
 
#ifdef CONFIG_RDT

typedef enum rdt_stream_type {
RDT_STREAM_CMD,
RDT_STREAM_DATA,
RDT_STREAM_COUNT,
} rdt_stream_type_e;

typedef enum rdt_state {
RDT_STATE_CLOSED,
RDT_STATE_OPENED,
RDT_STATE_BLOCKED,
RDT_STATE_PENDING,
RDT_STATE_BROKEN,
} rdt_state_e;

typedef struct rdt_status_info {
uint32_t     conn_id;
uint32_t     peer_uid;
rdt_state_e  state;
int send_queue_size[RDT_STREAM_COUNT];
int recv_queue_size[RDT_STREAM_COUNT];
} rdt_status_info_t;
 
#endif // CONFIG_RDT
typedef uint32_t connection_id_t;
#define CONNECTION_ID_ALL ((connection_id_t)0)
#define CONNECTION_ID_INVALID ((connection_id_t)-1)

typedef struct {
  connection_id_t conn_id;
  uint32_t uid;
  char channel_name[AGORA_RTC_CHANNEL_NAME_MAX_LEN + 1];
} connection_info_t;
 
 
#ifdef CONFIG_RTC_STRING_UID
typedef struct user_info_s {
    uint32_t uid;
    char user_account[AGORA_RTC_USER_ACCOUNT_MAX_LEN];
} user_info_t;
#endif


typedef struct rtc_stats_s {
  uint16_t tx_audio_kbitrate;
  uint16_t tx_video_kbitrate;
  uint16_t rx_audio_kbitrate;
  uint16_t rx_video_kbitrate;
  uint16_t tx_video_input_kbitrate;
  uint16_t lastmile_delay;
  uint16_t user_count;
  bool lan_accelerate_state;
} rtc_stats_t;
 

typedef struct {
  void (*on_error)(connection_id_t conn_id, int code, const char *msg);

  void (*on_join_channel_success)(connection_id_t conn_id, uint32_t uid, int elapsed_ms);
  void (*on_reconnecting)(connection_id_t conn_id);
  void (*on_connection_lost)(connection_id_t conn_id);
  void (*on_rejoin_channel_success)(connection_id_t conn_id, uint32_t uid, int elapsed_ms);
  void (*on_license_validation_failure)(connection_id_t conn_id, int error);

  void (*on_token_privilege_will_expire)(connection_id_t conn_id, const char *token);

  void (*on_user_joined)(connection_id_t conn_id, uint32_t uid, int elapsed_ms);
  void (*on_user_offline)(connection_id_t conn_id, uint32_t uid, int reason);
 
#ifdef CONFIG_RTC_STRING_UID
  void (*on_user_joined_with_user_account)(connection_id_t conn_id, const user_info_t *user, int elapsed_ms);

  void (*on_user_offline_with_user_account)(connection_id_t conn_id, const user_info_t *user, int reason);

  void (*on_user_info_updated)(connection_id_t conn_id, const user_info_t *user);
#endif

  void (*on_user_mute_audio)(connection_id_t conn_id, uint32_t uid, bool muted);

  void (*on_user_mute_video)(connection_id_t conn_id, uint32_t uid, bool muted);

  void (*on_audio_data)(connection_id_t conn_id, uint32_t uid, uint16_t sent_ts, const void *data_ptr, size_t data_len,
                        const audio_frame_info_t *info_ptr);

  void (*on_mixed_audio_data)(connection_id_t conn_id, const void *data_ptr, size_t data_len,
                              const audio_frame_info_t *info_ptr);
 
#ifndef CONFIG_AUDIO_ONLY
  void (*on_video_data)(connection_id_t conn_id, uint32_t uid, uint16_t sent_ts, const void *data_ptr, size_t data_len,
                        const video_frame_info_t *info_ptr);

  void (*on_target_bitrate_changed)(connection_id_t conn_id, uint32_t target_bps);
  void (*on_key_frame_gen_req)(connection_id_t conn_id, uint32_t uid, video_stream_type_e stream_type);
#endif


  void (*on_rtc_stats)(connection_id_t conn_id, rtc_stats_t stats);
 
 
#ifdef CONFIG_RTCM
  void (*on_media_ctrl_msg)(connection_id_t conn_id, uint32_t uid, const void *payload, size_t length);
#endif
 
 
#ifdef CONFIG_RTC_STRING_UID
  void (*on_local_user_registered)(const char *uname, uint32_t uid);
  void (*on_remote_user_registered)(const char *uname, uint32_t uid);
#endif // End of CONFIG_RTC_STRING_UID
 
#ifdef CONFIG_RDT
  void (*on_rdt_state)(connection_id_t conn_id, uint32_t uid, rdt_state_e state);
  void (*on_rdt_msg)(connection_id_t conn_id, uint32_t uid, rdt_stream_type_e type, const void *msg, size_t len);
#endif
 
#ifdef CONFIG_DATA_STREAM
  void (*on_stream_message)(connection_id_t conn_id, uint32_t uid, int stream_id, const char* data, size_t length, uint64_t sent_ts);
#endif


  void (*on_packet_incoming)(connection_id_t conn_id, rtc_packet_info_t *pkt_info);

  void (*on_packet_outgoing)(connection_id_t conn_id, rtc_packet_info_t *pkt_info);
 
} agora_rtc_event_handler_t;

extern const char *agora_rtc_get_version(void);

extern __agora_api__ const char *agora_rtc_err_2_str(int err);
 

#ifdef CONFIG_AHPL_MEM_STAT
extern __agora_api__ int agora_rtc_get_memory_used();
 
#ifdef CONFIG_AHPL_MEM_DUMP
extern __agora_api__ int agora_rtc_dump_memory_info();
#endif // CONFIG_AHPL_MEM_DUMP
#endif // CONFIG_AHPL_MEM_STAT
 
#ifdef CONFIG_LICENSE
extern __agora_api__ int agora_rtc_license_gen_credential(char *credential, unsigned int *credential_len);

extern __agora_api__ int agora_rtc_license_verify(const char *certificate, int certificate_len, const char *credential,
                                                  int credential_len);

extern __agora_api__ const char* agora_rtc_license_strerror(int err);
 
#endif // End CONFIG_LICENSE
extern __agora_api__ int agora_rtc_init(const char *app_id, const agora_rtc_event_handler_t *event_handler,
                                        rtc_service_option_t *option);
extern __agora_api__ int agora_rtc_fini(void);

extern __agora_api__ int agora_rtc_set_log_level(rtc_log_level_e level);

extern __agora_api__ int agora_rtc_config_log(int size_per_file, int max_file_count);

extern __agora_api__ int agora_rtc_create_connection(connection_id_t *conn_id);

extern __agora_api__ int agora_rtc_destroy_connection(connection_id_t conn_id);

extern __agora_api__ int agora_rtc_get_connection_info(connection_id_t conn_id, connection_info_t *conn_info);
 
#ifdef CONFIG_RTC_STRING_UID
extern __agora_api__ int agora_rtc_get_user_info_by_user_account(connection_id_t conn_id, const char *user_account, user_info_t *user);

extern __agora_api__ int agora_rtc_get_user_info_by_uid(connection_id_t conn_id, uint32_t uid, user_info_t *user);
#endif

extern __agora_api__ int agora_rtc_join_channel(connection_id_t conn_id, const char *channel_name, uint32_t uid,
                                                const char *token, rtc_channel_options_t *options);
 
 
#ifdef CONFIG_RTC_STRING_UID
extern __agora_api__ int agora_rtc_join_channel_with_user_account(connection_id_t conn_id, const char *channel_name,
                                                                  const char *user_account, const char *token,
                                                                  rtc_channel_options_t *options);
#endif
                                                

extern __agora_api__ int agora_rtc_leave_channel(connection_id_t conn_id);

extern __agora_api__ int agora_rtc_renew_token(connection_id_t conn_id, const char *token);


extern __agora_api__ int agora_rtc_notify_network_event(network_event_e event);

extern __agora_api__ int agora_rtc_mute_local_audio(connection_id_t conn_id, bool mute);
 
#ifndef CONFIG_AUDIO_ONLY
extern __agora_api__ int agora_rtc_mute_local_video(connection_id_t conn_id, bool mute);
#endif
extern __agora_api__ int agora_rtc_mute_remote_audio(connection_id_t conn_id, uint32_t remote_uid, bool mute);
 
#ifndef CONFIG_AUDIO_ONLY
extern __agora_api__ int agora_rtc_mute_remote_video(connection_id_t conn_id, uint32_t remote_uid, bool mute);

extern __agora_api__ int agora_rtc_request_video_key_frame(connection_id_t conn_id, uint32_t remote_uid,
                                                          video_stream_type_e stream_type);
#endif
extern __agora_api__ int agora_rtc_send_audio_data(connection_id_t conn_id, const void *data_ptr, size_t data_len,
                                                  audio_frame_info_t *info_ptr);
 
#ifndef CONFIG_AUDIO_ONLY
extern __agora_api__ int agora_rtc_send_video_data(connection_id_t conn_id, const void *data_ptr, size_t data_len,
                                                  video_frame_info_t *info_ptr);
extern __agora_api__ int agora_rtc_set_bwe_param(connection_id_t conn_id, uint32_t min_bps, uint32_t max_bps,
                                                uint32_t start_bps);

#ifdef CONFIG_FEC_ENABLE
extern __agora_api__ int agora_rtc_set_fec_config(connection_id_t conn_id, bool enable, int ratio);
#endif // End CONFIG_FEC_ENABLE
 
#endif // End CONFIG_AUDIO_ONLY

#ifdef CONFIG_RTC_PROXY
extern __agora_api__ int agora_rtc_set_cloud_proxy(cloud_proxy_type_e type);
#endif // End CONFIG_RTC_PROXY
 

extern __agora_api__ int agora_rtc_set_params(connection_id_t conn_id, const char *params);
 
#ifdef CONFIG_RTCM
extern __agora_api__ int agora_rtc_send_media_ctrl_msg(connection_id_t conn_id, uint32_t remote_uid,
                                                       const void *payload, size_t length);
#endif // End of CONFIG_RTCM
 
#ifdef CONFIG_RDT
extern __agora_api__ int agora_rtc_send_rdt_msg(connection_id_t conn_id, uint32_t remote_uid, rdt_stream_type_e type,
                                                const void *msg, size_t length);

extern __agora_api__ int agora_rtc_get_rdt_status_info(connection_id_t conn_id, uint32_t remote_uid, rdt_status_info_t *info);
 
#endif // end CONFIG_RDT
 
#ifdef CONFIG_DATA_STREAM
extern __agora_api__ int agora_rtc_create_data_stream(connection_id_t conn_id, int* stream_id, bool reliable, bool ordered);

extern __agora_api__ int agora_rtc_send_stream_message(connection_id_t conn_id, int stream_id, const char* data, size_t length);
 
#endif // end CONFIG_DATA_STREAM
 
#ifdef CONFIG_RTM

typedef enum {
  RTM_EVENT_TYPE_LOGIN = 0,
  RTM_EVENT_TYPE_KICKOFF = 1,
  RTM_EVENT_TYPE_EXIT = 2,
} rtm_event_type_e;

typedef enum {
RTM_MSG_STATE_INIT = 0,
RTM_MSG_STATE_RECEIVED,
RTM_MSG_STATE_UNREACHABLE,
RTM_MSG_STATE_TIMEOUT,
} rtm_msg_state_e;

typedef enum {
  ERR_RTM_OK = 0,
  ERR_RTM_FAILED = 1,
  ERR_RTM_LOGIN_REJECTED = 2,
  ERR_RTM_INVALID_RTM_UID = 3,
  ERR_RTM_LOGIN_INVALID_TOKEN = 5,
  ERR_RTM_LOGIN_NOT_AUTHORIZED = 7,
  ERR_RTM_LOCAL_NETDOWN = 8,
  ERR_RTM_LOCAL_INTERRUPT = 9,
  ERR_RTM_LOCAL_TIMEOUT = 10,
  ERR_RTM_SERVER_TIMEOUT = 11,
  ERR_RTM_INVALID_APP_ID = ERR_INVALID_APP_ID,
  WARN_RTM_LOOKUP_CHANNEL_REJECTED = ERR_LOOKUP_CHANNEL_REJECTED,
  ERR_RTM_TOKEN_EXPIRED = ERR_TOKEN_EXPIRED,
  ERR_RTM_INVALID_TOKEN = ERR_INVALID_TOKEN,
} rtm_err_code_e;

#ifdef CONFIG_RTM_STAT
typedef struct rtm_stats_s {
  // connection
  uint32_t connection_lost_cnt;
  uint16_t connection_delay_min;
  uint16_t connection_delay_max;
  uint16_t connection_delay_avg;
 
  struct {
    // tx-total
    uint32_t tx_cnts;
    uint32_t tx_cnts_received;
    uint32_t tx_cnts_unreachable;
    uint32_t tx_cnts_timeout;
 
    float tx_ratio_received;
    float tx_ratio_unreachable;
    float tx_ratio_timeout;
 
    uint16_t tx_delay_min;
    uint16_t tx_delay_max;
    uint16_t tx_delay_avg;
 
    // rx-total
    uint32_t rx_cnts;
  } total;
 
  struct {
    // tx-interval
    uint32_t tx_cnts;
    uint32_t tx_cnts_received;
    uint32_t tx_cnts_unreachable;
    uint32_t tx_cnts_timeout;
 
    uint32_t tx_kbps;
    uint32_t tx_kbps_received;
    uint32_t tx_kbps_unreachable;
    uint32_t tx_kbps_timeout;
 
    float tx_ratio_received;
    float tx_ratio_unreachable;
    float tx_ratio_timeout;
 
    uint16_t tx_delay_min;
    uint16_t tx_delay_max;
    uint16_t tx_delay_avg;
 
    // rx-interval-cal
    uint32_t rx_cnts;
    uint32_t rx_kbps;
  } interval;
 
} rtm_stats_t;
#endif

typedef struct {
  void (*on_rtm_event)(const char *rtm_uid, rtm_event_type_e event_type, rtm_err_code_e err_code);

  void (*on_rtm_data)(const char *rtm_uid, const void *msg, size_t msg_len);

  void (*on_rtm_send_data_result)(const char *rtm_uid, uint32_t msg_id, rtm_msg_state_e state);

#ifdef CONFIG_RTM_STAT
  void (*on_rtm_stats)(rtm_stats_t stats);
#endif
} agora_rtm_handler_t;

extern __agora_api__ int agora_rtc_login_rtm(const char *rtm_uid, const char *rtm_token,
                                            const agora_rtm_handler_t *handler);

extern __agora_api__ int agora_rtc_logout_rtm(void);
extern __agora_api__ int agora_rtc_send_rtm_data(const char *rtm_uid, const void *msg, size_t msg_len, uint32_t msg_id);
#endif // End CONFIG_RTM
 
#ifdef __cplusplus
}
#endif
 
#endif /* __AGORA_RTC_API_H__ */