自学教程：C++ switch_channel_event_set_data函数代码示例

static switch_status_t my_on_reporting(switch_core_session_t *session){	switch_channel_t *channel = switch_core_session_get_channel(session);	switch_status_t status = SWITCH_STATUS_SUCCESS;	const char *template_str = NULL;	char *expanded_vars = NULL, *sql = NULL;	if (globals.shutdown) {		return SWITCH_STATUS_SUCCESS;	}	if (!((globals.legs & CDR_LEG_A) && (globals.legs & CDR_LEG_B))) {		if ((globals.legs & CDR_LEG_A)) {			if (switch_channel_get_originator_caller_profile(channel)) {				return SWITCH_STATUS_SUCCESS;			}		} else {			if (switch_channel_get_originatee_caller_profile(channel)) {				return SWITCH_STATUS_SUCCESS;			}		}	}	if (globals.debug) {		switch_event_t *event;		if (switch_event_create_plain(&event, SWITCH_EVENT_CHANNEL_DATA) == SWITCH_STATUS_SUCCESS) {			char *buf;			switch_channel_event_set_data(channel, event);			switch_event_serialize(event, &buf, SWITCH_FALSE);			switch_assert(buf);			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "CHANNEL_DATA:/n%s/n", buf);			switch_event_destroy(&event);			switch_safe_free(buf);		}	}	template_str = (const char *) switch_core_hash_find(globals.template_hash, globals.default_template);	if (!template_str) {		template_str = default_template;	}	expanded_vars = switch_channel_expand_variables(channel, template_str);	if (!expanded_vars) {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error expanding CDR variables./n");		return SWITCH_STATUS_FALSE;	}	sql = switch_mprintf("INSERT INTO %s VALUES (%s)", globals.db_table, expanded_vars);	assert(sql);	write_cdr(sql);	switch_safe_free(sql);	if (expanded_vars != template_str) {		switch_safe_free(expanded_vars);	}	return status;}

SWITCH_DECLARE(switch_status_t) switch_core_session_set_video_write_codec(switch_core_session_t *session, switch_codec_t *codec){	switch_event_t *event;	switch_channel_t *channel = switch_core_session_get_channel(session);	char tmp[30];	switch_status_t status = SWITCH_STATUS_SUCCESS;	if (!codec || !codec->implementation || !switch_core_codec_ready(codec)) {		if (session->video_write_codec) {			session->video_write_codec = NULL;			status = SWITCH_STATUS_SUCCESS;			goto end;		}		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot set NULL codec!/n");		status = SWITCH_STATUS_FALSE;		goto end;	}	if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {		switch_channel_event_set_data(session->channel, event);		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-video-write-codec-name", codec->implementation->iananame);		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-video-write-codec-rate", "%d", codec->implementation->actual_samples_per_second);		switch_event_fire(&event);	}	switch_channel_set_variable(channel, "video_write_codec", codec->implementation->iananame);	switch_snprintf(tmp, sizeof(tmp), "%d", codec->implementation->actual_samples_per_second);	switch_channel_set_variable(channel, "video_write_rate", tmp);	session->video_write_codec = codec;	session->video_write_impl = *codec->implementation;  end:	return status;}

static void event_handler(switch_event_t *event){	if (process_event(event) != SWITCH_STATUS_SUCCESS) {		const char *peer_uuid = switch_event_get_header(event, "variable_signal_bond");		switch_core_session_t *peer_session = NULL;		switch_channel_t *peer_channel = NULL;		switch_event_t *peer_event = NULL;				if (!peer_uuid) {			return;		}		if (!(peer_session = switch_core_session_locate(peer_uuid))) {			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cant locate peer session for uuid %s/n", peer_uuid);			return;		}		peer_channel = switch_core_session_get_channel(peer_session);				if (switch_event_create(&peer_event, SWITCH_EVENT_CHANNEL_BRIDGE) != SWITCH_STATUS_SUCCESS) {			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cant create bridge event for peer channel %s/n", peer_uuid);			goto end;		}		switch_channel_event_set_data(peer_channel, peer_event);	end:		switch_core_session_rwunlock(peer_session);		if (peer_event) {			process_event(peer_event);			switch_event_destroy(&peer_event);		}	}}

SWITCH_DECLARE(void) CoreSession::setEventData(Event *e){	this_check_void();	sanity_check_noreturn;		if (channel && e->event) {		switch_channel_event_set_data(channel, e->event);	}}

static switch_status_t dialplan_xml_locate(switch_core_session_t *session, switch_caller_profile_t *caller_profile, switch_xml_t *root,										   switch_xml_t *node){	switch_channel_t *channel = switch_core_session_get_channel(session);	switch_status_t status = SWITCH_STATUS_GENERR;	switch_event_t *params = NULL;	switch_event_create(&params, SWITCH_EVENT_REQUEST_PARAMS);	switch_assert(params);	switch_channel_event_set_data(channel, params);	switch_caller_profile_event_set_data(caller_profile, "Hunt", params);	status = switch_xml_locate("dialplan", NULL, NULL, NULL, root, node, params, SWITCH_FALSE);	switch_event_destroy(&params);	return status;}

static void switch_core_media_bug_destroy(switch_media_bug_t *bug){	switch_event_t *event = NULL;	if (bug->raw_read_buffer) {		switch_buffer_destroy(&bug->raw_read_buffer);	}	if (bug->raw_write_buffer) {		switch_buffer_destroy(&bug->raw_write_buffer);	}	if (switch_event_create(&event, SWITCH_EVENT_MEDIA_BUG_STOP) == SWITCH_STATUS_SUCCESS) {		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Media-Bug-Function", "%s", bug->function);		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Media-Bug-Target", "%s", bug->target);		if (bug->session) switch_channel_event_set_data(bug->session->channel, event);		switch_event_fire(&event);	}}

static switch_status_t my_on_reporting(switch_core_session_t *session){	switch_channel_t *channel = switch_core_session_get_channel(session);	switch_status_t status = SWITCH_STATUS_SUCCESS;	const char *log_dir = NULL, *accountcode = NULL, *a_template_str = NULL, *g_template_str = NULL;	char *log_line, *path = NULL;	if (globals.shutdown) {		return SWITCH_STATUS_SUCCESS;	}	if (!((globals.legs & CDR_LEG_A) && (globals.legs & CDR_LEG_B))) {		if ((globals.legs & CDR_LEG_A)) {			if (switch_channel_get_originator_caller_profile(channel)) {				return SWITCH_STATUS_SUCCESS;			}		} else {			if (switch_channel_get_originatee_caller_profile(channel)) {				return SWITCH_STATUS_SUCCESS;			}		}	}	if (!(log_dir = switch_channel_get_variable(channel, "cdr_csv_base"))) {		log_dir = globals.log_dir;	}	if (switch_dir_make_recursive(log_dir, SWITCH_DEFAULT_DIR_PERMS, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error creating %s/n", log_dir);		return SWITCH_STATUS_FALSE;	}	if (globals.debug) {		switch_event_t *event;		if (switch_event_create_plain(&event, SWITCH_EVENT_CHANNEL_DATA) == SWITCH_STATUS_SUCCESS) {			char *buf;			switch_channel_event_set_data(channel, event);			switch_event_serialize(event, &buf, SWITCH_FALSE);			switch_assert(buf);			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "CHANNEL_DATA:/n%s/n", buf);			switch_event_destroy(&event);			free(buf);		}	}	g_template_str = (const char *) switch_core_hash_find(globals.template_hash, globals.default_template);	if ((accountcode = switch_channel_get_variable(channel, "ACCOUNTCODE"))) {		a_template_str = (const char *) switch_core_hash_find(globals.template_hash, accountcode);	}	if (!g_template_str) {		g_template_str =			"/"${accountcode}/",/"${caller_id_number}/",/"${destination_number}/",/"${context}/",/"${caller_id}/",/"${channel_name}/",/"${bridge_channel}/",/"${last_app}/",/"${last_arg}/",/"${start_stamp}/",/"${answer_stamp}/",/"${end_stamp}/",/"${duration}/",/"${billsec}/",/"${hangup_cause}/",/"${amaflags}/",/"${uuid}/",/"${userfield}/";";	}	if (!a_template_str) {		a_template_str = g_template_str;	}	log_line = switch_channel_expand_variables(channel, a_template_str);	if ((accountcode) && (!globals.masterfileonly)) {		path = switch_mprintf("%s%s%s.csv", log_dir, SWITCH_PATH_SEPARATOR, accountcode);		assert(path);		write_cdr(path, log_line);		free(path);	}	if (g_template_str != a_template_str) {		if (log_line != a_template_str) {			switch_safe_free(log_line);		}		log_line = switch_channel_expand_variables(channel, g_template_str);	}	if (!log_line) {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error creating cdr/n");		return SWITCH_STATUS_FALSE;	}	path = switch_mprintf("%s%sMaster.csv", log_dir, SWITCH_PATH_SEPARATOR);	assert(path);	write_cdr(path, log_line);	free(path);	if (log_line != g_template_str) {		free(log_line);	}	return status;}

//.........这里部分代码省略.........	if (flags & SMBF_READ_REPLACE) {		switch_thread_rwlock_wrlock(session->bug_rwlock);		for (bp = session->bugs; bp; bp = bp->next) {			if (switch_test_flag(bp, SMBF_READ_REPLACE)) {				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Only one bug of this type allowed!/n");				switch_thread_rwlock_unlock(session->bug_rwlock);				return SWITCH_STATUS_GENERR;			}		}		switch_thread_rwlock_unlock(session->bug_rwlock);	}#endif	if (!(bug = switch_core_session_alloc(session, sizeof(*bug)))) {		return SWITCH_STATUS_MEMERR;	}	bug->callback = callback;	bug->user_data = user_data;	bug->session = session;	bug->flags = flags;	bug->function = "N/A";	bug->target = "N/A";	switch_core_session_get_read_impl(session, &bug->read_impl);	switch_core_session_get_write_impl(session, &bug->write_impl);	if (function) {		bug->function = switch_core_session_strdup(session, function);	}	if (target) {		bug->target = switch_core_session_strdup(session, target);	}		bug->stop_time = stop_time;	bytes = bug->read_impl.decoded_bytes_per_packet;	if (!bug->flags) {		bug->flags = (SMBF_READ_STREAM | SMBF_WRITE_STREAM);	}	if (switch_test_flag(bug, SMBF_READ_STREAM) || switch_test_flag(bug, SMBF_READ_PING)) {		switch_buffer_create_dynamic(&bug->raw_read_buffer, bytes * SWITCH_BUFFER_BLOCK_FRAMES, bytes * SWITCH_BUFFER_START_FRAMES, MAX_BUG_BUFFER);		switch_mutex_init(&bug->read_mutex, SWITCH_MUTEX_NESTED, session->pool);	}	bytes = bug->write_impl.decoded_bytes_per_packet;	if (switch_test_flag(bug, SMBF_WRITE_STREAM)) {		switch_buffer_create_dynamic(&bug->raw_write_buffer, bytes * SWITCH_BUFFER_BLOCK_FRAMES, bytes * SWITCH_BUFFER_START_FRAMES, MAX_BUG_BUFFER);		switch_mutex_init(&bug->write_mutex, SWITCH_MUTEX_NESTED, session->pool);	}	if ((bug->flags & SMBF_THREAD_LOCK)) {		bug->thread_id = switch_thread_self();	}	if (bug->callback) {		switch_bool_t result = bug->callback(bug, bug->user_data, SWITCH_ABC_TYPE_INIT);		if (result == SWITCH_FALSE) {			switch_core_media_bug_destroy(bug);			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error attaching BUG to %s/n",							  switch_channel_get_name(session->channel));			return SWITCH_STATUS_GENERR;		}	}	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Attaching BUG to %s/n", switch_channel_get_name(session->channel));	bug->ready = 1;	switch_thread_rwlock_wrlock(session->bug_rwlock);	bug->next = session->bugs;	session->bugs = bug;	for(bp = session->bugs; bp; bp = bp->next) {		if (bp->ready && !switch_test_flag(bp, SMBF_TAP_NATIVE_READ) && !switch_test_flag(bp, SMBF_TAP_NATIVE_WRITE)) {			tap_only = 0;		}		}	switch_thread_rwlock_unlock(session->bug_rwlock);	*new_bug = bug;	if (tap_only) {		switch_set_flag(session, SSF_MEDIA_BUG_TAP_ONLY);	} else {		switch_clear_flag(session, SSF_MEDIA_BUG_TAP_ONLY);	}	if (switch_event_create(&event, SWITCH_EVENT_MEDIA_BUG_START) == SWITCH_STATUS_SUCCESS) {		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Media-Bug-Function", "%s", bug->function);		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Media-Bug-Target", "%s", bug->target);		switch_channel_event_set_data(session->channel, event);		switch_event_fire(&event);	}	return SWITCH_STATUS_SUCCESS;}

static switch_status_t my_on_reporting(switch_core_session_t *session){    switch_channel_t *channel = switch_core_session_get_channel(session);    switch_status_t status = SWITCH_STATUS_SUCCESS;    char *values = NULL, *tmp = NULL, *pq_var = NULL;    const char *var = NULL;    cdr_field_t *cdr_field = NULL;    switch_size_t len, offset;    if (globals.shutdown) {        return SWITCH_STATUS_SUCCESS;    }    if (!((globals.legs & CDR_LEG_A) && (globals.legs & CDR_LEG_B))) {        if ((globals.legs & CDR_LEG_A)) {            if (switch_channel_get_originator_caller_profile(channel)) {                return SWITCH_STATUS_SUCCESS;            }        } else {            if (switch_channel_get_originatee_caller_profile(channel)) {                return SWITCH_STATUS_SUCCESS;            }        }    }    if (switch_dir_make_recursive(globals.spool_dir, SWITCH_DEFAULT_DIR_PERMS, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error creating %s/n", globals.spool_dir);        return SWITCH_STATUS_FALSE;    }    if (globals.debug) {        switch_event_t *event;        if (switch_event_create(&event, SWITCH_EVENT_COMMAND) == SWITCH_STATUS_SUCCESS) {            char *buf;            switch_channel_event_set_data(channel, event);            switch_event_serialize(event, &buf, SWITCH_FALSE);            switch_assert(buf);            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "CHANNEL_DATA:/n%s/n", buf);            switch_event_destroy(&event);            switch_safe_free(buf);        }    }    switch_zmalloc(values, 1);    offset = 0;    for (cdr_field = globals.db_schema->fields; cdr_field->var_name; cdr_field++) {        if ((var = switch_channel_get_variable(channel, cdr_field->var_name))) {            /* Allocate sufficient buffer for PQescapeString */            len = strlen(var);            tmp = switch_core_session_alloc(session, len * 2 + 1);            PQescapeString(tmp, var, len);            var = tmp;        }        if (cdr_field->quote) {            if ((cdr_field->not_null == SWITCH_FALSE) && zstr(var)) {                pq_var = switch_mprintf("null,", var);            } else {                pq_var = switch_mprintf("'%s',", var);            }        } else {            pq_var = switch_mprintf("%s,", var);        }        /* Resize values buffer to accomodate next var */        len = strlen(pq_var);        tmp = realloc(values, offset + len);        values = tmp;        memcpy(values + offset, pq_var, len);        switch_safe_free(pq_var);        offset += len;    }    *(values + --offset) = '/0';    insert_cdr(values);    switch_safe_free(values);    return status;}