confbridge: Add support for disabling text messaging.
[asterisk/asterisk.git] / apps / confbridge / include / confbridge.h
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2011, Digium, Inc.
5  *
6  * David Vossel <dvossel@digium.com>
7  * Joshua Colp <jcolp@digium.com>
8  *
9  * See http://www.asterisk.org for more information about
10  * the Asterisk project. Please do not directly contact
11  * any of the maintainers of this project for assistance;
12  * the project provides a web site, mailing lists and IRC
13  * channels for your use.
14  *
15  * This program is free software, distributed under the terms of
16  * the GNU General Public License Version 2. See the LICENSE file
17  * at the top of the source tree.
18  */
19
20
21 #ifndef _CONFBRIDGE_H
22 #define _CONFBRIDGE_H
23
24 #include "asterisk.h"
25 #include "asterisk/app.h"
26 #include "asterisk/logger.h"
27 #include "asterisk/linkedlists.h"
28 #include "asterisk/channel.h"
29 #include "asterisk/bridge.h"
30 #include "asterisk/bridge_features.h"
31 #include "asterisk/stasis_bridges.h"
32 #include "conf_state.h"
33
34 /*! Maximum length of a conference bridge name */
35 #define MAX_CONF_NAME AST_MAX_EXTENSION
36 /*! Maximum length of a conference pin */
37 #define MAX_PIN     80
38 /*! Maximum length of bridge/user/menu profile names */
39 #define MAX_PROFILE_NAME 128
40
41 #define DEFAULT_USER_PROFILE "default_user"
42 #define DEFAULT_BRIDGE_PROFILE "default_bridge"
43 #define DEFAULT_MENU_PROFILE "default_menu"
44
45 /*! Default minimum average magnitude threshold to determine talking by the DSP. */
46 #define DEFAULT_TALKING_THRESHOLD 160
47
48 /*! Default time in ms of silence necessary to declare talking stopped by the bridge. */
49 #define DEFAULT_SILENCE_THRESHOLD 2500
50
51 enum user_profile_flags {
52         USER_OPT_ADMIN =        (1 << 0), /*!< Set if the caller is an administrator */
53         USER_OPT_NOONLYPERSON = (1 << 1), /*!< Set if the "you are currently the only person in this conference" sound file should not be played */
54         USER_OPT_MARKEDUSER =   (1 << 2), /*!< Set if the caller is a marked user */
55         USER_OPT_STARTMUTED =   (1 << 3), /*!< Set if the caller should be initially set muted */
56         USER_OPT_MUSICONHOLD =  (1 << 4), /*!< Set if music on hold should be played if nobody else is in the conference bridge */
57         USER_OPT_QUIET =        (1 << 5), /*!< Set if no audio prompts should be played */
58         USER_OPT_ANNOUNCEUSERCOUNT = (1 << 6), /*!< Set if the number of users should be announced to the caller */
59         USER_OPT_WAITMARKED =   (1 << 7), /*!< Set if the user must wait for a marked user before starting */
60         USER_OPT_ENDMARKED =    (1 << 8), /*!< Set if the user should be kicked after the last Marked user exits */
61         USER_OPT_DENOISE =      (1 << 9), /*!< Sets if denoise filter should be used on audio before mixing. */
62         USER_OPT_ANNOUNCE_JOIN_LEAVE = (1 << 10), /*!< Sets if the user's name should be recorded and announced on join and leave. */
63         USER_OPT_TALKER_DETECT = (1 << 11), /*!< Sets if start and stop talking events should generated for this user over AMI. */
64         USER_OPT_DROP_SILENCE =  (1 << 12), /*!< Sets if silence should be dropped from the mix or not. */
65         USER_OPT_DTMF_PASS    =  (1 << 13), /*!< Sets if dtmf should be passed into the conference or not */
66         USER_OPT_ANNOUNCEUSERCOUNTALL = (1 << 14), /*!< Sets if the number of users should be announced to everyone. */
67         USER_OPT_JITTERBUFFER =  (1 << 15), /*!< Places a jitterbuffer on the user. */
68         USER_OPT_ANNOUNCE_JOIN_LEAVE_REVIEW = (1 << 16), /*!< modifies ANNOUNCE_JOIN_LEAVE - user reviews the recording before continuing */
69         USER_OPT_SEND_EVENTS = (1 << 17), /*!< Send text message events to users */
70         USER_OPT_ECHO_EVENTS = (1 << 18), /*!< Send events only to the admin(s) */
71         USER_OPT_TEXT_MESSAGING = (1 << 19), /*!< Send text messages to the user */
72 };
73
74 enum bridge_profile_flags {
75         BRIDGE_OPT_RECORD_CONFERENCE = (1 << 0), /*!< Set if the conference should be recorded */
76         BRIDGE_OPT_VIDEO_SRC_LAST_MARKED = (1 << 1), /*!< Set if conference should feed video of last marked user to all participants. */
77         BRIDGE_OPT_VIDEO_SRC_FIRST_MARKED = (1 << 2), /*!< Set if conference should feed video of first marked user to all participants. */
78         BRIDGE_OPT_VIDEO_SRC_FOLLOW_TALKER = (1 << 3), /*!< Set if conference set the video feed to follow the loudest talker.  */
79         BRIDGE_OPT_RECORD_FILE_APPEND = (1 << 4), /*!< Set if the record file should be appended to between start/stops.  */
80         BRIDGE_OPT_RECORD_FILE_TIMESTAMP = (1 << 5), /*!< Set if the record file should have a timestamp appended */
81         BRIDGE_OPT_BINAURAL_ACTIVE = (1 << 6), /*!< Set if binaural convolution is activated */
82         BRIDGE_OPT_VIDEO_SRC_SFU = (1 << 7), /*!< Selective forwarding unit */
83         BRIDGE_OPT_REMB_BEHAVIOR_AVERAGE = (1 << 8), /*!< The average of all REMB reports is sent to the sender */
84         BRIDGE_OPT_REMB_BEHAVIOR_LOWEST = (1 << 9), /*!< The lowest estimated maximum bitrate is sent to the sender */
85         BRIDGE_OPT_REMB_BEHAVIOR_HIGHEST = (1 << 10), /*!< The highest estimated maximum bitrate is sent to the sender */
86         BRIDGE_OPT_ENABLE_EVENTS = (1 << 11), /*!< Enable sending events to participants */
87         BRIDGE_OPT_REMB_BEHAVIOR_AVERAGE_ALL = (1 << 12), /*!< The average of all REMB reports in the entire bridge is sent to each sender */
88         BRIDGE_OPT_REMB_BEHAVIOR_LOWEST_ALL = (1 << 13), /*!< The lowest estimated maximum bitrate from all receivers is sent to each sender */
89         BRIDGE_OPT_REMB_BEHAVIOR_HIGHEST_ALL = (1 << 14), /*!< The highest estimated maximum bitrate from all receivers is sent to each sender */
90 };
91
92 enum conf_menu_action_id {
93         MENU_ACTION_TOGGLE_MUTE = 1,
94         MENU_ACTION_PLAYBACK,
95         MENU_ACTION_PLAYBACK_AND_CONTINUE,
96         MENU_ACTION_INCREASE_LISTENING,
97         MENU_ACTION_DECREASE_LISTENING,
98         MENU_ACTION_RESET_LISTENING,
99         MENU_ACTION_RESET_TALKING,
100         MENU_ACTION_INCREASE_TALKING,
101         MENU_ACTION_DECREASE_TALKING,
102         MENU_ACTION_DIALPLAN_EXEC,
103         MENU_ACTION_ADMIN_TOGGLE_LOCK,
104         MENU_ACTION_ADMIN_KICK_LAST,
105         MENU_ACTION_LEAVE,
106         MENU_ACTION_NOOP,
107         MENU_ACTION_SET_SINGLE_VIDEO_SRC,
108         MENU_ACTION_RELEASE_SINGLE_VIDEO_SRC,
109         MENU_ACTION_PARTICIPANT_COUNT,
110         MENU_ACTION_ADMIN_TOGGLE_MUTE_PARTICIPANTS,
111         MENU_ACTION_TOGGLE_BINAURAL,
112 };
113
114 /*! The conference menu action contains both
115  *  the action id that represents the action that
116  *  must take place, along with any data associated
117  *  with that action. */
118 struct conf_menu_action {
119         enum conf_menu_action_id id;
120         union {
121                 char playback_file[PATH_MAX];
122                 struct {
123                         char context[AST_MAX_CONTEXT];
124                         char exten[AST_MAX_EXTENSION];
125                         int priority;
126                 } dialplan_args;
127         } data;
128         AST_LIST_ENTRY(conf_menu_action) action;
129 };
130
131 /*! Conference menu entries contain the DTMF sequence
132  *  and the list of actions that are associated with that
133  *  sequence. */
134 struct conf_menu_entry {
135         /*! the DTMF sequence that triggers the actions */
136         char dtmf[MAXIMUM_DTMF_FEATURE_STRING];
137         /*! The actions associated with this menu entry. */
138         AST_LIST_HEAD_NOLOCK(, conf_menu_action) actions;
139         AST_LIST_ENTRY(conf_menu_entry) entry;
140 };
141
142 /*! Conference menu structure.  Contains a list
143  * of DTMF sequences coupled with the actions those
144  * sequences invoke.*/
145 struct conf_menu {
146         char name[MAX_PROFILE_NAME];
147         AST_LIST_HEAD_NOLOCK(, conf_menu_entry) entries;
148 };
149
150 struct user_profile {
151         char name[MAX_PROFILE_NAME];
152         char pin[MAX_PIN];
153         char moh_class[128];
154         char announcement[PATH_MAX];
155         unsigned int flags;
156         unsigned int announce_user_count_all_after;
157         /*! Minimum average magnitude threshold to determine talking by the DSP. */
158         unsigned int talking_threshold;
159         /*! Time in ms of silence necessary to declare talking stopped by the bridge. */
160         unsigned int silence_threshold;
161         /*! The time in ms the user may stay in the confbridge */
162         unsigned int timeout;
163 };
164
165 enum conf_sounds {
166         CONF_SOUND_HAS_JOINED,
167         CONF_SOUND_HAS_LEFT,
168         CONF_SOUND_KICKED,
169         CONF_SOUND_MUTED,
170         CONF_SOUND_UNMUTED,
171         CONF_SOUND_ONLY_ONE,
172         CONF_SOUND_THERE_ARE,
173         CONF_SOUND_OTHER_IN_PARTY,
174         CONF_SOUND_PLACE_IN_CONF,
175         CONF_SOUND_WAIT_FOR_LEADER,
176         CONF_SOUND_LEADER_HAS_LEFT,
177         CONF_SOUND_GET_PIN,
178         CONF_SOUND_INVALID_PIN,
179         CONF_SOUND_ONLY_PERSON,
180         CONF_SOUND_LOCKED,
181         CONF_SOUND_LOCKED_NOW,
182         CONF_SOUND_UNLOCKED_NOW,
183         CONF_SOUND_ERROR_MENU,
184         CONF_SOUND_JOIN,
185         CONF_SOUND_LEAVE,
186         CONF_SOUND_PARTICIPANTS_MUTED,
187         CONF_SOUND_PARTICIPANTS_UNMUTED,
188         CONF_SOUND_BEGIN,
189         CONF_SOUND_BINAURAL_ON,
190         CONF_SOUND_BINAURAL_OFF,
191 };
192
193 struct bridge_profile_sounds {
194         AST_DECLARE_STRING_FIELDS(
195                 AST_STRING_FIELD(hasjoin);
196                 AST_STRING_FIELD(hasleft);
197                 AST_STRING_FIELD(kicked);
198                 AST_STRING_FIELD(muted);
199                 AST_STRING_FIELD(unmuted);
200                 AST_STRING_FIELD(onlyone);
201                 AST_STRING_FIELD(thereare);
202                 AST_STRING_FIELD(otherinparty);
203                 AST_STRING_FIELD(placeintoconf);
204                 AST_STRING_FIELD(waitforleader);
205                 AST_STRING_FIELD(leaderhasleft);
206                 AST_STRING_FIELD(getpin);
207                 AST_STRING_FIELD(invalidpin);
208                 AST_STRING_FIELD(onlyperson);
209                 AST_STRING_FIELD(locked);
210                 AST_STRING_FIELD(lockednow);
211                 AST_STRING_FIELD(unlockednow);
212                 AST_STRING_FIELD(errormenu);
213                 AST_STRING_FIELD(leave);
214                 AST_STRING_FIELD(join);
215                 AST_STRING_FIELD(participantsmuted);
216                 AST_STRING_FIELD(participantsunmuted);
217                 AST_STRING_FIELD(begin);
218                 AST_STRING_FIELD(binauralon);
219                 AST_STRING_FIELD(binauraloff);
220         );
221 };
222
223 struct bridge_profile {
224         char name[MAX_PROFILE_NAME];
225         char language[MAX_LANGUAGE];              /*!< Language used for playback_chan */
226         char rec_file[PATH_MAX];
227         char rec_options[128];
228         char rec_command[128];
229         unsigned int flags;
230         unsigned int max_members;          /*!< The maximum number of participants allowed in the conference */
231         unsigned int internal_sample_rate; /*!< The internal sample rate of the bridge. 0 when set to auto adjust mode. */
232         unsigned int maximum_sample_rate; /*!< The maximum sample rate of the bridge. 0 when set to no maximum. */
233         unsigned int mix_interval;  /*!< The internal mixing interval used by the bridge. When set to 0 the bridgewill use a default interval. */
234         struct bridge_profile_sounds *sounds;
235         char regcontext[AST_MAX_CONTEXT];
236         unsigned int video_update_discard; /*!< Amount of time after sending a video update request that subsequent requests should be discarded */
237         unsigned int remb_send_interval; /*!< Interval at which a combined REMB frame is sent to video sources */
238 };
239
240 /*! \brief The structure that represents a conference bridge */
241 struct confbridge_conference {
242         char name[MAX_CONF_NAME];                                         /*!< Name of the conference bridge */
243         struct confbridge_state *state;                                   /*!< Conference state information */
244         struct ast_bridge *bridge;                                        /*!< Bridge structure doing the mixing */
245         struct bridge_profile b_profile;                                  /*!< The Bridge Configuration Profile */
246         unsigned int activeusers;                                         /*!< Number of active users present */
247         unsigned int markedusers;                                         /*!< Number of marked users present */
248         unsigned int waitingusers;                                        /*!< Number of waiting users present */
249         unsigned int locked:1;                                            /*!< Is this conference bridge locked? */
250         unsigned int muted:1;                                             /*!< Is this conference bridge muted? */
251         struct ast_channel *playback_chan;                                /*!< Channel used for playback into the conference bridge */
252         struct ast_channel *record_chan;                                  /*!< Channel used for recording the conference */
253         struct ast_str *record_filename;                                  /*!< Recording filename. */
254         struct ast_str *orig_rec_file;                                    /*!< Previous b_profile.rec_file. */
255         AST_LIST_HEAD_NOLOCK(, confbridge_user) active_list;              /*!< List of users participating in the conference bridge */
256         AST_LIST_HEAD_NOLOCK(, confbridge_user) waiting_list;             /*!< List of users waiting to join the conference bridge */
257         struct ast_taskprocessor *playback_queue;                         /*!< Queue for playing back bridge announcements and managing the announcer channel */
258 };
259
260 extern struct ao2_container *conference_bridges;
261
262 struct post_join_action {
263         int (*func)(struct confbridge_user *user);
264         AST_LIST_ENTRY(post_join_action) list;
265 };
266
267 /*! \brief The structure that represents a conference bridge user */
268 struct confbridge_user {
269         struct confbridge_conference *conference;    /*!< Conference bridge they are participating in */
270         struct bridge_profile b_profile;             /*!< The Bridge Configuration Profile */
271         struct user_profile u_profile;               /*!< The User Configuration Profile */
272         char menu_name[MAX_PROFILE_NAME];            /*!< The name of the DTMF menu assigned to this user */
273         char name_rec_location[PATH_MAX];            /*!< Location of the User's name recorded file if it exists */
274         struct ast_channel *chan;                    /*!< Asterisk channel participating */
275         struct ast_bridge_features features;         /*!< Bridge features structure */
276         struct ast_bridge_tech_optimizations tech_args; /*!< Bridge technology optimizations for talk detection */
277         unsigned int suspended_moh;                  /*!< Count of active suspended MOH actions. */
278         unsigned int muted:1;                        /*!< Has the user requested to be muted? */
279         unsigned int kicked:1;                       /*!< User has been kicked from the conference */
280         unsigned int playing_moh:1;                  /*!< MOH is currently being played to the user */
281         unsigned int talking:1;                      /*!< User is currently talking */
282         AST_LIST_HEAD_NOLOCK(, post_join_action) post_join_list; /*!< List of sounds to play after joining */;
283         AST_LIST_ENTRY(confbridge_user) list;        /*!< Linked list information */
284 };
285
286 /*! \brief load confbridge.conf file */
287 int conf_load_config(void);
288
289 /*! \brief reload confbridge.conf file */
290 int conf_reload_config(void);
291
292 /*! \brief destroy the information loaded from the confbridge.conf file*/
293 void conf_destroy_config(void);
294
295 /*!
296  * \brief find a user profile given a user profile's name and store
297  * that profile in result structure.
298  *
299  * \param chan channel the user profile is requested for
300  * \param user_profile_name name of the profile requested (optional)
301  * \param result data contained by the user profile will be copied to this struct pointer
302  *
303  * \details If user_profile_name is not provided, this function will
304  * check for the presence of a user profile set by the CONFBRIDGE
305  * function on a channel datastore. If that doesn't exist, the
306  * default_user profile is used.
307  *
308  * \retval user profile on success
309  * \retval NULL on failure
310  */
311 const struct user_profile *conf_find_user_profile(struct ast_channel *chan, const char *user_profile_name, struct user_profile *result);
312
313 /*!
314  * \brief Find a bridge profile given a bridge profile's name and store
315  * that profile in result structure.
316  *
317  * \param chan channel the bridge profile is requested for
318  * \param bridge_profile_name name of the profile requested (optional)
319  * \param result data contained by the bridge profile will be copied to this struct pointer
320  *
321  * \details If bridge_profile_name is not provided, this function will
322  * check for the presence of a bridge profile set by the CONFBRIDGE
323  * function on a channel datastore. If that doesn't exist, the
324  * default_bridge profile is used.
325  *
326  * \retval bridge profile on success
327  * \retval NULL on failure
328  */
329 const struct bridge_profile *conf_find_bridge_profile(struct ast_channel *chan, const char *bridge_profile_name, struct bridge_profile *result);
330
331 /*!
332  * \brief find a menu profile given a menu profile's name and apply
333  * the menu in DTMF hooks.
334  *
335  * \param chan channel the menu profile is requested for
336  * \param user user profile the menu is being applied to
337  * \param menu_profile_name name of the profile requested (optional)
338  *
339  * \details If menu_profile_name is not provided, this function will
340  * check for the presence of a menu profile set by the CONFBRIDGE
341  * function on a channel datastore. If that doesn't exist, the
342  * default_menu profile is used.
343  *
344  * \retval 0 on success
345  * \retval -1 on failure
346  */
347 int conf_set_menu_to_user(struct ast_channel *chan, struct confbridge_user *user, const char *menu_profile_name);
348
349 /*!
350  * \brief Destroy a bridge profile found by 'conf_find_bridge_profile'
351  */
352 void conf_bridge_profile_destroy(struct bridge_profile *b_profile);
353
354 /*!
355  * \brief copies a bridge profile
356  * \note conf_bridge_profile_destroy must be called on the dst structure
357  */
358 void conf_bridge_profile_copy(struct bridge_profile *dst, struct bridge_profile *src);
359
360 /*!
361  * \brief Finds a menu_entry in a menu structure matched by DTMF sequence.
362  *
363  * \note the menu entry found must be destroyed using conf_menu_entry_destroy()
364  *
365  * \retval 1 success, entry is found and stored in result
366  * \retval 0 failure, no entry found for given DTMF sequence
367  */
368 int conf_find_menu_entry_by_sequence(const char *dtmf_sequence, struct conf_menu *menu, struct conf_menu_entry *result);
369
370 /*!
371  * \brief Destroys and frees all the actions stored in a menu_entry structure
372  */
373 void conf_menu_entry_destroy(struct conf_menu_entry *menu_entry);
374
375 /*!
376  * \brief Once a DTMF sequence matches a sequence in the user's DTMF menu, this function will get
377  * called to perform the menu action.
378  *
379  * \param bridge_channel Bridged channel this is involving
380  * \param user the conference user to perform the action on.
381  * \param menu_entry the menu entry that invoked this callback to occur.
382  * \param menu an AO2 referenced pointer to the entire menu structure the menu_entry
383  *        derived from.
384  *
385  * \note The menu_entry is a deep copy of the entry found in the menu structure.  This allows
386  * for the menu_entry to be accessed without requiring the menu lock.  If the menu must
387  * be accessed, the menu lock must be held.  Reference counting of the menu structure is
388  * handled outside of the scope of this function.
389  *
390  * \retval 0 success
391  * \retval -1 failure
392  */
393 int conf_handle_dtmf(
394         struct ast_bridge_channel *bridge_channel,
395         struct confbridge_user *user,
396         struct conf_menu_entry *menu_entry,
397         struct conf_menu *menu);
398
399
400 /*! \brief Looks to see if sound file is stored in bridge profile sounds, if not
401  *  default sound is provided.*/
402 const char *conf_get_sound(enum conf_sounds sound, struct bridge_profile_sounds *custom_sounds);
403
404 int func_confbridge_helper(struct ast_channel *chan, const char *cmd, char *data, const char *value);
405
406 /*!
407  * \brief Play sound file into conference bridge
408  *
409  * \param conference The conference bridge to play sound file into
410  * \param filename Sound file to play
411  *
412  * \retval 0 success
413  * \retval -1 failure
414  */
415 int play_sound_file(struct confbridge_conference *conference, const char *filename);
416
417 /*!
418  * \brief Play sound file into conference bridge asynchronously
419  *
420  * If the initiator parameter is non-NULL, then the playback will wait for
421  * that initiator channel to get back in the bridge before playing the sound
422  * file. This way, the initiator has no danger of hearing a "clipped" file.
423  *
424  * \param conference The conference bridge to play sound file into
425  * \param filename Sound file to play
426  * \param initiator Channel that initiated playback.
427  *
428  * \retval 0 success
429  * \retval -1 failure
430  */
431 int async_play_sound_file(struct confbridge_conference *conference, const char *filename,
432         struct ast_channel *initiator);
433
434 /*!
435  * \brief Indicate the initiator of an async sound file is ready for it to play.
436  *
437  * When playing an async sound file, the initiator is typically either out of the bridge
438  * or not in a position to hear the queued announcement. This function lets the announcement
439  * thread know that the initiator is now ready for the sound to play.
440  *
441  * If an async announcement was queued and no initiator channel was provided, then this is
442  * a no-op
443  *
444  * \param chan The channel that initiated the async announcement
445  */
446 void async_play_sound_ready(struct ast_channel *chan);
447
448 /*! \brief Callback to be called when the conference has become empty
449  * \param conference The conference bridge
450  */
451 void conf_ended(struct confbridge_conference *conference);
452
453 /*!
454  * \brief Update the actual mute status of the user and set it on the bridge.
455  *
456  * \param user User to update the mute status.
457  *
458  * \return Nothing
459  */
460 void conf_update_user_mute(struct confbridge_user *user);
461
462 /*!
463  * \brief Stop MOH for the conference user.
464  *
465  * \param user Conference user to stop MOH on.
466  *
467  * \return Nothing
468  */
469 void conf_moh_stop(struct confbridge_user *user);
470
471 /*!
472  * \brief Start MOH for the conference user.
473  *
474  * \param user Conference user to start MOH on.
475  *
476  * \return Nothing
477  */
478 void conf_moh_start(struct confbridge_user *user);
479
480 /*! \brief Attempt to mute/play MOH to the only user in the conference if they require it
481  * \param conference A conference bridge containing a single user
482  */
483 void conf_mute_only_active(struct confbridge_conference *conference);
484
485 /*! \brief Callback to execute any time we transition from zero to one active users
486  * \param conference The conference bridge with a single active user joined
487  * \retval 0 success
488  * \retval -1 failure
489  */
490 void conf_handle_first_join(struct confbridge_conference *conference);
491
492 /*! \brief Handle actions every time a waitmarked user joins w/o a marked user present
493  * \param user The waitmarked user
494  * \retval 0 success
495  * \retval -1 failure
496  */
497 int conf_handle_inactive_waitmarked(struct confbridge_user *user);
498
499 /*! \brief Handle actions whenever an user joins an empty conference
500  *
501  * \param user The user
502  */
503 int conf_handle_only_person(struct confbridge_user *user);
504
505 /*! \brief Handle when a conference moves to having more than one active participant
506  * \param conference The conference bridge with more than one active participant
507  */
508 void conf_handle_second_active(struct confbridge_conference *conference);
509
510 /*! \brief Add a conference bridge user as an unmarked active user of the conference
511  * \param conference The conference bridge to add the user to
512  * \param user The conference bridge user to add to the conference
513  */
514 void conf_add_user_active(struct confbridge_conference *conference, struct confbridge_user *user);
515
516 /*! \brief Add a conference bridge user as a marked active user of the conference
517  * \param conference The conference bridge to add the user to
518  * \param user The conference bridge user to add to the conference
519  */
520 void conf_add_user_marked(struct confbridge_conference *conference, struct confbridge_user *user);
521
522 /*! \brief Add a conference bridge user as an waiting user of the conference
523  * \param conference The conference bridge to add the user to
524  * \param user The conference bridge user to add to the conference
525  */
526 void conf_add_user_waiting(struct confbridge_conference *conference, struct confbridge_user *user);
527
528 /*! \brief Remove a conference bridge user from the unmarked active conference users in the conference
529  * \param conference The conference bridge to remove the user from
530  * \param user The conference bridge user to remove from the conference
531  */
532 void conf_remove_user_active(struct confbridge_conference *conference, struct confbridge_user *user);
533
534 /*! \brief Remove a conference bridge user from the marked active conference users in the conference
535  * \param conference The conference bridge to remove the user from
536  * \param user The conference bridge user to remove from the conference
537  */
538 void conf_remove_user_marked(struct confbridge_conference *conference, struct confbridge_user *user);
539
540 /*! \brief Remove a conference bridge user from the waiting conference users in the conference
541  * \param conference The conference bridge to remove the user from
542  * \param user The conference bridge user to remove from the conference
543  */
544 void conf_remove_user_waiting(struct confbridge_conference *conference, struct confbridge_user *user);
545
546 /*! \brief Queue a function to run with the given conference bridge user as an argument once the state transition is complete
547  * \param user The conference bridge user to pass to the function
548  * \param func The function to queue
549  * \retval 0 success
550  * \retval non-zero failure
551  */
552 int conf_add_post_join_action(struct confbridge_user *user, int (*func)(struct confbridge_user *user));
553
554 /*!
555  * \since 12.0
556  * \brief get the confbridge start stasis message type
557  *
558  * \retval stasis message type for confbridge start messages if it's available
559  * \retval NULL if it isn't
560  */
561 struct stasis_message_type *confbridge_start_type(void);
562
563 /*!
564  * \since 12.0
565  * \brief get the confbridge end stasis message type
566  *
567  * \retval stasis message type for confbridge end messages if it's available
568  * \retval NULL if it isn't
569  */
570 struct stasis_message_type *confbridge_end_type(void);
571
572 /*!
573  * \since 12.0
574  * \brief get the confbridge join stasis message type
575  *
576  * \retval stasis message type for confbridge join messages if it's available
577  * \retval NULL if it isn't
578  */
579 struct stasis_message_type *confbridge_join_type(void);
580
581 /*!
582  * \since 12.0
583  * \brief get the confbridge leave stasis message type
584  *
585  * \retval stasis message type for confbridge leave messages if it's available
586  * \retval NULL if it isn't
587  */
588 struct stasis_message_type *confbridge_leave_type(void);
589
590 /*!
591  * \since 12.0
592  * \brief get the confbridge start_record stasis message type
593  *
594  * \retval stasis message type for confbridge start_record messages if it's available
595  * \retval NULL if it isn't
596  */
597 struct stasis_message_type *confbridge_start_record_type(void);
598
599 /*!
600  * \since 12.0
601  * \brief get the confbridge stop_record stasis message type
602  *
603  * \retval stasis message type for confbridge stop_record messages if it's available
604  * \retval NULL if it isn't
605  */
606 struct stasis_message_type *confbridge_stop_record_type(void);
607
608 /*!
609  * \since 12.0
610  * \brief get the confbridge mute stasis message type
611  *
612  * \retval stasis message type for confbridge mute messages if it's available
613  * \retval NULL if it isn't
614  */
615 struct stasis_message_type *confbridge_mute_type(void);
616
617 /*!
618  * \since 12.0
619  * \brief get the confbridge unmute stasis message type
620  *
621  * \retval stasis message type for confbridge unmute messages if it's available
622  * \retval NULL if it isn't
623  */
624 struct stasis_message_type *confbridge_unmute_type(void);
625
626 /*!
627  * \since 12.0
628  * \brief get the confbridge talking stasis message type
629  *
630  * \retval stasis message type for confbridge talking messages if it's available
631  * \retval NULL if it isn't
632  */
633 struct stasis_message_type *confbridge_talking_type(void);
634
635 /*!
636  * \since 15.5
637  * \brief get the confbridge welcome stasis message type
638  *
639  * \retval stasis message type for confbridge welcome messages if it's available
640  * \retval NULL if it isn't
641  */
642 struct stasis_message_type *confbridge_welcome_type(void);
643
644 /*!
645  * \since 15.5
646  * \brief Get the string representation of a confbridge stasis message type
647  *
648  * \param event_type The confbridge event type such as 'confbridge_welcome_type()'
649  *
650  * \retval The string representation of the message type
651  * \retval "unknown" if not found
652  */
653 const char *confbridge_event_type_to_string(struct stasis_message_type *event_type);
654
655 /*!
656  * \since 12.0
657  * \brief register stasis message routers to handle manager events for confbridge messages
658  *
659  * \retval 0 success
660  * \retval non-zero failure
661  */
662 int manager_confbridge_init(void);
663
664 /*!
665  * \since 12.0
666  * \brief unregister stasis message routers to handle manager events for confbridge messages
667  */
668 void manager_confbridge_shutdown(void);
669
670 /*!
671  * \brief Get ConfBridge record channel technology struct.
672  * \since 12.0.0
673  *
674  * \return ConfBridge record channel technology.
675  */
676 struct ast_channel_tech *conf_record_get_tech(void);
677
678 /*!
679  * \brief Get ConfBridge announce channel technology struct.
680  * \since 12.0.0
681  *
682  * \return ConfBridge announce channel technology.
683  */
684 struct ast_channel_tech *conf_announce_get_tech(void);
685
686 /*!
687  * \brief Push the announcer channel into the conference.
688  * \since 12.0.0
689  *
690  * \param ast Either channel in the announcer channel pair.
691  *
692  * \retval 0 on success.
693  * \retval -1 on error.
694  */
695 int conf_announce_channel_push(struct ast_channel *ast);
696
697 /*!
698  * \brief Find a confbridge by name.
699  * \since 13.22.0
700  * \since 15.5.0
701  *
702  * \param confbridge_name The name to search for
703  *
704  * \return ConfBridge (which must be unreffed) or NULL.
705  */
706 struct confbridge_conference *conf_find_bridge(const char *conference_name);
707
708 /*!
709  * \brief Send events to bridge participants.
710  * \since 15.7
711  * \since 16.1
712  *
713  * \param conference The conference bridge
714  * \param chan The channel triggering the action
715  * \param msg The stasis message describing the event
716  */
717 void conf_send_event_to_participants(struct confbridge_conference *conference,
718         struct ast_channel *chan, struct stasis_message *msg);
719
720 /*!
721  * \brief Create join/leave events for attended transfers
722  * \since 13.28
723  * \since 16.5
724  *
725  * \param msg The attended transfer stasis message
726  *
727  */
728 void confbridge_handle_atxfer(struct ast_attended_transfer_message *msg);
729
730 #endif