From bf03df9f146152b68c46dc1ad289337bed9afc07 Mon Sep 17 00:00:00 2001 From: Jeff Lenk Date: Thu, 7 Nov 2013 23:01:40 -0600 Subject: [PATCH] fix windows compiler warnings and vs2010 reswig --- .../mod_managed/freeswitch_wrap.2010.cxx | 1515 ++++++++++++++++- .../mod_managed/managed/swig.2010.cs | 1350 ++++++++++++++- src/switch_core_media.c | 4 +- 3 files changed, 2807 insertions(+), 62 deletions(-) diff --git a/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx b/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx index 9afb1d2758..6b36513455 100644 --- a/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx +++ b/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx @@ -1930,6 +1930,16 @@ SWIGEXPORT int SWIGSTDCALL CSharp_SWITCH_MAX_TRANS_get() { } +SWIGEXPORT int SWIGSTDCALL CSharp_SWITCH_CORE_SESSION_MAX_PRIVATES_get() { + int jresult ; + int result; + + result = (int)(2); + jresult = result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_dtmf_t_digit_set(void * jarg1, char jarg2) { switch_dtmf_t *arg1 = (switch_dtmf_t *) 0 ; char arg2 ; @@ -6320,6 +6330,28 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_thread_data_t_alloc_get(void * jarg1) { } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_thread_data_t_pool_set(void * jarg1, void * jarg2) { + switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; + switch_memory_pool_t *arg2 = (switch_memory_pool_t *) 0 ; + + arg1 = (switch_thread_data_t *)jarg1; + arg2 = (switch_memory_pool_t *)jarg2; + if (arg1) (arg1)->pool = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_thread_data_t_pool_get(void * jarg1) { + void * jresult ; + switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; + switch_memory_pool_t *result = 0 ; + + arg1 = (switch_thread_data_t *)jarg1; + result = (switch_memory_pool_t *) ((arg1)->pool); + jresult = (void *)result; + return jresult; +} + + SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_thread_data_t() { void * jresult ; switch_thread_data_t *result = 0 ; @@ -6604,6 +6636,28 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_node_t_hup_profile_get(void * } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_direction_set(void * jarg1, int jarg2) { + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + switch_call_direction_t arg2 ; + + arg1 = (switch_device_node_t *)jarg1; + arg2 = (switch_call_direction_t)jarg2; + if (arg1) (arg1)->direction = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_device_node_t_direction_get(void * jarg1) { + int jresult ; + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + switch_call_direction_t result; + + arg1 = (switch_device_node_t *)jarg1; + result = (switch_call_direction_t) ((arg1)->direction); + jresult = result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_parent_set(void * jarg1, void * jarg2) { switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; switch_device_record_s *arg2 = (switch_device_record_s *) 0 ; @@ -6688,6 +6742,50 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_total_get(void } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_total_in_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->total_in = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_total_in_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->total_in); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_total_out_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->total_out = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_total_out_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->total_out); + jresult = (unsigned long)result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_offhook_set(void * jarg1, unsigned long jarg2) { switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; uint32_t arg2 ; @@ -6710,6 +6808,50 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_offhook_get(vo } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_offhook_in_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->offhook_in = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_offhook_in_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->offhook_in); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_offhook_out_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->offhook_out = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_offhook_out_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->offhook_out); + jresult = (unsigned long)result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_active_set(void * jarg1, unsigned long jarg2) { switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; uint32_t arg2 ; @@ -6732,6 +6874,50 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_active_get(voi } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_active_in_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->active_in = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_active_in_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->active_in); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_active_out_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->active_out = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_active_out_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->active_out); + jresult = (unsigned long)result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_held_set(void * jarg1, unsigned long jarg2) { switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; uint32_t arg2 ; @@ -6754,6 +6940,50 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_held_get(void } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_held_in_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->held_in = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_held_in_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->held_in); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_held_out_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->held_out = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_held_out_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->held_out); + jresult = (unsigned long)result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_hup_set(void * jarg1, unsigned long jarg2) { switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; uint32_t arg2 ; @@ -6776,6 +7006,50 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_hup_get(void * } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_hup_in_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->hup_in = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_hup_in_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->hup_in); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_hup_out_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->hup_out = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_hup_out_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->hup_out); + jresult = (unsigned long)result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_ringing_set(void * jarg1, unsigned long jarg2) { switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; uint32_t arg2 ; @@ -6798,6 +7072,50 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_ringing_get(vo } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_ringing_in_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->ringing_in = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_ringing_in_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->ringing_in); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_ringing_out_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->ringing_out = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_ringing_out_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->ringing_out); + jresult = (unsigned long)result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_early_set(void * jarg1, unsigned long jarg2) { switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; uint32_t arg2 ; @@ -6820,6 +7138,72 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_early_get(void } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_early_in_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->early_in = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_early_in_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->early_in); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_early_out_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->early_out = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_early_out_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->early_out); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_ring_wait_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->ring_wait = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_ring_wait_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->ring_wait); + jresult = (unsigned long)result; + return jresult; +} + + SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_device_stats_t() { void * jresult ; switch_device_stats_t *result = 0 ; @@ -6942,6 +7326,28 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_stats_get(void * jar } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_last_stats_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_device_stats_t *arg2 = (switch_device_stats_t *) 0 ; + + arg1 = (switch_device_record_t *)jarg1; + arg2 = (switch_device_stats_t *)jarg2; + if (arg1) (arg1)->last_stats = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_last_stats_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_device_stats_t *result = 0 ; + + arg1 = (switch_device_record_t *)jarg1; + result = (switch_device_stats_t *)& ((arg1)->last_stats); + jresult = (void *)result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_state_set(void * jarg1, int jarg2) { switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; switch_device_state_t arg2 ; @@ -7070,6 +7476,146 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_last_call_time_get(v } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_ring_start_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t arg2 ; + switch_time_t *argp2 ; + + arg1 = (switch_device_record_t *)jarg1; + argp2 = (switch_time_t *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_time_t", 0); + return ; + } + arg2 = *argp2; + if (arg1) (arg1)->ring_start = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_ring_start_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t result; + + arg1 = (switch_device_record_t *)jarg1; + result = ((arg1)->ring_start); + jresult = new switch_time_t((const switch_time_t &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_ring_stop_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t arg2 ; + switch_time_t *argp2 ; + + arg1 = (switch_device_record_t *)jarg1; + argp2 = (switch_time_t *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_time_t", 0); + return ; + } + arg2 = *argp2; + if (arg1) (arg1)->ring_stop = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_ring_stop_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t result; + + arg1 = (switch_device_record_t *)jarg1; + result = ((arg1)->ring_stop); + jresult = new switch_time_t((const switch_time_t &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_hold_start_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t arg2 ; + switch_time_t *argp2 ; + + arg1 = (switch_device_record_t *)jarg1; + argp2 = (switch_time_t *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_time_t", 0); + return ; + } + arg2 = *argp2; + if (arg1) (arg1)->hold_start = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_hold_start_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t result; + + arg1 = (switch_device_record_t *)jarg1; + result = ((arg1)->hold_start); + jresult = new switch_time_t((const switch_time_t &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_hold_stop_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t arg2 ; + switch_time_t *argp2 ; + + arg1 = (switch_device_record_t *)jarg1; + argp2 = (switch_time_t *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_time_t", 0); + return ; + } + arg2 = *argp2; + if (arg1) (arg1)->hold_stop = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_hold_stop_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t result; + + arg1 = (switch_device_record_t *)jarg1; + result = ((arg1)->hold_stop); + jresult = new switch_time_t((const switch_time_t &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_call_start_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t arg2 ; + switch_time_t *argp2 ; + + arg1 = (switch_device_record_t *)jarg1; + argp2 = (switch_time_t *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_time_t", 0); + return ; + } + arg2 = *argp2; + if (arg1) (arg1)->call_start = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_call_start_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t result; + + arg1 = (switch_device_record_t *)jarg1; + result = ((arg1)->call_start); + jresult = new switch_time_t((const switch_time_t &)result); + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_uuid_list_set(void * jarg1, void * jarg2) { switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; device_uuid_node_s *arg2 = (device_uuid_node_s *) 0 ; @@ -7158,6 +7704,28 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_pool_get(void * jarg } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_user_data_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = (switch_device_record_t *)jarg1; + arg2 = (void *)jarg2; + if (arg1) (arg1)->user_data = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_user_data_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + void *result = 0 ; + + arg1 = (switch_device_record_t *)jarg1; + result = (void *) ((arg1)->user_data); + jresult = (void *)result; + return jresult; +} + + SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_device_record_t() { void * jresult ; switch_device_record_t *result = 0 ; @@ -9436,6 +10004,18 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_switch_core_get_switchname() { } +SWIGEXPORT char * SWIGSTDCALL CSharp_switch_core_get_domain(int jarg1) { + char * jresult ; + switch_bool_t arg1 ; + char *result = 0 ; + + arg1 = (switch_bool_t)jarg1; + result = (char *)switch_core_get_domain(arg1); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_core_set_variable(char * jarg1, char * jarg2) { char *arg1 = (char *) 0 ; char *arg2 = (char *) 0 ; @@ -9722,6 +10302,14 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_session_exec(void * jarg1, void * } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_core_session_video_reset(void * jarg1) { + switch_core_session_t *arg1 = (switch_core_session_t *) 0 ; + + arg1 = (switch_core_session_t *)jarg1; + switch_core_session_video_reset(arg1); +} + + SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_session_execute_application_get_flags(void * jarg1, char * jarg2, char * jarg3, void * jarg4) { int jresult ; switch_core_session_t *arg1 = (switch_core_session_t *) 0 ; @@ -9802,27 +10390,31 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_session_receive_event(void * jarg1 } -SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_session_get_private(void * jarg1) { +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_session_get_private_class(void * jarg1, int jarg2) { void * jresult ; switch_core_session_t *arg1 = (switch_core_session_t *) 0 ; + switch_pvt_class_t arg2 ; void *result = 0 ; arg1 = (switch_core_session_t *)jarg1; - result = (void *)switch_core_session_get_private(arg1); + arg2 = (switch_pvt_class_t)jarg2; + result = (void *)switch_core_session_get_private_class(arg1,arg2); jresult = (void *)result; return jresult; } -SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_session_set_private(void * jarg1, void * jarg2) { +SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_session_set_private_class(void * jarg1, void * jarg2, int jarg3) { int jresult ; switch_core_session_t *arg1 = (switch_core_session_t *) 0 ; void *arg2 = (void *) 0 ; + switch_pvt_class_t arg3 ; switch_status_t result; arg1 = (switch_core_session_t *)jarg1; arg2 = (void *)jarg2; - result = (switch_status_t)switch_core_session_set_private(arg1,arg2); + arg3 = (switch_pvt_class_t)jarg3; + result = (switch_status_t)switch_core_session_set_private_class(arg1,arg2,arg3); jresult = result; return jresult; } @@ -11071,14 +11663,14 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_core_db_test_reactive(void * jarg1, ch } -SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_perform_file_open(char * jarg1, char * jarg2, int jarg3, void * jarg4, char * jarg5, unsigned char jarg6, unsigned long jarg7, unsigned int jarg8, void * jarg9) { +SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_perform_file_open(char * jarg1, char * jarg2, int jarg3, void * jarg4, char * jarg5, unsigned long jarg6, unsigned long jarg7, unsigned int jarg8, void * jarg9) { int jresult ; char *arg1 = (char *) 0 ; char *arg2 = (char *) 0 ; int arg3 ; switch_file_handle_t *arg4 = (switch_file_handle_t *) 0 ; char *arg5 = (char *) 0 ; - uint8_t arg6 ; + uint32_t arg6 ; uint32_t arg7 ; unsigned int arg8 ; switch_memory_pool_t *arg9 = (switch_memory_pool_t *) 0 ; @@ -11089,7 +11681,7 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_perform_file_open(char * jarg1, ch arg3 = (int)jarg3; arg4 = (switch_file_handle_t *)jarg4; arg5 = (char *)jarg5; - arg6 = (uint8_t)jarg6; + arg6 = (uint32_t)jarg6; arg7 = (uint32_t)jarg7; arg8 = (unsigned int)jarg8; arg9 = (switch_memory_pool_t *)jarg9; @@ -13605,6 +14197,18 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_stream_system_fork(char * jarg1, void * } +SWIGEXPORT int SWIGSTDCALL CSharp_switch_ice_direction(void * jarg1) { + int jresult ; + switch_core_session_t *arg1 = (switch_core_session_t *) 0 ; + switch_call_direction_t result; + + arg1 = (switch_core_session_t *)jarg1; + result = (switch_call_direction_t)switch_ice_direction(arg1); + jresult = result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_loadable_module_interface_module_name_set(void * jarg1, char * jarg2) { switch_loadable_module_interface *arg1 = (switch_loadable_module_interface *) 0 ; char *arg2 = (char *) 0 ; @@ -13788,6 +14392,28 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_loadable_module_interface_api_interf } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_loadable_module_interface_json_api_interface_set(void * jarg1, void * jarg2) { + switch_loadable_module_interface *arg1 = (switch_loadable_module_interface *) 0 ; + switch_json_api_interface_t *arg2 = (switch_json_api_interface_t *) 0 ; + + arg1 = (switch_loadable_module_interface *)jarg1; + arg2 = (switch_json_api_interface_t *)jarg2; + if (arg1) (arg1)->json_api_interface = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_loadable_module_interface_json_api_interface_get(void * jarg1) { + void * jresult ; + switch_loadable_module_interface *arg1 = (switch_loadable_module_interface *) 0 ; + switch_json_api_interface_t *result = 0 ; + + arg1 = (switch_loadable_module_interface *)jarg1; + result = (switch_json_api_interface_t *) ((arg1)->json_api_interface); + jresult = (void *)result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_loadable_module_interface_file_interface_set(void * jarg1, void * jarg2) { switch_loadable_module_interface *arg1 = (switch_loadable_module_interface *) 0 ; switch_file_interface_t *arg2 = (switch_file_interface_t *) 0 ; @@ -14233,6 +14859,18 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_loadable_module_get_api_interface(ch } +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_loadable_module_get_json_api_interface(char * jarg1) { + void * jresult ; + char *arg1 = (char *) 0 ; + switch_json_api_interface_t *result = 0 ; + + arg1 = (char *)jarg1; + result = (switch_json_api_interface_t *)switch_loadable_module_get_json_api_interface((char const *)arg1); + jresult = (void *)result; + return jresult; +} + + SWIGEXPORT void * SWIGSTDCALL CSharp_switch_loadable_module_get_file_interface(char * jarg1) { void * jresult ; char *arg1 = (char *) 0 ; @@ -14379,6 +15017,22 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_api_execute(char * jarg1, char * jarg2, } +SWIGEXPORT int SWIGSTDCALL CSharp_switch_json_api_execute(void * jarg1, void * jarg2, void * jarg3) { + int jresult ; + cJSON *arg1 = (cJSON *) 0 ; + switch_core_session_t *arg2 = (switch_core_session_t *) 0 ; + cJSON **arg3 = (cJSON **) 0 ; + switch_status_t result; + + arg1 = (cJSON *)jarg1; + arg2 = (switch_core_session_t *)jarg2; + arg3 = (cJSON **)jarg3; + result = (switch_status_t)switch_json_api_execute(arg1,arg2,arg3); + jresult = result; + return jresult; +} + + SWIGEXPORT int SWIGSTDCALL CSharp_switch_loadable_module_load_module(char * jarg1, char * jarg2, int jarg3, void * jarg4) { int jresult ; char *arg1 = (char *) 0 ; @@ -14507,6 +15161,40 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_codec_ready(void * jarg1) { } +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_get_secondary_recover_callback(char * jarg1) { + void * jresult ; + char *arg1 = (char *) 0 ; + switch_core_recover_callback_t result; + + arg1 = (char *)jarg1; + result = (switch_core_recover_callback_t)switch_core_get_secondary_recover_callback((char const *)arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_register_secondary_recover_callback(char * jarg1, void * jarg2) { + int jresult ; + char *arg1 = (char *) 0 ; + switch_core_recover_callback_t arg2 = (switch_core_recover_callback_t) 0 ; + switch_status_t result; + + arg1 = (char *)jarg1; + arg2 = (switch_core_recover_callback_t)jarg2; + result = (switch_status_t)switch_core_register_secondary_recover_callback((char const *)arg1,arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_core_unregister_secondary_recover_callback(char * jarg1) { + char *arg1 = (char *) 0 ; + + arg1 = (char *)jarg1; + switch_core_unregister_secondary_recover_callback((char const *)arg1); +} + + SWIGEXPORT int SWIGSTDCALL CSharp_SWITCH_CMD_CHUNK_LEN_get() { int jresult ; int result; @@ -14624,6 +15312,16 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_console_run_complete_func(char * jarg1, } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_console_push_match_unique(void * jarg1, char * jarg2) { + switch_console_callback_match_t **arg1 = (switch_console_callback_match_t **) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = (switch_console_callback_match_t **)jarg1; + arg2 = (char *)jarg2; + switch_console_push_match_unique(arg1,(char const *)arg2); +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_console_push_match(void * jarg1, char * jarg2) { switch_console_callback_match_t **arg1 = (switch_console_callback_match_t **) 0 ; char *arg2 = (char *) 0 ; @@ -15405,6 +16103,26 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_find_local_ip(char * jarg1, int jarg2, } +SWIGEXPORT int SWIGSTDCALL CSharp_switch_find_interface_ip(char * jarg1, int jarg2, void * jarg3, char * jarg4, int jarg5) { + int jresult ; + char *arg1 = (char *) 0 ; + int arg2 ; + int *arg3 = (int *) 0 ; + char *arg4 = (char *) 0 ; + int arg5 ; + switch_status_t result; + + arg1 = (char *)jarg1; + arg2 = (int)jarg2; + arg3 = (int *)jarg3; + arg4 = (char *)jarg4; + arg5 = (int)jarg5; + result = (switch_status_t)switch_find_interface_ip(arg1,arg2,arg3,(char const *)arg4,arg5); + jresult = result; + return jresult; +} + + SWIGEXPORT char * SWIGSTDCALL CSharp_get_addr(char * jarg1, void * jarg2, void * jarg3, void * jarg4) { char * jresult ; char *arg1 = (char *) 0 ; @@ -17483,6 +18201,28 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_caller_profile_direction_get(void * jar } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_caller_profile_logical_direction_set(void * jarg1, int jarg2) { + switch_caller_profile *arg1 = (switch_caller_profile *) 0 ; + switch_call_direction_t arg2 ; + + arg1 = (switch_caller_profile *)jarg1; + arg2 = (switch_call_direction_t)jarg2; + if (arg1) (arg1)->logical_direction = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_caller_profile_logical_direction_get(void * jarg1) { + int jresult ; + switch_caller_profile *arg1 = (switch_caller_profile *) 0 ; + switch_call_direction_t result; + + arg1 = (switch_caller_profile *)jarg1; + result = (switch_call_direction_t) ((arg1)->logical_direction); + jresult = result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_caller_profile_soft_set(void * jarg1, void * jarg2) { switch_caller_profile *arg1 = (switch_caller_profile *) 0 ; profile_node_t *arg2 = (profile_node_t *) 0 ; @@ -18459,6 +19199,28 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_frame_user_data_get(void * jarg1) { } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_frame_pmap_set(void * jarg1, void * jarg2) { + switch_frame *arg1 = (switch_frame *) 0 ; + payload_map_t *arg2 = (payload_map_t *) 0 ; + + arg1 = (switch_frame *)jarg1; + arg2 = (payload_map_t *)jarg2; + if (arg1) (arg1)->pmap = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_frame_pmap_get(void * jarg1) { + void * jresult ; + switch_frame *arg1 = (switch_frame *) 0 ; + payload_map_t *result = 0 ; + + arg1 = (switch_frame *)jarg1; + result = (payload_map_t *) ((arg1)->pmap); + jresult = (void *)result; + return jresult; +} + + SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_frame() { void * jresult ; switch_frame *result = 0 ; @@ -20827,24 +21589,24 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_file_handle_native_rate_get(v } -SWIGEXPORT void SWIGSTDCALL CSharp_switch_file_handle_channels_set(void * jarg1, unsigned char jarg2) { +SWIGEXPORT void SWIGSTDCALL CSharp_switch_file_handle_channels_set(void * jarg1, unsigned long jarg2) { switch_file_handle *arg1 = (switch_file_handle *) 0 ; - uint8_t arg2 ; + uint32_t arg2 ; arg1 = (switch_file_handle *)jarg1; - arg2 = (uint8_t)jarg2; + arg2 = (uint32_t)jarg2; if (arg1) (arg1)->channels = arg2; } -SWIGEXPORT unsigned char SWIGSTDCALL CSharp_switch_file_handle_channels_get(void * jarg1) { - unsigned char jresult ; +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_file_handle_channels_get(void * jarg1) { + unsigned long jresult ; switch_file_handle *arg1 = (switch_file_handle *) 0 ; - uint8_t result; + uint32_t result; arg1 = (switch_file_handle *)jarg1; - result = (uint8_t) ((arg1)->channels); - jresult = result; + result = (uint32_t) ((arg1)->channels); + jresult = (unsigned long)result; return jresult; } @@ -21672,6 +22434,50 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_file_handle__params_get(void * jarg1 } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_file_handle_cur_channels_set(void * jarg1, unsigned long jarg2) { + switch_file_handle *arg1 = (switch_file_handle *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_file_handle *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->cur_channels = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_file_handle_cur_channels_get(void * jarg1) { + unsigned long jresult ; + switch_file_handle *arg1 = (switch_file_handle *) 0 ; + uint32_t result; + + arg1 = (switch_file_handle *)jarg1; + result = (uint32_t) ((arg1)->cur_channels); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_file_handle_cur_samplerate_set(void * jarg1, unsigned long jarg2) { + switch_file_handle *arg1 = (switch_file_handle *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_file_handle *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->cur_samplerate = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_file_handle_cur_samplerate_get(void * jarg1) { + unsigned long jresult ; + switch_file_handle *arg1 = (switch_file_handle *) 0 ; + uint32_t result; + + arg1 = (switch_file_handle *)jarg1; + result = (uint32_t) ((arg1)->cur_samplerate); + jresult = (unsigned long)result; + return jresult; +} + + SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_file_handle() { void * jresult ; switch_file_handle *result = 0 ; @@ -26566,6 +27372,243 @@ SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_api_interface(void * jarg1) { } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_json_api_interface_interface_name_set(void * jarg1, char * jarg2) { + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + arg2 = (char *)jarg2; + { + if (arg2) { + arg1->interface_name = (char const *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->interface_name, (const char *)arg2); + } else { + arg1->interface_name = 0; + } + } +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_switch_json_api_interface_interface_name_get(void * jarg1) { + char * jresult ; + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + char *result = 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + result = (char *) ((arg1)->interface_name); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_json_api_interface_desc_set(void * jarg1, char * jarg2) { + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + arg2 = (char *)jarg2; + { + if (arg2) { + arg1->desc = (char const *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->desc, (const char *)arg2); + } else { + arg1->desc = 0; + } + } +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_switch_json_api_interface_desc_get(void * jarg1) { + char * jresult ; + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + char *result = 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + result = (char *) ((arg1)->desc); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_json_api_interface_function_set(void * jarg1, void * jarg2) { + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + switch_json_api_function_t arg2 = (switch_json_api_function_t) 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + arg2 = (switch_json_api_function_t)jarg2; + if (arg1) (arg1)->function = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_json_api_interface_function_get(void * jarg1) { + void * jresult ; + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + switch_json_api_function_t result; + + arg1 = (switch_json_api_interface *)jarg1; + result = (switch_json_api_function_t) ((arg1)->function); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_json_api_interface_syntax_set(void * jarg1, char * jarg2) { + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + arg2 = (char *)jarg2; + { + if (arg2) { + arg1->syntax = (char const *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->syntax, (const char *)arg2); + } else { + arg1->syntax = 0; + } + } +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_switch_json_api_interface_syntax_get(void * jarg1) { + char * jresult ; + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + char *result = 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + result = (char *) ((arg1)->syntax); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_json_api_interface_rwlock_set(void * jarg1, void * jarg2) { + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + switch_thread_rwlock_t *arg2 = (switch_thread_rwlock_t *) 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + arg2 = (switch_thread_rwlock_t *)jarg2; + if (arg1) (arg1)->rwlock = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_json_api_interface_rwlock_get(void * jarg1) { + void * jresult ; + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + switch_thread_rwlock_t *result = 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + result = (switch_thread_rwlock_t *) ((arg1)->rwlock); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_json_api_interface_refs_set(void * jarg1, int jarg2) { + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + int arg2 ; + + arg1 = (switch_json_api_interface *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->refs = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_json_api_interface_refs_get(void * jarg1) { + int jresult ; + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + int result; + + arg1 = (switch_json_api_interface *)jarg1; + result = (int) ((arg1)->refs); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_json_api_interface_reflock_set(void * jarg1, void * jarg2) { + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + switch_mutex_t *arg2 = (switch_mutex_t *) 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + arg2 = (switch_mutex_t *)jarg2; + if (arg1) (arg1)->reflock = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_json_api_interface_reflock_get(void * jarg1) { + void * jresult ; + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + switch_mutex_t *result = 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + result = (switch_mutex_t *) ((arg1)->reflock); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_json_api_interface_parent_set(void * jarg1, void * jarg2) { + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + switch_loadable_module_interface_t *arg2 = (switch_loadable_module_interface_t *) 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + arg2 = (switch_loadable_module_interface_t *)jarg2; + if (arg1) (arg1)->parent = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_json_api_interface_parent_get(void * jarg1) { + void * jresult ; + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + switch_loadable_module_interface_t *result = 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + result = (switch_loadable_module_interface_t *) ((arg1)->parent); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_json_api_interface_next_set(void * jarg1, void * jarg2) { + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + switch_json_api_interface *arg2 = (switch_json_api_interface *) 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + arg2 = (switch_json_api_interface *)jarg2; + if (arg1) (arg1)->next = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_json_api_interface_next_get(void * jarg1) { + void * jresult ; + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + switch_json_api_interface *result = 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + result = (switch_json_api_interface *) ((arg1)->next); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_json_api_interface() { + void * jresult ; + switch_json_api_interface *result = 0 ; + + result = (switch_json_api_interface *)new switch_json_api_interface(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_json_api_interface(void * jarg1) { + switch_json_api_interface *arg1 = (switch_json_api_interface *) 0 ; + + arg1 = (switch_json_api_interface *)jarg1; + delete arg1; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_slin_data_session_set(void * jarg1, void * jarg2) { switch_slin_data *arg1 = (switch_slin_data *) 0 ; switch_core_session_t *arg2 = (switch_core_session_t *) 0 ; @@ -28570,6 +29613,28 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_direction(void * jarg1) { } +SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_logical_direction(void * jarg1) { + int jresult ; + switch_channel_t *arg1 = (switch_channel_t *) 0 ; + switch_call_direction_t result; + + arg1 = (switch_channel_t *)jarg1; + result = (switch_call_direction_t)switch_channel_logical_direction(arg1); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_set_direction(void * jarg1, int jarg2) { + switch_channel_t *arg1 = (switch_channel_t *) 0 ; + switch_call_direction_t arg2 ; + + arg1 = (switch_channel_t *)jarg1; + arg2 = (switch_call_direction_t)jarg2; + switch_channel_set_direction(arg1,arg2); +} + + SWIGEXPORT void * SWIGSTDCALL CSharp_switch_channel_get_session(void * jarg1) { void * jresult ; switch_channel_t *arg1 = (switch_channel_t *) 0 ; @@ -30383,6 +31448,20 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_event_serialize_json(void * jarg1, void } +SWIGEXPORT int SWIGSTDCALL CSharp_switch_event_serialize_json_obj(void * jarg1, void * jarg2) { + int jresult ; + switch_event_t *arg1 = (switch_event_t *) 0 ; + cJSON **arg2 = (cJSON **) 0 ; + switch_status_t result; + + arg1 = (switch_event_t *)jarg1; + arg2 = (cJSON **)jarg2; + result = (switch_status_t)switch_event_serialize_json_obj(arg1,arg2); + jresult = result; + return jresult; +} + + SWIGEXPORT int SWIGSTDCALL CSharp_switch_event_create_json(void * jarg1, char * jarg2) { int jresult ; switch_event_t **arg1 = (switch_event_t **) 0 ; @@ -30587,6 +31666,18 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_event_add_presence_data_cols(void * ja } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_json_add_presence_data_cols(void * jarg1, void * jarg2, char * jarg3) { + switch_event_t *arg1 = (switch_event_t *) 0 ; + cJSON *arg2 = (cJSON *) 0 ; + char *arg3 = (char *) 0 ; + + arg1 = (switch_event_t *)jarg1; + arg2 = (cJSON *)jarg2; + arg3 = (char *)jarg3; + switch_json_add_presence_data_cols(arg1,arg2,(char const *)arg3); +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_event_launch_dispatch_threads(unsigned long jarg1) { uint32_t arg1 ; @@ -30595,6 +31686,334 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_event_launch_dispatch_threads(unsigned } +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_event_channel_broadcast(char * jarg1, void * jarg2, char * jarg3, unsigned long jarg4) { + unsigned long jresult ; + char *arg1 = (char *) 0 ; + cJSON **arg2 = (cJSON **) 0 ; + char *arg3 = (char *) 0 ; + switch_event_channel_id_t arg4 ; + uint32_t result; + + arg1 = (char *)jarg1; + arg2 = (cJSON **)jarg2; + arg3 = (char *)jarg3; + arg4 = (switch_event_channel_id_t)jarg4; + result = (uint32_t)switch_event_channel_broadcast((char const *)arg1,arg2,(char const *)arg3,arg4); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_event_channel_unbind(char * jarg1, void * jarg2) { + unsigned long jresult ; + char *arg1 = (char *) 0 ; + switch_event_channel_func_t arg2 = (switch_event_channel_func_t) 0 ; + uint32_t result; + + arg1 = (char *)jarg1; + arg2 = (switch_event_channel_func_t)jarg2; + result = (uint32_t)switch_event_channel_unbind((char const *)arg1,arg2); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_event_channel_bind(char * jarg1, void * jarg2, void * jarg3) { + int jresult ; + char *arg1 = (char *) 0 ; + switch_event_channel_func_t arg2 = (switch_event_channel_func_t) 0 ; + switch_event_channel_id_t *arg3 = (switch_event_channel_id_t *) 0 ; + switch_status_t result; + + arg1 = (char *)jarg1; + arg2 = (switch_event_channel_func_t)jarg2; + arg3 = (switch_event_channel_id_t *)jarg3; + result = (switch_status_t)switch_event_channel_bind((char const *)arg1,arg2,arg3); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_NO_EVENT_CHANNEL_ID_get() { + int jresult ; + int result; + + result = (int)(0); + jresult = result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_EVENT_CHANNEL_GLOBAL_get() { + char * jresult ; + char *result = 0 ; + + result = (char *)("__global__"); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_live_array_clear(void * jarg1) { + int jresult ; + switch_live_array_t *arg1 = (switch_live_array_t *) 0 ; + switch_status_t result; + + arg1 = (switch_live_array_t *)jarg1; + result = (switch_status_t)switch_live_array_clear(arg1); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_live_array_bootstrap(void * jarg1, char * jarg2, unsigned long jarg3) { + int jresult ; + switch_live_array_t *arg1 = (switch_live_array_t *) 0 ; + char *arg2 = (char *) 0 ; + switch_event_channel_id_t arg3 ; + switch_status_t result; + + arg1 = (switch_live_array_t *)jarg1; + arg2 = (char *)jarg2; + arg3 = (switch_event_channel_id_t)jarg3; + result = (switch_status_t)switch_live_array_bootstrap(arg1,(char const *)arg2,arg3); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_live_array_destroy(void * jarg1) { + int jresult ; + switch_live_array_t **arg1 = (switch_live_array_t **) 0 ; + switch_status_t result; + + arg1 = (switch_live_array_t **)jarg1; + result = (switch_status_t)switch_live_array_destroy(arg1); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_live_array_create(char * jarg1, char * jarg2, unsigned long jarg3, void * jarg4) { + int jresult ; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + switch_event_channel_id_t arg3 ; + switch_live_array_t **arg4 = (switch_live_array_t **) 0 ; + switch_status_t result; + + arg1 = (char *)jarg1; + arg2 = (char *)jarg2; + arg3 = (switch_event_channel_id_t)jarg3; + arg4 = (switch_live_array_t **)jarg4; + result = (switch_status_t)switch_live_array_create((char const *)arg1,(char const *)arg2,arg3,arg4); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_live_array_get(void * jarg1, char * jarg2) { + void * jresult ; + switch_live_array_t *arg1 = (switch_live_array_t *) 0 ; + char *arg2 = (char *) 0 ; + cJSON *result = 0 ; + + arg1 = (switch_live_array_t *)jarg1; + arg2 = (char *)jarg2; + result = (cJSON *)switch_live_array_get(arg1,(char const *)arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_live_array_get_idx(void * jarg1, int jarg2) { + void * jresult ; + switch_live_array_t *arg1 = (switch_live_array_t *) 0 ; + int arg2 ; + cJSON *result = 0 ; + + arg1 = (switch_live_array_t *)jarg1; + arg2 = (int)jarg2; + result = (cJSON *)switch_live_array_get_idx(arg1,arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_live_array_del(void * jarg1, char * jarg2) { + int jresult ; + switch_live_array_t *arg1 = (switch_live_array_t *) 0 ; + char *arg2 = (char *) 0 ; + switch_status_t result; + + arg1 = (switch_live_array_t *)jarg1; + arg2 = (char *)jarg2; + result = (switch_status_t)switch_live_array_del(arg1,(char const *)arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_live_array_add(void * jarg1, char * jarg2, int jarg3, void * jarg4, int jarg5) { + int jresult ; + switch_live_array_t *arg1 = (switch_live_array_t *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + cJSON **arg4 = (cJSON **) 0 ; + switch_bool_t arg5 ; + switch_status_t result; + + arg1 = (switch_live_array_t *)jarg1; + arg2 = (char *)jarg2; + arg3 = (int)jarg3; + arg4 = (cJSON **)jarg4; + arg5 = (switch_bool_t)jarg5; + result = (switch_status_t)switch_live_array_add(arg1,(char const *)arg2,arg3,arg4,arg5); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_live_array_visible(void * jarg1, int jarg2, int jarg3) { + int jresult ; + switch_live_array_t *arg1 = (switch_live_array_t *) 0 ; + switch_bool_t arg2 ; + switch_bool_t arg3 ; + switch_status_t result; + + arg1 = (switch_live_array_t *)jarg1; + arg2 = (switch_bool_t)jarg2; + arg3 = (switch_bool_t)jarg3; + result = (switch_status_t)switch_live_array_visible(arg1,arg2,arg3); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_live_array_isnew(void * jarg1) { + int jresult ; + switch_live_array_t *arg1 = (switch_live_array_t *) 0 ; + switch_bool_t result; + + arg1 = (switch_live_array_t *)jarg1; + result = (switch_bool_t)switch_live_array_isnew(arg1); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_live_array_lock(void * jarg1) { + switch_live_array_t *arg1 = (switch_live_array_t *) 0 ; + + arg1 = (switch_live_array_t *)jarg1; + switch_live_array_lock(arg1); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_live_array_unlock(void * jarg1) { + switch_live_array_t *arg1 = (switch_live_array_t *) 0 ; + + arg1 = (switch_live_array_t *)jarg1; + switch_live_array_unlock(arg1); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_live_array_set_user_data(void * jarg1, void * jarg2) { + switch_live_array_t *arg1 = (switch_live_array_t *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = (switch_live_array_t *)jarg1; + arg2 = (void *)jarg2; + switch_live_array_set_user_data(arg1,arg2); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_live_array_set_command_handler(void * jarg1, void * jarg2) { + switch_live_array_t *arg1 = (switch_live_array_t *) 0 ; + switch_live_array_command_handler_t arg2 = (switch_live_array_command_handler_t) 0 ; + + arg1 = (switch_live_array_t *)jarg1; + arg2 = (switch_live_array_command_handler_t)jarg2; + switch_live_array_set_command_handler(arg1,arg2); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_live_array_parse_json(void * jarg1, unsigned long jarg2) { + cJSON *arg1 = (cJSON *) 0 ; + switch_event_channel_id_t arg2 ; + + arg1 = (cJSON *)jarg1; + arg2 = (switch_event_channel_id_t)jarg2; + switch_live_array_parse_json(arg1,arg2); +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_live_array_add_alias(void * jarg1, char * jarg2, char * jarg3) { + int jresult ; + switch_live_array_t *arg1 = (switch_live_array_t *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + switch_bool_t result; + + arg1 = (switch_live_array_t *)jarg1; + arg2 = (char *)jarg2; + arg3 = (char *)jarg3; + result = (switch_bool_t)switch_live_array_add_alias(arg1,(char const *)arg2,(char const *)arg3); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_live_array_clear_alias(void * jarg1, char * jarg2, char * jarg3) { + int jresult ; + switch_live_array_t *arg1 = (switch_live_array_t *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + switch_bool_t result; + + arg1 = (switch_live_array_t *)jarg1; + arg2 = (char *)jarg2; + arg3 = (char *)jarg3; + result = (switch_bool_t)switch_live_array_clear_alias(arg1,(char const *)arg2,(char const *)arg3); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_event_channel_permission_verify(char * jarg1, char * jarg2) { + int jresult ; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + switch_bool_t result; + + arg1 = (char *)jarg1; + arg2 = (char *)jarg2; + result = (switch_bool_t)switch_event_channel_permission_verify((char const *)arg1,(char const *)arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_event_channel_permission_modify(char * jarg1, char * jarg2, int jarg3) { + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + switch_bool_t arg3 ; + + arg1 = (char *)jarg1; + arg2 = (char *)jarg2; + arg3 = (switch_bool_t)jarg3; + switch_event_channel_permission_modify((char const *)arg1,(char const *)arg2,arg3); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_event_channel_permission_clear(char * jarg1) { + char *arg1 = (char *) 0 ; + + arg1 = (char *)jarg1; + switch_event_channel_permission_clear((char const *)arg1); +} + + SWIGEXPORT int SWIGSTDCALL CSharp_SWITCH_RESAMPLE_QUALITY_get() { int jresult ; int result; @@ -35304,16 +36723,6 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_set_telephony_recv_event(void * ja } -SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_set_recv_pt(void * jarg1, unsigned char jarg2) { - switch_rtp_t *arg1 = (switch_rtp_t *) 0 ; - switch_payload_t arg2 ; - - arg1 = (switch_rtp_t *)jarg1; - arg2 = (switch_payload_t)jarg2; - switch_rtp_set_recv_pt(arg1,arg2); -} - - SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_set_cng_pt(void * jarg1, unsigned char jarg2) { switch_rtp_t *arg1 = (switch_rtp_t *) 0 ; switch_payload_t arg2 ; @@ -35336,6 +36745,20 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_get_private(void * jarg1) { } +SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_set_payload_map(void * jarg1, void * jarg2) { + int jresult ; + switch_rtp_t *arg1 = (switch_rtp_t *) 0 ; + payload_map_t **arg2 = (payload_map_t **) 0 ; + switch_status_t result; + + arg1 = (switch_rtp_t *)jarg1; + arg2 = (payload_map_t **)jarg2; + result = (switch_status_t)switch_rtp_set_payload_map(arg1,arg2); + jresult = result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_intentional_bugs(void * jarg1, int jarg2) { switch_rtp_t *arg1 = (switch_rtp_t *) 0 ; switch_rtp_bug_flag_t arg2 ; @@ -35400,6 +36823,20 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_add_dtls(void * jarg1, void * jarg2 } +SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_del_dtls(void * jarg1, int jarg2) { + int jresult ; + switch_rtp_t *arg1 = (switch_rtp_t *) 0 ; + dtls_type_t arg2 ; + switch_status_t result; + + arg1 = (switch_rtp_t *)jarg1; + arg2 = (dtls_type_t)jarg2; + result = (switch_status_t)switch_rtp_del_dtls(arg1,arg2); + jresult = result; + return jresult; +} + + SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_has_dtls() { int jresult ; int result; @@ -38380,6 +39817,28 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_scheduler_task_cmd_id_get(voi } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_scheduler_task_repeat_set(void * jarg1, unsigned long jarg2) { + switch_scheduler_task *arg1 = (switch_scheduler_task *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_scheduler_task *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->repeat = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_scheduler_task_repeat_get(void * jarg1) { + unsigned long jresult ; + switch_scheduler_task *arg1 = (switch_scheduler_task *) 0 ; + uint32_t result; + + arg1 = (switch_scheduler_task *)jarg1; + result = (uint32_t) ((arg1)->repeat); + jresult = (unsigned long)result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_scheduler_task_group_set(void * jarg1, char * jarg2) { switch_scheduler_task *arg1 = (switch_scheduler_task *) 0 ; char *arg2 = (char *) 0 ; @@ -38971,11 +40430,13 @@ SWIGEXPORT void SWIGSTDCALL CSharp_IvrMenu_Execute(void * jarg1, void * jarg2, c } -SWIGEXPORT void * SWIGSTDCALL CSharp_new_Api() { +SWIGEXPORT void * SWIGSTDCALL CSharp_new_Api(void * jarg1) { void * jresult ; + CoreSession *arg1 = (CoreSession *) NULL ; API *result = 0 ; - result = (API *)new API(); + arg1 = (CoreSession *)jarg1; + result = (API *)new API(arg1); jresult = (void *)result; return jresult; } diff --git a/src/mod/languages/mod_managed/managed/swig.2010.cs b/src/mod/languages/mod_managed/managed/swig.2010.cs index 3aff242242..44cc42ee90 100644 --- a/src/mod/languages/mod_managed/managed/swig.2010.cs +++ b/src/mod/languages/mod_managed/managed/swig.2010.cs @@ -41,7 +41,7 @@ public class Api : IDisposable { } } - public Api() : this(freeswitchPINVOKE.new_Api(), true) { + public Api(CoreSession s) : this(freeswitchPINVOKE.new_Api(CoreSession.getCPtr(s)), true) { } public string Execute(string command, string data) { @@ -1773,6 +1773,11 @@ public class freeswitch { return ret; } + public static string switch_core_get_domain(switch_bool_t dup) { + string ret = freeswitchPINVOKE.switch_core_get_domain((int)dup); + return ret; + } + public static void switch_core_set_variable(string varname, string value) { freeswitchPINVOKE.switch_core_set_variable(varname, value); } @@ -1881,6 +1886,10 @@ public class freeswitch { return ret; } + public static void switch_core_session_video_reset(SWIGTYPE_p_switch_core_session session) { + freeswitchPINVOKE.switch_core_session_video_reset(SWIGTYPE_p_switch_core_session.getCPtr(session)); + } + public static switch_status_t switch_core_session_execute_application_get_flags(SWIGTYPE_p_switch_core_session session, string app, string arg, SWIGTYPE_p_int flags) { switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_execute_application_get_flags(SWIGTYPE_p_switch_core_session.getCPtr(session), app, arg, SWIGTYPE_p_int.getCPtr(flags)); return ret; @@ -1906,14 +1915,14 @@ public class freeswitch { return ret; } - public static SWIGTYPE_p_void switch_core_session_get_private(SWIGTYPE_p_switch_core_session session) { - IntPtr cPtr = freeswitchPINVOKE.switch_core_session_get_private(SWIGTYPE_p_switch_core_session.getCPtr(session)); + public static SWIGTYPE_p_void switch_core_session_get_private_class(SWIGTYPE_p_switch_core_session session, switch_pvt_class_t index) { + IntPtr cPtr = freeswitchPINVOKE.switch_core_session_get_private_class(SWIGTYPE_p_switch_core_session.getCPtr(session), (int)index); SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false); return ret; } - public static switch_status_t switch_core_session_set_private(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_void private_info) { - switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_set_private(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_void.getCPtr(private_info)); + public static switch_status_t switch_core_session_set_private_class(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_void private_info, switch_pvt_class_t index) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_set_private_class(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_void.getCPtr(private_info), (int)index); return ret; } @@ -2353,7 +2362,7 @@ public class freeswitch { freeswitchPINVOKE.switch_core_db_test_reactive(SWIGTYPE_p_sqlite3.getCPtr(db), test_sql, drop_sql, reactive_sql); } - public static switch_status_t switch_core_perform_file_open(string file, string func, int line, switch_file_handle fh, string file_path, byte channels, uint rate, uint flags, SWIGTYPE_p_apr_pool_t pool) { + public static switch_status_t switch_core_perform_file_open(string file, string func, int line, switch_file_handle fh, string file_path, uint channels, uint rate, uint flags, SWIGTYPE_p_apr_pool_t pool) { switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_perform_file_open(file, func, line, switch_file_handle.getCPtr(fh), file_path, channels, rate, flags, SWIGTYPE_p_apr_pool_t.getCPtr(pool)); return ret; } @@ -3146,6 +3155,11 @@ public class freeswitch { return ret; } + public static switch_call_direction_t switch_ice_direction(SWIGTYPE_p_switch_core_session session) { + switch_call_direction_t ret = (switch_call_direction_t)freeswitchPINVOKE.switch_ice_direction(SWIGTYPE_p_switch_core_session.getCPtr(session)); + return ret; + } + public static switch_status_t switch_loadable_module_init(switch_bool_t autoload) { switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_loadable_module_init((int)autoload); return ret; @@ -3222,6 +3236,12 @@ public class freeswitch { return ret; } + public static switch_json_api_interface switch_loadable_module_get_json_api_interface(string name) { + IntPtr cPtr = freeswitchPINVOKE.switch_loadable_module_get_json_api_interface(name); + switch_json_api_interface ret = (cPtr == IntPtr.Zero) ? null : new switch_json_api_interface(cPtr, false); + return ret; + } + public static switch_file_interface switch_loadable_module_get_file_interface(string name) { IntPtr cPtr = freeswitchPINVOKE.switch_loadable_module_get_file_interface(name); switch_file_interface ret = (cPtr == IntPtr.Zero) ? null : new switch_file_interface(cPtr, false); @@ -3285,6 +3305,11 @@ public class freeswitch { return ret; } + public static switch_status_t switch_json_api_execute(SWIGTYPE_p_cJSON json, SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_p_cJSON retval) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_json_api_execute(SWIGTYPE_p_cJSON.getCPtr(json), SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_p_cJSON.getCPtr(retval)); + return ret; + } + public static switch_status_t switch_loadable_module_load_module(string dir, string fname, switch_bool_t runtime, ref string err) { switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_loadable_module_load_module(dir, fname, (int)runtime, ref err); return ret; @@ -3319,6 +3344,21 @@ public class freeswitch { return ret; } + public static SWIGTYPE_p_f_p_switch_core_session__int switch_core_get_secondary_recover_callback(string key) { + IntPtr cPtr = freeswitchPINVOKE.switch_core_get_secondary_recover_callback(key); + SWIGTYPE_p_f_p_switch_core_session__int ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_switch_core_session__int(cPtr, false); + return ret; + } + + public static switch_status_t switch_core_register_secondary_recover_callback(string key, SWIGTYPE_p_f_p_switch_core_session__int cb) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_register_secondary_recover_callback(key, SWIGTYPE_p_f_p_switch_core_session__int.getCPtr(cb)); + return ret; + } + + public static void switch_core_unregister_secondary_recover_callback(string key) { + freeswitchPINVOKE.switch_core_unregister_secondary_recover_callback(key); + } + public static void switch_console_loop() { freeswitchPINVOKE.switch_console_loop(); } @@ -3359,6 +3399,10 @@ public class freeswitch { return ret; } + public static void switch_console_push_match_unique(SWIGTYPE_p_p_switch_console_callback_match matches, string new_val) { + freeswitchPINVOKE.switch_console_push_match_unique(SWIGTYPE_p_p_switch_console_callback_match.getCPtr(matches), new_val); + } + public static void switch_console_push_match(SWIGTYPE_p_p_switch_console_callback_match matches, string new_val) { freeswitchPINVOKE.switch_console_push_match(SWIGTYPE_p_p_switch_console_callback_match.getCPtr(matches), new_val); } @@ -3605,6 +3649,11 @@ public class freeswitch { return ret; } + public static switch_status_t switch_find_interface_ip(string buf, int len, SWIGTYPE_p_int mask, string ifname, int family) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_find_interface_ip(buf, len, SWIGTYPE_p_int.getCPtr(mask), ifname, family); + return ret; + } + public static string get_addr(string buf, SWIGTYPE_p_switch_size_t len, SWIGTYPE_p_sockaddr sa, SWIGTYPE_p_socklen_t salen) { string ret = freeswitchPINVOKE.get_addr(buf, SWIGTYPE_p_switch_size_t.getCPtr(len), SWIGTYPE_p_sockaddr.getCPtr(sa), SWIGTYPE_p_socklen_t.getCPtr(salen)); if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); @@ -4546,6 +4595,15 @@ public class freeswitch { return ret; } + public static switch_call_direction_t switch_channel_logical_direction(SWIGTYPE_p_switch_channel channel) { + switch_call_direction_t ret = (switch_call_direction_t)freeswitchPINVOKE.switch_channel_logical_direction(SWIGTYPE_p_switch_channel.getCPtr(channel)); + return ret; + } + + public static void switch_channel_set_direction(SWIGTYPE_p_switch_channel channel, switch_call_direction_t direction) { + freeswitchPINVOKE.switch_channel_set_direction(SWIGTYPE_p_switch_channel.getCPtr(channel), (int)direction); + } + public static SWIGTYPE_p_switch_core_session switch_channel_get_session(SWIGTYPE_p_switch_channel channel) { IntPtr cPtr = freeswitchPINVOKE.switch_channel_get_session(SWIGTYPE_p_switch_channel.getCPtr(channel)); SWIGTYPE_p_switch_core_session ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_core_session(cPtr, false); @@ -4911,8 +4969,8 @@ public class freeswitch { return ret; } - public static switch_status_t switch_event_binary_deserialize(SWIGTYPE_p_p_switch_event eventp, SWIGTYPE_p_p_void data, SWIGTYPE_p_switch_size_t len, switch_bool_t destroy) { - switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_binary_deserialize(SWIGTYPE_p_p_switch_event.getCPtr(eventp), SWIGTYPE_p_p_void.getCPtr(data), SWIGTYPE_p_switch_size_t.getCPtr(len), (int)destroy); + public static switch_status_t switch_event_binary_deserialize(SWIGTYPE_p_p_switch_event eventp, SWIGTYPE_p_p_void data, SWIGTYPE_p_switch_size_t len, switch_bool_t duplicate) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_binary_deserialize(SWIGTYPE_p_p_switch_event.getCPtr(eventp), SWIGTYPE_p_p_void.getCPtr(data), SWIGTYPE_p_switch_size_t.getCPtr(len), (int)duplicate); if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); return ret; } @@ -4932,6 +4990,11 @@ public class freeswitch { return ret; } + public static switch_status_t switch_event_serialize_json_obj(switch_event arg0, SWIGTYPE_p_p_cJSON json) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_serialize_json_obj(switch_event.getCPtr(arg0), SWIGTYPE_p_p_cJSON.getCPtr(json)); + return ret; + } + public static switch_status_t switch_event_create_json(SWIGTYPE_p_p_switch_event arg0, string json) { switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_create_json(SWIGTYPE_p_p_switch_event.getCPtr(arg0), json); return ret; @@ -4990,10 +5053,124 @@ public class freeswitch { freeswitchPINVOKE.switch_event_add_presence_data_cols(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_event.getCPtr(arg1), prefix); } + public static void switch_json_add_presence_data_cols(switch_event arg0, SWIGTYPE_p_cJSON json, string prefix) { + freeswitchPINVOKE.switch_json_add_presence_data_cols(switch_event.getCPtr(arg0), SWIGTYPE_p_cJSON.getCPtr(json), prefix); + } + public static void switch_event_launch_dispatch_threads(uint max) { freeswitchPINVOKE.switch_event_launch_dispatch_threads(max); } + public static uint switch_event_channel_broadcast(string event_channel, SWIGTYPE_p_p_cJSON json, string key, uint id) { + uint ret = freeswitchPINVOKE.switch_event_channel_broadcast(event_channel, SWIGTYPE_p_p_cJSON.getCPtr(json), key, id); + return ret; + } + + public static uint switch_event_channel_unbind(string event_channel, SWIGTYPE_p_f_p_q_const__char_p_cJSON_p_q_const__char_unsigned_long__void func) { + uint ret = freeswitchPINVOKE.switch_event_channel_unbind(event_channel, SWIGTYPE_p_f_p_q_const__char_p_cJSON_p_q_const__char_unsigned_long__void.getCPtr(func)); + return ret; + } + + public static switch_status_t switch_event_channel_bind(string event_channel, SWIGTYPE_p_f_p_q_const__char_p_cJSON_p_q_const__char_unsigned_long__void func, SWIGTYPE_p_unsigned_long id) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_channel_bind(event_channel, SWIGTYPE_p_f_p_q_const__char_p_cJSON_p_q_const__char_unsigned_long__void.getCPtr(func), SWIGTYPE_p_unsigned_long.getCPtr(id)); + return ret; + } + + public static switch_status_t switch_live_array_clear(SWIGTYPE_p_switch_live_array_s la) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_live_array_clear(SWIGTYPE_p_switch_live_array_s.getCPtr(la)); + return ret; + } + + public static switch_status_t switch_live_array_bootstrap(SWIGTYPE_p_switch_live_array_s la, string sessid, uint channel_id) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_live_array_bootstrap(SWIGTYPE_p_switch_live_array_s.getCPtr(la), sessid, channel_id); + return ret; + } + + public static switch_status_t switch_live_array_destroy(SWIGTYPE_p_p_switch_live_array_s live_arrayP) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_live_array_destroy(SWIGTYPE_p_p_switch_live_array_s.getCPtr(live_arrayP)); + return ret; + } + + public static switch_status_t switch_live_array_create(string event_channel, string name, uint channel_id, SWIGTYPE_p_p_switch_live_array_s live_arrayP) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_live_array_create(event_channel, name, channel_id, SWIGTYPE_p_p_switch_live_array_s.getCPtr(live_arrayP)); + return ret; + } + + public static SWIGTYPE_p_cJSON switch_live_array_get(SWIGTYPE_p_switch_live_array_s la, string name) { + IntPtr cPtr = freeswitchPINVOKE.switch_live_array_get(SWIGTYPE_p_switch_live_array_s.getCPtr(la), name); + SWIGTYPE_p_cJSON ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_cJSON(cPtr, false); + return ret; + } + + public static SWIGTYPE_p_cJSON switch_live_array_get_idx(SWIGTYPE_p_switch_live_array_s la, int idx) { + IntPtr cPtr = freeswitchPINVOKE.switch_live_array_get_idx(SWIGTYPE_p_switch_live_array_s.getCPtr(la), idx); + SWIGTYPE_p_cJSON ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_cJSON(cPtr, false); + return ret; + } + + public static switch_status_t switch_live_array_del(SWIGTYPE_p_switch_live_array_s la, string name) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_live_array_del(SWIGTYPE_p_switch_live_array_s.getCPtr(la), name); + return ret; + } + + public static switch_status_t switch_live_array_add(SWIGTYPE_p_switch_live_array_s la, string name, int index, SWIGTYPE_p_p_cJSON obj, switch_bool_t destroy) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_live_array_add(SWIGTYPE_p_switch_live_array_s.getCPtr(la), name, index, SWIGTYPE_p_p_cJSON.getCPtr(obj), (int)destroy); + return ret; + } + + public static switch_status_t switch_live_array_visible(SWIGTYPE_p_switch_live_array_s la, switch_bool_t visible, switch_bool_t force) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_live_array_visible(SWIGTYPE_p_switch_live_array_s.getCPtr(la), (int)visible, (int)force); + return ret; + } + + public static switch_bool_t switch_live_array_isnew(SWIGTYPE_p_switch_live_array_s la) { + switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_live_array_isnew(SWIGTYPE_p_switch_live_array_s.getCPtr(la)); + return ret; + } + + public static void switch_live_array_lock(SWIGTYPE_p_switch_live_array_s la) { + freeswitchPINVOKE.switch_live_array_lock(SWIGTYPE_p_switch_live_array_s.getCPtr(la)); + } + + public static void switch_live_array_unlock(SWIGTYPE_p_switch_live_array_s la) { + freeswitchPINVOKE.switch_live_array_unlock(SWIGTYPE_p_switch_live_array_s.getCPtr(la)); + } + + public static void switch_live_array_set_user_data(SWIGTYPE_p_switch_live_array_s la, SWIGTYPE_p_void user_data) { + freeswitchPINVOKE.switch_live_array_set_user_data(SWIGTYPE_p_switch_live_array_s.getCPtr(la), SWIGTYPE_p_void.getCPtr(user_data)); + } + + public static void switch_live_array_set_command_handler(SWIGTYPE_p_switch_live_array_s la, SWIGTYPE_p_f_p_switch_live_array_s_p_q_const__char_p_q_const__char_p_cJSON_p_void__void command_handler) { + freeswitchPINVOKE.switch_live_array_set_command_handler(SWIGTYPE_p_switch_live_array_s.getCPtr(la), SWIGTYPE_p_f_p_switch_live_array_s_p_q_const__char_p_q_const__char_p_cJSON_p_void__void.getCPtr(command_handler)); + } + + public static void switch_live_array_parse_json(SWIGTYPE_p_cJSON json, uint channel_id) { + freeswitchPINVOKE.switch_live_array_parse_json(SWIGTYPE_p_cJSON.getCPtr(json), channel_id); + } + + public static switch_bool_t switch_live_array_add_alias(SWIGTYPE_p_switch_live_array_s la, string event_channel, string name) { + switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_live_array_add_alias(SWIGTYPE_p_switch_live_array_s.getCPtr(la), event_channel, name); + return ret; + } + + public static switch_bool_t switch_live_array_clear_alias(SWIGTYPE_p_switch_live_array_s la, string event_channel, string name) { + switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_live_array_clear_alias(SWIGTYPE_p_switch_live_array_s.getCPtr(la), event_channel, name); + return ret; + } + + public static switch_bool_t switch_event_channel_permission_verify(string cookie, string event_channel) { + switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_event_channel_permission_verify(cookie, event_channel); + return ret; + } + + public static void switch_event_channel_permission_modify(string cookie, string event_channel, switch_bool_t set) { + freeswitchPINVOKE.switch_event_channel_permission_modify(cookie, event_channel, (int)set); + } + + public static void switch_event_channel_permission_clear(string cookie) { + freeswitchPINVOKE.switch_event_channel_permission_clear(cookie); + } + public static switch_status_t switch_resample_perform_create(SWIGTYPE_p_p_switch_audio_resampler_t new_resampler, uint from_rate, uint to_rate, uint to_size, int quality, uint channels, string file, string func, int line) { switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_resample_perform_create(SWIGTYPE_p_p_switch_audio_resampler_t.getCPtr(new_resampler), from_rate, to_rate, to_size, quality, channels, file, func, line); return ret; @@ -6062,10 +6239,6 @@ public class freeswitch { freeswitchPINVOKE.switch_rtp_set_telephony_recv_event(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), te); } - public static void switch_rtp_set_recv_pt(SWIGTYPE_p_switch_rtp rtp_session, byte pt) { - freeswitchPINVOKE.switch_rtp_set_recv_pt(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), pt); - } - public static void switch_rtp_set_cng_pt(SWIGTYPE_p_switch_rtp rtp_session, byte pt) { freeswitchPINVOKE.switch_rtp_set_cng_pt(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), pt); } @@ -6076,6 +6249,11 @@ public class freeswitch { return ret; } + public static switch_status_t switch_rtp_set_payload_map(SWIGTYPE_p_switch_rtp rtp_session, SWIGTYPE_p_p_payload_map_t pmap) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_set_payload_map(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), SWIGTYPE_p_p_payload_map_t.getCPtr(pmap)); + return ret; + } + public static void switch_rtp_intentional_bugs(SWIGTYPE_p_switch_rtp rtp_session, switch_rtp_bug_flag_t bugs) { freeswitchPINVOKE.switch_rtp_intentional_bugs(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), (int)bugs); } @@ -6100,6 +6278,11 @@ public class freeswitch { return ret; } + public static switch_status_t switch_rtp_del_dtls(SWIGTYPE_p_switch_rtp rtp_session, dtls_type_t type) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_del_dtls(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), (int)type); + return ret; + } + public static int switch_rtp_has_dtls() { int ret = freeswitchPINVOKE.switch_rtp_has_dtls(); return ret; @@ -6814,6 +6997,7 @@ public class freeswitch { public static readonly int SWITCH_DEFAULT_FILE_BUFFER_LEN = freeswitchPINVOKE.SWITCH_DEFAULT_FILE_BUFFER_LEN_get(); public static readonly int SWITCH_DTMF_LOG_LEN = freeswitchPINVOKE.SWITCH_DTMF_LOG_LEN_get(); public static readonly int SWITCH_MAX_TRANS = freeswitchPINVOKE.SWITCH_MAX_TRANS_get(); + public static readonly int SWITCH_CORE_SESSION_MAX_PRIVATES = freeswitchPINVOKE.SWITCH_CORE_SESSION_MAX_PRIVATES_get(); public static readonly int SWITCH_MAX_STACKS = freeswitchPINVOKE.SWITCH_MAX_STACKS_get(); public static readonly int SWITCH_THREAD_STACKSIZE = freeswitchPINVOKE.SWITCH_THREAD_STACKSIZE_get(); public static readonly int SWITCH_SYSTEM_THREAD_STACKSIZE = freeswitchPINVOKE.SWITCH_SYSTEM_THREAD_STACKSIZE_get(); @@ -6870,6 +7054,8 @@ public class freeswitch { public static readonly int SWITCH_CMD_CHUNK_LEN = freeswitchPINVOKE.SWITCH_CMD_CHUNK_LEN_get(); public static readonly int SWITCH_SMAX = freeswitchPINVOKE.SWITCH_SMAX_get(); public static readonly int SWITCH_SMIN = freeswitchPINVOKE.SWITCH_SMIN_get(); + public static readonly int NO_EVENT_CHANNEL_ID = freeswitchPINVOKE.NO_EVENT_CHANNEL_ID_get(); + public static readonly string SWITCH_EVENT_CHANNEL_GLOBAL = freeswitchPINVOKE.SWITCH_EVENT_CHANNEL_GLOBAL_get(); public static readonly int SWITCH_RESAMPLE_QUALITY = freeswitchPINVOKE.SWITCH_RESAMPLE_QUALITY_get(); public static readonly int SWITCH_RTP_MAX_BUF_LEN = freeswitchPINVOKE.SWITCH_RTP_MAX_BUF_LEN_get(); public static readonly int SWITCH_RTCP_MAX_BUF_LEN = freeswitchPINVOKE.SWITCH_RTCP_MAX_BUF_LEN_get(); @@ -7561,6 +7747,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_MAX_TRANS_get")] public static extern int SWITCH_MAX_TRANS_get(); + [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_CORE_SESSION_MAX_PRIVATES_get")] + public static extern int SWITCH_CORE_SESSION_MAX_PRIVATES_get(); + [DllImport("mod_managed", EntryPoint="CSharp_switch_dtmf_t_digit_set")] public static extern void switch_dtmf_t_digit_set(HandleRef jarg1, char jarg2); @@ -8683,6 +8872,12 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_alloc_get")] public static extern int switch_thread_data_t_alloc_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_pool_set")] + public static extern void switch_thread_data_t_pool_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_pool_get")] + public static extern IntPtr switch_thread_data_t_pool_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_new_switch_thread_data_t")] public static extern IntPtr new_switch_thread_data_t(); @@ -8755,6 +8950,12 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_hup_profile_get")] public static extern IntPtr switch_device_node_t_hup_profile_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_direction_set")] + public static extern void switch_device_node_t_direction_set(HandleRef jarg1, int jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_direction_get")] + public static extern int switch_device_node_t_direction_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_parent_set")] public static extern void switch_device_node_t_parent_set(HandleRef jarg1, HandleRef jarg2); @@ -8779,42 +8980,132 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_total_get")] public static extern uint switch_device_stats_t_total_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_total_in_set")] + public static extern void switch_device_stats_t_total_in_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_total_in_get")] + public static extern uint switch_device_stats_t_total_in_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_total_out_set")] + public static extern void switch_device_stats_t_total_out_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_total_out_get")] + public static extern uint switch_device_stats_t_total_out_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_offhook_set")] public static extern void switch_device_stats_t_offhook_set(HandleRef jarg1, uint jarg2); [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_offhook_get")] public static extern uint switch_device_stats_t_offhook_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_offhook_in_set")] + public static extern void switch_device_stats_t_offhook_in_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_offhook_in_get")] + public static extern uint switch_device_stats_t_offhook_in_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_offhook_out_set")] + public static extern void switch_device_stats_t_offhook_out_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_offhook_out_get")] + public static extern uint switch_device_stats_t_offhook_out_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_active_set")] public static extern void switch_device_stats_t_active_set(HandleRef jarg1, uint jarg2); [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_active_get")] public static extern uint switch_device_stats_t_active_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_active_in_set")] + public static extern void switch_device_stats_t_active_in_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_active_in_get")] + public static extern uint switch_device_stats_t_active_in_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_active_out_set")] + public static extern void switch_device_stats_t_active_out_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_active_out_get")] + public static extern uint switch_device_stats_t_active_out_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_held_set")] public static extern void switch_device_stats_t_held_set(HandleRef jarg1, uint jarg2); [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_held_get")] public static extern uint switch_device_stats_t_held_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_held_in_set")] + public static extern void switch_device_stats_t_held_in_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_held_in_get")] + public static extern uint switch_device_stats_t_held_in_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_held_out_set")] + public static extern void switch_device_stats_t_held_out_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_held_out_get")] + public static extern uint switch_device_stats_t_held_out_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_hup_set")] public static extern void switch_device_stats_t_hup_set(HandleRef jarg1, uint jarg2); [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_hup_get")] public static extern uint switch_device_stats_t_hup_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_hup_in_set")] + public static extern void switch_device_stats_t_hup_in_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_hup_in_get")] + public static extern uint switch_device_stats_t_hup_in_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_hup_out_set")] + public static extern void switch_device_stats_t_hup_out_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_hup_out_get")] + public static extern uint switch_device_stats_t_hup_out_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_ringing_set")] public static extern void switch_device_stats_t_ringing_set(HandleRef jarg1, uint jarg2); [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_ringing_get")] public static extern uint switch_device_stats_t_ringing_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_ringing_in_set")] + public static extern void switch_device_stats_t_ringing_in_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_ringing_in_get")] + public static extern uint switch_device_stats_t_ringing_in_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_ringing_out_set")] + public static extern void switch_device_stats_t_ringing_out_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_ringing_out_get")] + public static extern uint switch_device_stats_t_ringing_out_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_early_set")] public static extern void switch_device_stats_t_early_set(HandleRef jarg1, uint jarg2); [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_early_get")] public static extern uint switch_device_stats_t_early_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_early_in_set")] + public static extern void switch_device_stats_t_early_in_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_early_in_get")] + public static extern uint switch_device_stats_t_early_in_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_early_out_set")] + public static extern void switch_device_stats_t_early_out_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_early_out_get")] + public static extern uint switch_device_stats_t_early_out_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_ring_wait_set")] + public static extern void switch_device_stats_t_ring_wait_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_ring_wait_get")] + public static extern uint switch_device_stats_t_ring_wait_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_new_switch_device_stats_t")] public static extern IntPtr new_switch_device_stats_t(); @@ -8845,6 +9136,12 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_stats_get")] public static extern IntPtr switch_device_record_t_stats_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_last_stats_set")] + public static extern void switch_device_record_t_last_stats_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_last_stats_get")] + public static extern IntPtr switch_device_record_t_last_stats_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_state_set")] public static extern void switch_device_record_t_state_set(HandleRef jarg1, int jarg2); @@ -8875,6 +9172,36 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_last_call_time_get")] public static extern IntPtr switch_device_record_t_last_call_time_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_ring_start_set")] + public static extern void switch_device_record_t_ring_start_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_ring_start_get")] + public static extern IntPtr switch_device_record_t_ring_start_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_ring_stop_set")] + public static extern void switch_device_record_t_ring_stop_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_ring_stop_get")] + public static extern IntPtr switch_device_record_t_ring_stop_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_hold_start_set")] + public static extern void switch_device_record_t_hold_start_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_hold_start_get")] + public static extern IntPtr switch_device_record_t_hold_start_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_hold_stop_set")] + public static extern void switch_device_record_t_hold_stop_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_hold_stop_get")] + public static extern IntPtr switch_device_record_t_hold_stop_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_call_start_set")] + public static extern void switch_device_record_t_call_start_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_call_start_get")] + public static extern IntPtr switch_device_record_t_call_start_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_uuid_list_set")] public static extern void switch_device_record_t_uuid_list_set(HandleRef jarg1, HandleRef jarg2); @@ -8899,6 +9226,12 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_pool_get")] public static extern IntPtr switch_device_record_t_pool_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_user_data_set")] + public static extern void switch_device_record_t_user_data_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_user_data_get")] + public static extern IntPtr switch_device_record_t_user_data_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_new_switch_device_record_t")] public static extern IntPtr new_switch_device_record_t(); @@ -9439,6 +9772,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_core_get_switchname")] public static extern string switch_core_get_switchname(); + [DllImport("mod_managed", EntryPoint="CSharp_switch_core_get_domain")] + public static extern string switch_core_get_domain(int jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_core_set_variable")] public static extern void switch_core_set_variable(string jarg1, string jarg2); @@ -9505,6 +9841,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_exec")] public static extern int switch_core_session_exec(HandleRef jarg1, HandleRef jarg2, string jarg3); + [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_video_reset")] + public static extern void switch_core_session_video_reset(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_execute_application_get_flags")] public static extern int switch_core_session_execute_application_get_flags(HandleRef jarg1, string jarg2, string jarg3, HandleRef jarg4); @@ -9520,11 +9859,11 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_receive_event")] public static extern int switch_core_session_receive_event(HandleRef jarg1, HandleRef jarg2); - [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_get_private")] - public static extern IntPtr switch_core_session_get_private(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_get_private_class")] + public static extern IntPtr switch_core_session_get_private_class(HandleRef jarg1, int jarg2); - [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_set_private")] - public static extern int switch_core_session_set_private(HandleRef jarg1, HandleRef jarg2); + [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_set_private_class")] + public static extern int switch_core_session_set_private_class(HandleRef jarg1, HandleRef jarg2, int jarg3); [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_add_stream")] public static extern int switch_core_session_add_stream(HandleRef jarg1, HandleRef jarg2); @@ -9788,7 +10127,7 @@ class freeswitchPINVOKE { public static extern void switch_core_db_test_reactive(HandleRef jarg1, string jarg2, string jarg3, string jarg4); [DllImport("mod_managed", EntryPoint="CSharp_switch_core_perform_file_open")] - public static extern int switch_core_perform_file_open(string jarg1, string jarg2, int jarg3, HandleRef jarg4, string jarg5, byte jarg6, uint jarg7, uint jarg8, HandleRef jarg9); + public static extern int switch_core_perform_file_open(string jarg1, string jarg2, int jarg3, HandleRef jarg4, string jarg5, uint jarg6, uint jarg7, uint jarg8, HandleRef jarg9); [DllImport("mod_managed", EntryPoint="CSharp_switch_core_file_read")] public static extern int switch_core_file_read(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3); @@ -10381,6 +10720,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_stream_system_fork")] public static extern int switch_stream_system_fork(string jarg1, HandleRef jarg2); + [DllImport("mod_managed", EntryPoint="CSharp_switch_ice_direction")] + public static extern int switch_ice_direction(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_loadable_module_interface_module_name_set")] public static extern void switch_loadable_module_interface_module_name_set(HandleRef jarg1, string jarg2); @@ -10429,6 +10771,12 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_loadable_module_interface_api_interface_get")] public static extern IntPtr switch_loadable_module_interface_api_interface_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_loadable_module_interface_json_api_interface_set")] + public static extern void switch_loadable_module_interface_json_api_interface_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_loadable_module_interface_json_api_interface_get")] + public static extern IntPtr switch_loadable_module_interface_json_api_interface_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_loadable_module_interface_file_interface_set")] public static extern void switch_loadable_module_interface_file_interface_set(HandleRef jarg1, HandleRef jarg2); @@ -10543,6 +10891,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_loadable_module_get_api_interface")] public static extern IntPtr switch_loadable_module_get_api_interface(string jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_loadable_module_get_json_api_interface")] + public static extern IntPtr switch_loadable_module_get_json_api_interface(string jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_loadable_module_get_file_interface")] public static extern IntPtr switch_loadable_module_get_file_interface(string jarg1); @@ -10576,6 +10927,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_api_execute")] public static extern int switch_api_execute(string jarg1, string jarg2, HandleRef jarg3, HandleRef jarg4); + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_execute")] + public static extern int switch_json_api_execute(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3); + [DllImport("mod_managed", EntryPoint="CSharp_switch_loadable_module_load_module")] public static extern int switch_loadable_module_load_module(string jarg1, string jarg2, int jarg3, ref string jarg4); @@ -10597,6 +10951,15 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_core_codec_ready")] public static extern int switch_core_codec_ready(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_core_get_secondary_recover_callback")] + public static extern IntPtr switch_core_get_secondary_recover_callback(string jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_core_register_secondary_recover_callback")] + public static extern int switch_core_register_secondary_recover_callback(string jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_core_unregister_secondary_recover_callback")] + public static extern void switch_core_unregister_secondary_recover_callback(string jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_CMD_CHUNK_LEN_get")] public static extern int SWITCH_CMD_CHUNK_LEN_get(); @@ -10624,6 +10987,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_console_run_complete_func")] public static extern int switch_console_run_complete_func(string jarg1, string jarg2, string jarg3, HandleRef jarg4); + [DllImport("mod_managed", EntryPoint="CSharp_switch_console_push_match_unique")] + public static extern void switch_console_push_match_unique(HandleRef jarg1, string jarg2); + [DllImport("mod_managed", EntryPoint="CSharp_switch_console_push_match")] public static extern void switch_console_push_match(HandleRef jarg1, string jarg2); @@ -10795,6 +11161,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_find_local_ip")] public static extern int switch_find_local_ip(string jarg1, int jarg2, HandleRef jarg3, int jarg4); + [DllImport("mod_managed", EntryPoint="CSharp_switch_find_interface_ip")] + public static extern int switch_find_interface_ip(string jarg1, int jarg2, HandleRef jarg3, string jarg4, int jarg5); + [DllImport("mod_managed", EntryPoint="CSharp_get_addr")] public static extern string get_addr(string jarg1, HandleRef jarg2, HandleRef jarg3, HandleRef jarg4); @@ -11242,6 +11611,12 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_direction_get")] public static extern int switch_caller_profile_direction_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_logical_direction_set")] + public static extern void switch_caller_profile_logical_direction_set(HandleRef jarg1, int jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_logical_direction_get")] + public static extern int switch_caller_profile_logical_direction_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_soft_set")] public static extern void switch_caller_profile_soft_set(HandleRef jarg1, HandleRef jarg2); @@ -11479,6 +11854,12 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_frame_user_data_get")] public static extern IntPtr switch_frame_user_data_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_frame_pmap_set")] + public static extern void switch_frame_pmap_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_frame_pmap_get")] + public static extern IntPtr switch_frame_pmap_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_new_switch_frame")] public static extern IntPtr new_switch_frame(); @@ -12116,10 +12497,10 @@ class freeswitchPINVOKE { public static extern uint switch_file_handle_native_rate_get(HandleRef jarg1); [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_channels_set")] - public static extern void switch_file_handle_channels_set(HandleRef jarg1, byte jarg2); + public static extern void switch_file_handle_channels_set(HandleRef jarg1, uint jarg2); [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_channels_get")] - public static extern byte switch_file_handle_channels_get(HandleRef jarg1); + public static extern uint switch_file_handle_channels_get(HandleRef jarg1); [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_format_set")] public static extern void switch_file_handle_format_set(HandleRef jarg1, uint jarg2); @@ -12325,6 +12706,18 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle__params_get")] public static extern IntPtr switch_file_handle__params_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_cur_channels_set")] + public static extern void switch_file_handle_cur_channels_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_cur_channels_get")] + public static extern uint switch_file_handle_cur_channels_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_cur_samplerate_set")] + public static extern void switch_file_handle_cur_samplerate_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_cur_samplerate_get")] + public static extern uint switch_file_handle_cur_samplerate_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_new_switch_file_handle")] public static extern IntPtr new_switch_file_handle(); @@ -13615,6 +14008,66 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_api_interface")] public static extern void delete_switch_api_interface(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_interface_name_set")] + public static extern void switch_json_api_interface_interface_name_set(HandleRef jarg1, string jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_interface_name_get")] + public static extern string switch_json_api_interface_interface_name_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_desc_set")] + public static extern void switch_json_api_interface_desc_set(HandleRef jarg1, string jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_desc_get")] + public static extern string switch_json_api_interface_desc_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_function_set")] + public static extern void switch_json_api_interface_function_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_function_get")] + public static extern IntPtr switch_json_api_interface_function_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_syntax_set")] + public static extern void switch_json_api_interface_syntax_set(HandleRef jarg1, string jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_syntax_get")] + public static extern string switch_json_api_interface_syntax_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_rwlock_set")] + public static extern void switch_json_api_interface_rwlock_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_rwlock_get")] + public static extern IntPtr switch_json_api_interface_rwlock_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_refs_set")] + public static extern void switch_json_api_interface_refs_set(HandleRef jarg1, int jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_refs_get")] + public static extern int switch_json_api_interface_refs_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_reflock_set")] + public static extern void switch_json_api_interface_reflock_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_reflock_get")] + public static extern IntPtr switch_json_api_interface_reflock_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_parent_set")] + public static extern void switch_json_api_interface_parent_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_parent_get")] + public static extern IntPtr switch_json_api_interface_parent_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_next_set")] + public static extern void switch_json_api_interface_next_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_api_interface_next_get")] + public static extern IntPtr switch_json_api_interface_next_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_new_switch_json_api_interface")] + public static extern IntPtr new_switch_json_api_interface(); + + [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_json_api_interface")] + public static extern void delete_switch_json_api_interface(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_slin_data_session_set")] public static extern void switch_slin_data_session_set(HandleRef jarg1, HandleRef jarg2); @@ -14071,6 +14524,12 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_direction")] public static extern int switch_channel_direction(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_logical_direction")] + public static extern int switch_channel_logical_direction(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_set_direction")] + public static extern void switch_channel_set_direction(HandleRef jarg1, int jarg2); + [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_get_session")] public static extern IntPtr switch_channel_get_session(HandleRef jarg1); @@ -14485,6 +14944,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_event_serialize_json")] public static extern int switch_event_serialize_json(HandleRef jarg1, ref string jarg2); + [DllImport("mod_managed", EntryPoint="CSharp_switch_event_serialize_json_obj")] + public static extern int switch_event_serialize_json_obj(HandleRef jarg1, HandleRef jarg2); + [DllImport("mod_managed", EntryPoint="CSharp_switch_event_create_json")] public static extern int switch_event_create_json(HandleRef jarg1, string jarg2); @@ -14521,9 +14983,87 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_event_add_presence_data_cols")] public static extern void switch_event_add_presence_data_cols(HandleRef jarg1, HandleRef jarg2, string jarg3); + [DllImport("mod_managed", EntryPoint="CSharp_switch_json_add_presence_data_cols")] + public static extern void switch_json_add_presence_data_cols(HandleRef jarg1, HandleRef jarg2, string jarg3); + [DllImport("mod_managed", EntryPoint="CSharp_switch_event_launch_dispatch_threads")] public static extern void switch_event_launch_dispatch_threads(uint jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_event_channel_broadcast")] + public static extern uint switch_event_channel_broadcast(string jarg1, HandleRef jarg2, string jarg3, uint jarg4); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_event_channel_unbind")] + public static extern uint switch_event_channel_unbind(string jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_event_channel_bind")] + public static extern int switch_event_channel_bind(string jarg1, HandleRef jarg2, HandleRef jarg3); + + [DllImport("mod_managed", EntryPoint="CSharp_NO_EVENT_CHANNEL_ID_get")] + public static extern int NO_EVENT_CHANNEL_ID_get(); + + [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_EVENT_CHANNEL_GLOBAL_get")] + public static extern string SWITCH_EVENT_CHANNEL_GLOBAL_get(); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_clear")] + public static extern int switch_live_array_clear(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_bootstrap")] + public static extern int switch_live_array_bootstrap(HandleRef jarg1, string jarg2, uint jarg3); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_destroy")] + public static extern int switch_live_array_destroy(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_create")] + public static extern int switch_live_array_create(string jarg1, string jarg2, uint jarg3, HandleRef jarg4); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_get")] + public static extern IntPtr switch_live_array_get(HandleRef jarg1, string jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_get_idx")] + public static extern IntPtr switch_live_array_get_idx(HandleRef jarg1, int jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_del")] + public static extern int switch_live_array_del(HandleRef jarg1, string jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_add")] + public static extern int switch_live_array_add(HandleRef jarg1, string jarg2, int jarg3, HandleRef jarg4, int jarg5); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_visible")] + public static extern int switch_live_array_visible(HandleRef jarg1, int jarg2, int jarg3); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_isnew")] + public static extern int switch_live_array_isnew(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_lock")] + public static extern void switch_live_array_lock(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_unlock")] + public static extern void switch_live_array_unlock(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_set_user_data")] + public static extern void switch_live_array_set_user_data(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_set_command_handler")] + public static extern void switch_live_array_set_command_handler(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_parse_json")] + public static extern void switch_live_array_parse_json(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_add_alias")] + public static extern int switch_live_array_add_alias(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_live_array_clear_alias")] + public static extern int switch_live_array_clear_alias(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_event_channel_permission_verify")] + public static extern int switch_event_channel_permission_verify(string jarg1, string jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_event_channel_permission_modify")] + public static extern void switch_event_channel_permission_modify(string jarg1, string jarg2, int jarg3); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_event_channel_permission_clear")] + public static extern void switch_event_channel_permission_clear(string jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_RESAMPLE_QUALITY_get")] public static extern int SWITCH_RESAMPLE_QUALITY_get(); @@ -15511,15 +16051,15 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_telephony_recv_event")] public static extern void switch_rtp_set_telephony_recv_event(HandleRef jarg1, byte jarg2); - [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_recv_pt")] - public static extern void switch_rtp_set_recv_pt(HandleRef jarg1, byte jarg2); - [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_cng_pt")] public static extern void switch_rtp_set_cng_pt(HandleRef jarg1, byte jarg2); [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_get_private")] public static extern IntPtr switch_rtp_get_private(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_payload_map")] + public static extern int switch_rtp_set_payload_map(HandleRef jarg1, HandleRef jarg2); + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_intentional_bugs")] public static extern void switch_rtp_intentional_bugs(HandleRef jarg1, int jarg2); @@ -15535,6 +16075,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_add_dtls")] public static extern int switch_rtp_add_dtls(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3, int jarg4); + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_del_dtls")] + public static extern int switch_rtp_del_dtls(HandleRef jarg1, int jarg2); + [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_has_dtls")] public static extern int switch_rtp_has_dtls(); @@ -16264,6 +16807,12 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_scheduler_task_cmd_id_get")] public static extern uint switch_scheduler_task_cmd_id_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_scheduler_task_repeat_set")] + public static extern void switch_scheduler_task_repeat_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_scheduler_task_repeat_get")] + public static extern uint switch_scheduler_task_repeat_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_scheduler_task_group_set")] public static extern void switch_scheduler_task_group_set(HandleRef jarg1, string jarg2); @@ -16403,7 +16952,7 @@ class freeswitchPINVOKE { public static extern void IvrMenu_Execute(HandleRef jarg1, HandleRef jarg2, string jarg3); [DllImport("mod_managed", EntryPoint="CSharp_new_Api")] - public static extern IntPtr new_Api(); + public static extern IntPtr new_Api(HandleRef jarg1); [DllImport("mod_managed", EntryPoint="CSharp_delete_Api")] public static extern void delete_Api(HandleRef jarg1); @@ -17624,6 +18173,36 @@ namespace FreeSWITCH.Native { using System; using System.Runtime.InteropServices; +public class SWIGTYPE_p_cJSON { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_cJSON(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_cJSON() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_cJSON obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +using System; +using System.Runtime.InteropServices; + public class SWIGTYPE_p_FILE { private HandleRef swigCPtr; @@ -17744,6 +18323,36 @@ namespace FreeSWITCH.Native { using System; using System.Runtime.InteropServices; +public class SWIGTYPE_p_f_p_q_const__char_p_cJSON_p_q_const__char_unsigned_long__void { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_f_p_q_const__char_p_cJSON_p_q_const__char_unsigned_long__void(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_f_p_q_const__char_p_cJSON_p_q_const__char_unsigned_long__void() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_f_p_q_const__char_p_cJSON_p_q_const__char_unsigned_long__void obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +using System; +using System.Runtime.InteropServices; + public class SWIGTYPE_p_f_p_q_const__char_p_q_const__char_p_p_switch_console_callback_match__switch_status_t { private HandleRef swigCPtr; @@ -17954,6 +18563,36 @@ namespace FreeSWITCH.Native { using System; using System.Runtime.InteropServices; +public class SWIGTYPE_p_f_p_q_const__cJSON_p_switch_core_session_p_p_cJSON__switch_status_t { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_f_p_q_const__cJSON_p_switch_core_session_p_p_cJSON__switch_status_t(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_f_p_q_const__cJSON_p_switch_core_session_p_p_cJSON__switch_status_t() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_f_p_q_const__cJSON_p_switch_core_session_p_p_cJSON__switch_status_t obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +using System; +using System.Runtime.InteropServices; + public class SWIGTYPE_p_f_p_q_const__switch_log_node_t_enum_switch_log_level_t__switch_status_t { private HandleRef swigCPtr; @@ -19634,6 +20273,36 @@ namespace FreeSWITCH.Native { using System; using System.Runtime.InteropServices; +public class SWIGTYPE_p_f_p_switch_live_array_s_p_q_const__char_p_q_const__char_p_cJSON_p_void__void { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_f_p_switch_live_array_s_p_q_const__char_p_q_const__char_p_cJSON_p_void__void(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_f_p_switch_live_array_s_p_q_const__char_p_q_const__char_p_cJSON_p_void__void() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_live_array_s_p_q_const__char_p_q_const__char_p_cJSON_p_void__void obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +using System; +using System.Runtime.InteropServices; + public class SWIGTYPE_p_f_p_switch_media_bug_p_void_enum_switch_abc_type_t__switch_bool_t { private HandleRef swigCPtr; @@ -20444,6 +21113,36 @@ namespace FreeSWITCH.Native { using System; using System.Runtime.InteropServices; +public class SWIGTYPE_p_payload_map_t { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_payload_map_t(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_payload_map_t() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_payload_map_t obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +using System; +using System.Runtime.InteropServices; + public class SWIGTYPE_p_pid_t { private HandleRef swigCPtr; @@ -20564,6 +21263,36 @@ namespace FreeSWITCH.Native { using System; using System.Runtime.InteropServices; +public class SWIGTYPE_p_p_payload_map_t { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_p_payload_map_t(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_p_payload_map_t() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_p_payload_map_t obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +using System; +using System.Runtime.InteropServices; + public class SWIGTYPE_p_p_p_char { private HandleRef swigCPtr; @@ -21344,6 +22073,36 @@ namespace FreeSWITCH.Native { using System; using System.Runtime.InteropServices; +public class SWIGTYPE_p_p_switch_live_array_s { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_p_switch_live_array_s(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_p_switch_live_array_s() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_p_switch_live_array_s obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +using System; +using System.Runtime.InteropServices; + public class SWIGTYPE_p_p_switch_log_node_t { private HandleRef swigCPtr; @@ -22394,6 +23153,36 @@ namespace FreeSWITCH.Native { using System; using System.Runtime.InteropServices; +public class SWIGTYPE_p_switch_live_array_s { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_switch_live_array_s(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_switch_live_array_s() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_switch_live_array_s obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +using System; +using System.Runtime.InteropServices; + public class SWIGTYPE_p_switch_media_bug { private HandleRef swigCPtr; @@ -25573,6 +26362,16 @@ public class switch_caller_profile : IDisposable { } } + public switch_call_direction_t logical_direction { + set { + freeswitchPINVOKE.switch_caller_profile_logical_direction_set(swigCPtr, (int)value); + } + get { + switch_call_direction_t ret = (switch_call_direction_t)freeswitchPINVOKE.switch_caller_profile_logical_direction_get(swigCPtr); + return ret; + } + } + public profile_node_t soft { set { freeswitchPINVOKE.switch_caller_profile_soft_set(swigCPtr, profile_node_t.getCPtr(value)); @@ -25773,6 +26572,7 @@ public enum switch_channel_callstate_t { CCS_EARLY, CCS_ACTIVE, CCS_HELD, + CCS_RING_WAIT, CCS_HANGUP, CCS_UNHOLD } @@ -25892,6 +26692,7 @@ public enum switch_channel_flag_t { CF_CONFIRM_BLIND_TRANSFER, CF_NO_PRESENCE, CF_CONFERENCE, + CF_CONFERENCE_ADV, CF_RECOVERING, CF_RECOVERING_BRIDGE, CF_TRACKED, @@ -25923,6 +26724,8 @@ public enum switch_channel_flag_t { CF_VIDEO_PASSIVE, CF_NOVIDEO, CF_VIDEO_ECHO, + CF_SLA_INTERCEPT, + CF_VIDEO_BREAK, CF_FLAG_MAX } @@ -27868,6 +28671,10 @@ public enum switch_core_session_message_types_t { SWITCH_MESSAGE_INDICATE_BLIND_TRANSFER_RESPONSE, SWITCH_MESSAGE_INDICATE_STUN_ERROR, SWITCH_MESSAGE_INDICATE_MEDIA_RENEG, + SWITCH_MESSAGE_REFER_EVENT, + SWITCH_MESSAGE_ANSWER_EVENT, + SWITCH_MESSAGE_PROGRESS_EVENT, + SWITCH_MESSAGE_RING_EVENT, SWITCH_MESSAGE_INVALID } @@ -28201,6 +29008,16 @@ public class switch_device_node_t : IDisposable { } } + public switch_call_direction_t direction { + set { + freeswitchPINVOKE.switch_device_node_t_direction_set(swigCPtr, (int)value); + } + get { + switch_call_direction_t ret = (switch_call_direction_t)freeswitchPINVOKE.switch_device_node_t_direction_get(swigCPtr); + return ret; + } + } + public switch_device_record_t parent { set { freeswitchPINVOKE.switch_device_node_t_parent_set(swigCPtr, switch_device_record_t.getCPtr(value)); @@ -28313,6 +29130,17 @@ public class switch_device_record_t : IDisposable { } } + public switch_device_stats_t last_stats { + set { + freeswitchPINVOKE.switch_device_record_t_last_stats_set(swigCPtr, switch_device_stats_t.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_device_record_t_last_stats_get(swigCPtr); + switch_device_stats_t ret = (cPtr == IntPtr.Zero) ? null : new switch_device_stats_t(cPtr, false); + return ret; + } + } + public switch_device_state_t state { set { freeswitchPINVOKE.switch_device_record_t_state_set(swigCPtr, (int)value); @@ -28369,6 +29197,66 @@ public class switch_device_record_t : IDisposable { } } + public SWIGTYPE_p_switch_time_t ring_start { + set { + freeswitchPINVOKE.switch_device_record_t_ring_start_set(swigCPtr, SWIGTYPE_p_switch_time_t.getCPtr(value)); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + } + get { + SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_device_record_t_ring_start_get(swigCPtr), true); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public SWIGTYPE_p_switch_time_t ring_stop { + set { + freeswitchPINVOKE.switch_device_record_t_ring_stop_set(swigCPtr, SWIGTYPE_p_switch_time_t.getCPtr(value)); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + } + get { + SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_device_record_t_ring_stop_get(swigCPtr), true); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public SWIGTYPE_p_switch_time_t hold_start { + set { + freeswitchPINVOKE.switch_device_record_t_hold_start_set(swigCPtr, SWIGTYPE_p_switch_time_t.getCPtr(value)); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + } + get { + SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_device_record_t_hold_start_get(swigCPtr), true); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public SWIGTYPE_p_switch_time_t hold_stop { + set { + freeswitchPINVOKE.switch_device_record_t_hold_stop_set(swigCPtr, SWIGTYPE_p_switch_time_t.getCPtr(value)); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + } + get { + SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_device_record_t_hold_stop_get(swigCPtr), true); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public SWIGTYPE_p_switch_time_t call_start { + set { + freeswitchPINVOKE.switch_device_record_t_call_start_set(swigCPtr, SWIGTYPE_p_switch_time_t.getCPtr(value)); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + } + get { + SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_device_record_t_call_start_get(swigCPtr), true); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + public switch_device_node_t uuid_list { set { freeswitchPINVOKE.switch_device_record_t_uuid_list_set(swigCPtr, switch_device_node_t.getCPtr(value)); @@ -28413,6 +29301,17 @@ public class switch_device_record_t : IDisposable { } } + public SWIGTYPE_p_void user_data { + set { + freeswitchPINVOKE.switch_device_record_t_user_data_set(swigCPtr, SWIGTYPE_p_void.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_device_record_t_user_data_get(swigCPtr); + SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false); + return ret; + } + } + public switch_device_record_t() : this(freeswitchPINVOKE.new_switch_device_record_t(), true) { } @@ -28492,6 +29391,26 @@ public class switch_device_stats_t : IDisposable { } } + public uint total_in { + set { + freeswitchPINVOKE.switch_device_stats_t_total_in_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_total_in_get(swigCPtr); + return ret; + } + } + + public uint total_out { + set { + freeswitchPINVOKE.switch_device_stats_t_total_out_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_total_out_get(swigCPtr); + return ret; + } + } + public uint offhook { set { freeswitchPINVOKE.switch_device_stats_t_offhook_set(swigCPtr, value); @@ -28502,6 +29421,26 @@ public class switch_device_stats_t : IDisposable { } } + public uint offhook_in { + set { + freeswitchPINVOKE.switch_device_stats_t_offhook_in_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_offhook_in_get(swigCPtr); + return ret; + } + } + + public uint offhook_out { + set { + freeswitchPINVOKE.switch_device_stats_t_offhook_out_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_offhook_out_get(swigCPtr); + return ret; + } + } + public uint active { set { freeswitchPINVOKE.switch_device_stats_t_active_set(swigCPtr, value); @@ -28512,6 +29451,26 @@ public class switch_device_stats_t : IDisposable { } } + public uint active_in { + set { + freeswitchPINVOKE.switch_device_stats_t_active_in_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_active_in_get(swigCPtr); + return ret; + } + } + + public uint active_out { + set { + freeswitchPINVOKE.switch_device_stats_t_active_out_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_active_out_get(swigCPtr); + return ret; + } + } + public uint held { set { freeswitchPINVOKE.switch_device_stats_t_held_set(swigCPtr, value); @@ -28522,6 +29481,26 @@ public class switch_device_stats_t : IDisposable { } } + public uint held_in { + set { + freeswitchPINVOKE.switch_device_stats_t_held_in_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_held_in_get(swigCPtr); + return ret; + } + } + + public uint held_out { + set { + freeswitchPINVOKE.switch_device_stats_t_held_out_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_held_out_get(swigCPtr); + return ret; + } + } + public uint hup { set { freeswitchPINVOKE.switch_device_stats_t_hup_set(swigCPtr, value); @@ -28532,6 +29511,26 @@ public class switch_device_stats_t : IDisposable { } } + public uint hup_in { + set { + freeswitchPINVOKE.switch_device_stats_t_hup_in_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_hup_in_get(swigCPtr); + return ret; + } + } + + public uint hup_out { + set { + freeswitchPINVOKE.switch_device_stats_t_hup_out_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_hup_out_get(swigCPtr); + return ret; + } + } + public uint ringing { set { freeswitchPINVOKE.switch_device_stats_t_ringing_set(swigCPtr, value); @@ -28542,6 +29541,26 @@ public class switch_device_stats_t : IDisposable { } } + public uint ringing_in { + set { + freeswitchPINVOKE.switch_device_stats_t_ringing_in_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_ringing_in_get(swigCPtr); + return ret; + } + } + + public uint ringing_out { + set { + freeswitchPINVOKE.switch_device_stats_t_ringing_out_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_ringing_out_get(swigCPtr); + return ret; + } + } + public uint early { set { freeswitchPINVOKE.switch_device_stats_t_early_set(swigCPtr, value); @@ -28552,6 +29571,36 @@ public class switch_device_stats_t : IDisposable { } } + public uint early_in { + set { + freeswitchPINVOKE.switch_device_stats_t_early_in_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_early_in_get(swigCPtr); + return ret; + } + } + + public uint early_out { + set { + freeswitchPINVOKE.switch_device_stats_t_early_out_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_early_out_get(swigCPtr); + return ret; + } + } + + public uint ring_wait { + set { + freeswitchPINVOKE.switch_device_stats_t_ring_wait_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_ring_wait_get(swigCPtr); + return ret; + } + } + public switch_device_stats_t() : this(freeswitchPINVOKE.new_switch_device_stats_t(), true) { } @@ -29842,6 +30891,8 @@ public enum switch_event_types_t { SWITCH_EVENT_RE_SCHEDULE, SWITCH_EVENT_RELOADXML, SWITCH_EVENT_NOTIFY, + SWITCH_EVENT_PHONE_FEATURE, + SWITCH_EVENT_PHONE_FEATURE_SUBSCRIBE, SWITCH_EVENT_SEND_MESSAGE, SWITCH_EVENT_RECV_MESSAGE, SWITCH_EVENT_REQUEST_PARAMS, @@ -29962,7 +31013,8 @@ namespace FreeSWITCH.Native { SWITCH_FILE_BUFFER_DONE = (1 << 14), SWITCH_FILE_WRITE_APPEND = (1 << 15), SWITCH_FILE_WRITE_OVER = (1 << 16), - SWITCH_FILE_NOMUX = (1 << 17) + SWITCH_FILE_NOMUX = (1 << 17), + SWITCH_FILE_BREAK_ON_CHANGE = (1 << 18) } } @@ -30071,12 +31123,12 @@ public class switch_file_handle : IDisposable { } } - public byte channels { + public uint channels { set { freeswitchPINVOKE.switch_file_handle_channels_set(swigCPtr, value); } get { - byte ret = freeswitchPINVOKE.switch_file_handle_channels_get(swigCPtr); + uint ret = freeswitchPINVOKE.switch_file_handle_channels_get(swigCPtr); return ret; } } @@ -30441,6 +31493,26 @@ public class switch_file_handle : IDisposable { } } + public uint cur_channels { + set { + freeswitchPINVOKE.switch_file_handle_cur_channels_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_file_handle_cur_channels_get(swigCPtr); + return ret; + } + } + + public uint cur_samplerate { + set { + freeswitchPINVOKE.switch_file_handle_cur_samplerate_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_file_handle_cur_samplerate_get(swigCPtr); + return ret; + } + } + public switch_file_handle() : this(freeswitchPINVOKE.new_switch_file_handle(), true) { } @@ -30899,6 +31971,17 @@ public class switch_frame : IDisposable { } } + public SWIGTYPE_p_payload_map_t pmap { + set { + freeswitchPINVOKE.switch_frame_pmap_set(swigCPtr, SWIGTYPE_p_payload_map_t.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_frame_pmap_get(swigCPtr); + SWIGTYPE_p_payload_map_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_payload_map_t(cPtr, false); + return ret; + } + } + public switch_frame() : this(freeswitchPINVOKE.new_switch_frame(), true) { } @@ -32618,6 +33701,150 @@ namespace FreeSWITCH.Native { using System; using System.Runtime.InteropServices; +public class switch_json_api_interface : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal switch_json_api_interface(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(switch_json_api_interface obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~switch_json_api_interface() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + freeswitchPINVOKE.delete_switch_json_api_interface(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public string interface_name { + set { + freeswitchPINVOKE.switch_json_api_interface_interface_name_set(swigCPtr, value); + } + get { + string ret = freeswitchPINVOKE.switch_json_api_interface_interface_name_get(swigCPtr); + return ret; + } + } + + public string desc { + set { + freeswitchPINVOKE.switch_json_api_interface_desc_set(swigCPtr, value); + } + get { + string ret = freeswitchPINVOKE.switch_json_api_interface_desc_get(swigCPtr); + return ret; + } + } + + public SWIGTYPE_p_f_p_q_const__cJSON_p_switch_core_session_p_p_cJSON__switch_status_t function { + set { + freeswitchPINVOKE.switch_json_api_interface_function_set(swigCPtr, SWIGTYPE_p_f_p_q_const__cJSON_p_switch_core_session_p_p_cJSON__switch_status_t.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_json_api_interface_function_get(swigCPtr); + SWIGTYPE_p_f_p_q_const__cJSON_p_switch_core_session_p_p_cJSON__switch_status_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_q_const__cJSON_p_switch_core_session_p_p_cJSON__switch_status_t(cPtr, false); + return ret; + } + } + + public string syntax { + set { + freeswitchPINVOKE.switch_json_api_interface_syntax_set(swigCPtr, value); + } + get { + string ret = freeswitchPINVOKE.switch_json_api_interface_syntax_get(swigCPtr); + return ret; + } + } + + public SWIGTYPE_p_switch_thread_rwlock_t rwlock { + set { + freeswitchPINVOKE.switch_json_api_interface_rwlock_set(swigCPtr, SWIGTYPE_p_switch_thread_rwlock_t.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_json_api_interface_rwlock_get(swigCPtr); + SWIGTYPE_p_switch_thread_rwlock_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_thread_rwlock_t(cPtr, false); + return ret; + } + } + + public int refs { + set { + freeswitchPINVOKE.switch_json_api_interface_refs_set(swigCPtr, value); + } + get { + int ret = freeswitchPINVOKE.switch_json_api_interface_refs_get(swigCPtr); + return ret; + } + } + + public SWIGTYPE_p_switch_mutex_t reflock { + set { + freeswitchPINVOKE.switch_json_api_interface_reflock_set(swigCPtr, SWIGTYPE_p_switch_mutex_t.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_json_api_interface_reflock_get(swigCPtr); + SWIGTYPE_p_switch_mutex_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_mutex_t(cPtr, false); + return ret; + } + } + + public switch_loadable_module_interface parent { + set { + freeswitchPINVOKE.switch_json_api_interface_parent_set(swigCPtr, switch_loadable_module_interface.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_json_api_interface_parent_get(swigCPtr); + switch_loadable_module_interface ret = (cPtr == IntPtr.Zero) ? null : new switch_loadable_module_interface(cPtr, false); + return ret; + } + } + + public switch_json_api_interface next { + set { + freeswitchPINVOKE.switch_json_api_interface_next_set(swigCPtr, switch_json_api_interface.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_json_api_interface_next_get(swigCPtr); + switch_json_api_interface ret = (cPtr == IntPtr.Zero) ? null : new switch_json_api_interface(cPtr, false); + return ret; + } + } + + public switch_json_api_interface() : this(freeswitchPINVOKE.new_switch_json_api_interface(), true) { + } + +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +using System; +using System.Runtime.InteropServices; + public class switch_limit_interface : IDisposable { private HandleRef swigCPtr; protected bool swigCMemOwn; @@ -33016,6 +34243,17 @@ public class switch_loadable_module_interface : IDisposable { } } + public switch_json_api_interface json_api_interface { + set { + freeswitchPINVOKE.switch_loadable_module_interface_json_api_interface_set(swigCPtr, switch_json_api_interface.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_loadable_module_interface_json_api_interface_get(swigCPtr); + switch_json_api_interface ret = (cPtr == IntPtr.Zero) ? null : new switch_json_api_interface(cPtr, false); + return ret; + } + } + public switch_file_interface file_interface { set { freeswitchPINVOKE.switch_loadable_module_interface_file_interface_set(swigCPtr, switch_file_interface.getCPtr(value)); @@ -33581,7 +34819,8 @@ public enum switch_module_interface_name_t { SWITCH_ASR_INTERFACE, SWITCH_MANAGEMENT_INTERFACE, SWITCH_LIMIT_INTERFACE, - SWITCH_CHAT_APPLICATION_INTERFACE + SWITCH_CHAT_APPLICATION_INTERFACE, + SWITCH_JSON_API_INTERFACE } } @@ -33599,9 +34838,11 @@ namespace FreeSWITCH.Native { SOF_NONE = 0, SOF_NOBLOCK = (1 << 0), SOF_FORKED_DIAL = (1 << 1), - SOF_NO_EFFECTIVE_CID_NUM = (1 << 2), - SOF_NO_EFFECTIVE_CID_NAME = (1 << 3), - SOF_NO_LIMITS = (1 << 4) + SOF_NO_EFFECTIVE_ANI = (1 << 2), + SOF_NO_EFFECTIVE_ANIII = (1 << 3), + SOF_NO_EFFECTIVE_CID_NUM = (1 << 4), + SOF_NO_EFFECTIVE_CID_NAME = (1 << 5), + SOF_NO_LIMITS = (1 << 6) } } @@ -33649,6 +34890,22 @@ public enum switch_priority_t { namespace FreeSWITCH.Native { +public enum switch_pvt_class_t { + SWITCH_PVT_PRIMARY = 0, + SWITCH_PVT_SECONDARY +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + public enum switch_ring_ready_t { SWITCH_RING_READY_NONE, SWITCH_RING_READY_RINGING, @@ -33856,7 +35113,8 @@ public enum switch_rtp_bug_flag_t { RTP_BUG_ACCEPT_ANY_PACKETS = (1 << 7), RTP_BUG_GEN_ONE_GEN_ALL = (1 << 8), RTP_BUG_CHANGE_SSRC_ON_MARKER = (1 << 9), - RTP_BUG_FLUSH_JB_ON_DTMF = (1 << 10) + RTP_BUG_FLUSH_JB_ON_DTMF = (1 << 10), + RTP_BUG_ACCEPT_ANY_PAYLOAD = (1 << 11) } } @@ -34044,6 +35302,9 @@ public enum switch_rtp_flag_t { SWITCH_RTP_FLAG_VIDEO, SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_RTCP_MUX, + SWITCH_RTP_FLAG_KILL_JB, + SWITCH_RTP_FLAG_VIDEO_BREAK, + SWITCH_RTP_FLAG_PAUSE, SWITCH_RTP_FLAG_INVALID } @@ -34930,6 +36191,16 @@ public class switch_scheduler_task : IDisposable { } } + public uint repeat { + set { + freeswitchPINVOKE.switch_scheduler_task_repeat_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_scheduler_task_repeat_get(swigCPtr); + return ret; + } + } + public string group { set { freeswitchPINVOKE.switch_scheduler_task_group_set(swigCPtr, value); @@ -36056,7 +37327,9 @@ public enum switch_status_t { SWITCH_STATUS_FOUND, SWITCH_STATUS_CONTINUE, SWITCH_STATUS_TERM, - SWITCH_STATUS_NOT_INITALIZED + SWITCH_STATUS_NOT_INITALIZED, + SWITCH_STATUS_XBREAK = 35, + SWITCH_STATUS_WINBREAK = 730035 } } @@ -36505,6 +37778,17 @@ public class switch_thread_data_t : IDisposable { } } + public SWIGTYPE_p_apr_pool_t pool { + set { + freeswitchPINVOKE.switch_thread_data_t_pool_set(swigCPtr, SWIGTYPE_p_apr_pool_t.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_thread_data_t_pool_get(swigCPtr); + SWIGTYPE_p_apr_pool_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_apr_pool_t(cPtr, false); + return ret; + } + } + public switch_thread_data_t() : this(freeswitchPINVOKE.new_switch_thread_data_t(), true) { } @@ -37377,7 +38661,7 @@ namespace FreeSWITCH.Native { SWITCH_XML_SECTION_CONFIG = (1 << 0), SWITCH_XML_SECTION_DIRECTORY = (1 << 1), SWITCH_XML_SECTION_DIALPLAN = (1 << 2), - SWITCH_XML_SECTION_PHRASES = (1 << 3), + SWITCH_XML_SECTION_LANGUAGES = (1 << 3), SWITCH_XML_SECTION_CHATPLAN = (1 << 4), SWITCH_XML_SECTION_MAX = (1 << 4) } diff --git a/src/switch_core_media.c b/src/switch_core_media.c index 59eacde94c..bbef0b79bd 100644 --- a/src/switch_core_media.c +++ b/src/switch_core_media.c @@ -510,10 +510,10 @@ SWITCH_DECLARE(payload_map_t *) switch_core_media_add_payload_map(switch_core_se } pmap->allocated = 1; - pmap->recv_pt = pt; + pmap->recv_pt = (switch_payload_t)pt; if (sdp_type == SDP_TYPE_REQUEST || !exists) { - pmap->pt = pt; + pmap->pt = (switch_payload_t)pt; } if (negotiated) {