FS-9736 #resolve add conference json_list

diff --git a/src/mod/applications/mod_conference/conference_api.c b/src/mod/applications/mod_conference/conference_api.c
index e0c040d1976193cae262547d3029edb9a4bb1dea..119e65c50bd71f61974b313173026eb5a5a39f32 100644 (file)
--- a/src/mod/applications/mod_conference/conference_api.c
+++ b/src/mod/applications/mod_conference/conference_api.c
@@ -45,6 +45,7 @@
 api_command_t conference_api_sub_commands[] = {
        {"list", (void_fn_t) & conference_api_sub_list, CONF_API_SUB_ARGS_SPLIT, "list", "[delim <string>]|[count]"},
        {"xml_list", (void_fn_t) & conference_api_sub_xml_list, CONF_API_SUB_ARGS_SPLIT, "xml_list", ""},
+       {"json_list", (void_fn_t) & conference_api_sub_json_list, CONF_API_SUB_ARGS_SPLIT, "json_list", "[compact]"},
        {"energy", (void_fn_t) & conference_api_sub_energy, CONF_API_SUB_MEMBER_TARGET, "energy", "<member_id|all|last|non_moderator> [<newval>]"},
        {"vid-canvas", (void_fn_t) & conference_api_sub_canvas, CONF_API_SUB_MEMBER_TARGET, "vid-canvas", "<member_id|all|last|non_moderator> [<newval>]"},
        {"vid-watching-canvas", (void_fn_t) & conference_api_sub_watching_canvas, CONF_API_SUB_MEMBER_TARGET, "vid-watching-canvas", "<member_id|all|last|non_moderator> [<newval>]"},
@@ -214,6 +215,8 @@ switch_status_t conference_api_main_real(const char *cmd, switch_core_session_t
                                conference_api_sub_list(NULL, stream, argc, argv);
                        } else if (strcasecmp(argv[0], "xml_list") == 0) {
                                conference_api_sub_xml_list(NULL, stream, argc, argv);
+                       } else if (strcasecmp(argv[0], "json_list") == 0) {
+                               conference_api_sub_json_list(NULL, stream, argc, argv);
                        } else if (strcasecmp(argv[0], "help") == 0 || strcasecmp(argv[0], "commands") == 0) {
                                stream->write_function(stream, "%s\n", api_syntax);
                        } else if (argv[1] && strcasecmp(argv[1], "dial") == 0) {
@@ -2878,8 +2881,37 @@ switch_status_t conference_api_sub_xml_list(conference_obj_t *conference, switch
        return SWITCH_STATUS_SUCCESS;
 }
 
+switch_status_t conference_api_sub_json_list(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
+{
+       switch_hash_index_t *hi;
+       void *val;
+       char *ebuf;
+       cJSON *conferences = cJSON_CreateArray();
+       switch_bool_t compact = SWITCH_FALSE;
 
+       switch_assert(conferences);
 
+       if (conference == NULL) {
+               switch_mutex_lock(conference_globals.hash_mutex);
+               for (hi = switch_core_hash_first(conference_globals.conference_hash); hi; hi = switch_core_hash_next(&hi)) {
+                       switch_core_hash_this(hi, NULL, NULL, &val);
+                       conference = (conference_obj_t *) val;
+                       conference_jlist(conference, conferences);
+               }
+               switch_mutex_unlock(conference_globals.hash_mutex);
+               compact = (argc == 2 && !strcmp(argv[1], "compact"));
+       } else {
+               conference_jlist(conference, conferences);
+               compact = (argc == 3 && !strcmp(argv[2], "compact"));
+       }
+
+       ebuf = compact ? cJSON_PrintUnformatted(conferences) : cJSON_Print(conferences);
+       switch_assert(ebuf);
+       stream->write_function(stream, "%s", ebuf);
+       free(ebuf);
+
+       return SWITCH_STATUS_SUCCESS;
+}
 
 switch_status_t conference_api_dispatch(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv, const char *cmdline, int argn)
 {

diff --git a/src/mod/applications/mod_conference/mod_conference.c b/src/mod/applications/mod_conference/mod_conference.c
index c4f00d129c124bfd086fea39ac4dae3b5e693257..eeaab028ed908d50b5a99740e9442a7863eae107 100644 (file)
--- a/src/mod/applications/mod_conference/mod_conference.c
+++ b/src/mod/applications/mod_conference/mod_conference.c
@@ -1333,6 +1333,104 @@ void conference_xlist(conference_obj_t *conference, switch_xml_t x_conference, i
        switch_mutex_unlock(conference->member_mutex);
 }
 
+void conference_jlist(conference_obj_t *conference, cJSON *json_conferences)
+{
+       conference_member_t *member = NULL;
+       static cJSON *json_conference, *json_conference_members, *json_conference_member, *json_conference_member_flags;
+
+       switch_assert(conference != NULL);
+       json_conference = cJSON_CreateObject();
+       switch_assert(json_conference);
+
+       cJSON_AddItemToObject(json_conferences, "conference", json_conference);
+       cJSON_AddStringToObject(json_conference, "conference_name", conference->name);
+       cJSON_AddNumberToObject(json_conference,"member_count", conference->count);
+       cJSON_AddNumberToObject(json_conference,"ghost_count", conference->count_ghosts);
+       cJSON_AddNumberToObject(json_conference,"rate", conference->rate);
+       cJSON_AddNumberToObject(json_conference,"run_time", switch_epoch_time_now(NULL) - conference->run_time);
+       cJSON_AddStringToObject(json_conference, "conference_uuid", conference->uuid_str);
+       cJSON_AddNumberToObject(json_conference, "canvas_count", conference->canvas_count);
+       cJSON_AddNumberToObject(json_conference, "max_bw_in", conference->max_bw_in);
+       cJSON_AddNumberToObject(json_conference, "force_bw_in", conference->force_bw_in);
+       cJSON_AddNumberToObject(json_conference, "video_floor_packets", conference->video_floor_packets);
+
+#define ADDBOOL(obj, name, b) cJSON_AddItemToObject(obj, name, (b) ? cJSON_CreateTrue() : cJSON_CreateFalse())
+
+       ADDBOOL(json_conference, "locked", conference_utils_test_flag(conference, CFLAG_LOCKED));
+       ADDBOOL(json_conference, "destruct", conference_utils_test_flag(conference, CFLAG_DESTRUCT));
+       ADDBOOL(json_conference, "wait_mod", conference_utils_test_flag(conference, CFLAG_WAIT_MOD));
+       ADDBOOL(json_conference, "audio_always", conference_utils_test_flag(conference, CFLAG_AUDIO_ALWAYS));
+       ADDBOOL(json_conference, "running", conference_utils_test_flag(conference, CFLAG_RUNNING));
+       ADDBOOL(json_conference, "answered", conference_utils_test_flag(conference, CFLAG_ANSWERED));
+       ADDBOOL(json_conference, "enforce_min", conference_utils_test_flag(conference, CFLAG_ENFORCE_MIN));
+       ADDBOOL(json_conference, "bridge_to", conference_utils_test_flag(conference, CFLAG_BRIDGE_TO));
+       ADDBOOL(json_conference, "dynamic", conference_utils_test_flag(conference, CFLAG_DYNAMIC));
+       ADDBOOL(json_conference, "exit_sound", conference_utils_test_flag(conference, CFLAG_EXIT_SOUND));
+       ADDBOOL(json_conference, "enter_sound", conference_utils_test_flag(conference, CFLAG_ENTER_SOUND));
+       ADDBOOL(json_conference, "recording", conference->record_count > 0);
+       ADDBOOL(json_conference, "video_bridge", conference_utils_test_flag(conference, CFLAG_VIDEO_BRIDGE_FIRST_TWO));
+       ADDBOOL(json_conference, "video_floor_only", conference_utils_test_flag(conference, CFLAG_VID_FLOOR));
+       ADDBOOL(json_conference, "video_rfc4579", conference_utils_test_flag(conference, CFLAG_RFC4579));
+
+       if (conference->max_members > 0) {
+               cJSON_AddNumberToObject(json_conference, "max_members", conference->max_members);
+       }
+
+       if (conference->agc_level) {
+               cJSON_AddNumberToObject(json_conference, "agc", conference->agc_level);
+       }
+
+       cJSON_AddItemToObject(json_conference, "members", json_conference_members = cJSON_CreateArray());
+       switch_mutex_lock(conference->member_mutex);
+       for (member = conference->members; member; member = member->next) {
+               switch_channel_t *channel;
+               switch_caller_profile_t *profile;
+               char *uuid;
+               cJSON_AddItemToObject(json_conference_members, "member", json_conference_member = cJSON_CreateObject());
+
+               if (conference_utils_member_test_flag(member, MFLAG_NOCHANNEL)) {
+                       if (member->rec_path) {
+                               cJSON_AddStringToObject(json_conference_member, "type", "recording_node");
+                               cJSON_AddStringToObject(json_conference_member, "record_path", member->rec_path);
+                               if (conference_utils_member_test_flag(member, MFLAG_PAUSE_RECORDING)) {
+                                       cJSON_AddStringToObject(json_conference_member, "status", "paused");
+                               }
+                               cJSON_AddNumberToObject(json_conference_member, "join_time", member->rec_time);
+                       }
+                       continue;
+               }
+
+               uuid = switch_core_session_get_uuid(member->session);
+               channel = switch_core_session_get_channel(member->session);
+               profile = switch_channel_get_caller_profile(channel);
+
+               cJSON_AddStringToObject(json_conference_member, "type", "caller");
+               cJSON_AddNumberToObject(json_conference_member, "id", member->id);
+               cJSON_AddItemToObject(json_conference_member, "flags", json_conference_member_flags = cJSON_CreateObject());
+               cJSON_AddStringToObject(json_conference_member, "uuid", uuid);
+               cJSON_AddStringToObject(json_conference_member, "caller_id_name", profile->caller_id_name);
+               cJSON_AddStringToObject(json_conference_member,"caller_id_number", profile->caller_id_number);
+               cJSON_AddNumberToObject(json_conference_member, "join_time", switch_epoch_time_now(NULL) - member->join_time);
+               cJSON_AddNumberToObject(json_conference_member, "last_talking", member->last_talking ? switch_epoch_time_now(NULL) - member->last_talking : 0);
+               cJSON_AddNumberToObject(json_conference_member, "energy", member->energy_level);
+               cJSON_AddNumberToObject(json_conference_member, "volume_in", member->volume_in_level);
+               cJSON_AddNumberToObject(json_conference_member, "volume_out", member->volume_out_level);
+               cJSON_AddNumberToObject(json_conference_member, "output-volume", member->volume_out_level);
+               cJSON_AddNumberToObject(json_conference_member, "input-volume", member->agc_volume_in_level ? member->agc_volume_in_level : member->volume_in_level);
+               cJSON_AddNumberToObject(json_conference_member, "auto-adjusted-input-volume", member->agc_volume_in_level);
+               ADDBOOL(json_conference_member_flags, "can_hear", conference_utils_member_test_flag(member, MFLAG_CAN_HEAR));
+               ADDBOOL(json_conference_member_flags, "can_speak", conference_utils_member_test_flag(member, MFLAG_CAN_SPEAK));
+               ADDBOOL(json_conference_member_flags, "mute_detect", conference_utils_member_test_flag(member, MFLAG_MUTE_DETECT));
+               ADDBOOL(json_conference_member_flags, "talking", conference_utils_member_test_flag(member, MFLAG_TALKING));
+               ADDBOOL(json_conference_member_flags, "has_video", switch_channel_test_flag(switch_core_session_get_channel(member->session), CF_VIDEO));
+               ADDBOOL(json_conference_member_flags, "video_bridge", conference_utils_member_test_flag(member, MFLAG_VIDEO_BRIDGE));
+               ADDBOOL(json_conference_member_flags, "has_floor", member == member->conference->floor_holder);
+               ADDBOOL(json_conference_member_flags, "is_moderator", conference_utils_member_test_flag(member, MFLAG_MOD));
+               ADDBOOL(json_conference_member_flags, "end_conference", conference_utils_member_test_flag(member, MFLAG_ENDCONF));
+       }
+       switch_mutex_unlock(conference->member_mutex);
+}
+
 void conference_fnode_toggle_pause(conference_file_node_t *fnode, switch_stream_handle_t *stream)
 {
        if (fnode) {

diff --git a/src/mod/applications/mod_conference/mod_conference.h b/src/mod/applications/mod_conference/mod_conference.h
index 22b38e7226b866f9c20dffdd1657745b07ef96cc..d1a35bb5aa59b6de83429214c6ffee6e2296ad3e 100644 (file)
--- a/src/mod/applications/mod_conference/mod_conference.h
+++ b/src/mod/applications/mod_conference/mod_conference.h
@@ -950,6 +950,7 @@ void conference_list_pretty(conference_obj_t *conference, switch_stream_handle_t
 switch_status_t conference_record_stop(conference_obj_t *conference, switch_stream_handle_t *stream, char *path);
 switch_status_t conference_record_action(conference_obj_t *conference, char *path, recording_action_type_t action);
 void conference_xlist(conference_obj_t *conference, switch_xml_t x_conference, int off);
+void conference_jlist(conference_obj_t *conference, cJSON *json_conferences);
 void conference_event_send_json(conference_obj_t *conference);
 void conference_event_send_rfc(conference_obj_t *conference);
 void conference_member_update_status_field(conference_member_t *member);
@@ -1122,6 +1123,7 @@ switch_status_t conference_api_sub_recording(conference_obj_t *conference, switc
 switch_status_t conference_api_sub_vid_layout(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
 switch_status_t conference_api_sub_list(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
 switch_status_t conference_api_sub_xml_list(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
+switch_status_t conference_api_sub_json_list(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
 switch_status_t conference_api_sub_energy(conference_member_t *member, switch_stream_handle_t *stream, void *data);
 switch_status_t conference_api_sub_watching_canvas(conference_member_t *member, switch_stream_handle_t *stream, void *data);
 switch_status_t conference_api_sub_canvas(conference_member_t *member, switch_stream_handle_t *stream, void *data);